@zudojs/database 1.3.2 → 1.5.0

package/README.md

@@ -81,6 +81,49 @@ repository passes (`RepositoryDelegateOperations`).
 `adapter` (in which case it constructs the `PrismaClient` for you). It throws a
 `DatabaseError` if neither is supplied.
 
+### Typed transaction clients
+
+The transaction client handed to `transaction()` callbacks is inferred from the
+`prisma` instance you pass, so model delegates keep the types of your generated
+client. This works with Prisma 7's `prisma-client` generator (client generated
+into your application, e.g. `src/generated/prisma`) and with the legacy
+`prisma-client-js` generator alike; the package's published types never import
+`@prisma/client`, so they compile with `skipLibCheck: false`.
+
+```typescript
+import { PrismaClient } from "./generated/prisma/client.js";
+
+const client = createDatabaseClient({ prisma: new PrismaClient({ adapter }) });
+
+await client.transaction(async (tx) => {
+  await tx.user.create({ data: { email: "bob@example.com", name: "Bob" } }); // fully typed
+});
+```
+
+`withTransaction`, `withTransactionRetry`, `TransactionManager`,
+`DatabaseUnitOfWork`, the `Database` facade, the lock manager and the
+migration and seed runners all take the type from the client they wrap.
+
+When the concrete client type is unknown (`new DatabaseClient(options)`,
+`createDatabaseClient({ adapter })`, `getDatabase()`), callbacks receive
+`DatabaseTransactionContext`: the raw-query surface (`$queryRaw`,
+`$executeRaw`, `$queryRawUnsafe`, `$executeRawUnsafe`) without model
+delegates. Pass the client type to opt in, for example
+`createDatabaseClient<PrismaClient>({ adapter })`. `TransactionClientOf<typeof
+prisma>` names the inferred type if you need to annotate it.
+
+The adapter-only form constructs `PrismaClient` from `@prisma/client` at
+runtime, which only exists with the `prisma-client-js` generator. With the
+`prisma-client` generator, construct the client yourself and pass it as
+`prisma`.
+
+**Writing your own transaction client** (a hand-written adapter, a test
+double, a PGlite wrapper): since 1.4.0 `DatabaseTransactionContext` is a real
+structural type rather than a type that resolved to `any`, so an object you
+return as one must implement all four raw-query methods — `$queryRaw`,
+`$executeRaw`, `$queryRawUnsafe` and `$executeRawUnsafe` — or TypeScript
+reports TS2739. Code that only *receives* a transaction client is unaffected.
+
 ## Querying
 
 ```typescript
@@ -137,6 +180,21 @@ cursor or its contents. Building keyset pages by hand? Fetch with
 `keysetFetchSort(sort, getKeysetDirection(payload))` and pass that
 `direction` to `createKeysetPage`.
 
+`paginateCursor` appends the id field to `sort` as a tiebreaker, so a cursor
+positioned at a row you hold must include it: use
+`users.createCursor(row, { sort })` (signed with `cursorSecret`), not
+`createKeysetCursor(row, sort)` with the bare sort, which `paginateCursor`
+rejects as missing the id field.
+
+A `Date` sort value is encoded at millisecond precision. PostgreSQL
+`timestamp`/`timestamptz` columns keep microseconds unless declared `(3)`,
+and Prisma returns `Date`s, so the cursor compares such a value as its
+millisecond bucket (`>= C AND < C + 1ms` for a tie) and lets the id
+tiebreaker order rows created in the same millisecond. That is exact for
+identical timestamps (rows inserted by one statement or transaction) and for
+ids that increase with insertion order (serial, ULID, UUIDv7) — with random
+ids, sort by a millisecond-precision column or add a monotonic tiebreaker.
+
 ## Migrations and seeds
 
 ```typescript
@@ -180,6 +238,31 @@ Each migration or seed runs in its own transaction by default
 (`perItemTransaction: true`); pass `transaction: { timeoutMs, maxWaitMs, isolationLevel }`
 to size it for long-running steps.
 
