@strapi/database 4.2.0-beta.2 → 4.2.0

package/lib/__tests__/lifecycles.test.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { createLifecyclesProvider } = require('../lifecycles');
+
+describe('LifecycleProvider', () => {
+  describe('run', () => {
+    /** @type {import("../lifecycles").LifecycleProvider} */
+    let provider;
+    let dbMetadataGetStub = jest.fn(uid => ({ uid, name: 'TestModel' }));
+
+    beforeEach(() => {
+      const db = {
+        metadata: {
+          get: dbMetadataGetStub,
+        },
+      };
+      provider = createLifecyclesProvider(db);
+      provider.clear();
+    });
+
+    it('store state', async () => {
+      const expectedState = new Date().toISOString();
+
+      const subscriber = {
+        async beforeEvent(event) {
+          event.state = expectedState;
+        },
+      };
+      provider.subscribe(subscriber);
+
+      const stateBefore = await provider.run('beforeEvent', 'test-model', { id: 'instance-id' });
+
+      expect(stateBefore.get(subscriber)).toEqual(expectedState);
+    });
+
+    it('use shared state', async () => {
+      const expectedState = { value: new Date().toISOString() };
+      let receivedState;
+
+      provider.subscribe({
+        async beforeEvent(event) {
+          event.state.value = expectedState.value;
+        },
+        async afterEvent(event) {
+          receivedState = event.state;
+        },
+      });
+
+      const stateBefore = await provider.run('beforeEvent', 'test-model', { id: 'instance-id' });
+      await provider.run('afterEvent', 'test-model', { id: 'instance-id' }, stateBefore);
+
+      expect(receivedState).toEqual(expectedState);
+    });
+  });
+});

package/lib/entity-manager.js

