@rvoh/dream 2.30.1 → 2.32.0

package/dist/types/src/decorators/field/sortable/helpers/prepareSortableFieldsForDestroy.d.ts

@@ -1,33 +1,50 @@
 import Dream from '../../../../Dream.js';
 import DreamTransaction from '../../../../dream/DreamTransaction.js';
+import { SortableFieldConfig } from '../Sortable.js';
+import { SortableCascadeEdge } from './sortableCascadeEdge.js';
+export interface SortableDestroyPreparation {
+    /**
+     * False when the snapshot read found no row: this destroy has nothing to
+     * vacate, and compacting from the instance's remembered position would shift
+     * a scope some other writer has already closed. The delete's own affected-row
+     * count is the stronger signal (a writer outside the sortable path can remove
+     * the row after this read), so the caller checks both.
+     */
+    rowExists: boolean;
+    /**
+     * The sortable fields whose scope this destroy compacts, for
+     * `performSortableDestroyWork`.
+     */
+    sortableFields: SortableFieldConfig[];
+}
 /**
  * @internal
  *
  * The sortable preparation phase of a destroy. Called from `destroyDream` after
  * every user `beforeDestroy` hook has run and before the delete — a phase, not
- * a hook among them — so the operation's whole advisory key set, across every
- * sortable field, is taken in one sorted stabilized acquisition, with one
- * snapshot SELECT covering all fields. Per-field acquisition would take
- * multi-field keys in declaration order, which deadlocks against the paths
- * that acquire sorted.
+ * a hook among them — so the row's real position and scope values are read in
+ * one snapshot SELECT covering every field while the row still exists.
+ * Pre-delete is the only seat for that read: on a hard destroy the row is gone
+ * afterwards, and a soft destroy nulls the position columns in the same UPDATE
+ * as `deletedAt`. The per-field compactions (`performSortableDestroyWork`)
+ * consume the cached snapshots.
  *
- * Pre-delete is the only seat available for the snapshot read: on a hard
- * destroy the row is gone afterwards, and a soft destroy nulls the position
- * columns in the same UPDATE as `deletedAt`. The lock is taken around the read
- * so the snapshot cannot be invalidated between the read and the compaction;
- * it is transaction-scoped, and `destroyDream` opens a transaction that spans
- * the delete and the after-destroy hooks, so one acquisition covers both.
+ * A direct destroy takes the operation's whole advisory key set — every
+ * sortable field — in one sorted stabilized acquisition around that read, so
+ * the snapshot cannot be invalidated before the compaction; per-field
+ * acquisition would take multi-field keys in declaration order and deadlock
+ * against the paths that acquire sorted. The lock is transaction-scoped, and
+ * `destroyDream` opens a transaction spanning the delete and the after-destroy
+ * hooks, so one acquisition covers both.
  *
- * The per-field compactions (`performSortableDestroyWork`) consume the cached
- * snapshots.
- *
- * @returns false when the snapshot read found no row — this destroy has nothing
- *   to vacate, and compacting from the instance's remembered position would
- *   shift a scope some other writer has already closed. The delete's own
- *   affected-row count is the stronger signal (a writer outside the sortable
- *   path can remove the row after this read), so the caller checks both.
+ * A cascaded destroy — one reached through a `dependent: 'destroy'` association,
+ * which passes the edge it arrived by — takes no scope lock: a cascade would
+ * otherwise hold one per distinct sort scope it touches until the root
+ * transaction commits. It reads the same snapshot unlocked and compacts from
+ * it, and skips both for a field whose whole sort scope the cascade is
+ * destroying, since nothing survives there to observe a compaction.
  */
-export default function prepareSortableFieldsForDestroy(dream: Dream, txn: DreamTransaction<any>): Promise<boolean>;
+export default function prepareSortableFieldsForDestroy(dream: Dream, txn: DreamTransaction<any>, cascadeEdge: SortableCascadeEdge | null): Promise<SortableDestroyPreparation>;
 /**
  * @internal
  *

package/dist/types/src/decorators/field/sortable/helpers/sortableCascadeEdge.d.ts

@@ -0,0 +1,20 @@
+import Dream from '../../../../Dream.js';
+import { HasStatement } from '../../../../types/associations/shared.js';
+export type SortableCascadeEdge = HasStatement<any, any, any, any, 'HasOne' | 'HasMany'>;
+/**
+ * @internal
+ *
+ * Marks a record a `dependent: 'destroy'` cascade is about to destroy or
+ * undestroy, with the association the cascade reached it through. The record's
+ * own destroy or undestroy consumes the mark and does its sortable work without
+ * the scope lock a direct operation takes.
+ */
+export declare function markSortableCascadeEdge(dream: Dream, association: SortableCascadeEdge): void;
+/**
+ * @internal
+ *
+ * The association a cascade reached this record through, or null on a direct
+ * destroy or undestroy. Consuming removes the mark, so a later direct operation
+ * on the same instance cannot inherit a cascade's optimism.
+ */
+export declare function consumeSortableCascadeEdge(dream: Dream): SortableCascadeEdge | null;

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

