@strapi/database 5.0.0-rc.0 → 5.0.0-rc.2

package/dist/index.js

@@ -1388,27 +1388,28 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTableColumns = (srcTable, destTable) => {
+  const diffTableColumns = (diffCtx) => {
+    const { databaseTable, userSchemaTable, previousTable } = diffCtx;
     const addedColumns = [];
     const updatedColumns = [];
     const unchangedColumns = [];
     const removedColumns = [];
-    for (const destColumn of destTable.columns) {
-      const srcColumn = helpers.findColumn(srcTable, destColumn.name);
-      if (srcColumn) {
-        const { status, diff } = diffColumns(srcColumn, destColumn);
+    for (const userSchemaColumn of userSchemaTable.columns) {
+      const databaseColumn = helpers.findColumn(databaseTable, userSchemaColumn.name);
+      if (databaseColumn) {
+        const { status, diff } = diffColumns(databaseColumn, userSchemaColumn);
         if (status === statuses.CHANGED) {
           updatedColumns.push(diff);
         } else {
-          unchangedColumns.push(srcColumn);
+          unchangedColumns.push(databaseColumn);
         }
       } else {
-        addedColumns.push(destColumn);
+        addedColumns.push(userSchemaColumn);
       }
     }
-    for (const srcColumn of srcTable.columns) {
-      if (!helpers.hasColumn(destTable, srcColumn.name)) {
-        removedColumns.push(srcColumn);
+    for (const databaseColumn of databaseTable.columns) {
+      if (!helpers.hasColumn(userSchemaTable, databaseColumn.name) && previousTable && helpers.hasColumn(previousTable, databaseColumn.name)) {
+        removedColumns.push(databaseColumn);
       }
     }
     const hasChanged = [addedColumns, updatedColumns, removedColumns].some((arr) => arr.length > 0);
@@ -1422,27 +1423,28 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTableIndexes = (srcTable, destTable) => {
+  const diffTableIndexes = (diffCtx) => {
+    const { databaseTable, userSchemaTable, previousTable } = diffCtx;
     const addedIndexes = [];
     const updatedIndexes = [];
     const unchangedIndexes = [];
     const removedIndexes = [];
-    for (const destIndex of destTable.indexes) {
-      const srcIndex = helpers.findIndex(srcTable, destIndex.name);
-      if (srcIndex) {
-        const { status, diff } = diffIndexes(srcIndex, destIndex);
+    for (const userSchemaIndex of userSchemaTable.indexes) {
+      const databaseIndex = helpers.findIndex(databaseTable, userSchemaIndex.name);
+      if (databaseIndex) {
+        const { status, diff } = diffIndexes(databaseIndex, userSchemaIndex);
         if (status === statuses.CHANGED) {
           updatedIndexes.push(diff);
         } else {
-          unchangedIndexes.push(srcIndex);
+          unchangedIndexes.push(databaseIndex);
         }
       } else {
-        addedIndexes.push(destIndex);
+        addedIndexes.push(userSchemaIndex);
       }
     }
-    for (const srcIndex of srcTable.indexes) {
-      if (!helpers.hasIndex(destTable, srcIndex.name)) {
-        removedIndexes.push(srcIndex);
+    for (const databaseIndex of databaseTable.indexes) {
+      if (!helpers.hasIndex(userSchemaTable, databaseIndex.name) && previousTable && helpers.hasIndex(previousTable, databaseIndex.name)) {
+        removedIndexes.push(databaseIndex);
       }
     }
     const hasChanged = [addedIndexes, updatedIndexes, removedIndexes].some((arr) => arr.length > 0);
@@ -1456,7 +1458,8 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTableForeignKeys = (srcTable, destTable) => {
+  const diffTableForeignKeys = (diffCtx) => {
+    const { databaseTable, userSchemaTable, previousTable } = diffCtx;
     const addedForeignKeys = [];
     const updatedForeignKeys = [];
     const unchangedForeignKeys = [];
@@ -1472,22 +1475,22 @@ const createSchemaDiff = (db) => {
         }
       };
     }
-    for (const destForeignKey of destTable.foreignKeys) {
-      const srcForeignKey = helpers.findForeignKey(srcTable, destForeignKey.name);
-      if (srcForeignKey) {
-        const { status, diff } = diffForeignKeys(srcForeignKey, destForeignKey);
+    for (const userSchemaForeignKeys of userSchemaTable.foreignKeys) {
+      const databaseForeignKeys = helpers.findForeignKey(databaseTable, userSchemaForeignKeys.name);
+      if (databaseForeignKeys) {
+        const { status, diff } = diffForeignKeys(databaseForeignKeys, userSchemaForeignKeys);
         if (status === statuses.CHANGED) {
           updatedForeignKeys.push(diff);
         } else {
-          unchangedForeignKeys.push(srcForeignKey);
+          unchangedForeignKeys.push(databaseForeignKeys);
         }
       } else {
-        addedForeignKeys.push(destForeignKey);
+        addedForeignKeys.push(userSchemaForeignKeys);
       }
     }
-    for (const srcForeignKey of srcTable.foreignKeys) {
-      if (!helpers.hasForeignKey(destTable, srcForeignKey.name)) {
-        removedForeignKeys.push(srcForeignKey);
+    for (const databaseForeignKeys of databaseTable.foreignKeys) {
+      if (!helpers.hasForeignKey(userSchemaTable, databaseForeignKeys.name) && previousTable && helpers.hasForeignKey(previousTable, databaseForeignKeys.name)) {
+        removedForeignKeys.push(databaseForeignKeys);
       }
     }
     const hasChanged = [addedForeignKeys, updatedForeignKeys, removedForeignKeys].some(
@@ -1503,37 +1506,44 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTables = (srcTable, destTable) => {
-    const columnsDiff = diffTableColumns(srcTable, destTable);
-    const indexesDiff = diffTableIndexes(srcTable, destTable);
-    const foreignKeysDiff = diffTableForeignKeys(srcTable, destTable);
+  const diffTables = (diffCtx) => {
+    const { databaseTable } = diffCtx;
+    const columnsDiff = diffTableColumns(diffCtx);
+    const indexesDiff = diffTableIndexes(diffCtx);
+    const foreignKeysDiff = diffTableForeignKeys(diffCtx);
     const hasChanged = [columnsDiff, indexesDiff, foreignKeysDiff].some(hasChangedStatus);
     return {
       status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
       diff: {
-        name: srcTable.name,
+        name: databaseTable.name,
         indexes: indexesDiff.diff,
         foreignKeys: foreignKeysDiff.diff,
         columns: columnsDiff.diff
       }
     };
   };
-  const diffSchemas = async (srcSchema, destSchema) => {
+  const diffSchemas = async (schemaDiffCtx) => {
+    const { previousSchema, databaseSchema, userSchema } = schemaDiffCtx;
     const addedTables = [];
     const updatedTables = [];
     const unchangedTables = [];
     const removedTables = [];
-    for (const destTable of destSchema.tables) {
-      const srcTable = helpers.findTable(srcSchema, destTable.name);
-      if (srcTable) {
-        const { status, diff } = diffTables(srcTable, destTable);
+    for (const userSchemaTable of userSchema.tables) {
+      const databaseTable = helpers.findTable(databaseSchema, userSchemaTable.name);
+      const previousTable = previousSchema && helpers.findTable(previousSchema, userSchemaTable.name);
+      if (databaseTable) {
+        const { status, diff } = diffTables({
+          previousTable,
+          databaseTable,
+          userSchemaTable
+        });
         if (status === statuses.CHANGED) {
           updatedTables.push(diff);
         } else {
-          unchangedTables.push(srcTable);
+          unchangedTables.push(databaseTable);
         }
       } else {
-        addedTables.push(destTable);
+        addedTables.push(userSchemaTable);
       }
     }
     const parsePersistedTable = (persistedTable) => {
@@ -1542,23 +1552,34 @@ const createSchemaDiff = (db) => {
       }
       return persistedTable.name;
     };
-    const persistedTables = helpers.hasTable(srcSchema, "strapi_core_store_settings") ? await strapi.store.get({
-      type: "core",
-      key: "persisted_tables"
-    }) ?? [] : [];
+    const persistedTables = helpers.hasTable(databaseSchema, "strapi_core_store_settings") ? (
+      // TODO: replace with low level db query instead
+      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)) {
+    for (const databaseTable of databaseSchema.tables) {
+      const isInUserSchema = helpers.hasTable(userSchema, databaseTable.name);
+      const wasTracked = previousSchema && helpers.hasTable(previousSchema, databaseTable.name);
+      const isReserved = reservedTables.includes(databaseTable.name);
+      if (!isInUserSchema && !wasTracked) {
+        continue;
+      }
+      if (!isInUserSchema && wasTracked && !isReserved) {
         const dependencies = persistedTables.filter((table) => {
           const dependsOn = table?.dependsOn;
           if (!___default.default.isArray(dependsOn)) {
             return;
           }
-          return dependsOn.some((table2) => table2.name === srcTable.name);
+          return dependsOn.some((table2) => table2.name === databaseTable.name);
         }).map((dependsOnTable) => {
-          return srcSchema.tables.find((srcTable2) => srcTable2.name === dependsOnTable.name);
+          return databaseSchema.tables.find(
+            (databaseTable2) => databaseTable2.name === dependsOnTable.name
+          );
         }).filter((table) => !___default.default.isNil(table));
-        removedTables.push(srcTable, ...dependencies);
+        removedTables.push(databaseTable, ...dependencies);
       }
     }
     const hasChanged = [addedTables, updatedTables, removedTables].some((arr) => arr.length > 0);
@@ -2204,8 +2225,13 @@ const createSchemaProvider = (db) => {
     },
     async syncSchema() {
       debug$1("Synchronizing database schema");
-      const DBSchema = await db.dialect.schemaInspector.getSchema();
-      const { status, diff } = await this.schemaDiff.diff(DBSchema, this.schema);
+      const databaseSchema = await db.dialect.schemaInspector.getSchema();
+      const storedSchema = await this.schemaStorage.read();
+      const { status, diff } = await this.schemaDiff.diff({
+        previousSchema: storedSchema?.schema,
+        databaseSchema,
+        userSchema: this.schema
+      });
       if (status === "CHANGED") {
         await this.builder.updateSchema(diff);
       }