@@ -113,33 +113,33 @@ const createEntityManager = db => {
 
   return {
     async findOne(uid, params) {
-      await db.lifecycles.run('beforeFindOne', uid, { params });
+      const states = await db.lifecycles.run('beforeFindOne', uid, { params });
 
       const result = await this.createQueryBuilder(uid)
         .init(params)
         .first()
         .execute();
 
-      await db.lifecycles.run('afterFindOne', uid, { params, result });
+      await db.lifecycles.run('afterFindOne', uid, { params, result }, states);
 
       return result;
     },
 
     // should we name it findOne because people are used to it ?
     async findMany(uid, params) {
-      await db.lifecycles.run('beforeFindMany', uid, { params });
+      const states = await db.lifecycles.run('beforeFindMany', uid, { params });
 
       const result = await this.createQueryBuilder(uid)
         .init(params)
         .execute();
 
-      await db.lifecycles.run('afterFindMany', uid, { params, result });
+      await db.lifecycles.run('afterFindMany', uid, { params, result }, states);
 
       return result;
     },
 
-    async count(uid, params = {}) {
-      await db.lifecycles.run('beforeCount', uid, { params });
+    async count(uid, params) {
+      const states = await db.lifecycles.run('beforeCount', uid, { params });
 
       const res = await this.createQueryBuilder(uid)
         .init(_.pick(['_q', 'where', 'filters'], params))
@@ -149,13 +149,13 @@ const createEntityManager = db => {
 
       const result = Number(res.count);
 
-      await db.lifecycles.run('afterCount', uid, { params, result });
+      await db.lifecycles.run('afterCount', uid, { params, result }, states);
 
       return result;
     },
 
     async create(uid, params = {}) {
-      await db.lifecycles.run('beforeCreate', uid, { params });
+      const states = await db.lifecycles.run('beforeCreate', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { data } = params;
@@ -182,14 +182,14 @@ const createEntityManager = db => {
         populate: params.populate,
       });
 
-      await db.lifecycles.run('afterCreate', uid, { params, result });
+      await db.lifecycles.run('afterCreate', uid, { params, result }, states);
 
       return result;
     },
 
     // TODO: where do we handle relation processing for many queries ?
     async createMany(uid, params = {}) {
-      await db.lifecycles.run('beforeCreateMany', uid, { params });
+      const states = await db.lifecycles.run('beforeCreateMany', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { data } = params;
@@ -210,13 +210,13 @@ const createEntityManager = db => {
 
       const result = { count: data.length };
 
-      await db.lifecycles.run('afterCreateMany', uid, { params, result });
+      await db.lifecycles.run('afterCreateMany', uid, { params, result }, states);
 
       return result;
     },
 
     async update(uid, params = {}) {
-      await db.lifecycles.run('beforeUpdate', uid, { params });
+      const states = await db.lifecycles.run('beforeUpdate', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { where, data } = params;
@@ -259,14 +259,14 @@ const createEntityManager = db => {
         populate: params.populate,
       });
 
-      await db.lifecycles.run('afterUpdate', uid, { params, result });
+      await db.lifecycles.run('afterUpdate', uid, { params, result }, states);
 
       return result;
     },
 
     // TODO: where do we handle relation processing for many queries ?
     async updateMany(uid, params = {}) {
-      await db.lifecycles.run('beforeUpdateMany', uid, { params });
+      const states = await db.lifecycles.run('beforeUpdateMany', uid, { params });
 
       const metadata = db.metadata.get(uid);
       const { where, data } = params;
@@ -284,13 +284,13 @@ const createEntityManager = db => {
 
       const result = { count: updatedRows };
 
-      await db.lifecycles.run('afterUpdateMany', uid, { params, result });
+      await db.lifecycles.run('afterUpdateMany', uid, { params, result }, states);
 
       return result;
     },
 
     async delete(uid, params = {}) {
-      await db.lifecycles.run('beforeDelete', uid, { params });
+      const states = await db.lifecycles.run('beforeDelete', uid, { params });
 
       const { where, select, populate } = params;
 
@@ -318,14 +318,14 @@ const createEntityManager = db => {
 
       await this.deleteRelations(uid, id);
 
-      await db.lifecycles.run('afterDelete', uid, { params, result: entity });
+      await db.lifecycles.run('afterDelete', uid, { params, result: entity }, states);
 
       return entity;
     },
 
     // TODO: where do we handle relation processing for many queries ?
     async deleteMany(uid, params = {}) {
-      await db.lifecycles.run('beforeDeleteMany', uid, { params });
+      const states = await db.lifecycles.run('beforeDeleteMany', uid, { params });
 
       const { where } = params;
 
@@ -336,7 +336,7 @@ const createEntityManager = db => {
 
       const result = { count: deletedRows };
 
-      await db.lifecycles.run('afterDelete', uid, { params, result });
+      await db.lifecycles.run('afterDeleteMany', uid, { params, result }, states);
 
       return result;
     },

package/lib/lifecycles/index.d.ts

@@ -43,7 +43,8 @@ export interface Event {
 export interface LifecycleProvider {
   subscribe(subscriber: Subscriber): () => void;
   clear(): void;
-  run(action: Action, uid: string, properties: any): Promise<void>;
+  run(action: Action, uid: string, properties: any): Promise<Map<any, any>>;
+  run(action: Action, uid: string, properties: any, states: Map<any, any>): Promise<Map<any, any>>;
   createEvent(action: Action, uid: string, properties: any): Event;
 }
 

package/lib/lifecycles/index.js

@@ -30,21 +30,39 @@ const createLifecyclesProvider = db => {
       subscribers = [];
     },
 
-    createEvent(action, uid, properties) {
+    /**
+     * @param {string} action
+     * @param {string} uid
+     * @param {{ params?: any, result?: any }} properties
+     * @param {Map<any, any>} state
+     */
+    createEvent(action, uid, properties, state) {
       const model = db.metadata.get(uid);
 
       return {
         action,
         model,
+        state,
         ...properties,
       };
     },
 
-    async run(action, uid, properties) {
-      for (const subscriber of subscribers) {
+    /**
+     * @param {string} action
+     * @param {string} uid
+     * @param {{ params?: any, result?: any }} properties
+     * @param {Map<any, any>} states
+     */
+    async run(action, uid, properties, states = new Map()) {
+      for (let i = 0; i < subscribers.length; i++) {
+        const subscriber = subscribers[i];
         if (typeof subscriber === 'function') {
-          const event = this.createEvent(action, uid, properties);
+          const state = states.get(subscriber) || {};
+          const event = this.createEvent(action, uid, properties, state);
           await subscriber(event);
+          if (event.state) {
+            states.set(subscriber, event.state || state);
+          }
           continue;
         }
 
@@ -52,11 +70,17 @@ const createLifecyclesProvider = db => {
         const hasModel = !subscriber.models || subscriber.models.includes(uid);
 
         if (hasAction && hasModel) {
-          const event = this.createEvent(action, uid, properties);
+          const state = states.get(subscriber) || {};
+          const event = this.createEvent(action, uid, properties, state);
 
           await subscriber[action](event);
+          if (event.state) {
+            states.set(subscriber, event.state);
+          }
         }
       }
+
+      return states;
     },
   };
 };

package/lib/migrations/index.js

@@ -2,42 +2,48 @@
 
 const path = require('path');
 const fse = require('fs-extra');
-const Umzug = require('umzug');
+const { Umzug } = require('umzug');
 
 const createStorage = require('./storage');
 
+const wrapTransaction = db => fn => () =>
+  db.getConnection().transaction(trx => Promise.resolve(fn(trx)));
+
 // TODO: check multiple commands in one sql statement
-const migrationResolver = path => {
+const migrationResolver = ({ name, path, context }) => {
+  const { db } = context;
+
   // if sql file run with knex raw
   if (path.match(/\.sql$/)) {
     const sql = fse.readFileSync(path, 'utf8');
 
     return {
-      up: knex => knex.raw(sql),
+      name,
+      up: wrapTransaction(db)(knex => knex.raw(sql)),
       down() {},
     };
   }
 
   // NOTE: we can add some ts register if we want to handle ts migration files at some point
-  return require(path);
+  const migration = require(path);
+  return {
+    name,
+    up: wrapTransaction(db)(migration.up),
+    down: wrapTransaction(db)(migration.down),
+  };
 };
 
 const createUmzugProvider = db => {
-  const migrationDir = path.join(strapi.dirs.app.root, 'database/migrations');
+  const migrationDir = path.join(strapi.dirs.root, 'database/migrations');
 
   fse.ensureDirSync(migrationDir);
 
-  const wrapFn = fn => db => db.getConnection().transaction(trx => Promise.resolve(fn(trx)));
-  const storage = createStorage({ db, tableName: 'strapi_migrations' });
-
   return new Umzug({
-    storage,
+    storage: createStorage({ db, tableName: 'strapi_migrations' }),
+    context: { db },
     migrations: {
-      path: migrationDir,
-      pattern: /\.(js|sql)$/,
-      params: [db],
-      wrap: wrapFn,
-      customResolver: migrationResolver,
+      glob: ['*.{js,sql}', { cwd: migrationDir }],
+      resolve: migrationResolver,
     },
   });
 };

package/lib/migrations/storage.js

@@ -14,21 +14,21 @@ const createStorage = (opts = {}) => {
   };
 
   return {
-    async logMigration(migrationName) {
+    async logMigration({ name }) {
       await db
         .getConnection()
         .insert({
-          name: migrationName,
+          name,
           time: new Date(),
         })
         .into(tableName);
     },
 
-    async unlogMigration(migrationName) {
+    async unlogMigration({ name }) {
       await db
         .getConnection(tableName)
         .del()
-        .where({ name: migrationName });
+        .where({ name });
     },
 
     async executed() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.2.0-beta.2",
+  "version": "4.2.0",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -36,11 +36,11 @@
     "fs-extra": "10.0.0",
     "knex": "1.0.4",
     "lodash": "4.17.21",
-    "umzug": "2.3.0"
+    "umzug": "3.1.1"
   },
   "engines": {
-    "node": ">=12.22.0 <=16.x.x",
+    "node": ">=14.19.1 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "bff73257e7695d6f361c91dda8cc810a2bb70b6e"
+  "gitHead": "12c8ee3b2d95fe417de4d939db0311a0513bd8da"
 }