@strapi/database 4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8 → 4.9.1

package/.eslintignore

@@ -0,0 +1,2 @@
+node_modules/
+.eslintrc.js

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ['custom/back'],
+};

package/jest.config.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const baseConfig = require('../../../jest.base-config');
-const pkg = require('./package.json');
-
 module.exports = {
-  ...baseConfig,
-  displayName: (pkg.strapi && pkg.strapi.name) || pkg.name,
-  roots: [__dirname],
+  preset: '../../../jest-preset.unit.js',
 };

package/lib/dialects/index.js

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * Require our dialect-specific code
+ */
 const getDialectClass = (client) => {
   switch (client) {
     case 'postgres':
@@ -13,12 +16,34 @@ const getDialectClass = (client) => {
   }
 };
 
+/**
+ * Get the dialect of a database client
+ *
+ * @param {string} The client value from a project database configuration
+ * @returns {string} The dialect of that client
+ */
+const getDialectName = (client) => {
+  switch (client) {
+    case 'postgres':
+      return 'postgres';
+    case 'mysql':
+    case 'mysql2':
+      return 'mysql';
+    case 'sqlite':
+    case 'sqlite-legacy':
+      return 'sqlite';
+    default:
+      throw new Error(`Unknown dialect ${client}`);
+  }
+};
+
 const getDialect = (db) => {
   const { client } = db.config.connection;
+  const dialectName = getDialectName(client);
 
-  const constructor = getDialectClass(client);
+  const constructor = getDialectClass(dialectName);
   const dialect = new constructor(db);
-  dialect.client = client;
+  dialect.client = dialectName;
 
   return dialect;
 };

package/lib/entity-manager/index.js

@@ -268,9 +268,12 @@ const createEntityManager = (db) => {
         throw new Error('Nothing to insert');
       }
 
-      await this.createQueryBuilder(uid).insert(dataToInsert).execute();
+      const createdEntries = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
 
-      const result = { count: data.length };
+      const result = {
+        count: data.length,
+        ids: createdEntries.map((entry) => (typeof entry === 'object' ? entry?.id : entry)),
+      };
 
       await db.lifecycles.run('afterCreateMany', uid, { params, result }, states);
 

package/lib/schema/__tests__/schema-diff.test.js

@@ -14,9 +14,15 @@ describe('diffSchemas', () => {
     });
 
     diffSchemas = schemaDiff.diff.bind(schemaDiff);
+
+    global.strapi = {
+      store: {
+        get: () => [],
+      },
+    };
   });
 
