@zudojs/database 1.3.2 → 1.5.0

package/dist/pagination/pagination.keysetValue.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cursor value comparisons for keyset pagination.
+ *
+ * A `Date` is encoded into a cursor as its ISO string, which carries
+ * millisecond precision. PostgreSQL `timestamp`/`timestamptz` columns keep
+ * microseconds unless declared with precision `(3)`, and Prisma hands rows
+ * back as JavaScript `Date`s, so the exact stored value is not available
+ * to the cursor. Comparing `field = C` against such a column matched
+ * nothing and `field < C` skipped every row created in the same
+ * millisecond as the cursor row.
+ *
+ * A date cursor value is therefore compared as its millisecond bucket
+ * `[C, C + 1ms)`: rows outside the bucket are ordered by the strict
+ * comparison, and rows inside it fall through to the next sort field (the
+ * id tiebreaker `paginateCursor` appends). On millisecond-precision
+ * columns this is exactly the old `=`/`<`/`>` comparison.
+ */
+/**
+ * Whether a cursor value was encoded from a `Date` by `createKeysetCursor`.
+ */
+export declare function isDateCursorValue(value: unknown): value is string;
+/**
+ * The ISO string one millisecond after a date cursor value: the exclusive
+ * upper bound of its millisecond bucket.
+ */
+export declare function nextMillisecond(value: string): string;
+/**
+ * The Prisma filter selecting rows that tie with a cursor value on a sort
+ * field: `{ equals }` for ordinary values, the millisecond bucket for dates.
+ */
+export declare function keysetTieFilter(value: unknown): Readonly<Record<string, unknown>>;
+/**
+ * The Prisma filter selecting rows strictly after (`"gt"`) or before
+ * (`"lt"`) a cursor value on a sort field. For a date the boundary is the
+ * whole millisecond bucket: `lt C` below it, `gte C + 1ms` above it.
+ */
+export declare function keysetStrictFilter(value: unknown, comparison: "gt" | "lt"): Readonly<Record<string, unknown>>;

package/dist/pagination/pagination.keysetValue.js

@@ -0,0 +1,55 @@
+/**
+ * Cursor value comparisons for keyset pagination.
+ *
+ * A `Date` is encoded into a cursor as its ISO string, which carries
+ * millisecond precision. PostgreSQL `timestamp`/`timestamptz` columns keep
+ * microseconds unless declared with precision `(3)`, and Prisma hands rows
+ * back as JavaScript `Date`s, so the exact stored value is not available
+ * to the cursor. Comparing `field = C` against such a column matched
+ * nothing and `field < C` skipped every row created in the same
+ * millisecond as the cursor row.
+ *
+ * A date cursor value is therefore compared as its millisecond bucket
+ * `[C, C + 1ms)`: rows outside the bucket are ordered by the strict
+ * comparison, and rows inside it fall through to the next sort field (the
+ * id tiebreaker `paginateCursor` appends). On millisecond-precision
+ * columns this is exactly the old `=`/`<`/`>` comparison.
+ */
+/** Exactly the shape `Date.prototype.toISOString` emits. */
+const ISO_MILLISECOND_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+/**
+ * Whether a cursor value was encoded from a `Date` by `createKeysetCursor`.
+ */
+export function isDateCursorValue(value) {
+    return (typeof value === "string" &&
+        ISO_MILLISECOND_PATTERN.test(value) &&
+        !Number.isNaN(Date.parse(value)));
+}
+/**
+ * The ISO string one millisecond after a date cursor value: the exclusive
+ * upper bound of its millisecond bucket.
+ */
+export function nextMillisecond(value) {
+    return new Date(Date.parse(value) + 1).toISOString();
+}
+/**
+ * The Prisma filter selecting rows that tie with a cursor value on a sort
+ * field: `{ equals }` for ordinary values, the millisecond bucket for dates.
+ */
+export function keysetTieFilter(value) {
+    if (isDateCursorValue(value)) {
+        return { gte: value, lt: nextMillisecond(value) };
+    }
+    return { equals: value };
+}
+/**
+ * The Prisma filter selecting rows strictly after (`"gt"`) or before
+ * (`"lt"`) a cursor value on a sort field. For a date the boundary is the
+ * whole millisecond bucket: `lt C` below it, `gte C + 1ms` above it.
+ */
+export function keysetStrictFilter(value, comparison) {
+    if (isDateCursorValue(value) && comparison === "gt") {
+        return { gte: nextMillisecond(value) };
+    }
+    return { [comparison]: value };
+}

