@strapi/database 4.3.4 → 4.3.5

package/lib/errors/not-null.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const DatabaseError = require('./database');
+
+class NotNullError extends DatabaseError {
+  constructor({ column = '' } = {}) {
+    super();
+    this.name = 'NotNullError';
+    this.message = `Not null constraint violation${column ? ` on column ${column}` : ''}.`;
+    this.details = { column };
+    this.stack = '';
+  }
+}
+
+module.exports = NotNullError;

package/lib/fields/biginteger.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { toString } = require('lodash/fp');
+
+const NumberField = require('./number');
+
+class BigIntegerField extends NumberField {
+  toDB(value) {
+    return toString(value);
+  }
+
+  fromDB(value) {
+    return toString(value);
+  }
+}
+
+module.exports = BigIntegerField;

package/lib/fields/boolean.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { toString } = require('lodash/fp');
+
+const Field = require('./field');
+
+class BooleanField extends Field {
+  toDB(value) {
+    if (typeof value === 'boolean') return value;
+
+    if (['true', 't', '1', 1].includes(value)) {
+      return true;
+    }
+
+    if (['false', 'f', '0', 0].includes(value)) {
+      return false;
+    }
+
+    return Boolean(value);
+  }
+
+  fromDB(value) {
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    const strVal = toString(value);
+
+    if (strVal === '1') {
+      return true;
+    }
+    if (strVal === '0') {
+      return false;
+    }
+    return null;
+  }
+}
+
+module.exports = BooleanField;

package/lib/fields/date.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { parseDate } = require('./shared/parsers');
+const Field = require('./field');
+
+class DateField extends Field {
+  toDB(value) {
+    return parseDate(value);
+  }
+
+  fromDB(value) {
+    return value;
+  }
+}
+
+module.exports = DateField;

package/lib/fields/datetime.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const dateFns = require('date-fns');
+
+const { parseDateTimeOrTimestamp } = require('./shared/parsers');
+const Field = require('./field');
+
+class DatetimeField extends Field {
+  toDB(value) {
+    return parseDateTimeOrTimestamp(value);
+  }
+
+  fromDB(value) {
+    const cast = new Date(value);
+    return dateFns.isValid(cast) ? cast.toISOString() : null;
+  }
+}
+
+module.exports = DatetimeField;

package/lib/fields/field.js

@@ -0,0 +1,17 @@
+'use strict';
+
+class Field {
+  constructor(config) {
+    this.config = config;
+  }
+
+  toDB(value) {
+    return value;
+  }
+
+  fromDB(value) {
+    return value;
+  }
+}
+
+module.exports = Field;

package/lib/fields/index.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const _ = require('lodash/fp');
+
+const Field = require('./field');
+const StringField = require('./string');
+const JSONField = require('./json');
+const BigIntegerField = require('./biginteger');
+const NumberField = require('./number');
+const DateField = require('./date');
+const TimeField = require('./time');
+const DatetimeField = require('./datetime');
+const TimestampField = require('./timestamp');
+const BooleanField = require('./boolean');
+
+const typeToFieldMap = {
+  increments: Field,
+  password: StringField,
+  email: StringField,
+  string: StringField,
+  uid: StringField,
+  richtext: StringField,
+  text: StringField,
+  enumeration: StringField,
+  json: JSONField,
+  biginteger: BigIntegerField,
+  integer: NumberField,
+  float: NumberField,
+  decimal: NumberField,
+  date: DateField,
+  time: TimeField,
+  datetime: DatetimeField,
+  timestamp: TimestampField,
+  boolean: BooleanField,
+};
+
+const createField = (attribute) => {
+  const { type } = attribute;
+
+  if (_.has(type, typeToFieldMap)) {
+    return new typeToFieldMap[type]({});
+  }
+
+  throw new Error(`Undefined field for type ${type}`);
+};
+
+module.exports = {
+  createField,
+};

