@rocicorp/zero 1.11.0-canary.37 → 1.11.0-canary.39
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/out/shared/src/valita.d.ts +75 -0
- package/out/shared/src/valita.d.ts.map +1 -1
- package/out/shared/src/valita.js +119 -1
- package/out/shared/src/valita.js.map +1 -1
- package/out/zero/package.js +1 -1
- package/out/zero/package.js.map +1 -1
- package/out/zero-cache/src/services/view-syncer/inspect-handler.d.ts +12 -2
- package/out/zero-cache/src/services/view-syncer/inspect-handler.d.ts.map +1 -1
- package/out/zero-cache/src/services/view-syncer/inspect-handler.js +27 -3
- package/out/zero-cache/src/services/view-syncer/inspect-handler.js.map +1 -1
- package/out/zero-cache/src/services/view-syncer/view-syncer.d.ts.map +1 -1
- package/out/zero-cache/src/services/view-syncer/view-syncer.js.map +1 -1
- package/out/zero-cache/src/workers/connection.d.ts +2 -1
- package/out/zero-cache/src/workers/connection.d.ts.map +1 -1
- package/out/zero-cache/src/workers/connection.js +9 -1
- package/out/zero-cache/src/workers/connection.js.map +1 -1
- package/out/zero-client/src/client/storage-version.d.ts +23 -0
- package/out/zero-client/src/client/storage-version.d.ts.map +1 -0
- package/out/zero-client/src/client/version.js +1 -1
- package/out/zero-client/src/client/zero.d.ts.map +1 -1
- package/out/zero-client/src/client/zero.js +1 -1
- package/out/zero-client/src/client/zero.js.map +1 -1
- package/out/zero-protocol/src/analyze-query-result.d.ts +12 -12
- package/out/zero-protocol/src/analyze-query-result.d.ts.map +1 -1
- package/out/zero-protocol/src/analyze-query-result.js +3 -3
- package/out/zero-protocol/src/analyze-query-result.js.map +1 -1
- package/out/zero-protocol/src/ast.d.ts +24 -0
- package/out/zero-protocol/src/ast.d.ts.map +1 -1
- package/out/zero-protocol/src/ast.js +26 -2
- package/out/zero-protocol/src/ast.js.map +1 -1
- package/out/zero-protocol/src/down.d.ts +5 -5
- package/out/zero-protocol/src/inspect-down.d.ts +15 -15
- package/out/zero-protocol/src/inspect-up.d.ts +158 -61
- package/out/zero-protocol/src/inspect-up.d.ts.map +1 -1
- package/out/zero-protocol/src/inspect-up.js +12 -6
- package/out/zero-protocol/src/inspect-up.js.map +1 -1
- package/out/zero-protocol/src/protocol-version.d.ts +4 -1
- package/out/zero-protocol/src/protocol-version.d.ts.map +1 -1
- package/out/zero-protocol/src/protocol-version.js.map +1 -1
- package/out/zero-protocol/src/queries-patch.js +2 -2
- package/out/zero-protocol/src/queries-patch.js.map +1 -1
- package/out/zero-protocol/src/up.d.ts +766 -256
- package/out/zero-protocol/src/up.d.ts.map +1 -1
- package/out/zero-protocol/src/up.js +25 -3
- package/out/zero-protocol/src/up.js.map +1 -1
- package/out/zero-server/src/adapters/drizzle.d.ts +14 -3
- package/out/zero-server/src/adapters/drizzle.d.ts.map +1 -1
- package/out/zero-server/src/adapters/drizzle.js +7 -4
- package/out/zero-server/src/adapters/drizzle.js.map +1 -1
- package/out/zero-server/src/adapters/kysely.d.ts +4 -2
- package/out/zero-server/src/adapters/kysely.d.ts.map +1 -1
- package/out/zero-server/src/adapters/kysely.js +8 -4
- package/out/zero-server/src/adapters/kysely.js.map +1 -1
- package/out/zero-server/src/adapters/pg.d.ts +3 -2
- package/out/zero-server/src/adapters/pg.d.ts.map +1 -1
- package/out/zero-server/src/adapters/pg.js +7 -4
- package/out/zero-server/src/adapters/pg.js.map +1 -1
- package/out/zero-server/src/adapters/postgresjs.d.ts +3 -2
- package/out/zero-server/src/adapters/postgresjs.d.ts.map +1 -1
- package/out/zero-server/src/adapters/postgresjs.js +8 -4
- package/out/zero-server/src/adapters/postgresjs.js.map +1 -1
- package/out/zero-server/src/adapters/prisma.d.ts +14 -3
- package/out/zero-server/src/adapters/prisma.d.ts.map +1 -1
- package/out/zero-server/src/adapters/prisma.js +12 -4
- package/out/zero-server/src/adapters/prisma.js.map +1 -1
- package/out/zero-server/src/mod.d.ts +1 -0
- package/out/zero-server/src/mod.d.ts.map +1 -1
- package/out/zero-server/src/transaction-options.d.ts +24 -0
- package/out/zero-server/src/transaction-options.d.ts.map +1 -0
- package/out/zero-server/src/transaction-options.js +11 -0
- package/out/zero-server/src/transaction-options.js.map +1 -0
- package/out/zql/src/query/query-registry.js +1 -1
- package/out/zqlite/src/sqlite-cost-model.d.ts.map +1 -1
- package/out/zqlite/src/sqlite-cost-model.js +1 -0
- package/out/zqlite/src/sqlite-cost-model.js.map +1 -1
- package/package.json +1 -1
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"up.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/up.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAchD,eAAO,MAAM,cAAc
|
|
1
|
+
{"version":3,"file":"up.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/up.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAchD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc1B,CAAC;AAEF,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAclD,CAAC;AAIF,MAAM,MAAM,QAAQ,GAAG,OAAO,CAC5B,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,EAC9B,CAAC,CAAC,iBAAiB,CACpB,CAAC;AACF,MAAM,MAAM,gCAAgC,GAAG,OAAO,CACpD,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,EACtD,CAAC,CAAC,iBAAiB,CACpB,CAAC"}
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { taggedTupleUnion } from "../../shared/src/valita.js";
|
|
2
2
|
import { deleteClientsMessageSchema } from "./delete-clients.js";
|
|
3
3
|
import { initConnectionMessageSchema } from "./connect.js";
|
|
4
4
|
import { pullRequestMessageSchema } from "./pull.js";
|
|
@@ -8,8 +8,30 @@ import { changeDesiredQueriesMessageSchema } from "./change-desired-queries.js";
|
|
|
8
8
|
import { closeConnectionMessageSchema } from "./close-connection.js";
|
|
9
9
|
import { pingMessageSchema } from "./ping.js";
|
|
10
10
|
import { updateAuthMessageSchema } from "./update-auth.js";
|
|
11
|
-
|
|
12
|
-
|
|
11
|
+
taggedTupleUnion([
|
|
12
|
+
initConnectionMessageSchema,
|
|
13
|
+
pingMessageSchema,
|
|
14
|
+
deleteClientsMessageSchema,
|
|
15
|
+
changeDesiredQueriesMessageSchema,
|
|
16
|
+
pullRequestMessageSchema,
|
|
17
|
+
updateAuthMessageSchema,
|
|
18
|
+
pushMessageSchema,
|
|
19
|
+
closeConnectionMessageSchema,
|
|
20
|
+
inspectUpMessageSchema,
|
|
21
|
+
ackMutationResponsesMessageSchema
|
|
22
|
+
], { open: true });
|
|
23
|
+
var upstreamSchemaWithUnparsedAnalyzeQuery = taggedTupleUnion([
|
|
24
|
+
initConnectionMessageSchema,
|
|
25
|
+
pingMessageSchema,
|
|
26
|
+
deleteClientsMessageSchema,
|
|
27
|
+
changeDesiredQueriesMessageSchema,
|
|
28
|
+
pullRequestMessageSchema,
|
|
29
|
+
updateAuthMessageSchema,
|
|
30
|
+
pushMessageSchema,
|
|
31
|
+
closeConnectionMessageSchema,
|
|
32
|
+
unparsedInspectUpMessageSchema,
|
|
33
|
+
ackMutationResponsesMessageSchema
|
|
34
|
+
], { open: true });
|
|
13
35
|
//#endregion
|
|
14
36
|
export { upstreamSchemaWithUnparsedAnalyzeQuery };
|
|
15
37
|
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"up.js","names":[],"sources":["../../../../zero-protocol/src/up.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {changeDesiredQueriesMessageSchema} from './change-desired-queries.ts';\nimport {closeConnectionMessageSchema} from './close-connection.ts';\nimport {initConnectionMessageSchema} from './connect.ts';\nimport {deleteClientsMessageSchema} from './delete-clients.ts';\nimport {\n inspectUpMessageSchema,\n unparsedInspectUpMessageSchema,\n} from './inspect-up.ts';\nimport {pingMessageSchema} from './ping.ts';\nimport {pullRequestMessageSchema} from './pull.ts';\nimport {ackMutationResponsesMessageSchema, pushMessageSchema} from './push.ts';\nimport {updateAuthMessageSchema} from './update-auth.ts';\n\nexport const upstreamSchema = v.
|
|
1
|
+
{"version":3,"file":"up.js","names":[],"sources":["../../../../zero-protocol/src/up.ts"],"sourcesContent":["import * as v from '../../shared/src/valita.ts';\nimport {changeDesiredQueriesMessageSchema} from './change-desired-queries.ts';\nimport {closeConnectionMessageSchema} from './close-connection.ts';\nimport {initConnectionMessageSchema} from './connect.ts';\nimport {deleteClientsMessageSchema} from './delete-clients.ts';\nimport {\n inspectUpMessageSchema,\n unparsedInspectUpMessageSchema,\n} from './inspect-up.ts';\nimport {pingMessageSchema} from './ping.ts';\nimport {pullRequestMessageSchema} from './pull.ts';\nimport {ackMutationResponsesMessageSchema, pushMessageSchema} from './push.ts';\nimport {updateAuthMessageSchema} from './update-auth.ts';\n\nexport const upstreamSchema = v.taggedTupleUnion(\n [\n initConnectionMessageSchema,\n pingMessageSchema,\n deleteClientsMessageSchema,\n changeDesiredQueriesMessageSchema,\n pullRequestMessageSchema,\n updateAuthMessageSchema,\n pushMessageSchema,\n closeConnectionMessageSchema,\n inspectUpMessageSchema,\n ackMutationResponsesMessageSchema,\n ],\n {open: true},\n);\n\nexport const upstreamSchemaWithUnparsedAnalyzeQuery = v.taggedTupleUnion(\n [\n initConnectionMessageSchema,\n pingMessageSchema,\n deleteClientsMessageSchema,\n changeDesiredQueriesMessageSchema,\n pullRequestMessageSchema,\n updateAuthMessageSchema,\n pushMessageSchema,\n closeConnectionMessageSchema,\n unparsedInspectUpMessageSchema,\n ackMutationResponsesMessageSchema,\n ],\n {open: true},\n);\n\n// The messages this build knows. Parsing can also return a v.UnrecognizedTuple\n// from a newer client; check with `isKnown`.\nexport type Upstream = Exclude<\n v.Infer<typeof upstreamSchema>,\n v.UnrecognizedTuple\n>;\nexport type UpstreamWithUnparsedAnalyzeQuery = Exclude<\n v.Infer<typeof upstreamSchemaWithUnparsedAnalyzeQuery>,\n v.UnrecognizedTuple\n>;\n"],"mappings":";;;;;;;;;;AAc8B,iBAC5B;CACE;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,GACA,EAAC,MAAM,KAAI,CACb;AAEA,IAAa,yCAAyC,iBACpD;CACE;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,GACA,EAAC,MAAM,KAAI,CACb"}
|
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import type { Schema } from '../../../zero-types/src/schema.ts';
|
|
2
2
|
import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
|
|
3
|
+
import type { TransactionOptions } from '../transaction-options.ts';
|
|
3
4
|
import { ZQLDatabase } from '../zql-database.ts';
|
|
4
5
|
export type { ZQLDatabase };
|
|
5
6
|
type DrizzleSession = {
|
|
@@ -26,7 +27,17 @@ type DrizzleTransactionFromSchema<TSchema> = DrizzleTransactionLike & {
|
|
|
26
27
|
};
|
|
27
28
|
};
|
|
28
29
|
export type DrizzleDatabase<TTransaction extends DrizzleTransactionLike = DrizzleTransactionLike> = DrizzleTransactionLike & {
|
|
29
|
-
transaction<T>(transaction: (tx: TTransaction) => Promise<T>, config?:
|
|
30
|
+
transaction<T>(transaction: (tx: TTransaction) => Promise<T>, config?: DrizzleTransactionConfig | undefined): Promise<T>;
|
|
31
|
+
};
|
|
32
|
+
/**
|
|
33
|
+
* Mirrors drizzle's own `PgTransactionConfig` so a real drizzle database stays
|
|
34
|
+
* assignable to {@link DrizzleDatabase}. Only `isolationLevel` is passed
|
|
35
|
+
* through by this adapter.
|
|
36
|
+
*/
|
|
37
|
+
type DrizzleTransactionConfig = {
|
|
38
|
+
isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
|
|
39
|
+
accessMode?: 'read only' | 'read write';
|
|
40
|
+
deferrable?: boolean;
|
|
30
41
|
};
|
|
31
42
|
/**
|
|
32
43
|
* Helper type for the wrapped transaction used by drizzle-orm.
|
|
@@ -36,7 +47,7 @@ export type DrizzleDatabase<TTransaction extends DrizzleTransactionLike = Drizzl
|
|
|
36
47
|
export type DrizzleTransaction<TDbOrSchema = Record<string, unknown>> = TDbOrSchema extends DrizzleDatabase<infer TTransaction> ? TTransaction : DrizzleTransactionFromSchema<TDbOrSchema>;
|
|
37
48
|
export declare class DrizzleConnection<TDrizzle, TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>> implements DBConnection<TTransaction> {
|
|
38
49
|
#private;
|
|
39
|
-
constructor(drizzle: TDrizzle & DrizzleDatabase<TTransaction
|
|
50
|
+
constructor(drizzle: TDrizzle & DrizzleDatabase<TTransaction>, options?: TransactionOptions);
|
|
40
51
|
query(sql: string, params: unknown[]): Promise<Iterable<Row>>;
|
|
41
52
|
transaction<T>(fn: (tx: DBTransaction<TTransaction>) => Promise<T>): Promise<T>;
|
|
42
53
|
}
|
|
@@ -79,5 +90,5 @@ export declare function toIterableRows(result: unknown): Iterable<Row>;
|
|
|
79
90
|
* });
|
|
80
91
|
* ```
|
|
81
92
|
*/
|
|
82
|
-
export declare function zeroDrizzle<TSchema extends Schema, TDrizzle, TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>>(schema: TSchema, client: TDrizzle & DrizzleDatabase<TTransaction
|
|
93
|
+
export declare function zeroDrizzle<TSchema extends Schema, TDrizzle, TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>>(schema: TSchema, client: TDrizzle & DrizzleDatabase<TTransaction>, options?: TransactionOptions): ZQLDatabase<TSchema, TTransaction>;
|
|
83
94
|
//# sourceMappingURL=drizzle.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/drizzle.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,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAmB1B,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC;CAChC,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,CAAC,EAAE;QAAC,OAAO,EAAE,cAAc,CAAA;KAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,kBAAkB,CAAC,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,GAAG;IACxD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS;IAAC,YAAY,EAAE,MAAM,OAAO,CAAA;CAAC,GAC1E,OAAO,GACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,KAAK,4BAA4B,CAAC,OAAO,IAAI,sBAAsB,GAAG;IACpE,KAAK,EAAE;SACJ,MAAM,IAAI,MAAM,OAAO,GAAG;YACzB,SAAS,CACP,IAAI,CAAC,EAAE,OAAO,GACb,kBAAkB,CAAC,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;SACxE;KACF,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,eAAe,CACzB,YAAY,SAAS,sBAAsB,GAAG,sBAAsB,IAClE,sBAAsB,GAAG;IAC3B,WAAW,CAAC,CAAC,EACX,WAAW,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,EAC7C,MAAM,CAAC,EAAE,
|
|
1
|
+
{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/drizzle.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,EAAC,kBAAkB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAmB1B,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC;CAChC,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,CAAC,EAAE;QAAC,OAAO,EAAE,cAAc,CAAA;KAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,kBAAkB,CAAC,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,GAAG;IACxD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS;IAAC,YAAY,EAAE,MAAM,OAAO,CAAA;CAAC,GAC1E,OAAO,GACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,KAAK,4BAA4B,CAAC,OAAO,IAAI,sBAAsB,GAAG;IACpE,KAAK,EAAE;SACJ,MAAM,IAAI,MAAM,OAAO,GAAG;YACzB,SAAS,CACP,IAAI,CAAC,EAAE,OAAO,GACb,kBAAkB,CAAC,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;SACxE;KACF,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,eAAe,CACzB,YAAY,SAAS,sBAAsB,GAAG,sBAAsB,IAClE,sBAAsB,GAAG;IAC3B,WAAW,CAAC,CAAC,EACX,WAAW,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,EAC7C,MAAM,CAAC,EAAE,wBAAwB,GAAG,SAAS,GAC5C,OAAO,CAAC,CAAC,CAAC,CAAC;CACf,CAAC;AAEF;;;;GAIG;AACH,KAAK,wBAAwB,GAAG;IAC9B,cAAc,CAAC,EACX,kBAAkB,GAClB,gBAAgB,GAChB,iBAAiB,GACjB,cAAc,CAAC;IACnB,UAAU,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC;IACxC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAClE,WAAW,SAAS,eAAe,CAAC,MAAM,YAAY,CAAC,GACnD,YAAY,GACZ,4BAA4B,CAAC,WAAW,CAAC,CAAC;AAEhD,qBAAa,iBAAiB,CAC5B,QAAQ,EACR,YAAY,SAAS,sBAAsB,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAC1E,YAAW,YAAY,CAAC,YAAY,CAAC;;IAIrC,YACE,OAAO,EAAE,QAAQ,GAAG,eAAe,CAAC,YAAY,CAAC,EACjD,OAAO,GAAE,kBAAuB,EAIjC;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,YAAY,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAClD,OAAO,CAAC,CAAC,CAAC,CAWZ;CACF;AA+DD,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,CAuB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,WAAW,CACzB,OAAO,SAAS,MAAM,EACtB,QAAQ,EACR,YAAY,SAAS,sBAAsB,GAAG,kBAAkB,CAAC,QAAQ,CAAC,EAE1E,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,QAAQ,GAAG,eAAe,CAAC,YAAY,CAAC,EAChD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,CAKpC"}
|
|
@@ -3,14 +3,17 @@ import { ZQLDatabase } from "../zql-database.js";
|
|
|
3
3
|
//#region ../zero-server/src/adapters/drizzle.ts
|
|
4
4
|
var DrizzleConnection = class {
|
|
5
5
|
#drizzle;
|
|
6
|
-
|
|
6
|
+
#options;
|
|
7
|
+
constructor(drizzle, options = {}) {
|
|
7
8
|
this.#drizzle = drizzle;
|
|
9
|
+
this.#options = options;
|
|
8
10
|
}
|
|
9
11
|
query(sql, params) {
|
|
10
12
|
return runDrizzleQuery(this.#drizzle._.session, sql, params);
|
|
11
13
|
}
|
|
12
14
|
transaction(fn) {
|
|
13
|
-
|
|
15
|
+
const { isolationLevel } = this.#options;
|
|
16
|
+
return this.#drizzle.transaction((drizzleTx) => fn(new DrizzleInternalTransaction(drizzleTx)), isolationLevel === void 0 ? void 0 : { isolationLevel });
|
|
14
17
|
}
|
|
15
18
|
};
|
|
16
19
|
var DrizzleInternalTransaction = class {
|
|
@@ -85,8 +88,8 @@ function toIterableRows(result) {
|
|
|
85
88
|
* });
|
|
86
89
|
* ```
|
|
87
90
|
*/
|
|
88
|
-
function zeroDrizzle(schema, client) {
|
|
89
|
-
return new ZQLDatabase(new DrizzleConnection(client), schema);
|
|
91
|
+
function zeroDrizzle(schema, client, options) {
|
|
92
|
+
return new ZQLDatabase(new DrizzleConnection(client, options), schema);
|
|
90
93
|
}
|
|
91
94
|
//#endregion
|
|
92
95
|
export { DrizzleConnection, toIterableRows, zeroDrizzle };
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"drizzle.js","names":["#drizzle"],"sources":["../../../../../zero-server/src/adapters/drizzle.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\ntype DrizzleQuery = {sql: string; params: unknown[]};\ntype DrizzlePreparedQuery = {execute(): Promise<unknown>};\n\ntype DrizzlePrepareQueryV0 = (\n query: DrizzleQuery,\n fields: undefined,\n name: undefined,\n isResponseInArrayMode: false,\n) => DrizzlePreparedQuery;\n\ntype DrizzlePrepareQueryV1 = (\n query: DrizzleQuery,\n mode: 'objects',\n name: undefined,\n mapper: undefined,\n) => DrizzlePreparedQuery;\n\ntype DrizzleSession = {\n prepareQuery: {length: number};\n};\n\ntype DrizzleTransactionLike = {\n _: {session: DrizzleSession};\n};\n\ntype DrizzleQueryResult<TResult> = PromiseLike<TResult> & {\n execute(): Promise<TResult>;\n};\n\ntype DrizzleInferSelect<TTable> = TTable extends {$inferSelect: infer TSelect}\n ? TSelect\n : Record<string, unknown>;\n\ntype DrizzleTransactionFromSchema<TSchema> = DrizzleTransactionLike & {\n query: {\n [TTable in keyof TSchema]: {\n findFirst(\n args?: unknown,\n ): DrizzleQueryResult<DrizzleInferSelect<TSchema[TTable]> | undefined>;\n };\n };\n};\n\nexport type DrizzleDatabase<\n TTransaction extends DrizzleTransactionLike = DrizzleTransactionLike,\n> = DrizzleTransactionLike & {\n transaction<T>(\n transaction: (tx: TTransaction) => Promise<T>,\n config?:
|
|
1
|
+
{"version":3,"file":"drizzle.js","names":["#drizzle","#options"],"sources":["../../../../../zero-server/src/adapters/drizzle.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 {TransactionOptions} from '../transaction-options.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\ntype DrizzleQuery = {sql: string; params: unknown[]};\ntype DrizzlePreparedQuery = {execute(): Promise<unknown>};\n\ntype DrizzlePrepareQueryV0 = (\n query: DrizzleQuery,\n fields: undefined,\n name: undefined,\n isResponseInArrayMode: false,\n) => DrizzlePreparedQuery;\n\ntype DrizzlePrepareQueryV1 = (\n query: DrizzleQuery,\n mode: 'objects',\n name: undefined,\n mapper: undefined,\n) => DrizzlePreparedQuery;\n\ntype DrizzleSession = {\n prepareQuery: {length: number};\n};\n\ntype DrizzleTransactionLike = {\n _: {session: DrizzleSession};\n};\n\ntype DrizzleQueryResult<TResult> = PromiseLike<TResult> & {\n execute(): Promise<TResult>;\n};\n\ntype DrizzleInferSelect<TTable> = TTable extends {$inferSelect: infer TSelect}\n ? TSelect\n : Record<string, unknown>;\n\ntype DrizzleTransactionFromSchema<TSchema> = DrizzleTransactionLike & {\n query: {\n [TTable in keyof TSchema]: {\n findFirst(\n args?: unknown,\n ): DrizzleQueryResult<DrizzleInferSelect<TSchema[TTable]> | undefined>;\n };\n };\n};\n\nexport type DrizzleDatabase<\n TTransaction extends DrizzleTransactionLike = DrizzleTransactionLike,\n> = DrizzleTransactionLike & {\n transaction<T>(\n transaction: (tx: TTransaction) => Promise<T>,\n config?: DrizzleTransactionConfig | undefined,\n ): Promise<T>;\n};\n\n/**\n * Mirrors drizzle's own `PgTransactionConfig` so a real drizzle database stays\n * assignable to {@link DrizzleDatabase}. Only `isolationLevel` is passed\n * through by this adapter.\n */\ntype DrizzleTransactionConfig = {\n isolationLevel?:\n | 'read uncommitted'\n | 'read committed'\n | 'repeatable read'\n | 'serializable';\n accessMode?: 'read only' | 'read write';\n deferrable?: boolean;\n};\n\n/**\n * Helper type for the wrapped transaction used by drizzle-orm.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, DrizzleTransaction<typeof drizzleDb>>`.\n */\nexport type DrizzleTransaction<TDbOrSchema = Record<string, unknown>> =\n TDbOrSchema extends DrizzleDatabase<infer TTransaction>\n ? TTransaction\n : DrizzleTransactionFromSchema<TDbOrSchema>;\n\nexport class DrizzleConnection<\n TDrizzle,\n TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>,\n> implements DBConnection<TTransaction> {\n readonly #drizzle: DrizzleDatabase<TTransaction>;\n readonly #options: TransactionOptions;\n\n constructor(\n drizzle: TDrizzle & DrizzleDatabase<TTransaction>,\n options: TransactionOptions = {},\n ) {\n this.#drizzle = drizzle;\n this.#options = options;\n }\n\n query(sql: string, params: unknown[]): Promise<Iterable<Row>> {\n return runDrizzleQuery(this.#drizzle._.session, sql, params);\n }\n\n transaction<T>(\n fn: (tx: DBTransaction<TTransaction>) => Promise<T>,\n ): Promise<T> {\n const {isolationLevel} = this.#options;\n return this.#drizzle.transaction(\n drizzleTx =>\n fn(\n new DrizzleInternalTransaction(\n drizzleTx,\n ) as DBTransaction<TTransaction>,\n ),\n isolationLevel === undefined ? undefined : {isolationLevel},\n );\n }\n}\n\nclass DrizzleInternalTransaction<\n TTransaction extends DrizzleTransactionLike,\n> implements DBTransaction<TTransaction> {\n readonly wrappedTransaction: TTransaction;\n\n constructor(drizzleTx: TTransaction) {\n this.wrappedTransaction = drizzleTx;\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 runDrizzleQuery(this.wrappedTransaction._.session, sql, params);\n }\n}\n\nasync function runDrizzleQuery(\n session: DrizzleSession,\n sql: string,\n params: unknown[],\n): Promise<Iterable<Row>> {\n const query = {sql, params};\n const prepared =\n session.prepareQuery.length < 7\n ? (session.prepareQuery as DrizzlePrepareQueryV1)(\n query,\n 'objects',\n undefined,\n undefined,\n )\n : (session.prepareQuery as DrizzlePrepareQueryV0)(\n query,\n undefined,\n undefined,\n false,\n );\n const result = await prepared.execute();\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\nexport function 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 if (typeof result === 'object') {\n const rows = (result as {rows?: unknown}).rows;\n if (rows === null || rows === undefined) {\n return [] as Row[];\n }\n if (Array.isArray(rows)) {\n return rows as Row[];\n }\n if (isIterable(rows)) {\n return rows as Iterable<Row>;\n }\n }\n throw new TypeError('Drizzle query result is not iterable');\n}\n\n/**\n * Wrap a `drizzle-orm` database for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying drizzle transaction.\n * Use {@link DrizzleTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param client - Drizzle database.\n *\n * @example\n * ```ts\n * import {Pool} from 'pg';\n * import {drizzle} from 'drizzle-orm/node-postgres';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroDrizzle} from '@rocicorp/zero/server/adapters/drizzle';\n * import {z} from 'zod/mini';\n *\n * const pool = new Pool({connectionString: process.env.ZERO_UPSTREAM_DB!});\n * const drizzleDb = drizzle(pool, {schema: drizzleSchema});\n * const zql = zeroDrizzle(schema, drizzleDb);\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(drizzleSchema.user)\n * .values({id: args.id, name: args.name, status: 'active'});\n * },\n * ),\n * },\n * });\n * ```\n */\nexport function zeroDrizzle<\n TSchema extends Schema,\n TDrizzle,\n TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>,\n>(\n schema: TSchema,\n client: TDrizzle & DrizzleDatabase<TTransaction>,\n options?: TransactionOptions,\n): ZQLDatabase<TSchema, TTransaction> {\n return new ZQLDatabase(\n new DrizzleConnection<TDrizzle, TTransaction>(client, options),\n schema,\n );\n}\n"],"mappings":";;;AA6FA,IAAa,oBAAb,MAGwC;CACtC;CACA;CAEA,YACE,SACA,UAA8B,CAAC,GAC/B;EACA,KAAKA,WAAW;EAChB,KAAKC,WAAW;CAClB;CAEA,MAAM,KAAa,QAA2C;EAC5D,OAAO,gBAAgB,KAAKD,SAAS,EAAE,SAAS,KAAK,MAAM;CAC7D;CAEA,YACE,IACY;EACZ,MAAM,EAAC,mBAAkB,KAAKC;EAC9B,OAAO,KAAKD,SAAS,aACnB,cACE,GACE,IAAI,2BACF,SACF,CACF,GACF,mBAAmB,KAAA,IAAY,KAAA,IAAY,EAAC,eAAc,CAC5D;CACF;AACF;AAEA,IAAM,6BAAN,MAEyC;CACvC;CAEA,YAAY,WAAyB;EACnC,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,KAAa,QAA2C;EAC5D,OAAO,gBAAgB,KAAK,mBAAmB,EAAE,SAAS,KAAK,MAAM;CACvE;AACF;AAEA,eAAe,gBACb,SACA,KACA,QACwB;CACxB,MAAM,QAAQ;EAAC;EAAK;CAAM;CAgB1B,OAAO,eAAe,OAdpB,QAAQ,aAAa,SAAS,IACzB,QAAQ,aACP,OACA,WACA,KAAA,GACA,KAAA,CACF,IACC,QAAQ,aACP,OACA,KAAA,GACA,KAAA,GACA,KACF,GACwB,QAAQ,CACV;AAC9B;AAEA,SAAS,WAAW,OAA4C;CAC9D,OAEE,SAAS,QACT,OAAQ,MAA4B,OAAO,cAAc;AAE7D;AAEA,SAAgB,eAAe,QAAgC;CAC7D,IAAI,WAAW,QAAQ,WAAW,KAAA,GAChC,OAAO,CAAC;CAEV,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAET,IAAI,WAAW,MAAM,GACnB,OAAO;CAET,IAAI,OAAO,WAAW,UAAU;EAC9B,MAAM,OAAQ,OAA4B;EAC1C,IAAI,SAAS,QAAQ,SAAS,KAAA,GAC5B,OAAO,CAAC;EAEV,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO;EAET,IAAI,WAAW,IAAI,GACjB,OAAO;CAEX;CACA,MAAM,IAAI,UAAU,sCAAsC;AAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,YAKd,QACA,QACA,SACoC;CACpC,OAAO,IAAI,YACT,IAAI,kBAA0C,QAAQ,OAAO,GAC7D,MACF;AACF"}
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import type { Kysely, Transaction as WrappedKyselyTransaction } from 'kysely';
|
|
2
2
|
import type { Schema } from '../../../zero-types/src/schema.ts';
|
|
3
3
|
import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
|
|
4
|
+
import type { TransactionOptions } from '../transaction-options.ts';
|
|
4
5
|
import { ZQLDatabase } from '../zql-database.ts';
|
|
5
6
|
export type { ZQLDatabase };
|
|
6
7
|
export type KyselyDatabase<TDatabase = unknown> = Kysely<TDatabase>;
|
|
@@ -12,7 +13,7 @@ export type KyselyDatabase<TDatabase = unknown> = Kysely<TDatabase>;
|
|
|
12
13
|
export type KyselyTransaction<TDbOrSchema = KyselyDatabase> = TDbOrSchema extends Kysely<infer TInferredDatabase> ? WrappedKyselyTransaction<TInferredDatabase> : WrappedKyselyTransaction<TDbOrSchema>;
|
|
13
14
|
export declare class KyselyConnection<TDatabase> implements DBConnection<WrappedKyselyTransaction<TDatabase>> {
|
|
14
15
|
#private;
|
|
15
|
-
constructor(client: Kysely<TDatabase
|
|
16
|
+
constructor(client: Kysely<TDatabase>, options?: TransactionOptions);
|
|
16
17
|
query(sql: string, params: unknown[]): Promise<Row[]>;
|
|
17
18
|
transaction<T>(fn: (tx: DBTransaction<WrappedKyselyTransaction<TDatabase>>) => Promise<T>): Promise<T>;
|
|
18
19
|
}
|
|
@@ -24,6 +25,7 @@ export declare class KyselyConnection<TDatabase> implements DBConnection<Wrapped
|
|
|
24
25
|
*
|
|
25
26
|
* @param schema - Zero schema.
|
|
26
27
|
* @param client - Kysely client.
|
|
28
|
+
* @param options - Transaction options, e.g. `{isolationLevel: 'repeatable read'}`.
|
|
27
29
|
*
|
|
28
30
|
* @example
|
|
29
31
|
* ```ts
|
|
@@ -66,5 +68,5 @@ export declare class KyselyConnection<TDatabase> implements DBConnection<Wrapped
|
|
|
66
68
|
* });
|
|
67
69
|
* ```
|
|
68
70
|
*/
|
|
69
|
-
export declare function zeroKysely<TSchema extends Schema, TDatabase>(schema: TSchema, client: Kysely<TDatabase
|
|
71
|
+
export declare function zeroKysely<TSchema extends Schema, TDatabase>(schema: TSchema, client: Kysely<TDatabase>, options?: TransactionOptions): ZQLDatabase<TSchema, WrappedKyselyTransaction<TDatabase>>;
|
|
70
72
|
//# sourceMappingURL=kysely.d.ts.map
|
|
@@ -1 +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,EACb,GAAG,EACJ,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;;
|
|
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,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"}
|
|
@@ -4,14 +4,17 @@ import { CompiledQuery } from "kysely";
|
|
|
4
4
|
//#region ../zero-server/src/adapters/kysely.ts
|
|
5
5
|
var KyselyConnection = class {
|
|
6
6
|
#client;
|
|
7
|
-
|
|
7
|
+
#options;
|
|
8
|
+
constructor(client, options = {}) {
|
|
8
9
|
this.#client = client;
|
|
10
|
+
this.#options = options;
|
|
9
11
|
}
|
|
10
12
|
query(sql, params) {
|
|
11
13
|
return kyselyQuery(this.#client, sql, params);
|
|
12
14
|
}
|
|
13
15
|
transaction(fn) {
|
|
14
|
-
|
|
16
|
+
const { isolationLevel } = this.#options;
|
|
17
|
+
return (isolationLevel === void 0 ? this.#client.transaction() : this.#client.transaction().setIsolationLevel(isolationLevel)).execute((kyselyTx) => fn(new KyselyInternalTransaction(kyselyTx)));
|
|
15
18
|
}
|
|
16
19
|
};
|
|
17
20
|
var KyselyInternalTransaction = class {
|
|
@@ -37,6 +40,7 @@ async function kyselyQuery(executor, sql, params) {
|
|
|
37
40
|
*
|
|
38
41
|
* @param schema - Zero schema.
|
|
39
42
|
* @param client - Kysely client.
|
|
43
|
+
* @param options - Transaction options, e.g. `{isolationLevel: 'repeatable read'}`.
|
|
40
44
|
*
|
|
41
45
|
* @example
|
|
42
46
|
* ```ts
|
|
@@ -79,8 +83,8 @@ async function kyselyQuery(executor, sql, params) {
|
|
|
79
83
|
* });
|
|
80
84
|
* ```
|
|
81
85
|
*/
|
|
82
|
-
function zeroKysely(schema, client) {
|
|
83
|
-
return new ZQLDatabase(new KyselyConnection(client), schema);
|
|
86
|
+
function zeroKysely(schema, client, options) {
|
|
87
|
+
return new ZQLDatabase(new KyselyConnection(client, options), schema);
|
|
84
88
|
}
|
|
85
89
|
//#endregion
|
|
86
90
|
export { KyselyConnection, zeroKysely };
|
|
@@ -1 +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
|
|
1
|
+
{"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"}
|
|
@@ -7,6 +7,7 @@ import type { Schema } from '../../../zero-types/src/schema.ts';
|
|
|
7
7
|
import type { ServerSchema } from '../../../zero-types/src/server-schema.ts';
|
|
8
8
|
import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
|
|
9
9
|
import type { HumanReadable } from '../../../zql/src/query/query.ts';
|
|
10
|
+
import { type TransactionOptions } from '../transaction-options.ts';
|
|
10
11
|
import { ZQLDatabase } from '../zql-database.ts';
|
|
11
12
|
export type { ZQLDatabase };
|
|
12
13
|
/**
|
|
@@ -17,7 +18,7 @@ export type { ZQLDatabase };
|
|
|
17
18
|
export type NodePgTransaction = Pool | PoolClient | Client;
|
|
18
19
|
export declare class NodePgConnection implements DBConnection<NodePgTransaction> {
|
|
19
20
|
#private;
|
|
20
|
-
constructor(pool: NodePgTransaction);
|
|
21
|
+
constructor(pool: NodePgTransaction, options?: TransactionOptions);
|
|
21
22
|
query(sql: string, params: unknown[]): Promise<Row[]>;
|
|
22
23
|
transaction<TRet>(fn: (tx: DBTransaction<NodePgTransaction>) => Promise<TRet>): Promise<TRet>;
|
|
23
24
|
}
|
|
@@ -66,5 +67,5 @@ export declare class NodePgTransactionInternal implements DBTransaction<NodePgTr
|
|
|
66
67
|
* });
|
|
67
68
|
* ```
|
|
68
69
|
*/
|
|
69
|
-
export declare function zeroNodePg<S extends Schema>(schema: S, pg: NodePgTransaction | string, lc?: LogContext): ZQLDatabase<S, NodePgTransaction>;
|
|
70
|
+
export declare function zeroNodePg<S extends Schema>(schema: S, pg: NodePgTransaction | string, lc?: LogContext, options?: TransactionOptions): ZQLDatabase<S, NodePgTransaction>;
|
|
70
71
|
//# sourceMappingURL=pg.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"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,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;;
|
|
1
|
+
{"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"}
|
|
@@ -1,12 +1,15 @@
|
|
|
1
1
|
import { executePostgresQuery } from "../pg-query-executor.js";
|
|
2
2
|
import { createLogContext } from "../logging.js";
|
|
3
3
|
import { ZQLDatabase } from "../zql-database.js";
|
|
4
|
+
import { beginStatement } from "../transaction-options.js";
|
|
4
5
|
import { DatabaseError, Pool } from "pg";
|
|
5
6
|
//#region ../zero-server/src/adapters/pg.ts
|
|
6
7
|
var NodePgConnection = class {
|
|
7
8
|
#pool;
|
|
8
|
-
|
|
9
|
+
#options;
|
|
10
|
+
constructor(pool, options = {}) {
|
|
9
11
|
this.#pool = pool;
|
|
12
|
+
this.#options = options;
|
|
10
13
|
}
|
|
11
14
|
query(sql, params) {
|
|
12
15
|
return nodePgQuery(this.#pool, sql, params);
|
|
@@ -19,7 +22,7 @@ var NodePgConnection = class {
|
|
|
19
22
|
};
|
|
20
23
|
client.on("error", onError);
|
|
21
24
|
try {
|
|
22
|
-
await client.query(
|
|
25
|
+
await client.query(beginStatement(this.#options.isolationLevel));
|
|
23
26
|
const result = await fn(new NodePgTransactionInternal(client));
|
|
24
27
|
await client.query("COMMIT");
|
|
25
28
|
return result;
|
|
@@ -88,7 +91,7 @@ async function nodePgQuery(client, sql, params) {
|
|
|
88
91
|
* });
|
|
89
92
|
* ```
|
|
90
93
|
*/
|
|
91
|
-
function zeroNodePg(schema, pg, lc = createLogContext("warn")) {
|
|
94
|
+
function zeroNodePg(schema, pg, lc = createLogContext("warn"), options) {
|
|
92
95
|
if (typeof pg === "string") {
|
|
93
96
|
const pool = new Pool({ connectionString: pg });
|
|
94
97
|
pool.on("error", (e) => {
|
|
@@ -96,7 +99,7 @@ function zeroNodePg(schema, pg, lc = createLogContext("warn")) {
|
|
|
96
99
|
});
|
|
97
100
|
pg = pool;
|
|
98
101
|
}
|
|
99
|
-
return new ZQLDatabase(new NodePgConnection(pg), schema);
|
|
102
|
+
return new ZQLDatabase(new NodePgConnection(pg, options), schema);
|
|
100
103
|
}
|
|
101
104
|
//#endregion
|
|
102
105
|
export { NodePgConnection, NodePgTransactionInternal, zeroNodePg };
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"pg.js","names":["#pool"],"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 {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 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(
|
|
1
|
+
{"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"}
|
|
@@ -5,6 +5,7 @@ import type { Schema } from '../../../zero-types/src/schema.ts';
|
|
|
5
5
|
import type { ServerSchema } from '../../../zero-types/src/server-schema.ts';
|
|
6
6
|
import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
|
|
7
7
|
import type { HumanReadable } from '../../../zql/src/query/query.ts';
|
|
8
|
+
import type { TransactionOptions } from '../transaction-options.ts';
|
|
8
9
|
import { ZQLDatabase } from '../zql-database.ts';
|
|
9
10
|
export type { ZQLDatabase };
|
|
10
11
|
/**
|
|
@@ -16,7 +17,7 @@ export type { ZQLDatabase };
|
|
|
16
17
|
export type PostgresJsTransaction<T extends Record<string, unknown> = Record<string, unknown>> = postgres.TransactionSql<T>;
|
|
17
18
|
export declare class PostgresJSConnection<T extends Record<string, unknown>> implements DBConnection<PostgresJsTransaction<T>> {
|
|
18
19
|
#private;
|
|
19
|
-
constructor(pg: postgres.Sql<T
|
|
20
|
+
constructor(pg: postgres.Sql<T>, options?: TransactionOptions);
|
|
20
21
|
query(sql: string, params: unknown[]): Promise<Row[]>;
|
|
21
22
|
transaction<TRet>(fn: (tx: DBTransaction<PostgresJsTransaction<T>>) => Promise<TRet>): Promise<TRet>;
|
|
22
23
|
}
|
|
@@ -63,5 +64,5 @@ export declare class PostgresJsTransactionInternal<T extends Record<string, unkn
|
|
|
63
64
|
* });
|
|
64
65
|
* ```
|
|
65
66
|
*/
|
|
66
|
-
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>>;
|
|
67
|
+
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>>;
|
|
67
68
|
//# sourceMappingURL=postgresjs.d.ts.map
|
|
@@ -1 +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;;
|
|
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,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"}
|
|
@@ -4,14 +4,18 @@ import postgres from "postgres";
|
|
|
4
4
|
//#region ../zero-server/src/adapters/postgresjs.ts
|
|
5
5
|
var PostgresJSConnection = class {
|
|
6
6
|
#pg;
|
|
7
|
-
|
|
7
|
+
#options;
|
|
8
|
+
constructor(pg, options = {}) {
|
|
8
9
|
this.#pg = pg;
|
|
10
|
+
this.#options = options;
|
|
9
11
|
}
|
|
10
12
|
query(sql, params) {
|
|
11
13
|
return postgresJsQuery(this.#pg, sql, params);
|
|
12
14
|
}
|
|
13
15
|
transaction(fn) {
|
|
14
|
-
|
|
16
|
+
const run = (pgTx) => fn(new PostgresJsTransactionInternal(pgTx));
|
|
17
|
+
const { isolationLevel } = this.#options;
|
|
18
|
+
return isolationLevel === void 0 ? this.#pg.begin(run) : this.#pg.begin(`isolation level ${isolationLevel}`, run);
|
|
15
19
|
}
|
|
16
20
|
};
|
|
17
21
|
var PostgresJsTransactionInternal = class {
|
|
@@ -66,9 +70,9 @@ function postgresJsQuery(sql, text, params) {
|
|
|
66
70
|
* });
|
|
67
71
|
* ```
|
|
68
72
|
*/
|
|
69
|
-
function zeroPostgresJS(schema, pg) {
|
|
73
|
+
function zeroPostgresJS(schema, pg, options) {
|
|
70
74
|
if (typeof pg === "string") pg = postgres(pg, { connection: { ["application_name"]: "zero-server" } });
|
|
71
|
-
return new ZQLDatabase(new PostgresJSConnection(pg), schema);
|
|
75
|
+
return new ZQLDatabase(new PostgresJSConnection(pg, options), schema);
|
|
72
76
|
}
|
|
73
77
|
//#endregion
|
|
74
78
|
export { PostgresJSConnection, PostgresJsTransactionInternal, zeroPostgresJS };
|
|
@@ -1 +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
|
|
1
|
+
{"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"}
|
|
@@ -1,13 +1,24 @@
|
|
|
1
1
|
import type { Schema } from '../../../zero-types/src/schema.ts';
|
|
2
2
|
import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
|
|
3
|
+
import type { TransactionOptions } from '../transaction-options.ts';
|
|
3
4
|
import { ZQLDatabase } from '../zql-database.ts';
|
|
4
5
|
export type { ZQLDatabase };
|
|
5
6
|
export type PrismaTransactionLike = {
|
|
6
7
|
$queryRawUnsafe: (query: string, ...params: unknown[]) => Promise<unknown>;
|
|
7
8
|
};
|
|
8
9
|
export type PrismaClientLike<TTransaction extends PrismaTransactionLike = PrismaTransactionLike> = PrismaTransactionLike & {
|
|
9
|
-
$transaction: <T>(fn: (tx: TTransaction) => Promise<T
|
|
10
|
+
$transaction: <T>(fn: (tx: TTransaction) => Promise<T>, options?: PrismaTransactionOptions | undefined) => Promise<T>;
|
|
10
11
|
};
|
|
12
|
+
/**
|
|
13
|
+
* The subset of Prisma's transaction options this adapter passes through.
|
|
14
|
+
*
|
|
15
|
+
* Prisma spells the levels in PascalCase rather than as Postgres does, so
|
|
16
|
+
* {@link PRISMA_ISOLATION_LEVELS} maps between them.
|
|
17
|
+
*/
|
|
18
|
+
type PrismaTransactionOptions = {
|
|
19
|
+
isolationLevel?: PrismaIsolationLevel;
|
|
20
|
+
};
|
|
21
|
+
type PrismaIsolationLevel = 'ReadCommitted' | 'RepeatableRead' | 'Serializable';
|
|
11
22
|
/**
|
|
12
23
|
* Helper type for the wrapped transaction used by Prisma.
|
|
13
24
|
*
|
|
@@ -16,7 +27,7 @@ export type PrismaClientLike<TTransaction extends PrismaTransactionLike = Prisma
|
|
|
16
27
|
export type PrismaTransaction<TClient extends PrismaClientLike = PrismaClientLike> = TClient extends PrismaClientLike<infer TTransaction> ? TTransaction : PrismaTransactionLike;
|
|
17
28
|
export declare class PrismaConnection<TClient extends PrismaClientLike> implements DBConnection<PrismaTransaction<TClient>> {
|
|
18
29
|
#private;
|
|
19
|
-
constructor(client: TClient);
|
|
30
|
+
constructor(client: TClient, options?: TransactionOptions);
|
|
20
31
|
query(sql: string, params: unknown[]): Promise<Iterable<Row>>;
|
|
21
32
|
transaction<T>(fn: (tx: DBTransaction<PrismaTransaction<TClient>>) => Promise<T>): Promise<T>;
|
|
22
33
|
}
|
|
@@ -63,5 +74,5 @@ export declare class PrismaConnection<TClient extends PrismaClientLike> implemen
|
|
|
63
74
|
* });
|
|
64
75
|
* ```
|
|
65
76
|
*/
|
|
66
|
-
export declare function zeroPrisma<TSchema extends Schema, TClient extends PrismaClientLike>(schema: TSchema, client: TClient): ZQLDatabase<TSchema, PrismaTransaction<TClient>>;
|
|
77
|
+
export declare function zeroPrisma<TSchema extends Schema, TClient extends PrismaClientLike>(schema: TSchema, client: TClient, options?: TransactionOptions): ZQLDatabase<TSchema, PrismaTransaction<TClient>>;
|
|
67
78
|
//# sourceMappingURL=prisma.d.ts.map
|
|
@@ -1 +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,EACb,GAAG,EACJ,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,qBAAqB,GAAG;IAC1B,YAAY,EAAE,CAAC,CAAC,
|
|
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,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"}
|