package/dist/queryBuilder/index.d.ts

@@ -8,4 +8,3 @@ export { createQueryBuilder } from "./queryBuilder.factory.js";
 export { toPrismaWhere, toPrismaArgs, toPrismaOrderBy, toPrismaSelect, toPrismaSkipTake, type PrismaWhere, type PrismaQueryArgs, type ToPrismaArgsOptions, } from "./queryBuilder.prisma.js";
 export type { QueryCondition, QueryFilter, QueryOperator, RelationOperator, QueryBuilderState, } from "./queryBuilder.type.js";
 export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, cloneFilter, between, matchesPattern, isEmpty, isNotEmpty, dateOnly, isBefore, isAfter, isBetween, notCondition, relational, } from "./queryBuilder.filter.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/queryBuilder/index.js

@@ -7,4 +7,3 @@ export { QueryBuilder } from "./queryBuilder.core.js";
 export { createQueryBuilder } from "./queryBuilder.factory.js";
 export { toPrismaWhere, toPrismaArgs, toPrismaOrderBy, toPrismaSelect, toPrismaSkipTake, } from "./queryBuilder.prisma.js";
 export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, cloneFilter, between, matchesPattern, isEmpty, isNotEmpty, dateOnly, isBefore, isAfter, isBetween, notCondition, relational, } from "./queryBuilder.filter.js";
-//# sourceMappingURL=index.js.map

package/dist/queryBuilder/queryBuilder.core.d.ts

@@ -175,4 +175,3 @@ export declare class QueryBuilder<TField extends string = string> {
      */
     private addCondition;
 }
-//# sourceMappingURL=queryBuilder.core.d.ts.map

package/dist/queryBuilder/queryBuilder.core.js

@@ -417,4 +417,3 @@ function deepFreeze(value) {
     }
     return value;
 }
-//# sourceMappingURL=queryBuilder.core.js.map

package/dist/queryBuilder/queryBuilder.factory.d.ts

@@ -3,4 +3,3 @@ import { QueryBuilder } from "./queryBuilder.core.js";
  * Creates a new query builder.
  */
 export declare function createQueryBuilder<TField extends string = string>(): QueryBuilder<TField>;
-//# sourceMappingURL=queryBuilder.factory.d.ts.map

package/dist/queryBuilder/queryBuilder.factory.js

@@ -5,4 +5,3 @@ import { QueryBuilder } from "./queryBuilder.core.js";
 export function createQueryBuilder() {
     return new QueryBuilder();
 }
-//# sourceMappingURL=queryBuilder.factory.js.map

package/dist/queryBuilder/queryBuilder.filter.d.ts

@@ -167,4 +167,3 @@ export declare function flattenAnd(filter: QueryFilter): QueryCondition[];
  */
 export declare function cloneFilter(filter: QueryFilter): QueryFilter;
 export declare function cloneFilter(filter?: QueryFilter): QueryFilter | undefined;
-//# sourceMappingURL=queryBuilder.filter.d.ts.map

package/dist/queryBuilder/queryBuilder.filter.js

@@ -494,4 +494,3 @@ function validateDate(value, name) {
         throw new TypeError(`Invalid ${name} date.`);
     }
 }
-//# sourceMappingURL=queryBuilder.filter.js.map

package/dist/queryBuilder/queryBuilder.prisma.d.ts

@@ -57,4 +57,3 @@ export declare function toPrismaSkipTake(pagination?: PaginationInput, offset?:
     readonly skip?: number;
     readonly take?: number;
 };
-//# sourceMappingURL=queryBuilder.prisma.d.ts.map

package/dist/queryBuilder/queryBuilder.prisma.js

@@ -225,4 +225,3 @@ function validateFieldName(field) {
         throw new TypeError(`Invalid query field name "${String(field)}".`);
     }
 }
-//# sourceMappingURL=queryBuilder.prisma.js.map

package/dist/queryBuilder/queryBuilder.type.d.ts