package/lib/fields/json.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const Field = require('./field');
+
+class JSONField extends Field {
+  toDB(value) {
+    return JSON.stringify(value);
+  }
+
+  fromDB(value) {
+    if (typeof value === 'string') return JSON.parse(value);
+    return value;
+  }
+}
+
+module.exports = JSONField;

package/lib/fields/number.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { toNumber } = require('lodash/fp');
+
+const Field = require('./field');
+
+class NumberField extends Field {
+  toDB(value) {
+    const numberValue = toNumber(value);
+
+    if (Number.isNaN(numberValue)) {
+      throw new Error(`Expected a valid Number, got ${value}`);
+    }
+
+    return numberValue;
+  }
+
+  fromDB(value) {
+    return toNumber(value);
+  }
+}
+
+module.exports = NumberField;

package/lib/fields/shared/parsers.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { isString, padCharsEnd } = require('lodash/fp');
+const dateFns = require('date-fns');
+
+const { InvalidDateTimeError, InvalidDateError, InvalidTimeError } = require('../../errors');
+
+const DATE_REGEX = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/;
+const PARTIAL_DATE_REGEX = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])/g;
+const TIME_REGEX = /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$/;
+
+const parseDateTimeOrTimestamp = (value) => {
+  if (dateFns.isDate(value)) return value;
+  try {
+    const date = dateFns.parseISO(value);
+    if (dateFns.isValid(date)) return date;
+
+    const milliUnixDate = dateFns.parse(value, 'T', new Date());
+    if (dateFns.isValid(milliUnixDate)) return milliUnixDate;
+
+    throw new InvalidDateTimeError(`Invalid format, expected a timestamp or an ISO date`);
+  } catch (error) {
+    throw new InvalidDateTimeError(`Invalid format, expected a timestamp or an ISO date`);
+  }
+};
+
+const parseDate = (value) => {
+  const found = isString(value) ? value.match(PARTIAL_DATE_REGEX) || [] : [];
+  const extractedValue = found[0];
+
+  if (extractedValue && !DATE_REGEX.test(value)) {
+    // TODO V5: throw an error when format yyyy-MM-dd is not respected
+    // throw new InvalidDateError(`Invalid format, expected yyyy-MM-dd`);
+    process.emitWarning(
+      `[deprecated] Using a date format other than YYYY-MM-DD will be removed in future versions. Date received: ${value}. Date stored: ${extractedValue}.`
+    );
+  }
+
+  const date = dateFns.parseISO(extractedValue);
+  if (!dateFns.isValid(date)) {
+    throw new InvalidDateError(`Invalid date`);
+  }
+
+  return extractedValue;
+};
+
+const parseTime = (value) => {
+  if (dateFns.isDate(value)) return dateFns.format(value, 'HH:mm:ss.SSS');
+
+  if (typeof value !== 'string') {
+    throw new InvalidTimeError(`Expected a string, got a ${typeof value}`);
+  }
+  const result = value.match(TIME_REGEX);
+
+  if (result === null) {
+    throw new InvalidTimeError('Invalid time format, expected HH:mm:ss.SSS');
+  }
+
+  const [, hours, minutes, seconds, fraction = '.000'] = result;
+  const fractionPart = padCharsEnd('0', 3, fraction.slice(1));
+
+  return `${hours}:${minutes}:${seconds}.${fractionPart}`;
+};
+
+module.exports = {
+  parseDateTimeOrTimestamp,
+  parseDate,
+  parseTime,
+};

package/lib/fields/string.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { toString } = require('lodash/fp');
+
+const Field = require('./field');
+
+class StringField extends Field {
+  toDB(value) {
+    return toString(value);
+  }
+
+  fromDB(value) {
+    return toString(value);
+  }
+}
+
+module.exports = StringField;

