Add transaction success hook

Don't log stats for virtual collections

Author: brettwillis

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-connector-firestore",
-  "version": "3.0.0-alpha.40",
+  "version": "3.0.0-alpha.41",
   "description": "Strapi database connector for Firestore database on Google Cloud Platform.",
   "keywords": [
     "firestore",
@@ -27,7 +27,7 @@
     "test": "npm run build:test && npm test --prefix test"
   },
   "dependencies": {
-    "@google-cloud/firestore": "^4.15.0",
+    "@google-cloud/firestore": "^4.15.1",
     "@types/pino": "^4.16.1",
     "fs-extra": "^9.1.0",
     "lodash": "^4.17.21",
@@ -38,8 +38,8 @@
     "@tsconfig/node12": "^1.0.9",
     "@types/fs-extra": "^9.0.12",
     "@types/lodash": "^4.14.172",
-    "@types/node": "^12.20.19",
+    "@types/node": "^12.20.24",
     "rimraf": "^3.0.2",
-    "typescript": "^4.4.2"
+    "typescript": "^4.4.3"
   }
 }

package.json

@@ -1,7 +1,7 @@
 import * as _ from 'lodash';
-import { PickReferenceKeys, PopulatedByKeys, populateDoc, populateSnapshots } from './populate';
+import { PickReferenceKeys, populateDoc, populateSnapshots } from './populate';
 import { StatusError } from './utils/status-error';
-import type { StrapiQuery, StrapiContext } from './types';
+import type { StrapiQuery, StrapiContext, TransactionSuccessHook } from './types';
 import type { Queryable } from './db/collection';
 import type { Transaction } from './db/transaction';
 import type { Reference, Snapshot } from './db/reference';
@@ -52,20 +52,25 @@ export function queries<T extends object>({ model, strapi }: StrapiContext<T>):
       ? model.db.doc(model.getPK(values))
       : model.db.doc();
 