@@ -1356,13 +1356,15 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      *   {@link Query.delete | delete} (a single statement, no hooks or cascade)
      *   are the right tools for bulk removal.
      *
+     * To bypass a default scope, chain `removeDefaultScope` onto the Query
+     * before calling this method; it is Query state, not an option, and it
+     * carries through to the cascade.
+     *
      * @param options - Options for destroying the instance
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.lock - If true, each batch is re-selected with an exclusive row lock inside its own transaction before being destroyed, making the destroy a compare-and-set. Defaults to false
      * @param options.batchSize - The number of records to process per batch. Must be a positive integer. Defaults to 10 when `lock` is true, and to 1000 otherwise
-     * @param options.bypassAllDefaultScopes - If true, bypasses user-removable default scopes when cascade destroying; an STI child's reserved discriminator remains enforced, including when associations are loaded. Defaults to false
-     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
      * @returns The number of records that were removed
      * @throws InvalidBatchSize if `batchSize` is not a positive integer
      * @throws BatchingIncompatibleWithLimitOrOffset if the query carries a `limit` or `offset`
@@ -1433,11 +1435,12 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      *   transaction ends, so every batch's scope keys are still held when the
      *   next one preflights. That accumulation is bounded — the preflight counts
      *   the keys the transaction already holds along with the ones the batch
-     *   would add, and refuses with `SortableBatchRequiresTooManyScopeLocks`
-     *   rather than letting a long run over a high-cardinality sort scope exhaust
-     *   `max_locks_per_transaction` for the whole cluster — so a run long enough
-     *   raises instead of completing. Letting Dream open a transaction per batch
-     *   releases the keys as it goes and gives each batch the whole budget.
+     *   would add, and raises rather than letting a long run over a
+     *   high-cardinality sort scope exhaust `max_locks_per_transaction` for the
+     *   whole cluster — so a run long enough raises instead of completing. That
+     *   refusal is a sizing failure to fix, not a condition to catch: letting
+     *   Dream open a transaction per batch releases the keys as it goes and gives
+     *   each batch the whole budget, and a smaller `batchSize` takes fewer.
      * - the preflight covers **the claimed rows' own scopes only**. A
      *   `dependent: 'destroy'` cascade under `destroy({ lock: true })` destroys
      *   child records of other tables, and a sortable child takes its own table's