package/lib/fields/time.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { parseTime } = require('./shared/parsers');
+const Field = require('./field');
+
+class TimeField extends Field {
+  toDB(value) {
+    return parseTime(value);
+  }
+
+  fromDB(value) {
+    // make sure that's a string with valid format ?
+    return value;
+  }
+}
+
+module.exports = TimeField;

package/lib/fields/timestamp.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const dateFns = require('date-fns');
+
+const { parseDateTimeOrTimestamp } = require('./shared/parsers');
+const Field = require('./field');
+
+class TimestampField extends Field {
+  toDB(value) {
+    return parseDateTimeOrTimestamp(value);
+  }
+
+  fromDB(value) {
+    const cast = new Date(value);
+    return dateFns.isValid(cast) ? dateFns.format(cast, 'T') : null;
+  }
+}
+
+module.exports = TimestampField;

package/lib/index.js

@@ -74,7 +74,7 @@ class Database {
 
 // TODO: move into strapi
 Database.transformContentTypes = transformContentTypes;
-Database.init = async config => new Database(config);
+Database.init = async (config) => new Database(config);
 
 module.exports = {
   Database,

package/lib/lifecycles/index.js

@@ -5,7 +5,7 @@ const assert = require('assert').strict;
 const timestampsLifecyclesSubscriber = require('./subscribers/timestamps');
 const modelLifecyclesSubscriber = require('./subscribers/models-lifecycles');
 
-const isValidSubscriber = subscriber => {
+const isValidSubscriber = (subscriber) => {
   return (
     typeof subscriber === 'function' || (typeof subscriber === 'object' && subscriber !== null)
   );
@@ -14,7 +14,7 @@ const isValidSubscriber = subscriber => {
 /**
  * @type {import('.').createLifecyclesProvider}
  */
-const createLifecyclesProvider = db => {
+const createLifecyclesProvider = (db) => {
   let subscribers = [timestampsLifecyclesSubscriber, modelLifecyclesSubscriber];
 
   return {

package/lib/lifecycles/subscribers/models-lifecycles.js

@@ -8,7 +8,7 @@
  * For each model try to run it's lifecycles function if any is defined
  * @type {Subscriber}
  */
-const modelsLifecyclesSubscriber = async event => {
+const modelsLifecyclesSubscriber = async (event) => {
   const { model } = event;
 
   if (event.action in model.lifecycles) {

package/lib/lifecycles/subscribers/timestamps.js

@@ -33,7 +33,7 @@ const timestampsLifecyclesSubscriber = {
 
     const now = new Date();
     if (_.isArray(data)) {
-      data.forEach(data => _.defaults(data, { createdAt: now, updatedAt: now }));
+      data.forEach((data) => _.defaults(data, { createdAt: now, updatedAt: now }));
     }
   },
 
@@ -57,7 +57,7 @@ const timestampsLifecyclesSubscriber = {
 
     const now = new Date();
     if (_.isArray(data)) {
-      data.forEach(data => _.assign(data, { updatedAt: now }));
+      data.forEach((data) => _.assign(data, { updatedAt: now }));
     }
   },
 };

package/lib/metadata/index.js

@@ -84,14 +84,14 @@ const createMetadata = (models = []) => {
   return metadata;
 };
 
-const hasComponentsOrDz = model => {
+const hasComponentsOrDz = (model) => {
   return Object.values(model.attributes).some(
     ({ type }) => types.isComponent(type) || types.isDynamicZone(type)
   );
 };
 
 // NOTE: we might just move the compo logic outside this layer too at some point
-const createCompoLinkModelMeta = baseModelMeta => {
+const createCompoLinkModelMeta = (baseModelMeta) => {
   return {
     // TODO: make sure there can't be any conflicts with a prefix
     // singularName: 'compo',

package/lib/metadata/relations.js

@@ -9,10 +9,10 @@ const _ = require('lodash/fp');
 const hasInversedBy = _.has('inversedBy');
 const hasMappedBy = _.has('mappedBy');
 
-const isOneToAny = attribute => ['oneToOne', 'oneToMany'].includes(attribute.relation);
-const isBidirectional = attribute => hasInversedBy(attribute) || hasMappedBy(attribute);
-const isOwner = attribute => !isBidirectional(attribute) || hasInversedBy(attribute);
-const shouldUseJoinTable = attribute => attribute.useJoinTable !== false;
+const isOneToAny = (attribute) => ['oneToOne', 'oneToMany'].includes(attribute.relation);
+const isBidirectional = (attribute) => hasInversedBy(attribute) || hasMappedBy(attribute);
+const isOwner = (attribute) => !isBidirectional(attribute) || hasInversedBy(attribute);
+const shouldUseJoinTable = (attribute) => attribute.useJoinTable !== false;
 
 /**
  * Creates a oneToOne relation metadata
@@ -75,12 +75,8 @@ const createOneToMany = (attributeName, attribute, meta, metadata) => {
       attributeName,
       meta,
     });
-  } else {
-    if (isOwner(attribute)) {
-      throw new Error(
-        'one side of a oneToMany cannot be the owner side in a bidirectional relation'
-      );
-    }
+  } else if (isOwner(attribute)) {
+    throw new Error('one side of a oneToMany cannot be the owner side in a bidirectional relation');
   }
 };
 
@@ -169,7 +165,7 @@ const createManyToMany = (attributeName, attribute, meta, metadata) => {
  * @param {ModelMetadata} meta
  * @param {Metadata} metadata
  */
-const createMorphToOne = (attributeName, attribute /*meta, metadata*/) => {
+const createMorphToOne = (attributeName, attribute /* meta, metadata */) => {
   const idColumnName = 'target_id';
   const typeColumnName = 'target_type';
 
@@ -341,9 +337,10 @@ const createRelation = (attributeName, attribute, meta, metadata) => {
       return createMorphOne(attributeName, attribute, meta, metadata);
     case 'morphMany':
       return createMorphMany(attributeName, attribute, meta, metadata);
+    default: {
+      throw new Error(`Unknown relation ${attribute.relation}`);
+    }
   }
-
-  throw new Error(`Unknown relation ${attribute.relation}`);
 };
 
 /**
@@ -354,7 +351,7 @@ const createRelation = (attributeName, attribute, meta, metadata) => {
  * @param {string} param.attributeName name of the associated attribute
  * @param {Object} param.meta model metadata
  */
-const createJoinColum = (metadata, { attribute, attributeName /*meta */ }) => {
+const createJoinColum = (metadata, { attribute, attributeName /* meta */ }) => {
   const targetMeta = metadata.get(attribute.target);
 
   const joinColumnName = _.snakeCase(`${attributeName}_id`);
@@ -395,7 +392,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
 
   const joinTableName = _.snakeCase(`${meta.tableName}_${attributeName}_links`);
 
-  let joinColumnName = _.snakeCase(`${meta.singularName}_id`);
+  const joinColumnName = _.snakeCase(`${meta.singularName}_id`);
   let inverseJoinColumnName = _.snakeCase(`${targetMeta.singularName}_id`);
 
   // if relation is slef referencing

package/lib/migrations/index.js

@@ -6,8 +6,8 @@ const { Umzug } = require('umzug');
 
 const createStorage = require('./storage');
 
-const wrapTransaction = db => fn => () =>
-  db.connection.transaction(trx => Promise.resolve(fn(trx)));
+const wrapTransaction = (db) => (fn) => () =>
+  db.connection.transaction((trx) => Promise.resolve(fn(trx)));
 
 // TODO: check multiple commands in one sql statement
 const migrationResolver = ({ name, path, context }) => {
@@ -19,7 +19,7 @@ const migrationResolver = ({ name, path, context }) => {
 
     return {
       name,
-      up: wrapTransaction(db)(knex => knex.raw(sql)),
+      up: wrapTransaction(db)((knex) => knex.raw(sql)),
       down() {},
     };
   }
@@ -33,7 +33,7 @@ const migrationResolver = ({ name, path, context }) => {
   };
 };
 
-const createUmzugProvider = db => {
+const createUmzugProvider = (db) => {
   const migrationDir = path.join(strapi.dirs.app.root, 'database/migrations');
 
   fse.ensureDirSync(migrationDir);
@@ -54,7 +54,7 @@ const createUmzugProvider = db => {
  * Creates migrations provider
  * @type {import('.').createMigrationsProvider}
  */
-const createMigrationsProvider = db => {
+const createMigrationsProvider = (db) => {
   const migrations = createUmzugProvider(db);
 
   return {

package/lib/migrations/storage.js

@@ -6,7 +6,7 @@ const createStorage = (opts = {}) => {
   const hasMigrationTable = () => db.getSchemaConnection().hasTable(tableName);
 
   const createMigrationTable = () => {
-    return db.getSchemaConnection().createTable(tableName, table => {
+    return db.getSchemaConnection().createTable(tableName, (table) => {
       table.increments('id');
       table.string('name');
       table.datetime('time', { useTz: false });
@@ -25,10 +25,7 @@ const createStorage = (opts = {}) => {
     },
 
     async unlogMigration({ name }) {
-      await db
-        .getConnection(tableName)
-        .del()
-        .where({ name });
+      await db.getConnection(tableName).del().where({ name });
     },
 
     async executed() {
@@ -37,13 +34,9 @@ const createStorage = (opts = {}) => {
         return [];
       }
 
-      const logs = await db
-        .getConnection(tableName)
-        .select()
-        .from(tableName)
-        .orderBy('time');
+      const logs = await db.getConnection(tableName).select().from(tableName).orderBy('time');
 
-      return logs.map(log => log.name);
+      return logs.map((log) => log.name);
     },
   };
 };

package/lib/query/helpers/join.js

@@ -32,7 +32,7 @@ const createJoin = (ctx, { alias, attributeName, attribute }) => {
 
   const tragetMeta = db.metadata.get(attribute.target);
 
-  const joinColumn = attribute.joinColumn;
+  const { joinColumn } = attribute;
 
   if (joinColumn) {
     const subAlias = qb.getAlias();
@@ -46,7 +46,7 @@ const createJoin = (ctx, { alias, attributeName, attribute }) => {
     return subAlias;
   }
 
-  const joinTable = attribute.joinTable;
+  const { joinTable } = attribute;
   if (joinTable) {
     return createPivotJoin(qb, joinTable, alias, tragetMeta);
   }
@@ -67,7 +67,7 @@ const applyJoin = (qb, join) => {
     orderBy,
   } = join;
 
-  qb[method](`${referencedTable} as ${alias}`, inner => {
+  qb[method](`${referencedTable} as ${alias}`, (inner) => {
     inner.on(`${rootTable}.${rootColumn}`, `${alias}.${referencedColumn}`);
 
     if (on) {
@@ -78,14 +78,14 @@ const applyJoin = (qb, join) => {
   });
 
   if (orderBy) {
-    Object.keys(orderBy).forEach(column => {
+    Object.keys(orderBy).forEach((column) => {
       const direction = orderBy[column];
       qb.orderBy(`${alias}.${column}`, direction);
     });
   }
 };
 
-const applyJoins = (qb, joins) => joins.forEach(join => applyJoin(qb, join));
+const applyJoins = (qb, joins) => joins.forEach((join) => applyJoin(qb, join));
 
 module.exports = {
   createJoin,

package/lib/query/helpers/order-by.js

@@ -24,7 +24,7 @@ const processOrderBy = (orderBy, ctx) => {
   }
 
   if (Array.isArray(orderBy)) {
-    return orderBy.flatMap(value => processOrderBy(value, ctx));
+    return orderBy.flatMap((value) => processOrderBy(value, ctx));
   }
 
   if (_.isPlainObject(orderBy)) {