@strapi/database 4.25.19 → 4.25.20

package/dist/index.mjs

@@ -28,6 +28,9 @@ class Dialect {
   }
   initialize() {
   }
+  getTables() {
+    throw new Error("getTables not implemented for this dialect");
+  }
   getSqlType(type) {
     return type;
   }
@@ -983,7 +986,7 @@ const getDialect = (db) => {
   const dialect = new constructor(db, dialectName);
   return dialect;
 };
-const debug$1 = createDebug("strapi::database");
+const debug$2 = createDebug("strapi::database");
 const createSchemaBuilder = (db) => {
   const helpers2 = createHelpers(db);
   return {
@@ -1009,12 +1012,12 @@ const createSchemaBuilder = (db) => {
      */
     async createTables(tables, trx) {
       for (const table of tables) {
-        debug$1(`Creating table: ${table.name}`);
+        debug$2(`Creating table: ${table.name}`);
         const schemaBuilder = this.getSchemaBuilder(trx);
         await helpers2.createTable(schemaBuilder, table);
       }
       for (const table of tables) {
-        debug$1(`Creating table foreign keys: ${table.name}`);
+        debug$2(`Creating table foreign keys: ${table.name}`);
         const schemaBuilder = this.getSchemaBuilder(trx);
         await helpers2.createTableForeignKeys(schemaBuilder, table);
       }
@@ -1045,18 +1048,18 @@ const createSchemaBuilder = (db) => {
         await this.createTables(schemaDiff.tables.added, trx);
         if (forceMigration) {
           for (const table of schemaDiff.tables.removed) {
-            debug$1(`Removing table foreign keys: ${table.name}`);
+            debug$2(`Removing table foreign keys: ${table.name}`);
             const schemaBuilder = this.getSchemaBuilder(trx);
             await helpers2.dropTableForeignKeys(schemaBuilder, table);
           }
           for (const table of schemaDiff.tables.removed) {
-            debug$1(`Removing table: ${table.name}`);
+            debug$2(`Removing table: ${table.name}`);
             const schemaBuilder = this.getSchemaBuilder(trx);
             await helpers2.dropTable(schemaBuilder, table);
           }
         }
         for (const table of schemaDiff.tables.updated) {
-          debug$1(`Updating table: ${table.name}`);
+          debug$2(`Updating table: ${table.name}`);
           const schemaBuilder = this.getSchemaBuilder(trx);
           await helpers2.alterTable(schemaBuilder, table);
         }
@@ -1152,27 +1155,27 @@ const createHelpers = (db) => {
   const alterTable = async (schemaBuilder, table) => {
     await schemaBuilder.alterTable(table.name, (tableBuilder) => {
       for (const removedIndex of table.indexes.removed) {
-        debug$1(`Dropping index ${removedIndex.name}`);
+        debug$2(`Dropping index ${removedIndex.name}`);
         dropIndex(tableBuilder, removedIndex);
       }
       for (const updateddIndex of table.indexes.updated) {
-        debug$1(`Dropping updated index ${updateddIndex.name}`);
+        debug$2(`Dropping updated index ${updateddIndex.name}`);
         dropIndex(tableBuilder, updateddIndex.object);
       }
       for (const removedForeignKey of table.foreignKeys.removed) {
-        debug$1(`Dropping foreign key ${removedForeignKey.name}`);
+        debug$2(`Dropping foreign key ${removedForeignKey.name}`);
         dropForeignKey(tableBuilder, removedForeignKey);
       }
       for (const updatedForeignKey of table.foreignKeys.updated) {
-        debug$1(`Dropping updated foreign key ${updatedForeignKey.name}`);
+        debug$2(`Dropping updated foreign key ${updatedForeignKey.name}`);
         dropForeignKey(tableBuilder, updatedForeignKey.object);
       }
       for (const removedColumn of table.columns.removed) {
-        debug$1(`Dropping column ${removedColumn.name}`);
+        debug$2(`Dropping column ${removedColumn.name}`);
         dropColumn(tableBuilder, removedColumn);
       }
       for (const updatedColumn of table.columns.updated) {
-        debug$1(`Updating column ${updatedColumn.name}`);
+        debug$2(`Updating column ${updatedColumn.name}`);
         const { object } = updatedColumn;
         if (object.type === "increments") {
           createColumn2(tableBuilder, { ...object, type: "integer" }).alter();
@@ -1181,15 +1184,15 @@ const createHelpers = (db) => {
         }
       }
       for (const updatedForeignKey of table.foreignKeys.updated) {
-        debug$1(`Recreating updated foreign key ${updatedForeignKey.name}`);
+        debug$2(`Recreating updated foreign key ${updatedForeignKey.name}`);
         createForeignKey(tableBuilder, updatedForeignKey.object);
       }
       for (const updatedIndex of table.indexes.updated) {
-        debug$1(`Recreating updated index ${updatedIndex.name}`);
+        debug$2(`Recreating updated index ${updatedIndex.name}`);
         createIndex(tableBuilder, updatedIndex.object);
       }
       for (const addedColumn of table.columns.added) {
-        debug$1(`Creating column ${addedColumn.name}`);
+        debug$2(`Creating column ${addedColumn.name}`);
         if (addedColumn.type === "increments" && !db.dialect.canAddIncrements()) {
           tableBuilder.integer(addedColumn.name).unsigned();
           tableBuilder.primary([addedColumn.name]);
@@ -1198,11 +1201,11 @@ const createHelpers = (db) => {
         }
       }
       for (const addedForeignKey of table.foreignKeys.added) {
-        debug$1(`Creating foreign keys ${addedForeignKey.name}`);
+        debug$2(`Creating foreign keys ${addedForeignKey.name}`);
         createForeignKey(tableBuilder, addedForeignKey);
       }
       for (const addedIndex of table.indexes.added) {
-        debug$1(`Creating index ${addedIndex.name}`);
+        debug$2(`Creating index ${addedIndex.name}`);
         createIndex(tableBuilder, addedIndex);
       }
     });
@@ -1788,7 +1791,7 @@ const metadataToSchema = (metadata) => {
   });
   return schema;
 };
-const debug = createDebug("strapi::database");
+const debug$1 = createDebug("strapi::database");
 const createSchemaProvider = (db) => {
   const schema = metadataToSchema(db.metadata);
   return {
@@ -1799,7 +1802,7 @@ const createSchemaProvider = (db) => {
      * Drops the database schema
      */
     async drop() {
-      debug("Dropping database schema");
+      debug$1("Dropping database schema");
       const DBSchema = await db.dialect.schemaInspector.getSchema();
       await this.builder.dropSchema(DBSchema);
     },
@@ -1807,47 +1810,49 @@ const createSchemaProvider = (db) => {
      * Creates the database schema
      */
     async create() {
-      debug("Created database schema");
+      debug$1("Created database schema");
       await this.builder.createSchema(schema);
     },
     /**
      * Resets the database schema
      */
     async reset() {
-      debug("Resetting database schema");
+      debug$1("Resetting database schema");
       await this.drop();
       await this.create();
     },
     async syncSchema() {
-      debug("Synchronizing database schema");
+      debug$1("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);
+      return status;
     },
     // 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");
+        debug$1("Found migrations to run");
         await db.migrations.up();
         return this.syncSchema();
       }
       const oldSchema = await this.schemaStorage.read();
       if (!oldSchema) {
-        debug("Schema not persisted yet");
+        debug$1("Schema not persisted yet");
         return this.syncSchema();
       }
       const { hash: oldHash } = oldSchema;
       const hash = await this.schemaStorage.hashSchema(schema);
       if (oldHash !== hash) {
-        debug("Schema changed");
+        debug$1("Schema changed");
         return this.syncSchema();
       }
-      debug("Schema unchanged");
+      debug$1("Schema unchanged");
+      return "UNCHANGED";
     }
   };
 };
@@ -5955,6 +5960,7 @@ const createLifecyclesProvider = (db) => {
     timestampsLifecyclesSubscriber,
     modelsLifecyclesSubscriber
   ];
+  let isLifecycleHooksDisabled = false;
   return {
     subscribe(subscriber) {
       strict(
@@ -5964,6 +5970,12 @@ const createLifecyclesProvider = (db) => {
       subscribers.push(subscriber);
       return () => subscribers.splice(subscribers.indexOf(subscriber), 1);
     },
+    disable() {
+      isLifecycleHooksDisabled = true;
+    },
+    enable() {
+      isLifecycleHooksDisabled = false;
+    },
     clear() {
       subscribers = [];
     },
@@ -5983,6 +5995,8 @@ const createLifecyclesProvider = (db) => {
      * @param {Map<any, any>} states
      */
     async run(action, uid, properties, states = /* @__PURE__ */ new Map()) {
+      if (isLifecycleHooksDisabled)
+        return states;
       for (let i = 0; i < subscribers.length; i += 1) {
         const subscriber = subscribers[i];
         if (typeof subscriber === "function") {
@@ -6048,6 +6062,61 @@ const createConnection = (config) => {
   }
   return knex(knexConfig);
 };
+const debug = createDebug("strapi::database");
+const isMorphRelationWithPivot = (attribute, pivot) => {
+  return attribute.type === "relation" && "relation" in attribute && "joinTable" in attribute && "target" in attribute && "name" in attribute.joinTable && "pivotColumns" in attribute.joinTable && attribute.joinTable.pivotColumns.includes(pivot);
+};
+const filterMorphRelationalAttributes = (attributes, pivot) => {
+  return Object.values(attributes).filter(
+    (attribute) => isMorphRelationWithPivot(attribute, pivot)
+  );
+};
+const removeOrphanMorphType = async (db, { pivot }) => {
+  debug(`Removing orphaned morph type: ${JSON.stringify(pivot)}`);
+  const mdValues = db.metadata.values();
+  for (const model of mdValues) {
+    const attributes = filterMorphRelationalAttributes(model.attributes || {}, pivot);
+    for (const attribute of attributes) {
+      const joinTableName = attribute.joinTable.name;
+      const morphTypes = await db.connection(joinTableName).distinct(pivot).pluck(pivot);
+      for (const morphType of morphTypes) {
+        const deleteComponentType = await (async () => {
+          try {
+            return !db.metadata.get(morphType);
+          } catch {
+            debug(`Metadata for morph type "${morphType}" in table "${joinTableName}" not found`);
+            return true;
+          }
+        })();
+        if (deleteComponentType) {
+          debug(`Removing invalid morph type "${morphType}" from table "${joinTableName}".`);
+          try {
+            await db.connection(joinTableName).where(pivot, morphType).del();
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            debug(
+              `Failed to remove invalid morph type "${morphType}" from table "${joinTableName}": ${errorMessage}`
+            );
+          }
+        }
+      }
+    }
+  }
+};
+const asyncCurry = (fn) => {
+  const curried = (...args) => {
+    if (args.length >= fn.length) {
+      return fn(...args);
+    }
+    return (...moreArgs) => curried(...args, ...moreArgs);
+  };
+  return curried;
+};
+const createRepairManager = (db) => {
+  return {
+    removeOrphanMorphType: asyncCurry(removeOrphanMorphType)(db)
+  };
+};
 const transformAttribute = (attribute) => {
   switch (attribute.type) {
     case "media": {
@@ -6145,6 +6214,7 @@ class Database {
   migrations;
   lifecycles;
   entityManager;
+  repair;
   static transformContentTypes = transformContentTypes;
   static async init(config) {
     const db = new Database(config);
@@ -6169,6 +6239,7 @@ class Database {
     this.migrations = createMigrationsProvider(this);
     this.lifecycles = createLifecyclesProvider(this);
     this.entityManager = createEntityManager(this);
+    this.repair = createRepairManager(this);
   }
   query(uid) {
     if (!this.metadata.has(uid)) {