joist-orm 2.4.0 → 2.5.0-next.1
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/build/drivers/PostgreJsDriver.cjs +216 -0
- package/build/drivers/PostgreJsDriver.cjs.map +1 -0
- package/build/drivers/PostgreJsDriver.d.cts +87 -0
- package/build/drivers/PostgreJsDriver.d.cts.map +1 -0
- package/build/drivers/PostgreJsDriver.d.mts +87 -0
- package/build/drivers/PostgreJsDriver.d.mts.map +1 -0
- package/build/drivers/PostgreJsDriver.js +212 -0
- package/build/drivers/PostgreJsDriver.js.map +1 -0
- package/build/drivers/PostgresDriver.cjs +165 -196
- package/build/drivers/PostgresDriver.cjs.map +1 -1
- package/build/drivers/PostgresDriver.d.cts +71 -47
- package/build/drivers/PostgresDriver.d.cts.map +1 -1
- package/build/drivers/PostgresDriver.d.mts +71 -47
- package/build/drivers/PostgresDriver.d.mts.map +1 -1
- package/build/drivers/PostgresDriver.js +164 -197
- package/build/drivers/PostgresDriver.js.map +1 -1
- package/build/drivers/WireRowData.cjs +26 -130
- package/build/drivers/WireRowData.cjs.map +1 -1
- package/build/drivers/WireRowData.d.cts +26 -33
- package/build/drivers/WireRowData.d.cts.map +1 -1
- package/build/drivers/WireRowData.d.mts +26 -33
- package/build/drivers/WireRowData.d.mts.map +1 -1
- package/build/drivers/WireRowData.js +27 -128
- package/build/drivers/WireRowData.js.map +1 -1
- package/build/drivers/binaryParsers.cjs +21 -13
- package/build/drivers/binaryParsers.cjs.map +1 -1
- package/build/drivers/binaryParsers.d.cts +16 -18
- package/build/drivers/binaryParsers.d.cts.map +1 -1
- package/build/drivers/binaryParsers.d.mts +16 -18
- package/build/drivers/binaryParsers.d.mts.map +1 -1
- package/build/drivers/binaryParsers.js +21 -13
- package/build/drivers/binaryParsers.js.map +1 -1
- package/build/drivers/patchPgProtocol.cjs.map +1 -1
- package/build/drivers/patchPgProtocol.d.cts +2 -3
- package/build/drivers/patchPgProtocol.d.cts.map +1 -1
- package/build/drivers/patchPgProtocol.d.mts +2 -3
- package/build/drivers/patchPgProtocol.d.mts.map +1 -1
- package/build/drivers/patchPgProtocol.js.map +1 -1
- package/build/drivers/postgresSql.cjs +145 -0
- package/build/drivers/postgresSql.cjs.map +1 -0
- package/build/drivers/postgresSql.d.cts +19 -0
- package/build/drivers/postgresSql.d.cts.map +1 -0
- package/build/drivers/postgresSql.d.mts +19 -0
- package/build/drivers/postgresSql.d.mts.map +1 -0
- package/build/drivers/postgresSql.js +143 -0
- package/build/drivers/postgresSql.js.map +1 -0
- package/build/index.js +1 -2
- package/build/pg-export.d.cts +1 -1
- package/build/pg-export.d.mts +1 -1
- package/build/postgrejs-export.cjs +3 -0
- package/build/postgrejs-export.d.cts +2 -0
- package/build/postgrejs-export.d.mts +2 -0
- package/build/postgrejs-export.js +1 -0
- package/build/seed.d.cts +1 -2
- package/build/seed.d.cts.map +1 -1
- package/build/seed.d.mts +1 -2
- package/build/seed.d.mts.map +1 -1
- package/package.json +38 -11
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"PostgreJsDriver.js","names":[],"sources":["../../src/drivers/PostgreJsDriver.ts"],"sourcesContent":["import {\n type Driver,\n type DriverQueryResult,\n type EntityManager,\n type IdAssigner,\n type JoinRowTodo,\n type ParsedFindQuery,\n type PreloadPlugin,\n type RowData,\n SequenceIdAssigner,\n type Todo,\n buildRawQuery,\n driverAfterBegin,\n driverAfterCommit,\n driverBeforeBegin,\n driverBeforeCommit,\n fail,\n getRuntimeConfig,\n requireTemporal,\n} from \"joist-core\";\nimport * as native from \"postgrejs\";\nimport type {\n AnyParseFunction,\n Connection,\n DataMappingOptions,\n FieldInfo,\n Pool,\n QueryOptions,\n QueryResult,\n} from \"postgrejs\";\n\nimport { flushPostgres, toPgParams } from \"./postgresSql.ts\";\nimport { WireRowData } from \"./WireRowData.ts\";\n\nexport interface PostgreJsDriverOpts {\n idAssigner?: IdAssigner;\n /** Sets a default `PreloadPlugin` for any `EntityManager` that uses this driver. */\n preloadPlugin?: PreloadPlugin;\n /** Observes SQL before submission to PostgreJS. */\n onQuery?: (sql: string) => void;\n}\n\n/** PostgreSQL over native PostgreJS pools and transaction connections. */\nexport class PostgreJsDriver implements Driver<Connection> {\n readonly #idAssigner: IdAssigner;\n readonly #preloadPlugin: PreloadPlugin | undefined;\n private readonly onQuery: PostgreJsDriverOpts[\"onQuery\"];\n\n constructor(\n readonly pool: Pool,\n opts?: PostgreJsDriverOpts,\n ) {\n this.onQuery = opts?.onQuery;\n this.#preloadPlugin = opts?.preloadPlugin;\n\n this.#idAssigner =\n opts?.idAssigner ?? new SequenceIdAssigner(async (sql) => (await this.query(undefined, sql, [])).rows);\n }\n\n /** Executes through the native pool or the transaction's native connection. */\n private query(txn: Connection | undefined, sql: string, bindings: readonly unknown[]): Promise<DriverQueryResult> {\n this.onQuery?.(sql);\n return executeNativeQuery(txn ?? this.pool, sql, bindings);\n }\n\n /** Executes an entity find with the EntityManager's default limit. */\n async executeFind(\n em: EntityManager,\n parsed: ParsedFindQuery,\n settings: { limit?: number; offset?: number },\n ): Promise<any[]> {\n const { sql, bindings } = buildRawQuery(parsed, { limit: em.entityLimit, ...settings });\n return (await this.executeQuery(em, sql, bindings)).rows;\n }\n\n /** Returns PostgreJS command counts and rows through Joist's query boundary. */\n executeQuery(em: EntityManager, sql: string, bindings: readonly unknown[]): Promise<DriverQueryResult> {\n return this.query(em.txn as Connection | undefined, toPgParams(sql), bindings);\n }\n\n /** Assigns identifiers with the configured strategy before dependent writes. */\n async assignNewIds(_: EntityManager, todos: Record<string, Todo>): Promise<void> {\n await this.#idAssigner.assignNewIds(todos);\n }\n\n /** Flushes PostgreSQL operations on the active native PostgreJS transaction. */\n async flush(\n em: EntityManager,\n entityTodos: Record<string, Todo>,\n joinRows: Record<string, JoinRowTodo>,\n ): Promise<void> {\n const txn = (em.txn ?? fail(\"Expected EntityManager.txn to be set\")) as Connection;\n await this.#idAssigner.assignNewIds(entityTodos);\n await flushPostgres((sql, bindings) => this.query(txn, sql, bindings), entityTodos, joinRows);\n }\n\n get defaultPlugins() {\n return { preloadPlugin: this.#preloadPlugin };\n }\n\n /**\n * Supplies lazy entity rows through PostgreJS's native decoder hook.\n *\n * EntityManager uses this for finds, loads and o2m/o2o/recursive loads.\n * M2m join-table rows, lazy columns and id/count queries use eager results.\n * Deferred parser errors surface on field access.\n */\n async executeFindRowData(\n em: EntityManager,\n parsed: ParsedFindQuery,\n settings: { limit?: number; offset?: number },\n ): Promise<RowData> {\n const { sql, bindings } = buildRawQuery(parsed, { limit: em.entityLimit, ...settings });\n const pgSql = toPgParams(sql);\n this.onQuery?.(pgSql);\n const decoder = new PostgreJsRowDecoder();\n const client = (em.txn as Connection | undefined) ?? this.pool;\n await client.query(pgSql, {\n ...mappingOptions(true),\n params: bindings as unknown[],\n rowDecoder: decoder,\n });\n return decoder.rows;\n }\n\n /**\n * Preserves transaction hooks and rollback on a dedicated native connection.\n *\n * The callback and all ORM queries share this Connection; close returns it to its pool.\n */\n async transaction<T>(em: EntityManager, fn: (txn: Connection) => Promise<T>): Promise<T> {\n if (em.txn) return fn(em.txn as Connection);\n const client = await this.pool.acquire();\n let result: T;\n try {\n await driverBeforeBegin(em, client);\n this.onQuery?.(\"BEGIN;\");\n await executeNativeQuery(client, \"BEGIN\", []);\n em.txn = client;\n try {\n await driverAfterBegin(em, client);\n result = await fn(client);\n await driverBeforeCommit(em, client);\n this.onQuery?.(\"COMMIT;\");\n await executeNativeQuery(client, \"COMMIT\", []);\n } catch (error) {\n await executeNativeQuery(client, \"ROLLBACK\", []);\n throw error;\n } finally {\n em.txn = undefined;\n }\n await driverAfterCommit(em, client);\n } finally {\n await client.close();\n }\n return result;\n }\n}\n\n/** Records immutable raw rows, leaving all value construction to field access. */\nexport class PostgreJsRowDecoder extends native.RowDecoder {\n readonly rows = new WireRowData(0);\n #chunk: Buffer | undefined;\n\n /**\n * Records a row when PostgreJS supplies its payload as a Buffer slice.\n *\n * PostgreJS calls this on paths that collect raw DataRow messages before decoding them.\n * For example, if a query needs the server's money format, it buffers the rows, finishes\n * the SQL response, obtains that format, and then calls decode for each buffered row\n * before resolving the query. These paths call decode even when decodeAt is implemented.\n *\n * `data` is a view of one row's payload within a larger backing ArrayBuffer, not a copy.\n * We reuse one Buffer spanning that backing allocation and forward the row's offset and\n * length to decodeAt. Neither method parses field values; WireRowData does that later\n * when Joist accesses an entity field.\n */\n decode(parsers: AnyParseFunction[], data: Buffer, count: number, options: DataMappingOptions, fields: FieldInfo[]) {\n if (this.#chunk?.buffer !== data.buffer) this.#chunk = Buffer.from(data.buffer);\n return this.decodeAt(parsers, this.#chunk!, data.byteOffset, data.byteLength, count, options, fields);\n }\n\n /**\n * Records a row directly from PostgreJS's incoming socket buffer.\n *\n * On the streaming query path, PostgreJS first receives RowDescription and resolves the\n * column metadata and parsers. As each subsequent DataRow arrives, it prefers decodeAt\n * over decode when this method exists, passing the socket buffer plus the row payload's\n * offset and length. This avoids allocating a separate Buffer slice for every row.\n *\n * The first row installs column decoders; every call retains the raw row bytes. PostgreJS\n * stores our undefined return value in its ordinary result.rows, which Joist ignores.\n * Once the query completes, executeFindRowData returns this decoder's WireRowData for\n * entity hydration. Actual field parsing remains deferred until a field is accessed.\n */\n override decodeAt(\n parsers: AnyParseFunction[],\n buffer: Buffer,\n offset: number,\n length: number,\n _count: number,\n options: DataMappingOptions,\n fields: FieldInfo[],\n ) {\n if (this.rows.rowCount === 0) {\n // Use separate function scopes and copy only decoding options so the stored closures cannot\n // capture decodeAt's socket buffer or the original query options, which also hold params.\n this.rows.setColumnDecoders(columnDecoders(parsers, fields, decodingOptions(options)));\n }\n this.rows.addRow(buffer, offset, length);\n return undefined;\n }\n}\n\n/** Selects the options used to decode field values. */\nfunction decodingOptions(options: DataMappingOptions): DataMappingOptions {\n return {\n decimalAsString: options.decimalAsString,\n temporalTypes: options.temporalTypes,\n timeZone: options.timeZone,\n dateStyle: options.dateStyle,\n moneyFormat: options.moneyFormat,\n utcDates: options.utcDates,\n fetchAsString: options.fetchAsString,\n unknownTypesAsString: options.unknownTypesAsString,\n };\n}\n\n/** Adapts native parsers to Joist's column decoders without changing their values. */\nfunction columnDecoders(parsers: AnyParseFunction[], fields: FieldInfo[], options: DataMappingOptions) {\n return fields.map((field, index) => ({\n name: field.fieldName,\n decode: (chunk: Buffer, start: number, len: number) => parsers[index](chunk, start, len, options),\n }));\n}\n\nlet lazyMappingOptions: QueryOptions | undefined;\nlet eagerMappingOptions: QueryOptions | undefined;\n\n/** Lazily captures application-wide mapping settings after generated metadata initializes them. */\nfunction mappingOptions(lazy = false): QueryOptions {\n if (!lazyMappingOptions || !eagerMappingOptions) {\n const temporal = getRuntimeConfig().temporal;\n if (temporal) requireTemporal();\n lazyMappingOptions = {\n rowDecoder: \"object\",\n fetchCount: 0,\n rollbackOnError: false,\n unknownTypesAsString: true,\n temporalTypes: temporal ? [1082, 1083, 1114, 1184] : false,\n fetchAsString: temporal ? [] : [1083],\n };\n // Accept Temporal parameters on both paths, but return strings for raw queries to preserve\n // Joist's node-pg-compatible result types. Parsing through Date would lose microseconds;\n // returning Temporal objects would change the values callers receive when switching drivers.\n eagerMappingOptions = { ...lazyMappingOptions, fetchAsString: temporal ? [1082, 1083, 1114, 1184] : [1083] };\n }\n return lazy ? lazyMappingOptions : eagerMappingOptions;\n}\n\n/** Executes with Joist's value representations without changing the caller's pool configuration. */\nasync function executeNativeQuery(\n client: Pool | Connection,\n sql: string,\n params: readonly unknown[],\n): Promise<DriverQueryResult> {\n return client\n .query(sql, {\n ...mappingOptions(),\n params: params as unknown[],\n })\n .then(toDriverResult);\n}\n\n/** Uses rowsAffected for writes and rows.length for SELECTs, which PostgreJS does not count in rowsAffected. */\nfunction toDriverResult(result: QueryResult): DriverQueryResult {\n const rows = result.rows ?? [];\n return {\n rowCount: result.rowsAffected ?? (result.command === \"SELECT\" ? rows.length : null),\n rows,\n };\n}\n"],"mappings":"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"}
|
|
@@ -2,54 +2,43 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
|
2
2
|
const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
|
|
3
3
|
const require_drivers_binaryParsers = require("./binaryParsers.cjs");
|
|
4
4
|
const require_drivers_patchPgProtocol = require("./patchPgProtocol.cjs");
|
|
5
|
+
const require_drivers_postgresSql = require("./postgresSql.cjs");
|
|
5
6
|
const require_drivers_WireRowData = require("./WireRowData.cjs");
|
|
6
7
|
let joist_core = require("joist-core");
|
|
8
|
+
let node_module = require("node:module");
|
|
7
9
|
let pg = require("pg");
|
|
8
10
|
pg = require_runtime.__toESM(pg, 1);
|
|
9
11
|
let pg_types = require("pg-types");
|
|
10
12
|
let postgres_array = require("postgres-array");
|
|
11
13
|
postgres_array = require_runtime.__toESM(postgres_array, 1);
|
|
12
14
|
//#region src/drivers/PostgresDriver.ts
|
|
13
|
-
/**
|
|
14
|
-
* Implements the `Driver` interface for Postgres.
|
|
15
|
-
*
|
|
16
|
-
* This is the canonical driver implementation and leverages several aspects of
|
|
17
|
-
* Postgres for the best performance, i.e.:
|
|
18
|
-
*
|
|
19
|
-
* - Deferred foreign key constraints are used to allow bulk inserting/updating
|
|
20
|
-
* all entities without any topographic sorting/ordering issues.
|
|
21
|
-
*
|
|
22
|
-
* - Sequences are used to bulk-assign + then bulk-insert all entities, to again
|
|
23
|
-
* avoid issues with ordering issues (cannot bulk insert A w/o knowing the id of B).
|
|
24
|
-
*
|
|
25
|
-
* - We use a pg-specific bulk update syntax.
|
|
26
|
-
*
|
|
27
|
-
* Query pipelining is enabled for clients created after driver construction unless the pool was
|
|
28
|
-
* configured with `pipeline: false`.
|
|
29
|
-
*/
|
|
15
|
+
/** PostgreSQL over node-pg, with optional patched lazy row decoding. */
|
|
30
16
|
var PostgresDriver = class {
|
|
31
17
|
pool;
|
|
18
|
+
#databaseBinaryParsers;
|
|
32
19
|
#idAssigner;
|
|
33
20
|
#preloadPlugin;
|
|
34
|
-
|
|
21
|
+
onQuery;
|
|
35
22
|
lazyRows;
|
|
36
|
-
/**
|
|
23
|
+
/** Its presence is the lazy-read capability signal checked by EntityManager. */
|
|
37
24
|
executeFindRowData;
|
|
38
|
-
#databaseBinaryParsers = void 0;
|
|
39
25
|
constructor(pool, opts) {
|
|
40
26
|
this.pool = pool;
|
|
41
|
-
|
|
42
|
-
this.#idAssigner = opts?.idAssigner ?? new joist_core.SequenceIdAssigner(async (sql) => {
|
|
43
|
-
this.#onQuery?.(sql);
|
|
44
|
-
return (await pool.query(sql)).rows;
|
|
45
|
-
});
|
|
27
|
+
this.onQuery = opts?.onQuery;
|
|
46
28
|
this.#preloadPlugin = opts?.preloadPlugin;
|
|
47
|
-
this.#
|
|
48
|
-
this.lazyRows =
|
|
29
|
+
this.#idAssigner = opts?.idAssigner ?? new joist_core.SequenceIdAssigner(async (sql) => (await this.query(void 0, sql, [])).rows);
|
|
30
|
+
this.lazyRows = !!opts?.lazyRows && require_drivers_patchPgProtocol.ensureLazyDataRows();
|
|
31
|
+
this.executeFindRowData = this.lazyRows ? (em, parsed, settings) => this.findRowData(em, parsed, settings) : void 0;
|
|
32
|
+
pool.options.pipeline ??= true;
|
|
49
33
|
if (opts?.lazyRows && !this.lazyRows) console.warn("joist-orm: lazyRows was requested, but patching pg-protocol failed; using classic rows.");
|
|
50
|
-
this.executeFindRowData = this.lazyRows ? (em, parsed, settings) => this.#executeFindRowData(em, parsed, settings) : void 0;
|
|
51
34
|
setupLatestPgTypes((0, joist_core.getRuntimeConfig)().temporal);
|
|
52
35
|
}
|
|
36
|
+
/** Uses the transaction's socket when a transaction is active. */
|
|
37
|
+
query(txn, sql, bindings) {
|
|
38
|
+
this.onQuery?.(sql);
|
|
39
|
+
return (txn ?? this.pool).query(sql, bindings);
|
|
40
|
+
}
|
|
41
|
+
/** Executes an entity find with the EntityManager's default limit. */
|
|
53
42
|
async executeFind(em, parsed, settings) {
|
|
54
43
|
const { sql, bindings } = (0, joist_core.buildRawQuery)(parsed, {
|
|
55
44
|
limit: em.entityLimit,
|
|
@@ -57,7 +46,29 @@ var PostgresDriver = class {
|
|
|
57
46
|
});
|
|
58
47
|
return (await this.executeQuery(em, sql, bindings)).rows;
|
|
59
48
|
}
|
|
60
|
-
|
|
49
|
+
/** Returns native command counts and rows, including null counts for DDL. */
|
|
50
|
+
async executeQuery(em, sql, bindings) {
|
|
51
|
+
const { rowCount, rows } = await this.query(em.txn, require_drivers_postgresSql.toPgParams(sql), bindings);
|
|
52
|
+
return {
|
|
53
|
+
rowCount,
|
|
54
|
+
rows
|
|
55
|
+
};
|
|
56
|
+
}
|
|
57
|
+
/** Assigns identifiers with the configured strategy before dependent writes. */
|
|
58
|
+
async assignNewIds(_, todos) {
|
|
59
|
+
await this.#idAssigner.assignNewIds(todos);
|
|
60
|
+
}
|
|
61
|
+
/** Flushes PostgreSQL operations on the active node-pg transaction. */
|
|
62
|
+
async flush(em, entityTodos, joinRows) {
|
|
63
|
+
const txn = em.txn ?? (0, joist_core.fail)("Expected EntityManager.txn to be set");
|
|
64
|
+
await this.#idAssigner.assignNewIds(entityTodos);
|
|
65
|
+
await require_drivers_postgresSql.flushPostgres((sql, bindings) => this.query(txn, sql, bindings), entityTodos, joinRows);
|
|
66
|
+
}
|
|
67
|
+
get defaultPlugins() {
|
|
68
|
+
return { preloadPlugin: this.#preloadPlugin };
|
|
69
|
+
}
|
|
70
|
+
/** Decodes immutable pg-protocol rows, falling back only for known unsupported clients. */
|
|
71
|
+
async findRowData(em, parsed, settings) {
|
|
61
72
|
await (this.#databaseBinaryParsers ??= require_drivers_binaryParsers.registerDatabaseBinaryParsers(this.pool).catch((err) => {
|
|
62
73
|
this.#databaseBinaryParsers = void 0;
|
|
63
74
|
throw err;
|
|
@@ -66,44 +77,39 @@ var PostgresDriver = class {
|
|
|
66
77
|
limit: em.entityLimit,
|
|
67
78
|
...settings
|
|
68
79
|
});
|
|
69
|
-
const pgSql = toPgParams(sql);
|
|
70
|
-
this
|
|
71
|
-
const
|
|
72
|
-
const client =
|
|
80
|
+
const pgSql = require_drivers_postgresSql.toPgParams(sql);
|
|
81
|
+
this.onQuery?.(pgSql);
|
|
82
|
+
const txn = em.txn;
|
|
83
|
+
const client = txn ?? await this.pool.connect();
|
|
73
84
|
try {
|
|
74
|
-
if (!
|
|
85
|
+
if (!isRowDataCapableClient(client)) {
|
|
75
86
|
warnUnsupportedClientOnce();
|
|
76
87
|
return new joist_core.PojoRowData((await client.query(pgSql, bindings)).rows);
|
|
77
88
|
}
|
|
78
|
-
return await
|
|
89
|
+
return await executeRowDataQuery(client, pgSql, bindings);
|
|
79
90
|
} finally {
|
|
80
|
-
if (!
|
|
91
|
+
if (!txn) client.release();
|
|
81
92
|
}
|
|
82
93
|
}
|
|
83
|
-
/**
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
return {
|
|
89
|
-
rowCount,
|
|
90
|
-
rows
|
|
91
|
-
};
|
|
92
|
-
}
|
|
94
|
+
/**
|
|
95
|
+
* Runs hooks and SQL on one checked-out native pg client.
|
|
96
|
+
*
|
|
97
|
+
* Nested calls reuse the active transaction rather than starting a second one.
|
|
98
|
+
*/
|
|
93
99
|
async transaction(em, fn) {
|
|
94
100
|
if (em.txn) return fn(em.txn);
|
|
95
101
|
const client = await this.pool.connect();
|
|
96
102
|
let result;
|
|
97
103
|
try {
|
|
98
104
|
await (0, joist_core.driverBeforeBegin)(em, client);
|
|
99
|
-
this
|
|
105
|
+
this.onQuery?.("BEGIN;");
|
|
100
106
|
await client.query("BEGIN");
|
|
101
107
|
em.txn = client;
|
|
102
108
|
try {
|
|
103
109
|
await (0, joist_core.driverAfterBegin)(em, client);
|
|
104
110
|
result = await fn(client);
|
|
105
111
|
await (0, joist_core.driverBeforeCommit)(em, client);
|
|
106
|
-
this
|
|
112
|
+
this.onQuery?.("COMMIT;");
|
|
107
113
|
await client.query("COMMIT");
|
|
108
114
|
} catch (e) {
|
|
109
115
|
await client.query("ROLLBACK");
|
|
@@ -117,155 +123,21 @@ var PostgresDriver = class {
|
|
|
117
123
|
}
|
|
118
124
|
return result;
|
|
119
125
|
}
|
|
120
|
-
async assignNewIds(_, todos) {
|
|
121
|
-
return this.#idAssigner.assignNewIds(todos);
|
|
122
|
-
}
|
|
123
|
-
async flush(em, entityTodos, joinRows) {
|
|
124
|
-
const client = em.txn ?? (0, joist_core.fail)("Expected EntityManager.txn to be set");
|
|
125
|
-
await this.#idAssigner.assignNewIds(entityTodos);
|
|
126
|
-
const ops = (0, joist_core.generateOps)(entityTodos);
|
|
127
|
-
const onQuery = this.#onQuery;
|
|
128
|
-
await Promise.all([
|
|
129
|
-
...ops.inserts.map((op) => batchInsert(client, op, onQuery)),
|
|
130
|
-
...ops.updates.map((op) => batchUpdate(client, op, onQuery)),
|
|
131
|
-
...ops.deletes.map((op) => batchDelete(client, op, onQuery)),
|
|
132
|
-
...Object.entries(joinRows).flatMap(([joinTableName, todo]) => {
|
|
133
|
-
return [m2mBatchInsert(client, joinTableName, todo, onQuery), m2mBatchDelete(client, joinTableName, todo, onQuery)];
|
|
134
|
-
})
|
|
135
|
-
]);
|
|
136
|
-
}
|
|
137
|
-
get defaultPlugins() {
|
|
138
|
-
return { preloadPlugin: this.#preloadPlugin };
|
|
139
|
-
}
|
|
140
|
-
getMaybeInTxnClient(em) {
|
|
141
|
-
return em.txn || this.pool;
|
|
142
|
-
}
|
|
143
126
|
};
|
|
144
|
-
async function batchInsert(client, op, onQuery) {
|
|
145
|
-
const { tableName, columns, columnValues } = op;
|
|
146
|
-
const [cte, bindings] = buildUnnestCte("data", columns, columnValues);
|
|
147
|
-
const pgSql = toPgParams((0, joist_core.cleanSql)(`
|
|
148
|
-
${cte}
|
|
149
|
-
INSERT INTO ${(0, joist_core.kq)(tableName)} (${columns.map((c) => (0, joist_core.kq)(c.columnName)).join(", ")})
|
|
150
|
-
SELECT * FROM data
|
|
151
|
-
`));
|
|
152
|
-
onQuery?.(pgSql);
|
|
153
|
-
return client.query(pgSql, bindings);
|
|
154
|
-
}
|
|
155
|
-
async function batchUpdate(client, op, onQuery) {
|
|
156
|
-
const { tableName, columns, columnValues, updatedAt } = op;
|
|
157
|
-
const [cte, bindings] = buildUnnestCte("data", columns, columnValues);
|
|
158
|
-
const truncateToMills = !(0, joist_core.getRuntimeConfig)().temporal;
|
|
159
|
-
const maybeUpdatedAt = updatedAt && truncateToMills ? ` AND date_trunc('milliseconds', ${(0, joist_core.kqDot)(tableName, updatedAt)}) = data.__original_updated_at` : updatedAt ? ` AND ${(0, joist_core.kqDot)(tableName, updatedAt)} = data.__original_updated_at` : "";
|
|
160
|
-
const sql = `
|
|
161
|
-
${cte}
|
|
162
|
-
UPDATE ${(0, joist_core.kq)(tableName)}
|
|
163
|
-
SET ${columns.filter((c) => c.columnName !== "id" && c.columnName !== "__original_updated_at").map((c) => `${(0, joist_core.kq)(c.columnName)} = data.${(0, joist_core.kq)(c.columnName)}`).join(", ")}
|
|
164
|
-
FROM data
|
|
165
|
-
WHERE ${(0, joist_core.kq)(tableName)}.id = data.id ${maybeUpdatedAt}
|
|
166
|
-
RETURNING ${(0, joist_core.kq)(tableName)}.id
|
|
167
|
-
`;
|
|
168
|
-
const pgSql = toPgParams((0, joist_core.cleanSql)(sql));
|
|
169
|
-
onQuery?.(pgSql);
|
|
170
|
-
const results = (await client.query(pgSql, bindings)).rows;
|
|
171
|
-
const ids = columnValues[0];
|
|
172
|
-
if (results.length !== ids.length) {
|
|
173
|
-
const updated = new Set(results.map((r) => r.id));
|
|
174
|
-
const missing = ids.filter((id) => !updated.has(id));
|
|
175
|
-
throw new Error(`Oplock failure for ${tableName} rows ${missing.join(", ")}`);
|
|
176
|
-
}
|
|
177
|
-
}
|
|
178
|
-
async function batchDelete(client, op, onQuery) {
|
|
179
|
-
const { tableName, ids } = op;
|
|
180
|
-
const pgSql = toPgParams(`DELETE FROM ${(0, joist_core.kq)(tableName)} WHERE id = ANY(?)`);
|
|
181
|
-
onQuery?.(pgSql);
|
|
182
|
-
await client.query(pgSql, [ids]);
|
|
183
|
-
}
|
|
184
|
-
/** Creates a CTE named `tableName` that bulk-injects the `columnValues` into a SQL query. */
|
|
185
|
-
function buildUnnestCte(tableName, columns, columnValues) {
|
|
186
|
-
(0, joist_core.ensureRectangularArraySizes)(columns, columnValues);
|
|
187
|
-
return [`WITH ${tableName} AS (SELECT ${columns.map((c) => {
|
|
188
|
-
if (c.dbType.endsWith("[]")) {
|
|
189
|
-
if (c.isNullableArray) return `unnest_arrays(?::${c.dbType}[], true) as ${(0, joist_core.kq)(c.columnName)}`;
|
|
190
|
-
else return `unnest_arrays(?::${c.dbType}[]) as ${(0, joist_core.kq)(c.columnName)}`;
|
|
191
|
-
} else return `unnest(?::${c.dbType}[]) as ${(0, joist_core.kq)(c.columnName)}`;
|
|
192
|
-
}).join(", ")})`, columnValues];
|
|
193
|
-
}
|
|
194
|
-
async function m2mBatchInsert(client, joinTableName, todo, onQuery) {
|
|
195
|
-
const { m2m, newRows } = todo;
|
|
196
|
-
if (newRows.length === 0) return;
|
|
197
|
-
const col1Values = newRows.map((row) => todo.dbValue(row, m2m.columnName));
|
|
198
|
-
const col2Values = newRows.map((row) => todo.dbValue(row, m2m.otherColumnName));
|
|
199
|
-
if (m2m.hasJoinTableId) {
|
|
200
|
-
const pgSql = toPgParams((0, joist_core.cleanSql)(`
|
|
201
|
-
WITH data AS (SELECT unnest(?::int[]) as ${(0, joist_core.kq)(m2m.columnName)}, unnest(?::int[]) as ${(0, joist_core.kq)(m2m.otherColumnName)})
|
|
202
|
-
INSERT INTO ${(0, joist_core.kq)(joinTableName)} (${(0, joist_core.kq)(m2m.columnName)}, ${(0, joist_core.kq)(m2m.otherColumnName)})
|
|
203
|
-
SELECT * FROM data
|
|
204
|
-
ON CONFLICT (${(0, joist_core.kq)(m2m.columnName)}, ${(0, joist_core.kq)(m2m.otherColumnName)}) DO UPDATE SET id = ${(0, joist_core.kq)(joinTableName)}.id
|
|
205
|
-
RETURNING id;
|
|
206
|
-
`));
|
|
207
|
-
onQuery?.(pgSql);
|
|
208
|
-
const { rows } = await client.query(pgSql, [col1Values, col2Values]);
|
|
209
|
-
for (let i = 0; i < rows.length; i++) {
|
|
210
|
-
newRows[i].id = rows[i].id;
|
|
211
|
-
newRows[i].op = joist_core.JoinRowOperation.Flushed;
|
|
212
|
-
newRows[i].persisted = true;
|
|
213
|
-
}
|
|
214
|
-
} else {
|
|
215
|
-
const pgSql = toPgParams((0, joist_core.cleanSql)(`
|
|
216
|
-
WITH data AS (SELECT unnest(?::int[]) as ${(0, joist_core.kq)(m2m.columnName)}, unnest(?::int[]) as ${(0, joist_core.kq)(m2m.otherColumnName)})
|
|
217
|
-
INSERT INTO ${(0, joist_core.kq)(joinTableName)} (${(0, joist_core.kq)(m2m.columnName)}, ${(0, joist_core.kq)(m2m.otherColumnName)})
|
|
218
|
-
SELECT * FROM data
|
|
219
|
-
ON CONFLICT (${(0, joist_core.kq)(m2m.columnName)}, ${(0, joist_core.kq)(m2m.otherColumnName)}) DO NOTHING;
|
|
220
|
-
`));
|
|
221
|
-
onQuery?.(pgSql);
|
|
222
|
-
await client.query(pgSql, [col1Values, col2Values]);
|
|
223
|
-
for (const row of newRows) {
|
|
224
|
-
row.op = joist_core.JoinRowOperation.Flushed;
|
|
225
|
-
row.persisted = true;
|
|
226
|
-
}
|
|
227
|
-
}
|
|
228
|
-
}
|
|
229
|
-
async function m2mBatchDelete(client, joinTableName, todo, onQuery) {
|
|
230
|
-
const { m2m, deletedRows } = todo;
|
|
231
|
-
if (deletedRows.length === 0) return;
|
|
232
|
-
const [haveIds, noIds] = (0, joist_core.partition)(deletedRows, (r) => {
|
|
233
|
-
return r.id !== void 0 && r.id !== -1;
|
|
234
|
-
});
|
|
235
|
-
if (haveIds.length > 0) {
|
|
236
|
-
const pgSql = toPgParams(`DELETE FROM ${(0, joist_core.kq)(joinTableName)} WHERE id = ANY(?)`);
|
|
237
|
-
onQuery?.(pgSql);
|
|
238
|
-
await client.query(pgSql, [haveIds.map((r) => r.id)]);
|
|
239
|
-
}
|
|
240
|
-
if (noIds.length > 0) {
|
|
241
|
-
const data = noIds.filter((row) => !todo.isNew(row, m2m.columnName) && !todo.isNew(row, m2m.otherColumnName)).map((row) => [todo.dbValue(row, m2m.columnName), todo.dbValue(row, m2m.otherColumnName)]);
|
|
242
|
-
if (data.length > 0) {
|
|
243
|
-
const pgSql = toPgParams(`
|
|
244
|
-
DELETE FROM ${(0, joist_core.kq)(joinTableName)}
|
|
245
|
-
WHERE (${(0, joist_core.kq)(m2m.columnName)}, ${(0, joist_core.kq)(m2m.otherColumnName)}) IN (
|
|
246
|
-
SELECT (data->>0)::int, (data->>1)::int FROM jsonb_array_elements(?) data
|
|
247
|
-
)`);
|
|
248
|
-
onQuery?.(pgSql);
|
|
249
|
-
await client.query(pgSql, [JSON.stringify(data)]);
|
|
250
|
-
}
|
|
251
|
-
}
|
|
252
|
-
deletedRows.forEach((row) => {
|
|
253
|
-
row.id = void 0;
|
|
254
|
-
row.persisted = false;
|
|
255
|
-
row.op = joist_core.JoinRowOperation.Flushed;
|
|
256
|
-
});
|
|
257
|
-
}
|
|
258
127
|
/**
|
|
259
128
|
* Configures the `pg` driver with the best type parsers.
|
|
260
129
|
*
|
|
261
130
|
* In particular, pg's default `TIMESTAMPTZ` parser is very inefficient, and even just
|
|
262
|
-
* pulling in the latest `pg-types` and installing the fixed parser makes a
|
|
263
|
-
* difference.
|
|
131
|
+
* pulling in the latest `pg-types` and installing the fixed parser makes a noticeable difference.
|
|
264
132
|
*/
|
|
265
133
|
function setupLatestPgTypes(temporal) {
|
|
266
134
|
if (temporal) {
|
|
267
|
-
|
|
268
|
-
|
|
135
|
+
function noop(s) {
|
|
136
|
+
return s;
|
|
137
|
+
}
|
|
138
|
+
function noopArray(s) {
|
|
139
|
+
return postgres_array.default.parse(s, noop);
|
|
140
|
+
}
|
|
269
141
|
const { TIMESTAMP, TIMESTAMPTZ, DATE } = pg.default.types.builtins;
|
|
270
142
|
pg.default.types.setTypeParser(DATE, noop);
|
|
271
143
|
pg.default.types.setTypeParser(TIMESTAMP, noop);
|
|
@@ -276,16 +148,111 @@ function setupLatestPgTypes(temporal) {
|
|
|
276
148
|
require_drivers_binaryParsers.registerTemporalBinaryParsers();
|
|
277
149
|
} else pg.default.types.setTypeParser(pg.default.types.builtins.TIMESTAMPTZ, (0, pg_types.getTypeParser)(pg_types.builtins.TIMESTAMPTZ));
|
|
278
150
|
}
|
|
279
|
-
|
|
151
|
+
let warnedUnsupportedClient = false;
|
|
152
|
+
const PgQuery = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("pg/lib/query");
|
|
153
|
+
const BINARY_BY_DEFAULT = process.env.JOIST_LAZY_BINARY !== "0";
|
|
154
|
+
/** A pg Query that diverts DataRows into a {@link WireRowData} instead of a `Result`. */
|
|
155
|
+
var RowDataQuery = class extends PgQuery {
|
|
156
|
+
#wire = new require_drivers_WireRowData.WireRowData();
|
|
157
|
+
constructor(config, callback) {
|
|
158
|
+
super(config, void 0, callback);
|
|
159
|
+
}
|
|
160
|
+
/**
|
|
161
|
+
* The query's result rows, i.e. once our callback has fired.
|
|
162
|
+
*
|
|
163
|
+
* If a small-result materialization threshold ever seems attractive, this is where it would
|
|
164
|
+
* go — but see the "Small results deliberately stay lazy" note on WireRowData: lazy
|
|
165
|
+
* won the measured comparison at every row count for sparse access, so no threshold exists.
|
|
166
|
+
*/
|
|
167
|
+
get rowData() {
|
|
168
|
+
return this.#wire;
|
|
169
|
+
}
|
|
170
|
+
handleRowDescription(msg) {
|
|
171
|
+
if (this._canceledDueToError) return;
|
|
172
|
+
try {
|
|
173
|
+
super.handleRowDescription(msg);
|
|
174
|
+
const types = this._result?._types;
|
|
175
|
+
this.#wire.setColumnDecoders(pgColumnDecoders(msg.fields, types && ((oid) => types.getTypeParser(oid, "text"))));
|
|
176
|
+
} catch (err) {
|
|
177
|
+
this._canceledDueToError = err;
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
handleDataRow(msg) {
|
|
181
|
+
if (this._canceledDueToError) return;
|
|
182
|
+
try {
|
|
183
|
+
if (msg.bytes === void 0) throw new Error("joist-orm: lazyRows is enabled, but this connection's pg-protocol emits classic DataRows (likely a duplicate pg install); fix the install or disable lazyRows.");
|
|
184
|
+
this.#wire.addRow(msg.bytes, msg.offset, msg.length - 4);
|
|
185
|
+
} catch (err) {
|
|
186
|
+
this._canceledDueToError = err;
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
};
|
|
190
|
+
/**
|
|
191
|
+
* Executes `sql` on an already-checked-out client, returning a {@link RowData} instead of
|
|
192
|
+
* materialized POJO rows.
|
|
193
|
+
*
|
|
194
|
+
* Uses a `pg` Query subclass that records each DataRow's raw payload bytes into the result
|
|
195
|
+
* (via the lazy DataRow message from `patchPgProtocol`) and never materializes per-cell
|
|
196
|
+
* strings or per-row objects. If the client's connection turns out to use an unpatched
|
|
197
|
+
* pg-protocol copy (i.e. the app's pool was built from a different `pg` install than the one
|
|
198
|
+
* joist-orm patched), the query fails with a descriptive error — a misconfiguration any CI
|
|
199
|
+
* build/smoketest will surface immediately, so we fail loudly rather than silently degrade.
|
|
200
|
+
* The rows already streamed are discarded; the connection itself stays usable.
|
|
201
|
+
*
|
|
202
|
+
* By default the query requests binary result format via the extended protocol.
|
|
203
|
+
* Pass `binary: false` for classic text-format results, or set `JOIST_LAZY_BINARY=0`
|
|
204
|
+
* for A/B benchmarking or as an escape hatch.
|
|
205
|
+
*/
|
|
206
|
+
function executeRowDataQuery(client, sql, bindings, opts) {
|
|
207
|
+
const binary = opts?.binary ?? BINARY_BY_DEFAULT;
|
|
208
|
+
return new Promise((resolve, reject) => {
|
|
209
|
+
const query = new RowDataQuery(binary ? {
|
|
210
|
+
text: sql,
|
|
211
|
+
values: bindings,
|
|
212
|
+
binary: true,
|
|
213
|
+
queryMode: "extended"
|
|
214
|
+
} : {
|
|
215
|
+
text: sql,
|
|
216
|
+
values: bindings
|
|
217
|
+
}, (err) => {
|
|
218
|
+
if (err) reject(err);
|
|
219
|
+
else resolve(query.rowData);
|
|
220
|
+
});
|
|
221
|
+
client.query(query);
|
|
222
|
+
});
|
|
223
|
+
}
|
|
224
|
+
/** Returns whether `client` supports the lazy row-data query path, before submitting anything. */
|
|
225
|
+
function isRowDataCapableClient(client) {
|
|
226
|
+
return typeof client === "object" && client !== null && typeof client.query === "function" && client.connection !== void 0 && client.native === void 0;
|
|
227
|
+
}
|
|
280
228
|
/**
|
|
281
|
-
*
|
|
229
|
+
* Resolves each column's decoder from the query's RowDescription.
|
|
282
230
|
*
|
|
283
|
-
*
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
231
|
+
* Binary-format fields decode through Joist's own binary registry only (see
|
|
232
|
+
* `setBinaryTypeParser`) — `pg.types`/`TypeOverrides` are never consulted, and a column whose
|
|
233
|
+
* oid has no registered binary parser fails the query here, before any rows arrive, rather
|
|
234
|
+
* than guessing at a lossy decoding. Text-format fields (the `binary: false` escape hatch)
|
|
235
|
+
* decode by utf8-slicing the cell into the active text parser, resolved via `getTypeParser`
|
|
236
|
+
* (i.e. the pool/client `TypeOverrides` chain) or the global registry.
|
|
237
|
+
*/
|
|
238
|
+
function pgColumnDecoders(fields, getTypeParser) {
|
|
239
|
+
return fields.map((field) => {
|
|
240
|
+
const { name, dataTypeID, format } = field;
|
|
241
|
+
let decode;
|
|
242
|
+
if (format === "binary") {
|
|
243
|
+
decode = require_drivers_binaryParsers.getBinaryTypeParser(dataTypeID);
|
|
244
|
+
if (decode === void 0) throw new Error(`joist-orm: no binary type parser registered for oid ${dataTypeID} (column "${name}"); register one with setBinaryTypeParser (i.e. binaryTextParser for text-like types)`);
|
|
245
|
+
} else decode = textCellDecoder(getTypeParser?.(dataTypeID) ?? pg.default.types.getTypeParser(dataTypeID, "text"));
|
|
246
|
+
return {
|
|
247
|
+
name,
|
|
248
|
+
decode
|
|
249
|
+
};
|
|
250
|
+
});
|
|
251
|
+
}
|
|
252
|
+
/** Builds a text-format cell decoder: utf8-slice the cell bytes into the active text parser. */
|
|
253
|
+
function textCellDecoder(parse) {
|
|
254
|
+
return (chunk, start, length) => parse(chunk.toString("utf8", start, start + length));
|
|
287
255
|
}
|
|
288
|
-
let warnedUnsupportedClient = false;
|
|
289
256
|
/** Warns once when lazyRows degrades to classic rows for an unsupported client, i.e. pg-native. */
|
|
290
257
|
function warnUnsupportedClientOnce() {
|
|
291
258
|
if (warnedUnsupportedClient) return;
|
|
@@ -294,6 +261,8 @@ function warnUnsupportedClientOnce() {
|
|
|
294
261
|
}
|
|
295
262
|
//#endregion
|
|
296
263
|
exports.PostgresDriver = PostgresDriver;
|
|
264
|
+
exports.executeRowDataQuery = executeRowDataQuery;
|
|
265
|
+
exports.pgColumnDecoders = pgColumnDecoders;
|
|
297
266
|
exports.setupLatestPgTypes = setupLatestPgTypes;
|
|
298
267
|
|
|
299
268
|
//# sourceMappingURL=PostgresDriver.cjs.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"PostgresDriver.cjs","names":["#idAssigner","#preloadPlugin","#onQuery","SequenceIdAssigner","ensureLazyDataRows","#executeFindRowData","getRuntimeConfig","buildRawQuery","#databaseBinaryParsers","registerDatabaseBinaryParsers","isRowDataCapableClient","PojoRowData","executeRowDataQuery","driverBeforeBegin","driverAfterBegin","driverBeforeCommit","driverAfterCommit","fail","generateOps","cleanSql","kq","kqDot","JoinRowOperation","partition","array","getTypeParser","builtins"],"sources":["../../src/drivers/PostgresDriver.ts"],"sourcesContent":["import {\n type DeleteOp,\n type Driver,\n type DriverQueryResult,\n type EntityManager,\n type IdAssigner,\n type InsertOp,\n JoinRowOperation,\n type JoinRowTodo,\n type OpColumn,\n type ParsedFindQuery,\n PojoRowData,\n type PreloadPlugin,\n type RowData,\n type RuntimeConfig,\n SequenceIdAssigner,\n type Todo,\n type UpdateOp,\n buildRawQuery,\n cleanSql,\n driverAfterBegin,\n driverAfterCommit,\n driverBeforeBegin,\n driverBeforeCommit,\n ensureRectangularArraySizes,\n fail,\n generateOps,\n getRuntimeConfig,\n kq,\n kqDot,\n partition,\n} from \"joist-core\";\nimport pg from \"pg\";\nimport { builtins, getTypeParser } from \"pg-types\";\nimport array from \"postgres-array\";\n\nimport { registerDatabaseBinaryParsers, registerTemporalBinaryParsers } from \"./binaryParsers.ts\";\nimport { ensureLazyDataRows } from \"./patchPgProtocol.ts\";\nimport { executeRowDataQuery, isRowDataCapableClient } from \"./WireRowData.ts\";\n\nexport interface PostgresDriverOpts {\n idAssigner?: IdAssigner;\n /** Sets a default `PreloadPlugin` for any `EntityManager` that uses this driver. */\n preloadPlugin?: PreloadPlugin;\n /** Called after each query is executed, useful for testing/debugging. */\n onQuery?: (sql: string) => void;\n /**\n * Experimental: keeps entity find results as raw wire bytes and decodes each row/column cell\n * lazily on field access, instead of eagerly materializing POJO rows.\n *\n * Applies to unpaginated `em.find`, `em.load`, and o2m/o2o/recursive relation loads against\n * the pure-JS pg client. Other loaders deliberately stay classic: paginated finds (small\n * pages, measured neutral), m2m join-table rows (narrow + fully read, where materialized rows\n * measured faster, and `JoinRows` owns/mutates them), lazy columns, and id/count loaders.\n *\n * Lazy queries also request *binary* result format (prototype), decoding int/bool/float/text\n * cells — and, via the fast paths `setupLatestPgTypes` registers, date/timestamptz cells —\n * wire-bytes -> value with no intermediate strings; numeric/exotic cells render to pg's\n * canonical text and reuse the active text parsers for parity. `JOIST_LAZY_BINARY=0`\n * reverts lazy queries to text-format results. It\n * uses classic rows when the choice is knowable up-front (patching pg-protocol failed, or the\n * client is unsupported, i.e. pg-native — both warn once). If a connection turns out\n * mid-query to use an unpatched pg-protocol copy (a duplicate `pg` install), the query fails\n * with a descriptive error — a misconfiguration CI builds/smoketests will catch immediately.\n * Note deferred decoding also defers custom-parser errors from `await em.find` to first field\n * access. See JS-ROW-STORE-DESIGN.md.\n */\n lazyRows?: boolean;\n}\n\n/**\n * Provides a callback for tests/debugging.\n *\n * We used to get this for-free from knex, but node-pg does not have a `query` event.\n */\ntype OnQuery = ((sql: string) => void) | undefined;\n\n/**\n * Implements the `Driver` interface for Postgres.\n *\n * This is the canonical driver implementation and leverages several aspects of\n * Postgres for the best performance, i.e.:\n *\n * - Deferred foreign key constraints are used to allow bulk inserting/updating\n * all entities without any topographic sorting/ordering issues.\n *\n * - Sequences are used to bulk-assign + then bulk-insert all entities, to again\n * avoid issues with ordering issues (cannot bulk insert A w/o knowing the id of B).\n *\n * - We use a pg-specific bulk update syntax.\n *\n * Query pipelining is enabled for clients created after driver construction unless the pool was\n * configured with `pipeline: false`.\n */\nexport class PostgresDriver implements Driver<pg.PoolClient> {\n readonly #idAssigner: IdAssigner;\n readonly #preloadPlugin: PreloadPlugin | undefined;\n readonly #onQuery: OnQuery;\n readonly lazyRows: boolean;\n /** Defined only when `lazyRows` is enabled; its presence is the capability signal the EM checks. */\n readonly executeFindRowData: Driver[\"executeFindRowData\"];\n #databaseBinaryParsers: Promise<void> | undefined = undefined;\n\n constructor(\n readonly pool: pg.Pool,\n opts?: PostgresDriverOpts,\n ) {\n // Set the option before pg creates clients, but preserve an explicit consumer opt-out.\n pool.options.pipeline ??= true;\n this.#idAssigner =\n opts?.idAssigner ??\n new SequenceIdAssigner(async (sql: string) => {\n this.#onQuery?.(sql);\n return (await pool.query(sql)).rows;\n });\n this.#preloadPlugin = opts?.preloadPlugin;\n this.#onQuery = opts?.onQuery;\n // Lazy rows require pg-protocol to emit lazy DataRows, which we patch in at runtime; if the\n // patch cannot be applied/verified (i.e. future pg-protocol internals changed), stay classic\n this.lazyRows = (opts?.lazyRows ?? false) && ensureLazyDataRows();\n if (opts?.lazyRows && !this.lazyRows) {\n console.warn(\"joist-orm: lazyRows was requested, but patching pg-protocol failed; using classic rows.\");\n }\n this.executeFindRowData = this.lazyRows\n ? (em, parsed, settings) => this.#executeFindRowData(em, parsed, settings)\n : undefined;\n setupLatestPgTypes(getRuntimeConfig().temporal);\n }\n\n async executeFind(\n em: EntityManager,\n parsed: ParsedFindQuery,\n settings: { limit?: number; offset?: number },\n ): Promise<any[]> {\n const { sql, bindings } = buildRawQuery(parsed, { limit: em.entityLimit, ...settings });\n return (await this.executeQuery(em, sql, bindings)).rows;\n }\n\n async #executeFindRowData(\n em: EntityManager,\n parsed: ParsedFindQuery,\n settings: { limit?: number; offset?: number },\n ): Promise<RowData> {\n // Auto-register binary parsers for the db's dynamic-oid text-likes (native enums, citext)\n // once, before our first lazy query; on failure, reset so the next query retries\n await (this.#databaseBinaryParsers ??= registerDatabaseBinaryParsers(this.pool).catch((err) => {\n this.#databaseBinaryParsers = undefined;\n throw err;\n }));\n const { sql, bindings } = buildRawQuery(parsed, { limit: em.entityLimit, ...settings });\n const pgSql = toPgParams(sql);\n this.#onQuery?.(pgSql);\n // Centralize client checkout here (pg-pool rejects Submittables in pool.query), and decide\n // classic-vs-lazy *before* submitting anything, i.e. unsupported clients like pg-native fall\n // back to classic rows rather than failing mid-query\n const txnClient = em.txn as pg.PoolClient | undefined;\n const client = txnClient ?? (await this.pool.connect());\n try {\n if (!isRowDataCapableClient(client)) {\n warnUnsupportedClientOnce();\n return new PojoRowData((await (client as pg.PoolClient).query(pgSql, bindings as any[])).rows);\n }\n return await executeRowDataQuery(client, pgSql, bindings);\n } finally {\n if (!txnClient) client.release();\n }\n }\n\n /** Returns PostgreSQL's native command count and raw rows, including null counts for DDL. */\n async executeQuery(em: EntityManager, sql: string, bindings: readonly any[]): Promise<DriverQueryResult> {\n const pgSql = toPgParams(sql);\n this.#onQuery?.(pgSql);\n const client = this.getMaybeInTxnClient(em);\n const { rowCount, rows } = await client.query(pgSql, bindings as any[]);\n return { rowCount, rows };\n }\n\n async transaction<T>(em: EntityManager, fn: (txn: pg.PoolClient) => Promise<T>): Promise<T> {\n if (em.txn) {\n return fn(em.txn as pg.PoolClient);\n }\n const client = await this.pool.connect();\n let result: T;\n try {\n await driverBeforeBegin(em, client);\n this.#onQuery?.(\"BEGIN;\");\n await client.query(\"BEGIN\");\n em.txn = client;\n try {\n await driverAfterBegin(em, client);\n result = await fn(client);\n await driverBeforeCommit(em, client);\n this.#onQuery?.(\"COMMIT;\");\n await client.query(\"COMMIT\");\n } catch (e) {\n await client.query(\"ROLLBACK\");\n throw e;\n } finally {\n em.txn = undefined;\n }\n await driverAfterCommit(em, client);\n } finally {\n client.release();\n }\n return result;\n }\n\n async assignNewIds(_: EntityManager, todos: Record<string, Todo>): Promise<void> {\n return this.#idAssigner.assignNewIds(todos);\n }\n\n async flush(\n em: EntityManager,\n entityTodos: Record<string, Todo>,\n joinRows: Record<string, JoinRowTodo>,\n ): Promise<void> {\n const client = (em.txn ?? fail(\"Expected EntityManager.txn to be set\")) as pg.PoolClient;\n await this.#idAssigner.assignNewIds(entityTodos);\n const ops = generateOps(entityTodos);\n const onQuery = this.#onQuery;\n // Do INSERTs+UPDATEs first so that we avoid DELETE cascades invalidating oplocks\n // See https://github.com/joist-orm/joist-orm/issues/591\n await Promise.all([\n ...ops.inserts.map((op) => batchInsert(client, op, onQuery)),\n ...ops.updates.map((op) => batchUpdate(client, op, onQuery)),\n ...ops.deletes.map((op) => batchDelete(client, op, onQuery)),\n ...Object.entries(joinRows).flatMap(([joinTableName, todo]) => {\n return [\n m2mBatchInsert(client, joinTableName, todo, onQuery),\n m2mBatchDelete(client, joinTableName, todo, onQuery),\n ];\n }),\n ]);\n }\n\n get defaultPlugins() {\n return { preloadPlugin: this.#preloadPlugin };\n }\n\n private getMaybeInTxnClient(em: EntityManager): pg.PoolClient | pg.Pool {\n return (em.txn as pg.PoolClient) || this.pool;\n }\n}\n\nasync function batchInsert(client: pg.PoolClient, op: InsertOp, onQuery: OnQuery): Promise<unknown> {\n const { tableName, columns, columnValues } = op;\n const [cte, bindings] = buildUnnestCte(\"data\", columns, columnValues);\n const sql = cleanSql(`\n ${cte}\n INSERT INTO ${kq(tableName)} (${columns.map((c) => kq(c.columnName)).join(\", \")})\n SELECT * FROM data\n `);\n const pgSql = toPgParams(sql);\n onQuery?.(pgSql);\n return client.query(pgSql, bindings);\n}\n\nasync function batchUpdate(client: pg.PoolClient, op: UpdateOp, onQuery: OnQuery): Promise<void> {\n const { tableName, columns, columnValues, updatedAt } = op;\n\n const [cte, bindings] = buildUnnestCte(\"data\", columns, columnValues);\n\n // JS Dates only have millisecond-level precision, so we may have dropped/lost accuracy when\n // reading Postgres's microsecond-level `timestamptz` values; using `date_trunc` \"downgrades\"\n // the pg data to match what we have in the JS Date.\n //\n // ...but Temporal's types don't have this flaw.\n const truncateToMills = !getRuntimeConfig().temporal;\n const maybeUpdatedAt =\n updatedAt && truncateToMills\n ? ` AND date_trunc('milliseconds', ${kqDot(tableName, updatedAt)}) = data.__original_updated_at`\n : updatedAt\n ? ` AND ${kqDot(tableName, updatedAt)} = data.__original_updated_at`\n : \"\";\n\n const sql = `\n ${cte}\n UPDATE ${kq(tableName)}\n SET ${columns\n .filter((c) => c.columnName !== \"id\" && c.columnName !== \"__original_updated_at\")\n .map((c) => `${kq(c.columnName)} = data.${kq(c.columnName)}`)\n .join(\", \")}\n FROM data\n WHERE ${kq(tableName)}.id = data.id ${maybeUpdatedAt}\n RETURNING ${kq(tableName)}.id\n `;\n\n const pgSql = toPgParams(cleanSql(sql));\n onQuery?.(pgSql);\n const result = await client.query(pgSql, bindings);\n const results = result.rows;\n\n const ids = columnValues[0]; // assume id is the 1st column\n if (results.length !== ids.length) {\n const updated = new Set(results.map((r: any) => r.id));\n const missing = ids.filter((id) => !updated.has(id));\n throw new Error(`Oplock failure for ${tableName} rows ${missing.join(\", \")}`);\n }\n}\n\nasync function batchDelete(client: pg.PoolClient, op: DeleteOp, onQuery: OnQuery): Promise<void> {\n const { tableName, ids } = op;\n const pgSql = toPgParams(`DELETE FROM ${kq(tableName)} WHERE id = ANY(?)`);\n onQuery?.(pgSql);\n await client.query(pgSql, [ids]);\n}\n\n/** Creates a CTE named `tableName` that bulk-injects the `columnValues` into a SQL query. */\nfunction buildUnnestCte(tableName: string, columns: OpColumn[], columnValues: any[][]): [string, any[][]] {\n ensureRectangularArraySizes(columns, columnValues);\n const selects = columns.map((c) => {\n if (c.dbType.endsWith(\"[]\")) {\n if (c.isNullableArray) {\n return `unnest_arrays(?::${c.dbType}[], true) as ${kq(c.columnName)}`;\n } else {\n return `unnest_arrays(?::${c.dbType}[]) as ${kq(c.columnName)}`;\n }\n } else {\n return `unnest(?::${c.dbType}[]) as ${kq(c.columnName)}`;\n }\n });\n const sql = `WITH ${tableName} AS (SELECT ${selects.join(\", \")})`;\n return [sql, columnValues];\n}\n\nasync function m2mBatchInsert(client: pg.PoolClient, joinTableName: string, todo: JoinRowTodo, onQuery: OnQuery) {\n const { m2m, newRows } = todo;\n if (newRows.length === 0) return;\n const col1Values = newRows.map((row) => todo.dbValue(row, m2m.columnName));\n const col2Values = newRows.map((row) => todo.dbValue(row, m2m.otherColumnName));\n if (m2m.hasJoinTableId) {\n const sql = cleanSql(`\n WITH data AS (SELECT unnest(?::int[]) as ${kq(m2m.columnName)}, unnest(?::int[]) as ${kq(m2m.otherColumnName)})\n INSERT INTO ${kq(joinTableName)} (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)})\n SELECT * FROM data\n ON CONFLICT (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)}) DO UPDATE SET id = ${kq(joinTableName)}.id\n RETURNING id;\n `);\n const pgSql = toPgParams(sql);\n onQuery?.(pgSql);\n const { rows } = await client.query(pgSql, [col1Values, col2Values]);\n for (let i = 0; i < rows.length; i++) {\n newRows[i].id = rows[i].id;\n newRows[i].op = JoinRowOperation.Flushed;\n newRows[i].persisted = true;\n }\n } else {\n // Id-less join tables have no surrogate id to return; the FK pair is the PK, so just\n // insert and let any duplicate be a no-op.\n const sql = cleanSql(`\n WITH data AS (SELECT unnest(?::int[]) as ${kq(m2m.columnName)}, unnest(?::int[]) as ${kq(m2m.otherColumnName)})\n INSERT INTO ${kq(joinTableName)} (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)})\n SELECT * FROM data\n ON CONFLICT (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)}) DO NOTHING;\n `);\n const pgSql = toPgParams(sql);\n onQuery?.(pgSql);\n await client.query(pgSql, [col1Values, col2Values]);\n for (const row of newRows) {\n row.op = JoinRowOperation.Flushed;\n row.persisted = true;\n }\n }\n}\n\nasync function m2mBatchDelete(client: pg.PoolClient, joinTableName: string, todo: JoinRowTodo, onQuery: OnQuery) {\n const { m2m, deletedRows } = todo;\n if (deletedRows.length === 0) return;\n // Rows with a surrogate id are deleted by id; rows without one — id-less tables, or `remove`s\n // done against an unloaded ManyToManyCollection — are deleted by their (col1, col2) composite.\n const [haveIds, noIds] = partition(deletedRows, (r) => {\n // We used to use `id !== -1` as a marker for \"row is/is-not persisted in the db\" -- but when adding support\n // for id-column-less m2m tables, we couldn't use `id === -1` as this marker anymore, so now rely on a dedicated\n // `persisted` key instead.\n //\n // So, ideally, this `id !== -1` could go away _except_ that our internal verisoning plugin leverages this \"m2m rows\n // with an id=-1 delete by their FK values\" to handle our versioned m2m tables. And for now it's easier to\n // keep/restore this `id !== -1` than refactor that.\n return r.id !== undefined && r.id !== -1;\n });\n if (haveIds.length > 0) {\n const pgSql = toPgParams(`DELETE FROM ${kq(joinTableName)} WHERE id = ANY(?)`);\n onQuery?.(pgSql);\n await client.query(pgSql, [haveIds.map((r) => r.id!)]);\n }\n if (noIds.length > 0) {\n const data = noIds\n // Watch for m2m rows that got added-then-removed to entities that were themselves added-then-removed,\n // as the deTagId will be undefined for those, as we're skipping adding them to the database.\n .filter((row) => !todo.isNew(row, m2m.columnName) && !todo.isNew(row, m2m.otherColumnName))\n .map((row) => [todo.dbValue(row, m2m.columnName), todo.dbValue(row, m2m.otherColumnName)] as any);\n if (data.length > 0) {\n const pgSql = toPgParams(`\n DELETE FROM ${kq(joinTableName)}\n WHERE (${kq(m2m.columnName)}, ${kq(m2m.otherColumnName)}) IN (\n SELECT (data->>0)::int, (data->>1)::int FROM jsonb_array_elements(?) data\n )`);\n onQuery?.(pgSql);\n await client.query(pgSql, [JSON.stringify(data)]);\n }\n }\n deletedRows.forEach((row) => {\n row.id = undefined;\n row.persisted = false;\n row.op = JoinRowOperation.Flushed;\n });\n}\n\n/**\n * Configures the `pg` driver with the best type parsers.\n *\n * In particular, pg's default `TIMESTAMPTZ` parser is very inefficient, and even just\n * pulling in the latest `pg-types` and installing the fixed parser makes a noticable\n * difference.\n */\nexport function setupLatestPgTypes(temporal: RuntimeConfig[\"temporal\"]): void {\n if (temporal) {\n // Don't eagerly parse the strings, instead defer to the serde logic. This only governs\n // classic *text* results (knex, pool.query, non-lazy drivers); binary lazy cells construct\n // Temporal values directly, with no strings involved (see registerTemporalBinaryParsers).\n const noop = (s: string) => s;\n const noopArray = (s: string) => array.parse(s, noop);\n\n const { TIMESTAMP, TIMESTAMPTZ, DATE } = pg.types.builtins;\n pg.types.setTypeParser(DATE, noop);\n pg.types.setTypeParser(TIMESTAMP, noop);\n pg.types.setTypeParser(TIMESTAMPTZ, noop);\n\n // Use `as number` b/c the typings of shadowed pg-types from `pg` and `pg-types` top-level don't line up\n pg.types.setTypeParser(1182 as number, noopArray); // date[]\n pg.types.setTypeParser(1115 as number, noopArray); // timestamp[]\n pg.types.setTypeParser(1185 as number, noopArray); // timestamptz[]\n\n registerTemporalBinaryParsers();\n } else {\n pg.types.setTypeParser(pg.types.builtins.TIMESTAMPTZ, getTypeParser(builtins.TIMESTAMPTZ));\n // The binary registry's date/timestamp/timestamptz builtins already decode to Dates\n }\n}\n\nconst questionMarks = /(?<!@)\\?/g;\n\n/**\n * Converts our knex-style `?` placeholders to pg-native `$1, $2, ...` numbered parameters.\n *\n * We skipping postgres operators like `@?`. */\nfunction toPgParams(sql: string): string {\n let i = 0;\n return sql.replace(questionMarks, () => `$${++i}`);\n}\n\nlet warnedUnsupportedClient = false;\n\n/** Warns once when lazyRows degrades to classic rows for an unsupported client, i.e. pg-native. */\nfunction warnUnsupportedClientOnce(): void {\n if (warnedUnsupportedClient) return;\n warnedUnsupportedClient = true;\n console.warn(\"joist-orm: lazyRows is enabled, but this client does not support it; using classic rows.\");\n}\n"],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"PostgresDriver.cjs","names":["SequenceIdAssigner","ensureLazyDataRows","getRuntimeConfig","buildRawQuery","toPgParams","fail","flushPostgres","registerDatabaseBinaryParsers","PojoRowData","driverBeforeBegin","driverAfterBegin","driverBeforeCommit","driverAfterCommit","array","getTypeParser","builtins","createRequire","WireRowData","getBinaryTypeParser"],"sources":["../../src/drivers/PostgresDriver.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\nimport {\n type Driver,\n type DriverQueryResult,\n type EntityManager,\n type IdAssigner,\n type JoinRowTodo,\n type ParsedFindQuery,\n PojoRowData,\n type PreloadPlugin,\n type RowData,\n type RuntimeConfig,\n SequenceIdAssigner,\n type Todo,\n buildRawQuery,\n driverAfterBegin,\n driverAfterCommit,\n driverBeforeBegin,\n driverBeforeCommit,\n fail,\n getRuntimeConfig,\n} from \"joist-core\";\nimport pg from \"pg\";\nimport { builtins, getTypeParser } from \"pg-types\";\nimport array from \"postgres-array\";\n\nimport { getBinaryTypeParser, registerDatabaseBinaryParsers, registerTemporalBinaryParsers } from \"./binaryParsers.ts\";\nimport { ensureLazyDataRows } from \"./patchPgProtocol.ts\";\nimport { flushPostgres, toPgParams } from \"./postgresSql.ts\";\nimport { WireRowData } from \"./WireRowData.ts\";\n\nexport interface PostgresDriverOpts {\n idAssigner?: IdAssigner;\n /** Sets a default `PreloadPlugin` for any `EntityManager` that uses this driver. */\n preloadPlugin?: PreloadPlugin;\n /** Observes SQL before submission; node-pg does not expose a query event. */\n onQuery?: (sql: string) => void;\n /**\n * Keeps entity find results as raw wire bytes and decodes cells on field access. Defaults to false.\n *\n * Applies to em.find, em.load and o2m/o2o/recursive relation loads.\n * Other loaders deliberately stay classic: m2m join-table\n * rows (narrow, fully read and mutated by JoinRows), lazy columns, and id/count loaders.\n *\n * Binary cells use Joist's parser registry; JOIST_LAZY_BINARY=0 requests text results instead.\n * If patching pg-protocol fails or the client is unsupported (i.e. pg-native), we warn and\n * use classic rows. An unpatched duplicate pg-protocol discovered mid-query fails loudly\n * rather than silently degrading. Deferred parsing also defers custom-parser errors from\n * await em.find to field access. See JS-ROW-STORE-DESIGN.md.\n */\n lazyRows?: boolean;\n}\n\n/** PostgreSQL over node-pg, with optional patched lazy row decoding. */\nexport class PostgresDriver implements Driver<pg.PoolClient> {\n #databaseBinaryParsers: Promise<void> | undefined;\n readonly #idAssigner: IdAssigner;\n readonly #preloadPlugin: PreloadPlugin | undefined;\n private readonly onQuery: PostgresDriverOpts[\"onQuery\"];\n readonly lazyRows: boolean;\n /** Its presence is the lazy-read capability signal checked by EntityManager. */\n readonly executeFindRowData: Driver[\"executeFindRowData\"];\n\n constructor(\n readonly pool: pg.Pool,\n opts?: PostgresDriverOpts,\n ) {\n this.onQuery = opts?.onQuery;\n this.#preloadPlugin = opts?.preloadPlugin;\n\n // Sequences assign IDs before bulk insertion, including mutually dependent new entities.\n this.#idAssigner =\n opts?.idAssigner ?? new SequenceIdAssigner(async (sql) => (await this.query(undefined, sql, [])).rows);\n\n this.lazyRows = !!opts?.lazyRows && ensureLazyDataRows();\n this.executeFindRowData = this.lazyRows\n ? (em, parsed, settings) => this.findRowData(em, parsed, settings)\n : undefined;\n\n // Set the option before pg creates clients, but preserve an explicit consumer opt-out.\n pool.options.pipeline ??= true;\n if (opts?.lazyRows && !this.lazyRows) {\n console.warn(\"joist-orm: lazyRows was requested, but patching pg-protocol failed; using classic rows.\");\n }\n setupLatestPgTypes(getRuntimeConfig().temporal);\n }\n\n /** Uses the transaction's socket when a transaction is active. */\n private query(txn: pg.PoolClient | undefined, sql: string, bindings: readonly unknown[]) {\n this.onQuery?.(sql);\n return (txn ?? this.pool).query(sql, bindings as unknown[]);\n }\n\n /** Executes an entity find with the EntityManager's default limit. */\n async executeFind(\n em: EntityManager,\n parsed: ParsedFindQuery,\n settings: { limit?: number; offset?: number },\n ): Promise<any[]> {\n const { sql, bindings } = buildRawQuery(parsed, { limit: em.entityLimit, ...settings });\n return (await this.executeQuery(em, sql, bindings)).rows;\n }\n\n /** Returns native command counts and rows, including null counts for DDL. */\n async executeQuery(em: EntityManager, sql: string, bindings: readonly unknown[]): Promise<DriverQueryResult> {\n const { rowCount, rows } = await this.query(em.txn as pg.PoolClient | undefined, toPgParams(sql), bindings);\n return { rowCount, rows };\n }\n\n /** Assigns identifiers with the configured strategy before dependent writes. */\n async assignNewIds(_: EntityManager, todos: Record<string, Todo>): Promise<void> {\n await this.#idAssigner.assignNewIds(todos);\n }\n\n /** Flushes PostgreSQL operations on the active node-pg transaction. */\n async flush(\n em: EntityManager,\n entityTodos: Record<string, Todo>,\n joinRows: Record<string, JoinRowTodo>,\n ): Promise<void> {\n const txn = (em.txn ?? fail(\"Expected EntityManager.txn to be set\")) as pg.PoolClient;\n await this.#idAssigner.assignNewIds(entityTodos);\n await flushPostgres((sql, bindings) => this.query(txn, sql, bindings), entityTodos, joinRows);\n }\n\n get defaultPlugins() {\n return { preloadPlugin: this.#preloadPlugin };\n }\n\n /** Decodes immutable pg-protocol rows, falling back only for known unsupported clients. */\n private async findRowData(\n em: EntityManager,\n parsed: ParsedFindQuery,\n settings: { limit?: number; offset?: number },\n ): Promise<RowData> {\n // Auto-register binary parsers for the db's dynamic-oid text-likes (native enums, citext)\n // once, before our first lazy query; on failure, reset so the next query retries.\n await (this.#databaseBinaryParsers ??= registerDatabaseBinaryParsers(this.pool).catch((err) => {\n this.#databaseBinaryParsers = undefined;\n throw err;\n }));\n const { sql, bindings } = buildRawQuery(parsed, { limit: em.entityLimit, ...settings });\n const pgSql = toPgParams(sql);\n this.onQuery?.(pgSql);\n // pg-pool rejects Submittables in pool.query; choose classic-vs-lazy before submitting.\n const txn = em.txn as pg.PoolClient | undefined;\n const client = txn ?? (await this.pool.connect());\n try {\n if (!isRowDataCapableClient(client)) {\n warnUnsupportedClientOnce();\n return new PojoRowData((await (client as pg.PoolClient).query(pgSql, bindings as unknown[])).rows);\n }\n return await executeRowDataQuery(client, pgSql, bindings);\n } finally {\n if (!txn) client.release();\n }\n }\n\n /**\n * Runs hooks and SQL on one checked-out native pg client.\n *\n * Nested calls reuse the active transaction rather than starting a second one.\n */\n async transaction<T>(em: EntityManager, fn: (txn: pg.PoolClient) => Promise<T>): Promise<T> {\n if (em.txn) return fn(em.txn as pg.PoolClient);\n const client = await this.pool.connect();\n let result: T;\n try {\n await driverBeforeBegin(em, client);\n this.onQuery?.(\"BEGIN;\");\n await client.query(\"BEGIN\");\n em.txn = client;\n try {\n await driverAfterBegin(em, client);\n result = await fn(client);\n await driverBeforeCommit(em, client);\n this.onQuery?.(\"COMMIT;\");\n await client.query(\"COMMIT\");\n } catch (e) {\n await client.query(\"ROLLBACK\");\n throw e;\n } finally {\n em.txn = undefined;\n }\n await driverAfterCommit(em, client);\n } finally {\n client.release();\n }\n return result;\n }\n}\n\n/**\n * Configures the `pg` driver with the best type parsers.\n *\n * In particular, pg's default `TIMESTAMPTZ` parser is very inefficient, and even just\n * pulling in the latest `pg-types` and installing the fixed parser makes a noticeable difference.\n */\nexport function setupLatestPgTypes(temporal: RuntimeConfig[\"temporal\"]): void {\n if (temporal) {\n // Don't eagerly parse the strings, instead defer to the serde logic. This only governs\n // classic *text* results (knex, pool.query, non-lazy drivers); binary lazy cells construct\n // Temporal values directly, with no strings involved (see registerTemporalBinaryParsers).\n function noop(s: string) {\n return s;\n }\n function noopArray(s: string) {\n return array.parse(s, noop);\n }\n const { TIMESTAMP, TIMESTAMPTZ, DATE } = pg.types.builtins;\n pg.types.setTypeParser(DATE, noop);\n pg.types.setTypeParser(TIMESTAMP, noop);\n pg.types.setTypeParser(TIMESTAMPTZ, noop);\n // Use `as number` b/c the typings of shadowed pg-types from `pg` and `pg-types` top-level don't line up.\n pg.types.setTypeParser(1182 as number, noopArray); // date[]\n pg.types.setTypeParser(1115 as number, noopArray); // timestamp[]\n pg.types.setTypeParser(1185 as number, noopArray); // timestamptz[]\n registerTemporalBinaryParsers();\n } else {\n pg.types.setTypeParser(pg.types.builtins.TIMESTAMPTZ, getTypeParser(builtins.TIMESTAMPTZ));\n // The binary registry's date/timestamp/timestamptz builtins already decode to Dates.\n }\n}\n\nlet warnedUnsupportedClient = false;\n\nconst runtimeRequire = createRequire(import.meta.url);\n\n// pg's internal-but-exported Query class; subclassing it reuses its extended-protocol\n// submit/bind logic while letting us intercept row handling (the same seam pg-cursor uses).\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst PgQuery: any = runtimeRequire(\"pg/lib/query\");\n\n// The prototype escape hatch for binary results, i.e. for A/B benchmarking; read once at load.\nconst BINARY_BY_DEFAULT = process.env.JOIST_LAZY_BINARY !== \"0\";\n\n/** A pg Query that diverts DataRows into a {@link WireRowData} instead of a `Result`. */\nclass RowDataQuery extends PgQuery {\n #wire = new WireRowData();\n\n constructor(\n config: { text: string; values: any[]; binary?: boolean; queryMode?: string },\n callback: (err: unknown) => void,\n ) {\n super(config, undefined, callback);\n }\n\n /**\n * The query's result rows, i.e. once our callback has fired.\n *\n * If a small-result materialization threshold ever seems attractive, this is where it would\n * go — but see the \"Small results deliberately stay lazy\" note on WireRowData: lazy\n * won the measured comparison at every row count for sparse access, so no threshold exists.\n */\n get rowData(): RowData {\n return this.#wire;\n }\n\n handleRowDescription(msg: any): void {\n if (this._canceledDueToError) return;\n try {\n super.handleRowDescription(msg);\n // Resolve active text parsers through the client's TypeOverrides chain (client.js\n // injects `_types` at submit time). Binary fields use Joist's binary registry instead\n // of pg's broken binary parsing of UTF-8 strings.\n const types = this._result?._types;\n this.#wire.setColumnDecoders(\n pgColumnDecoders(msg.fields, types && ((oid: number) => types.getTypeParser(oid, \"text\"))),\n );\n } catch (err) {\n // Mirror pg's Query error containment: record + reject at ReadyForQuery, keeping the\n // connection's protocol state intact.\n this._canceledDueToError = err;\n }\n }\n\n handleDataRow(msg: any): void {\n if (this._canceledDueToError) return;\n try {\n if (msg.bytes === undefined) {\n // This connection's pg-protocol copy is unpatched (i.e. the pool came from a different\n // `pg` install than the one joist-orm patched), so lazyRows cannot work — fail loudly\n // rather than silently degrade; any CI build/smoketest will surface this immediately.\n throw new Error(\n \"joist-orm: lazyRows is enabled, but this connection's pg-protocol emits classic\" +\n \" DataRows (likely a duplicate pg install); fix the install or disable lazyRows.\",\n );\n }\n // `msg.length` includes the int32 length field itself, so the payload is `length - 4`;\n // our patched message carries the real length from `handlePacket`'s argument.\n this.#wire.addRow(msg.bytes, msg.offset, msg.length - 4);\n } catch (err) {\n this._canceledDueToError = err;\n }\n }\n}\n\n/**\n * Executes `sql` on an already-checked-out client, returning a {@link RowData} instead of\n * materialized POJO rows.\n *\n * Uses a `pg` Query subclass that records each DataRow's raw payload bytes into the result\n * (via the lazy DataRow message from `patchPgProtocol`) and never materializes per-cell\n * strings or per-row objects. If the client's connection turns out to use an unpatched\n * pg-protocol copy (i.e. the app's pool was built from a different `pg` install than the one\n * joist-orm patched), the query fails with a descriptive error — a misconfiguration any CI\n * build/smoketest will surface immediately, so we fail loudly rather than silently degrade.\n * The rows already streamed are discarded; the connection itself stays usable.\n *\n * By default the query requests binary result format via the extended protocol.\n * Pass `binary: false` for classic text-format results, or set `JOIST_LAZY_BINARY=0`\n * for A/B benchmarking or as an escape hatch.\n */\nexport function executeRowDataQuery(\n client: pg.PoolClient,\n sql: string,\n bindings: readonly any[],\n opts?: { binary?: boolean },\n): Promise<RowData> {\n const binary = opts?.binary ?? BINARY_BY_DEFAULT;\n return new Promise((resolve, reject) => {\n const query = new RowDataQuery(\n // Binary results require the extended protocol; `queryMode` forces it for bindings-less queries.\n binary\n ? { text: sql, values: bindings as any[], binary: true, queryMode: \"extended\" }\n : { text: sql, values: bindings as any[] },\n (err: unknown) => {\n if (err) reject(err);\n else resolve(query.rowData);\n },\n );\n client.query(query as any);\n });\n}\n\n/** Returns whether `client` supports the lazy row-data query path, before submitting anything. */\nfunction isRowDataCapableClient(client: unknown): client is pg.PoolClient {\n // Require the pure-JS pg client (pg-native has no `connection` and different query internals).\n return (\n typeof client === \"object\" &&\n client !== null &&\n typeof (client as any).query === \"function\" &&\n (client as any).connection !== undefined &&\n (client as any).native === undefined\n );\n}\n\n/**\n * Resolves each column's decoder from the query's RowDescription.\n *\n * Binary-format fields decode through Joist's own binary registry only (see\n * `setBinaryTypeParser`) — `pg.types`/`TypeOverrides` are never consulted, and a column whose\n * oid has no registered binary parser fails the query here, before any rows arrive, rather\n * than guessing at a lossy decoding. Text-format fields (the `binary: false` escape hatch)\n * decode by utf8-slicing the cell into the active text parser, resolved via `getTypeParser`\n * (i.e. the pool/client `TypeOverrides` chain) or the global registry.\n */\nexport function pgColumnDecoders(\n fields: Array<{ name: string; dataTypeID: number; format?: string }>,\n getTypeParser?: (dataTypeID: number) => (value: any) => any,\n) {\n return fields.map((field) => {\n const { name, dataTypeID, format } = field;\n let decode;\n if (format === \"binary\") {\n decode = getBinaryTypeParser(dataTypeID);\n if (decode === undefined) {\n throw new Error(\n `joist-orm: no binary type parser registered for oid ${dataTypeID} (column \"${name}\");` +\n ` register one with setBinaryTypeParser (i.e. binaryTextParser for text-like types)`,\n );\n }\n } else {\n const parse = getTypeParser?.(dataTypeID) ?? pg.types.getTypeParser(dataTypeID, \"text\");\n decode = textCellDecoder(parse);\n }\n return { name, decode };\n });\n}\n\n/** Builds a text-format cell decoder: utf8-slice the cell bytes into the active text parser. */\nfunction textCellDecoder(parse: (value: any) => any): (chunk: Buffer, start: number, length: number) => any {\n return (chunk, start, length) => parse(chunk.toString(\"utf8\", start, start + length));\n}\n\n/** Warns once when lazyRows degrades to classic rows for an unsupported client, i.e. pg-native. */\nfunction warnUnsupportedClientOnce(): void {\n if (warnedUnsupportedClient) return;\n warnedUnsupportedClient = true;\n console.warn(\"joist-orm: lazyRows is enabled, but this client does not support it; using classic rows.\");\n}\n"],"mappings":"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"}
|