@@ -1454,8 +1457,18 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
     private lockedBatches;
     /**
      * Destroys all records matching the Query,
-     * ignoring the SoftDelete decorator and
-     * permanently removing records from the database.
+     * permanently removing each matched record from
+     * the database instead of soft deleting it.
+     *
+     * The SoftDelete decorator is bypassed when
+     * deleting each matched record, not when
+     * matching: the Query selects under its default
+     * scopes, `dream:SoftDelete` among them, so on a
+     * SoftDelete model it matches only records that
+     * have not already been soft deleted. Reaching
+     * soft deleted records takes
+     * `removeDefaultScope('dream:SoftDelete')` on
+     * the Query.
      *
      * Calls model hooks and applies cascade destroy
      * to associations with `dependent: 'destroy'`,
@@ -1470,17 +1483,26 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * // 12
      * ```
      *
+     * ```ts
+     * await User.removeDefaultScope('dream:SoftDelete')
+     *   .where({ email: ops.ilike('%burpcollaborator%') })
+     *   .reallyDestroy()
+     * // 12
+     * ```
+     *
      * A `limit` or `offset` on the Query is incompatible with `reallyDestroy`,
      * exactly as it is with {@link Query.destroy}: a limit- or offset-carrying
      * Query throws at runtime.
      *
+     * To bypass a default scope, chain `removeDefaultScope` onto the Query
+     * before calling this method; it is Query state, not an option, and it
+     * carries through to the cascade.
+     *
      * @param options - Options for destroying the instance
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.lock - If true, each batch is re-selected with an exclusive row lock inside its own transaction before being destroyed, making the destroy a compare-and-set. See {@link Query.destroy} for the full semantics. Defaults to false
      * @param options.batchSize - The number of records to process per batch. Must be a positive integer. Defaults to 10 when `lock` is true, and to 1000 otherwise
-     * @param options.bypassAllDefaultScopes - If true, bypasses user-removable default scopes when cascade destroying; an STI child's reserved discriminator remains enforced, including when associations are loaded. Defaults to false
-     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
      * @returns The number of records that were removed
      * @throws InvalidBatchSize if `batchSize` is not a positive integer
      * @throws BatchingIncompatibleWithLimitOrOffset if the query carries a `limit` or `offset`
@@ -1509,11 +1531,13 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * re-applied to every window — so a limit- or offset-carrying Query throws
      * at runtime.
      *
+     * To bypass a default scope, chain `removeDefaultScope` onto the Query
+     * before calling this method; it is Query state, not an option, and it
+     * carries through to the cascade. The SoftDelete scope is always bypassed.
+     *
      * @param options - Options for undestroying the instance
      * @param options.skipHooks - If true, skips applying model hooks during the undestroy operation. Defaults to false
      * @param options.cascade - If false, skips undestroying associations marked `dependent: 'destroy'`. Defaults to true
-     * @param options.bypassAllDefaultScopes - If true, bypasses user-removable default scopes when cascade undestroying; an STI child's reserved discriminator remains enforced, including when associations are loaded. Defaults to false
-     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade undestroying (soft delete is always bypassed). Defaults to an empty array
      * @returns The number of records that were removed
      * @throws BatchingIncompatibleWithLimitOrOffset if the query carries a `limit` or `offset`
      */

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

@@ -162,6 +162,26 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * than silently racing on position values.
      */
     static supportsAdvisoryTransactionLocks: boolean;
+    /**
+     * @internal
+     *
+     * Whether `error` is the database refusing a write for violating a unique
+     * constraint. `withConcurrentWriterRetry` asks this of an error raised at
+     * COMMIT, which is where a `DEFERRABLE INITIALLY DEFERRED` constraint — the
+     * one `DreamMigrationHelpers.addDeferrableUniqueConstraint` declares — reports
+     * a collision. A driver that does not recognize one reports false, and nothing
+     * is retried.
+     */
+    static isUniqueConstraintViolation(error: unknown): boolean;
+    /**
+     * @internal
+     *
+     * Whether `error` is the database aborting a transaction to break a deadlock
+     * with another. `withConcurrentWriterRetry` reruns a transaction of Dream's
+     * own that was aborted this way. A driver that does not recognize one reports
+     * false, and nothing is retried.
+     */
+    static isDeadlock(error: unknown): boolean;
     /**
      * @internal
      *

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

@@ -56,6 +56,8 @@ export default class PostgresQueryDriver<DreamInstance extends Dream> extends Ky
      */
     applyRowLock(kyselyQuery: SelectQueryBuilder<any, any, any>, tableAlias: string): SelectQueryBuilder<any, any, any>;
     static supportsAdvisoryTransactionLocks: boolean;
+    static isUniqueConstraintViolation(error: unknown): boolean;
+    static isDeadlock(error: unknown): boolean;
     /**
      * @internal
      *

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

@@ -10,7 +10,9 @@ export interface ReallyDestroyOptions<DreamInstance extends Dream> extends Destr
  *
  * Destroys the Dream and any `dependent: 'destroy'` associations
  * within a transaction. If a transaction is passed, it will be used.
- * Otherwise, a new transaction will be created automatically.
+ * Otherwise, a new transaction will be created automatically, and the
+ * whole destroy is run again if that transaction is undone by a concurrent
+ * writer (see `withConcurrentWriterRetry`).
  * If any of the nested associations fails to destroy, then this
  * record will also fail to destroy. If skipHooks is true, model hooks
  * will be bypassed.

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

@@ -5,11 +5,13 @@ type UndestroyOptions<DreamInstance extends Dream> = Required<OptionalDestroyOpt
 /**
  * @internal
  *
- * Destroys the Dream and any `dependent: 'destroy'` associations
+ * Undestroys the Dream and any `dependent: 'destroy'` associations
  * within a transaction. If a transaction is passed, it will be used.
- * Otherwise, a new transaction will be created automatically.
- * If any of the nested associations fails to destroy, then this
- * record will also fail to destroy. If skipHooks is true, model hooks
+ * Otherwise, a new transaction will be created automatically, and the
+ * whole undestroy is run again if that transaction is undone by a
+ * concurrent writer (see `withConcurrentWriterRetry`).
+ * If any of the nested associations fails to undestroy, then this
+ * record will also fail to undestroy. If skipHooks is true, model hooks
  * will be bypassed.
  */
 export default function undestroyDream<I extends Dream>(dream: I, txn: (DreamTransaction<I> | null) | undefined, options: UndestroyOptions<I>): Promise<I>;

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