-    return await model.runTransaction(async trans => {
+    const { result, onSuccess } = await model.runTransaction(async trans => {
       // Create while coercing data and updating relations
       const data = await trans.create(ref, values);
-      await model.options.onChange(undefined, data, trans);
+      const onSuccess = await model.options.onChange(undefined, data, trans);
 
       // Populate relations
-      return await populateDoc(model, ref, data, populate, trans);
+      const result = await populateDoc(model, ref, data, populate, trans);
+      return { result, onSuccess };
     });
+
+    // Run the success hook
+    await runOnSuccess(onSuccess, result as any);
+    return result;
   };
 
   const update: FirestoreConnectorQueries<T>['update'] = async (params, values, populate = (model.defaultPopulate as any)) => {
     log('update', { params, populate });
 
-    return await model.runTransaction(async trans => {
+    const { result, onSuccess } =  await model.runTransaction(async trans => {
       const [snap] = await buildAndFetchQuery({
         model,
         params: { ...params, _limit: 1 },
@@ -81,17 +86,22 @@ export function queries<T extends object>({ model, strapi }: StrapiContext<T>):
         ...snap.data(),
         ...await trans.update(snap.ref, values),
       };
-      await model.options.onChange(prevData, data, trans);
+      const onSuccess = await model.options.onChange(prevData, data, trans);
 
       // Populate relations
-      return await populateDoc(model, snap.ref, data, populate, trans);
+      const result = await populateDoc(model, snap.ref, data, populate, trans);
+      return { result, onSuccess };
     });
+
+    // Run the success hook
+    await runOnSuccess(onSuccess, result as any);
+    return result;
   };
 
   const deleteMany: FirestoreConnectorQueries<T>['delete'] = async (params, populate = (model.defaultPopulate as any)) => {
     log('delete', { params, populate });
 
-    return await model.runTransaction(async trans => {
+    const results = await model.runTransaction(async trans => {
       const query = buildQuery(model.db, { model, params });
       const snaps = await fetchQuery(query, trans);
 
@@ -105,9 +115,25 @@ export function queries<T extends object>({ model, strapi }: StrapiContext<T>):
         );
       }
     });
+
+    // Run the success hook
+    if (Array.isArray(results)) {
+      await Promise.all(results.map(r => r && runOnSuccess(r.onSuccess, r.result as any)));
+    } else {
+      if (results) {
+        await runOnSuccess(results.onSuccess, results.result as any);
+      }
+    }
+
+    // Return the results
+    if (Array.isArray(results)) {
+      return results.map(r => r && r.result);
+    } else {
+      return results && results.result;
+    }
   };
 
-  async function deleteOne<K extends PickReferenceKeys<T>>(snap: Snapshot<T>, populate: K[], trans: Transaction): Promise<PopulatedByKeys<T, K> | null> {
+  async function deleteOne<K extends PickReferenceKeys<T>>(snap: Snapshot<T>, populate: K[], trans: Transaction) {
     const prevData = snap.data();
     if (!prevData) {
       // Delete API returns `null` rather than throwing an error for non-existent documents
@@ -116,10 +142,11 @@ export function queries<T extends object>({ model, strapi }: StrapiContext<T>):
 
     // Delete while updating relations
     await trans.delete(snap.ref);
-    await model.options.onChange(prevData, undefined, trans);
+    const onSuccess = await model.options.onChange(prevData, undefined, trans);
 
     // Populate relations
-    return await populateDoc(model, snap.ref, prevData, populate, trans);
+    const result = await populateDoc(model, snap.ref, prevData, populate, trans);
+    return { result, onSuccess };
   };
 
   const search: FirestoreConnectorQueries<T>['search'] = async (params, populate = (model.defaultPopulate as any)) => {
@@ -213,3 +240,13 @@ async function fetchQuery<T extends object>(queryOrRefs: Queryable<T> | Referenc
     return result.docs;
   }
 }
+
+async function runOnSuccess<T extends object>(onSuccess: void | TransactionSuccessHook<T>, result: T | undefined) {
+  if (typeof onSuccess === 'function') {
+    try {
+      await onSuccess(result);
+    } catch (err) {
+      strapi.log.warn(`Transaction onSuccess hook threw an error: ${(err as any).message}`, err);
+    }
+  }
+}

src/queries.ts

@@ -200,15 +200,27 @@ export interface ModelOptions<T extends object, R extends DocumentData = Documen
    * This hook is only called via the query interface (i.e. `strapi.query(...).create(...)` etc). Any operations performed directly using the model's 
    * `runTransaction(...)` interface will bypass this hook.
    * 
+   * Note: This hook may be called multiple times for a single transaction, if the transaction is retried. The result
+   * of transaction may not necessarily be committed to the database, depending on the success of the transaction.
+   * Return a function from this hook, for any code that should be executed only once upon success of the transaction.
+   * 
    * @param previousData The previous value of the entity, or `undefined` if the entity is being created.
    * @param newData The new value of the entity, or `undefined` if the entity is being deleted.
    * @param transaction The transaction being run. Can be used to fetch additional entities, or make additional
    *    atomic writes.
-   * @returns If a promise is returned, if will be awaited before completing the transaction.
+   * @returns The hook may optionally return a function, or a Promise that optionally resolves to a function.
+   *    If a promise is returned, it will be awaited before completing the transaction.
+   *    If it resolves to a function, this function will be called only once, after the transaction has been
+   *    successfully committed.
+   *    Any errors thrown by this function will be caught and ignored.
+   *    
    */
-  onChange?: (previousData: T | undefined, newData: T | undefined, transaction: Transaction) => void | Promise<void>
+  onChange?: TransactionOnChangeHook<T>
 }
 
+export type TransactionOnChangeHook<T> = (previousData: T | undefined, newData: T | undefined, transaction: Transaction) => (void | TransactionSuccessHook<T>) | PromiseLike<void | TransactionSuccessHook<T>>
+export type TransactionSuccessHook<T> = (result: T | undefined) => (void | PromiseLike<void>)
+
 export interface DataSource<T extends object> {
   /**
    * Indicates whether entries in this data source will have persistent and stable IDs

src/types.ts

@@ -23,7 +23,8 @@ export function makeTransactionRunner<T extends object>(firestore: Firestore, op
       // The only scenario where a virtual collection may want to perform a Firestore write is if it has
       // a dominant relation to a non-virtual collection. However, because of the (potentially) transient nature of
       // references to virtual collections, dominant relations to a virtual collection are not supported.
-      const trans = new ReadOnlyTransaction(firestore, logTransactionStats);
+      // Don't log stats for virtual collections
+      const trans = new ReadOnlyTransaction(firestore, logTransactionStats && !isVirtual);
       const result = await fn(trans);
       await trans.commit();
       return result;