@rocicorp/zero 1.11.0-canary.4 → 1.11.0-canary.40

package/out/zero-server/src/adapters/kysely.d.ts

@@ -1,6 +1,7 @@
 import type { Kysely, Transaction as WrappedKyselyTransaction } from 'kysely';
 import type { Schema } from '../../../zero-types/src/schema.ts';
-import type { DBConnection, DBTransaction } from '../../../zql/src/mutate/custom.ts';
+import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
+import type { TransactionOptions } from '../transaction-options.ts';
 import { ZQLDatabase } from '../zql-database.ts';
 export type { ZQLDatabase };
 export type KyselyDatabase<TDatabase = unknown> = Kysely<TDatabase>;
@@ -12,7 +13,8 @@ export type KyselyDatabase<TDatabase = unknown> = Kysely<TDatabase>;
 export type KyselyTransaction<TDbOrSchema = KyselyDatabase> = TDbOrSchema extends Kysely<infer TInferredDatabase> ? WrappedKyselyTransaction<TInferredDatabase> : WrappedKyselyTransaction<TDbOrSchema>;
 export declare class KyselyConnection<TDatabase> implements DBConnection<WrappedKyselyTransaction<TDatabase>> {
     #private;
-    constructor(client: Kysely<TDatabase>);
+    constructor(client: Kysely<TDatabase>, options?: TransactionOptions);
+    query(sql: string, params: unknown[]): Promise<Row[]>;
     transaction<T>(fn: (tx: DBTransaction<WrappedKyselyTransaction<TDatabase>>) => Promise<T>): Promise<T>;
 }
 /**
@@ -23,6 +25,7 @@ export declare class KyselyConnection<TDatabase> implements DBConnection<Wrapped
  *
  * @param schema - Zero schema.
  * @param client - Kysely client.
+ * @param options - Transaction options, e.g. `{isolationLevel: 'repeatable read'}`.
  *
  * @example
  * ```ts
@@ -65,5 +68,5 @@ export declare class KyselyConnection<TDatabase> implements DBConnection<Wrapped
  * });
  * ```
  */
-export declare function zeroKysely<TSchema extends Schema, TDatabase>(schema: TSchema, client: Kysely<TDatabase>): ZQLDatabase<TSchema, WrappedKyselyTransaction<TDatabase>>;
+export declare function zeroKysely<TSchema extends Schema, TDatabase>(schema: TSchema, client: Kysely<TDatabase>, options?: TransactionOptions): ZQLDatabase<TSchema, WrappedKyselyTransaction<TDatabase>>;
 //# sourceMappingURL=kysely.d.ts.map

package/out/zero-server/src/adapters/kysely.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/kysely.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,IAAI,wBAAwB,EAAC,MAAM,QAAQ,CAAC;AAG5E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAE9D,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAEd,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B,MAAM,MAAM,cAAc,CAAC,SAAS,GAAG,OAAO,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,WAAW,GAAG,cAAc,IACxD,WAAW,SAAS,MAAM,CAAC,MAAM,iBAAiB,CAAC,GAC/C,wBAAwB,CAAC,iBAAiB,CAAC,GAC3C,wBAAwB,CAAC,WAAW,CAAC,CAAC;AAE5C,qBAAa,gBAAgB,CAAC,SAAS,CAAE,YAAW,YAAY,CAC9D,wBAAwB,CAAC,SAAS,CAAC,CACpC;;IAGC,YAAY,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,EAEpC;IAED,WAAW,CAAC,CAAC,EACX,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACzE,OAAO,CAAC,CAAC,CAAC,CAIZ;CACF;AAkCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,MAAM,EAAE,SAAS,EAC1D,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,GACxB,WAAW,CAAC,OAAO,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAE3D"}
+{"version":3,"file":"kysely.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/kysely.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,IAAI,wBAAwB,EAAC,MAAM,QAAQ,CAAC;AAG5E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAE9D,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAG3C,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B,MAAM,MAAM,cAAc,CAAC,SAAS,GAAG,OAAO,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;AAEpE;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,WAAW,GAAG,cAAc,IACxD,WAAW,SAAS,MAAM,CAAC,MAAM,iBAAiB,CAAC,GAC/C,wBAAwB,CAAC,iBAAiB,CAAC,GAC3C,wBAAwB,CAAC,WAAW,CAAC,CAAC;AAE5C,qBAAa,gBAAgB,CAAC,SAAS,CAAE,YAAW,YAAY,CAC9D,wBAAwB,CAAC,SAAS,CAAC,CACpC;;IAIC,YAAY,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,GAAE,kBAAuB,EAGtE;IAED,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAEpD;IAED,WAAW,CAAC,CAAC,EACX,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACzE,OAAO,CAAC,CAAC,CAAC,CASZ;CACF;AA0CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,UAAU,CAAC,OAAO,SAAS,MAAM,EAAE,SAAS,EAC1D,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,EACzB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,CAAC,OAAO,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAE3D"}

package/out/zero-server/src/adapters/kysely.js