-  test('New Table', () => {
+  test('New Table', async () => {
     const testTable = {
       name: 'my_table',
     };
@@ -29,7 +35,7 @@ describe('diffSchemas', () => {
       tables: [testTable],
     };
 
-    expect(diffSchemas(srcSchema, destSchema)).toStrictEqual({
+    expect(await diffSchemas(srcSchema, destSchema)).toStrictEqual({
       status: 'CHANGED',
       diff: {
         tables: {
@@ -42,7 +48,7 @@ describe('diffSchemas', () => {
     });
   });
 
-  test('Removed Table', () => {
+  test('Removed Table', async () => {
     const testTable = {
       name: 'my_table',
     };
@@ -55,7 +61,7 @@ describe('diffSchemas', () => {
       tables: [],
     };
 
-    expect(diffSchemas(srcSchema, destSchema)).toStrictEqual({
+    expect(await diffSchemas(srcSchema, destSchema)).toStrictEqual({
       status: 'CHANGED',
       diff: {
         tables: {
@@ -68,7 +74,7 @@ describe('diffSchemas', () => {
     });
   });
 
-  test('Unchanged Table', () => {
+  test('Unchanged Table', async () => {
     const testTable = {
       name: 'my_table',
       columns: [],
@@ -84,7 +90,7 @@ describe('diffSchemas', () => {
       tables: [testTable],
     };
 
-    expect(diffSchemas(srcSchema, destSchema)).toStrictEqual({
+    expect(await diffSchemas(srcSchema, destSchema)).toStrictEqual({
       status: 'UNCHANGED',
       diff: {
         tables: {
@@ -98,7 +104,7 @@ describe('diffSchemas', () => {
   });
 
   describe('Changed table', () => {
-    test('added column', () => {
+    test('added column', async () => {
       const srcSchema = {
         tables: [
           {
@@ -125,7 +131,7 @@ describe('diffSchemas', () => {
         ],
       };
 
-      expect(diffSchemas(srcSchema, destSchema)).toStrictEqual({
+      expect(await diffSchemas(srcSchema, destSchema)).toStrictEqual({
         status: 'CHANGED',
         diff: {
           tables: {
@@ -178,4 +184,48 @@ describe('diffSchemas', () => {
     test.todo('unchanged foreign key');
     test.todo('removed foreign key');
   });
+
+  test('With persisted DB tables', async () => {
+    const testTables = [
+      {
+        name: 'my_table',
+      },
+      {
+        name: 'my_table_1',
+      },
+    ];
+
+    const coreStoreTable = {
+      name: 'strapi_core_store_settings',
+      columns: [],
+      indexes: [],
+      foreignKeys: [],
+    };
+
+    global.strapi = {
+      store: {
+        get: async () => [testTables[0].name, 'table2'],
+      },
+    };
+
+    const srcSchema = {
+      tables: [...testTables, coreStoreTable],
+    };
+
+    const destSchema = {
+      tables: [coreStoreTable],
+    };
+
+    expect(await diffSchemas(srcSchema, destSchema)).toStrictEqual({
+      status: 'CHANGED',
+      diff: {
+        tables: {
+          added: [],
+          updated: [],
+          unchanged: [coreStoreTable],
+          removed: [testTables[1]],
+        },
+      },
+    });
+  });
 });

package/lib/schema/diff.js

@@ -322,7 +322,7 @@ module.exports = (db) => {
     };
   };
 
-  const diffSchemas = (srcSchema, destSchema) => {
+  const diffSchemas = async (srcSchema, destSchema) => {
     const addedTables = [];
     const updatedTables = [];
     const unchangedTables = [];
@@ -344,10 +344,17 @@ module.exports = (db) => {
       }
     }
 
+    const persistedTables = helpers.hasTable(srcSchema, 'strapi_core_store_settings')
+      ? (await strapi.store.get({
+          type: 'core',
+          key: 'persisted_tables',
+        })) ?? []
+      : [];
+
     for (const srcTable of srcSchema.tables) {
       if (
         !helpers.hasTable(destSchema, srcTable.name) &&
-        !RESERVED_TABLE_NAMES.includes(srcTable.name)
+        ![...RESERVED_TABLE_NAMES, ...persistedTables].includes(srcTable.name)
       ) {
         removedTables.push(srcTable);
       }

package/lib/schema/index.js

@@ -50,7 +50,7 @@ const createSchemaProvider = (db) => {
 
       const DBSchema = await db.dialect.schemaInspector.getSchema();
 
-      const { status, diff } = this.schemaDiff.diff(DBSchema, schema);
+      const { status, diff } = await this.schemaDiff.diff(DBSchema, schema);
 
       if (status === 'CHANGED') {
         await this.builder.updateSchema(diff);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
+  "version": "4.9.1",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -28,7 +28,9 @@
     "lib": "./lib"
   },
   "scripts": {
-    "test:unit": "jest --verbose"
+    "test:unit": "run -T jest",
+    "test:unit:watch": "run -T jest --watch",
+    "lint": "run -T eslint ."
   },
   "dependencies": {
     "date-fns": "2.29.3",
@@ -43,5 +45,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "366eb8a0d0f06935914854c6d9c4b3fe859468e0"
+  "gitHead": "c8f2f0543b45dda8eadde21a0782b64d156fc786"
 }

package/lib/tests/knex-utils.test.api.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const { createStrapiInstance } = require('../../../../../test/helpers/strapi');
-const { isKnexQuery } = require('../utils/knex');
-
-let strapi;
-
-describe('knex', () => {
-  beforeAll(async () => {
-    strapi = await createStrapiInstance();
-  });
-
-  afterAll(async () => {
-    await strapi.destroy();
-  });
-
-  describe('isKnexQuery', () => {
-    test('knex query: true', () => {
-      const res = isKnexQuery(strapi.db.connection('strapi_core_store_settings'));
-      expect(res).toBe(true);
-    });
-
-    test('knex raw: true', () => {
-      const res = isKnexQuery(strapi.db.connection.raw('SELECT * FROM strapi_core_store_settings'));
-      expect(res).toBe(true);
-    });
-
-    test.each([[''], [{}], [[]], [2], [new Date()]])('%s: false', (value) => {
-      const res = isKnexQuery(value);
-      expect(res).toBe(false);
-    });
-  });
-});

package/lib/tests/transactions.test.api.js

@@ -1,308 +0,0 @@
-'use strict';
-
-const { createStrapiInstance } = require('../../../../../test/helpers/strapi');
-
-let strapi;
-
-describe('transactions', () => {
-  let original;
-  beforeAll(async () => {
-    strapi = await createStrapiInstance();
-    original = await strapi.db
-      .queryBuilder('strapi::core-store')
-      .select(['*'])
-      .where({ id: 1 })
-      .execute();
-  });
-
-  afterAll(async () => {
-    await strapi.destroy();
-  });
-
-  afterEach(async () => {
-    await strapi.db
-      .queryBuilder('strapi::core-store')
-      .update({
-        key: original[0].key,
-      })
-      .where({ id: 1 })
-      .execute();
-  });
-
-  describe('using a transaction method', () => {
-    test('commits successfully', async () => {
-      await strapi.db.transaction(async () => {
-        await strapi.db
-          .queryBuilder('strapi::core-store')
-          .update({
-            key: 'wrong key',
-          })
-          .where({ id: 1 })
-          .execute();
-
-        await strapi.db
-          .queryBuilder('strapi::core-store')
-          .update({
-            key: 'new key',
-          })
-          .where({ id: 1 })
-          .execute();
-      });
-
-      const end = await strapi.db
-        .queryBuilder('strapi::core-store')
-        .select(['*'])
-        .where({ id: 1 })
-        .execute();
-
-      expect(end[0].key).toEqual('new key');
-    });
-
-    test('rollback successfully', async () => {
-      try {
-        await strapi.db.transaction(async () => {
-          // this is valid
-          await strapi.db
-            .queryBuilder('strapi::core-store')
-            .update({
-              key: 'wrong key',
-            })
-            .where({ id: 1 })
-            .execute();
-
-          // this throws
-          await strapi.db
-            .queryBuilder('invalid_uid')
-            .update({
-              key: 'bad key',
-              invalid_key: 'error',
-            })
-            .where({ id: 1 })
-            .execute();
-        });
-
-        expect('this should not be reached').toBe(false);
-      } catch (e) {
-        // do nothing
-      }
-
-      const end = await strapi.db
-        .queryBuilder('strapi::core-store')
-        .select(['*'])
-        .where({ id: 1 })
-        .execute();
-
-      expect(end[0].key).toEqual(original[0].key);
-    });
-
-    test('nested rollback -> rollback works', async () => {
-      try {
-        await strapi.db.transaction(async () => {
-          // this is valid
-          await strapi.db
-            .queryBuilder('strapi::core-store')
-            .update({
-              key: 'changed key',
-            })
-            .where({ id: 1 })
-            .execute();
-
-          // here we'll make a nested transaction that throws and then confirm we still have "changed key" from above
-          try {
-            await strapi.db.transaction(async () => {
-              await strapi.db
-                .queryBuilder('strapi::core-store')
-                .update({
-                  key: 'changed key - nested',
-                })
-                .where({ id: 1 })
-                .execute();
-
-              // this should throw and roll back
-              await strapi.db
-                .queryBuilder('invalid_uid')
-                .update({
-                  invalid_key: 'error',
-                })
-                .where({ id: 1 })
-                .execute();
-            });
-          } catch (e) {
-            // do nothing
-          }
-
-          // should equal the result from above
-          const result = await strapi.db
-            .queryBuilder('strapi::core-store')
-            .select(['*'])
-            .where({ id: 1 })
-            .execute();
-
-          expect(result[0].key).toEqual('changed key');
-
-          // this throws
-          await strapi.db
-            .queryBuilder('invalid_uid')
-            .update({
-              key: original[0].key,
-              invalid_key: 'error',
-            })
-            .where({ id: 1 })
-            .execute();
-        });
-
-        expect('this should not be reached').toBe(false);
-      } catch (e) {
-        // do nothing
-      }
-
-      const end = await strapi.db
-        .queryBuilder('strapi::core-store')
-        .select(['*'])
-        .where({ id: 1 })
-        .execute();
-
-      expect(end[0].key).toEqual(original[0].key);
-    });
-
-    test('nested commit -> rollback works', async () => {
-      try {
-        await strapi.db.transaction(async () => {
-          // this is valid
-          await strapi.db
-            .queryBuilder('strapi::core-store')
-            .update({
-              key: 'changed key',
-            })
-            .where({ id: 1 })
-            .execute();
-
-          // here we'll make a nested transaction that works, and then later we'll rollback the outer transaction
-          try {
-            await strapi.db.transaction(async () => {
-              await strapi.db
-                .queryBuilder('strapi::core-store')
-                .update({
-                  key: 'changed key - nested',
-                })
-                .where({ id: 1 })
-                .execute();
-            });
-          } catch (e) {
-            // do nothing
-          }
-
-          // should equal the result from above
-          const result = await strapi.db
-            .queryBuilder('strapi::core-store')
-            .select(['*'])
-            .where({ id: 1 })
-            .execute();
-
-          expect(result[0].key).toEqual('changed key - nested');
-
-          // this throws
-          await strapi.db
-            .queryBuilder('invalid_uid')
-            .update({
-              key: original[0].key,
-              invalid_key: 'error',
-            })
-            .where({ id: 1 })
-            .execute();
-        });
-
-        expect('this should not be reached').toBe(false);
-      } catch (e) {
-        // do nothing
-      }
-
-      const end = await strapi.db
-        .queryBuilder('strapi::core-store')
-        .select(['*'])
-        .where({ id: 1 })
-        .execute();
-
-      expect(end[0].key).toEqual(original[0].key);
-    });
-  });
-
-  describe('using a transaction object', () => {
-    test('commits successfully', async () => {
-      const trx = await strapi.db.transaction();
-
-      try {
-        await strapi.db
-          .queryBuilder('strapi::core-store')
-          .update({
-            key: 'wrong key',
-          })
-          .where({ id: 1 })
-          .transacting(trx.get())
-          .execute();
-
-        await strapi.db
-          .queryBuilder('strapi::core-store')
-          .update({
-            key: original[0].key,
-          })
-          .where({ id: 1 })
-          .transacting(trx.get())
-          .execute();
-
-        await trx.commit();
-      } catch (e) {
-        await trx.rollback();
-        console.log(e.message);
-        expect('this should not be reached').toBe(false);
-      }
-
-      const end = await strapi.db
-        .queryBuilder('strapi::core-store')
-        .select(['*'])
-        .where({ id: 1 })
-        .execute();
-
-      expect(end[0].key).toEqual('strapi_content_types_schema');
-    });
-
-    test('rollback successfully', async () => {
-      const trx = await strapi.db.transaction();
-
-      try {
-        await strapi.db
-          .queryBuilder('strapi::core-store')
-          .update({
-            key: 'wrong key',
-          })
-          .where({ id: 1 })
-          .transacting(trx.get())
-          .execute();
-
-        // this query should throw because it has errors
-        await strapi.db
-          .queryBuilder('invalid_uid')
-          .update({
-            key: 123,
-            key_not_here: 'this should error',
-          })
-          .where({ id: 'this should error' })
-          .transacting(trx.get())
-          .execute();
-
-        await trx.commit();
-        expect('this should not be reached').toBe(false);
-      } catch (e) {
-        await trx.rollback();
-      }
-
-      const end = await strapi.db
-        .queryBuilder('strapi::core-store')
-        .select(['*'])
-        .where({ id: 1 })
-        .execute();
-
-      expect(end[0].key).toEqual('strapi_content_types_schema');
-    });
-  });
-});