@strapi/database 4.14.4 → 4.14.6

package/lib/schema/diff.js

@@ -1,399 +0,0 @@
-'use strict';
-
-const _ = require('lodash/fp');
-
-const RESERVED_TABLE_NAMES = ['strapi_migrations', 'strapi_database_schema'];
-
-const statuses = {
-  CHANGED: 'CHANGED',
-  UNCHANGED: 'UNCHANGED',
-};
-
-// NOTE:We could move the schema to use maps of tables & columns instead of arrays to make it easier to diff
-// => this will make the creation a bit more complicated (ordering, Object.values(tables | columns)) -> not a big pbl
-
-const helpers = {
-  hasTable(schema, tableName) {
-    return schema.tables.findIndex((table) => table.name === tableName) !== -1;
-  },
-  findTable(schema, tableName) {
-    return schema.tables.find((table) => table.name === tableName);
-  },
-
-  hasColumn(table, columnName) {
-    return table.columns.findIndex((column) => column.name === columnName) !== -1;
-  },
-  findColumn(table, columnName) {
-    return table.columns.find((column) => column.name === columnName);
-  },
-
-  hasIndex(table, columnName) {
-    return table.indexes.findIndex((column) => column.name === columnName) !== -1;
-  },
-  findIndex(table, columnName) {
-    return table.indexes.find((column) => column.name === columnName);
-  },
-
-  hasForeignKey(table, columnName) {
-    return table.foreignKeys.findIndex((column) => column.name === columnName) !== -1;
-  },
-  findForeignKey(table, columnName) {
-    return table.foreignKeys.find((column) => column.name === columnName);
-  },
-};
-
-module.exports = (db) => {
-  const hasChangedStatus = (diff) => diff.status === statuses.CHANGED;
-
-  /**
-   * Compares two indexes info
-   * @param {Object} oldIndex - index info read from DB
-   * @param {Object} index - newly generate index info
-   */
-  const diffIndexes = (oldIndex, index) => {
-    const changes = [];
-
-    if (!_.isEqual(oldIndex.columns, index.columns)) {
-      changes.push('columns');
-    }
-
-    if (_.toLower(oldIndex.type) !== _.toLower(index.type)) {
-      changes.push('type');
-    }
-
-    return {
-      status: changes.length > 0 ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        name: index.name,
-        object: index,
-      },
-    };
-  };
-
-  /**
-   * Compares two foreign keys info
-   * @param {Object} oldForeignKey - foreignKey info read from DB
-   * @param {Object} foreignKey - newly generate foreignKey info
-   */
-  const diffForeignKeys = (oldForeignKey, foreignKey) => {
-    const changes = [];
-
-    if (_.difference(oldForeignKey.columns, foreignKey.columns).length > 0) {
-      changes.push('columns');
-    }
-
-    if (_.difference(oldForeignKey.referencedColumns, foreignKey.referencedColumns).length > 0) {
-      changes.push('referencedColumns');
-    }
-
-    if (oldForeignKey.referencedTable !== foreignKey.referencedTable) {
-      changes.push('referencedTable');
-    }
-
-    if (_.isNil(oldForeignKey.onDelete) || _.toUpper(oldForeignKey.onDelete) === 'NO ACTION') {
-      if (!_.isNil(foreignKey.onDelete) && _.toUpper(oldForeignKey.onDelete) !== 'NO ACTION') {
-        changes.push('onDelete');
-      }
-    } else if (_.toUpper(oldForeignKey.onDelete) !== _.toUpper(foreignKey.onDelete)) {
-      changes.push('onDelete');
-    }
-
-    if (_.isNil(oldForeignKey.onUpdate) || _.toUpper(oldForeignKey.onUpdate) === 'NO ACTION') {
-      if (!_.isNil(foreignKey.onUpdate) && _.toUpper(oldForeignKey.onUpdate) !== 'NO ACTION') {
-        changes.push('onUpdate');
-      }
-    } else if (_.toUpper(oldForeignKey.onUpdate) !== _.toUpper(foreignKey.onUpdate)) {
-      changes.push('onUpdate');
-    }
-
-    return {
-      status: changes.length > 0 ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        name: foreignKey.name,
-        object: foreignKey,
-      },
-    };
-  };
-
-  const diffDefault = (oldColumn, column) => {
-    const oldDefaultTo = oldColumn.defaultTo;
-    const { defaultTo } = column;
-
-    if (oldDefaultTo === null || _.toLower(oldDefaultTo) === 'null') {
-      return _.isNil(defaultTo) || _.toLower(defaultTo) === 'null';
-    }
-
-    return (
-      _.toLower(oldDefaultTo) === _.toLower(column.defaultTo) ||
-      _.toLower(oldDefaultTo) === _.toLower(`'${column.defaultTo}'`)
-    );
-  };
-
-  /**
-   * Compares two columns info
-   * @param {Object} oldColumn - column info read from DB
-   * @param {Object} column - newly generate column info
-   */
-  const diffColumns = (oldColumn, column) => {
-    const changes = [];
-
-    const isIgnoredType = ['increments'].includes(column.type);
-    const oldType = oldColumn.type;
-    const type = db.dialect.getSqlType(column.type);
-
-    if (oldType !== type && !isIgnoredType) {
-      changes.push('type');
-    }
-
-    // NOTE: compare args at some point and split them into specific properties instead
-
-    if (oldColumn.notNullable !== column.notNullable) {
-      changes.push('notNullable');
-    }
-
-    const hasSameDefault = diffDefault(oldColumn, column);
-    if (!hasSameDefault) {
-      changes.push('defaultTo');
-    }
-
-    if (oldColumn.unsigned !== column.unsigned && db.dialect.supportsUnsigned()) {
-      changes.push('unsigned');
-    }
-
-    return {
-      status: changes.length > 0 ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        name: column.name,
-        object: column,
-      },
-    };
-  };
-
-  const diffTableColumns = (srcTable, destTable) => {
-    const addedColumns = [];
-    const updatedColumns = [];
-    const unchangedColumns = [];
-    const removedColumns = [];
-
-    for (const destColumn of destTable.columns) {
-      if (!helpers.hasColumn(srcTable, destColumn.name)) {
-        addedColumns.push(destColumn);
-        continue;
-      }
-
-      const srcColumn = helpers.findColumn(srcTable, destColumn.name);
-      const { status, diff } = diffColumns(srcColumn, destColumn);
-
-      if (status === statuses.CHANGED) {
-        updatedColumns.push(diff);
-      } else {
-        unchangedColumns.push(srcColumn);
-      }
-    }
-
-    for (const srcColumn of srcTable.columns) {
-      if (!helpers.hasColumn(destTable, srcColumn.name)) {
-        removedColumns.push(srcColumn);
-      }
-    }
-
-    const hasChanged = [addedColumns, updatedColumns, removedColumns].some((arr) => arr.length > 0);
-
-    return {
-      status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        added: addedColumns,
-        updated: updatedColumns,
-        unchanged: unchangedColumns,
-        removed: removedColumns,
-      },
-    };
-  };
-
-  const diffTableIndexes = (srcTable, destTable) => {
-    const addedIndexes = [];
-    const updatedIndexes = [];
-    const unchangedIndexes = [];
-    const removedIndexes = [];
-
-    for (const destIndex of destTable.indexes) {
-      if (helpers.hasIndex(srcTable, destIndex.name)) {
-        const srcIndex = helpers.findIndex(srcTable, destIndex.name);
-        const { status, diff } = diffIndexes(srcIndex, destIndex);
-
-        if (status === statuses.CHANGED) {
-          updatedIndexes.push(diff);
-        } else {
-          unchangedIndexes.push(srcIndex);
-        }
-      } else {
-        addedIndexes.push(destIndex);
-      }
-    }
-
-    for (const srcIndex of srcTable.indexes) {
-      if (!helpers.hasIndex(destTable, srcIndex.name)) {
-        removedIndexes.push(srcIndex);
-      }
-    }
-
-    const hasChanged = [addedIndexes, updatedIndexes, removedIndexes].some((arr) => arr.length > 0);
-
-    return {
-      status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        added: addedIndexes,
-        updated: updatedIndexes,
-        unchanged: unchangedIndexes,
-        removed: removedIndexes,
-      },
-    };
-  };
-
-  const diffTableForeignKeys = (srcTable, destTable) => {
-    const addedForeignKeys = [];
-    const updatedForeignKeys = [];
-    const unchangedForeignKeys = [];
-    const removedForeignKeys = [];
-
-    if (!db.dialect.usesForeignKeys()) {
-      return {
-        status: statuses.UNCHANGED,
-        diff: {
-          added: addedForeignKeys,
-          updated: updatedForeignKeys,
-          unchanged: unchangedForeignKeys,
-          removed: removedForeignKeys,
-        },
-      };
-    }
-
-    for (const destForeignKey of destTable.foreignKeys) {
-      if (helpers.hasForeignKey(srcTable, destForeignKey.name)) {
-        const srcForeignKey = helpers.findForeignKey(srcTable, destForeignKey.name);
-        const { status, diff } = diffForeignKeys(srcForeignKey, destForeignKey);
-
-        if (status === statuses.CHANGED) {
-          updatedForeignKeys.push(diff);
-        } else {
-          unchangedForeignKeys.push(srcForeignKey);
-        }
-      } else {
-        addedForeignKeys.push(destForeignKey);
-      }
-    }
-
-    for (const srcForeignKey of srcTable.foreignKeys) {
-      if (!helpers.hasForeignKey(destTable, srcForeignKey.name)) {
-        removedForeignKeys.push(srcForeignKey);
-      }
-    }
-
-    const hasChanged = [addedForeignKeys, updatedForeignKeys, removedForeignKeys].some(
-      (arr) => arr.length > 0
-    );
-
-    return {
-      status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        added: addedForeignKeys,
-        updated: updatedForeignKeys,
-        unchanged: unchangedForeignKeys,
-        removed: removedForeignKeys,
-      },
-    };
-  };
-
-  const diffTables = (srcTable, destTable) => {
-    const columnsDiff = diffTableColumns(srcTable, destTable);
-    const indexesDiff = diffTableIndexes(srcTable, destTable);
-    const foreignKeysDiff = diffTableForeignKeys(srcTable, destTable);
-
-    const hasChanged = [columnsDiff, indexesDiff, foreignKeysDiff].some(hasChangedStatus);
-
-    return {
-      status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        name: srcTable.name,
-        indexes: indexesDiff.diff,
-        foreignKeys: foreignKeysDiff.diff,
-        columns: columnsDiff.diff,
-      },
-    };
-  };
-
-  const diffSchemas = async (srcSchema, destSchema) => {
-    const addedTables = [];
-    const updatedTables = [];
-    const unchangedTables = [];
-    const removedTables = [];
-
-    for (const destTable of destSchema.tables) {
-      if (helpers.hasTable(srcSchema, destTable.name)) {
-        const srcTable = helpers.findTable(srcSchema, destTable.name);
-
-        const { status, diff } = diffTables(srcTable, destTable);
-
-        if (status === statuses.CHANGED) {
-          updatedTables.push(diff);
-        } else {
-          unchangedTables.push(srcTable);
-        }
-      } else {
-        addedTables.push(destTable);
-      }
-    }
-
-    const parsePersistedTable = (persistedTable) => {
-      if (typeof persistedTable === 'string') {
-        return persistedTable;
-      }
-      return persistedTable.name;
-    };
-
-    const persistedTables = helpers.hasTable(srcSchema, 'strapi_core_store_settings')
-      ? (await strapi.store.get({
-          type: 'core',
-          key: 'persisted_tables',
-        })) ?? []
-      : [];
-
-    const reservedTables = [...RESERVED_TABLE_NAMES, ...persistedTables.map(parsePersistedTable)];
-
-    for (const srcTable of srcSchema.tables) {
-      if (!helpers.hasTable(destSchema, srcTable.name) && !reservedTables.includes(srcTable.name)) {
-        const dependencies = persistedTables
-          .filter((table) => {
-            const dependsOn = table?.dependsOn;
-            if (!_.isArray(dependsOn)) return;
-            return dependsOn.some((table) => table.name === srcTable.name);
-          })
-          .map((dependsOnTable) => {
-            return srcSchema.tables.find((srcTable) => srcTable.name === dependsOnTable.name);
-          })
-          // In case the table is not found, filter undefined values
-          .filter((table) => !_.isNil(table));
-
-        removedTables.push(srcTable, ...dependencies);
-      }
-    }
-
-    const hasChanged = [addedTables, updatedTables, removedTables].some((arr) => arr.length > 0);
-
-    return {
-      status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
-      diff: {
-        tables: {
-          added: addedTables,
-          updated: updatedTables,
-          unchanged: unchangedTables,
-          removed: removedTables,
-        },
-      },
-    };
-  };
-
-  return {
-    diff: diffSchemas,
-  };
-};

