@akemona-org/strapi-database 3.7.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015-present Strapi Solutions SAS
+
+Portions of the Strapi software are licensed as follows:
+
+* All software that resides under an "ee/" directory (the “EE Software”), if that directory exists, is licensed under the license defined in "ee/LICENSE".
+
+* All software outside of the above-mentioned directories or restrictions above is available under the "MIT Expat" license as set forth below.
+
+MIT Expat License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# Strapi database layer
+
+[![npm version](https://img.shields.io/npm/v/strapi-database.svg)](https://www.npmjs.org/package/strapi-database)
+[![npm downloads](https://img.shields.io/npm/dm/strapi-database.svg)](https://www.npmjs.org/package/strapi-database)
+[![npm dependencies](https://david-dm.org/strapi/strapi-database.svg)](https://david-dm.org/strapi/strapi-database)
+[![Build status](https://travis-ci.org/strapi/strapi-database.svg?branch=master)](https://travis-ci.org/strapi/strapi-database)
+[![Slack status](https://slack.strapi.io/badge.svg)](https://slack.strapi.io)
+
+---
+
+## Deprecation Warning :warning:
+
+Hello! We have some news to share,
+
+We’ve decided it’ll soon be time to end the support for `strapi-database`.
+
+After years of iterations, Strapi is going to V4 and we won’t maintain V3 packages when it’ll reach its end-of-support milestone (~end of Q3 2022).
+
+If you’ve been using `strapi-database` and have migrated to V4 (or if you want to), you can find the equivalent and updated version of this package at this [URL](https://github.com/strapi/strapi/tree/master/packages/core/database) and with the following name on NPM: `@strapi/database`.
+
+If you’ve contributed to the development of this package, thank you again for that! We hope to see you on the V4 soon.
+
+The Akemona team
+
+---
+
+This package is strapi's database handling layer. It is responsible for orchestrating database connectors and implementing the logic of strapi's data structures.
+
+This package is not meant to be used as a standalone module.
+
+## Resources
+
+- [License](LICENSE)
+
+## Links
+
+- [Strapi documentation](https://strapi.akemona.com/documentation)
+- [Strapi website](https://strapi.akemona.com/)
+- [Strapi community on Slack](https://slack.strapi.io)
+- [Strapi news on Twitter](https://twitter.com/strapijs)

package/lib/connector-registry.js

@@ -0,0 +1,63 @@
+'use strict';
+/**
+ * Database connector registry
+ */
+
+const _ = require('lodash');
+const requireConnector = require('./require-connector');
+
+const createConnectorRegistry = ({ defaultConnection, connections }) => {
+  const _connectors = new Map();
+
+  return {
+    /**
+     * Load connector modules
+     */
+    load() {
+      for (const connection of Object.values(connections)) {
+        const { connector } = connection;
+        if (!_connectors.has(connector)) {
+          _connectors.set(connector, requireConnector(connector)(strapi));
+        }
+      }
+    },
+
+    /**
+     * Initialize connectors
+     */
+    async initialize() {
+      for (const connector of _connectors.values()) {
+        await connector.initialize();
+      }
+    },
+
+    getAll() {
+      return Array.from(_connectors.values());
+    },
+
+    get(key) {
+      return _connectors.get(key);
+    },
+
+    set(key, val) {
+      _connectors.set(key, val);
+      return this;
+    },
+
+    get default() {
+      const defaultConnector = connections[defaultConnection].connector;
+      return _connectors.get(defaultConnector);
+    },
+
+    getByConnection(connection) {
+      if (!_.has(connections, connection)) {
+        throw new Error('Trying to access a connector for an unknown connection');
+      }
+
+      const connectorKey = connections[connection].connector;
+      return _connectors.get(connectorKey);
+    },
+  };
+};
+
+module.exports = createConnectorRegistry;

package/lib/constants/index.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+
+const { PUBLISHED_AT_ATTRIBUTE, CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } =
+  contentTypesUtils.constants;
+
+// contentTypes and components reserved names
+const RESERVED_MODEL_NAMES = ['admin', 'boolean', 'date', 'date-time', 'time', 'upload'];
+// attribute reserved names
+const RESERVED_ATTRIBUTE_NAMES = [
+  // existing fields
+  '_id',
+  'id',
+  CREATED_BY_ATTRIBUTE,
+  UPDATED_BY_ATTRIBUTE,
+  PUBLISHED_AT_ATTRIBUTE,
+
+  // existing object properties that may cause trouble
+  'length',
+  'attributes',
+  'relations',
+  'changed',
+
+  // list found here https://mongoosejs.com/docs/api.html#schema_Schema.reserved
+  '_posts',
+  '_pres',
+  'collection',
+  'emit',
+  'errors',
+  'get',
+  'init',
+  'isModified',
+  'isNew',
+  'listeners',
+  'modelName',
+  'on',
+  'once',
+  'populated',
+  'prototype',
+  'remove',
+  'removeListener',
+  'save',
+  'schema',
+  'toObject',
+  'validate',
+  'format',
+];
+
+module.exports = {
+  RESERVED_MODEL_NAMES,
+  RESERVED_ATTRIBUTE_NAMES,
+};

package/lib/database-manager.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const _ = require('lodash');
+
+const { createQuery } = require('./queries');
+const createConnectorRegistry = require('./connector-registry');
+const constants = require('./constants');
+const { validateModelSchemas } = require('./validation');
+const createMigrationManager = require('./migration-manager');
+const createLifecycleManager = require('./lifecycle-manager');
+
+class DatabaseManager {
+  constructor(strapi) {
+    this.strapi = strapi;
+
+    this.initialized = false;
+
+    this.connectors = createConnectorRegistry({
+      connections: strapi.config.get('database.connections'),
+      defaultConnection: strapi.config.get('database.defaultConnection'),
+    });
+
+    this.queries = new Map();
+    this.models = new Map();
+
+    this.migrations = createMigrationManager(this);
+    this.lifecycles = createLifecycleManager();
+  }
+
+  async initialize() {
+    if (this.initialized === true) {
+      throw new Error('Database manager already initialized');
+    }
+
+    this.initialized = true;
+
+    this.connectors.load();
+
+    validateModelSchemas({ strapi: this.strapi, manager: this });
+
+    this.initializeModelsMap();
+
+    await this.connectors.initialize();
+
+    return this;
+  }
+
+  async destroy() {
+    await Promise.all(this.connectors.getAll().map(connector => connector.destroy()));
+  }
+
+  initializeModelsMap() {
+    Object.keys(this.strapi.models).forEach(modelKey => {
+      const model = this.strapi.models[modelKey];
+      this.models.set(model.uid, model);
+    });
+
+    Object.keys(this.strapi.admin.models).forEach(modelKey => {
+      const model = this.strapi.admin.models[modelKey];
+      this.models.set(model.uid, model);
+    });
+
+    Object.keys(this.strapi.plugins).forEach(pluginKey => {
+      Object.keys(this.strapi.plugins[pluginKey].models).forEach(modelKey => {
+        const model = this.strapi.plugins[pluginKey].models[modelKey];
+        this.models.set(model.uid, model);
+      });
+    });
+  }
+
+  query(entity, plugin) {
+    if (!entity) {
+      throw new Error(`argument entity is required`);
+    }
+
+    const model = this.getModel(entity, plugin);
+
+    if (!model) {
+      throw new Error(`The model ${entity} can't be found.`);
+    }
+
+    if (this.queries.has(model.uid)) {
+      return this.queries.get(model.uid);
+    }
+
+    const connectorQuery = this.connectors
+      .get(model.orm)
+      .queries({ model, modelKey: model.modelName, strapi });
+
+    const query = createQuery({
+      connectorQuery,
+      model,
+    });
+
+    this.queries.set(model.uid, query);
+    return query;
+  }
+
+  getModelFromStrapi(name, plugin) {
+    const key = _.toLower(name);
+    if (plugin === 'admin') {
+      return _.get(strapi.admin, ['models', key]);
+    }
+
+    if (plugin) {
+      return _.get(strapi.plugins, [plugin, 'models', key]);
+    }
+
+    return _.get(strapi, ['models', key]) || _.get(strapi, ['components', key]);
+  }
+
+  getModel(name, plugin) {
+    const key = _.toLower(name);
+
+    if (this.models.has(key)) {
+      const { modelName, plugin: pluginName } = this.models.get(key);
+      return this.getModelFromStrapi(modelName, pluginName);
+    } else {
+      return this.getModelFromStrapi(key, plugin);
+    }
+  }
+
+  getModelByAssoc(assoc) {
+    return this.getModel(assoc.collection || assoc.model, assoc.plugin);
+  }
+
+  getModelByCollectionName(collectionName) {
+    return Array.from(this.models.values()).find(model => {
+      return model.collectionName === collectionName;
+    });
+  }
+
+  getModelByGlobalId(globalId) {
+    return Array.from(this.models.values()).find(model => {
+      return model.globalId === globalId;
+    });
+  }
+
+  getModelsByAttribute(attr) {
+    if (attr.type === 'component') {
+      return [this.getModel(attr.component)];
+    }
+    if (attr.type === 'dynamiczone') {
+      return attr.components.map(compoName => this.getModel(compoName));
+    }
+    if (attr.model || attr.collection) {
+      return [this.getModelByAssoc(attr)];
+    }
+
+    return [];
+  }
+
+  getModelsByPluginName(pluginName) {
+    if (!pluginName) {
+      return strapi.models;
+    }
+
+    return pluginName === 'admin' ? strapi.admin.models : strapi.plugins[pluginName].models;
+  }
+
+  getReservedNames() {
+    return {
+      models: constants.RESERVED_MODEL_NAMES,
+      attributes: [
+        ...constants.RESERVED_ATTRIBUTE_NAMES,
+        ...(strapi.db.connectors.default.defaultTimestamps || []),
+      ],
+    };
+  }
+}
+
+function createDatabaseManager(strapi) {
+  return new DatabaseManager(strapi);
+}
+
+module.exports = {
+  createDatabaseManager,
+};

package/lib/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { createDatabaseManager } = require('./database-manager');
+
+module.exports = {
+  createDatabaseManager,
+};

package/lib/lifecycle-manager.js

@@ -0,0 +1,33 @@
+'use strict';
+const debug = require('debug')('strapi-database:lifecycle');
+const { isFunction, isNil } = require('lodash/fp');
+
+class LifecycleManager {
+  constructor() {
+    debug('Initialize lifecycle manager');
+    this.lifecycles = [];
+  }
+
+  register(lifecycle) {
+    debug('Register lifecycle');
+
+    this.lifecycles.push(lifecycle);
+    return this;
+  }
+
+  async run(action, model, ...args) {
+    for (const lifecycle of this.lifecycles) {
+      if (!isNil(lifecycle.model) && lifecycle.model !== model.uid) {
+        continue;
+      }
+
+      if (isFunction(lifecycle[action])) {
+        debug(`Run lifecycle ${action} for model ${model.uid}`);
+
+        await lifecycle[action](...args);
+      }
+    }
+  }
+}
+
+module.exports = () => new LifecycleManager();

package/lib/migration-manager.js

@@ -0,0 +1,66 @@
+'use strict';
+const debug = require('debug')('strapi-database:migration');
+const { isFunction, get } = require('lodash/fp');
+
+class MigrationManager {
+  constructor(db) {
+    debug('Initialize migration manager');
+    this.db = db;
+    this.migrations = [];
+  }
+
+  register(migration) {
+    debug('Register migration');
+    this.migrations.push(migration);
+  }
+
+  async run(fn, options, context = {}) {
+    debug('Run migration');
+    await this.runBefore(options, context);
+    await fn(options, context);
+    await this.runAfter(options, context);
+  }
+
+  async shouldRun({ migration, step, options, context }) {
+    const method = migration[step];
+    const shouldRunMethod = get(`shouldRun.${step}`, migration, null);
+
+    if (!isFunction(method)) {
+      return false;
+    }
+
+    if (!isFunction(shouldRunMethod)) {
+      return true;
+    }
+
+    return shouldRunMethod(options, context);
+  }
+
+  async runBefore(options, context) {
+    debug('Run before migrations');
+
+    for (const migration of this.migrations) {
+      const willRunStep = await this.shouldRun({ migration, step: 'before', options, context });
+
+      if (willRunStep) {
+        await migration.before(options, context);
+      }
+    }
+  }
+
+  async runAfter(options, context) {
+    debug('Run after migrations');
+
+    for (const migration of this.migrations.slice(0).reverse()) {
+      const willRunStep = await this.shouldRun({ migration, step: 'after', options, context });
+
+      if (willRunStep) {
+        await migration.after(options, context);
+      }
+    }
+  }
+}
+
+module.exports = strapi => {
+  return new MigrationManager(strapi);
+};

package/lib/queries/create-query.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const pmap = require('p-map');
+
+const { createQueryWithLifecycles, withLifecycles } = require('./helpers');
+const { createRelationsCountsQuery } = require('./relations-counts-queries');
+const { createFindPageQuery, createSearchPageQuery } = require('./paginated-queries');
+
+/**
+ * @param {Object} opts options
+ * @param {Object} opts.model The ORM model
+ * @param {Object} opts.connectorQuery The ORM queries implementation
+ */
+module.exports = function createQuery(opts) {
+  const { model, connectorQuery } = opts;
+
+  const createFn = createQueryWithLifecycles({
+    query: 'create',
+    model,
+    connectorQuery,
+  });
+
+  const createMany = (entities, { concurrency = 100 } = {}, ...rest) => {
+    return pmap(entities, entity => createFn(entity, ...rest), {
+      concurrency,
+      stopOnError: true,
+    });
+  };
+
+  const findPage = withLifecycles({
+    query: 'findPage',
+    model,
+    fn: createFindPageQuery(connectorQuery),
+  });
+
+  const findWithRelationCounts = createRelationsCountsQuery({
+    model,
+    fn: findPage,
+    connectorQuery,
+  });
+
+  const searchPage = withLifecycles({
+    query: 'searchPage',
+    model,
+    fn: createSearchPageQuery(connectorQuery),
+  });
+
+  const searchWithRelationCounts = createRelationsCountsQuery({
+    model,
+    fn: searchPage,
+    connectorQuery,
+  });
+
+  return {
+    get model() {
+      return model;
+    },
+
+    get orm() {
+      return model.orm;
+    },
+
+    get primaryKey() {
+      return model.primaryKey;
+    },
+
+    get associations() {
+      return model.associations;
+    },
+
+    /**
+     * Run custom database logic
+     */
+    custom(mapping) {
+      if (typeof mapping === 'function') {
+        return mapping.bind(this, { model: this.model });
+      }
+
+      if (!mapping[this.orm]) {
+        throw new Error(`Missing mapping for orm ${this.orm}`);
+      }
+
+      if (typeof mapping[this.orm] !== 'function') {
+        throw new Error(`Custom queries must be functions received ${typeof mapping[this.orm]}`);
+      }
+
+      return mapping[this.model.orm].call(this, { model: this.model });
+    },
+
+    create: createFn,
+    createMany,
+    update: createQueryWithLifecycles({ query: 'update', model, connectorQuery }),
+    delete: createQueryWithLifecycles({ query: 'delete', model, connectorQuery }),
+    find: createQueryWithLifecycles({ query: 'find', model, connectorQuery }),
+    findOne: createQueryWithLifecycles({ query: 'findOne', model, connectorQuery }),
+    count: createQueryWithLifecycles({ query: 'count', model, connectorQuery }),
+    search: createQueryWithLifecycles({ query: 'search', model, connectorQuery }),
+    countSearch: createQueryWithLifecycles({ query: 'countSearch', model, connectorQuery }),
+
+    // paginated queries
+    findPage,
+    searchPage,
+
+    searchWithRelationCounts,
+    findWithRelationCounts,
+  };
+};

package/lib/queries/helpers.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { replaceIdByPrimaryKey } = require('../utils/primary-key');
+const { executeBeforeLifecycle, executeAfterLifecycle } = require('../utils/lifecycles');
+
+const withLifecycles = ({ query, model, fn }) => async (params, ...rest) => {
+  // substitute id for primaryKey value in params
+  const newParams = replaceIdByPrimaryKey(params, model);
+  const queryArguments = [newParams, ...rest];
+
+  // execute before hook
+  await executeBeforeLifecycle(query, model, ...queryArguments);
+
+  // execute query
+  const result = await fn(...queryArguments);
+
+  // execute after hook with result and arguments
+  await executeAfterLifecycle(query, model, result, ...queryArguments);
+
+  // return result
+  return result;
+};
+
+// wraps a connectorQuery call with:
+// - param substitution
+// - lifecycle hooks
+const createQueryWithLifecycles = ({ query, model, connectorQuery }) => {
+  return withLifecycles({
+    query,
+    model,
+    fn: (...queryParameters) => connectorQuery[query](...queryParameters),
+  });
+};
+
+module.exports = { withLifecycles, createQueryWithLifecycles };

package/lib/queries/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const createQuery = require('./create-query');
+
+module.exports = {
+  createQuery,
+};

package/lib/queries/paginated-queries.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const _ = require('lodash');
+
+const createPaginatedQuery = ({ fetch, count }) => async (queryParams, ...args) => {
+  const params = _.omit(queryParams, ['page', 'pageSize']);
+  const pagination = await getPaginationInfos(queryParams, count, ...args);
+
+  Object.assign(params, paginationToQueryParams(pagination));
+  const results = await fetch(params, undefined, ...args);
+
+  return { results, pagination };
+};
+
+const createSearchPageQuery = ({ search, countSearch }) =>
+  createPaginatedQuery({ fetch: search, count: countSearch });
+
+const createFindPageQuery = ({ find, count }) => createPaginatedQuery({ fetch: find, count });
+
+const getPaginationInfos = async (queryParams, count, ...args) => {
+  const { page, pageSize, ...params } = withDefaultPagination(queryParams);
+
+  const total = await count(params, ...args);
+  return {
+    page,
+    pageSize,
+    pageCount: Math.ceil(total / pageSize),
+    total,
+  };
+};
+
+const withDefaultPagination = params => {
+  const { page = 1, pageSize = 100, ...rest } = params;
+
+  return {
+    page: parseInt(page),
+    pageSize: parseInt(pageSize),
+    ...rest,
+  };
+};
+
+const paginationToQueryParams = ({ page, pageSize }) => ({
+  _start: Math.max(page - 1, 0) * pageSize,
+  _limit: pageSize,
+});
+
+module.exports = {
+  getPaginationInfos,
+  withDefaultPagination,
+  createPaginatedQuery,
+  createFindPageQuery,
+  createSearchPageQuery,
+};

package/lib/queries/relations-counts-queries.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { prop, assoc } = require('lodash/fp');
+const { MANY_RELATIONS } = require('@akemona-org/strapi-utils').relations.constants;
+const { isVisibleAttribute } = require('@akemona-org/strapi-utils').contentTypes;
+
+const createRelationsCountsQuery = ({ model, fn, connectorQuery }) => {
+  // fetch counter map
+  const fetchCounters = async (...args) => {
+    const results = await connectorQuery.fetchRelationCounters(...args);
+    return results.reduce((map, { id, count }) => assoc(id, Number(count), map), {});
+  };
+
+  return async function (params, populate) {
+    const toCount = [];
+    const toPopulate = [];
+
+    model.associations
+      .filter((assoc) => !populate || populate.includes(assoc.alias))
+      .forEach((assoc) => {
+        if (MANY_RELATIONS.includes(assoc.nature) && isVisibleAttribute(model, assoc.alias)) {
+          return toCount.push(assoc);
+        }
+
+        toPopulate.push(assoc.alias);
+      });
+
+    const { results, pagination } = await fn(params, toPopulate);
+    const resultsIds = results.map(prop('id'));
+
+    const counters = await Promise.all(
+      toCount.map(async ({ alias }) => ({
+        field: alias,
+        counts: await fetchCounters(alias, resultsIds),
+      }))
+    );
+
+    results.forEach((entity) => {
+      counters.forEach(({ field, counts }) => {
+        entity[field] = { count: counts[entity.id] || 0 };
+      });
+    });
+
+    return {
+      results,
+      pagination,
+    };
+  };
+};
+
+module.exports = {
+  createRelationsCountsQuery,
+};

package/lib/require-connector.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const VError = require('verror');
+
+/**
+ * Requires a database connector
+ * @param {string} connector connector name
+ * @param {DatabaseManager} databaseManager reference to the database manager
+ */
+module.exports = function requireConnector(connector) {
+  if (!connector) {
+    throw new VError(
+      { name: 'ConnectorError' },
+      'initialize connector without name'
+    );
+  }
+
+  try {
+    require.resolve(`strapi-connector-${connector}`);
+  } catch (error) {
+    throw new VError(
+      { name: 'ConnectorError', cause: error },
+      'connector "%s" not found',
+      connector
+    );
+  }
+
+  try {
+    return require(`strapi-connector-${connector}`);
+  } catch (error) {
+    throw new VError(
+      { name: 'ConnectorError', cause: error },
+      'initialize connector "%s"',
+      connector
+    );
+  }
+};

package/lib/utils/lifecycles.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const _ = require('lodash');
+
+const executeLifecycle = async (lifecycle, model, ...args) => {
+  // Run registered lifecycles
+  await strapi.db.lifecycles.run(lifecycle, model, ...args);
+
+  // Run user lifecycles
+  if (_.has(model, `lifecycles.${lifecycle}`)) {
+    await model.lifecycles[lifecycle](...args);
+  }
+};
+
+const executeBeforeLifecycle = (lifecycle, model, ...args) =>
+  executeLifecycle(`before${_.upperFirst(lifecycle)}`, model, ...args);
+
+const executeAfterLifecycle = (lifecycle, model, ...args) =>
+  executeLifecycle(`after${_.upperFirst(lifecycle)}`, model, ...args);
+
+module.exports = {
+  executeBeforeLifecycle,
+  executeAfterLifecycle,
+};

package/lib/utils/primary-key.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * If exists, rename the key "id" by the primary key name of the model ("_id" by default for mongoose).
+ */
+const replaceIdByPrimaryKey = (params, model) => {
+  const newParams = { ...params };
+  if (_.has(params, 'id')) {
+    delete newParams.id;
+    newParams[model.primaryKey] = params[model.primaryKey] || params.id;
+  }
+  return newParams;
+};
+
+module.exports = {
+  replaceIdByPrimaryKey,
+};

package/lib/validation/check-duplicated-table-names.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const _ = require('lodash');
+
+const createErrorMessage = (
+  modelA,
+  modelB
+) => `Duplicated collection name: \`${modelA.model.collectionName}\`.
+The same collection name can't be used for two different models.
+First found in ${modelA.origin} \`${modelA.apiOrPluginName}\`, model \`${modelA.modelName}\`.
+Second found in ${modelB.origin} \`${modelB.apiOrPluginName}\`, model \`${modelB.modelName}\`.`;
+
+// Check if all collection names are unique
+const checkDuplicatedTableNames = ({ strapi }) => {
+  const modelsWithInfo = [];
+  _.forIn(strapi.admin.models, (model, modelName) => {
+    modelsWithInfo.push({
+      origin: 'Strapi internal',
+      model,
+      apiOrPluginName: 'admin',
+      modelName,
+    });
+  });
+
+  _.forIn(strapi.api, (api, apiName) => {
+    _.forIn(api.models, (model, modelName) => {
+      modelsWithInfo.push({
+        origin: 'API',
+        model,
+        apiOrPluginName: apiName,
+        modelName,
+      });
+    });
+  });
+
+  _.forIn(strapi.plugins, (plugin, pluginName) => {
+    _.forIn(plugin.models, (model, modelName) => {
+      modelsWithInfo.push({
+        origin: 'Plugin',
+        model,
+        apiOrPluginName: pluginName,
+        modelName,
+      });
+    });
+  });
+
+  modelsWithInfo.forEach(modelA => {
+    const similarModelFound = modelsWithInfo.find(
+      modelB =>
+        modelB.model.collectionName === modelA.model.collectionName &&
+        modelB.model.uid !== modelA.model.uid
+    );
+
+    if (similarModelFound) {
+      throw new Error(createErrorMessage(modelA, similarModelFound));
+    }
+  });
+};
+
+module.exports = checkDuplicatedTableNames;

package/lib/validation/check-reserved-names.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const _ = require('lodash');
+const constants = require('../constants');
+
+class ModelError extends Error {
+  constructor(message) {
+    super(message);
+    this.stack = null;
+  }
+}
+
+const checkReservedAttributeNames = (model, { manager }) => {
+  const reservedNames = [...constants.RESERVED_ATTRIBUTE_NAMES];
+
+  if (_.has(model, 'options.timestamps')) {
+    const [connectorCreatedAt, connectorUpdatedAt] = manager.connectors.getByConnection(
+      model.connection
+    ).defaultTimestamps;
+
+    if (Array.isArray(model.options.timestamps)) {
+      const [
+        createdAtAttribute = connectorCreatedAt,
+        updatedAtAttribute = connectorUpdatedAt,
+      ] = model.options.timestamps;
+
+      reservedNames.push(createdAtAttribute, updatedAtAttribute);
+    } else {
+      reservedNames.push(connectorCreatedAt, connectorUpdatedAt);
+    }
+  }
+
+  const usedReservedAttributeNames = _.intersection(Object.keys(model.attributes), reservedNames);
+
+  if (usedReservedAttributeNames.length > 0) {
+    throw new ModelError(
+      `Model "${
+        model.modelName
+      }" is using reserved attribute names "${usedReservedAttributeNames.join(
+        ', '
+      )}".\n-> Make sure you are not using a reserved name or overriding the defined timestamp attributes.`
+    );
+  }
+};
+
+const checkReservedModelName = model => {
+  if (constants.RESERVED_MODEL_NAMES.includes(model.modelName)) {
+    throw new ModelError(
+      `"${model.modelName}" is a reserved model name. You need to rename your model and the files associated with it.`
+    );
+  }
+};
+
+const getModelsFrom = source => _.flatMap(source, iteratee => _.values(iteratee.models));
+
+/**
+ * Checks that there are no model using reserved names (content type, component, attributes)
+ */
+module.exports = ({ strapi, manager }) => {
+  [...getModelsFrom(strapi.api), ...getModelsFrom(strapi.plugins)].forEach(model => {
+    checkReservedModelName(model);
+    checkReservedAttributeNames(model, { manager });
+  });
+};

package/lib/validation/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const checkDuplicatedTableNames = require('./check-duplicated-table-names');
+const checkReservedNames = require('./check-reserved-names');
+
+const validateModelSchemas = ({ strapi, manager }) => {
+  checkDuplicatedTableNames({ strapi, manager });
+  checkReservedNames({ strapi, manager });
+};
+
+module.exports = {
+  validateModelSchemas,
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@akemona-org/strapi-database",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "3.7.0",
+  "description": "Strapi's database layer",
+  "homepage": "https://strapi.akemona.com",
+  "main": "./lib/index.js",
+  "scripts": {
+    "test": "echo \"no tests yet\""
+  },
+  "directories": {
+    "lib": "./lib"
+  },
+  "author": {
+    "name": "Akemona team",
+    "email": "strapi@akemona.com",
+    "url": "https://strapi.akemona.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/akemona/strapi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/akemona/strapi/issues"
+  },
+  "engines": {
+    "node": ">=10.16.0 <=14.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@akemona-org/strapi-utils": "3.7.0",
+    "debug": "4.3.1",
+    "lodash": "4.17.21",
+    "p-map": "4.0.0",
+    "verror": "^1.10.0"
+  },
+  "gitHead": "129a8d6191b55810fd66448dcc47fee829df986c"
+}