@@ -0,0 +1,47 @@
+import Dream from '../../Dream.js';
+import DreamTransaction from '../DreamTransaction.js';
+/**
+ * How many times a destroy or undestroy that opened its own transaction runs
+ * before a failure caused by a concurrent writer escapes. One such failure
+ * needs another writer of the same rows or sort scope during the operation;
+ * three in a row is contention past the point of retrying.
+ */
+export declare const MAX_CONCURRENT_WRITER_ATTEMPTS = 3;
+/**
+ * @internal
+ *
+ * Runs `callback` in a transaction of the model's own, and runs it again when
+ * that transaction is undone by a concurrent writer: a deadlock, or a unique
+ * constraint refusing the COMMIT.
+ *
+ * A cascaded destroy or undestroy does its sortable position work without the
+ * scope lock a direct one takes (see `@deco.Sortable`), so a concurrent writer
+ * of the same sort scope can leave two live rows sharing a position, which the
+ * scope's deferrable unique constraint refuses at COMMIT — or, when both
+ * writers reach COMMIT together, as a deadlock between their two checks. A
+ * cascade holding row locks can deadlock against another writer of the same
+ * 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.
+ *
+ * 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
+ * retried; only a refusal of the COMMIT itself is, which is why the callback
+ * having resolved is part of the test.
+ *
+ * Only a transaction Dream opens is retried. Inside a caller's transaction the
+ * failure is the caller's, and the caller retries the whole transaction.
+ *
+ * Saves are deliberately not run through this. When a direct save and a
+ * cascade collide, the loser is whichever transaction waits first at COMMIT,
+ * and that is usually the save, which is short and reaches COMMIT while the
+ * cascade is still working: it fails with the adapter's deadlock error after
+ * `deadlock_timeout`. That bounded, occasional failure is the accepted price of
+ * cascades holding no scope locks, and the save path's state restore
+ * (`saveDream`) already makes calling `save` again correct. The collision needs
+ * a position write into the same sort scope inside the cascade's window that
+ * picks the same position, which a cascade destroying a scope's owner never
+ * exposes since it writes no position at all.
+ */
+export default function withConcurrentWriterRetry<R>(dreamClass: typeof Dream, callback: (txn: DreamTransaction<any>) => Promise<R>): Promise<R>;

package/dist/types/src/errors/CannotSaveMissingDream.d.ts

@@ -0,0 +1,23 @@
+import Dream from '../Dream.js';
+/**
+ * Raised when saving a persisted instance whose database row no longer exists —
+ * the row was deleted between the moment the instance was loaded and the moment
+ * the save reached the database.
+ *
+ * This is the write-side counterpart of `RecordNotFound`, and applications catch
+ * it for the same reasons: a request updating a record another request has since
+ * deleted should answer 404 or 409 rather than 500, and a background job holding
+ * a stale instance should usually drop the work rather than fail loudly. Nothing
+ * is written when it is raised.
+ *
+ * It does not mean the save was rejected — a save that fails validation raises
+ * `ValidationError`, and a constraint violation raises its own error. It means
+ * the row that the instance stands for is gone.
+ *
+ * Dream raises it from the query driver, so a custom driver overriding
+ * `saveDream` translates its own adapter's empty-result error the same way, as
+ * the test-app MySQL driver does.
+ */
+export default class CannotSaveMissingDream extends Error {
+    constructor(dream: Dream);
+}

package/dist/types/src/errors/SortableBatchRequiresTooManyScopeLocks.d.ts