package/lib/schema/index.d.ts

@@ -1,49 +0,0 @@
-import { Database } from '../';
-import { Action } from '../lifecycles';
-
-type Type =
-  | 'string'
-  | 'text'
-  | 'richtext'
-  | 'json'
-  | 'enumeration'
-  | 'password'
-  | 'email'
-  | 'integer'
-  | 'biginteger'
-  | 'float'
-  | 'decimal'
-  | 'date'
-  | 'time'
-  | 'datetime'
-  | 'timestamp'
-  | 'boolean'
-  | 'relation';
-
-export interface Attribute {
-  type: Type;
-}
-
-export interface Model {
-  uid: string;
-  tableName: string;
-  attributes: {
-    id: {
-      type: 'increments';
-    };
-    [k: string]: Attribute;
-  };
-  lifecycles?: {
-    [k in Action]: () => void;
-  };
-}
-
-export interface SchemaProvider {
-  sync(): Promise<void>;
-  syncSchema(): Promise<void>;
-  reset(): Promise<void>;
-  create(): Promise<void>;
-  drop(): Promise<void>;
-}
-
-export default function (db: Database): SchemaProvider;

package/lib/schema/index.js

@@ -1,94 +0,0 @@
-'use strict';
-
-const debug = require('debug')('strapi::database');
-
-const createSchemaBuilder = require('./builder');
-const createSchemaDiff = require('./diff');
-const createSchemaStorage = require('./storage');
-const { metadataToSchema } = require('./schema');
-
-/**
- * @type {import('.').default}
- */
-const createSchemaProvider = (db) => {
-  const schema = metadataToSchema(db.metadata);
-
-  return {
-    builder: createSchemaBuilder(db),
-    schemaDiff: createSchemaDiff(db),
-    schemaStorage: createSchemaStorage(db),
-
-    /**
-     * Drops the database schema
-     */
-    async drop() {
-      debug('Dropping database schema');
-
-      const DBSchema = await db.dialect.schemaInspector.getSchema();
-      await this.builder.dropSchema(DBSchema);
-    },
-
-    /**
-     * Creates the database schema
-     */
-    async create() {
-      debug('Created database schema');
-      await this.builder.createSchema(schema);
-    },
-
-    /**
-     * Resets the database schema
-     */
-    async reset() {
-      debug('Resetting database schema');
-      await this.drop();
-      await this.create();
-    },
-
-    async syncSchema() {
-      debug('Synchronizing database schema');
-
-      const DBSchema = await db.dialect.schemaInspector.getSchema();
-
-      const { status, diff } = await this.schemaDiff.diff(DBSchema, schema);
-
-      if (status === 'CHANGED') {
-        await this.builder.updateSchema(diff);
-      }
-
-      await this.schemaStorage.add(schema);
-    },
-
-    // TODO: support options to migrate softly or forcefully
-    // TODO: support option to disable auto migration & run a CLI command instead to avoid doing it at startup
-    // TODO: Allow keeping extra indexes / extra tables / extra columns (globally or on a per table basis)
-    async sync() {
-      if (await db.migrations.shouldRun()) {
-        debug('Found migrations to run');
-        await db.migrations.up();
-
-        return this.syncSchema();
-      }
-
-      const oldSchema = await this.schemaStorage.read();
-
-      if (!oldSchema) {
-        debug('Schema not persisted yet');
-        return this.syncSchema();
-      }
-
-      const { hash: oldHash } = oldSchema;
-      const hash = await this.schemaStorage.hashSchema(schema);
-
-      if (oldHash !== hash) {
-        debug('Schema changed');
-
-        return this.syncSchema();
-      }
-
-      debug('Schema unchanged');
-    },
-  };
-};
-
-module.exports = createSchemaProvider;