@strapi/database 4.14.4 → 4.14.6

package/lib/entity-manager/relations-orderer.js

@@ -1,225 +0,0 @@
-'use strict';
-
-const { castArray } = require('lodash/fp');
-const _ = require('lodash/fp');
-const { InvalidRelationError } = require('../errors');
-/**
- * When connecting relations, the order you connect them matters.
- *
- * Example, if you connect the following relations:
- *   { id: 5, position: { before: 1 } }
- *   { id: 1, position: { before: 2 } }
- *   { id: 2, position: { end: true } }
- *
- * Going through the connect array, id 5 has to be connected before id 1,
- * so the order of id5 = id1 - 1. But the order value of id 1 is unknown.
- * The only way to know the order of id 1 is to connect it first.
- *
- * This function makes sure the relations are connected in the right order:
- *   { id: 2, position: { end: true } }
- *   { id: 1, position: { before: 2 } }
- *   { id: 5, position: { before: 1 } }
- *
- */
-const sortConnectArray = (connectArr, initialArr = [], strictSort = true) => {
-  const sortedConnect = [];
-  // Boolean to know if we have to recalculate the order of the relations
-  let needsSorting = false;
-  // Map to validate if relation is already in sortedConnect or DB.
-  const relationInInitialArray = initialArr.reduce((acc, rel) => ({ ...acc, [rel.id]: true }), {});
-  // Map to store the first index where a relation id is connected
-  const mappedRelations = connectArr.reduce((mapper, relation) => {
-    const adjacentRelId = relation.position?.before || relation.position?.after;
-
-    if (!relationInInitialArray[adjacentRelId] && !mapper[adjacentRelId]) {
-      needsSorting = true;
-    }
-
-    // If the relation is already in the array, throw an error
-    if (mapper[relation.id]) {
-      throw new InvalidRelationError(
-        `The relation with id ${relation.id} is already connected. ` +
-          'You cannot connect the same relation twice.'
-      );
-    }
-
-    return {
-      [relation.id]: { ...relation, computed: false },
-      ...mapper,
-    };
-  }, {});
-
-  // If we don't need to sort the connect array, we can return it as is
-  if (!needsSorting) return connectArr;
-
-  // Recursively compute in which order the relation should be connected
-  const computeRelation = (relation, relationsSeenInBranch) => {
-    const adjacentRelId = relation.position?.before || relation.position?.after;
-    const adjacentRelation = mappedRelations[adjacentRelId];
-
-    // If the relation has already been seen in the current branch,
-    // it means there is a circular reference
-    if (relationsSeenInBranch[adjacentRelId]) {
-      throw new InvalidRelationError(
-        'A circular reference was found in the connect array. ' +
-          'One relation is trying to connect before/after another one that is trying to connect before/after it'
-      );
-    }
-
-    // This relation has already been computed
-    if (mappedRelations[relation.id]?.computed) return;
-
-    mappedRelations[relation.id].computed = true;
-
-    // Relation does not have a before or after attribute or is in the initial array
-    if (!adjacentRelId || relationInInitialArray[adjacentRelId]) {
-      sortedConnect.push(relation);
-      return;
-    }
-
-    // Look if id is referenced elsewhere in the array
-    if (mappedRelations[adjacentRelId]) {
-      computeRelation(adjacentRelation, { ...relationsSeenInBranch, [relation.id]: true });
-      sortedConnect.push(relation);
-    } else if (strictSort) {
-      // If we reach this point, it means that the adjacent relation is not in the connect array
-      // and it is not in the database.
-      throw new InvalidRelationError(
-        `There was a problem connecting relation with id ${
-          relation.id
-        } at position ${JSON.stringify(
-          relation.position
-        )}. The relation with id ${adjacentRelId} needs to be connected first.`
-      );
-    } else {
-      // We are in non-strict mode so we can push the relation.
-      sortedConnect.push({ id: relation.id, position: { end: true } });
-    }
-  };
-
-  // Iterate over connectArr and populate sortedConnect
-  connectArr.forEach((relation) => computeRelation(relation, {}));
-
-  return sortedConnect;
-};
-
-/**
- * Responsible for calculating the relations order when connecting them.
- *
- * The connect method takes an array of relations with positional attributes:
- * - before: the id of the relation to connect before
- * - after: the id of the relation to connect after
- * - end: it should be at the end
- * - start: it should be at the start
- *
- * Example:
- *  - Having a connect array like:
- *      [ { id: 4, before: 2 }, { id: 4, before: 3}, {id: 5, before: 4} ]
- * - With the initial relations:
- *      [ { id: 2, order: 4 }, { id: 3, order: 10 } ]
- * - Step by step, going through the connect array, the array of relations would be:
- *      [ { id: 4, order: 3.5 }, { id: 2, order: 4 }, { id: 3, order: 10 } ]
- *      [ { id: 2, order: 4 }, { id: 4, order: 3.5 }, { id: 3, order: 10 } ]
- *      [ { id: 2, order: 4 }, { id: 5, order: 3.5 },  { id: 4, order: 3.5 }, { id: 3, order: 10 } ]
- * - The final step would be to recalculate fractional order values.
- *      [ { id: 2, order: 4 }, { id: 5, order: 3.33 },  { id: 4, order: 3.66 }, { id: 3, order: 10 } ]
- *
- * @param {Array<*>} initArr - array of relations to initialize the class with
- * @param {string} idColumn - the column name of the id
- * @param {string} orderColumn - the column name of the order
- * @param {boolean} strict - if true, will throw an error if a relation is connected adjacent to
- *                               another one that does not exist
- * @return {*}
- */
-const relationsOrderer = (initArr, idColumn, orderColumn, strict) => {
-  const computedRelations = _.castArray(initArr || []).map((r) => ({
-    init: true,
-    id: r[idColumn],
-    order: r[orderColumn] || 1,
-  }));
-
-  const maxOrder = _.maxBy('order', computedRelations)?.order || 0;
-
-  const findRelation = (id) => {
-    const idx = computedRelations.findIndex((r) => r.id === id);
-    return { idx, relation: computedRelations[idx] };
-  };
-
-  const removeRelation = (r) => {
-    const { idx } = findRelation(r.id);
-    if (idx >= 0) {
-      computedRelations.splice(idx, 1);
-    }
-  };
-
-  const insertRelation = (r) => {
-    let idx;
-
-    if (r.position?.before) {
-      const { idx: _idx, relation } = findRelation(r.position.before);
-      if (relation.init) r.order = relation.order - 0.5;
-      else r.order = relation.order;
-      idx = _idx;
-    } else if (r.position?.after) {
-      const { idx: _idx, relation } = findRelation(r.position.after);
-      if (relation.init) r.order = relation.order + 0.5;
-      else r.order = relation.order;
-      idx = _idx + 1;
-    } else if (r.position?.start) {
-      r.order = 0.5;
-      idx = 0;
-    } else {
-      r.order = maxOrder + 0.5;
-      idx = computedRelations.length;
-    }
-
-    // Insert the relation in the array
-    computedRelations.splice(idx, 0, r);
-  };
-
-  return {
-    disconnect(relations) {
-      castArray(relations).forEach((relation) => {
-        removeRelation(relation);
-      });
-      return this;
-    },
-    connect(relations) {
-      sortConnectArray(castArray(relations), computedRelations, strict).forEach((relation) => {
-        this.disconnect(relation);
-
-        try {
-          insertRelation(relation);
-        } catch (err) {
-          throw new Error(
-            `There was a problem connecting relation with id ${
-              relation.id
-            } at position ${JSON.stringify(
-              relation.position
-            )}. The list of connect relations is not valid`
-          );
-        }
-      });
-      return this;
-    },
-    get() {
-      return computedRelations;
-    },
-    /**
-     * Get a map between the relation id and its order
-     */
-    getOrderMap() {
-      return _(computedRelations)
-        .groupBy('order')
-        .reduce((acc, relations) => {
-          if (relations[0]?.init) return acc;
-          relations.forEach((relation, idx) => {
-            acc[relation.id] = Math.floor(relation.order) + (idx + 1) / (relations.length + 1);
-          });
-          return acc;
-        }, {});
-    },
-  };
-};
-
-module.exports = { relationsOrderer, sortConnectArray };