+A migration that cannot run inside a transaction (`CREATE INDEX CONCURRENTLY`,
+`ALTER TYPE ... ADD VALUE`) sets `transaction: false`. Its `up`/`down` then
+receive the root client and run outside any transaction; the applied check
+and the history record still happen in short transactions under the advisory
+lock, which is released while the body runs, so write such a migration
+idempotently (`IF NOT EXISTS`). It requires `perItemTransaction: true`; a
+batch runner refuses it at construction.
+
+```typescript
+{
+  version: 20260926120000,
+  name: "orders_customer_idx",
+  transaction: false,
+  up: (db) => db.$executeRawUnsafe(
+    'CREATE INDEX CONCURRENTLY IF NOT EXISTS "orders_customer_idx" ON "orders" ("customerId")',
+  ),
+  down: (db) => db.$executeRawUnsafe('DROP INDEX CONCURRENTLY IF EXISTS "orders_customer_idx"'),
+}
+```
+
+`createTransactionContext` here builds the immutable status record that
+`TransactionManager.run` reports (`transactionId`, `startedAt`, `status`);
+it is unrelated to the `createTransactionContext` of `@zudojs/transactions`,
+which creates that package's AsyncLocalStorage propagation store.
+
 ## Errors
 
 Errors your own transaction callback throws that are already `@zudojs/errors`

package/dist/cache/cache.memory.d.ts

@@ -164,4 +164,3 @@ export declare function getOrSet<TValue>(cache: DatabaseCache<TValue>, key: stri
  * namespace only.
  */
 export declare function invalidateByPrefix(cache: DatabaseCache, prefix: string): number;
-//# sourceMappingURL=cache.memory.d.ts.map

package/dist/cache/cache.memory.js

@@ -374,4 +374,3 @@ function validateKey(key) {
         throw new TypeError("A non-empty cache key is required.");
     }
 }
-//# sourceMappingURL=cache.memory.js.map

package/dist/cache/index.d.ts

@@ -4,4 +4,3 @@
  * In-memory LRU cache for database read results.
  */
 export { MemoryDatabaseCache, createDatabaseCache, createCacheKey, escapeCachePart, serializeCachePart, getOrSet, invalidateByPrefix, CACHE_KEY_SEPARATOR, type CacheEntry, type CacheOptions, type MemoryCacheOptions, type CacheStats, type DatabaseCache, } from "./cache.memory.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/cache/index.js

@@ -4,4 +4,3 @@
  * In-memory LRU cache for database read results.
  */
 export { MemoryDatabaseCache, createDatabaseCache, createCacheKey, escapeCachePart, serializeCachePart, getOrSet, invalidateByPrefix, CACHE_KEY_SEPARATOR, } from "./cache.memory.js";
-//# sourceMappingURL=index.js.map

package/dist/database/database.core.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseClient, type DatabaseClientOptions, type DatabaseTransactionContext, type PrismaClientLike } from "../databaseClient/databaseClient.core.js";
+import { DatabaseClient, type DatabaseClientOptions, type DatabaseTransactionContext, type PrismaClientLike, type TransactionClientOf } from "../databaseClient/databaseClient.core.js";
 import type { DatabaseHealth, DatabaseStatus, TransactionCallback, TransactionOptions } from "../databaseType/databaseType.type.js";
 /**
  * Database facade used by the application layer.
@@ -6,14 +6,18 @@ import type { DatabaseHealth, DatabaseStatus, TransactionCallback, TransactionOp
  * This module provides a single database lifecycle entry point while
  * keeping the underlying Prisma client implementation inside the
  * database package.
+ *
+ * `TTransaction` is the transaction client handed to `transaction()`
+ * callbacks. {@link createDatabase} infers it from the wrapped client or
+ * from `options.prisma`.
  */