@@ -1,4 +1,6 @@
 /**
+ * @internal
+ *
  * Raised when a batch of a locked `Query#destroy` or `Query#update` on a
  * sortable model would carry its transaction past the number of advisory
  * sort-scope locks Dream is willing to hold at once.
@@ -27,6 +29,11 @@
  * — a long multi-batch run inside a transaction you opened — either let Dream
  * open a transaction per batch (do not pass a transaction of your own) or
  * commit between runs, which is what releases the locks as it goes.
+ *
+ * Not exported from `@rvoh/dream/errors`. Exceeding the bound is a sizing
+ * mistake in the calling code, not a runtime condition an application can
+ * recover from, so there is nothing for a consumer to catch: the fix is a
+ * smaller batch or a narrower transaction, never a retry.
  */
 export default class SortableBatchRequiresTooManyScopeLocks extends Error {
     dreamClassName: string;

package/dist/types/src/errors/associations/MissingRequiredBelongsToAssociation.d.ts

@@ -44,6 +44,7 @@ export default class MissingRequiredBelongsToAssociation extends Error {
         polymorphic: boolean;
     });
     get message(): string;
+    private get populatedForeignKeyDiagnosticMessage();
     private get foreignKeyMessage();
     private formatValue;
 }

package/dist/types/src/package-exports/errors.d.ts

@@ -1,5 +1,6 @@
 export { pgErrorType } from '../db/errors.js';
 export { default as NonLoadedAssociation } from '../errors/associations/NonLoadedAssociation.js';
+export { default as CannotSaveMissingDream } from '../errors/CannotSaveMissingDream.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from '../errors/CreateOrFindByFailedToCreateAndFind.js';
 export { default as CheckConstraintViolation } from '../errors/db/CheckConstraintViolation.js';
 export { default as ColumnOverflow } from '../errors/db/ColumnOverflow.js';
@@ -12,7 +13,6 @@ export { default as DecryptionParseError } from '../errors/encrypt/DecryptionPar
 export { default as DecryptionRotationError } from '../errors/encrypt/DecryptionRotationError.js';
 export { default as RecordNotFound } from '../errors/RecordNotFound.js';
 export { default as MissingSerializersDefinition } from '../errors/serializers/MissingSerializersDefinition.js';
-export { default as SortableBatchRequiresTooManyScopeLocks } from '../errors/SortableBatchRequiresTooManyScopeLocks.js';
 export { default as SortableScopeDidNotStabilize } from '../errors/SortableScopeDidNotStabilize.js';
 export { default as SortableScopeLockWaitTimedOut } from '../errors/SortableScopeLockWaitTimedOut.js';
 export { default as ValidationError } from '../errors/ValidationError.js';

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJyVkkFPwjAUx7/LOxekY3SsRyEmxoiaGD0QDmV7uIauJW2HWQjf3VQuFdGNU5vm/fv79fUdwBrjHfAlZaOMUEpXBCxuFBZeGu2AH4BSGhYtagQOLw3adm7lHu2tcAgEtlKXwGkyJdBYBRwKJZxDd1Ouh2fVw8rXCsipAjh4Vw5CfHA6IFBUUpUWNfBlko9XRwJJPo7oD61D1Ua3dvB/1V9jQMeUBYWwRg7PxvkPi66/xYVEh0egTrK477MKi+3MaOetkNq/SaNE+KL/0GitsW74V7SPwzSPHYxqav20R7tR5rMP+UegB4+Nsog3F17c68LUO+HlWuG79FU4WwuHdxJV2UOh846rJmKSURKaQihLGKEsTb8HhCXsTPu13eHp9WH3KF0tfFH19L0c7tO+NI08FsYvGqWuGZXzSBfzePwC4ktvDw=="
+window.hierarchyData = "eJyVk0FPwyAUx7/LO+McuLCVo1tMjHFqYvSw7MDaN0tGYQE60yz77gZ3wTktO0HJ+/P7Aa97cNYGD2JB+YgRSumSgMO1xjIoazyIPVBK42BkgyDgpUXXzZzaobuVHoHARpkKBGUTAq3TIKDU0nv019VqcFI9qEOjgRwrQEDw1VWMXx0XCJS10pVDA2LBimJ5IMCKIqE/dB51l+zaw/9Vf4kBvWGTqBDHxOHZ+vDh0OdbnEn0eEQqH/KEOq2x3Eyt8cFJZcKbslrGJ/oPjc5Z5wd/RXMc2Ch1sLptzNMO3Vrbzxzyj0AOb8QS3kwGeW9K22xlUCuN7yrUcW0lPd4p1FWGQu8eF3UEH3ISL4VQzimhfPzdo/HjRPu12+Lx9HH2qHwjQ1ln+p4P51zfOP1Z5jbMW60vaZXTSB/zcPgCAPBvFw=="

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "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"
+window.navigationData = "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"