package/lib/errors/database.js

@@ -1,12 +0,0 @@
-'use strict';
-
-class DatabaseError extends Error {
-  constructor(message, details = {}) {
-    super();
-    this.name = 'DatabaseError';
-    this.message = message || 'A database error occured';
-    this.details = details;
-  }
-}
-
-module.exports = DatabaseError;

package/lib/errors/index.js

@@ -1,17 +0,0 @@
-'use strict';
-
-const DatabaseError = require('./database');
-const NotNullError = require('./not-null');
-const InvalidTimeError = require('./invalid-time');
-const InvalidDateError = require('./invalid-date');
-const InvalidDateTimeError = require('./invalid-datetime');
-const InvalidRelationError = require('./invalid-relation');
-
-module.exports = {
-  DatabaseError,
-  NotNullError,
-  InvalidTimeError,
-  InvalidDateError,
-  InvalidDateTimeError,
-  InvalidRelationError,
-};

package/lib/errors/invalid-date.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const DatabaseError = require('./database');
-
-class InvalidDateError extends DatabaseError {
-  constructor(message) {
-    super();
-    this.name = 'InvalidTimeFormat';
-    this.message = message || 'Invalid date format, expected YYYY-MM-DD';
-    this.details = {};
-  }
-}
-
-module.exports = InvalidDateError;