-export declare class Database {
+export declare class Database<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext> {
     private readonly client;
     /**
      * @param options Client options, or an existing {@link DatabaseClient}
      * to wrap so a single client is shared by the facade and other managers.
      */
-    constructor(options?: DatabaseClientOptions | DatabaseClient);
+    constructor(options?: DatabaseClientOptions | DatabaseClient<TTransaction>);
     /**
      * Initializes the database connection.
      */
@@ -41,14 +45,14 @@ export declare class Database {
     /**
      * Executes work inside a database transaction.
      */
-    transaction<TResult>(callback: TransactionCallback<DatabaseTransactionContext, TResult>, options?: TransactionOptions): Promise<TResult>;
+    transaction<TResult>(callback: TransactionCallback<TTransaction, TResult>, options?: TransactionOptions): Promise<TResult>;
     /**
      * Returns the underlying database client.
      *
      * This should primarily be used by repository and infrastructure
      * implementations that require direct Prisma access.
      */
-    getClient(): DatabaseClient;
+    getClient(): DatabaseClient<TTransaction>;
     /**
      * Returns the underlying Prisma client.
      */
@@ -59,7 +63,17 @@ export declare class Database {
     destroy(): Promise<void>;
 }
 /**
- * Creates a database facade.
+ * Creates a database facade over an existing client, keeping its
+ * transaction client type.
+ */
+export declare function createDatabase<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext>(client: DatabaseClient<TTransaction>): Database<TTransaction>;
+/**
+ * Creates a database facade from client options. The transaction client
+ * type is inferred from `options.prisma`.
+ */
+export declare function createDatabase<TClient extends PrismaClientLike = PrismaClientLike>(options?: DatabaseClientOptions<TClient>): Database<TransactionClientOf<TClient>>;
+/**
+ * Creates a database facade from client options or an existing client.
  */
 export declare function createDatabase(options?: DatabaseClientOptions | DatabaseClient): Database;
 /**
@@ -88,4 +102,3 @@ export declare function disconnectDatabase(): Promise<void>;
  * runtime environments.
  */
 export declare function resetDatabase(): Promise<void>;
-//# sourceMappingURL=database.core.d.ts.map

package/dist/database/database.core.js

@@ -1,10 +1,14 @@
-import { DatabaseClient, createDatabaseClient, } from "../databaseClient/databaseClient.core.js";
+import { DatabaseClient, } from "../databaseClient/databaseClient.core.js";
 /**
  * Database facade used by the application layer.
  *
  * This module provides a single database lifecycle entry point while
  * keeping the underlying Prisma client implementation inside the
  * database package.
+ *
+ * `TTransaction` is the transaction client handed to `transaction()`
+ * callbacks. {@link createDatabase} infers it from the wrapped client or
+ * from `options.prisma`.
  */
 export class Database {
     client;
@@ -14,7 +18,9 @@ export class Database {
      */
     constructor(options = {}) {
         this.client =
-            options instanceof DatabaseClient ? options : createDatabaseClient(options);
+            options instanceof DatabaseClient
+                ? options
+                : new DatabaseClient(options);
     }
     /**
      * Initializes the database connection.
@@ -80,9 +86,6 @@ export class Database {
         await this.client.destroy();
     }
 }
-/**
- * Creates a database facade.
- */
 export function createDatabase(options = {}) {
     return new Database(options);
 }
@@ -147,4 +150,3 @@ export async function resetDatabase() {
     defaultDatabase = undefined;
     await database.destroy();
 }
-//# sourceMappingURL=database.core.js.map

package/dist/database/index.d.ts

@@ -4,4 +4,3 @@
  * High-level database lifecycle entry point.
  */
 export { Database, createDatabase, getDatabase, connectDatabase, disconnectDatabase, resetDatabase, } from "./database.core.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/database/index.js

@@ -4,4 +4,3 @@
  * High-level database lifecycle entry point.
  */
 export { Database, createDatabase, getDatabase, connectDatabase, disconnectDatabase, resetDatabase, } from "./database.core.js";
-//# sourceMappingURL=index.js.map

package/dist/databaseClient/databaseClient.core.d.ts

@@ -11,14 +11,10 @@
  * Only PostgreSQL is exercised by the runners, locks and health helpers in
  * this package.
  */
-import type { Prisma } from "@prisma/client";
 import { DatabaseError } from "@zudojs/errors";
 import type { DatabaseClient as DatabaseClientContract, DatabaseConnectionOptions, DatabaseHealth, DatabaseLogger, DatabaseOperationOptions, DatabaseStatus, TransactionCallback, TransactionIsolationLevel, TransactionOptions } from "../databaseType/databaseType.type.js";
-/**
- * Transaction client handed to callbacks. This is Prisma's interactive
- * transaction client (model delegates plus raw query helpers).
- */
-export type DatabaseTransactionContext = Prisma.TransactionClient;
+import type { DatabaseTransactionContext, PrismaSqlLike, TransactionClientOf } from "./databaseClient.type.js";
+export type { DatabaseTransactionContext, PrismaSqlLike, TransactionClientOf, } from "./databaseClient.type.js";
 /**
  * Isolation levels accepted by Prisma's interactive transactions. The
  * values are identical to the string names, so no namespace lookup is
@@ -79,12 +75,15 @@ export interface PrismaDriverAdapterLike {
  * Prisma 7 requires either a driver adapter or an already constructed
  * client; connection URLs, pool sizes and SSL flags are configured on the
  * adapter and are therefore not accepted here.
+ *
+ * `TClient` is the type of `prisma`; {@link createDatabaseClient} infers
+ * it to type the transaction client handed to callbacks.
  */
-export interface DatabaseClientOptions extends Pick<DatabaseConnectionOptions, "connectionTimeoutMs" | "logging"> {
+export interface DatabaseClientOptions<TClient extends PrismaClientLike = PrismaClientLike> extends Pick<DatabaseConnectionOptions, "connectionTimeoutMs" | "logging"> {
     /**
      * Pre-built Prisma client. Takes precedence over `adapter`.
      */
-    readonly prisma?: PrismaClientLike;
+    readonly prisma?: TClient;
     /**
      * Prisma driver adapter used to construct a client when `prisma` is
      * not supplied.
@@ -102,8 +101,15 @@ export type RawQueryOptions = DatabaseOperationOptions;
  * `connect()` de-duplicates concurrent calls through a shared in-flight
  * promise, and `disconnect()` waits for an in-flight connect before
  * tearing the client down.
+ *
+ * `TTransaction` is the client handed to `transaction()` callbacks.
+ * {@link createDatabaseClient} infers it from the Prisma client passed as
+ * `prisma`, so `tx.user.create(...)` is typed by the generated client. The
+ * constructor cannot infer it; `new DatabaseClient(options)` uses the
+ * structural {@link DatabaseTransactionContext} unless a type argument is
+ * given.
  */
-export declare class DatabaseClient implements DatabaseClientContract<DatabaseTransactionContext> {
+export declare class DatabaseClient<TTransaction extends DatabaseTransactionContext = DatabaseTransactionContext> implements DatabaseClientContract<TTransaction> {
     private readonly prisma;
     private readonly logger;
     private readonly options;
@@ -151,7 +157,7 @@ export declare class DatabaseClient implements DatabaseClientContract<DatabaseTr
      * being logged as a database failure. Driver and database failures, and
      * any other thrown value, are normalised to a `DatabaseError` and logged.
      */
-    transaction<TResult>(callback: TransactionCallback<DatabaseTransactionContext, TResult>, options?: TransactionOptions): Promise<TResult>;
+    transaction<TResult>(callback: TransactionCallback<TTransaction, TResult>, options?: TransactionOptions): Promise<TResult>;
     /**
      * Executes a raw statement with positional parameters and returns the
      * affected row count.
@@ -166,11 +172,11 @@ export declare class DatabaseClient implements DatabaseClientContract<DatabaseTr
      *
      * Only available when the underlying client supports `$executeRaw`.
      */
-    executeRaw(query: Prisma.Sql, options?: RawQueryOptions): Promise<number>;
+    executeRaw(query: PrismaSqlLike, options?: RawQueryOptions): Promise<number>;
     /**
      * Executes a `Prisma.sql` tagged query.
      */
-    queryRaw<TResult = unknown>(query: Prisma.Sql, options?: RawQueryOptions): Promise<TResult>;
+    queryRaw<TResult = unknown>(query: PrismaSqlLike, options?: RawQueryOptions): Promise<TResult>;
     ensureConnected(): Promise<void>;
     destroy(): Promise<void>;
     private registerQueryLogging;
@@ -209,6 +215,15 @@ export declare function createAbortError(signal?: AbortSignal): DatabaseAbortErr
  * running. The abort listener is removed once the operation settles.
  */
 export declare function raceAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
-/** Creates a database client. */
-export declare function createDatabaseClient(options?: DatabaseClientOptions): DatabaseClient;
-//# sourceMappingURL=databaseClient.core.d.ts.map
+/**
+ * Creates a database client.
+ *
+ * The transaction client handed to `transaction()` callbacks is inferred
+ * from `options.prisma`: with a generated client it is that client's own
+ * interactive transaction client, so model delegates are fully typed.
+ * Without `prisma` (adapter only) it is the structural
+ * {@link DatabaseTransactionContext}; pass the generated client type as a
+ * type argument (`createDatabaseClient<PrismaClient>({ adapter })`) to type
+ * the delegates.
+ */
+export declare function createDatabaseClient<TClient extends PrismaClientLike = PrismaClientLike>(options?: DatabaseClientOptions<TClient>): DatabaseClient<TransactionClientOf<TClient>>;

package/dist/databaseClient/databaseClient.core.js

@@ -32,6 +32,13 @@ export const SUPPORTED_ISOLATION_LEVELS = Object.freeze([
  * `connect()` de-duplicates concurrent calls through a shared in-flight
  * promise, and `disconnect()` waits for an in-flight connect before
  * tearing the client down.
+ *
+ * `TTransaction` is the client handed to `transaction()` callbacks.
+ * {@link createDatabaseClient} infers it from the Prisma client passed as
+ * `prisma`, so `tx.user.create(...)` is typed by the generated client. The
+ * constructor cannot infer it; `new DatabaseClient(options)` uses the
+ * structural {@link DatabaseTransactionContext} unless a type argument is
+ * given.
  */
 export class DatabaseClient {
     prisma;
@@ -358,7 +365,7 @@ let cachedPrismaClientConstructor;
 function resolvePrismaClientConstructor() {
     if (cachedPrismaClientConstructor)
         return cachedPrismaClientConstructor;
-    const guidance = "Install it and run `prisma generate`, or pass an already-constructed client as `prisma` in the DatabaseClient options.";
+    const guidance = "Install it and run `prisma generate`, or pass an already-constructed client as `prisma` in the DatabaseClient options (required with the `prisma-client` generator, whose client is generated into your application rather than into @prisma/client).";
     let module;
     try {
         module = requirePeer("@prisma/client");
@@ -489,8 +496,17 @@ export function raceAbort(promise, signal) {
         });
     });
 }
-/** Creates a database client. */
+/**
+ * Creates a database client.
+ *
+ * The transaction client handed to `transaction()` callbacks is inferred
+ * from `options.prisma`: with a generated client it is that client's own
+ * interactive transaction client, so model delegates are fully typed.
+ * Without `prisma` (adapter only) it is the structural
+ * {@link DatabaseTransactionContext}; pass the generated client type as a
+ * type argument (`createDatabaseClient<PrismaClient>({ adapter })`) to type
+ * the delegates.
+ */
 export function createDatabaseClient(options = {}) {
     return new DatabaseClient(options);
 }
-//# sourceMappingURL=databaseClient.core.js.map

package/dist/databaseClient/databaseClient.errors.d.ts

@@ -11,7 +11,7 @@
  * `clientVersion`), so the mapping works regardless of which copy of
  * `@prisma/client` produced the error.
  */
-import { DatabaseError, DatabaseOperation, type BaseError, type DatabaseErrorOptions } from "@zudojs/errors";
+import { DatabaseError, DatabaseOperation, ErrorCode, type BaseError, type DatabaseErrorOptions } from "@zudojs/errors";
 import type { DatabaseErrorInfo } from "../databaseType/databaseType.type.js";
 /**
  * Structural `DatabaseError` guard.
@@ -67,10 +67,28 @@ export interface PrismaErrorLike {
     readonly message?: string;
     readonly retryable?: boolean;
 }
+/**
+ * How a Prisma error code is normalised: its classification, HTTP status,
+ * framework error code, client-safe message and whether that message may
+ * be exposed.
+ */
+export interface PrismaCodeMapping {
+    readonly kind: DatabaseErrorKind;
+    readonly statusCode: number;
+    readonly code: ErrorCode;
+    readonly message: string;
+    readonly expose: boolean;
+}
 /**
  * Codes that indicate a transient transaction failure worth retrying.
  */
 export declare const RETRYABLE_DATABASE_CODES: ReadonlySet<string>;
+/**
+ * The mapping {@link normalizeDatabaseError} applies to a Prisma error
+ * code, or `undefined` for a code it does not know. Shared with the
+ * repository mapper so both classify the same code the same way.
+ */
+export declare function getPrismaCodeMapping(code: string): PrismaCodeMapping | undefined;
 /**
  * Detects a Prisma error structurally.
  */
@@ -120,4 +138,3 @@ export declare function normalizeDatabaseError(error: unknown, options?: Normali
  * normalised first, so Prisma codes appear as `code`.
  */
 export declare function toDatabaseErrorInfo(error: unknown, options?: NormalizeDatabaseErrorOptions): DatabaseErrorInfo;
-//# sourceMappingURL=databaseClient.errors.d.ts.map

package/dist/databaseClient/databaseClient.errors.js

@@ -199,6 +199,14 @@ export const RETRYABLE_DATABASE_CODES = new Set([
     "40001", // PostgreSQL: serialization_failure
     "40P01", // PostgreSQL: deadlock_detected
 ]);
+/**
+ * The mapping {@link normalizeDatabaseError} applies to a Prisma error
+ * code, or `undefined` for a code it does not know. Shared with the
+ * repository mapper so both classify the same code the same way.
+ */
+export function getPrismaCodeMapping(code) {
+    return PRISMA_CODE_MAP[code];
+}
 /**
  * Detects a Prisma error structurally.
  */
@@ -435,4 +443,3 @@ export function toDatabaseErrorInfo(error, options = {}) {
         metadata,
     };
 }
-//# sourceMappingURL=databaseClient.errors.js.map

package/dist/databaseClient/databaseClient.logger.d.ts

@@ -17,4 +17,3 @@ export declare const DEFAULT_DATABASE_LOGGER_NAME = "@zudojs/database";
 export declare function createDatabaseLoggerAdapter(logger: Logger): DatabaseLogger;
 /** Creates the fallback database logger, backed by `@zudojs/logger`. */
 export declare function createDefaultLogger(): DatabaseLogger;
-//# sourceMappingURL=databaseClient.logger.d.ts.map

package/dist/databaseClient/databaseClient.logger.js

@@ -52,4 +52,3 @@ export function createDefaultLogger() {
         level: LoggerLevel.DEBUG,
     }));
 }
-//# sourceMappingURL=databaseClient.logger.js.map

package/dist/databaseClient/databaseClient.type.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @zudojs/database — Database Client Types
+ *
+ * Transaction-client types owned by this package. They are structural on
+ * purpose: nothing here imports `@prisma/client`, so the published
+ * declarations resolve whether the consumer's generated client lives in
+ * `node_modules/.prisma/client` (`prisma-client-js`) or in an application
+ * directory such as `src/generated/prisma` (`prisma-client`, the Prisma 7
+ * default).
+ */
+/**
+ * A `Prisma.sql` tagged query. Any `Prisma.Sql` instance satisfies it.
+ */
+export interface PrismaSqlLike {
+    readonly strings: readonly string[];
+    readonly values: readonly unknown[];
+    readonly sql: string;
+}
+/**
+ * The raw-query surface every Prisma interactive transaction client
+ * exposes. This is the transaction type used when the concrete client type
+ * is not known: the default type argument of `DatabaseClient`,
+ * `TransactionManager`, `DatabaseUnitOfWork` and the other transaction
+ * helpers, and the type the migration, seed and lock helpers require.
+ *
+ * `createDatabaseClient({ prisma })` infers the real transaction client
+ * (model delegates included) from the client passed in; see
+ * {@link TransactionClientOf}.
+ *
+ * Declared as a type alias rather than an interface so it keeps an
+ * implicit index signature and stays assignable to
+ * `BaseRepository#withTransaction`'s `TransactionClientLike`.
+ */
+export type DatabaseTransactionContext = {
+    $queryRawUnsafe<TResult = unknown>(query: string, ...values: unknown[]): Promise<TResult>;
+    $executeRawUnsafe(query: string, ...values: unknown[]): Promise<number>;
+    $queryRaw<TResult = unknown>(query: TemplateStringsArray | PrismaSqlLike, ...values: unknown[]): Promise<TResult>;
+    $executeRaw(query: TemplateStringsArray | PrismaSqlLike, ...values: unknown[]): Promise<number>;
+};
+/**
+ * The interactive-transaction callback parameter of a Prisma client: for a
+ * generated client this is its own `Omit<PrismaClient, ITXClientDenyList>`
+ * (or the extended equivalent after `$extends`), so model delegates such
+ * as `tx.user` keep their generated types.
+ *
+ * Falls back to {@link DatabaseTransactionContext} for clients whose
+ * transaction callback cannot be read (hand-written stubs,
+ * `PrismaClientLike` itself) or does not expose the raw-query surface.
+ */
+export type TransactionClientOf<TClient> = TClient extends {
+    $transaction(callback: (transaction: infer TTransaction) => never, ...rest: never[]): unknown;
+} ? [TTransaction] extends [never] ? DatabaseTransactionContext : [TTransaction] extends [DatabaseTransactionContext] ? TTransaction : DatabaseTransactionContext : DatabaseTransactionContext;

package/dist/databaseClient/databaseClient.type.js

@@ -0,0 +1,11 @@
+/**
+ * @zudojs/database — Database Client Types
+ *
+ * Transaction-client types owned by this package. They are structural on
+ * purpose: nothing here imports `@prisma/client`, so the published
+ * declarations resolve whether the consumer's generated client lives in
+ * `node_modules/.prisma/client` (`prisma-client-js`) or in an application
+ * directory such as `src/generated/prisma` (`prisma-client`, the Prisma 7
+ * default).
+ */
+export {};

package/dist/databaseClient/index.d.ts

@@ -3,6 +3,5 @@
  *
  * Prisma-backed database client and connection infrastructure.
  */
-export { DatabaseClient, DatabaseAbortError, createDatabaseClient, buildPrismaTransactionOptions, createAbortError, raceAbort, throwIfAborted, SUPPORTED_ISOLATION_LEVELS, type DatabaseClientOptions, type DatabaseTransactionContext, type PrismaClientLike, type PrismaDriverAdapterLike, type PrismaQueryEvent, type PrismaTransactionOptions, type RawQueryOptions, } from "./databaseClient.core.js";
-export { normalizeDatabaseError, withDatabaseErrorMetadata, isPrismaError, isRetryableTransactionError, isConflictError, isNotFoundError, getDatabaseErrorCode, getDatabaseErrorKind, isDatabaseErrorLike, isNonDatabaseBaseError, toDatabaseErrorInfo, RETRYABLE_DATABASE_CODES, type DatabaseErrorKind, type NormalizeDatabaseErrorOptions, type PrismaErrorLike, } from "./databaseClient.errors.js";
-//# sourceMappingURL=index.d.ts.map
+export { DatabaseClient, DatabaseAbortError, createDatabaseClient, buildPrismaTransactionOptions, createAbortError, raceAbort, throwIfAborted, SUPPORTED_ISOLATION_LEVELS, type DatabaseClientOptions, type DatabaseTransactionContext, type PrismaClientLike, type PrismaDriverAdapterLike, type PrismaQueryEvent, type PrismaTransactionOptions, type PrismaSqlLike, type RawQueryOptions, type TransactionClientOf, } from "./databaseClient.core.js";
+export { normalizeDatabaseError, withDatabaseErrorMetadata, isPrismaError, isRetryableTransactionError, isConflictError, isNotFoundError, getDatabaseErrorCode, getDatabaseErrorKind, getPrismaCodeMapping, isDatabaseErrorLike, isNonDatabaseBaseError, toDatabaseErrorInfo, RETRYABLE_DATABASE_CODES, type DatabaseErrorKind, type NormalizeDatabaseErrorOptions, type PrismaCodeMapping, type PrismaErrorLike, } from "./databaseClient.errors.js";

package/dist/databaseClient/index.js

@@ -4,5 +4,4 @@
  * Prisma-backed database client and connection infrastructure.
  */
 export { DatabaseClient, DatabaseAbortError, createDatabaseClient, buildPrismaTransactionOptions, createAbortError, raceAbort, throwIfAborted, SUPPORTED_ISOLATION_LEVELS, } from "./databaseClient.core.js";
-export { normalizeDatabaseError, withDatabaseErrorMetadata, isPrismaError, isRetryableTransactionError, isConflictError, isNotFoundError, getDatabaseErrorCode, getDatabaseErrorKind, isDatabaseErrorLike, isNonDatabaseBaseError, toDatabaseErrorInfo, RETRYABLE_DATABASE_CODES, } from "./databaseClient.errors.js";
-//# sourceMappingURL=index.js.map
+export { normalizeDatabaseError, withDatabaseErrorMetadata, isPrismaError, isRetryableTransactionError, isConflictError, isNotFoundError, getDatabaseErrorCode, getDatabaseErrorKind, getPrismaCodeMapping, isDatabaseErrorLike, isNonDatabaseBaseError, toDatabaseErrorInfo, RETRYABLE_DATABASE_CODES, } from "./databaseClient.errors.js";

package/dist/databaseConnection/databaseConnection.manager.d.ts

@@ -165,4 +165,3 @@ export declare class DatabaseConnectionManager {
  * Creates a database connection manager.
  */
 export declare function createConnectionManager(options?: DatabaseConnectionManagerOptions): DatabaseConnectionManager;
-//# sourceMappingURL=databaseConnection.manager.d.ts.map

package/dist/databaseConnection/databaseConnection.manager.js

@@ -312,4 +312,3 @@ function sleep(milliseconds, signal) {
 export function createConnectionManager(options = {}) {
     return new DatabaseConnectionManager(options);
 }
-//# sourceMappingURL=databaseConnection.manager.js.map

package/dist/databaseConnection/index.d.ts

@@ -4,4 +4,3 @@
  * Connection lifecycle management with health checks.
  */
 export { DatabaseConnectionManager, createConnectionManager, type DatabaseConnectionEvent, type DatabaseConnectionListener, type DatabaseConnectionEventDetails, type DatabaseConnectionManagerOptions, type DatabaseReconnectOptions, } from "./databaseConnection.manager.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/databaseConnection/index.js

@@ -4,4 +4,3 @@
  * Connection lifecycle management with health checks.
  */
 export { DatabaseConnectionManager, createConnectionManager, } from "./databaseConnection.manager.js";
-//# sourceMappingURL=index.js.map

package/dist/databaseType/databaseType.type.d.ts

@@ -174,15 +174,17 @@ export interface DatabaseEntity<TId = string> {
     readonly updatedAt: Date;
 }
 /**
- * Soft-deletable entity contract.
+ * Soft-deletable entity contract. `TId` is the primary key type (default
+ * `string`), as on {@link DatabaseEntity}.
  */
-export interface SoftDeletableEntity extends DatabaseEntity {
+export interface SoftDeletableEntity<TId = string> extends DatabaseEntity<TId> {
     readonly deletedAt: Date | null;
 }
 /**
- * Auditable entity contract.
+ * Auditable entity contract. `TId` is the primary key type (default
+ * `string`), as on {@link DatabaseEntity}.
  */
-export interface AuditableEntity extends DatabaseEntity {
+export interface AuditableEntity<TId = string> extends DatabaseEntity<TId> {
     readonly createdBy?: string;
     readonly updatedBy?: string;
 }
@@ -221,4 +223,3 @@ export interface DatabaseLogger {
  * Default no-op database logger.
  */
 export declare const noopDatabaseLogger: DatabaseLogger;
-//# sourceMappingURL=databaseType.type.d.ts.map

package/dist/databaseType/databaseType.type.js

@@ -7,4 +7,3 @@ export const noopDatabaseLogger = Object.freeze({
     warn: () => undefined,
     error: () => undefined,
 });
-//# sourceMappingURL=databaseType.type.js.map

package/dist/databaseType/index.d.ts

@@ -4,4 +4,3 @@
  * Core type definitions for the database package.
  */
 export * from "./databaseType.type.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/databaseType/index.js

@@ -4,4 +4,3 @@
  * Core type definitions for the database package.
  */
 export * from "./databaseType.type.js";
-//# sourceMappingURL=index.js.map

package/dist/health/health.check.d.ts

@@ -71,4 +71,3 @@ export declare function assertDatabaseHealth(client: DatabaseClient, options?: D
  * Checks whether a database is reachable.
  */
 export declare function isDatabaseHealthy(client: DatabaseClient, options?: DatabaseHealthOptions): Promise<boolean>;
-//# sourceMappingURL=health.check.d.ts.map

package/dist/health/health.check.js

@@ -187,4 +187,3 @@ function normalizeHealthError(error) {
             : {}),
     };
 }
-//# sourceMappingURL=health.check.js.map

package/dist/health/index.d.ts

@@ -4,4 +4,3 @@
  * Database health and readiness monitoring.
  */
 export { checkDatabaseHealth, checkDatabaseReadiness, assertDatabaseHealth, isDatabaseHealthy, getHealthCheckCause, DatabaseUnhealthyError, DEFAULT_HEALTH_TIMEOUT_MS, type DatabaseHealthStatus, type DatabaseHealth, type DatabaseHealthOptions, type DatabaseReadiness, } from "./health.check.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/health/index.js

@@ -4,4 +4,3 @@
  * Database health and readiness monitoring.
  */
 export { checkDatabaseHealth, checkDatabaseReadiness, assertDatabaseHealth, isDatabaseHealthy, getHealthCheckCause, DatabaseUnhealthyError, DEFAULT_HEALTH_TIMEOUT_MS, } from "./health.check.js";
-//# sourceMappingURL=index.js.map