@@ -4,11 +4,17 @@ import { CompiledQuery } from "kysely";
 //#region ../zero-server/src/adapters/kysely.ts
 var KyselyConnection = class {
 	#client;
-	constructor(client) {
+	#options;
+	constructor(client, options = {}) {
 		this.#client = client;
+		this.#options = options;
+	}
+	query(sql, params) {
+		return kyselyQuery(this.#client, sql, params);
 	}
 	transaction(fn) {
-		return this.#client.transaction().execute((kyselyTx) => fn(new KyselyInternalTransaction(kyselyTx)));
+		const { isolationLevel } = this.#options;
+		return (isolationLevel === void 0 ? this.#client.transaction() : this.#client.transaction().setIsolationLevel(isolationLevel)).execute((kyselyTx) => fn(new KyselyInternalTransaction(kyselyTx)));
 	}
 };
 var KyselyInternalTransaction = class {
@@ -19,10 +25,13 @@ var KyselyInternalTransaction = class {
 	runQuery(ast, format, schema, serverSchema) {
 		return executePostgresQuery(this, ast, format, schema, serverSchema);
 	}
-	async query(sql, params) {
-		return (await this.wrappedTransaction.executeQuery(CompiledQuery.raw(sql, params))).rows;
+	query(sql, params) {
+		return kyselyQuery(this.wrappedTransaction, sql, params);
 	}
 };
+async function kyselyQuery(executor, sql, params) {
+	return (await executor.executeQuery(CompiledQuery.raw(sql, params))).rows;
+}
 /**
 * Wrap a Postgres-backed Kysely client for Zero ZQL.
 *
@@ -31,6 +40,7 @@ var KyselyInternalTransaction = class {
 *
 * @param schema - Zero schema.
 * @param client - Kysely client.
+* @param options - Transaction options, e.g. `{isolationLevel: 'repeatable read'}`.
 *
 * @example
 * ```ts
@@ -73,8 +83,8 @@ var KyselyInternalTransaction = class {
 * });
 * ```
 */
-function zeroKysely(schema, client) {
-	return new ZQLDatabase(new KyselyConnection(client), schema);
+function zeroKysely(schema, client, options) {
+	return new ZQLDatabase(new KyselyConnection(client, options), schema);
 }
 //#endregion
 export { KyselyConnection, zeroKysely };

package/out/zero-server/src/adapters/kysely.js.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.js","names":["#client"],"sources":["../../../../../zero-server/src/adapters/kysely.ts"],"sourcesContent":["import {CompiledQuery} from 'kysely';\nimport type {Kysely, Transaction as WrappedKyselyTransaction} from 'kysely';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\nexport type KyselyDatabase<TDatabase = unknown> = Kysely<TDatabase>;\n\n/**\n * Helper type for the wrapped transaction used by Kysely.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, KyselyTransaction<typeof db>>`.\n */\nexport type KyselyTransaction<TDbOrSchema = KyselyDatabase> =\n  TDbOrSchema extends Kysely<infer TInferredDatabase>\n    ? WrappedKyselyTransaction<TInferredDatabase>\n    : WrappedKyselyTransaction<TDbOrSchema>;\n\nexport class KyselyConnection<TDatabase> implements DBConnection<\n  WrappedKyselyTransaction<TDatabase>\n> {\n  readonly #client: Kysely<TDatabase>;\n\n  constructor(client: Kysely<TDatabase>) {\n    this.#client = client;\n  }\n\n  transaction<T>(\n    fn: (tx: DBTransaction<WrappedKyselyTransaction<TDatabase>>) => Promise<T>,\n  ): Promise<T> {\n    return this.#client\n      .transaction()\n      .execute(kyselyTx => fn(new KyselyInternalTransaction(kyselyTx)));\n  }\n}\n\nclass KyselyInternalTransaction<TDatabase> implements DBTransaction<\n  WrappedKyselyTransaction<TDatabase>\n> {\n  readonly wrappedTransaction: WrappedKyselyTransaction<TDatabase>;\n\n  constructor(kyselyTx: WrappedKyselyTransaction<TDatabase>) {\n    this.wrappedTransaction = kyselyTx;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  async query(sql: string, params: unknown[]): Promise<Row[]> {\n    const result = await this.wrappedTransaction.executeQuery<Row>(\n      CompiledQuery.raw(sql, params),\n    );\n    return result.rows;\n  }\n}\n\n/**\n * Wrap a Postgres-backed Kysely client for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying Kysely transaction.\n * Use {@link KyselyTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param client - Kysely client.\n *\n * @example\n * ```ts\n * import {Pool} from 'pg';\n * import {Kysely, PostgresDialect} from 'kysely';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroKysely} from '@rocicorp/zero/server/adapters/kysely';\n * import {z} from 'zod/mini';\n *\n * interface Database {\n *   user: {\n *     id: string;\n *     name: string | null;\n *     status: 'active' | 'inactive';\n *   };\n * }\n *\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({connectionString: process.env.ZERO_UPSTREAM_DB!}),\n *   }),\n * });\n * const zql = zeroKysely(schema, db);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction\n *           .insertInto('user')\n *           .values({id: args.id, name: args.name, status: 'active'})\n *           .execute();\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroKysely<TSchema extends Schema, TDatabase>(\n  schema: TSchema,\n  client: Kysely<TDatabase>,\n): ZQLDatabase<TSchema, WrappedKyselyTransaction<TDatabase>> {\n  return new ZQLDatabase(new KyselyConnection(client), schema);\n}\n"],"mappings":";;;;AA6BA,IAAa,mBAAb,MAEE;CACA;CAEA,YAAY,QAA2B;EACrC,KAAKA,UAAU;CACjB;CAEA,YACE,IACY;EACZ,OAAO,KAAKA,QACT,YAAY,EACZ,SAAQ,aAAY,GAAG,IAAI,0BAA0B,QAAQ,CAAC,CAAC;CACpE;AACF;AAEA,IAAM,4BAAN,MAEE;CACA;CAEA,YAAY,UAA+C;EACzD,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,MAAM,KAAa,QAAmC;EAI1D,QAAO,MAHc,KAAK,mBAAmB,aAC3C,cAAc,IAAI,KAAK,MAAM,CAC/B,GACc;CAChB;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SAAgB,WACd,QACA,QAC2D;CAC3D,OAAO,IAAI,YAAY,IAAI,iBAAiB,MAAM,GAAG,MAAM;AAC7D"}
+{"version":3,"file":"kysely.js","names":["#client","#options"],"sources":["../../../../../zero-server/src/adapters/kysely.ts"],"sourcesContent":["import {CompiledQuery} from 'kysely';\nimport type {Kysely, Transaction as WrappedKyselyTransaction} from 'kysely';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport type {TransactionOptions} from '../transaction-options.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\nexport type KyselyDatabase<TDatabase = unknown> = Kysely<TDatabase>;\n\n/**\n * Helper type for the wrapped transaction used by Kysely.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, KyselyTransaction<typeof db>>`.\n */\nexport type KyselyTransaction<TDbOrSchema = KyselyDatabase> =\n  TDbOrSchema extends Kysely<infer TInferredDatabase>\n    ? WrappedKyselyTransaction<TInferredDatabase>\n    : WrappedKyselyTransaction<TDbOrSchema>;\n\nexport class KyselyConnection<TDatabase> implements DBConnection<\n  WrappedKyselyTransaction<TDatabase>\n> {\n  readonly #client: Kysely<TDatabase>;\n  readonly #options: TransactionOptions;\n\n  constructor(client: Kysely<TDatabase>, options: TransactionOptions = {}) {\n    this.#client = client;\n    this.#options = options;\n  }\n\n  query(sql: string, params: unknown[]): Promise<Row[]> {\n    return kyselyQuery(this.#client, sql, params);\n  }\n\n  transaction<T>(\n    fn: (tx: DBTransaction<WrappedKyselyTransaction<TDatabase>>) => Promise<T>,\n  ): Promise<T> {\n    const {isolationLevel} = this.#options;\n    const builder =\n      isolationLevel === undefined\n        ? this.#client.transaction()\n        : this.#client.transaction().setIsolationLevel(isolationLevel);\n    return builder.execute(kyselyTx =>\n      fn(new KyselyInternalTransaction(kyselyTx)),\n    );\n  }\n}\n\nclass KyselyInternalTransaction<TDatabase> implements DBTransaction<\n  WrappedKyselyTransaction<TDatabase>\n> {\n  readonly wrappedTransaction: WrappedKyselyTransaction<TDatabase>;\n\n  constructor(kyselyTx: WrappedKyselyTransaction<TDatabase>) {\n    this.wrappedTransaction = kyselyTx;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  query(sql: string, params: unknown[]): Promise<Row[]> {\n    return kyselyQuery(this.wrappedTransaction, sql, params);\n  }\n}\n\nasync function kyselyQuery<TDatabase>(\n  executor: Kysely<TDatabase>,\n  sql: string,\n  params: unknown[],\n): Promise<Row[]> {\n  const result = await executor.executeQuery<Row>(\n    CompiledQuery.raw(sql, params),\n  );\n  return result.rows;\n}\n\n/**\n * Wrap a Postgres-backed Kysely client for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying Kysely transaction.\n * Use {@link KyselyTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param client - Kysely client.\n * @param options - Transaction options, e.g. `{isolationLevel: 'repeatable read'}`.\n *\n * @example\n * ```ts\n * import {Pool} from 'pg';\n * import {Kysely, PostgresDialect} from 'kysely';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroKysely} from '@rocicorp/zero/server/adapters/kysely';\n * import {z} from 'zod/mini';\n *\n * interface Database {\n *   user: {\n *     id: string;\n *     name: string | null;\n *     status: 'active' | 'inactive';\n *   };\n * }\n *\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({connectionString: process.env.ZERO_UPSTREAM_DB!}),\n *   }),\n * });\n * const zql = zeroKysely(schema, db);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction\n *           .insertInto('user')\n *           .values({id: args.id, name: args.name, status: 'active'})\n *           .execute();\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroKysely<TSchema extends Schema, TDatabase>(\n  schema: TSchema,\n  client: Kysely<TDatabase>,\n  options?: TransactionOptions,\n): ZQLDatabase<TSchema, WrappedKyselyTransaction<TDatabase>> {\n  return new ZQLDatabase(new KyselyConnection(client, options), schema);\n}\n"],"mappings":";;;;AA8BA,IAAa,mBAAb,MAEE;CACA;CACA;CAEA,YAAY,QAA2B,UAA8B,CAAC,GAAG;EACvE,KAAKA,UAAU;EACf,KAAKC,WAAW;CAClB;CAEA,MAAM,KAAa,QAAmC;EACpD,OAAO,YAAY,KAAKD,SAAS,KAAK,MAAM;CAC9C;CAEA,YACE,IACY;EACZ,MAAM,EAAC,mBAAkB,KAAKC;EAK9B,QAHE,mBAAmB,KAAA,IACf,KAAKD,QAAQ,YAAY,IACzB,KAAKA,QAAQ,YAAY,EAAE,kBAAkB,cAAc,GAClD,SAAQ,aACrB,GAAG,IAAI,0BAA0B,QAAQ,CAAC,CAC5C;CACF;AACF;AAEA,IAAM,4BAAN,MAEE;CACA;CAEA,YAAY,UAA+C;EACzD,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,KAAa,QAAmC;EACpD,OAAO,YAAY,KAAK,oBAAoB,KAAK,MAAM;CACzD;AACF;AAEA,eAAe,YACb,UACA,KACA,QACgB;CAIhB,QAAO,MAHc,SAAS,aAC5B,cAAc,IAAI,KAAK,MAAM,CAC/B,GACc;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAgB,WACd,QACA,QACA,SAC2D;CAC3D,OAAO,IAAI,YAAY,IAAI,iBAAiB,QAAQ,OAAO,GAAG,MAAM;AACtE"}

package/out/zero-server/src/adapters/pg.d.ts

@@ -1,3 +1,4 @@
+import type { LogContext } from '@rocicorp/logger';
 import type { Client } from 'pg';
 import { Pool, type PoolClient } from 'pg';
 import type { AST } from '../../../zero-protocol/src/ast.ts';
@@ -6,6 +7,7 @@ import type { Schema } from '../../../zero-types/src/schema.ts';
 import type { ServerSchema } from '../../../zero-types/src/server-schema.ts';
 import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
 import type { HumanReadable } from '../../../zql/src/query/query.ts';
+import { type TransactionOptions } from '../transaction-options.ts';
 import { ZQLDatabase } from '../zql-database.ts';
 export type { ZQLDatabase };
 /**
@@ -16,7 +18,8 @@ export type { ZQLDatabase };
 export type NodePgTransaction = Pool | PoolClient | Client;
 export declare class NodePgConnection implements DBConnection<NodePgTransaction> {
     #private;
-    constructor(pool: NodePgTransaction);
+    constructor(pool: NodePgTransaction, options?: TransactionOptions);
+    query(sql: string, params: unknown[]): Promise<Row[]>;
     transaction<TRet>(fn: (tx: DBTransaction<NodePgTransaction>) => Promise<TRet>): Promise<TRet>;
 }
 export declare class NodePgTransactionInternal implements DBTransaction<NodePgTransaction> {
@@ -33,6 +36,8 @@ export declare class NodePgTransactionInternal implements DBTransaction<NodePgTr
  *
  * @param schema - Zero schema.
  * @param pg - `pg` Pool or connection string.
+ * @param lc - Where to log errors from a pool built from a connection string.
+ * Defaults to `console` at level `warn`.
  *
  * @example
  * ```ts
@@ -62,5 +67,5 @@ export declare class NodePgTransactionInternal implements DBTransaction<NodePgTr
  * });
  * ```
  */
-export declare function zeroNodePg<S extends Schema>(schema: S, pg: NodePgTransaction | string): ZQLDatabase<S, NodePgTransaction>;
+export declare function zeroNodePg<S extends Schema>(schema: S, pg: NodePgTransaction | string, lc?: LogContext, options?: TransactionOptions): ZQLDatabase<S, NodePgTransaction>;
 //# sourceMappingURL=pg.d.ts.map

package/out/zero-server/src/adapters/pg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/pg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,IAAI,CAAC;AAC/B,OAAO,EAAC,IAAI,EAAE,KAAK,UAAU,EAAC,MAAM,IAAI,CAAC;AACzC,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAC;AAC3D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0CAA0C,CAAC;AAC3E,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D,qBAAa,gBAAiB,YAAW,YAAY,CAAC,iBAAiB,CAAC;;IAGtE,YAAY,IAAI,EAAE,iBAAiB,EAElC;IAEK,WAAW,CAAC,IAAI,EACpB,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,iBAAiB,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAC1D,OAAO,CAAC,IAAI,CAAC,CAoBf;CACF;AAED,qBAAa,yBAA0B,YAAW,aAAa,CAAC,iBAAiB,CAAC;IAChF,QAAQ,CAAC,kBAAkB,EAAE,iBAAiB,CAAC;IAE/C,YAAY,MAAM,EAAE,iBAAiB,EAEpC;IAED,QAAQ,CAAC,OAAO,EACd,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAQjC;IAEK,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAG1D;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,MAAM,EAAE,CAAC,EACT,EAAE,EAAE,iBAAiB,GAAG,MAAM,qCAM/B"}
+{"version":3,"file":"pg.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/pg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,IAAI,CAAC;AAC/B,OAAO,EAAgB,IAAI,EAAE,KAAK,UAAU,EAAC,MAAM,IAAI,CAAC;AACxD,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAC;AAC3D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0CAA0C,CAAC;AAC3E,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iCAAiC,CAAC;AAGnE,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,IAAI,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D,qBAAa,gBAAiB,YAAW,YAAY,CAAC,iBAAiB,CAAC;;IAItE,YAAY,IAAI,EAAE,iBAAiB,EAAE,OAAO,GAAE,kBAAuB,EAGpE;IAED,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAEpD;IAEK,WAAW,CAAC,IAAI,EACpB,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,iBAAiB,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAC1D,OAAO,CAAC,IAAI,CAAC,CAqCf;CACF;AAED,qBAAa,yBAA0B,YAAW,aAAa,CAAC,iBAAiB,CAAC;IAChF,QAAQ,CAAC,kBAAkB,EAAE,iBAAiB,CAAC;IAE/C,YAAY,MAAM,EAAE,iBAAiB,EAEpC;IAED,QAAQ,CAAC,OAAO,EACd,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAQjC;IAED,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAEpD;CACF;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,MAAM,EAAE,CAAC,EACT,EAAE,EAAE,iBAAiB,GAAG,MAAM,EAC9B,EAAE,GAAE,UAAqC,EACzC,OAAO,CAAC,EAAE,kBAAkB,qCAkB7B"}

package/out/zero-server/src/adapters/pg.js

@@ -1,16 +1,28 @@
 import { executePostgresQuery } from "../pg-query-executor.js";
+import { createLogContext } from "../logging.js";
 import { ZQLDatabase } from "../zql-database.js";
-import { Pool } from "pg";
+import { beginStatement } from "../transaction-options.js";
+import { DatabaseError, Pool } from "pg";
 //#region ../zero-server/src/adapters/pg.ts
 var NodePgConnection = class {
 	#pool;
-	constructor(pool) {
+	#options;
+	constructor(pool, options = {}) {
 		this.#pool = pool;
+		this.#options = options;
+	}
+	query(sql, params) {
+		return nodePgQuery(this.#pool, sql, params);
 	}
 	async transaction(fn) {
 		const client = this.#pool instanceof Pool ? await this.#pool.connect() : this.#pool;
+		let connectionError;
+		const onError = (e) => {
+			connectionError ??= e;
+		};
+		client.on("error", onError);
 		try {
-			await client.query("BEGIN");
+			await client.query(beginStatement(this.#options.isolationLevel));
 			const result = await fn(new NodePgTransactionInternal(client));
 			await client.query("COMMIT");
 			return result;
@@ -18,9 +30,10 @@ var NodePgConnection = class {
 			try {
 				await client.query("ROLLBACK");
 			} catch {}
-			throw error;
+			throw connectionError && !(error instanceof DatabaseError) ? connectionError : error;
 		} finally {
-			if (this.#pool instanceof Pool && "release" in client) client.release();
+			client.off("error", onError);
+			if (this.#pool instanceof Pool && "release" in client) client.release(connectionError);
 		}
 	}
 };
@@ -32,10 +45,13 @@ var NodePgTransactionInternal = class {
 	runQuery(ast, format, schema, serverSchema) {
 		return executePostgresQuery(this, ast, format, schema, serverSchema);
 	}
-	async query(sql, params) {
-		return (await this.wrappedTransaction.query(sql, params)).rows;
+	query(sql, params) {
+		return nodePgQuery(this.wrappedTransaction, sql, params);
 	}
 };
+async function nodePgQuery(client, sql, params) {
+	return (await client.query(sql, params)).rows;
+}
 /**
 * Wrap a `pg` Pool for Zero ZQL.
 *
@@ -44,6 +60,8 @@ var NodePgTransactionInternal = class {
 *
 * @param schema - Zero schema.
 * @param pg - `pg` Pool or connection string.
+* @param lc - Where to log errors from a pool built from a connection string.
+* Defaults to `console` at level `warn`.
 *
 * @example
 * ```ts
@@ -73,9 +91,15 @@ var NodePgTransactionInternal = class {
 * });
 * ```
 */
-function zeroNodePg(schema, pg) {
-	if (typeof pg === "string") pg = new Pool({ connectionString: pg });
-	return new ZQLDatabase(new NodePgConnection(pg), schema);
+function zeroNodePg(schema, pg, lc = createLogContext("warn"), options) {
+	if (typeof pg === "string") {
+		const pool = new Pool({ connectionString: pg });
+		pool.on("error", (e) => {
+			lc.warn?.("node-postgres pool error; the client was removed from the pool", e);
+		});
+		pg = pool;
+	}
+	return new ZQLDatabase(new NodePgConnection(pg, options), schema);
 }
 //#endregion
 export { NodePgConnection, NodePgTransactionInternal, zeroNodePg };

package/out/zero-server/src/adapters/pg.js.map

@@ -1 +1 @@
-{"version":3,"file":"pg.js","names":["#pool"],"sources":["../../../../../zero-server/src/adapters/pg.ts"],"sourcesContent":["import type {Client} from 'pg';\nimport {Pool, type PoolClient} from 'pg';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\n/**\n * Helper type for the wrapped transaction used by node-postgres.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, NodePgTransaction>`.\n */\nexport type NodePgTransaction = Pool | PoolClient | Client;\n\nexport class NodePgConnection implements DBConnection<NodePgTransaction> {\n  readonly #pool: NodePgTransaction;\n\n  constructor(pool: NodePgTransaction) {\n    this.#pool = pool;\n  }\n\n  async transaction<TRet>(\n    fn: (tx: DBTransaction<NodePgTransaction>) => Promise<TRet>,\n  ): Promise<TRet> {\n    const client =\n      this.#pool instanceof Pool ? await this.#pool.connect() : this.#pool;\n    try {\n      await client.query('BEGIN');\n      const result = await fn(new NodePgTransactionInternal(client));\n      await client.query('COMMIT');\n      return result;\n    } catch (error) {\n      try {\n        await client.query('ROLLBACK');\n      } catch {\n        // ignore rollback error; original error will be thrown\n      }\n      throw error;\n    } finally {\n      if (this.#pool instanceof Pool && 'release' in client) {\n        client.release();\n      }\n    }\n  }\n}\n\nexport class NodePgTransactionInternal implements DBTransaction<NodePgTransaction> {\n  readonly wrappedTransaction: NodePgTransaction;\n\n  constructor(client: NodePgTransaction) {\n    this.wrappedTransaction = client;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  async query(sql: string, params: unknown[]): Promise<Row[]> {\n    const res = await this.wrappedTransaction.query(sql, params as unknown[]);\n    return res.rows as Row[];\n  }\n}\n\n/**\n * Wrap a `pg` Pool for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying node-postgres client.\n * Use {@link NodePgTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param pg - `pg` Pool or connection string.\n *\n * @example\n * ```ts\n * import {Pool} from 'pg';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroNodePg} from '@rocicorp/zero/server/adapters/pg';\n * import {z} from 'zod/mini';\n *\n * const pool = new Pool({connectionString: process.env.ZERO_UPSTREAM_DB!});\n * const zql = zeroNodePg(schema, pool);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction.query(\n *           'INSERT INTO \"user\" (id, name, status) VALUES ($1, $2, $3)',\n *           [args.id, args.name, 'active'],\n *         );\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroNodePg<S extends Schema>(\n  schema: S,\n  pg: NodePgTransaction | string,\n) {\n  if (typeof pg === 'string') {\n    pg = new Pool({connectionString: pg});\n  }\n  return new ZQLDatabase(new NodePgConnection(pg), schema);\n}\n"],"mappings":";;;;AAwBA,IAAa,mBAAb,MAAyE;CACvE;CAEA,YAAY,MAAyB;EACnC,KAAKA,QAAQ;CACf;CAEA,MAAM,YACJ,IACe;EACf,MAAM,SACJ,KAAKA,iBAAiB,OAAO,MAAM,KAAKA,MAAM,QAAQ,IAAI,KAAKA;EACjE,IAAI;GACF,MAAM,OAAO,MAAM,OAAO;GAC1B,MAAM,SAAS,MAAM,GAAG,IAAI,0BAA0B,MAAM,CAAC;GAC7D,MAAM,OAAO,MAAM,QAAQ;GAC3B,OAAO;EACT,SAAS,OAAO;GACd,IAAI;IACF,MAAM,OAAO,MAAM,UAAU;GAC/B,QAAQ,CAER;GACA,MAAM;EACR,UAAU;GACR,IAAI,KAAKA,iBAAiB,QAAQ,aAAa,QAC7C,OAAO,QAAQ;EAEnB;CACF;AACF;AAEA,IAAa,4BAAb,MAAmF;CACjF;CAEA,YAAY,QAA2B;EACrC,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,MAAM,KAAa,QAAmC;EAE1D,QAAO,MADW,KAAK,mBAAmB,MAAM,KAAK,MAAmB,GAC7D;CACb;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,WACd,QACA,IACA;CACA,IAAI,OAAO,OAAO,UAChB,KAAK,IAAI,KAAK,EAAC,kBAAkB,GAAE,CAAC;CAEtC,OAAO,IAAI,YAAY,IAAI,iBAAiB,EAAE,GAAG,MAAM;AACzD"}
+{"version":3,"file":"pg.js","names":["#pool","#options"],"sources":["../../../../../zero-server/src/adapters/pg.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Client} from 'pg';\nimport {DatabaseError, Pool, type PoolClient} from 'pg';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {createLogContext} from '../logging.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport {\n  beginStatement,\n  type TransactionOptions,\n} from '../transaction-options.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\n/**\n * Helper type for the wrapped transaction used by node-postgres.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, NodePgTransaction>`.\n */\nexport type NodePgTransaction = Pool | PoolClient | Client;\n\nexport class NodePgConnection implements DBConnection<NodePgTransaction> {\n  readonly #pool: NodePgTransaction;\n  readonly #options: TransactionOptions;\n\n  constructor(pool: NodePgTransaction, options: TransactionOptions = {}) {\n    this.#pool = pool;\n    this.#options = options;\n  }\n\n  query(sql: string, params: unknown[]): Promise<Row[]> {\n    return nodePgQuery(this.#pool, sql, params);\n  }\n\n  async transaction<TRet>(\n    fn: (tx: DBTransaction<NodePgTransaction>) => Promise<TRet>,\n  ): Promise<TRet> {\n    const client =\n      this.#pool instanceof Pool ? await this.#pool.connect() : this.#pool;\n    // The pool only listens for 'error' on a client idle in the pool. If the\n    // server ends the connection while the client is checked out here and no\n    // query is running (an idle_in_transaction_session_timeout while the\n    // mutator awaits something else, a restart, a failover), node-postgres\n    // emits 'error' on the client, and with no listener the process dies.\n    let connectionError: Error | undefined;\n    const onError = (e: Error) => {\n      connectionError ??= e;\n    };\n    client.on('error', onError);\n    try {\n      await client.query(beginStatement(this.#options.isolationLevel));\n      const result = await fn(new NodePgTransactionInternal(client));\n      await client.query('COMMIT');\n      return result;\n    } catch (error) {\n      try {\n        await client.query('ROLLBACK');\n      } catch {\n        // ignore rollback error; original error will be thrown\n      }\n      // After a connection error, a query only fails with \"Client has\n      // encountered a connection error and is not queryable\". Throw what\n      // ended the connection instead, unless the server reported an error of\n      // its own to the query.\n      throw connectionError && !(error instanceof DatabaseError)\n        ? connectionError\n        : error;\n    } finally {\n      client.off('error', onError);\n      if (this.#pool instanceof Pool && 'release' in client) {\n        client.release(connectionError);\n      }\n    }\n  }\n}\n\nexport class NodePgTransactionInternal implements DBTransaction<NodePgTransaction> {\n  readonly wrappedTransaction: NodePgTransaction;\n\n  constructor(client: NodePgTransaction) {\n    this.wrappedTransaction = client;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  query(sql: string, params: unknown[]): Promise<Row[]> {\n    return nodePgQuery(this.wrappedTransaction, sql, params);\n  }\n}\n\nasync function nodePgQuery(\n  client: NodePgTransaction,\n  sql: string,\n  params: unknown[],\n): Promise<Row[]> {\n  const res = await client.query(sql, params);\n  return res.rows as Row[];\n}\n\n/**\n * Wrap a `pg` Pool for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying node-postgres client.\n * Use {@link NodePgTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param pg - `pg` Pool or connection string.\n * @param lc - Where to log errors from a pool built from a connection string.\n * Defaults to `console` at level `warn`.\n *\n * @example\n * ```ts\n * import {Pool} from 'pg';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroNodePg} from '@rocicorp/zero/server/adapters/pg';\n * import {z} from 'zod/mini';\n *\n * const pool = new Pool({connectionString: process.env.ZERO_UPSTREAM_DB!});\n * const zql = zeroNodePg(schema, pool);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction.query(\n *           'INSERT INTO \"user\" (id, name, status) VALUES ($1, $2, $3)',\n *           [args.id, args.name, 'active'],\n *         );\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroNodePg<S extends Schema>(\n  schema: S,\n  pg: NodePgTransaction | string,\n  lc: LogContext = createLogContext('warn'),\n  options?: TransactionOptions,\n) {\n  if (typeof pg === 'string') {\n    const pool = new Pool({connectionString: pg});\n    // node-postgres emits 'error' on the pool when the server terminates a\n    // client idle in the pool (an idle_session_timeout, a restart, a\n    // failover). The pool has already discarded that client and will open\n    // another; with no listener the event is an uncaught exception and the\n    // process dies with whatever request it was serving. Log it and carry on.\n    pool.on('error', e => {\n      lc.warn?.(\n        'node-postgres pool error; the client was removed from the pool',\n        e,\n      );\n    });\n    pg = pool;\n  }\n  return new ZQLDatabase(new NodePgConnection(pg, options), schema);\n}\n"],"mappings":";;;;;;AA8BA,IAAa,mBAAb,MAAyE;CACvE;CACA;CAEA,YAAY,MAAyB,UAA8B,CAAC,GAAG;EACrE,KAAKA,QAAQ;EACb,KAAKC,WAAW;CAClB;CAEA,MAAM,KAAa,QAAmC;EACpD,OAAO,YAAY,KAAKD,OAAO,KAAK,MAAM;CAC5C;CAEA,MAAM,YACJ,IACe;EACf,MAAM,SACJ,KAAKA,iBAAiB,OAAO,MAAM,KAAKA,MAAM,QAAQ,IAAI,KAAKA;EAMjE,IAAI;EACJ,MAAM,WAAW,MAAa;GAC5B,oBAAoB;EACtB;EACA,OAAO,GAAG,SAAS,OAAO;EAC1B,IAAI;GACF,MAAM,OAAO,MAAM,eAAe,KAAKC,SAAS,cAAc,CAAC;GAC/D,MAAM,SAAS,MAAM,GAAG,IAAI,0BAA0B,MAAM,CAAC;GAC7D,MAAM,OAAO,MAAM,QAAQ;GAC3B,OAAO;EACT,SAAS,OAAO;GACd,IAAI;IACF,MAAM,OAAO,MAAM,UAAU;GAC/B,QAAQ,CAER;GAKA,MAAM,mBAAmB,EAAE,iBAAiB,iBACxC,kBACA;EACN,UAAU;GACR,OAAO,IAAI,SAAS,OAAO;GAC3B,IAAI,KAAKD,iBAAiB,QAAQ,aAAa,QAC7C,OAAO,QAAQ,eAAe;EAElC;CACF;AACF;AAEA,IAAa,4BAAb,MAAmF;CACjF;CAEA,YAAY,QAA2B;EACrC,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,KAAa,QAAmC;EACpD,OAAO,YAAY,KAAK,oBAAoB,KAAK,MAAM;CACzD;AACF;AAEA,eAAe,YACb,QACA,KACA,QACgB;CAEhB,QAAO,MADW,OAAO,MAAM,KAAK,MAAM,GAC/B;AACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,WACd,QACA,IACA,KAAiB,iBAAiB,MAAM,GACxC,SACA;CACA,IAAI,OAAO,OAAO,UAAU;EAC1B,MAAM,OAAO,IAAI,KAAK,EAAC,kBAAkB,GAAE,CAAC;EAM5C,KAAK,GAAG,UAAS,MAAK;GACpB,GAAG,OACD,kEACA,CACF;EACF,CAAC;EACD,KAAK;CACP;CACA,OAAO,IAAI,YAAY,IAAI,iBAAiB,IAAI,OAAO,GAAG,MAAM;AAClE"}

package/out/zero-server/src/adapters/postgresjs.d.ts

@@ -5,6 +5,7 @@ import type { Schema } from '../../../zero-types/src/schema.ts';
 import type { ServerSchema } from '../../../zero-types/src/server-schema.ts';
 import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
 import type { HumanReadable } from '../../../zql/src/query/query.ts';
+import type { TransactionOptions } from '../transaction-options.ts';
 import { ZQLDatabase } from '../zql-database.ts';
 export type { ZQLDatabase };
 /**
@@ -16,7 +17,8 @@ export type { ZQLDatabase };
 export type PostgresJsTransaction<T extends Record<string, unknown> = Record<string, unknown>> = postgres.TransactionSql<T>;
 export declare class PostgresJSConnection<T extends Record<string, unknown>> implements DBConnection<PostgresJsTransaction<T>> {
     #private;
-    constructor(pg: postgres.Sql<T>);
+    constructor(pg: postgres.Sql<T>, options?: TransactionOptions);
+    query(sql: string, params: unknown[]): Promise<Row[]>;
     transaction<TRet>(fn: (tx: DBTransaction<PostgresJsTransaction<T>>) => Promise<TRet>): Promise<TRet>;
 }
 export declare class PostgresJsTransactionInternal<T extends Record<string, unknown>> implements DBTransaction<PostgresJsTransaction<T>> {
@@ -62,5 +64,5 @@ export declare class PostgresJsTransactionInternal<T extends Record<string, unkn
  * });
  * ```
  */
-export declare function zeroPostgresJS<S extends Schema, T extends Record<string, unknown> = Record<string, unknown>>(schema: S, pg: postgres.Sql<T> | string): ZQLDatabase<S, PostgresJsTransaction<T>>;
+export declare function zeroPostgresJS<S extends Schema, T extends Record<string, unknown> = Record<string, unknown>>(schema: S, pg: postgres.Sql<T> | string, options?: TransactionOptions): ZQLDatabase<S, PostgresJsTransaction<T>>;
 //# sourceMappingURL=postgresjs.d.ts.map

package/out/zero-server/src/adapters/postgresjs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgresjs.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/postgresjs.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAC;AAC3D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0CAA0C,CAAC;AAC3E,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,CAC/B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzD,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;AAE/B,qBAAa,oBAAoB,CAC/B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjC,YAAW,YAAY,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;;IAEjD,YAAY,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAE9B;IAED,WAAW,CAAC,IAAI,EACd,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GACjE,OAAO,CAAC,IAAI,CAAC,CAIf;CACF;AAED,qBAAa,6BAA6B,CACxC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjC,YAAW,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IACtD,YAAY,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAEzC;IAED,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAEpD;IAED,QAAQ,CAAC,OAAO,EACd,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAQjC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,cAAc,CAC5B,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,4CAOxC"}
+{"version":3,"file":"postgresjs.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/postgresjs.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAEhC,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,mCAAmC,CAAC;AAC3D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAC9D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,0CAA0C,CAAC;AAC3E,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iCAAiC,CAAC;AAEnE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,CAC/B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzD,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;AAE/B,qBAAa,oBAAoB,CAC/B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjC,YAAW,YAAY,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;;IAGjD,YAAY,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,kBAAuB,EAGhE;IAED,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAEpD;IAED,WAAW,CAAC,IAAI,EACd,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GACjE,OAAO,CAAC,IAAI,CAAC,CASf;CACF;AAED,qBAAa,6BAA6B,CACxC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjC,YAAW,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC;IACtD,YAAY,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,EAEzC;IAED,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAEpD;IAED,QAAQ,CAAC,OAAO,EACd,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAQjC;CACF;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,cAAc,CAC5B,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,4CAOtE"}

package/out/zero-server/src/adapters/postgresjs.js

@@ -4,11 +4,18 @@ import postgres from "postgres";
 //#region ../zero-server/src/adapters/postgresjs.ts
 var PostgresJSConnection = class {
 	#pg;
-	constructor(pg) {
+	#options;
+	constructor(pg, options = {}) {
 		this.#pg = pg;
+		this.#options = options;
+	}
+	query(sql, params) {
+		return postgresJsQuery(this.#pg, sql, params);
 	}
 	transaction(fn) {
-		return this.#pg.begin((pgTx) => fn(new PostgresJsTransactionInternal(pgTx)));
+		const run = (pgTx) => fn(new PostgresJsTransactionInternal(pgTx));
+		const { isolationLevel } = this.#options;
+		return isolationLevel === void 0 ? this.#pg.begin(run) : this.#pg.begin(`isolation level ${isolationLevel}`, run);
 	}
 };
 var PostgresJsTransactionInternal = class {
@@ -17,12 +24,15 @@ var PostgresJsTransactionInternal = class {
 		this.wrappedTransaction = pgTx;
 	}
 	query(sql, params) {
-		return this.wrappedTransaction.unsafe(sql, params);
+		return postgresJsQuery(this.wrappedTransaction, sql, params);
 	}
 	runQuery(ast, format, schema, serverSchema) {
 		return executePostgresQuery(this, ast, format, schema, serverSchema);
 	}
 };
+function postgresJsQuery(sql, text, params) {
+	return sql.unsafe(text, params);
+}
 /**
 * Wrap a `postgres` client for Zero ZQL.
 *
@@ -60,9 +70,9 @@ var PostgresJsTransactionInternal = class {
 * });
 * ```
 */
-function zeroPostgresJS(schema, pg) {
+function zeroPostgresJS(schema, pg, options) {
 	if (typeof pg === "string") pg = postgres(pg, { connection: { ["application_name"]: "zero-server" } });
-	return new ZQLDatabase(new PostgresJSConnection(pg), schema);
+	return new ZQLDatabase(new PostgresJSConnection(pg, options), schema);
 }
 //#endregion
 export { PostgresJSConnection, PostgresJsTransactionInternal, zeroPostgresJS };

package/out/zero-server/src/adapters/postgresjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"postgresjs.js","names":["#pg"],"sources":["../../../../../zero-server/src/adapters/postgresjs.ts"],"sourcesContent":["import postgres from 'postgres';\nimport type {JSONValue} from '../../../shared/src/json.ts';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\n/**\n * Helper type for the wrapped transaction used by postgres.js.\n *\n * @typeParam T - The row-shape context bound to the postgres.js client.\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, PostgresJsTransaction>`.\n */\nexport type PostgresJsTransaction<\n  T extends Record<string, unknown> = Record<string, unknown>,\n> = postgres.TransactionSql<T>;\n\nexport class PostgresJSConnection<\n  T extends Record<string, unknown>,\n> implements DBConnection<PostgresJsTransaction<T>> {\n  readonly #pg: postgres.Sql<T>;\n  constructor(pg: postgres.Sql<T>) {\n    this.#pg = pg;\n  }\n\n  transaction<TRet>(\n    fn: (tx: DBTransaction<PostgresJsTransaction<T>>) => Promise<TRet>,\n  ): Promise<TRet> {\n    return this.#pg.begin(pgTx =>\n      fn(new PostgresJsTransactionInternal(pgTx)),\n    ) as Promise<TRet>;\n  }\n}\n\nexport class PostgresJsTransactionInternal<\n  T extends Record<string, unknown>,\n> implements DBTransaction<PostgresJsTransaction<T>> {\n  readonly wrappedTransaction: PostgresJsTransaction<T>;\n  constructor(pgTx: PostgresJsTransaction<T>) {\n    this.wrappedTransaction = pgTx;\n  }\n\n  query(sql: string, params: unknown[]): Promise<Row[]> {\n    return this.wrappedTransaction.unsafe(sql, params as JSONValue[]);\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n}\n\n/**\n * Wrap a `postgres` client for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying postgres.js transaction.\n * Use {@link PostgresJsTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param pg - `postgres` client or connection string.\n *\n * @example\n * ```ts\n * import postgres from 'postgres';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroPostgresJS} from '@rocicorp/zero/server/adapters/postgresjs';\n * import {z} from 'zod/mini';\n *\n * const sql = postgres(process.env.ZERO_UPSTREAM_DB!);\n * const zql = zeroPostgresJS(schema, sql);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction`\n *           INSERT INTO \"user\" (id, name, status)\n *           VALUES (${args.id}, ${args.name}, ${'active'})\n *         `;\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroPostgresJS<\n  S extends Schema,\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(schema: S, pg: postgres.Sql<T> | string) {\n  if (typeof pg === 'string') {\n    pg = postgres(pg, {\n      connection: {['application_name']: 'zero-server'},\n    }) as postgres.Sql<T>;\n  }\n  return new ZQLDatabase(new PostgresJSConnection(pg), schema);\n}\n"],"mappings":";;;;AA2BA,IAAa,uBAAb,MAEoD;CAClD;CACA,YAAY,IAAqB;EAC/B,KAAKA,MAAM;CACb;CAEA,YACE,IACe;EACf,OAAO,KAAKA,IAAI,OAAM,SACpB,GAAG,IAAI,8BAA8B,IAAI,CAAC,CAC5C;CACF;AACF;AAEA,IAAa,gCAAb,MAEqD;CACnD;CACA,YAAY,MAAgC;EAC1C,KAAK,qBAAqB;CAC5B;CAEA,MAAM,KAAa,QAAmC;EACpD,OAAO,KAAK,mBAAmB,OAAO,KAAK,MAAqB;CAClE;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,eAGd,QAAW,IAA8B;CACzC,IAAI,OAAO,OAAO,UAChB,KAAK,SAAS,IAAI,EAChB,YAAY,GAAE,qBAAqB,cAAa,EAClD,CAAC;CAEH,OAAO,IAAI,YAAY,IAAI,qBAAqB,EAAE,GAAG,MAAM;AAC7D"}
+{"version":3,"file":"postgresjs.js","names":["#pg","#options"],"sources":["../../../../../zero-server/src/adapters/postgresjs.ts"],"sourcesContent":["import postgres from 'postgres';\nimport type {JSONValue} from '../../../shared/src/json.ts';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport type {TransactionOptions} from '../transaction-options.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\n/**\n * Helper type for the wrapped transaction used by postgres.js.\n *\n * @typeParam T - The row-shape context bound to the postgres.js client.\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, PostgresJsTransaction>`.\n */\nexport type PostgresJsTransaction<\n  T extends Record<string, unknown> = Record<string, unknown>,\n> = postgres.TransactionSql<T>;\n\nexport class PostgresJSConnection<\n  T extends Record<string, unknown>,\n> implements DBConnection<PostgresJsTransaction<T>> {\n  readonly #pg: postgres.Sql<T>;\n  readonly #options: TransactionOptions;\n  constructor(pg: postgres.Sql<T>, options: TransactionOptions = {}) {\n    this.#pg = pg;\n    this.#options = options;\n  }\n\n  query(sql: string, params: unknown[]): Promise<Row[]> {\n    return postgresJsQuery(this.#pg, sql, params);\n  }\n\n  transaction<TRet>(\n    fn: (tx: DBTransaction<PostgresJsTransaction<T>>) => Promise<TRet>,\n  ): Promise<TRet> {\n    const run = (pgTx: PostgresJsTransaction<T>) =>\n      fn(new PostgresJsTransactionInternal(pgTx));\n    const {isolationLevel} = this.#options;\n    return (\n      isolationLevel === undefined\n        ? this.#pg.begin(run)\n        : this.#pg.begin(`isolation level ${isolationLevel}`, run)\n    ) as Promise<TRet>;\n  }\n}\n\nexport class PostgresJsTransactionInternal<\n  T extends Record<string, unknown>,\n> implements DBTransaction<PostgresJsTransaction<T>> {\n  readonly wrappedTransaction: PostgresJsTransaction<T>;\n  constructor(pgTx: PostgresJsTransaction<T>) {\n    this.wrappedTransaction = pgTx;\n  }\n\n  query(sql: string, params: unknown[]): Promise<Row[]> {\n    return postgresJsQuery(this.wrappedTransaction, sql, params);\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n}\n\nfunction postgresJsQuery<T extends Record<string, unknown>>(\n  sql: postgres.Sql<T>,\n  text: string,\n  params: unknown[],\n): Promise<Row[]> {\n  return sql.unsafe(text, params as JSONValue[]);\n}\n\n/**\n * Wrap a `postgres` client for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying postgres.js transaction.\n * Use {@link PostgresJsTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param pg - `postgres` client or connection string.\n *\n * @example\n * ```ts\n * import postgres from 'postgres';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroPostgresJS} from '@rocicorp/zero/server/adapters/postgresjs';\n * import {z} from 'zod/mini';\n *\n * const sql = postgres(process.env.ZERO_UPSTREAM_DB!);\n * const zql = zeroPostgresJS(schema, sql);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction`\n *           INSERT INTO \"user\" (id, name, status)\n *           VALUES (${args.id}, ${args.name}, ${'active'})\n *         `;\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroPostgresJS<\n  S extends Schema,\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(schema: S, pg: postgres.Sql<T> | string, options?: TransactionOptions) {\n  if (typeof pg === 'string') {\n    pg = postgres(pg, {\n      connection: {['application_name']: 'zero-server'},\n    }) as postgres.Sql<T>;\n  }\n  return new ZQLDatabase(new PostgresJSConnection(pg, options), schema);\n}\n"],"mappings":";;;;AA4BA,IAAa,uBAAb,MAEoD;CAClD;CACA;CACA,YAAY,IAAqB,UAA8B,CAAC,GAAG;EACjE,KAAKA,MAAM;EACX,KAAKC,WAAW;CAClB;CAEA,MAAM,KAAa,QAAmC;EACpD,OAAO,gBAAgB,KAAKD,KAAK,KAAK,MAAM;CAC9C;CAEA,YACE,IACe;EACf,MAAM,OAAO,SACX,GAAG,IAAI,8BAA8B,IAAI,CAAC;EAC5C,MAAM,EAAC,mBAAkB,KAAKC;EAC9B,OACE,mBAAmB,KAAA,IACf,KAAKD,IAAI,MAAM,GAAG,IAClB,KAAKA,IAAI,MAAM,mBAAmB,kBAAkB,GAAG;CAE/D;AACF;AAEA,IAAa,gCAAb,MAEqD;CACnD;CACA,YAAY,MAAgC;EAC1C,KAAK,qBAAqB;CAC5B;CAEA,MAAM,KAAa,QAAmC;EACpD,OAAO,gBAAgB,KAAK,oBAAoB,KAAK,MAAM;CAC7D;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;AACF;AAEA,SAAS,gBACP,KACA,MACA,QACgB;CAChB,OAAO,IAAI,OAAO,MAAM,MAAqB;AAC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,eAGd,QAAW,IAA8B,SAA8B;CACvE,IAAI,OAAO,OAAO,UAChB,KAAK,SAAS,IAAI,EAChB,YAAY,GAAE,qBAAqB,cAAa,EAClD,CAAC;CAEH,OAAO,IAAI,YAAY,IAAI,qBAAqB,IAAI,OAAO,GAAG,MAAM;AACtE"}

package/out/zero-server/src/adapters/prisma.d.ts

@@ -1,13 +1,24 @@
 import type { Schema } from '../../../zero-types/src/schema.ts';
-import type { DBConnection, DBTransaction } from '../../../zql/src/mutate/custom.ts';
+import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
+import type { TransactionOptions } from '../transaction-options.ts';
 import { ZQLDatabase } from '../zql-database.ts';
 export type { ZQLDatabase };
 export type PrismaTransactionLike = {
     $queryRawUnsafe: (query: string, ...params: unknown[]) => Promise<unknown>;
 };
-export type PrismaClientLike<TTransaction extends PrismaTransactionLike = PrismaTransactionLike> = {
-    $transaction: <T>(fn: (tx: TTransaction) => Promise<T>) => Promise<T>;
+export type PrismaClientLike<TTransaction extends PrismaTransactionLike = PrismaTransactionLike> = PrismaTransactionLike & {
+    $transaction: <T>(fn: (tx: TTransaction) => Promise<T>, options?: PrismaTransactionOptions | undefined) => Promise<T>;
 };
+/**
+ * The subset of Prisma's transaction options this adapter passes through.
+ *
+ * Prisma spells the levels in PascalCase rather than as Postgres does, so
+ * {@link PRISMA_ISOLATION_LEVELS} maps between them.
+ */
+type PrismaTransactionOptions = {
+    isolationLevel?: PrismaIsolationLevel;
+};
+type PrismaIsolationLevel = 'ReadCommitted' | 'RepeatableRead' | 'Serializable';
 /**
  * Helper type for the wrapped transaction used by Prisma.
  *
@@ -16,7 +27,8 @@ export type PrismaClientLike<TTransaction extends PrismaTransactionLike = Prisma
 export type PrismaTransaction<TClient extends PrismaClientLike = PrismaClientLike> = TClient extends PrismaClientLike<infer TTransaction> ? TTransaction : PrismaTransactionLike;
 export declare class PrismaConnection<TClient extends PrismaClientLike> implements DBConnection<PrismaTransaction<TClient>> {
     #private;
-    constructor(client: TClient);
+    constructor(client: TClient, options?: TransactionOptions);
+    query(sql: string, params: unknown[]): Promise<Iterable<Row>>;
     transaction<T>(fn: (tx: DBTransaction<PrismaTransaction<TClient>>) => Promise<T>): Promise<T>;
 }
 /**
@@ -62,5 +74,5 @@ export declare class PrismaConnection<TClient extends PrismaClientLike> implemen
  * });
  * ```
  */
-export declare function zeroPrisma<TSchema extends Schema, TClient extends PrismaClientLike>(schema: TSchema, client: TClient): ZQLDatabase<TSchema, PrismaTransaction<TClient>>;
+export declare function zeroPrisma<TSchema extends Schema, TClient extends PrismaClientLike>(schema: TSchema, client: TClient, options?: TransactionOptions): ZQLDatabase<TSchema, PrismaTransaction<TClient>>;
 //# sourceMappingURL=prisma.d.ts.map

package/out/zero-server/src/adapters/prisma.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/prisma.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAE9D,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAEd,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5E,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAC1B,YAAY,SAAS,qBAAqB,GAAG,qBAAqB,IAChE;IACF,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACvE,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAC3B,OAAO,SAAS,gBAAgB,GAAG,gBAAgB,IAEnD,OAAO,SAAS,gBAAgB,CAAC,MAAM,YAAY,CAAC,GAChD,YAAY,GACZ,qBAAqB,CAAC;AAE5B,qBAAa,gBAAgB,CAC3B,OAAO,SAAS,gBAAgB,CAChC,YAAW,YAAY,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;;IAGnD,YAAY,MAAM,EAAE,OAAO,EAE1B;IAED,WAAW,CAAC,CAAC,EACX,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAChE,OAAO,CAAC,CAAC,CAAC,CAQZ;CACF;AAwDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,UAAU,CACxB,OAAO,SAAS,MAAM,EACtB,OAAO,SAAS,gBAAgB,EAEhC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,OAAO,GACd,WAAW,CAAC,OAAO,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAElD"}
+{"version":3,"file":"prisma.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/prisma.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAE9D,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAG3C,OAAO,KAAK,EAEV,kBAAkB,EACnB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5E,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAC1B,YAAY,SAAS,qBAAqB,GAAG,qBAAqB,IAChE,qBAAqB,GAAG;IAC1B,YAAY,EAAE,CAAC,CAAC,EACd,EAAE,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,EACpC,OAAO,CAAC,EAAE,wBAAwB,GAAG,SAAS,KAC3C,OAAO,CAAC,CAAC,CAAC,CAAC;CACjB,CAAC;AAEF;;;;;GAKG;AACH,KAAK,wBAAwB,GAAG;IAG9B,cAAc,CAAC,EAAE,oBAAoB,CAAC;CACvC,CAAC;AAEF,KAAK,oBAAoB,GAAG,eAAe,GAAG,gBAAgB,GAAG,cAAc,CAAC;AAQhF;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAC3B,OAAO,SAAS,gBAAgB,GAAG,gBAAgB,IAEnD,OAAO,SAAS,gBAAgB,CAAC,MAAM,YAAY,CAAC,GAChD,YAAY,GACZ,qBAAqB,CAAC;AAE5B,qBAAa,gBAAgB,CAC3B,OAAO,SAAS,gBAAgB,CAChC,YAAW,YAAY,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;;IAInD,YAAY,MAAM,EAAE,OAAO,EAAE,OAAO,GAAE,kBAAuB,EAG5D;IAED,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAE5D;IAED,WAAW,CAAC,CAAC,EACX,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAChE,OAAO,CAAC,CAAC,CAAC,CAaZ;CACF;AA6DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,UAAU,CACxB,OAAO,SAAS,MAAM,EACtB,OAAO,SAAS,gBAAgB,EAEhC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,CAAC,OAAO,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAElD"}

package/out/zero-server/src/adapters/prisma.js

@@ -1,13 +1,24 @@
 import { executePostgresQuery } from "../pg-query-executor.js";
 import { ZQLDatabase } from "../zql-database.js";
 //#region ../zero-server/src/adapters/prisma.ts
+var PRISMA_ISOLATION_LEVELS = {
+	"read committed": "ReadCommitted",
+	"repeatable read": "RepeatableRead",
+	"serializable": "Serializable"
+};
 var PrismaConnection = class {
 	#client;
-	constructor(client) {
+	#options;
+	constructor(client, options = {}) {
 		this.#client = client;
+		this.#options = options;
+	}
+	query(sql, params) {
+		return prismaQuery(this.#client, sql, params);
 	}
 	transaction(fn) {
-		return this.#client.$transaction((prismaTx) => fn(new PrismaInternalTransaction(prismaTx)));
+		const { isolationLevel } = this.#options;
+		return this.#client.$transaction((prismaTx) => fn(new PrismaInternalTransaction(prismaTx)), isolationLevel === void 0 ? void 0 : { isolationLevel: PRISMA_ISOLATION_LEVELS[isolationLevel] });
 	}
 };
 var PrismaInternalTransaction = class {
@@ -18,10 +29,13 @@ var PrismaInternalTransaction = class {
 	runQuery(ast, format, schema, serverSchema) {
 		return executePostgresQuery(this, ast, format, schema, serverSchema);
 	}
-	async query(sql, params) {
-		return toIterableRows(await this.wrappedTransaction.$queryRawUnsafe(sql, ...params));
+	query(sql, params) {
+		return prismaQuery(this.wrappedTransaction, sql, params);
 	}
 };
+async function prismaQuery(client, sql, params) {
+	return toIterableRows(await client.$queryRawUnsafe(sql, ...params));
+}
 function isIterable(value) {
 	return value != null && typeof value[Symbol.iterator] === "function";
 }
@@ -74,8 +88,8 @@ function toIterableRows(result) {
 * });
 * ```
 */
-function zeroPrisma(schema, client) {
-	return new ZQLDatabase(new PrismaConnection(client), schema);
+function zeroPrisma(schema, client, options) {
+	return new ZQLDatabase(new PrismaConnection(client, options), schema);
 }
 //#endregion
 export { PrismaConnection, zeroPrisma };

package/out/zero-server/src/adapters/prisma.js.map

@@ -1 +1 @@
-{"version":3,"file":"prisma.js","names":["#client"],"sources":["../../../../../zero-server/src/adapters/prisma.ts"],"sourcesContent":["import type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\nexport type PrismaTransactionLike = {\n  $queryRawUnsafe: (query: string, ...params: unknown[]) => Promise<unknown>;\n};\n\nexport type PrismaClientLike<\n  TTransaction extends PrismaTransactionLike = PrismaTransactionLike,\n> = {\n  $transaction: <T>(fn: (tx: TTransaction) => Promise<T>) => Promise<T>;\n};\n\n/**\n * Helper type for the wrapped transaction used by Prisma.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, PrismaTransaction<typeof prisma>>`.\n */\nexport type PrismaTransaction<\n  TClient extends PrismaClientLike = PrismaClientLike,\n> =\n  TClient extends PrismaClientLike<infer TTransaction>\n    ? TTransaction\n    : PrismaTransactionLike;\n\nexport class PrismaConnection<\n  TClient extends PrismaClientLike,\n> implements DBConnection<PrismaTransaction<TClient>> {\n  readonly #client: TClient;\n\n  constructor(client: TClient) {\n    this.#client = client;\n  }\n\n  transaction<T>(\n    fn: (tx: DBTransaction<PrismaTransaction<TClient>>) => Promise<T>,\n  ): Promise<T> {\n    return this.#client.$transaction(prismaTx =>\n      fn(\n        new PrismaInternalTransaction(prismaTx) as DBTransaction<\n          PrismaTransaction<TClient>\n        >,\n      ),\n    );\n  }\n}\n\nclass PrismaInternalTransaction<\n  TTransaction extends PrismaTransactionLike,\n> implements DBTransaction<TTransaction> {\n  readonly wrappedTransaction: TTransaction;\n\n  constructor(prismaTx: TTransaction) {\n    this.wrappedTransaction = prismaTx;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  async query(sql: string, params: unknown[]): Promise<Iterable<Row>> {\n    const result = await this.wrappedTransaction.$queryRawUnsafe(\n      sql,\n      ...params,\n    );\n    return toIterableRows(result);\n  }\n}\n\nfunction isIterable(value: unknown): value is Iterable<unknown> {\n  return (\n    // oxlint-disable-next-line eqeqeq\n    value != null &&\n    typeof (value as Iterable<unknown>)[Symbol.iterator] === 'function'\n  );\n}\n\nfunction toIterableRows(result: unknown): Iterable<Row> {\n  if (result === null || result === undefined) {\n    return [] as Row[];\n  }\n  if (Array.isArray(result)) {\n    return result as Row[];\n  }\n  if (isIterable(result)) {\n    return result as Iterable<Row>;\n  }\n  return [] as Row[];\n}\n\n/**\n * Wrap a Prisma client for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying Prisma transaction.\n * Use {@link PrismaTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param client - Prisma client.\n *\n * @example\n * ```ts\n * import {PrismaPg} from '@prisma/adapter-pg';\n * import {PrismaClient} from '@prisma/client';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroPrisma} from '@rocicorp/zero/server/adapters/prisma';\n * import {z} from 'zod/mini';\n *\n * const prisma = new PrismaClient({\n *   adapter: new PrismaPg({connectionString: process.env.ZERO_UPSTREAM_DB!}),\n * });\n * const zql = zeroPrisma(schema, prisma);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction.user.create({\n *           data: {\n *             id: args.id,\n *             name: args.name,\n *             status: 'active',\n *           },\n *         });\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroPrisma<\n  TSchema extends Schema,\n  TClient extends PrismaClientLike,\n>(\n  schema: TSchema,\n  client: TClient,\n): ZQLDatabase<TSchema, PrismaTransaction<TClient>> {\n  return new ZQLDatabase(new PrismaConnection(client), schema);\n}\n"],"mappings":";;;AAqCA,IAAa,mBAAb,MAEsD;CACpD;CAEA,YAAY,QAAiB;EAC3B,KAAKA,UAAU;CACjB;CAEA,YACE,IACY;EACZ,OAAO,KAAKA,QAAQ,cAAa,aAC/B,GACE,IAAI,0BAA0B,QAAQ,CAGxC,CACF;CACF;AACF;AAEA,IAAM,4BAAN,MAEyC;CACvC;CAEA,YAAY,UAAwB;EAClC,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,MAAM,KAAa,QAA2C;EAKlE,OAAO,eAAe,MAJD,KAAK,mBAAmB,gBAC3C,KACA,GAAG,MACL,CAC4B;CAC9B;AACF;AAEA,SAAS,WAAW,OAA4C;CAC9D,OAEE,SAAS,QACT,OAAQ,MAA4B,OAAO,cAAc;AAE7D;AAEA,SAAS,eAAe,QAAgC;CACtD,IAAI,WAAW,QAAQ,WAAW,KAAA,GAChC,OAAO,CAAC;CAEV,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAET,IAAI,WAAW,MAAM,GACnB,OAAO;CAET,OAAO,CAAC;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,WAId,QACA,QACkD;CAClD,OAAO,IAAI,YAAY,IAAI,iBAAiB,MAAM,GAAG,MAAM;AAC7D"}
+{"version":3,"file":"prisma.js","names":["#client","#options"],"sources":["../../../../../zero-server/src/adapters/prisma.ts"],"sourcesContent":["import type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport type {\n  IsolationLevel,\n  TransactionOptions,\n} from '../transaction-options.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\nexport type PrismaTransactionLike = {\n  $queryRawUnsafe: (query: string, ...params: unknown[]) => Promise<unknown>;\n};\n\nexport type PrismaClientLike<\n  TTransaction extends PrismaTransactionLike = PrismaTransactionLike,\n> = PrismaTransactionLike & {\n  $transaction: <T>(\n    fn: (tx: TTransaction) => Promise<T>,\n    options?: PrismaTransactionOptions | undefined,\n  ) => Promise<T>;\n};\n\n/**\n * The subset of Prisma's transaction options this adapter passes through.\n *\n * Prisma spells the levels in PascalCase rather than as Postgres does, so\n * {@link PRISMA_ISOLATION_LEVELS} maps between them.\n */\ntype PrismaTransactionOptions = {\n  // No `| undefined`: Prisma's own option is declared without it, and under\n  // `exactOptionalPropertyTypes` that would make a real client unassignable.\n  isolationLevel?: PrismaIsolationLevel;\n};\n\ntype PrismaIsolationLevel = 'ReadCommitted' | 'RepeatableRead' | 'Serializable';\n\nconst PRISMA_ISOLATION_LEVELS: Record<IsolationLevel, PrismaIsolationLevel> = {\n  'read committed': 'ReadCommitted',\n  'repeatable read': 'RepeatableRead',\n  'serializable': 'Serializable',\n};\n\n/**\n * Helper type for the wrapped transaction used by Prisma.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, PrismaTransaction<typeof prisma>>`.\n */\nexport type PrismaTransaction<\n  TClient extends PrismaClientLike = PrismaClientLike,\n> =\n  TClient extends PrismaClientLike<infer TTransaction>\n    ? TTransaction\n    : PrismaTransactionLike;\n\nexport class PrismaConnection<\n  TClient extends PrismaClientLike,\n> implements DBConnection<PrismaTransaction<TClient>> {\n  readonly #client: TClient;\n  readonly #options: TransactionOptions;\n\n  constructor(client: TClient, options: TransactionOptions = {}) {\n    this.#client = client;\n    this.#options = options;\n  }\n\n  query(sql: string, params: unknown[]): Promise<Iterable<Row>> {\n    return prismaQuery(this.#client, sql, params);\n  }\n\n  transaction<T>(\n    fn: (tx: DBTransaction<PrismaTransaction<TClient>>) => Promise<T>,\n  ): Promise<T> {\n    const {isolationLevel} = this.#options;\n    return this.#client.$transaction(\n      prismaTx =>\n        fn(\n          new PrismaInternalTransaction(prismaTx) as DBTransaction<\n            PrismaTransaction<TClient>\n          >,\n        ),\n      isolationLevel === undefined\n        ? undefined\n        : {isolationLevel: PRISMA_ISOLATION_LEVELS[isolationLevel]},\n    );\n  }\n}\n\nclass PrismaInternalTransaction<\n  TTransaction extends PrismaTransactionLike,\n> implements DBTransaction<TTransaction> {\n  readonly wrappedTransaction: TTransaction;\n\n  constructor(prismaTx: TTransaction) {\n    this.wrappedTransaction = prismaTx;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  query(sql: string, params: unknown[]): Promise<Iterable<Row>> {\n    return prismaQuery(this.wrappedTransaction, sql, params);\n  }\n}\n\nasync function prismaQuery(\n  client: PrismaTransactionLike,\n  sql: string,\n  params: unknown[],\n): Promise<Iterable<Row>> {\n  const result = await client.$queryRawUnsafe(sql, ...params);\n  return toIterableRows(result);\n}\n\nfunction isIterable(value: unknown): value is Iterable<unknown> {\n  return (\n    // oxlint-disable-next-line eqeqeq\n    value != null &&\n    typeof (value as Iterable<unknown>)[Symbol.iterator] === 'function'\n  );\n}\n\nfunction toIterableRows(result: unknown): Iterable<Row> {\n  if (result === null || result === undefined) {\n    return [] as Row[];\n  }\n  if (Array.isArray(result)) {\n    return result as Row[];\n  }\n  if (isIterable(result)) {\n    return result as Iterable<Row>;\n  }\n  return [] as Row[];\n}\n\n/**\n * Wrap a Prisma client for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying Prisma transaction.\n * Use {@link PrismaTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param client - Prisma client.\n *\n * @example\n * ```ts\n * import {PrismaPg} from '@prisma/adapter-pg';\n * import {PrismaClient} from '@prisma/client';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroPrisma} from '@rocicorp/zero/server/adapters/prisma';\n * import {z} from 'zod/mini';\n *\n * const prisma = new PrismaClient({\n *   adapter: new PrismaPg({connectionString: process.env.ZERO_UPSTREAM_DB!}),\n * });\n * const zql = zeroPrisma(schema, prisma);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction.user.create({\n *           data: {\n *             id: args.id,\n *             name: args.name,\n *             status: 'active',\n *           },\n *         });\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroPrisma<\n  TSchema extends Schema,\n  TClient extends PrismaClientLike,\n>(\n  schema: TSchema,\n  client: TClient,\n  options?: TransactionOptions,\n): ZQLDatabase<TSchema, PrismaTransaction<TClient>> {\n  return new ZQLDatabase(new PrismaConnection(client, options), schema);\n}\n"],"mappings":";;;AA8CA,IAAM,0BAAwE;CAC5E,kBAAkB;CAClB,mBAAmB;CACnB,gBAAgB;AAClB;AAcA,IAAa,mBAAb,MAEsD;CACpD;CACA;CAEA,YAAY,QAAiB,UAA8B,CAAC,GAAG;EAC7D,KAAKA,UAAU;EACf,KAAKC,WAAW;CAClB;CAEA,MAAM,KAAa,QAA2C;EAC5D,OAAO,YAAY,KAAKD,SAAS,KAAK,MAAM;CAC9C;CAEA,YACE,IACY;EACZ,MAAM,EAAC,mBAAkB,KAAKC;EAC9B,OAAO,KAAKD,QAAQ,cAClB,aACE,GACE,IAAI,0BAA0B,QAAQ,CAGxC,GACF,mBAAmB,KAAA,IACf,KAAA,IACA,EAAC,gBAAgB,wBAAwB,gBAAe,CAC9D;CACF;AACF;AAEA,IAAM,4BAAN,MAEyC;CACvC;CAEA,YAAY,UAAwB;EAClC,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,KAAa,QAA2C;EAC5D,OAAO,YAAY,KAAK,oBAAoB,KAAK,MAAM;CACzD;AACF;AAEA,eAAe,YACb,QACA,KACA,QACwB;CAExB,OAAO,eAAe,MADD,OAAO,gBAAgB,KAAK,GAAG,MAAM,CAC9B;AAC9B;AAEA,SAAS,WAAW,OAA4C;CAC9D,OAEE,SAAS,QACT,OAAQ,MAA4B,OAAO,cAAc;AAE7D;AAEA,SAAS,eAAe,QAAgC;CACtD,IAAI,WAAW,QAAQ,WAAW,KAAA,GAChC,OAAO,CAAC;CAEV,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAET,IAAI,WAAW,MAAM,GACnB,OAAO;CAET,OAAO,CAAC;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,WAId,QACA,QACA,SACkD;CAClD,OAAO,IAAI,YAAY,IAAI,iBAAiB,QAAQ,OAAO,GAAG,MAAM;AACtE"}

package/out/zero-server/src/closable-db-transaction.d.ts

@@ -0,0 +1,16 @@
+import type { DBTransaction, Queryable } from '../../zql/src/mutate/custom.ts';
+import type { HumanReadable } from '../../zql/src/query/query.ts';
+/**
+ * A {@linkcode DBTransaction} that stops working once closed. The mutator's
+ * `tx` is built on it, so code that outlives the transaction cannot reach a
+ * connection that has been committed, rolled back or returned to the pool.
+ */
+export declare class ClosableDBTransaction<T> implements DBTransaction<T> {
+    #private;
+    constructor(inner: DBTransaction<T>);
+    close(): void;
+    get wrappedTransaction(): T;
+    query: Queryable['query'];
+    runQuery<TReturn>(...args: Parameters<DBTransaction<T>['runQuery']>): Promise<HumanReadable<TReturn>>;
+}
+//# sourceMappingURL=closable-db-transaction.d.ts.map

package/out/zero-server/src/closable-db-transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closable-db-transaction.d.ts","sourceRoot":"","sources":["../../../../zero-server/src/closable-db-transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,SAAS,EAAC,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,8BAA8B,CAAC;AAEhE;;;;GAIG;AACH,qBAAa,qBAAqB,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;;IAI/D,YAAY,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAElC;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,IAAI,kBAAkB,IAAI,CAAC,CAK1B;IAED,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,CAGY;IAErC,QAAQ,CAAC,OAAO,EACd,GAAG,IAAI,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAChD,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAIjC;CACF"}