From 2dbad3fcdeace9656cf919fa29ebd7112badbc22 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Tue, 3 Dec 2019 09:50:43 +0100
Subject: [PATCH 01/11] Init date type splitting

---
 .../lib/buildDatabaseSchema.js                |  9 +++--
 .../lib/mount-models.js                       | 33 ++++++++++++++-----
 .../strapi-connector-bookshelf/package.json   |  2 +-
 packages/strapi-generate-model/lib/before.js  |  4 ++-
 packages/strapi/bin/strapi.js                 |  1 +
 yarn.lock                                     |  7 +++-
 6 files changed, 41 insertions(+), 15 deletions(-)

diff --git a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
index 793a8f2a7f..afdb743de8 100644
--- a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
+++ b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
@@ -412,20 +412,23 @@ const getType = ({ definition, attribute, name, tableExists = false }) => {
       return 'decimal(10,2)';
     // TODO: split time types as they should be different
     case 'date':
+      return 'date';
     case 'time':
-    case 'datetime':
+      return 'time';
+    case 'datetime': {
       if (client === 'pg') {
         return 'timestamp with time zone';
       }
-
       return 'timestamp';
-    case 'timestamp':
+    }
+    case 'timestamp': {
       if (client === 'pg') {
         return 'timestamp with time zone';
       } else if (client === 'sqlite3' && tableExists) {
         return 'timestamp DEFAULT NULL';
       }
       return 'timestamp DEFAULT CURRENT_TIMESTAMP';
+    }
     case 'timestampUpdate':
       switch (client) {
         case 'pg':
diff --git a/packages/strapi-connector-bookshelf/lib/mount-models.js b/packages/strapi-connector-bookshelf/lib/mount-models.js
index f56ebe7fb4..aff2e96ec1 100644
--- a/packages/strapi-connector-bookshelf/lib/mount-models.js
+++ b/packages/strapi-connector-bookshelf/lib/mount-models.js
@@ -611,10 +611,8 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
             : Promise.resolve();
         });
 