@@ -45,4 +45,3 @@ export interface QueryBuilderState<TField extends string = string> {
     readonly select?: readonly TField[];
     readonly include?: readonly RelationInclude[];
 }
-//# sourceMappingURL=queryBuilder.type.d.ts.map

package/dist/queryBuilder/queryBuilder.type.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=queryBuilder.type.js.map

package/dist/relations/index.d.ts

@@ -4,4 +4,3 @@
  * Entity relation definitions and registry.
  */
 export { oneToOne, oneToMany, manyToOne, manyToMany, includeRelation, includeRelations, RelationRegistry, createRelationRegistry, validateRelation, validateInclude, toPrismaInclude, DEFAULT_INCLUDE_DEPTH, isRelationType, isCollectionRelation, isSingleRelation, type RelationDefinition, type RelationType, type RelationLoadOptions, type RelationInclude, type ToPrismaIncludeOptions, } from "./relations.definition.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/relations/index.js

@@ -4,4 +4,3 @@
  * Entity relation definitions and registry.
  */
 export { oneToOne, oneToMany, manyToOne, manyToMany, includeRelation, includeRelations, RelationRegistry, createRelationRegistry, validateRelation, validateInclude, toPrismaInclude, DEFAULT_INCLUDE_DEPTH, isRelationType, isCollectionRelation, isSingleRelation, } from "./relations.definition.js";
-//# sourceMappingURL=index.js.map

package/dist/relations/relations.definition.d.ts

@@ -181,4 +181,3 @@ export declare function isCollectionRelation(relation: RelationDefinition): bool
  * Returns whether the relation represents a single entity.
  */
 export declare function isSingleRelation(relation: RelationDefinition): boolean;
-//# sourceMappingURL=relations.definition.d.ts.map

package/dist/relations/relations.definition.js

@@ -379,4 +379,3 @@ function validateFieldName(field) {
         throw new TypeError(`Invalid relation field name "${String(field)}".`);
     }
 }
-//# sourceMappingURL=relations.definition.js.map

package/dist/repository/index.d.ts

@@ -3,7 +3,6 @@
  *
  * Generic repository pattern with Prisma delegate support.
  */
-export { BaseRepository, type BaseRepositoryOptions, type SoftDeleteOptions, type CursorQueryOptions, type TransactionClientLike, } from "./repository.base.js";
+export { BaseRepository, type BaseRepositoryOptions, type SoftDeleteOptions, type CreateCursorOptions, type CursorQueryOptions, type TransactionClientLike, } from "./repository.base.js";
 export { type RepositoryDelegate, type RepositoryDelegateOperations, } from "./repository.delegate.js";
 export { mapRepositoryError, isPrismaErrorLike, toDatabaseOperation, toErrorMetadata, createAbortError, createTimeoutError, type RepositoryOperation, type RepositoryErrorContext, type PrismaErrorLike, } from "./repository.errors.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/repository/index.js

@@ -6,4 +6,3 @@
 export { BaseRepository, } from "./repository.base.js";
 export {} from "./repository.delegate.js";
 export { mapRepositoryError, isPrismaErrorLike, toDatabaseOperation, toErrorMetadata, createAbortError, createTimeoutError, } from "./repository.errors.js";
-//# sourceMappingURL=index.js.map

package/dist/repository/repository.base.d.ts

@@ -1,5 +1,6 @@
 import type { DatabaseOperationOptions, PaginatedResult, QueryOptions, Repository, SoftDeletableRepository, SortInput } from "../databaseType/databaseType.type.js";
 import { type CursorPaginatedResult } from "../pagination/pagination.core.js";
+import { type KeysetDirection } from "../pagination/pagination.keysetDirection.js";
 import type { QueryBuilder } from "../queryBuilder/queryBuilder.core.js";
 import type { QueryBuilderState } from "../queryBuilder/queryBuilder.type.js";
 import type { RelationLoadOptions, RelationRegistry } from "../relations/relations.definition.js";
@@ -61,6 +62,22 @@ export interface CursorQueryOptions<TField extends string = string> extends Data
      */
     readonly sort?: readonly SortInput<TField>[];
 }
