@rvoh/dream 2.32.0 → 2.34.0

package/dist/esm/src/dream/QueryDriver/Base.js

@@ -626,6 +626,13 @@ export default class QueryDriverBase {
     static get syncDialect() {
         return 'postgres';
     }
+    /** @internal Resolve the credential used by the database type generator. */
+    static codegenPassword(password) {
+        if (typeof password === 'function') {
+            throw new Error('This database adapter does not support a password provider for type generation');
+        }
+        return Promise.resolve(password);
+    }
     /**
      * Returns the sql that would be executed by this Query
      *

package/dist/esm/src/dream/QueryDriver/Kysely.js

@@ -71,6 +71,7 @@ import softDeleteDream from '../internal/softDeleteDream.js';
 import sqlResultToDreamInstance from '../internal/sqlResultToDreamInstance.js';
 import Query from '../Query.js';
 import QueryDriverBase from './Base.js';
+import { PasswordProviderPoolClient } from './helpers/pg/loadPgClient.js';
 import checkForNeedToBeRunMigrations from './helpers/kysely/checkForNeedToBeRunMigrations.js';
 import foreignKeyTypeFromPrimaryKey from './helpers/kysely/foreignKeyTypeFromPrimaryKey.js';
 import runMigration from './helpers/kysely/runMigration.js';
@@ -103,7 +104,10 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 // Spread pg passthrough first; Dream's resolved fields follow and
                 // always win (per-connection database name, TLS directive).
                 ...(connectionConf.pg ?? {}),
+                Client: typeof connectionConf.password === 'function' ? PasswordProviderPoolClient : undefined,
                 user: connectionConf.user || '',
+                // pg accepts a callback here and resolves it for each new client when
+                // the server requests password authentication.
                 password: connectionConf.password || '',
                 database: DreamApp.getOrFail().dbName(connectionName, dbConnectionType),
                 host: connectionConf.host || 'localhost',
@@ -227,6 +231,9 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     static get syncDialect() {
         return 'postgres';
     }
+    static async codegenPassword(password) {
+        return typeof password === 'function' ? await password() : password;
+    }
     /**
      * @internal
      *
@@ -344,7 +351,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             dreamTransaction.kyselyTransaction = kyselyTransaction;
             callbackResponse = (await callback(dreamTransaction));
         });
-        await dreamTransaction.runAfterCommitHooks(dreamTransaction);
+        await dreamTransaction.runAfterCommitHooks();
         return callbackResponse;
     }
     /**

package/dist/esm/src/dream/QueryDriver/Postgres.js

@@ -332,7 +332,13 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
             keepAlive: true,
             keepAliveInitialDelayMillis: LOCK_CONNECTION_KEEPALIVE_INITIAL_DELAY_MS,
         });
-        await client.connect();
+        try {
+            await client.connect();
+        }
+        catch (err) {
+            await client.end().catch(() => undefined);
+            throw err;
+        }
         return {
             async tryAcquire(namespace, index) {
                 const result = await client.query('SELECT pg_try_advisory_lock($1::int4, $2::int4) AS locked', [

package/dist/esm/src/dream/QueryDriver/helpers/pg/loadPgClient.js

@@ -8,6 +8,28 @@
 // @ts-ignore
 import pg from 'pg';
 import DreamApp from '../../../../dream-app/index.js';
+export class PasswordProviderPoolClient extends pg.Client {
+    connect(callback) {
+        if (callback) {
+            super.connect(err => {
+                if (err)
+                    this.destroyConnectionStream();
+                callback(err);
+            });
+        }
+        else {
+            return super.connect().catch(err => {
+                this.destroyConnectionStream();
+                throw err;
+            });
+        }
+    }
+    destroyConnectionStream() {
+        // pg reports a rejected password provider without closing its socket.
+        ;
+        this.connection?.stream.destroy();
+    }
+}
 export default async function loadPgClient({ connectionName, useSystemDb, }) {
     const dreamconf = DreamApp.getOrFail();
     const creds = dreamconf.dbCredentialsFor(connectionName)?.primary;
@@ -20,6 +42,12 @@ export default async function loadPgClient({ connectionName, useSystemDb, }) {
         user: creds.user,
         password: creds.password,
     });
-    await client.connect();
+    try {
+        await client.connect();
+    }
+    catch (err) {
+        await client.end().catch(() => undefined);
+        throw err;
+    }
     return client;
 }

package/dist/esm/src/dream/internal/runHooksFor.js

@@ -35,7 +35,7 @@ export default async function runHooksFor(key, dream, alreadyPersisted, beforeSa
                         if (txn)
                             txn.addCommitHook(hook, dream);
                         else
-                            await runHook(hook, dream, null);
+                            await runCommitHook(hook, dream);
                     }
                     break;
                 case 'afterSave':
@@ -50,7 +50,7 @@ export default async function runHooksFor(key, dream, alreadyPersisted, beforeSa
                         if (txn)
                             txn.addCommitHook(hook, dream);
                         else
-                            await runHook(hook, dream, null);
+                            await runCommitHook(hook, dream);
                     }
                     break;
                 case 'afterUpdate':
@@ -63,7 +63,7 @@ export default async function runHooksFor(key, dream, alreadyPersisted, beforeSa
                         if (txn)
                             txn.addCommitHook(hook, dream);
                         else
-                            await runHook(hook, dream, null);
+                            await runCommitHook(hook, dream);
                     }
                     break;
                 default:
@@ -79,7 +79,7 @@ export default async function runHooksFor(key, dream, alreadyPersisted, beforeSa
                     if (txn)
                         txn.addCommitHook(hook, dream);
                     else
-                        await runHook(hook, dream, null);
+                        await runCommitHook(hook, dream);
                     break;
                 default:
                     await runHook(hook, dream, txn);
@@ -88,6 +88,18 @@ export default async function runHooksFor(key, dream, alreadyPersisted, beforeSa
     }
 }
 export async function runHook(statement, dream, txn) {
+    assertHookMethodExists(statement, dream);
+    await dream[statement.method](txn);
+}
+/**
+ * Commit hooks run after the transaction has committed, so they are called
+ * with no argument.
+ */
+export async function runCommitHook(statement, dream) {
+    assertHookMethodExists(statement, dream);
+    await dream[statement.method]();
+}
+function assertHookMethodExists(statement, dream) {
     if (typeof dream[statement.method] !== 'function') {
         throw new Error(`
 Attempting to run ${statement.method} as part of the ${statement.type}
@@ -96,7 +108,6 @@ Dream model hook sequence, but we encountered a method that does not exist.
 Please make sure "${statement.method}" is defined on ${dream['sanitizedConstructorName']}
 `);
     }
-    await dream[statement.method](txn);
 }
 function shouldRunBeforeCreateHook(dream, statement) {
     let shouldRun = false;

package/dist/esm/src/dream/internal/withConcurrentWriterRetry.js

@@ -22,7 +22,8 @@ export const MAX_CONCURRENT_WRITER_ATTEMPTS = 3;
  * rows mid-statement as well. Either way the database has undone the whole
  * transaction, nothing has committed and no commit hook has run, so running
  * the operation again reads the rows as the other writer left them. The last
- * attempt's error is the adapter's own.
+ * attempt's error is the adapter's own. An error raised after COMMIT, such as a
+ * commit hook's, is never retried.
  *
  * A unique violation raised by a statement inside the callback is not a
  * collision but a write that violates a constraint outright, and is not
@@ -46,15 +47,19 @@ export const MAX_CONCURRENT_WRITER_ATTEMPTS = 3;
 export default async function withConcurrentWriterRetry(dreamClass, callback) {
     const queryDriverClass = DreamApp.getOrFail().dbConnectionQueryDriverClass(dreamClass.prototype.connectionName);
     for (let attempt = 1;; attempt++) {
+        let attemptTransaction = null;
         let callbackResolved = false;
         try {
             return await dreamClass.transaction(async (txn) => {
+                attemptTransaction = txn;
                 const result = await callback(txn);
                 callbackResolved = true;
                 return result;
             });
         }
         catch (error) {
+            if (attemptTransaction?.['committed'])
+                throw error;
             const undoneByConcurrentWriter = queryDriverClass.isDeadlock(error) ||
                 (callbackResolved && queryDriverClass.isUniqueConstraintViolation(error));
             if (!undoneByConcurrentWriter || attempt === MAX_CONCURRENT_WRITER_ATTEMPTS)

package/dist/types/src/Dream.d.ts

@@ -2312,6 +2312,10 @@ export default class Dream {
      * being persisted to the database, with the values
      * that were last persisted to the database.
      *
+     * On a record that has not been persisted, every
+     * column counts as changed: the object has a key
+     * for every column.
+     *
      * ```ts
      *  const user = User.new({ email: 'original@email', password: 'howyadoin' })
      *  await user.save()
@@ -2421,6 +2425,10 @@ export default class Dream {
      * Returns true if the columnName provided has
      * changes that have not yet been persisted.
      *
+     * On a record that has not been persisted, every
+     * column counts as changed, so this returns true
+     * for every column, whether or not it was assigned.
+     *
      * @param attribute - the column name to check
      * @returns A boolean
      */
@@ -2436,10 +2444,15 @@ export default class Dream {
      * of columns that have changed since last persist,
      * and their current values.
      *
+     * On a record that has not been persisted, every
+     * column counts as changed: the object has a key
+     * for every column, including those never assigned,
+     * whose value is `undefined`.
+     *
      * ```ts
      *  const user = User.new({ email: 'hello@world' })
      *  user.dirtyAttributes()
-     *  // { email: 'hello@world' }
+     *  // { id: undefined, email: 'hello@world', name: undefined, ...every other column: undefined }
      *
      *  await user.save()
      *

package/dist/types/src/cli/index.d.ts

@@ -8,8 +8,9 @@ export type SpawnOptions = Omit<NodeSpawnOptions, 'shell'> & {
      * Argv elements passed to the child as separate arguments. Defaults to `[]`.
      * Each entry is passed literally — shell meta-characters (`$`, backticks,
      * `&&`, spaces, etc.) inside any element are not interpreted by a shell.
-     * This is the right shape for any caller that interpolates a path or
-     * credential.
+     * This is the right shape for paths and other non-secret values. Pass
+     * credentials through the child's environment so they do not appear in
+     * the process command line or a refused-spawn error.
      */
     args?: string[];
 };
@@ -103,10 +104,10 @@ export default class DreamCLI {
      * (package.json scripts, CLI argv, scaffold templates) — never from
      * runtime request input or any other untrusted external source.
      *
-     * Argv-form is the safe choice for any caller that interpolates a
-     * config value, path, or credential: a database password containing
-     * `$` or backticks is passed literally to the child rather than
-     * interpreted by a shell.
+     * Argv-form passes config values and paths literally to the child,
+     * without interpreting shell metacharacters. Credentials belong in
+     * the child's environment, since argv is visible in process listings
+     * and in the refused-spawn error.
      *
      * ## Layered defense
      *

package/dist/types/src/decorators/Decorators.d.ts

@@ -399,9 +399,14 @@ export default class Decorators<TD extends typeof Dream, T extends Dream = Insta
      * }
      * ```
      *
+     * The decorated method is called with no argument, once the
+     * transaction has committed, so declaring a parameter on it is a
+     * compile error. A subclass override of the method that is not itself
+     * decorated is not checked; it is still called with no argument.
+     *
      * @returns The AfterCreateCommit decorator
      */
-    AfterCreateCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
+    AfterCreateCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): import("../types/lifecycle.js").CommitHookDecorator;
     /**
      * AfterSave decorator
      *
@@ -430,10 +435,15 @@ export default class Decorators<TD extends typeof Dream, T extends Dream = Insta
      * }
      * ```
      *
+     * The decorated method is called with no argument, once the
+     * transaction has committed, so declaring a parameter on it is a
+     * compile error. A subclass override of the method that is not itself
+     * decorated is not checked; it is still called with no argument.
+     *
      * @returns The AfterSaveCommit decorator
      *
      */
-    AfterSaveCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
+    AfterSaveCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): import("../types/lifecycle.js").CommitHookDecorator;
     /**
      * AfterUpdate decorator
      *
@@ -462,10 +472,15 @@ export default class Decorators<TD extends typeof Dream, T extends Dream = Insta
      * }
      * ```
      *
+     * The decorated method is called with no argument, once the
+     * transaction has committed, so declaring a parameter on it is a
+     * compile error. A subclass override of the method that is not itself
+     * decorated is not checked; it is still called with no argument.
+     *
      * @returns The AfterUpdateCommit decorator
      *
      */
-    AfterUpdateCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): any;
+    AfterUpdateCommit(this: Decorators<TD>, opts?: AfterHookOpts<T>): import("../types/lifecycle.js").CommitHookDecorator;
     /**
      * AfterDestroy decorator
      *
@@ -494,8 +509,13 @@ export default class Decorators<TD extends typeof Dream, T extends Dream = Insta
      * }
      * ```
      *
+     * The decorated method is called with no argument, once the
+     * transaction has committed, so declaring a parameter on it is a
+     * compile error. A subclass override of the method that is not itself
+     * decorated is not checked; it is still called with no argument.
+     *
      * @returns The AfterDestroyCommit decorator
      *
      */
-    AfterDestroyCommit(this: Decorators<TD>): any;
+    AfterDestroyCommit(this: Decorators<TD>): import("../types/lifecycle.js").CommitHookDecorator;
 }

package/dist/types/src/decorators/field/lifecycle/AfterCreateCommit.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from '../../../types/lifecycle.js';
+import { AfterHookOpts, CommitHookDecorator } from '../../../types/lifecycle.js';
 /**
  * Calls the decorated method whenever a dream has finished
  * being created. If the save takes place within a transaction,
@@ -8,6 +8,10 @@ import { AfterHookOpts } from '../../../types/lifecycle.js';
  * a transaction, the method will be run after the save
  * is complete.
  *
+ * The method is called with no argument: the transaction has already
+ * committed, so there is none to hand it. Decorating a method that
+ * declares a parameter is a compile error (see {@link CommitHookDecorator}).
+ *
  * class User extends ApplicationModel {
  *   @deco.AfterCreateCommit()
  *   public doSomething() {
@@ -17,5 +21,5 @@ import { AfterHookOpts } from '../../../types/lifecycle.js';
  *
  * @param opts.ifChanged - Optional. A list of columns which should must change in order for this function to be called.
  */
-export default function AfterCreateCommit<T extends Dream>(opts?: AfterHookOpts<T>): any;
+export default function AfterCreateCommit<T extends Dream>(opts?: AfterHookOpts<T>): CommitHookDecorator;
 export declare function afterCreateCommitImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/field/lifecycle/AfterDestroyCommit.d.ts

@@ -1,4 +1,5 @@
 import Dream from '../../../Dream.js';
+import { CommitHookDecorator } from '../../../types/lifecycle.js';
 /**
  * Calls the decorated method whenever a dream has finished
  * being destroyed. If the destroy takes place within a transaction,
@@ -7,6 +8,10 @@ import Dream from '../../../Dream.js';
  * a transaction, the method will be run after the save
  * is complete.
  *
+ * The method is called with no argument: the transaction has already
+ * committed, so there is none to hand it. Decorating a method that
+ * declares a parameter is a compile error (see {@link CommitHookDecorator}).
+ *
  * class User extends ApplicationModel {
  *   @deco.AfterDestroyCommit()
  *   public doSomething() {
@@ -14,5 +19,5 @@ import Dream from '../../../Dream.js';
  *   }
  * }
  */
-export default function AfterDestroyCommit(): any;
+export default function AfterDestroyCommit(): CommitHookDecorator;
 export declare function afterDestroyCommitImplementation<T extends Dream>(target: T, key: string): void;

package/dist/types/src/decorators/field/lifecycle/AfterSaveCommit.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from '../../../types/lifecycle.js';
+import { AfterHookOpts, CommitHookDecorator } from '../../../types/lifecycle.js';
 /**
  * Calls the decorated method whenever a dream has finished
  * being saved. If the save takes place within a transaction,
@@ -8,6 +8,10 @@ import { AfterHookOpts } from '../../../types/lifecycle.js';
  * a transaction, the method will be run after the save
  * is complete.
  *
+ * The method is called with no argument: the transaction has already
+ * committed, so there is none to hand it. Decorating a method that
+ * declares a parameter is a compile error (see {@link CommitHookDecorator}).
+ *
  * class User extends ApplicationModel {
  *   @deco.AfterSaveCommit()
  *   public doSomething() {
@@ -17,5 +21,5 @@ import { AfterHookOpts } from '../../../types/lifecycle.js';
  *
  * @param opts.ifChanged - Optional. A list of columns which should must change in order for this function to be called.
  */
-export default function AfterSaveCommit<T extends Dream>(opts?: AfterHookOpts<T>): any;
+export default function AfterSaveCommit<T extends Dream>(opts?: AfterHookOpts<T>): CommitHookDecorator;
 export declare function afterSaveCommitImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/decorators/field/lifecycle/AfterUpdateCommit.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../../../Dream.js';
-import { AfterHookOpts } from '../../../types/lifecycle.js';
+import { AfterHookOpts, CommitHookDecorator } from '../../../types/lifecycle.js';
 /**
  * Calls the decorated method whenever a dream has finished
  * being updated. If the save takes place within a transaction,
@@ -8,6 +8,10 @@ import { AfterHookOpts } from '../../../types/lifecycle.js';
  * a transaction, the method will be run after the save
  * is complete.
  *
+ * The method is called with no argument: the transaction has already
+ * committed, so there is none to hand it. Decorating a method that
+ * declares a parameter is a compile error (see {@link CommitHookDecorator}).
+ *
  * class User extends ApplicationModel {
  *   @deco.AfterUpdateCommit()
  *   public doSomething() {
@@ -17,5 +21,5 @@ import { AfterHookOpts } from '../../../types/lifecycle.js';
  *
  * @param opts.ifChanged - Optional. A list of columns which should must change in order for this function to be called.
  */
-export default function AfterUpdateCommit<T extends Dream>(opts?: AfterHookOpts<T>): any;
+export default function AfterUpdateCommit<T extends Dream>(opts?: AfterHookOpts<T>): CommitHookDecorator;
 export declare function afterUpdateCommitImplementation<T extends Dream>(target: T, key: string, opts?: AfterHookOpts<T>): void;

package/dist/types/src/dream/DreamTransaction.d.ts

@@ -8,8 +8,15 @@ export interface TransactionCommitHookStatement {
 export default class DreamTransaction<T extends Dream, DB extends T['DB'] = T['DB']> {
     private _kyselyTransaction;
     private commitHooks;
+    private committed;
     get kyselyTransaction(): Transaction<DB>;
     set kyselyTransaction(txn: Transaction<DB>);
     addCommitHook(hookStatement: HookStatement, dreamInstance: Dream): void;
-    runAfterCommitHooks(txn: DreamTransaction<any>): Promise<void>;
+    /**
+     * Runs the commit hooks queued during the transaction, in the order they
+     * were queued. A query driver calls this once the transaction has
+     * committed. Each hook is called with no argument, since the transaction
+     * it would otherwise receive can no longer run queries.
+     */
+    runAfterCommitHooks(): Promise<void>;
 }

package/dist/types/src/dream/QueryDriver/Base.d.ts

@@ -1,4 +1,5 @@
 import { CompiledQuery, DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
+import type { DreamDbConfig } from '../../dream-app/index.js';
 import Dream from '../../Dream.js';
 import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/ASTBuilder.js';
 import { AssociationStatement } from '../../types/associations/shared.js';
@@ -480,6 +481,8 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      */
     static destroyDream(dream: Dream, txn: DreamTransaction<Dream>, reallyDestroy: boolean): Promise<number>;
     static get syncDialect(): string;
+    /** @internal Resolve the credential used by the database type generator. */
+    static codegenPassword(password: DreamDbConfig['password']): Promise<string>;
     /**
      * Returns the sql that would be executed by this Query
      *

package/dist/types/src/dream/QueryDriver/Kysely.d.ts

@@ -44,6 +44,7 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
         schemaOnly?: boolean;
     }): Promise<void>;
     static get syncDialect(): string;
+    static codegenPassword(password: DreamDbConfig['password']): Promise<string>;
     /**
      * @internal
      *

package/dist/types/src/dream/QueryDriver/helpers/pg/loadPgClient.d.ts

@@ -1,4 +1,9 @@
 import pg from 'pg';
+export declare class PasswordProviderPoolClient extends pg.Client {
+    connect(): Promise<void>;
+    connect(callback: (err: Error) => void): void;
+    private destroyConnectionStream;
+}
 export default function loadPgClient({ connectionName, useSystemDb, }: {
     connectionName: string;
     useSystemDb?: boolean;

package/dist/types/src/dream/internal/runHooksFor.d.ts

@@ -6,3 +6,8 @@ export default function runHooksFor<T extends Dream>(key: HookType, dream: T, al
     now: any;
 }>> | null, txn: DreamTransaction<any> | null): Promise<void>;
 export declare function runHook<T extends Dream>(statement: HookStatement, dream: T, txn: DreamTransaction<any> | null): Promise<void>;
+/**
+ * Commit hooks run after the transaction has committed, so they are called
+ * with no argument.
+ */
+export declare function runCommitHook<T extends Dream>(statement: HookStatement, dream: T): Promise<void>;

package/dist/types/src/dream/internal/withConcurrentWriterRetry.d.ts

@@ -23,7 +23,8 @@ export declare const MAX_CONCURRENT_WRITER_ATTEMPTS = 3;
  * rows mid-statement as well. Either way the database has undone the whole
  * transaction, nothing has committed and no commit hook has run, so running
  * the operation again reads the rows as the other writer left them. The last
- * attempt's error is the adapter's own.
+ * attempt's error is the adapter's own. An error raised after COMMIT, such as a
+ * commit hook's, is never retried.
  *
  * A unique violation raised by a statement inside the callback is not a
  * collision but a write that violates a constraint outright, and is not

package/dist/types/src/dream-app/index.d.ts

@@ -288,7 +288,17 @@ export interface DreamDbCredentialOptions {
 type UnicodeNormalizationForm = 'NFC' | 'NFD' | 'none';
 export interface DreamDbConfig {
     user: string;
-    password: string;
+    /**
+     * A fixed password, or a provider for Dream's built-in PostgreSQL driver.
+     * PostgreSQL calls the provider when the server requests password
+     * authentication for a new physical connection. The provider may return a
+     * string or a promise of one. Each such connection gets a fresh result;
+     * existing pooled connections keep their credential. A rejected provider
+     * fails that connection attempt and reaches its caller; Dream does not cache
+     * credentials or retry. Custom query drivers receive the configured value
+     * and must handle or reject a provider themselves.
+     */
+    password: string | (() => string | Promise<string>);
     host: string;
     name: string;
     port: number;

package/dist/types/src/types/lifecycle.d.ts

@@ -2,6 +2,35 @@ import Dream from '../Dream.js';
 import { DreamColumnNames } from './dream.js';
 export type HookType = 'beforeCreate' | 'beforeSave' | 'beforeUpdate' | 'beforeDestroy' | 'afterCreate' | 'afterSave' | 'afterUpdate' | 'afterDestroy' | CommitHookType;
 export type CommitHookType = 'afterCreateCommit' | 'afterSaveCommit' | 'afterUpdateCommit' | 'afterDestroyCommit';
+/**
+ * The decorator returned by `deco.AfterCreateCommit()`,
+ * `deco.AfterSaveCommit()`, `deco.AfterUpdateCommit()` and
+ * `deco.AfterDestroyCommit()`.
+ *
+ * Dream calls every commit hook with no argument: by the time it runs, the
+ * transaction has already committed, so there is no transaction to hand it.
+ * Decorating an instance method that declares a parameter — required,
+ * optional, defaulted or rest — is therefore a compile error.
+ *
+ * Other placements of the decorator (an arrow-function field, an `accessor`
+ * field, a getter, a static method) are not checked.
+ *
+ * A subclass that overrides a decorated commit hook without decorating the
+ * override is not checked either, so `override hook(txn?: ...)` compiles; at
+ * runtime the override is still called with no argument.
+ */
+export interface CommitHookDecorator {
+    <This, Method extends (...args: any[]) => unknown>(value: This extends abstract new (...args: any[]) => unknown ? Method : CommitHookMethod<Method>, context: ClassMethodDecoratorContext<This, Method>): void;
+    (value: any, context: ClassFieldDecoratorContext<any, any> | ClassGetterDecoratorContext<any, any> | ClassSetterDecoratorContext<any, any> | ClassAccessorDecoratorContext<any, any> | ClassDecoratorContext<any>): void;
+}
+/**
+ * A method a commit-hook decorator accepts: one that declares no parameter.
+ * Any other method resolves to a message naming the problem, which the
+ * decorated method is not assignable to. The parameter tuple is compared
+ * whole, so a rest parameter typed as a union such as `[] | [X]` is rejected
+ * too.
+ */
+export type CommitHookMethod<Method> = Method extends (...args: infer Params) => unknown ? [Params] extends [[]] ? Method : 'a commit hook is called with no argument: remove its parameters' : never;
 export interface HookStatement {
     type: HookType;
     className: string;

package/dist/types/src/types/types/lifecycle.ts

@@ -18,6 +18,52 @@ export type CommitHookType =
   | 'afterUpdateCommit'
   | 'afterDestroyCommit'
 
+/**
+ * The decorator returned by `deco.AfterCreateCommit()`,
+ * `deco.AfterSaveCommit()`, `deco.AfterUpdateCommit()` and
+ * `deco.AfterDestroyCommit()`.
+ *
+ * Dream calls every commit hook with no argument: by the time it runs, the
+ * transaction has already committed, so there is no transaction to hand it.
+ * Decorating an instance method that declares a parameter — required,
+ * optional, defaulted or rest — is therefore a compile error.
+ *
+ * Other placements of the decorator (an arrow-function field, an `accessor`
+ * field, a getter, a static method) are not checked.
+ *
+ * A subclass that overrides a decorated commit hook without decorating the
+ * override is not checked either, so `override hook(txn?: ...)` compiles; at
+ * runtime the override is still called with no argument.
+ */
+export interface CommitHookDecorator {
+  <This, Method extends (...args: any[]) => unknown>(
+    value: This extends abstract new (...args: any[]) => unknown ? Method : CommitHookMethod<Method>,
+    context: ClassMethodDecoratorContext<This, Method>
+  ): void
+  (
+    value: any,
+    context:
+      | ClassFieldDecoratorContext<any, any>
+      | ClassGetterDecoratorContext<any, any>
+      | ClassSetterDecoratorContext<any, any>
+      | ClassAccessorDecoratorContext<any, any>
+      | ClassDecoratorContext<any>
+  ): void
+}
+
+/**
+ * A method a commit-hook decorator accepts: one that declares no parameter.
+ * Any other method resolves to a message naming the problem, which the
+ * decorated method is not assignable to. The parameter tuple is compared
+ * whole, so a rest parameter typed as a union such as `[] | [X]` is rejected
+ * too.
+ */
+export type CommitHookMethod<Method> = Method extends (...args: infer Params) => unknown
+  ? [Params] extends [[]]
+    ? Method
+    : 'a commit hook is called with no argument: remove its parameters'
+  : never
+
 export interface HookStatement {
   type: HookType
   className: string

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJyVk0FPwyAUx7/LO+McuLCVo1tMjHFqYvSw7MDaN0tGYQE60yz77gZ3wTktO0HJ+/P7Aa97cNYGD2JB+YgRSumSgMO1xjIoazyIPVBK42BkgyDgpUXXzZzaobuVHoHARpkKBGUTAq3TIKDU0nv019VqcFI9qEOjgRwrQEDw1VWMXx0XCJS10pVDA2LBimJ5IMCKIqE/dB51l+zaw/9Vf4kBvWGTqBDHxOHZ+vDh0OdbnEn0eEQqH/KEOq2x3Eyt8cFJZcKbslrGJ/oPjc5Z5wd/RXMc2Ch1sLptzNMO3Vrbzxzyj0AOb8QS3kwGeW9K22xlUCuN7yrUcW0lPd4p1FWGQu8eF3UEH3ISL4VQzimhfPzdo/HjRPu12+Lx9HH2qHwjQ1ln+p4P51zfOP1Z5jbMW60vaZXTSB/zcPgCAPBvFw=="
+window.hierarchyData = "eJyVk8FOAjEQht9lzgUpCwvboxATY0RNjB4Ih7I7uA3dlnS6mA3h3U3lsiK65dR2Mv/8X6fTAzhrPYFY8nQ8YZzzFQOHG425V9YQiANwzsNiZIUg4KVG18yd2qO7lYTAYKtMAYIPpwxqp0FAriUR0k2x7p9l90tfaWCnDBDgqegFee8UYJCXShcODYhlMhitjgySwajl/tAQ6qZVtcP/V/41BDxJpgEhrC2GZ0v+wyHFU1xQdHAE13TY7vusxHw7s4a8k8r4N2W1DE/0nzU6Zx31/5LGMCRZm8HqujJPe3QbbT9jnH8IYvzGk5bfXHp5b3Jb7aRXa43vypchtpaEdwp1EYHQWeOqiUiHnIWmMJ5OUsbT7HtGw+EM+7XZ4en2YfeoqJI+LyN5L4tj2pe1P8vC+kWt9TWjci7p8jwevwDboG8X"