package/lib/errors/invalid-datetime.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const DatabaseError = require('./database');
-
-class InvalidDateTimeError extends DatabaseError {
-  constructor(message) {
-    super();
-    this.name = 'InvalidTimeFormat';
-    this.message = message || 'Invalid datetime format, expected a timestamp or an ISO date';
-    this.details = {};
-  }
-}
-
-module.exports = InvalidDateTimeError;

package/lib/errors/invalid-relation.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const DatabaseError = require('./database');
-
-class InvalidRelationError extends DatabaseError {
-  constructor(message) {
-    super();
-    this.name = 'InvalidRelationFormat';
-    this.message = message || 'Invalid relation format';
-    this.details = {};
-  }
-}
-
-module.exports = InvalidRelationError;

package/lib/errors/invalid-time.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const DatabaseError = require('./database');
-
-class InvalidTimeError extends DatabaseError {
-  constructor(message) {
-    super();
-    this.name = 'InvalidTimeFormat';
-    this.message = message || 'Invalid time format, expected HH:mm:ss.SSS';
-    this.details = {};
-  }
-}
-
-module.exports = InvalidTimeError;

package/lib/errors/not-null.js

@@ -1,15 +0,0 @@
-'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

@@ -1,17 +0,0 @@
-'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

@@ -1,39 +0,0 @@
-'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

@@ -1,16 +0,0 @@
-'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

@@ -1,19 +0,0 @@
-'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

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

package/lib/fields/index.d.ts

@@ -1,9 +0,0 @@
-import { Attribute } from './schema';
-
-interface Field {
-  config: {};
-  toDB(value: any): any;
-  fromDB(value: any): any;
-}
-
-export function createField(attribute: Attribute): Field;

package/lib/fields/index.js

@@ -1,50 +0,0 @@
-'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,
-  blocks: JSONField,
-};
-
-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

@@ -1,21 +0,0 @@
-'use strict';
-
-const Field = require('./field');
-
-class JSONField extends Field {
-  toDB(value) {
-    return JSON.stringify(value);
-  }
-
-  fromDB(value) {
-    try {
-      if (typeof value === 'string') return JSON.parse(value);
-    } catch (error) {
-      // Just return the value if it's not a valid JSON string
-      return value;
-    }
-    return value;
-  }
-}
-
-module.exports = JSONField;

package/lib/fields/number.js

@@ -1,23 +0,0 @@
-'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

@@ -1,71 +0,0 @@
-'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) => {
-  if (dateFns.isDate(value)) return dateFns.format(value, 'yyyy-MM-dd');
-
-  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

@@ -1,17 +0,0 @@
-'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

@@ -1,17 +0,0 @@
-'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

@@ -1,19 +0,0 @@
-'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;