+/**
+ * Options for {@link BaseRepository.createCursor}.
+ */
+export interface CreateCursorOptions<TField extends string = string> {
+    /**
+     * The sort the page is fetched with, as passed to `paginateCursor`. The
+     * id field is appended as a tiebreaker when absent, exactly as
+     * `paginateCursor` does.
+     */
+    readonly sort?: readonly SortInput<TField>[];
+    /**
+     * `"forward"` (default) selects the rows after `row`; `"backward"` the
+     * rows before it (a `previousCursor`).
+     */
+    readonly direction?: KeysetDirection;
+}
 /**
  * A Prisma transaction client (or any object exposing model delegates).
  */
@@ -133,6 +150,16 @@ export declare abstract class BaseRepository<TEntity, TId = string, TCreateInput
      * before any query runs.
      */
     paginateCursor<TField extends string = string>(filter?: TWhereInput, options?: CursorQueryOptions<TField>): Promise<CursorPaginatedResult<TEntity>>;
+    /**
+     * Builds a cursor positioned at `row` that `paginateCursor` accepts for
+     * the same `sort`: the id tiebreaker is appended and the cursor is
+     * signed with `cursorSecret` when configured.
+     *
+     * `createKeysetCursor(row, sort)` with the bare sort produces a cursor
+     * without the tiebreaker, which `paginateCursor` rejects as missing the
+     * id field.
+     */
+    createCursor<TField extends string = string>(row: TEntity, options?: CreateCursorOptions<TField>): string;
     /**
      * Finds entities from a query builder (or its built state), applying the
      * filter, sort, select, include and pagination it carries.
@@ -234,4 +261,3 @@ export declare abstract class BaseRepository<TEntity, TId = string, TCreateInput
     private buildCursorSort;
     private rebind;
 }
-//# sourceMappingURL=repository.base.d.ts.map

package/dist/repository/repository.base.js

@@ -1,6 +1,6 @@
 import { DatabaseError } from "@zudojs/errors";
 import { createPaginationMeta, normalizeLimit, normalizePage, } from "../pagination/pagination.core.js";
-import { buildKeysetWhere, createKeysetPage, decodeKeysetCursor, } from "../pagination/pagination.keyset.js";
+import { buildKeysetWhere, createKeysetCursor, createKeysetPage, decodeKeysetCursor, } from "../pagination/pagination.keyset.js";
 import { getKeysetDirection, keysetFetchSort, } from "../pagination/pagination.keysetDirection.js";
 import { toPrismaArgs, toPrismaOrderBy, } from "../queryBuilder/queryBuilder.prisma.js";
 import { toDelegateOperations, } from "./repository.delegate.js";
@@ -188,6 +188,18 @@ export class BaseRepository {
             direction,
         });
     }
+    /**
+     * Builds a cursor positioned at `row` that `paginateCursor` accepts for
+     * the same `sort`: the id tiebreaker is appended and the cursor is
+     * signed with `cursorSecret` when configured.
+     *
+     * `createKeysetCursor(row, sort)` with the bare sort produces a cursor
+     * without the tiebreaker, which `paginateCursor` rejects as missing the
+     * id field.
+     */
+    createCursor(row, options) {
+        return createKeysetCursor(row, this.buildCursorSort(options?.sort), this.cursorSecret, options?.direction ?? "forward");
+    }
     /**
      * Finds entities from a query builder (or its built state), applying the
      * filter, sort, select, include and pagination it carries.
@@ -536,4 +548,3 @@ function validateFieldName(field, name) {
 function lowerFirst(value) {
     return value.length === 0 ? value : value[0].toLowerCase() + value.slice(1);
 }
-//# sourceMappingURL=repository.base.js.map

package/dist/repository/repository.delegate.d.ts

@@ -90,4 +90,3 @@ export interface RepositoryDelegateOperations<TEntity, TId = string, TCreateInpu
  * model delegate accepts at runtime.
  */
 export declare function toDelegateOperations<TEntity, TId, TCreateInput, TUpdateInput, TWhereInput>(delegate: RepositoryDelegate<TEntity, TId, TCreateInput, TUpdateInput, TWhereInput>): RepositoryDelegateOperations<TEntity, TId, TCreateInput, TUpdateInput, TWhereInput>;
-//# sourceMappingURL=repository.delegate.d.ts.map

