@nymphjs/nymph 1.0.0-beta.3 → 1.0.0-beta.31

package/src/Nymph.ts

@@ -1,7 +1,7 @@
 import { Config, ConfigDefaults as defaults } from './conf';
-import { NymphDriver } from './driver';
+import type { NymphDriver } from './driver';
 import Entity from './Entity';
-import { EntityConstructor, EntityData, EntityInterface } from './Entity.types';
+import type { EntityConstructor, EntityInterface } from './Entity.types';
 import { ClassNotAvailableError } from './errors';
 import type {
   Selector,
@@ -12,18 +12,31 @@ import type {
   NymphBeforeGetEntitiesCallback,
   NymphBeforeSaveEntityCallback,
   NymphAfterSaveEntityCallback,
+  NymphFailedSaveEntityCallback,
   NymphBeforeDeleteEntityCallback,
   NymphAfterDeleteEntityCallback,
+  NymphFailedDeleteEntityCallback,
   NymphBeforeDeleteEntityByIDCallback,
   NymphAfterDeleteEntityByIDCallback,
+  NymphFailedDeleteEntityByIDCallback,
   NymphBeforeNewUIDCallback,
   NymphAfterNewUIDCallback,
+  NymphFailedNewUIDCallback,
   NymphBeforeSetUIDCallback,
   NymphAfterSetUIDCallback,
+  NymphFailedSetUIDCallback,
   NymphBeforeRenameUIDCallback,
   NymphAfterRenameUIDCallback,
+  NymphFailedRenameUIDCallback,
   NymphBeforeDeleteUIDCallback,
   NymphAfterDeleteUIDCallback,
+  NymphFailedDeleteUIDCallback,
+  NymphBeforeStartTransactionCallback,
+  NymphAfterStartTransactionCallback,
+  NymphBeforeCommitTransactionCallback,
+  NymphAfterCommitTransactionCallback,
+  NymphBeforeRollbackTransactionCallback,
+  NymphAfterRollbackTransactionCallback,
   NymphEventType,
   NymphQueryCallback,
   FormattedSelector,
@@ -41,10 +54,16 @@ import type {
  */
 export default class Nymph {
   /**
-   * The PubSub config.
+   * The Nymph config.
    */
   public config: Config;
 
+  /**
+   * The Nymph instance that this one was cloned from, or null if it's not a
+   * clone.
+   */
+  public parent: Nymph | null;
+
   /**
    * The Nymph database driver.
    */
@@ -63,7 +82,7 @@ export default class Nymph {
   /**
    * The entity class for this instance of Nymph.
    */
-  public Entity: typeof Entity = Entity;
+  public Entity: typeof Entity;
 
   private connectCallbacks: NymphConnectCallback[] = [];
   private disconnectCallbacks: NymphDisconnectCallback[] = [];
@@ -72,34 +91,40 @@ export default class Nymph {
   private beforeGetEntitiesCallbacks: NymphBeforeGetEntitiesCallback[] = [];
   private beforeSaveEntityCallbacks: NymphBeforeSaveEntityCallback[] = [];
   private afterSaveEntityCallbacks: NymphAfterSaveEntityCallback[] = [];
+  private failedSaveEntityCallbacks: NymphFailedSaveEntityCallback[] = [];
   private beforeDeleteEntityCallbacks: NymphBeforeDeleteEntityCallback[] = [];
   private afterDeleteEntityCallbacks: NymphAfterDeleteEntityCallback[] = [];
+  private failedDeleteEntityCallbacks: NymphFailedDeleteEntityCallback[] = [];
   private beforeDeleteEntityByIDCallbacks: NymphBeforeDeleteEntityByIDCallback[] =
     [];
   private afterDeleteEntityByIDCallbacks: NymphAfterDeleteEntityByIDCallback[] =
     [];
+  private failedDeleteEntityByIDCallbacks: NymphFailedDeleteEntityByIDCallback[] =
+    [];
   private beforeNewUIDCallbacks: NymphBeforeNewUIDCallback[] = [];
   private afterNewUIDCallbacks: NymphAfterNewUIDCallback[] = [];
+  private failedNewUIDCallbacks: NymphFailedNewUIDCallback[] = [];
   private beforeSetUIDCallbacks: NymphBeforeSetUIDCallback[] = [];
   private afterSetUIDCallbacks: NymphAfterSetUIDCallback[] = [];
+  private failedSetUIDCallbacks: NymphFailedSetUIDCallback[] = [];
   private beforeRenameUIDCallbacks: NymphBeforeRenameUIDCallback[] = [];
   private afterRenameUIDCallbacks: NymphAfterRenameUIDCallback[] = [];
+  private failedRenameUIDCallbacks: NymphFailedRenameUIDCallback[] = [];
   private beforeDeleteUIDCallbacks: NymphBeforeDeleteUIDCallback[] = [];
   private afterDeleteUIDCallbacks: NymphAfterDeleteUIDCallback[] = [];
-
-  public addEntityClass(entityClass: EntityConstructor) {
-    this.entityClasses[entityClass.class] = entityClass;
-    entityClass.nymph = this;
-  }
-
-  public getEntityClass(className: string): EntityConstructor {
-    if (className in this.entityClasses) {
-      const EntityClass = this.entityClasses[className];
-      EntityClass.nymph = this;
-      return EntityClass;
-    }
-    throw new ClassNotAvailableError('Tried to use class: ' + className);
-  }
+  private failedDeleteUIDCallbacks: NymphFailedDeleteUIDCallback[] = [];
+  private beforeStartTransactionCallbacks: NymphBeforeStartTransactionCallback[] =
+    [];
+  private afterStartTransactionCallbacks: NymphAfterStartTransactionCallback[] =
+    [];
+  private beforeCommitTransactionCallbacks: NymphBeforeCommitTransactionCallback[] =
+    [];
+  private afterCommitTransactionCallbacks: NymphAfterCommitTransactionCallback[] =
+    [];
+  private beforeRollbackTransactionCallbacks: NymphBeforeRollbackTransactionCallback[] =
+    [];
+  private afterRollbackTransactionCallbacks: NymphAfterRollbackTransactionCallback[] =
+    [];
 
   /**
    * Initialize Nymph.
@@ -111,18 +136,77 @@ export default class Nymph {
   public constructor(
     config: Partial<Config>,
     driver: NymphDriver,
-    tilmeld?: TilmeldInterface
+    tilmeld?: TilmeldInterface,
+    parent?: Nymph
   ) {
     this.config = { ...defaults, ...config };
     this.driver = driver;
-    if (typeof tilmeld !== 'undefined') {
-      this.tilmeld = tilmeld;
+    this.parent = parent ?? null;
+
+    this.Entity = this.addEntityClass(Entity);
+
+    if (parent) {
+      for (const name in parent.entityClasses) {
+        if (
+          name === 'Entity' ||
+          (parent.entityClasses[name] as any).skipOnClone
+        ) {
+          continue;
+        }
+        this.addEntityClass(parent.entityClasses[name]);
+      }
+
+      const events = [
+        'connect',
+        'disconnect',
+        'query',
+        'beforeGetEntity',
+        'beforeGetEntities',
+        'beforeSaveEntity',
+        'afterSaveEntity',
+        'failedSaveEntity',
+        'beforeDeleteEntity',
+        'afterDeleteEntity',
+        'failedDeleteEntity',
+        'beforeDeleteEntityByID',
+        'afterDeleteEntityByID',
+        'failedDeleteEntityByID',
+        'beforeNewUID',
+        'afterNewUID',
+        'failedNewUID',
+        'beforeSetUID',
+        'afterSetUID',
+        'failedSetUID',
+        'beforeRenameUID',
+        'afterRenameUID',
+        'failedRenameUID',
+        'beforeDeleteUID',
+        'afterDeleteUID',
+        'failedDeleteUID',
+        'beforeStartTransaction',
+        'afterStartTransaction',
+        'beforeCommitTransaction',
+        'afterCommitTransaction',
+        'beforeRollbackTransaction',
+        'afterRollbackTransaction',
+      ];
+
+      for (let event of events) {
+        const prop = event + 'Callbacks';
+        // @ts-ignore: The callback should be the right type here.
+        const callbacks = parent[prop];
+        for (let callback of callbacks) {
+          if (callback.skipOnClone) {
+            continue;
+          }
+          this.on(event as NymphEventType, callback);
+        }
+      }
     }
 
-    class NymphEntity<T extends EntityData = EntityData> extends Entity<T> {}
-    NymphEntity.nymph = this;
-    this.Entity = NymphEntity;
-    this.addEntityClass(NymphEntity);
+    if (tilmeld != null) {
+      this.tilmeld = tilmeld;
+    }
 
     this.driver.init(this);
     if (this.tilmeld) {
@@ -131,54 +215,60 @@ export default class Nymph {
   }
 
   /**
-   * Get a clone of this instance with duplicate classes and event listeners.
+   * Add your class to this instance.
    *
-   * @returns A clone of this instance.
+   * This will create a class that extends your class within this instance of
+   * Nymph and return it. You can then use this class's constructor and methods,
+   * which will use this instance of Nymph.
+   *
+   * Because this creates a subclass, don't use the class
+   * returned from `getEntityClass` to check with `instanceof`.
    */
-  public clone() {
-    const nymph = new Nymph(this.config, this.driver, this.tilmeld?.clone());
-    for (const name in this.entityClasses) {
-      if (name === 'Entity' || (this.entityClasses[name] as any).skipOnClone) {
-        continue;
-      }
-      nymph.addEntityClass(this.entityClasses[name]);
-    }
-
-    const events = [
-      'connect',
-      'disconnect',
-      'query',
-      'beforeGetEntity',
-      'beforeGetEntities',
-      'beforeSaveEntity',
-      'afterSaveEntity',
-      'beforeDeleteEntity',
-      'afterDeleteEntity',
-      'beforeDeleteEntityByID',
-      'afterDeleteEntityByID',
-      'beforeNewUID',
-      'afterNewUID',
-      'beforeSetUID',
-      'afterSetUID',
-      'beforeRenameUID',
-      'afterRenameUID',
-      'beforeDeleteUID',
-      'afterDeleteUID',
-    ];
-
-    for (let event of events) {
-      const prop = event + 'Callbacks';
-      // @ts-ignore: The callback should be the right type here.
-      const callbacks = this[prop];
-      for (let callback of callbacks) {
-        if (callback.skipOnClone) {
-          continue;
-        }
-        nymph.on(event as NymphEventType, callback);
+  public addEntityClass<T extends EntityConstructor>(entityClass: T): T {
+    const nymph = this;
+    class NymphEntity extends entityClass {
+      static nymph: Nymph = nymph;
+
+      constructor(...args: any[]) {
+        super(...args);
       }
     }
+    this.entityClasses[entityClass.class] = NymphEntity;
+    return NymphEntity;
+  }
 
-    return nymph;
+  /**
+   * Get the class that uses the specified class name.
+   */
+  public getEntityClass<T extends EntityConstructor>(className: T): T;
+  public getEntityClass(className: string): EntityConstructor;
+  public getEntityClass<T extends EntityConstructor = EntityConstructor>(
+    className: T | string
+  ): T | EntityConstructor {
+    let key: string | null = null;
+    if (typeof className === 'string') {
+      key = className;
+    } else {
+      key = className.class;
+    }
+    if (key in this.entityClasses) {
+      return this.entityClasses[key];
+    }
+    throw new ClassNotAvailableError('Tried to use class: ' + key);
+  }
+
+  /**
+   * Get a clone of this instance with duplicate classes and event listeners.
+   *
+   * @returns A clone of this instance.
+   */
+  public clone() {
+    return new Nymph(
+      this.config,
+      this.driver.clone(),
+      this.tilmeld?.clone(),
+      this
+    );
   }
 
   /**
@@ -232,28 +322,65 @@ export default class Nymph {
    * Transactions will nest as long as every name is unique. Internally, Nymph
    * uses names prefixed with "nymph-".
    *
-   * @returns True on success, false on failure.
+   * @returns A new instance of Nymph that should be used for the transaction.
    */
   public async startTransaction(name: string): Promise<Nymph> {
-    return await this.driver.startTransaction(name);
+    for (let callback of this.beforeStartTransactionCallbacks) {
+      if (callback) {
+        await callback(this, name);
+      }
+    }
+    const result = await this.driver.startTransaction(name);
+    for (let callback of this.afterStartTransactionCallbacks) {
+      if (callback) {
+        await callback(this, name, result);
+      }
+    }
+    return result;
   }
 
   /**
    * Commit the named transaction.
    *
+   * After this is called, the transaction instance should be discarded.
+   *
    * @returns True on success, false on failure.
    */
   public async commit(name: string): Promise<boolean> {
-    return await this.driver.commit(name);
+    for (let callback of this.beforeCommitTransactionCallbacks) {
+      if (callback) {
+        await callback(this, name);
+      }
+    }
+    const result = await this.driver.commit(name);
+    for (let callback of this.afterCommitTransactionCallbacks) {
+      if (callback) {
+        await callback(this, name, result);
+      }
+    }
+    return result;
   }
 
   /**
    * Rollback the named transaction.
    *
+   * After this is called, the transaction instance should be discarded.
+   *
    * @returns True on success, false on failure.
    */
   public async rollback(name: string): Promise<boolean> {
-    return await this.driver.rollback(name);
+    for (let callback of this.beforeRollbackTransactionCallbacks) {
+      if (callback) {
+        await callback(this, name);
+      }
+    }
+    const result = await this.driver.rollback(name);
+    for (let callback of this.afterRollbackTransactionCallbacks) {
+      if (callback) {
+        await callback(this, name, result);
+      }
+    }
+    return result;
   }
 
   /**
@@ -292,7 +419,17 @@ export default class Nymph {
         await callback(this, name);
       }
     }
-    const result = this.driver.newUID(name);
+    let result: Promise<number | null>;
+    try {
+      result = this.driver.newUID(name);
+    } catch (e: any) {
+      for (let callback of this.failedNewUIDCallbacks) {
+        if (callback) {
+          await callback(this, e);
+        }
+      }
+      throw e;
+    }
     for (let callback of this.afterNewUIDCallbacks) {
       if (callback) {
         await callback(this, result);
@@ -323,7 +460,17 @@ export default class Nymph {
         await callback(this, name, value);
       }
     }
-    const result = this.driver.setUID(name, value);
+    let result: Promise<boolean>;
+    try {
+      result = this.driver.setUID(name, value);
+    } catch (e: any) {
+      for (let callback of this.failedSetUIDCallbacks) {
+        if (callback) {
+          await callback(this, e);
+        }
+      }
+      throw e;
+    }
     for (let callback of this.afterSetUIDCallbacks) {
       if (callback) {
         await callback(this, result);
@@ -344,7 +491,17 @@ export default class Nymph {
         await callback(this, name);
       }
     }
-    const result = this.driver.deleteUID(name);
+    let result: Promise<boolean>;
+    try {
+      result = this.driver.deleteUID(name);
+    } catch (e: any) {
+      for (let callback of this.failedDeleteUIDCallbacks) {
+        if (callback) {
+          await callback(this, e);
+        }
+      }
+      throw e;
+    }
     for (let callback of this.afterDeleteUIDCallbacks) {
       if (callback) {
         await callback(this, result);
@@ -366,7 +523,17 @@ export default class Nymph {
         await callback(this, oldName, newName);
       }
     }
-    const result = this.driver.renameUID(oldName, newName);
+    let result: Promise<boolean>;
+    try {
+      result = this.driver.renameUID(oldName, newName);
+    } catch (e: any) {
+      for (let callback of this.failedRenameUIDCallbacks) {
+        if (callback) {
+          await callback(this, e);
+        }
+      }
+      throw e;
+    }
     for (let callback of this.afterRenameUIDCallbacks) {
       if (callback) {
         await callback(this, result);
@@ -392,7 +559,17 @@ export default class Nymph {
         await callback(this, entity);
       }
     }
-    const result = this.driver.saveEntity(entity);
+    let result: Promise<boolean>;
+    try {
+      result = this.driver.saveEntity(entity);
+    } catch (e: any) {
+      for (let callback of this.failedSaveEntityCallbacks) {
+        if (callback) {
+          await callback(this, e);
+        }
+      }
+      throw e;
+    }
     for (let callback of this.afterSaveEntityCallbacks) {
       if (callback) {
         await callback(this, result);
@@ -411,8 +588,10 @@ export default class Nymph {
    * - offset - The offset from the oldest matching entity to start retrieving.
    * - reverse - If true, entities will be retrieved from newest to oldest.
    *   Therefore, offset will be from the newest entity.
-   * - sort - How to sort the entities. Accepts "cdate" or "mdate". Defaults to
-   *   "cdate".
+   * - sort - How to sort the entities. Accepts "cdate", "mdate", or the name of
+   *   a top-level property. The method of sorting properties other than cdate
+   *   and mdate is driver dependent. The only hard rule is that numbers should
+   *   be sorted numerically (2 before 10). Defaults to "cdate".
    * - return - What to return. "entity", "guid", or "count". Defaults to
    *   "entity".
    * - source - Will be 'client' if the query came from a REST call.
@@ -656,7 +835,17 @@ export default class Nymph {
         await callback(this, entity);
       }
     }
-    const result = this.driver.deleteEntity(entity);
+    let result: Promise<boolean>;
+    try {
+      result = this.driver.deleteEntity(entity);
+    } catch (e: any) {
+      for (let callback of this.failedDeleteEntityCallbacks) {
+        if (callback) {
+          await callback(this, e);
+        }
+      }
+      throw e;
+    }
     for (let callback of this.afterDeleteEntityCallbacks) {
       if (callback) {
         await callback(this, result);
@@ -681,7 +870,17 @@ export default class Nymph {
         await callback(this, guid, className);
       }
     }
-    const result = this.driver.deleteEntityByID(guid, className);
+    let result: Promise<boolean>;
+    try {
+      result = this.driver.deleteEntityByID(guid, className);
+    } catch (e: any) {
+      for (let callback of this.failedDeleteEntityByIDCallbacks) {
+        if (callback) {
+          await callback(this, e);
+        }
+      }
+      throw e;
+    }
     for (let callback of this.afterDeleteEntityByIDCallbacks) {
       if (callback) {
         await callback(this, result);
@@ -712,7 +911,7 @@ export default class Nymph {
    * #  brackets ([]).
    * # Properties are stored like this:
    * # propname=JSON.stringify(value)
-   *     abilities=["system/all"]
+   *     abilities=["system/admin"]
    *     groups=[]
    *     inheritAbilities=false
    *     name="admin"
@@ -765,30 +964,56 @@ export default class Nymph {
       ? NymphBeforeSaveEntityCallback
       : T extends 'afterSaveEntity'
       ? NymphAfterSaveEntityCallback
+      : T extends 'failedSaveEntity'
+      ? NymphFailedSaveEntityCallback
       : T extends 'beforeDeleteEntity'
       ? NymphBeforeDeleteEntityCallback
       : T extends 'afterDeleteEntity'
       ? NymphAfterDeleteEntityCallback
+      : T extends 'failedDeleteEntity'
+      ? NymphFailedDeleteEntityCallback
       : T extends 'beforeDeleteEntityByID'
       ? NymphBeforeDeleteEntityByIDCallback
       : T extends 'afterDeleteEntityByID'
       ? NymphAfterDeleteEntityByIDCallback
+      : T extends 'failedDeleteEntityByID'
+      ? NymphFailedDeleteEntityByIDCallback
       : T extends 'beforeNewUID'
       ? NymphBeforeNewUIDCallback
       : T extends 'afterNewUID'
       ? NymphAfterNewUIDCallback
+      : T extends 'failedNewUID'
+      ? NymphFailedNewUIDCallback
       : T extends 'beforeSetUID'
       ? NymphBeforeSetUIDCallback
       : T extends 'afterSetUID'
       ? NymphAfterSetUIDCallback
+      : T extends 'failedSetUID'
+      ? NymphFailedSetUIDCallback
       : T extends 'beforeRenameUID'
       ? NymphBeforeRenameUIDCallback
       : T extends 'afterRenameUID'
       ? NymphAfterRenameUIDCallback
+      : T extends 'failedRenameUID'
+      ? NymphFailedRenameUIDCallback
       : T extends 'beforeDeleteUID'
       ? NymphBeforeDeleteUIDCallback
       : T extends 'afterDeleteUID'
       ? NymphAfterDeleteUIDCallback
+      : T extends 'failedDeleteUID'
+      ? NymphFailedDeleteUIDCallback
+      : T extends 'beforeStartTransaction'
+      ? NymphBeforeStartTransactionCallback
+      : T extends 'afterStartTransaction'
+      ? NymphAfterStartTransactionCallback
+      : T extends 'beforeCommitTransaction'
+      ? NymphBeforeCommitTransactionCallback
+      : T extends 'afterCommitTransaction'
+      ? NymphAfterCommitTransactionCallback
+      : T extends 'beforeRollbackTransaction'
+      ? NymphBeforeRollbackTransactionCallback
+      : T extends 'afterRollbackTransaction'
+      ? NymphAfterRollbackTransactionCallback
       : never
   ) {
     const prop = (event + 'Callbacks') as T extends 'connect'
@@ -805,30 +1030,56 @@ export default class Nymph {
       ? 'beforeSaveEntityCallbacks'
       : T extends 'afterSaveEntity'
       ? 'afterSaveEntityCallbacks'
+      : T extends 'failedSaveEntity'
+      ? 'failedSaveEntityCallbacks'
       : T extends 'beforeDeleteEntity'
       ? 'beforeDeleteEntityCallbacks'
       : T extends 'afterDeleteEntity'
       ? 'afterDeleteEntityCallbacks'
+      : T extends 'failedDeleteEntity'
+      ? 'failedDeleteEntityCallbacks'
       : T extends 'beforeDeleteEntityByID'
       ? 'beforeDeleteEntityByIDCallbacks'
       : T extends 'afterDeleteEntityByID'
       ? 'afterDeleteEntityByIDCallbacks'
+      : T extends 'failedDeleteEntityByID'
+      ? 'failedDeleteEntityByIDCallbacks'
       : T extends 'beforeNewUID'
       ? 'beforeNewUIDCallbacks'
       : T extends 'afterNewUID'
       ? 'afterNewUIDCallbacks'
+      : T extends 'failedNewUID'
+      ? 'failedNewUIDCallbacks'
       : T extends 'beforeSetUID'
       ? 'beforeSetUIDCallbacks'
       : T extends 'afterSetUID'
       ? 'afterSetUIDCallbacks'
+      : T extends 'failedSetUID'
+      ? 'failedSetUIDCallbacks'
       : T extends 'beforeRenameUID'
       ? 'beforeRenameUIDCallbacks'
       : T extends 'afterRenameUID'
       ? 'afterRenameUIDCallbacks'
+      : T extends 'failedRenameUID'
+      ? 'failedRenameUIDCallbacks'
       : T extends 'beforeDeleteUID'
       ? 'beforeDeleteUIDCallbacks'
       : T extends 'afterDeleteUID'
       ? 'afterDeleteUIDCallbacks'
+      : T extends 'failedDeleteUID'
+      ? 'failedDeleteUIDCallbacks'
+      : T extends 'beforeStartTransaction'
+      ? 'beforeStartTransactionCallbacks'
+      : T extends 'afterStartTransaction'
+      ? 'afterStartTransactionCallbacks'
+      : T extends 'beforeCommitTransaction'
+      ? 'beforeCommitTransactionCallbacks'
+      : T extends 'afterCommitTransaction'
+      ? 'afterCommitTransactionCallbacks'
+      : T extends 'beforeRollbackTransaction'
+      ? 'beforeRollbackTransactionCallbacks'
+      : T extends 'afterRollbackTransaction'
+      ? 'afterRollbackTransactionCallbacks'
       : never;
     if (!(prop in this)) {
       throw new Error('Invalid event type.');
@@ -854,30 +1105,56 @@ export default class Nymph {
       ? NymphBeforeSaveEntityCallback
       : T extends 'afterSaveEntity'
       ? NymphAfterSaveEntityCallback
+      : T extends 'failedSaveEntity'
+      ? NymphFailedSaveEntityCallback
       : T extends 'beforeDeleteEntity'
       ? NymphBeforeDeleteEntityCallback
       : T extends 'afterDeleteEntity'
       ? NymphAfterDeleteEntityCallback
+      : T extends 'failedDeleteEntity'
+      ? NymphFailedDeleteEntityCallback
       : T extends 'beforeDeleteEntityByID'
       ? NymphBeforeDeleteEntityByIDCallback
       : T extends 'afterDeleteEntityByID'
       ? NymphAfterDeleteEntityByIDCallback
+      : T extends 'failedDeleteEntityByID'
+      ? NymphFailedDeleteEntityByIDCallback
       : T extends 'beforeNewUID'
       ? NymphBeforeNewUIDCallback
       : T extends 'afterNewUID'
       ? NymphAfterNewUIDCallback
+      : T extends 'failedNewUID'
+      ? NymphFailedNewUIDCallback
       : T extends 'beforeSetUID'
       ? NymphBeforeSetUIDCallback
       : T extends 'afterSetUID'
       ? NymphAfterSetUIDCallback
+      : T extends 'failedSetUID'
+      ? NymphFailedSetUIDCallback
       : T extends 'beforeRenameUID'
       ? NymphBeforeRenameUIDCallback
       : T extends 'afterRenameUID'
       ? NymphAfterRenameUIDCallback
+      : T extends 'failedRenameUID'
+      ? NymphFailedRenameUIDCallback
       : T extends 'beforeDeleteUID'
       ? NymphBeforeDeleteUIDCallback
       : T extends 'afterDeleteUID'
       ? NymphAfterDeleteUIDCallback
+      : T extends 'failedDeleteUID'
+      ? NymphFailedDeleteUIDCallback
+      : T extends 'beforeStartTransaction'
+      ? NymphBeforeStartTransactionCallback
+      : T extends 'afterStartTransaction'
+      ? NymphAfterStartTransactionCallback
+      : T extends 'beforeCommitTransaction'
+      ? NymphBeforeCommitTransactionCallback
+      : T extends 'afterCommitTransaction'
+      ? NymphAfterCommitTransactionCallback
+      : T extends 'beforeRollbackTransaction'
+      ? NymphBeforeRollbackTransactionCallback
+      : T extends 'afterRollbackTransaction'
+      ? NymphAfterRollbackTransactionCallback
       : never
   ) {
     const prop = (event + 'Callbacks') as T extends 'connect'
@@ -894,30 +1171,56 @@ export default class Nymph {
       ? 'beforeGetEntitiesCallbacks'
       : T extends 'afterSaveEntity'
       ? 'afterSaveEntityCallbacks'
+      : T extends 'failedSaveEntity'
+      ? 'failedSaveEntityCallbacks'
       : T extends 'beforeDeleteEntity'
       ? 'beforeDeleteEntityCallbacks'
       : T extends 'afterDeleteEntity'
       ? 'afterDeleteEntityCallbacks'
+      : T extends 'failedDeleteEntity'
+      ? 'failedDeleteEntityCallbacks'
       : T extends 'beforeDeleteEntityByID'
       ? 'beforeDeleteEntityByIDCallbacks'
       : T extends 'afterDeleteEntityByID'
       ? 'afterDeleteEntityByIDCallbacks'
+      : T extends 'failedDeleteEntityByID'
+      ? 'failedDeleteEntityByIDCallbacks'
       : T extends 'beforeNewUID'
       ? 'beforeNewUIDCallbacks'
       : T extends 'afterNewUID'
       ? 'afterNewUIDCallbacks'
+      : T extends 'failedNewUID'
+      ? 'failedNewUIDCallbacks'
       : T extends 'beforeSetUID'
       ? 'beforeSetUIDCallbacks'
       : T extends 'afterSetUID'
       ? 'afterSetUIDCallbacks'
+      : T extends 'failedSetUID'
+      ? 'failedSetUIDCallbacks'
       : T extends 'beforeRenameUID'
       ? 'beforeRenameUIDCallbacks'
       : T extends 'afterRenameUID'
       ? 'afterRenameUIDCallbacks'
+      : T extends 'failedRenameUID'
+      ? 'failedRenameUIDCallbacks'
       : T extends 'beforeDeleteUID'
       ? 'beforeDeleteUIDCallbacks'
       : T extends 'afterDeleteUID'
       ? 'afterDeleteUIDCallbacks'
+      : T extends 'failedDeleteUID'
+      ? 'failedDeleteUIDCallbacks'
+      : T extends 'beforeStartTransaction'
+      ? 'beforeStartTransactionCallbacks'
+      : T extends 'afterStartTransaction'
+      ? 'afterStartTransactionCallbacks'
+      : T extends 'beforeCommitTransaction'
+      ? 'beforeCommitTransactionCallbacks'
+      : T extends 'afterCommitTransaction'
+      ? 'afterCommitTransactionCallbacks'
+      : T extends 'beforeRollbackTransaction'
+      ? 'beforeRollbackTransactionCallbacks'
+      : T extends 'afterRollbackTransaction'
+      ? 'afterRollbackTransactionCallbacks'
       : never;
     if (!(prop in this)) {
       return false;