-        //eslint-disable-next-line
-        this.on('saving', (instance, attrs, options) => {
+        this.on('saving', instance => {
           instance.attributes = mapper(instance.attributes);
-          attrs = mapper(attrs);
 
           return _.isFunction(target[model.toLowerCase()]['beforeSave'])
             ? target[model.toLowerCase()]['beforeSave']
@@ -664,7 +662,10 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
               }
 
               if (attr.type === 'date' && definition.client === 'sqlite3') {
-                attributes[key] = dateFns.parse(attributes[key]);
+                const cast = dateFns.parseISO(attributes[key]);
+                attributes[key] = dateFns.isValid(cast)
+                  ? dateFns.format(cast, 'yyyy-MM-dd')
+                  : null;
               }
 
               if (
@@ -756,13 +757,27 @@ const castValueFromType = (type, value /* definition */) => {
   switch (type) {
     case 'json':
       return JSON.stringify(value);
-    // TODO: handle real date format 1970-01-01
-    // TODO: handle real time format 12:00:00
-    case 'time':
+    case 'time': {
+      try {
+        dateFns.parse(value, 'HH:mm:ss', new Date());
+      } catch (error) {
+        throw new Error(`Invalid time format, expected a time HH:mm:ss`);
+      }
+
+      return value;
+    }
+    case 'date': {
+      try {
+        dateFns.parse(value, 'yyyy-MM-dd', new Date());
+      } catch (error) {
+        throw new Error(`Invalid date format, expected a date YYYY-MM-DD`);
+      }
+
+      return value;
+    }
     case 'timestamp':
-    case 'date':
     case 'datetime': {
-      const date = dateFns.parse(value);
+      const date = dateFns.parseISO(value);
       if (dateFns.isValid(date)) return date;
 
       date.setTime(value);
diff --git a/packages/strapi-connector-bookshelf/package.json b/packages/strapi-connector-bookshelf/package.json
index 7276174bac..665256b64c 100644
--- a/packages/strapi-connector-bookshelf/package.json
+++ b/packages/strapi-connector-bookshelf/package.json
@@ -17,7 +17,7 @@
   "main": "./lib",
   "dependencies": {
     "bookshelf": "^1.0.1",
-    "date-fns": "^1.30.1",
+    "date-fns": "^2.8.1",
     "inquirer": "^6.3.1",
     "lodash": "^4.17.11",
     "pluralize": "^7.0.0",
diff --git a/packages/strapi-generate-model/lib/before.js b/packages/strapi-generate-model/lib/before.js
index ab7e215ed8..e24d0c1c5c 100644
--- a/packages/strapi-generate-model/lib/before.js
+++ b/packages/strapi-generate-model/lib/before.js
@@ -138,6 +138,7 @@ module.exports = (scope, cb) => {
   // Get default connection
   try {
     scope.connection =
+      scope.args.connection ||
       JSON.parse(
         fs.readFileSync(
           path.resolve(
@@ -148,7 +149,8 @@ module.exports = (scope, cb) => {
             'database.json'
           )
         )
-      ).defaultConnection || '';
+      ).defaultConnection ||
+      '';
   } catch (err) {
     return cb.invalid(err);
   }
diff --git a/packages/strapi/bin/strapi.js b/packages/strapi/bin/strapi.js
index 7db7e17bf9..e106b1180b 100755
--- a/packages/strapi/bin/strapi.js
+++ b/packages/strapi/bin/strapi.js
@@ -144,6 +144,7 @@ program
   .option('-a, --api <api>', 'API name to generate a sub API')
   .option('-p, --plugin <api>', 'plugin name')
   .option('-t, --tpl <template>', 'template name')
+  .option('-c, --connection <connection>', 'The name of the connection to use')
   .description('generate a model for an API')
   .action((id, attributes, cliArguments) => {
     cliArguments.attributes = attributes;
diff --git a/yarn.lock b/yarn.lock
index bd913dbfee..86dfb7fdbe 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5942,11 +5942,16 @@ date-and-time@^0.6.3:
   resolved "https://registry.yarnpkg.com/date-and-time/-/date-and-time-0.6.3.tgz#2daee52df67c28bd93bce862756ac86b68cf4237"
   integrity sha512-lcWy3AXDRJOD7MplwZMmNSRM//kZtJaLz4n6D1P5z9wEmZGBKhJRBIr1Xs9KNQJmdXPblvgffynYji4iylUTcA==
 
-date-fns@^1.27.2, date-fns@^1.30.1:
+date-fns@^1.27.2:
   version "1.30.1"
   resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-1.30.1.tgz#2e71bf0b119153dbb4cc4e88d9ea5acfb50dc05c"
   integrity sha512-hBSVCvSmWC+QypYObzwGOd9wqdDpOt+0wl0KbU+R+uuZBS1jN8VsD1ss3irQDknRj5NvxiTF6oj/nDRnN/UQNw==
 
+date-fns@^2.8.1:
+  version "2.8.1"
+  resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-2.8.1.tgz#2109362ccb6c87c3ca011e9e31f702bc09e4123b"
+  integrity sha512-EL/C8IHvYRwAHYgFRse4MGAPSqlJVlOrhVYZ75iQBKrnv+ZedmYsgwH3t+BCDuZDXpoo07+q9j4qgSSOa7irJg==
+
 date-now@^0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/date-now/-/date-now-0.1.4.tgz#eaf439fd4d4848ad74e5cc7dbef200672b9e345b"

From 95c7a515d7478e333d8170169ac8dd1019dfacd3 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Tue, 3 Dec 2019 11:27:15 +0100
Subject: [PATCH 02/11] Split parser and formatter in specific files

---
 .../lib/formatter.js                          | 65 ++++++++++++++
 .../lib/mount-models.js                       | 88 ++-----------------
 .../strapi-connector-bookshelf/lib/parser.js  | 73 +++++++++++++++
 .../services/utils/configuration/layouts.js   |  1 +
 4 files changed, 145 insertions(+), 82 deletions(-)
 create mode 100644 packages/strapi-connector-bookshelf/lib/formatter.js
 create mode 100644 packages/strapi-connector-bookshelf/lib/parser.js

diff --git a/packages/strapi-connector-bookshelf/lib/formatter.js b/packages/strapi-connector-bookshelf/lib/formatter.js
new file mode 100644
index 0000000000..1575aafc87
--- /dev/null
+++ b/packages/strapi-connector-bookshelf/lib/formatter.js
@@ -0,0 +1,65 @@
+'use strict';
+
+const { isValid, format, formatISO } = require('date-fns');
+const { has } = require('lodash');
+
+const createFormatter = client => ({ type }, value) => {
+  if (value === null) return null;
+
+  const formatter = {
+    ...defaultFormatter,
+    ...formatters[client],
+  };
+
+  if (has(formatter, type)) {
+    return formatter[type](value);
+  }
+
+  return value;
+};
+
+const defaultFormatter = {
+  json: value => JSON.parse(value),
+  boolean: value => {
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    const strVal = value.toString();
+    if (strVal === '1') {
+      return true;
+    } else if (strVal === '0') {
+      return false;
+    } else {
+      return null;
+    }
+  },
+};
+
+const formatters = {
+  sqlite3: {
+    date: value => {
+      const cast = new Date(value);
+      return isValid(cast) ? formatISO(cast, { representation: 'date' }) : null;
+    },
+    time: value => {
+      const cast = new Date(value);
+      return isValid(cast) ? formatISO(cast, { representation: 'time' }) : null;
+    },
+    datetime: value => {
+      const cast = new Date(value);
+      return isValid(cast) ? formatISO(cast) : null;
+    },
+    timestamp: value => {
+      const cast = new Date(value);
+      return isValid(cast) ? format(cast, 'T') : null;
+    },
+    biginteger: value => {
+      return value.toString();
+    },
+  },
+};
+
+module.exports = {
+  createFormatter,
+};
diff --git a/packages/strapi-connector-bookshelf/lib/mount-models.js b/packages/strapi-connector-bookshelf/lib/mount-models.js
index aff2e96ec1..8e85af495b 100644
--- a/packages/strapi-connector-bookshelf/lib/mount-models.js
+++ b/packages/strapi-connector-bookshelf/lib/mount-models.js
@@ -1,7 +1,6 @@
 'use strict';
 const _ = require('lodash');
 const { singular } = require('pluralize');
-const dateFns = require('date-fns');
 
 const utilsModels = require('strapi-utils').models;
 const relations = require('./relations');
@@ -10,6 +9,8 @@ const {
   createComponentJoinTables,
   createComponentModels,
 } = require('./generate-component-relations');
+const { createParser } = require('./parser');
+const { createFormatter } = require('./formatter');
 
 const populateFetch = require('./populate');
 
@@ -457,12 +458,13 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
     // Call this callback function after we are done parsing
     // all attributes for relationships-- see below.
 
+    const parseValue = createParser();
     try {
       // External function to map key that has been updated with `columnName`
       const mapper = (params = {}) => {
         Object.keys(params).map(key => {
           const attr = definition.attributes[key] || {};
-          params[key] = castValueFromType(attr.type, params[key], definition);
+          params[key] = parseValue(attr.type, params[key], definition);
         });
 
         return _.mapKeys(params, (value, key) => {
@@ -636,44 +638,11 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
             },
           ];
 
+          const formatValue = createFormatter(definition.client);
           const formatter = attributes => {
             Object.keys(attributes).forEach(key => {
               const attr = definition.attributes[key] || {};
-
-              if (attributes[key] === null) return;
-
-              if (attr.type === 'json') {
-                attributes[key] = JSON.parse(attributes[key]);
-              }
-
-              if (attr.type === 'boolean') {
-                if (typeof attributes[key] === 'boolean') {
-                  return;
-                }
-
-                const strVal = attributes[key].toString();
-                if (strVal === '1') {
-                  attributes[key] = true;
-                } else if (strVal === '0') {
-                  attributes[key] = false;
-                } else {
-                  attributes[key] = null;
-                }
-              }
-
-              if (attr.type === 'date' && definition.client === 'sqlite3') {
-                const cast = dateFns.parseISO(attributes[key]);
-                attributes[key] = dateFns.isValid(cast)
-                  ? dateFns.format(cast, 'yyyy-MM-dd')
-                  : null;
-              }
-
-              if (
-                attr.type === 'biginteger' &&
-                definition.client === 'sqlite3'
-              ) {
-                attributes[key] = attributes[key].toString();
-              }
+              attributes[key] = formatValue(attr, attributes[key]);
             });
           };
 
@@ -749,48 +718,3 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
 
   return Promise.all(updates);
 };
-
-const castValueFromType = (type, value /* definition */) => {
-  // do not cast null values
-  if (value === null) return null;
-
-  switch (type) {
-    case 'json':
-      return JSON.stringify(value);
-    case 'time': {
-      try {
-        dateFns.parse(value, 'HH:mm:ss', new Date());
-      } catch (error) {
-        throw new Error(`Invalid time format, expected a time HH:mm:ss`);
-      }
-
-      return value;
-    }
-    case 'date': {
-      try {
-        dateFns.parse(value, 'yyyy-MM-dd', new Date());
-      } catch (error) {
-        throw new Error(`Invalid date format, expected a date YYYY-MM-DD`);
-      }
-
-      return value;
-    }
-    case 'timestamp':
-    case 'datetime': {
-      const date = dateFns.parseISO(value);
-      if (dateFns.isValid(date)) return date;
-
-      date.setTime(value);
-
-      if (!dateFns.isValid(date)) {
-        throw new Error(
-          `Invalid ${type} format, expected a timestamp or an ISO date`
-        );
-      }
-
-      return date;
-    }
-    default:
-      return value;
-  }
-};
diff --git a/packages/strapi-connector-bookshelf/lib/parser.js b/packages/strapi-connector-bookshelf/lib/parser.js
new file mode 100644
index 0000000000..558687fbce
--- /dev/null
+++ b/packages/strapi-connector-bookshelf/lib/parser.js
@@ -0,0 +1,73 @@
+'use strict';
+
+const _ = require('lodash');
+const { parse, isValid, parseISO } = require('date-fns');
+
+const createParser = () => (type, value) => {
+  if (value === null) return null;
+
+  switch (type) {
+    case 'json':
+      return JSON.stringify(value);
+    case 'time':
+      return parseTime(value);
+    case 'date':
+      return parseDate(value);
+    case 'timestamp':
+    case 'datetime':
+      return parseDateTimeOrTimestamp(value);
+    default:
+      return value;
+  }
+};
+
+const parseDateOrThrow = format => value => {
+  try {
+    let date = parseISO(value);
+    if (isValid(date)) return date;
+
+    date = parse(value, format, new Date());
+
+    if (isValid(date)) {
+      return date;
+    } else {
+      throw new Error(`Invalid format, expected a ${format}`);
+    }
+  } catch (error) {
+    throw new Error(`Invalid format, expected a ${format}`);
+  }
+};
+
+const parseDateTimeOrTimestamp = value => {
+  const date = parseISO(value);
+  if (isValid(date)) return date;
+
+  date.setTime(value);
+
+  if (!isValid(date)) {
+    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+  }
+
+  return date;
+};
+
+const parseTime = value => {
+  const time = {
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    secondsFraction: 0,
+  };
+
+  const padTime = t => _.padStart(t, 2, '0');
+
+  const hrs = padTime(time.hours);
+  const min = padeTime(time.minutes);
+  const seconds = padeTime(time.seconds);
+
+  return `${time}.${padFraction()}`;
+};
+
+const parseDate = parseDateOrThrow('yyyy-MM-dd');
+
+module.exports = { createParser };
diff --git a/packages/strapi-plugin-content-manager/services/utils/configuration/layouts.js b/packages/strapi-plugin-content-manager/services/utils/configuration/layouts.js
index 005bc80278..438246fcd1 100644
--- a/packages/strapi-plugin-content-manager/services/utils/configuration/layouts.js
+++ b/packages/strapi-plugin-content-manager/services/utils/configuration/layouts.js
@@ -15,6 +15,7 @@ const typeToSize = type => {
     case 'checkbox':
     case 'boolean':
     case 'date':
+    case 'time':
     case 'biginteger':
     case 'decimal':
     case 'float':

From 4c784318d83e6f4cda3f13ae9a5913d48064b32a Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Wed, 4 Dec 2019 12:17:45 +0100
Subject: [PATCH 03/11] Handle time type

---
 .../lib/formatter.js                          |  4 --
 .../strapi-connector-bookshelf/lib/parser.js  | 21 +------
 .../controllers/validation/component.js       |  2 +
 .../controllers/validation/content-type.js    |  2 +
 packages/strapi-utils/lib/buildQuery.js       | 38 ++++---------
 packages/strapi-utils/lib/index.js            |  2 +
 packages/strapi-utils/lib/parse-type.js       | 55 +++++++++++++++++++
 7 files changed, 73 insertions(+), 51 deletions(-)
 create mode 100644 packages/strapi-utils/lib/parse-type.js

diff --git a/packages/strapi-connector-bookshelf/lib/formatter.js b/packages/strapi-connector-bookshelf/lib/formatter.js
index 1575aafc87..bbc57c1851 100644
--- a/packages/strapi-connector-bookshelf/lib/formatter.js
+++ b/packages/strapi-connector-bookshelf/lib/formatter.js
@@ -42,10 +42,6 @@ const formatters = {
       const cast = new Date(value);
       return isValid(cast) ? formatISO(cast, { representation: 'date' }) : null;
     },
-    time: value => {
-      const cast = new Date(value);
-      return isValid(cast) ? formatISO(cast, { representation: 'time' }) : null;
-    },
     datetime: value => {
       const cast = new Date(value);
       return isValid(cast) ? formatISO(cast) : null;
diff --git a/packages/strapi-connector-bookshelf/lib/parser.js b/packages/strapi-connector-bookshelf/lib/parser.js
index 558687fbce..97710c2a24 100644
--- a/packages/strapi-connector-bookshelf/lib/parser.js
+++ b/packages/strapi-connector-bookshelf/lib/parser.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const _ = require('lodash');
+const { parseType } = require('strapi-utils');
 const { parse, isValid, parseISO } = require('date-fns');
 
 const createParser = () => (type, value) => {
@@ -10,7 +10,7 @@ const createParser = () => (type, value) => {
     case 'json':
       return JSON.stringify(value);
     case 'time':
-      return parseTime(value);
+      return parseType({ type: 'time', value });
     case 'date':
       return parseDate(value);
     case 'timestamp':
@@ -51,23 +51,6 @@ const parseDateTimeOrTimestamp = value => {
   return date;
 };
 
-const parseTime = value => {
-  const time = {
-    hours: 0,
-    minutes: 0,
-    seconds: 0,
-    secondsFraction: 0,
-  };
-
-  const padTime = t => _.padStart(t, 2, '0');
-
-  const hrs = padTime(time.hours);
-  const min = padeTime(time.minutes);
-  const seconds = padeTime(time.seconds);
-
-  return `${time}.${padFraction()}`;
-};
-
 const parseDate = parseDateOrThrow('yyyy-MM-dd');
 
 module.exports = { createParser };
diff --git a/packages/strapi-plugin-content-type-builder/controllers/validation/component.js b/packages/strapi-plugin-content-type-builder/controllers/validation/component.js
index e313cf1f22..9f51e31369 100644
--- a/packages/strapi-plugin-content-type-builder/controllers/validation/component.js
+++ b/packages/strapi-plugin-content-type-builder/controllers/validation/component.js
@@ -26,6 +26,8 @@ const VALID_TYPES = [
   'float',
   'decimal',
   'date',
+  'time',
+  'datetime',
   'boolean',
 
   // nested component
diff --git a/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js b/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js
index de33b40197..4aaad55a70 100644
--- a/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js
+++ b/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js
@@ -33,6 +33,8 @@ const VALID_TYPES = [
   'float',
   'decimal',
   'date',
+  'time',
+  'datetime',
   'boolean',
 
   // nested component
diff --git a/packages/strapi-utils/lib/buildQuery.js b/packages/strapi-utils/lib/buildQuery.js
index fe03df1696..5419c281d3 100644
--- a/packages/strapi-utils/lib/buildQuery.js
+++ b/packages/strapi-utils/lib/buildQuery.js
@@ -1,6 +1,7 @@
 //TODO: move to dbal
 
 const _ = require('lodash');
+const parseType = require('./parse-type');
 
 const findModelByAssoc = assoc => {
   const { models } = assoc.plugin ? strapi.plugins[assoc.plugin] : strapi;
@@ -58,33 +59,16 @@ const getAssociationFromFieldKey = ({ model, field }) => {
 };
 
 /**
- * Cast basic values based on attribute type
+ * Cast an input value
  * @param {Object} options - Options
  * @param {string} options.type - type of the atribute
  * @param {*} options.value - value tu cast
+ * @param {string} options.operator - name of operator
  */
-const castValueToType = ({ type, value }) => {
-  switch (type) {
-    case 'boolean': {
-      if (['true', 't', '1', 1, true].includes(value)) {
-        return true;
-      }
-
-      if (['false', 'f', '0', 0].includes(value)) {
-        return false;
-      }
-
-      return Boolean(value);
-    }
-    case 'integer':
-    case 'biginteger':
-    case 'float':
-    case 'decimal': {
-      return _.toNumber(value);
-    }
-    default:
-      return value;
-  }
+const castInput = ({ type, value, operator }) => {
+  return Array.isArray(value)
+    ? value.map(val => castValue({ type, operator, value: val }))
+    : castValue({ type, operator, value: value });
 };
 
 /**
@@ -95,8 +79,8 @@ const castValueToType = ({ type, value }) => {
  * @param {string} options.operator - name of operator
  */
 const castValue = ({ type, value, operator }) => {
-  if (operator === 'null') return castValueToType({ type: 'boolean', value });
-  return castValueToType({ type, value });
+  if (operator === 'null') return parseType({ type: 'boolean', value });
+  return parseType({ type, value });
 };
 /**
  *
@@ -129,9 +113,7 @@ const buildQuery = ({ model, filters = {}, ...rest }) => {
         const { type } = _.get(assocModel, ['attributes', attribute], {});
 
         // cast value or array of values
-        const castedValue = Array.isArray(value)
-          ? value.map(val => castValue({ type, operator, value: val }))
-          : castValue({ type, operator, value: value });
+        const castedValue = castInput({ type, operator, value });
 
         return {
           field: field === 'id' ? model.primaryKey : field,
diff --git a/packages/strapi-utils/lib/index.js b/packages/strapi-utils/lib/index.js
index 8e2c773dc7..c65ba96441 100644
--- a/packages/strapi-utils/lib/index.js
+++ b/packages/strapi-utils/lib/index.js
@@ -8,6 +8,7 @@ const convertRestQueryParams = require('./convertRestQueryParams');
 const buildQuery = require('./buildQuery');
 const parseMultipartData = require('./parse-multipart');
 const sanitizeEntity = require('./sanitize-entity');
+const parseType = require('./parse-type');
 
 module.exports = {
   cli: require('./cli'),
@@ -25,4 +26,5 @@ module.exports = {
   buildQuery,
   parseMultipartData,
   sanitizeEntity,
+  parseType,
 };
diff --git a/packages/strapi-utils/lib/parse-type.js b/packages/strapi-utils/lib/parse-type.js
new file mode 100644
index 0000000000..a98895a4d8
--- /dev/null
+++ b/packages/strapi-utils/lib/parse-type.js
@@ -0,0 +1,55 @@
+'use strict';
+
+const _ = require('lodash');
+
+const timeRegex = new RegExp(
+  '^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$'
+);
+
+const parseTime = value => {
+  const result = value.match(timeRegex);
+
+  if (result === null) {
+    throw new Error('Invalid time format, expected HH:mm:ss.SSS');
+  }
+
+  const [, hours, minutes, seconds, fraction = '.000'] = result;
+  const fractionPart = _.padEnd(fraction.slice(1), 3, '0');
+
+  return `${hours}:${minutes}:${seconds}.${fractionPart}`;
+};
+
+/**
+ * Cast basic values based on attribute type
+ * @param {Object} options - Options
+ * @param {string} options.type - type of the atribute
+ * @param {*} options.value - value tu cast
+ */
+const parseType = ({ type, value }) => {
+  switch (type) {
+    case 'boolean': {
+      if (['true', 't', '1', 1, true].includes(value)) {
+        return true;
+      }
+
+      if (['false', 'f', '0', 0].includes(value)) {
+        return false;
+      }
+
+      return Boolean(value);
+    }
+    case 'integer':
+    case 'biginteger':
+    case 'float':
+    case 'decimal': {
+      return _.toNumber(value);
+    }
+    case 'time': {
+      return parseTime(value);
+    }
+    default:
+      return value;
+  }
+};
+
+module.exports = parseType;

From 06b0cc22c834039e538ddff6dcdcd89de9291be0 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Wed, 4 Dec 2019 15:29:17 +0100
Subject: [PATCH 04/11] parse date types

---
 .../lib/buildDatabaseSchema.js                | 32 +++++++++-----
 .../strapi-connector-bookshelf/lib/parser.js  | 42 +------------------
 .../lib/mount-models.js                       |  4 +-
 packages/strapi-utils/lib/parse-type.js       | 32 ++++++++++++++
 4 files changed, 57 insertions(+), 53 deletions(-)

diff --git a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
index afdb743de8..e156ae735a 100644
--- a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
+++ b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
@@ -283,15 +283,22 @@ module.exports = async ({
   // Add created_at and updated_at field if timestamp option is true
   if (hasTimestamps) {
     definition.attributes[createAtCol] = {
-      type: 'timestamp',
+      type: 'currentTimestamp',
     };
     definition.attributes[updatedAtCol] = {
       type: 'timestampUpdate',
     };
   }
 
-  // Save all attributes (with timestamps)
-  model.allAttributes = _.clone(definition.attributes);
+  // Save all attributes (with timestamps) and right type
+  model.allAttributes = _.assign(_.clone(definition.attributes), {
+    [createAtCol]: {
+      type: 'timestamp',
+    },
+    [updatedAtCol]: {
+      type: 'timestamp',
+    },
+  });
 
   // Equilize tables
   if (connection.options && connection.options.autoMigration !== false) {
@@ -410,29 +417,34 @@ const getType = ({ definition, attribute, name, tableExists = false }) => {
       return client === 'pg' ? 'double precision' : 'double';
     case 'decimal':
       return 'decimal(10,2)';
-    // TODO: split time types as they should be different
     case 'date':
       return 'date';
     case 'time':
       return 'time';
     case 'datetime': {
-      if (client === 'pg') {
-        return 'timestamp with time zone';
-      }
-      return 'timestamp';
+      if (client === 'pg') return 'timestampz';
+      return 'datetime';
     }
     case 'timestamp': {
       if (client === 'pg') {
-        return 'timestamp with time zone';
+        return 'timestampz';
+      }
+
+      return 'timestamp';
+    }
+    case 'currentTimestamp': {
+      if (client === 'pg') {
+        return 'timestamp with time zone DEFAULT CURRENT_TIMESTAMP';
       } else if (client === 'sqlite3' && tableExists) {
         return 'timestamp DEFAULT NULL';
       }
+
       return 'timestamp DEFAULT CURRENT_TIMESTAMP';
     }
     case 'timestampUpdate':
       switch (client) {
         case 'pg':
-          return 'timestamp with time zone';
+          return 'timestamp with time zone DEFAULT CURRENT_TIMESTAMP';
         case 'sqlite3':
           if (tableExists) {
             return 'timestamp DEFAULT NULL';
diff --git a/packages/strapi-connector-bookshelf/lib/parser.js b/packages/strapi-connector-bookshelf/lib/parser.js
index 97710c2a24..6e4419633c 100644
--- a/packages/strapi-connector-bookshelf/lib/parser.js
+++ b/packages/strapi-connector-bookshelf/lib/parser.js
@@ -1,7 +1,6 @@
 'use strict';
 
 const { parseType } = require('strapi-utils');
-const { parse, isValid, parseISO } = require('date-fns');
 
 const createParser = () => (type, value) => {
   if (value === null) return null;
@@ -9,48 +8,9 @@ const createParser = () => (type, value) => {
   switch (type) {
     case 'json':
       return JSON.stringify(value);
-    case 'time':
-      return parseType({ type: 'time', value });
-    case 'date':
-      return parseDate(value);
-    case 'timestamp':
-    case 'datetime':
-      return parseDateTimeOrTimestamp(value);
     default:
-      return value;
+      return parseType({ type, value });
   }
 };
 
-const parseDateOrThrow = format => value => {
-  try {
-    let date = parseISO(value);
-    if (isValid(date)) return date;
-
-    date = parse(value, format, new Date());
-
-    if (isValid(date)) {
-      return date;
-    } else {
-      throw new Error(`Invalid format, expected a ${format}`);
-    }
-  } catch (error) {
-    throw new Error(`Invalid format, expected a ${format}`);
-  }
-};
-
-const parseDateTimeOrTimestamp = value => {
-  const date = parseISO(value);
-  if (isValid(date)) return date;
-
-  date.setTime(value);
-
-  if (!isValid(date)) {
-    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
-  }
-
-  return date;
-};
-
-const parseDate = parseDateOrThrow('yyyy-MM-dd');
-
 module.exports = { createParser };
diff --git a/packages/strapi-connector-mongoose/lib/mount-models.js b/packages/strapi-connector-mongoose/lib/mount-models.js
index c2e33e43d2..7d566ae1c9 100644
--- a/packages/strapi-connector-mongoose/lib/mount-models.js
+++ b/packages/strapi-connector-mongoose/lib/mount-models.js
@@ -203,7 +203,7 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
         type: 'timestamp',
       };
       target[model].allAttributes[updatedAtCol] = {
-        type: 'timestampUpdate',
+        type: 'timestamp',
       };
     } else if (timestampsOption === true) {
       schema.set('timestamps', true);
@@ -214,7 +214,7 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
         type: 'timestamp',
       };
       target[model].allAttributes.updatedAt = {
-        type: 'timestampUpdate',
+        type: 'timestamp',
       };
     }
     schema.set(
diff --git a/packages/strapi-utils/lib/parse-type.js b/packages/strapi-utils/lib/parse-type.js
index a98895a4d8..c6cac4a3ed 100644
--- a/packages/strapi-utils/lib/parse-type.js
+++ b/packages/strapi-utils/lib/parse-type.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const _ = require('lodash');
+const dates = require('date-fns');
 
 const timeRegex = new RegExp(
   '^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$'
@@ -19,6 +20,30 @@ const parseTime = value => {
   return `${hours}:${minutes}:${seconds}.${fractionPart}`;
 };
 
+const parseDate = value => {
+  try {
+    let date = dates.parseISO(value);
+    if (dates.isValid(date)) return dates.format(date, 'yyyy-MM-dd');
+
+    throw new Error(`Invalid format, expected an ISO compatble date`);
+  } catch (error) {
+    throw new Error(`Invalid format, expected an ISO compatble date`);
+  }
+};
+
+const parseDateTimeOrTimestamp = value => {
+  const date = dates.parseISO(value);
+  if (dates.isValid(date)) return date;
+
+  dates.setTime(date, value);
+
+  if (!dates.isValid(date)) {
+    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+  }
+
+  return date;
+};
+
 /**
  * Cast basic values based on attribute type
  * @param {Object} options - Options
@@ -47,6 +72,13 @@ const parseType = ({ type, value }) => {
     case 'time': {
       return parseTime(value);
     }
+    case 'date': {
+      return parseDate(value);
+    }
+    case 'timestamp':
+    case 'datetime': {
+      return parseDateTimeOrTimestamp(value);
+    }
     default:
       return value;
   }

From fe5ff4bc83e47a21763293da831e36465b4cfdd3 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Wed, 4 Dec 2019 16:10:22 +0100
Subject: [PATCH 05/11] Handle and parse datetime & timestamps

---
 .../controllers/validation/component.js       | 27 ++----------------
 .../controllers/validation/constants.js       | 24 ++++++++++++++++
 .../controllers/validation/content-type.js    | 28 ++-----------------
 .../schema-builder/content-type-builder.js    |  4 +++
 packages/strapi-utils/lib/buildQuery.js       |  2 +-
 packages/strapi-utils/lib/parse-type.js       | 14 ++++++----
 packages/strapi-utils/package.json            |  1 +
 7 files changed, 42 insertions(+), 58 deletions(-)

diff --git a/packages/strapi-plugin-content-type-builder/controllers/validation/component.js b/packages/strapi-plugin-content-type-builder/controllers/validation/component.js
index 9f51e31369..fc6fe2970e 100644
--- a/packages/strapi-plugin-content-type-builder/controllers/validation/component.js
+++ b/packages/strapi-plugin-content-type-builder/controllers/validation/component.js
@@ -6,33 +6,10 @@ const yup = require('yup');
 const { isValidName, isValidIcon } = require('./common');
 const formatYupErrors = require('./yup-formatter');
 const createSchema = require('./model-schema');
-const { modelTypes } = require('./constants');
+const { modelTypes, DEFAULT_TYPES } = require('./constants');
 
 const VALID_RELATIONS = ['oneWay', 'manyWay'];
-const VALID_TYPES = [
-  // advanced types
-  'media',
-
-  // scalar types
-  'string',
-  'text',
-  'richtext',
-  'json',
-  'enumeration',
-  'password',
-  'email',
-  'integer',
-  'biginteger',
-  'float',
-  'decimal',
-  'date',
-  'time',
-  'datetime',
-  'boolean',
-
-  // nested component
-  'component',
-];
+const VALID_TYPES = [...DEFAULT_TYPES, 'component'];
 
 const componentSchema = createSchema(VALID_TYPES, VALID_RELATIONS, {
   modelType: modelTypes.COMPONENT,
diff --git a/packages/strapi-plugin-content-type-builder/controllers/validation/constants.js b/packages/strapi-plugin-content-type-builder/controllers/validation/constants.js
index b275752ff7..39aac7e04d 100644
--- a/packages/strapi-plugin-content-type-builder/controllers/validation/constants.js
+++ b/packages/strapi-plugin-content-type-builder/controllers/validation/constants.js
@@ -3,7 +3,31 @@
 const CONTENT_TYPE = 'CONTENT_TYPE';
 const COMPONENT = 'COMPONENT';
 
+const DEFAULT_TYPES = [
+  // advanced types
+  'media',
+
+  // scalar types
+  'string',
+  'text',
+  'richtext',
+  'json',
+  'enumeration',
+  'password',
+  'email',
+  'integer',
+  'biginteger',
+  'float',
+  'decimal',
+  'date',
+  'time',
+  'datetime',
+  'timestamp',
+  'boolean',
+];
+
 module.exports = {
+  DEFAULT_TYPES,
   modelTypes: {
     CONTENT_TYPE,
     COMPONENT,
diff --git a/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js b/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js
index 4aaad55a70..f6046b726a 100644
--- a/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js
+++ b/packages/strapi-plugin-content-type-builder/controllers/validation/content-type.js
@@ -6,7 +6,7 @@ const formatYupErrors = require('./yup-formatter');
 
 const createSchema = require('./model-schema');
 const { nestedComponentSchema } = require('./component');
-const { modelTypes } = require('./constants');
+const { modelTypes, DEFAULT_TYPES } = require('./constants');
 
 const VALID_RELATIONS = [
   'oneWay',
@@ -16,31 +16,7 @@ const VALID_RELATIONS = [
   'manyToOne',
   'manyToMany',
 ];
-const VALID_TYPES = [
-  // advanced types
-  'media',
-
-  // scalar types
-  'string',
-  'text',
-  'richtext',
-  'json',
-  'enumeration',
-  'password',
-  'email',
-  'integer',
-  'biginteger',
-  'float',
-  'decimal',
-  'date',
-  'time',
-  'datetime',
-  'boolean',
-
-  // nested component
-  'component',
-  'dynamiczone',
-];
+const VALID_TYPES = [...DEFAULT_TYPES, 'component', 'dynamiczone'];
 
 const contentTypeSchema = createSchema(VALID_TYPES, VALID_RELATIONS, {
   modelType: modelTypes.CONTENT_TYPE,
diff --git a/packages/strapi-plugin-content-type-builder/services/schema-builder/content-type-builder.js b/packages/strapi-plugin-content-type-builder/services/schema-builder/content-type-builder.js
index af5fa12896..fb5d68cb5d 100644
--- a/packages/strapi-plugin-content-type-builder/services/schema-builder/content-type-builder.js
+++ b/packages/strapi-plugin-content-type-builder/services/schema-builder/content-type-builder.js
@@ -80,6 +80,10 @@ module.exports = function createComponentBuilder() {
         .set('collectionName', infos.collectionName || defaultCollectionName)
         .set(['info', 'name'], infos.name)
         .set(['info', 'description'], infos.description)
+        .set('options', {
+          increments: true,
+          timestamps: true,
+        })
         .set('attributes', this.convertAttributes(infos.attributes));
 
       Object.keys(infos.attributes).forEach(key => {
diff --git a/packages/strapi-utils/lib/buildQuery.js b/packages/strapi-utils/lib/buildQuery.js
index 5419c281d3..5e814b3323 100644
--- a/packages/strapi-utils/lib/buildQuery.js
+++ b/packages/strapi-utils/lib/buildQuery.js
@@ -110,7 +110,7 @@ const buildQuery = ({ model, filters = {}, ...rest }) => {
           field,
         });
 
-        const { type } = _.get(assocModel, ['attributes', attribute], {});
+        const { type } = _.get(assocModel, ['allAttributes', attribute], {});
 
         // cast value or array of values
         const castedValue = castInput({ type, operator, value });
diff --git a/packages/strapi-utils/lib/parse-type.js b/packages/strapi-utils/lib/parse-type.js
index c6cac4a3ed..b351e1379b 100644
--- a/packages/strapi-utils/lib/parse-type.js
+++ b/packages/strapi-utils/lib/parse-type.js
@@ -23,6 +23,7 @@ const parseTime = value => {
 const parseDate = value => {
   try {
     let date = dates.parseISO(value);
+
     if (dates.isValid(date)) return dates.format(date, 'yyyy-MM-dd');
 
     throw new Error(`Invalid format, expected an ISO compatble date`);
@@ -32,16 +33,17 @@ const parseDate = value => {
 };
 
 const parseDateTimeOrTimestamp = value => {
-  const date = dates.parseISO(value);
-  if (dates.isValid(date)) return date;
+  try {
+    const date = dates.parseISO(value);
+    if (dates.isValid(date)) return date;
 
-  dates.setTime(date, value);
+    const milliUnixDate = dates.parse(value, 'T', new Date());
+    if (dates.isValid(milliUnixDate)) return milliUnixDate;
 
-  if (!dates.isValid(date)) {
+    throw new Error(`Invalid format, expected a timestamp or an ISO date`);
+  } catch (error) {
     throw new Error(`Invalid format, expected a timestamp or an ISO date`);
   }
-
-  return date;
 };
 
 /**
diff --git a/packages/strapi-utils/package.json b/packages/strapi-utils/package.json
index 404c5e5294..1ec717a638 100644
--- a/packages/strapi-utils/package.json
+++ b/packages/strapi-utils/package.json
@@ -19,6 +19,7 @@
   },
   "dependencies": {
     "commander": "^2.20.0",
+    "date-fns": "^2.8.1",
     "joi-json": "^2.1.0",
     "knex": "^0.16.5",
     "lodash": "^4.17.11",

From 909266232fd58c86c096be6e992ea221c50fa00e Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Wed, 4 Dec 2019 18:49:47 +0100
Subject: [PATCH 06/11] Add tests on datetime

---
 .../lib/formatter.js                          |   2 +-
 .../test/types/date.test.e2e.js               |   2 +-
 .../test/types/datetime.test.e2e.js           | 145 ++++++++++++++++++
 .../test/types/time.test.e2e.js               | 145 ++++++++++++++++++
 .../test/types/timestamp.test.e2e.js          | 145 ++++++++++++++++++
 .../strapi-utils/lib/__tests__/parse-type.js  |  89 +++++++++++
 packages/strapi-utils/lib/parse-type.js       |  11 +-
 7 files changed, 535 insertions(+), 4 deletions(-)
 create mode 100644 packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js
 create mode 100644 packages/strapi-plugin-content-manager/test/types/time.test.e2e.js
 create mode 100644 packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js
 create mode 100644 packages/strapi-utils/lib/__tests__/parse-type.js

diff --git a/packages/strapi-connector-bookshelf/lib/formatter.js b/packages/strapi-connector-bookshelf/lib/formatter.js
index bbc57c1851..265c82e3e6 100644
--- a/packages/strapi-connector-bookshelf/lib/formatter.js
+++ b/packages/strapi-connector-bookshelf/lib/formatter.js
@@ -44,7 +44,7 @@ const formatters = {
     },
     datetime: value => {
       const cast = new Date(value);
-      return isValid(cast) ? formatISO(cast) : null;
+      return isValid(cast) ? cast.toISOString() : null;
     },
     timestamp: value => {
       const cast = new Date(value);
diff --git a/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js
index c342371206..8d55dee235 100644
--- a/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js
+++ b/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js
@@ -5,7 +5,7 @@ const { createAuthRequest } = require('../../../../test/helpers/request');
 let modelsUtils;
 let rq;
 
-describe('Test type date', () => {
+describe.skip('Test type date', () => {
   beforeAll(async () => {
     const token = await registerAndLogin();
     rq = createAuthRequest(token);
diff --git a/packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js
new file mode 100644
index 0000000000..c4406d36ff
--- /dev/null
+++ b/packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js
@@ -0,0 +1,145 @@
+const { registerAndLogin } = require('../../../../test/helpers/auth');
+const createModelsUtils = require('../../../../test/helpers/models');
+const { createAuthRequest } = require('../../../../test/helpers/request');
+
+let modelsUtils;
+let rq;
+
+describe('Test type date', () => {
+  beforeAll(async () => {
+    const token = await registerAndLogin();
+    rq = createAuthRequest(token);
+
+    modelsUtils = createModelsUtils({ rq });
+
+    await modelsUtils.createModelWithType('withdate', 'datetime');
+  }, 60000);
+
+  afterAll(async () => {
+    await modelsUtils.deleteModel('withdate');
+  }, 60000);
+
+  test('Create entry with valid value JSON', async () => {
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: '2019-08-08T10:10:57.000Z',
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: '2019-08-08T10:10:57.000Z',
+    });
+  });
+
+  test('Create entry with valid value FormData', async () => {
+    const now = new Date(2019, 0, 12);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        formData: {
+          data: JSON.stringify({ field: now }),
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Create entry with timestamp value should be converted to ISO', async () => {
+    const now = new Date(2016, 4, 8);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: now.getTime(),
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Accepts string timestamp', async () => {
+    const now = new Date(2000, 0, 1);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: `${now.getTime()}`,
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Throws on invalid date format', async () => {
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: 'azdazindoaizdnoainzd',
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('Reading entry, returns correct value', async () => {
+    const res = await rq.get(
+      '/content-manager/explorer/application::withdate.withdate'
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(Array.isArray(res.body)).toBe(true);
+    res.body.forEach(entry => {
+      expect(new Date(entry.field).toISOString()).toBe(entry.field);
+    });
+  });
+
+  test('Updating entry sets the right value and format JSON', async () => {
+    const now = new Date(2018, 7, 5);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: now.getTime(),
+        },
+      }
+    );
+
+    const newDate = new Date(2017, 10, 23);
+    const updateRes = await rq.put(
+      `/content-manager/explorer/application::withdate.withdate/${res.body.id}`,
+      {
+        body: {
+          field: newDate,
+        },
+      }
+    );
+
+    expect(updateRes.statusCode).toBe(200);
+    expect(updateRes.body).toMatchObject({
+      id: res.body.id,
+      field: newDate.toISOString(),
+    });
+  });
+});
diff --git a/packages/strapi-plugin-content-manager/test/types/time.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/time.test.e2e.js
new file mode 100644
index 0000000000..8d55dee235
--- /dev/null
+++ b/packages/strapi-plugin-content-manager/test/types/time.test.e2e.js
@@ -0,0 +1,145 @@
+const { registerAndLogin } = require('../../../../test/helpers/auth');
+const createModelsUtils = require('../../../../test/helpers/models');
+const { createAuthRequest } = require('../../../../test/helpers/request');
+
+let modelsUtils;
+let rq;
+
+describe.skip('Test type date', () => {
+  beforeAll(async () => {
+    const token = await registerAndLogin();
+    rq = createAuthRequest(token);
+
+    modelsUtils = createModelsUtils({ rq });
+
+    await modelsUtils.createModelWithType('withdate', 'date');
+  }, 60000);
+
+  afterAll(async () => {
+    await modelsUtils.deleteModel('withdate');
+  }, 60000);
+
+  test('Create entry with valid value JSON', async () => {
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: '2019-08-08T10:10:57.000Z',
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: '2019-08-08T10:10:57.000Z',
+    });
+  });
+
+  test('Create entry with valid value FormData', async () => {
+    const now = new Date(2019, 0, 12);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        formData: {
+          data: JSON.stringify({ field: now }),
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Create entry with timestamp value should be converted to ISO', async () => {
+    const now = new Date(2016, 4, 8);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: now.getTime(),
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Accepts string timestamp', async () => {
+    const now = new Date(2000, 0, 1);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: `${now.getTime()}`,
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Throws on invalid date format', async () => {
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: 'azdazindoaizdnoainzd',
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('Reading entry, returns correct value', async () => {
+    const res = await rq.get(
+      '/content-manager/explorer/application::withdate.withdate'
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(Array.isArray(res.body)).toBe(true);
+    res.body.forEach(entry => {
+      expect(new Date(entry.field).toISOString()).toBe(entry.field);
+    });
+  });
+
+  test('Updating entry sets the right value and format JSON', async () => {
+    const now = new Date(2018, 7, 5);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: now.getTime(),
+        },
+      }
+    );
+
+    const newDate = new Date(2017, 10, 23);
+    const updateRes = await rq.put(
+      `/content-manager/explorer/application::withdate.withdate/${res.body.id}`,
+      {
+        body: {
+          field: newDate,
+        },
+      }
+    );
+
+    expect(updateRes.statusCode).toBe(200);
+    expect(updateRes.body).toMatchObject({
+      id: res.body.id,
+      field: newDate.toISOString(),
+    });
+  });
+});
diff --git a/packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js
new file mode 100644
index 0000000000..7188a2bd92
--- /dev/null
+++ b/packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js
@@ -0,0 +1,145 @@
+const { registerAndLogin } = require('../../../../test/helpers/auth');
+const createModelsUtils = require('../../../../test/helpers/models');
+const { createAuthRequest } = require('../../../../test/helpers/request');
+
+let modelsUtils;
+let rq;
+
+describe.skip('Test type date', () => {
+  beforeAll(async () => {
+    const token = await registerAndLogin();
+    rq = createAuthRequest(token);
+
+    modelsUtils = createModelsUtils({ rq });
+
+    await modelsUtils.createModelWithType('withdate', 'datetime');
+  }, 60000);
+
+  afterAll(async () => {
+    await modelsUtils.deleteModel('withdate');
+  }, 60000);
+
+  test('Create entry with valid value JSON', async () => {
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: '2019-08-08T10:10:57.000Z',
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: '2019-08-08T10:10:57.000Z',
+    });
+  });
+
+  test('Create entry with valid value FormData', async () => {
+    const now = new Date(2019, 0, 12);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        formData: {
+          data: JSON.stringify({ field: now }),
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Create entry with timestamp value should be converted to ISO', async () => {
+    const now = new Date(2016, 4, 8);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: now.getTime(),
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Accepts string timestamp', async () => {
+    const now = new Date(2000, 0, 1);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: `${now.getTime()}`,
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toMatchObject({
+      field: now.toISOString(),
+    });
+  });
+
+  test('Throws on invalid date format', async () => {
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: 'azdazindoaizdnoainzd',
+        },
+      }
+    );
+
+    expect(res.statusCode).toBe(400);
+  });
+
+  test('Reading entry, returns correct value', async () => {
+    const res = await rq.get(
+      '/content-manager/explorer/application::withdate.withdate'
+    );
+
+    expect(res.statusCode).toBe(200);
+    expect(Array.isArray(res.body)).toBe(true);
+    res.body.forEach(entry => {
+      expect(new Date(entry.field).toISOString()).toBe(entry.field);
+    });
+  });
+
+  test('Updating entry sets the right value and format JSON', async () => {
+    const now = new Date(2018, 7, 5);
+
+    const res = await rq.post(
+      '/content-manager/explorer/application::withdate.withdate',
+      {
+        body: {
+          field: now.getTime(),
+        },
+      }
+    );
+
+    const newDate = new Date(2017, 10, 23);
+    const updateRes = await rq.put(
+      `/content-manager/explorer/application::withdate.withdate/${res.body.id}`,
+      {
+        body: {
+          field: newDate,
+        },
+      }
+    );
+
+    expect(updateRes.statusCode).toBe(200);
+    expect(updateRes.body).toMatchObject({
+      id: res.body.id,
+      field: newDate.toISOString(),
+    });
+  });
+});
diff --git a/packages/strapi-utils/lib/__tests__/parse-type.js b/packages/strapi-utils/lib/__tests__/parse-type.js
new file mode 100644
index 0000000000..4ca7934db1
--- /dev/null
+++ b/packages/strapi-utils/lib/__tests__/parse-type.js
@@ -0,0 +1,89 @@
+const parseType = require('../parse-type');
+
+describe('parseType', () => {
+  describe('boolean', () => {
+    it('Handles string booleans', () => {
+      expect(parseType({ type: 'boolean', value: 'true' })).toBe(true);
+      expect(parseType({ type: 'boolean', value: 't' })).toBe(true);
+      expect(parseType({ type: 'boolean', value: '1' })).toBe(true);
+
+      expect(parseType({ type: 'boolean', value: 'false' })).toBe(false);
+      expect(parseType({ type: 'boolean', value: 'f' })).toBe(false);
+      expect(parseType({ type: 'boolean', value: '0' })).toBe(false);
+
+      expect(() => parseType({ type: 'boolean', value: 'test' })).toThrow();
+    });
+
+    it('Handles numerical booleans', () => {
+      expect(parseType({ type: 'boolean', value: 1 })).toBe(true);
+
+      expect(parseType({ type: 'boolean', value: 0 })).toBe(false);
+
+      expect(() => parseType({ type: 'boolean', value: 12 })).toThrow();
+    });
+  });
+
+  describe('Time', () => {
+    it('Always returns the same time format', () => {
+      expect(parseType({ type: 'time', value: '12:31:11' })).toBe(
+        '12:31:11.000'
+      );
+      expect(parseType({ type: 'time', value: '12:31:11.2' })).toBe(
+        '12:31:11.200'
+      );
+      expect(parseType({ type: 'time', value: '12:31:11.31' })).toBe(
+        '12:31:11.310'
+      );
+      expect(parseType({ type: 'time', value: '12:31:11.319' })).toBe(
+        '12:31:11.319'
+      );
+    });
+
+    it('Throws on  invalid time format', () => {
+      expect(() => parseType({ type: 'time', value: '25:12:09' })).toThrow();
+      expect(() => parseType({ type: 'time', value: '23:78:09' })).toThrow();
+      expect(() => parseType({ type: 'time', value: '23:11:99' })).toThrow();
+
+      expect(() => parseType({ type: 'time', value: '12:12' })).toThrow();
+      expect(() => parseType({ type: 'time', value: 'test' })).toThrow();
+      expect(() => parseType({ type: 'time', value: 122 })).toThrow();
+      expect(() => parseType({ type: 'time', value: {} })).toThrow();
+      expect(() => parseType({ type: 'time', value: [] })).toThrow();
+    });
+  });
+
+  describe('Date', () => {
+    it('Supports ISO formats and always returns the right format', () => {
+      expect(parseType({ type: 'date', value: '2019-01-01 12:01:11' })).toBe(
+        '2019-01-01'
+      );
+
+      expect(parseType({ type: 'date', value: '2018-11-02' })).toBe(
+        '2018-11-02'
+      );
+
+      expect(
+        parseType({ type: 'date', value: '2019-04-21T00:00:00.000Z' })
+      ).toBe('2019-04-21');
+    });
+
+    it('Throws on invalid formator dates', () => {
+      expect(() => parseType({ type: 'date', value: '-1029-11-02' })).toThrow();
+      expect(() => parseType({ type: 'date', value: '2019-13-02' })).toThrow();
+      expect(() => parseType({ type: 'date', value: '2019-12-32' })).toThrow();
+      expect(() => parseType({ type: 'date', value: '2019-02-31' })).toThrow();
+    });
+  });
+
+  describe('Datetime', () => {
+    it.each([
+      '2019-01-01',
+      '2019-01-01 10:11:12',
+      '1234567890111',
+      '2019-01-01T10:11:12.123Z',
+    ])('Supports ISO formats and always returns a date %s', value => {
+      const r = parseType({ type: 'datetime', value });
+      expect(r instanceof Date).toBe(true);
+    });
+  });
+});
diff --git a/packages/strapi-utils/lib/parse-type.js b/packages/strapi-utils/lib/parse-type.js
index b351e1379b..2bb46d02a6 100644
--- a/packages/strapi-utils/lib/parse-type.js
+++ b/packages/strapi-utils/lib/parse-type.js
@@ -8,6 +8,9 @@ const timeRegex = new RegExp(
 );
 
 const parseTime = value => {
+  if (typeof value !== 'string') {
+    throw new Error(`Expected a string, got a ${typeof value}`);
+  }
   const result = value.match(timeRegex);
 
   if (result === null) {
@@ -55,7 +58,9 @@ const parseDateTimeOrTimestamp = value => {
 const parseType = ({ type, value }) => {
   switch (type) {
     case 'boolean': {
-      if (['true', 't', '1', 1, true].includes(value)) {
+      if (typeof value === 'boolean') return value;
+
+      if (['true', 't', '1', 1].includes(value)) {
         return true;
       }
 
@@ -63,7 +68,9 @@ const parseType = ({ type, value }) => {
         return false;
       }
 
-      return Boolean(value);
+      throw new Error(
+        'Invalid boolean input. Expected "t","1","true","false","0","f"'
+      );
     }
     case 'integer':
     case 'biginteger':

From dd072c40c3efeb3114e80b873c1643dc738530c7 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Thu, 5 Dec 2019 11:37:07 +0100
Subject: [PATCH 07/11] Refactor column creation to use plain knex schema
 builder

---
 .../lib/buildDatabaseSchema.js                | 239 +++++++++---------
 .../lib/formatter.js                          |  45 +++-
 .../lib/mount-models.js                       |  89 +++----
 .../__tests__/attributes.test.js              |   2 +-
 4 files changed, 192 insertions(+), 183 deletions(-)

diff --git a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
index e156ae735a..e368207359 100644
--- a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
+++ b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
@@ -9,6 +9,94 @@ module.exports = async ({
   connection,
   model,
 }) => {
+  const createIdType = (table, definition) => {
+    if (definition.primaryKeyType === 'uuid' && definition.client === 'pg') {
+      return table
+        .specificType('id', 'uuid DEFAULT uuid_generate_v4()')
+        .notNullable()
+        .primary();
+    }
+
+    if (definition.primaryKeyType !== 'integer') {
+      const col = buildColType({
+        name: 'id',
+        table,
+        definition,
+        attribute: {
+          type: definition.primaryKeyType,
+        },
+      });
+
+      if (!col) throw new Error('Invalid primaryKeyType');
+
+      return col.notNullable().primary();
+    }
+
+    return table.increments('id');
+  };
+
+  const buildColType = ({ name, attribute, table }) => {
+    if (!attribute.type) {
+      const relation = definition.associations.find(association => {
+        return association.alias === name;
+      });
+
+      if (['oneToOne', 'manyToOne', 'oneWay'].includes(relation.nature)) {
+        return buildColType({
+          name,
+          attribute: { type: definition.primaryKeyType },
+          table,
+        });
+      }
+
+      return null;
+    }
+
+    // allo custom data type for a column
+    if (_.has(attribute, 'columnType')) {
+      return table.specificType(name, attribute.columnType);
+    }
+
+    switch (attribute.type) {
+      case 'uuid':
+        return table.uuid(name);
+      case 'richtext':
+      case 'text':
+        return table.text(name, 'longtext');
+      case 'json':
+        // return client === 'pg' ? 'jsonb' : 'longtext';
+        return table.jsonb(name);
+      case 'enumeration':
+        return table.enu(name, attribute.enum || []);
+      case 'string':
+      case 'password':
+      case 'email':
+        return table.string(name);
+      case 'integer':
+        return table.integer(name);
+      case 'biginteger':
+        return table.bigInteger(name);
+      case 'float':
+        return table.double(name);
+      case 'decimal':
+        return table.decimal(name, 10, 2);
+      case 'date':
+        return table.date(name);
+      case 'time':
+        return table.time(name);
+      case 'datetime':
+        return table.datetime(name);
+      case 'timestamp':
+        return table.timestamp(name);
+      case 'currentTimestamp':
+        return table.timestamp(name).defaultTo(ORM.knex.fn.now());
+      case 'boolean':
+        return table.boolean(name);
+      default:
+        return null;
+    }
+  };
+
   const { hasTimestamps } = loadedModel;
 
   let [createAtCol, updatedAtCol] = ['created_at', 'updated_at'];
@@ -83,33 +171,26 @@ module.exports = async ({
 
       Object.keys(columns).forEach(key => {
         const attribute = columns[key];
-        const type = getType({
-          definition,
-          attribute,
-          name: key,
-          tableExists,
-        });
 
-        if (type) {
-          const col = tbl.specificType(key, type);
+        const col = buildColType({ name: key, attribute, table: tbl });
+        if (!col) return;
 
-          if (attribute.required === true) {
-            if (definition.client !== 'sqlite3' || !tableExists) {
-              col.notNullable();
-            }
-          } else {
-            col.nullable();
+        if (attribute.required === true) {
+          if (definition.client !== 'sqlite3' || !tableExists) {
+            col.notNullable();
           }
+        } else {
+          col.nullable();
+        }
 
-          if (attribute.unique === true) {
-            if (definition.client !== 'sqlite3' || !tableExists) {
-              tbl.unique(key, uniqueColName(table, key));
-            }
+        if (attribute.unique === true) {
+          if (definition.client !== 'sqlite3' || !tableExists) {
+            tbl.unique(key, uniqueColName(table, key));
           }
+        }
 
-          if (alter) {
-            col.alter();
-          }
+        if (alter) {
+          col.alter();
         }
       });
     };
@@ -124,7 +205,7 @@ module.exports = async ({
 
     const createTable = (table, { trx = ORM.knex, ...opts } = {}) => {
       return trx.schema.createTable(table, tbl => {
-        tbl.specificType('id', getIdType(definition));
+        createIdType(tbl, definition);
         createColumns(tbl, attributes, { ...opts, tableExists: false });
       });
     };
@@ -201,7 +282,7 @@ module.exports = async ({
         await createTable(table, { trx });
 
         const attrs = Object.keys(attributes).filter(attribute =>
-          getType({
+          isColumn({
             definition,
             attribute: attributes[attribute],
             name: attribute,
@@ -286,7 +367,7 @@ module.exports = async ({
       type: 'currentTimestamp',
     };
     definition.attributes[updatedAtCol] = {
-      type: 'timestampUpdate',
+      type: 'currentTimestamp',
     };
   }
 
@@ -376,87 +457,26 @@ module.exports = async ({
   }
 };
 
-const getType = ({ definition, attribute, name, tableExists = false }) => {
-  const { client } = definition;
-
-  if (!attribute.type) {
-    // Add integer value if there is a relation
+const isColumn = ({ definition, attribute, name }) => {
+  if (!_.has(attribute, 'type')) {
     const relation = definition.associations.find(association => {
       return association.alias === name;
     });
 
-    switch (relation.nature) {
-      case 'oneToOne':
-      case 'manyToOne':
-      case 'oneWay':
-        return definition.primaryKeyType;
-      default:
-        return null;
+    if (!relation) return false;
+
+    if (['oneToOne', 'manyToOne', 'oneWay'].includes(relation.nature)) {
+      return true;
     }
+
+    return false;
   }
 
-  switch (attribute.type) {
-    case 'uuid':
-      return client === 'pg' ? 'uuid' : 'varchar(36)';
-    case 'richtext':
-    case 'text':
-      return client === 'pg' ? 'text' : 'longtext';
-    case 'json':
-      return client === 'pg' ? 'jsonb' : 'longtext';
-    case 'string':
-    case 'enumeration':
-    case 'password':
-    case 'email':
-      return 'varchar(255)';
-    case 'integer':
-      return client === 'pg' ? 'integer' : 'int';
-    case 'biginteger':
-      if (client === 'sqlite3') return 'bigint(53)'; // no choice until the sqlite3 package supports returning strings for big integers
-      return 'bigint';
-    case 'float':
-      return client === 'pg' ? 'double precision' : 'double';
-    case 'decimal':
-      return 'decimal(10,2)';
-    case 'date':
-      return 'date';
-    case 'time':
-      return 'time';
-    case 'datetime': {
-      if (client === 'pg') return 'timestampz';
-      return 'datetime';
-    }
-    case 'timestamp': {
-      if (client === 'pg') {
-        return 'timestampz';
-      }
-
-      return 'timestamp';
-    }
-    case 'currentTimestamp': {
-      if (client === 'pg') {
-        return 'timestamp with time zone DEFAULT CURRENT_TIMESTAMP';
-      } else if (client === 'sqlite3' && tableExists) {
-        return 'timestamp DEFAULT NULL';
-      }
-
-      return 'timestamp DEFAULT CURRENT_TIMESTAMP';
-    }
-    case 'timestampUpdate':
-      switch (client) {
-        case 'pg':
-          return 'timestamp with time zone DEFAULT CURRENT_TIMESTAMP';
-        case 'sqlite3':
-          if (tableExists) {
-            return 'timestamp DEFAULT NULL';
-          }
-          return 'timestamp DEFAULT CURRENT_TIMESTAMP';
-        default:
-          return 'timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP';
-      }
-    case 'boolean':
-      return 'boolean';
-    default:
+  if (['component', 'dynamiczone'].includes(attribute.type)) {
+    return false;
   }
+
+  return true;
 };
 
 const storeTable = async (table, attributes) => {
@@ -479,29 +499,4 @@ const storeTable = async (table, attributes) => {
   }).save();
 };
 
-const defaultIdType = {
-  mysql: 'INT AUTO_INCREMENT NOT NULL PRIMARY KEY',
-  pg: 'SERIAL NOT NULL PRIMARY KEY',
-  sqlite3: 'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL',
-};
-
-const getIdType = definition => {
-  if (definition.primaryKeyType === 'uuid' && definition.client === 'pg') {
-    return 'uuid NOT NULL DEFAULT uuid_generate_v4() NOT NULL PRIMARY KEY';
-  }
-
-  if (definition.primaryKeyType !== 'integer') {
-    const type = getType({
-      definition,
-      attribute: {
-        type: definition.primaryKeyType,
-      },
-    });
-
-    return `${type} NOT NULL PRIMARY KEY`;
-  }
-
-  return defaultIdType[definition.client];
-};
-
 const uniqueColName = (table, key) => `${table}_${key}_unique`;
diff --git a/packages/strapi-connector-bookshelf/lib/formatter.js b/packages/strapi-connector-bookshelf/lib/formatter.js
index 265c82e3e6..0a8cbdfa44 100644
--- a/packages/strapi-connector-bookshelf/lib/formatter.js
+++ b/packages/strapi-connector-bookshelf/lib/formatter.js
@@ -19,7 +19,10 @@ const createFormatter = client => ({ type }, value) => {
 };
 
 const defaultFormatter = {
-  json: value => JSON.parse(value),
+  json: value => {
+    if (typeof value === 'object') return value;
+    return JSON.parse(value);
+  },
   boolean: value => {
     if (typeof value === 'boolean') {
       return value;
@@ -34,26 +37,42 @@ const defaultFormatter = {
       return null;
     }
   },
+  date: value => {
+    const cast = new Date(value);
+    return isValid(cast) ? formatISO(cast, { representation: 'date' }) : null;
+  },
+  datetime: value => {
+    const cast = new Date(value);
+    return isValid(cast) ? cast.toISOString() : null;
+  },
+  timestamp: value => {
+    const cast = new Date(value);
+    return isValid(cast) ? format(cast, 'T') : null;
+  },
 };
 
 const formatters = {
   sqlite3: {
-    date: value => {
-      const cast = new Date(value);
-      return isValid(cast) ? formatISO(cast, { representation: 'date' }) : null;
-    },
-    datetime: value => {
-      const cast = new Date(value);
-      return isValid(cast) ? cast.toISOString() : null;
-    },
-    timestamp: value => {
-      const cast = new Date(value);
-      return isValid(cast) ? format(cast, 'T') : null;
-    },
     biginteger: value => {
       return value.toString();
     },
   },
+  mysql: {
+    boolean: value => {
+      if (typeof value === 'boolean') {
+        return value;
+      }
+
+      const strVal = value.toString();
+      if (strVal === '1') {
+        return true;
+      } else if (strVal === '0') {
+        return false;
+      } else {
+        return null;
+      }
+    },
+  },
 };
 
 module.exports = {
diff --git a/packages/strapi-connector-bookshelf/lib/mount-models.js b/packages/strapi-connector-bookshelf/lib/mount-models.js
index 8e85af495b..e78251f92c 100644
--- a/packages/strapi-connector-bookshelf/lib/mount-models.js
+++ b/packages/strapi-connector-bookshelf/lib/mount-models.js
@@ -464,7 +464,8 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
       const mapper = (params = {}) => {
         Object.keys(params).map(key => {
           const attr = definition.attributes[key] || {};
-          params[key] = parseValue(attr.type, params[key], definition);
+
+          params[key] = parseValue(attr.type, params[key]);
         });
 
         return _.mapKeys(params, (value, key) => {
@@ -613,60 +614,54 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
             : Promise.resolve();
         });
 
-        this.on('saving', instance => {
-          instance.attributes = mapper(instance.attributes);
+        this.on('saving', (instance, attrs) => {
+          instance.attributes = mapper(attrs);
 
           return _.isFunction(target[model.toLowerCase()]['beforeSave'])
             ? target[model.toLowerCase()]['beforeSave']
             : Promise.resolve();
         });
 
-        // Convert to JSON format stringify json for mysql database
-        if (definition.client === 'mysql' || definition.client === 'sqlite3') {
-          const events = [
-            {
-              name: 'saved',
-              target: 'afterSave',
-            },
-            {
-              name: 'fetched',
-              target: 'afterFetch',
-            },
-            {
-              name: 'fetched:collection',
-              target: 'afterFetchAll',
-            },
-          ];
-
-          const formatValue = createFormatter(definition.client);
-          const formatter = attributes => {
-            Object.keys(attributes).forEach(key => {
-              const attr = definition.attributes[key] || {};
-              attributes[key] = formatValue(attr, attributes[key]);
-            });
-          };
-
-          events.forEach(event => {
-            let fn;
-
-            if (event.name.indexOf('collection') !== -1) {
-              fn = instance =>
-                instance.models.map(entry => {
-                  formatter(entry.attributes);
-                });
-            } else {
-              fn = instance => formatter(instance.attributes);
-            }
-
-            this.on(event.name, instance => {
-              fn(instance);
-
-              return _.isFunction(target[model.toLowerCase()][event.target])
-                ? target[model.toLowerCase()][event.target]
-                : Promise.resolve();
-            });
+        const formatValue = createFormatter(definition.client);
+        function formatEntry(entry) {
+          Object.keys(entry.attributes).forEach(key => {
+            const attr = definition.attributes[key] || {};
+            entry.attributes[key] = formatValue(attr, entry.attributes[key]);
           });
         }
+
+        function formatOutput(instance) {
+          if (Array.isArray(instance.models)) {
+            instance.models.map(formatEntry);
+          } else {
+            formatEntry(instance);
+          }
+        }
+
+        const events = [
+          {
+            name: 'saved',
+            target: 'afterSave',
+          },
+          {
+            name: 'fetched',
+            target: 'afterFetch',
+          },
+          {
+            name: 'fetched:collection',
+            target: 'afterFetchAll',
+          },
+        ];
+
+        events.forEach(event => {
+          this.on(event.name, instance => {
+            formatOutput(instance);
+
+            return _.isFunction(target[model.toLowerCase()][event.target])
+              ? target[model.toLowerCase()][event.target]
+              : Promise.resolve();
+          });
+        });
       };
 
       loadedModel.hidden = _.keys(
diff --git a/packages/strapi-plugin-content-manager/services/utils/configuration/__tests__/attributes.test.js b/packages/strapi-plugin-content-manager/services/utils/configuration/__tests__/attributes.test.js
index aec2118a79..2d1b95b528 100644
--- a/packages/strapi-plugin-content-manager/services/utils/configuration/__tests__/attributes.test.js
+++ b/packages/strapi-plugin-content-manager/services/utils/configuration/__tests__/attributes.test.js
@@ -16,7 +16,7 @@ const createMockSchema = (attrs, timestamps = true) => {
               type: 'timestamp',
             },
             updatedAt: {
-              type: 'timestampUpdate',
+              type: 'timestamp',
             },
           }
         : {}),

From f55e1f704b77e6d4bdb453c0da2b240b5814db37 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Thu, 5 Dec 2019 12:29:24 +0100
Subject: [PATCH 08/11] Do not parse date types

---
 .../lib/buildDatabaseSchema.js                   |  5 +++--
 .../strapi-connector-bookshelf/lib/formatter.js  | 16 ----------------
 .../lib/generate-component-relations.js          |  5 ++++-
 .../lib/mount-models.js                          |  4 ++--
 packages/strapi-utils/lib/parse-type.js          |  4 ++++
 5 files changed, 13 insertions(+), 21 deletions(-)

diff --git a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
index e368207359..a6f3c097bd 100644
--- a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
+++ b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
@@ -64,8 +64,9 @@ module.exports = async ({
       case 'text':
         return table.text(name, 'longtext');
       case 'json':
-        // return client === 'pg' ? 'jsonb' : 'longtext';
-        return table.jsonb(name);
+        return definition.client === 'pg'
+          ? table.jsonb(name)
+          : table.text(name, 'longtext');
       case 'enumeration':
         return table.enu(name, attribute.enum || []);
       case 'string':
diff --git a/packages/strapi-connector-bookshelf/lib/formatter.js b/packages/strapi-connector-bookshelf/lib/formatter.js
index 0a8cbdfa44..24c4c01619 100644
--- a/packages/strapi-connector-bookshelf/lib/formatter.js
+++ b/packages/strapi-connector-bookshelf/lib/formatter.js
@@ -57,22 +57,6 @@ const formatters = {
       return value.toString();
     },
   },
-  mysql: {
-    boolean: value => {
-      if (typeof value === 'boolean') {
-        return value;
-      }
-
-      const strVal = value.toString();
-      if (strVal === '1') {
-        return true;
-      } else if (strVal === '0') {
-        return false;
-      } else {
-        return null;
-      }
-    },
-  },
 };
 
 module.exports = {
diff --git a/packages/strapi-connector-bookshelf/lib/generate-component-relations.js b/packages/strapi-connector-bookshelf/lib/generate-component-relations.js
index 78272d3cc4..09119ca10a 100644
--- a/packages/strapi-connector-bookshelf/lib/generate-component-relations.js
+++ b/packages/strapi-connector-bookshelf/lib/generate-component-relations.js
@@ -78,7 +78,10 @@ const createComponentJoinTables = async ({ definition, ORM }) => {
         .notNullable();
       table.string('component_type').notNullable();
       table.integer('component_id').notNullable();
-      table.integer(joinColumn).notNullable();
+      table
+        .integer(joinColumn)
+        .unsigned()
+        .notNullable();
 
       table
         .foreign(joinColumn)
diff --git a/packages/strapi-connector-bookshelf/lib/mount-models.js b/packages/strapi-connector-bookshelf/lib/mount-models.js
index e78251f92c..4e0135543a 100644
--- a/packages/strapi-connector-bookshelf/lib/mount-models.js
+++ b/packages/strapi-connector-bookshelf/lib/mount-models.js
@@ -615,7 +615,7 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
         });
 
         this.on('saving', (instance, attrs) => {
-          instance.attributes = mapper(attrs);
+          instance.attributes = _.assign(instance.attributes, mapper(attrs));
 
           return _.isFunction(target[model.toLowerCase()]['beforeSave'])
             ? target[model.toLowerCase()]['beforeSave']
@@ -632,7 +632,7 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
 
         function formatOutput(instance) {
           if (Array.isArray(instance.models)) {
-            instance.models.map(formatEntry);
+            instance.models.forEach(entry => formatEntry(entry));
           } else {
             formatEntry(instance);
           }
diff --git a/packages/strapi-utils/lib/parse-type.js b/packages/strapi-utils/lib/parse-type.js
index 2bb46d02a6..aa34445e76 100644
--- a/packages/strapi-utils/lib/parse-type.js
+++ b/packages/strapi-utils/lib/parse-type.js
@@ -8,6 +8,8 @@ const timeRegex = new RegExp(
 );
 
 const parseTime = value => {
+  if (dates.isDate(value)) return dates.format(value, 'HH:mm:ss.SSS');
+
   if (typeof value !== 'string') {
     throw new Error(`Expected a string, got a ${typeof value}`);
   }
@@ -24,6 +26,7 @@ const parseTime = value => {
 };
 
 const parseDate = value => {
+  if (dates.isDate(value)) return dates.format(value, 'yyyy-MM-dd');
   try {
     let date = dates.parseISO(value);
 
@@ -36,6 +39,7 @@ const parseDate = value => {
 };
 
 const parseDateTimeOrTimestamp = value => {
+  if (dates.isDate(value)) return value;
   try {
     const date = dates.parseISO(value);
     if (dates.isValid(date)) return date;

From c66fe82c411bd47761399b71fbaa11b428ce769b Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Thu, 5 Dec 2019 15:26:01 +0100
Subject: [PATCH 09/11] Handle time and date in mongo

---
 .../lib/mount-models.js                       |   2 +-
 .../lib/utils/index.js                        |  42 +++--
 .../test/types/date.test.e2e.js               | 101 ++++++------
 .../test/types/time.test.e2e.js               | 128 ++++++----------
 .../test/types/timestamp.test.e2e.js          | 145 ------------------
 .../services/Aggregator.js                    |   2 +-
 6 files changed, 126 insertions(+), 294 deletions(-)
 delete mode 100644 packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js

diff --git a/packages/strapi-connector-mongoose/lib/mount-models.js b/packages/strapi-connector-mongoose/lib/mount-models.js
index 7d566ae1c9..62c5b9ea3c 100644
--- a/packages/strapi-connector-mongoose/lib/mount-models.js
+++ b/packages/strapi-connector-mongoose/lib/mount-models.js
@@ -71,7 +71,7 @@ module.exports = ({ models, target, plugin = false }, ctx) => {
 
       definition.loadedModel[name] = {
         ...attr,
-        type: utils(instance).convertType(attr.type),
+        ...utils(instance).convertType(attr.type),
       };
     });
 
diff --git a/packages/strapi-connector-mongoose/lib/utils/index.js b/packages/strapi-connector-mongoose/lib/utils/index.js
index daf0fdbeae..1a7fb9d71f 100644
--- a/packages/strapi-connector-mongoose/lib/utils/index.js
+++ b/packages/strapi-connector-mongoose/lib/utils/index.js
@@ -2,6 +2,7 @@
 
 const _ = require('lodash');
 const Mongoose = require('mongoose');
+const { parseType } = require('strapi-utils');
 
 /**
  * Module dependencies
@@ -29,35 +30,50 @@ module.exports = (mongoose = Mongoose) => {
   const convertType = mongooseType => {
     switch (mongooseType.toLowerCase()) {
       case 'array':
-        return Array;
+        return { type: Array };
       case 'boolean':
-        return 'Boolean';
+        return { type: 'Boolean' };
       case 'binary':
-        return 'Buffer';
-      case 'date':
-      case 'datetime':
+        return { type: 'Buffer' };
       case 'time':
+        return {
+          type: String,
+          validate: value => parseType({ type: 'time', value }),
+          set: value => parseType({ type: 'time', value }),
+        };
+      case 'date':
+        return {
+          type: String,
+          validate: value => parseType({ type: 'date', value }),
+          set: value => parseType({ type: 'date', value }),
+        };
+      case 'datetime':
+        return {
+          type: Date,
+        };
       case 'timestamp':
-        return Date;
+        return {
+          type: Date,
+        };
       case 'decimal':
-        return 'Decimal';
+        return { type: 'Decimal' };
       case 'float':
-        return 'Float';
+        return { type: 'Float' };
       case 'json':
-        return 'Mixed';
+        return { type: 'Mixed' };
       case 'biginteger':
-        return 'Long';
+        return { type: 'Long' };
       case 'integer':
-        return 'Number';
+        return { type: 'Number' };
       case 'uuid':
-        return 'ObjectId';
+        return { type: 'ObjectId' };
       case 'email':
       case 'enumeration':
       case 'password':
       case 'string':
       case 'text':
       case 'richtext':
-        return 'String';
+        return { type: 'String' };
       default:
         return undefined;
     }
diff --git a/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js
index 8d55dee235..2f1a4b43ba 100644
--- a/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js
+++ b/packages/strapi-plugin-content-manager/test/types/date.test.e2e.js
@@ -5,7 +5,7 @@ const { createAuthRequest } = require('../../../../test/helpers/request');
 let modelsUtils;
 let rq;
 
-describe.skip('Test type date', () => {
+describe('Test type date', () => {
   beforeAll(async () => {
     const token = await registerAndLogin();
     rq = createAuthRequest(token);
@@ -24,14 +24,14 @@ describe.skip('Test type date', () => {
       '/content-manager/explorer/application::withdate.withdate',
       {
         body: {
-          field: '2019-08-08T10:10:57.000Z',
+          field: '2019-08-08',
         },
       }
     );
 
     expect(res.statusCode).toBe(200);
     expect(res.body).toMatchObject({
-      field: '2019-08-08T10:10:57.000Z',
+      field: '2019-08-08',
     });
   });
 
@@ -49,58 +49,53 @@ describe.skip('Test type date', () => {
 
     expect(res.statusCode).toBe(200);
     expect(res.body).toMatchObject({
-      field: now.toISOString(),
+      field: '2019-01-12',
     });
   });
 
-  test('Create entry with timestamp value should be converted to ISO', async () => {
-    const now = new Date(2016, 4, 8);
+  test.each([
+    '2019-08-08',
+    '2019-08-08 12:11:12',
+    '2019-08-08T00:00:00',
+    '2019-08-08T00:00:00Z',
+    '2019-08-08 00:00:00.123',
+    '2019-08-08 00:00:00.123Z',
+    '2019-08-08T00:00:00.123',
+    '2019-08-08T00:00:00.123Z',
+  ])(
+    'Date can be sent in any iso format and the date part will be kept, (%s)',
+    async input => {
+      const res = await rq.post(
+        '/content-manager/explorer/application::withdate.withdate',
+        {
+          body: {
+            field: input,
+          },
+        }
+      );
 
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: now.getTime(),
-        },
-      }
-    );
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toMatchObject({
+        field: '2019-08-08',
+      });
+    }
+  );
 
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
+  test.each([1234567891012, '1234567891012', '2019/12/11', '12:11:11'])(
+    'Throws on invalid date (%s)',
+    async value => {
+      const res = await rq.post(
+        '/content-manager/explorer/application::withdate.withdate',
+        {
+          body: {
+            field: value,
+          },
+        }
+      );
 
-  test('Accepts string timestamp', async () => {
-    const now = new Date(2000, 0, 1);
-
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: `${now.getTime()}`,
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
-
-  test('Throws on invalid date format', async () => {
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: 'azdazindoaizdnoainzd',
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(400);
-  });
+      expect(res.statusCode).toBe(400);
+    }
+  );
 
   test('Reading entry, returns correct value', async () => {
     const res = await rq.get(
@@ -110,7 +105,9 @@ describe.skip('Test type date', () => {
     expect(res.statusCode).toBe(200);
     expect(Array.isArray(res.body)).toBe(true);
     res.body.forEach(entry => {
-      expect(new Date(entry.field).toISOString()).toBe(entry.field);
+      expect(entry.field).toMatch(
+        /^([12]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01]))$/
+      );
     });
   });
 
@@ -121,7 +118,7 @@ describe.skip('Test type date', () => {
       '/content-manager/explorer/application::withdate.withdate',
       {
         body: {
-          field: now.getTime(),
+          field: now,
         },
       }
     );
@@ -139,7 +136,7 @@ describe.skip('Test type date', () => {
     expect(updateRes.statusCode).toBe(200);
     expect(updateRes.body).toMatchObject({
       id: res.body.id,
-      field: newDate.toISOString(),
+      field: '2017-11-23',
     });
   });
 });
diff --git a/packages/strapi-plugin-content-manager/test/types/time.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/time.test.e2e.js
index 8d55dee235..106a323c48 100644
--- a/packages/strapi-plugin-content-manager/test/types/time.test.e2e.js
+++ b/packages/strapi-plugin-content-manager/test/types/time.test.e2e.js
@@ -5,141 +5,105 @@ const { createAuthRequest } = require('../../../../test/helpers/request');
 let modelsUtils;
 let rq;
 
-describe.skip('Test type date', () => {
+describe('Test type time', () => {
   beforeAll(async () => {
     const token = await registerAndLogin();
     rq = createAuthRequest(token);
 
     modelsUtils = createModelsUtils({ rq });
 
-    await modelsUtils.createModelWithType('withdate', 'date');
+    await modelsUtils.createModelWithType('withtime', 'time');
   }, 60000);
 
   afterAll(async () => {
-    await modelsUtils.deleteModel('withdate');
+    await modelsUtils.deleteModel('withtime');
   }, 60000);
 
   test('Create entry with valid value JSON', async () => {
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withtime.withtime',
       {
         body: {
-          field: '2019-08-08T10:10:57.000Z',
+          field: '10:10:57.123',
         },
       }
     );
 
     expect(res.statusCode).toBe(200);
     expect(res.body).toMatchObject({
-      field: '2019-08-08T10:10:57.000Z',
+      field: '10:10:57.123',
     });
   });
 
-  test('Create entry with valid value FormData', async () => {
-    const now = new Date(2019, 0, 12);
+  test.each(['00:00:00', '01:03:11.2', '01:03:11.93', '01:03:11.123'])(
+    'Accepts multiple time formats %s',
+    async input => {
+      const res = await rq.post(
+        '/content-manager/explorer/application::withtime.withtime',
+        {
+          body: {
+            field: input,
+          },
+        }
+      );
 
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        formData: {
-          data: JSON.stringify({ field: now }),
-        },
-      }
-    );
+      expect(res.statusCode).toBe(200);
+    }
+  );
 
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
+  test.each(['24:11:23', '23:72:11', '12:45:83', 1234, {}, 'test', new Date()])(
+    'Throws on invalid time (%s)',
+    async input => {
+      const res = await rq.post(
+        '/content-manager/explorer/application::withtime.withtime',
+        {
+          body: {
+            field: input,
+          },
+        }
+      );
 
-  test('Create entry with timestamp value should be converted to ISO', async () => {
-    const now = new Date(2016, 4, 8);
-
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: now.getTime(),
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
-
-  test('Accepts string timestamp', async () => {
-    const now = new Date(2000, 0, 1);
-
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: `${now.getTime()}`,
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
-
-  test('Throws on invalid date format', async () => {
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: 'azdazindoaizdnoainzd',
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(400);
-  });
+      expect(res.statusCode).toBe(400);
+    }
+  );
 
   test('Reading entry, returns correct value', async () => {
     const res = await rq.get(
-      '/content-manager/explorer/application::withdate.withdate'
+      '/content-manager/explorer/application::withtime.withtime'
     );
 
     expect(res.statusCode).toBe(200);
     expect(Array.isArray(res.body)).toBe(true);
     res.body.forEach(entry => {
-      expect(new Date(entry.field).toISOString()).toBe(entry.field);
+      expect(entry.field).toMatch(
+        /^2[0-3]|[01][0-9]:[0-5][0-9]:[0-5][0-9](.[0-9]{1,3})?$/
+      );
     });
   });
 
   test('Updating entry sets the right value and format JSON', async () => {
-    const now = new Date(2018, 7, 5);
-
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withtime.withtime',
       {
         body: {
-          field: now.getTime(),
+          field: '12:11:04',
         },
       }
     );
 
-    const newDate = new Date(2017, 10, 23);
-    const updateRes = await rq.put(
-      `/content-manager/explorer/application::withdate.withdate/${res.body.id}`,
+    const uptimeRes = await rq.put(
+      `/content-manager/explorer/application::withtime.withtime/${res.body.id}`,
       {
         body: {
-          field: newDate,
+          field: '13:45:19.123',
         },
       }
     );
 
-    expect(updateRes.statusCode).toBe(200);
-    expect(updateRes.body).toMatchObject({
+    expect(uptimeRes.statusCode).toBe(200);
+    expect(uptimeRes.body).toMatchObject({
       id: res.body.id,
-      field: newDate.toISOString(),
+      field: '13:45:19.123',
     });
   });
 });
diff --git a/packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js
deleted file mode 100644
index 7188a2bd92..0000000000
--- a/packages/strapi-plugin-content-manager/test/types/timestamp.test.e2e.js
+++ /dev/null
@@ -1,145 +0,0 @@
-const { registerAndLogin } = require('../../../../test/helpers/auth');
-const createModelsUtils = require('../../../../test/helpers/models');
-const { createAuthRequest } = require('../../../../test/helpers/request');
-
-let modelsUtils;
-let rq;
-
-describe.skip('Test type date', () => {
-  beforeAll(async () => {
-    const token = await registerAndLogin();
-    rq = createAuthRequest(token);
-
-    modelsUtils = createModelsUtils({ rq });
-
-    await modelsUtils.createModelWithType('withdate', 'datetime');
-  }, 60000);
-
-  afterAll(async () => {
-    await modelsUtils.deleteModel('withdate');
-  }, 60000);
-
-  test('Create entry with valid value JSON', async () => {
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: '2019-08-08T10:10:57.000Z',
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: '2019-08-08T10:10:57.000Z',
-    });
-  });
-
-  test('Create entry with valid value FormData', async () => {
-    const now = new Date(2019, 0, 12);
-
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        formData: {
-          data: JSON.stringify({ field: now }),
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
-
-  test('Create entry with timestamp value should be converted to ISO', async () => {
-    const now = new Date(2016, 4, 8);
-
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: now.getTime(),
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
-
-  test('Accepts string timestamp', async () => {
-    const now = new Date(2000, 0, 1);
-
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: `${now.getTime()}`,
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(res.body).toMatchObject({
-      field: now.toISOString(),
-    });
-  });
-
-  test('Throws on invalid date format', async () => {
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: 'azdazindoaizdnoainzd',
-        },
-      }
-    );
-
-    expect(res.statusCode).toBe(400);
-  });
-
-  test('Reading entry, returns correct value', async () => {
-    const res = await rq.get(
-      '/content-manager/explorer/application::withdate.withdate'
-    );
-
-    expect(res.statusCode).toBe(200);
-    expect(Array.isArray(res.body)).toBe(true);
-    res.body.forEach(entry => {
-      expect(new Date(entry.field).toISOString()).toBe(entry.field);
-    });
-  });
-
-  test('Updating entry sets the right value and format JSON', async () => {
-    const now = new Date(2018, 7, 5);
-
-    const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
-      {
-        body: {
-          field: now.getTime(),
-        },
-      }
-    );
-
-    const newDate = new Date(2017, 10, 23);
-    const updateRes = await rq.put(
-      `/content-manager/explorer/application::withdate.withdate/${res.body.id}`,
-      {
-        body: {
-          field: newDate,
-        },
-      }
-    );
-
-    expect(updateRes.statusCode).toBe(200);
-    expect(updateRes.body).toMatchObject({
-      id: res.body.id,
-      field: newDate.toISOString(),
-    });
-  });
-});
diff --git a/packages/strapi-plugin-graphql/services/Aggregator.js b/packages/strapi-plugin-graphql/services/Aggregator.js
index 09a9139fa3..a2bbeb8749 100644
--- a/packages/strapi-plugin-graphql/services/Aggregator.js
+++ b/packages/strapi-plugin-graphql/services/Aggregator.js
@@ -481,7 +481,7 @@ const formatModelConnectionsGQL = function(fields, model, name, modelResolver) {
     groupBy: `${globalId}GroupBy`,
     aggregate: `${globalId}Aggregator`,
   };
-  const pluralName = pluralize.plural(name);
+  const pluralName = pluralize.plural(_.camelCase(name));
 
   let modelConnectionTypes = `type ${connectionGlobalId} {${Schema.formatGQL(
     connectionFields

From 1c229e24d7452d529920d06c85a26f7b6700a731 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Thu, 5 Dec 2019 16:00:39 +0100
Subject: [PATCH 10/11] Add time precision to allow up to 3 fractional digits

---
 packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
index a6f3c097bd..1f33f748e6 100644
--- a/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
+++ b/packages/strapi-connector-bookshelf/lib/buildDatabaseSchema.js
@@ -84,7 +84,7 @@ module.exports = async ({
       case 'date':
         return table.date(name);
       case 'time':
-        return table.time(name);
+        return table.time(name, 3);
       case 'datetime':
         return table.datetime(name);
       case 'timestamp':

From c469345f352b935760a582fe0d0817816d3b5c67 Mon Sep 17 00:00:00 2001
From: Alexandre Bodin <bodin.alex@gmail.com>
Date: Thu, 5 Dec 2019 16:03:45 +0100
Subject: [PATCH 11/11] Fix test conflicts

---
 .../test/types/datetime.test.e2e.js           | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js b/packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js
index c4406d36ff..64b808717e 100644
--- a/packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js
+++ b/packages/strapi-plugin-content-manager/test/types/datetime.test.e2e.js
@@ -12,16 +12,16 @@ describe('Test type date', () => {
 
     modelsUtils = createModelsUtils({ rq });
 
-    await modelsUtils.createModelWithType('withdate', 'datetime');
+    await modelsUtils.createModelWithType('withdatetime', 'datetime');
   }, 60000);
 
   afterAll(async () => {
-    await modelsUtils.deleteModel('withdate');
+    await modelsUtils.deleteModel('withdatetime');
   }, 60000);
 
   test('Create entry with valid value JSON', async () => {
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withdatetime.withdatetime',
       {
         body: {
           field: '2019-08-08T10:10:57.000Z',
@@ -39,7 +39,7 @@ describe('Test type date', () => {
     const now = new Date(2019, 0, 12);
 
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withdatetime.withdatetime',
       {
         formData: {
           data: JSON.stringify({ field: now }),
@@ -57,7 +57,7 @@ describe('Test type date', () => {
     const now = new Date(2016, 4, 8);
 
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withdatetime.withdatetime',
       {
         body: {
           field: now.getTime(),
@@ -75,7 +75,7 @@ describe('Test type date', () => {
     const now = new Date(2000, 0, 1);
 
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withdatetime.withdatetime',
       {
         body: {
           field: `${now.getTime()}`,
@@ -91,7 +91,7 @@ describe('Test type date', () => {
 
   test('Throws on invalid date format', async () => {
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withdatetime.withdatetime',
       {
         body: {
           field: 'azdazindoaizdnoainzd',
@@ -104,7 +104,7 @@ describe('Test type date', () => {
 
   test('Reading entry, returns correct value', async () => {
     const res = await rq.get(
-      '/content-manager/explorer/application::withdate.withdate'
+      '/content-manager/explorer/application::withdatetime.withdatetime'
     );
 
     expect(res.statusCode).toBe(200);
@@ -118,7 +118,7 @@ describe('Test type date', () => {
     const now = new Date(2018, 7, 5);
 
     const res = await rq.post(
-      '/content-manager/explorer/application::withdate.withdate',
+      '/content-manager/explorer/application::withdatetime.withdatetime',
       {
         body: {
           field: now.getTime(),
@@ -128,7 +128,7 @@ describe('Test type date', () => {
 
     const newDate = new Date(2017, 10, 23);
     const updateRes = await rq.put(
-      `/content-manager/explorer/application::withdate.withdate/${res.body.id}`,
+      `/content-manager/explorer/application::withdatetime.withdatetime/${res.body.id}`,
       {
         body: {
           field: newDate,