package/dist/repository/repository.delegate.js

@@ -9,4 +9,3 @@
 export function toDelegateOperations(delegate) {
     return delegate;
 }
-//# sourceMappingURL=repository.delegate.js.map

package/dist/repository/repository.errors.d.ts

@@ -40,6 +40,9 @@ export declare function toDatabaseOperation(operation: RepositoryOperation | str
  * - `P2034` serialization failure → `ERR_DATABASE_TRANSACTION` / 409 (retryable)
  * - `P2024` pool timeout → `ERR_DATABASE_TIMEOUT` / 503
  * - `P1xxx` connection failures → `ERR_DATABASE_CONNECTION` / 503
+ * - every other code `normalizeDatabaseError` knows (`P2000` value too
+ *   long / 400, `P2004` constraint / 409, `P2011` null / 400, `P2014`,
+ *   `P2015`, `P2018`, `P2028`) → the same status, code and exposure
  *
  * Existing `DatabaseError`s are returned unchanged.
  */
@@ -57,4 +60,3 @@ export declare function createTimeoutError(context: Omit<RepositoryErrorContext,
  * package accepts.
  */
 export declare function toErrorMetadata(value?: Readonly<Record<string, unknown>>): ErrorMetadata;
-//# sourceMappingURL=repository.errors.d.ts.map

package/dist/repository/repository.errors.js

@@ -1,5 +1,5 @@
 import { DatabaseError, DatabaseOperation, ErrorCode, } from "@zudojs/errors";
-import { isDatabaseErrorLike } from "../databaseClient/databaseClient.errors.js";
+import { getPrismaCodeMapping, isDatabaseErrorLike, } from "../databaseClient/databaseClient.errors.js";
 const PRISMA_CODE_PATTERN = /^P\d{4}$/;
 /**
  * Determines whether a value looks like a Prisma known request error.
@@ -53,6 +53,9 @@ export function toDatabaseOperation(operation) {
  * - `P2034` serialization failure → `ERR_DATABASE_TRANSACTION` / 409 (retryable)
  * - `P2024` pool timeout → `ERR_DATABASE_TIMEOUT` / 503
  * - `P1xxx` connection failures → `ERR_DATABASE_CONNECTION` / 503
+ * - every other code `normalizeDatabaseError` knows (`P2000` value too
+ *   long / 400, `P2004` constraint / 409, `P2011` null / 400, `P2014`,
+ *   `P2015`, `P2018`, `P2028`) → the same status, code and exposure
  *
  * Existing `DatabaseError`s are returned unchanged.
  */
@@ -139,6 +142,16 @@ export function mapRepositoryError(error, context) {
             statusCode: 503,
         });
     }
+    const mapping = getPrismaCodeMapping(error.code);
+    if (mapping !== undefined) {
+        return new DatabaseError(`${context.model} ${context.operation} failed: ${lowerFirst(mapping.message)}`, {
+            ...options,
+            code: mapping.code,
+            statusCode: mapping.statusCode,
+            expose: mapping.expose,
+            metadata: { ...metadata, kind: mapping.kind },
+        });
+    }
     return new DatabaseError(`${context.model} ${context.operation} failed.`, {
         ...options,
         code: ErrorCode.DATABASE_QUERY,
@@ -222,6 +235,9 @@ function toMetadataValue(value) {
     }
     return String(value);
 }
+function lowerFirst(value) {
+    return value.length === 0 ? value : value[0].toLowerCase() + value.slice(1);
+}
 function extractTarget(meta) {
     const target = meta?.["target"];
     if (typeof target === "string") {
@@ -232,4 +248,3 @@ function extractTarget(meta) {
     }
     return undefined;
 }
-//# sourceMappingURL=repository.errors.js.map

package/dist/seed/index.d.ts

@@ -4,4 +4,3 @@
  * Database seed runner with execution tracking (PostgreSQL).
  */
 export { SeedRunner, createSeedRunner, normalizeSeeds, validateSeed, DEFAULT_SEED_TABLE, DEFAULT_SEED_LOCK, type Seed, type SeedRecord, type SeedResult, type SeedStatus, type SeedRunnerOptions, } from "./seed.runner.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/seed/index.js

@@ -4,4 +4,3 @@
  * Database seed runner with execution tracking (PostgreSQL).
  */
 export { SeedRunner, createSeedRunner, normalizeSeeds, validateSeed, DEFAULT_SEED_TABLE, DEFAULT_SEED_LOCK, } from "./seed.runner.js";
-//# sourceMappingURL=index.js.map

package/dist/seed/seed.runner.d.ts

@@ -3,8 +3,11 @@ import { type SqlDialectName } from "../migration/migration.dialect.js";
 import type { RunnerTransactionOptions } from "../migration/migration.types.js";
 /**
  * Defines a database seed operation.
+ *
+ * `TTransaction` is the transaction client handed to `run` and `rollback`;
+ * {@link createSeedRunner} infers it from the database client.
  */
-export interface Seed {
+export interface Seed<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext> {
     /**
      * Unique seed name.
      */
@@ -16,11 +19,11 @@ export interface Seed {
     /**
      * Executes the seed.
      */
-    readonly run: (database: DatabaseTransactionContext) => Promise<void>;
+    readonly run: (database: TTransaction) => Promise<void>;
     /**
      * Optional cleanup operation.
      */
-    readonly rollback?: (database: DatabaseTransactionContext) => Promise<void>;
+    readonly rollback?: (database: TTransaction) => Promise<void>;
 }
 /**
  * Persisted seed execution record.
@@ -45,8 +48,8 @@ export interface SeedResult {
 /**
  * Seed runner status.
  */
-export interface SeedStatus {
-    readonly pending: readonly Seed[];
+export interface SeedStatus<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext> {
+    readonly pending: readonly Seed<TTransaction>[];
     readonly applied: readonly SeedRecord[];
 }
 /**
@@ -91,7 +94,7 @@ export declare const DEFAULT_SEED_LOCK = "database:seeds";
  * lock before deciding what to execute, so two runners started together
  * never apply or revert the same seed twice.
  */
-export declare class SeedRunner {
+export declare class SeedRunner<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext> {
     private readonly client;
     private readonly seeds;
     private readonly tableName;
@@ -99,11 +102,11 @@ export declare class SeedRunner {
     private readonly dialect;
     private readonly transactionOptions;
     private readonly perItemTransaction;
-    constructor(client: DatabaseClient, seeds: readonly Seed[], options?: SeedRunnerOptions);
+    constructor(client: DatabaseClient<TTransaction>, seeds: readonly Seed<TTransaction>[], options?: SeedRunnerOptions);
     /**
      * Returns the seed runner status.
      */
-    status(): Promise<SeedStatus>;
+    status(): Promise<SeedStatus<TTransaction>>;
     /**
      * Executes every pending seed in order.
      */
@@ -148,13 +151,12 @@ export declare class SeedRunner {
 /**
  * Creates a seed runner.
  */
-export declare function createSeedRunner(client: DatabaseClient, seeds: readonly Seed[], options?: SeedRunnerOptions): SeedRunner;
+export declare function createSeedRunner<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext>(client: DatabaseClient<TTransaction>, seeds: readonly Seed<TTransaction>[], options?: SeedRunnerOptions): SeedRunner<TTransaction>;
 /**
  * Validates and sorts seed definitions (stable sort on `order`).
  */
-export declare function normalizeSeeds(seeds: readonly Seed[]): readonly Seed[];
+export declare function normalizeSeeds<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext>(seeds: readonly Seed<TTransaction>[]): readonly Seed<TTransaction>[];
 /**
  * Validates one seed definition.
  */
-export declare function validateSeed(seed: Seed): void;
-//# sourceMappingURL=seed.runner.d.ts.map
+export declare function validateSeed<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext>(seed: Seed<TTransaction>): void;

package/dist/seed/seed.runner.js

@@ -368,4 +368,3 @@ function validateSeedName(name) {
         throw new TypeError("Seed name cannot exceed 255 characters.");
     }
 }
-//# sourceMappingURL=seed.runner.js.map

package/dist/transaction/index.d.ts

@@ -4,4 +4,3 @@
  * Managed transaction execution with retry support.
  */
 export { TransactionManager, createTransactionManager, withTransaction, withTransactionRetry, createTransactionContext, createTransactionId, getTransactionContextFromError, isTransactionActive, isTransactionCommitted, isTransactionFailed, type TransactionStatus, type TransactionContext, type TransactionOutcome, type TransactionRetryOptions, type ManagedTransactionOptions, } from "./transaction.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/transaction/index.js

@@ -4,4 +4,3 @@
  * Managed transaction execution with retry support.
  */
 export { TransactionManager, createTransactionManager, withTransaction, withTransactionRetry, createTransactionContext, createTransactionId, getTransactionContextFromError, isTransactionActive, isTransactionCommitted, isTransactionFailed, } from "./transaction.core.js";
-//# sourceMappingURL=index.js.map

package/dist/transaction/transaction.backoff.d.ts

@@ -30,4 +30,3 @@ export interface RetryDelayOptions {
  * @returns A finite delay in `[0, min(maxRetryDelayMs, 2^31-1)]`.
  */
 export declare function computeRetryDelay(attempt: number, options: RetryDelayOptions): number;
-//# sourceMappingURL=transaction.backoff.d.ts.map

package/dist/transaction/transaction.backoff.js

@@ -29,4 +29,3 @@ export function computeRetryDelay(attempt, options) {
     const random = options.random ?? Math.random;
     return Math.floor(random() * (capped + 1));
 }
-//# sourceMappingURL=transaction.backoff.js.map

package/dist/transaction/transaction.core.d.ts

@@ -5,7 +5,14 @@ import type { TransactionIsolationLevel, TransactionOptions } from "../databaseT
  */
 export type TransactionStatus = "idle" | "active" | "committed" | "rolled-back" | "failed";
 /**
- * Runtime transaction information.
+ * Runtime transaction information: the immutable status record
+ * `TransactionManager.run` reports in its `TransactionOutcome` and attaches
+ * to failures (see `getTransactionContextFromError`).
+ *
+ * Not the `TransactionContext` of `@zudojs/transactions`, which is the
+ * AsyncLocalStorage store its manager propagates transactions through.
+ * The two packages share the name but not the concept; import from the
+ * package whose manager you use.
  */
 export interface TransactionContext {
     readonly transactionId: string;
@@ -64,15 +71,18 @@ export interface TransactionRetryOptions extends ManagedTransactionOptions {
 export declare function createTransactionId(): string;
 /**
  * Manages transaction execution and lifecycle metadata.
+ *
+ * `TTransaction` is the transaction client handed to callbacks, taken from
+ * the {@link DatabaseClient} the manager wraps.
  */
-export declare class TransactionManager {
+export declare class TransactionManager<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext> {
     private readonly client;
-    constructor(client: DatabaseClient);
+    constructor(client: DatabaseClient<TTransaction>);
     /**
      * Executes a callback inside a managed transaction and returns its
      * result.
      */
-    execute<TResult>(callback: (transaction: DatabaseTransactionContext, context: TransactionContext) => Promise<TResult>, options?: ManagedTransactionOptions): Promise<TResult>;
+    execute<TResult>(callback: (transaction: TTransaction, context: TransactionContext) => Promise<TResult>, options?: ManagedTransactionOptions): Promise<TResult>;
     /**
      * Executes a callback inside a managed transaction and returns the
      * result together with the final context (`status: "committed"`).
@@ -86,16 +96,16 @@ export declare class TransactionManager {
      * `NotFoundError` or `DomainError`) rolls the transaction back and is
      * rethrown as the same, unmodified instance.
      */
-    run<TResult>(callback: (transaction: DatabaseTransactionContext, context: TransactionContext) => Promise<TResult>, options?: ManagedTransactionOptions): Promise<TransactionOutcome<TResult>>;
+    run<TResult>(callback: (transaction: TTransaction, context: TransactionContext) => Promise<TResult>, options?: ManagedTransactionOptions): Promise<TransactionOutcome<TResult>>;
     /**
      * Returns the database client used by the manager.
      */
-    getClient(): DatabaseClient;
+    getClient(): DatabaseClient<TTransaction>;
 }
 /**
  * Creates a transaction manager.
  */
-export declare function createTransactionManager(client: DatabaseClient): TransactionManager;
+export declare function createTransactionManager<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext>(client: DatabaseClient<TTransaction>): TransactionManager<TTransaction>;
 /**
  * Executes a managed database transaction.
  *
@@ -104,7 +114,7 @@ export declare function createTransactionManager(client: DatabaseClient): Transa
  * validation, not-found, ...) propagates unchanged; driver and database
  * failures and any other thrown value become a `DatabaseError`.
  */
-export declare function withTransaction<TResult>(client: DatabaseClient, callback: (transaction: DatabaseTransactionContext, context: TransactionContext) => Promise<TResult>, options?: ManagedTransactionOptions): Promise<TResult>;
+export declare function withTransaction<TResult, TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext>(client: DatabaseClient<TTransaction>, callback: (transaction: TTransaction, context: TransactionContext) => Promise<TResult>, options?: ManagedTransactionOptions): Promise<TResult>;
 /**
  * Executes a transaction with retry support.
  *
@@ -112,9 +122,16 @@ export declare function withTransaction<TResult>(client: DatabaseClient, callbac
  * callback must be idempotent with respect to any side effects performed
  * outside the transaction client (for example, sending emails).
  */
-export declare function withTransactionRetry<TResult>(client: DatabaseClient, callback: (transaction: DatabaseTransactionContext, context: TransactionContext) => Promise<TResult>, options?: TransactionRetryOptions): Promise<TResult>;
+export declare function withTransactionRetry<TResult, TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext>(client: DatabaseClient<TTransaction>, callback: (transaction: TTransaction, context: TransactionContext) => Promise<TResult>, options?: TransactionRetryOptions): Promise<TResult>;
 /**
- * Creates an immutable transaction context.
+ * Creates an immutable transaction status record (see
+ * {@link TransactionContext}), as `TransactionManager.run` does for every
+ * transaction it opens.
+ *
+ * Unrelated to `createTransactionContext` from `@zudojs/transactions`,
+ * which creates the AsyncLocalStorage propagation store that package's
+ * manager runs callbacks in. This one holds no transaction and propagates
+ * nothing; it is data for logging and error reporting.
  */
 export declare function createTransactionContext(options?: ManagedTransactionOptions): TransactionContext;
 /**
@@ -134,4 +151,3 @@ export declare function isTransactionCommitted(context: TransactionContext): boo
  * Determines whether a transaction failed.
  */
 export declare function isTransactionFailed(context: TransactionContext): boolean;
-//# sourceMappingURL=transaction.core.d.ts.map

package/dist/transaction/transaction.core.js

@@ -12,6 +12,9 @@ export function createTransactionId() {
 }
 /**
  * Manages transaction execution and lifecycle metadata.
+ *
+ * `TTransaction` is the transaction client handed to callbacks, taken from
+ * the {@link DatabaseClient} the manager wraps.
  */
 export class TransactionManager {
     client;
@@ -120,7 +123,14 @@ export async function withTransactionRetry(client, callback, options = {}) {
     }
 }
 /**
- * Creates an immutable transaction context.
+ * Creates an immutable transaction status record (see
+ * {@link TransactionContext}), as `TransactionManager.run` does for every
+ * transaction it opens.
+ *
+ * Unrelated to `createTransactionContext` from `@zudojs/transactions`,
+ * which creates the AsyncLocalStorage propagation store that package's
+ * manager runs callbacks in. This one holds no transaction and propagates
+ * nothing; it is data for logging and error reporting.
  */
 export function createTransactionContext(options = {}) {
     return Object.freeze({
@@ -201,4 +211,3 @@ function sleep(milliseconds) {
         setTimeout(resolve, milliseconds);
     });
 }
-//# sourceMappingURL=transaction.core.js.map

package/dist/unitOfWork/index.d.ts

@@ -4,4 +4,3 @@
  * Groups multiple repository operations into a single transaction.
  */
 export { DatabaseUnitOfWork, createUnitOfWork, executeUnitOfWork, type UnitOfWork, type UnitOfWorkOptions, } from "./unitOfWork.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/unitOfWork/index.js

@@ -4,4 +4,3 @@
  * Groups multiple repository operations into a single transaction.
  */
 export { DatabaseUnitOfWork, createUnitOfWork, executeUnitOfWork, } from "./unitOfWork.core.js";
-//# sourceMappingURL=index.js.map