pqb 0.64.0 → 0.65.0

package/dist/node-postgres.mjs

@@ -1,603 +1,129 @@
-import pg, { DatabaseError } from 'pg';
-import { emptyObject, setConnectRetryConfig, wrapAdapterFnWithConnectRetry, noop, returnArg } from 'pqb/internal';
-import { createDbWithAdapter } from 'pqb';
-
-const transactionArgs = {
-  cb: void 0,
-  options: void 0
-};
-const getTransactionArgs = (args) => {
-  if (args[1]) {
-    transactionArgs.options = args[0];
-    transactionArgs.cb = args[1];
-  } else {
-    transactionArgs.cb = args[0];
-  }
-  return transactionArgs;
-};
-const mergeLocals = (locals, options) => options?.locals ? { ...locals, ...options.locals } : locals;
-const getSetLocalsSql = (options) => {
-  if (!options?.locals) return;
-  return Object.entries(options.locals).map(([key, value]) => `SET LOCAL ${key}=${value}`).join("; ");
-};
-const getResetLocalsSql = (parentLocals, options) => {
-  if (!options?.locals) return;
-  return Object.entries(options.locals).reduce((acc, [key, value]) => {
-    if (parentLocals[key] !== value) {
-      acc.push(`SET LOCAL ${key}=${parentLocals[key]}`);
-    }
-    return acc;
-  }, []).join("; ");
-};
-
-const quoteRoleIdentifier = (role) => {
-  return `"${role.replace(/"/g, '""')}"`;
-};
-const buildConfigRestoreExpression = (key, value) => {
-  const escapedKey = key.replace(/'/g, "''");
-  if (value === null || value === void 0) {
-    value = "";
-  }
-  return `set_config('${escapedKey}', '${value.replace(/'/g, "''")}', false) as "${key}"`;
-};
-const sqlSessionContextComputeSetup = (desired) => {
-  if (!desired) return void 0;
-  const role = desired.role;
-  const hasRole = role !== void 0;
-  const { setConfig } = desired;
-  const configKeys = setConfig && Object.keys(setConfig);
-  const hasConfig = configKeys && configKeys.length > 0;
-  if (!hasRole && !hasConfig) return void 0;
-  const result = {};
-  if (hasRole) {
-    result.roleSetupSql = `SET ROLE ${quoteRoleIdentifier(role)}`;
-    result.captureRoleSql = "SELECT current_user";
-  }
-  if (hasConfig && setConfig) {
-    result.captureConfigValues = configKeys;
-    const captureColumns = configKeys.map((key, i) => `current_setting($${i + 1}, true) as "${key}"`).join(", ");
-    result.captureConfigSql = `SELECT ${captureColumns}`;
-    const setColumns = configKeys.map((key) => {
-      const value = setConfig[key];
-      return `set_config('${key.replace(/'/g, "''")}', '${typeof value === "string" ? value.replace(/'/g, "''") : value}', false) as "${key}"`;
-    }).join(", ");
-    result.configSetupSql = `SELECT ${setColumns}`;
-  }
-  return result;
-};
-const sqlSessionContextBuildConfigRestoreBatchSql = (configs) => {
-  const keys = Object.keys(configs);
-  if (keys.length === 0) return void 0;
-  const expressions = keys.map((key) => buildConfigRestoreExpression(key, configs[key])).join(", ");
-  return `SELECT ${expressions}`;
-};
-const sqlSessionContextExecute = async (query, setup, mainQuery, release) => {
-  if (!setup) {
-    return mainQuery();
-  }
-  const captured = {};
-  const {
-    captureRoleSql,
-    roleSetupSql,
-    captureConfigSql,
-    captureConfigValues,
-    configSetupSql
-  } = setup;
-  const setupPromises = [];
-  if (captureRoleSql) {
-    setupPromises.push(
-      query(captureRoleSql).then((res) => {
-        captured.previousRole = res.rows[0]?.[0];
-      })
-    );
-    setupPromises.push(query(roleSetupSql));
-  }
-  if (captureConfigSql && captureConfigValues && configSetupSql) {
-    captured.previousConfigs = {};
-    const previousConfigs = captured.previousConfigs;
-    setupPromises.push(
-      query(captureConfigSql, captureConfigValues).then((res) => {
-        const row = res.rows[0];
-        captureConfigValues.forEach((key, i) => {
-          previousConfigs[key] = row[i];
-        });
-      })
-    );
-    setupPromises.push(query(configSetupSql));
-  }
-  try {
-    await Promise.all(setupPromises);
-    return await mainQuery();
-  } finally {
-    try {
-      const cleanupPromises = [];
-      if (roleSetupSql && captured.previousRole !== void 0) {
-        cleanupPromises.push(
-          query(`SET ROLE ${quoteRoleIdentifier(captured.previousRole)}`)
-        );
-      }
-      if (captured.previousConfigs) {
-        const restoreSql = sqlSessionContextBuildConfigRestoreBatchSql(
-          captured.previousConfigs
-        );
-        if (restoreSql) {
-          cleanupPromises.push(query(restoreSql));
-        }
-      }
-      await Promise.all(cleanupPromises);
-    } finally {
-      if (release) {
-        await release();
-      }
-    }
-  }
-};
-
-const createDb = ({
-  log,
-  ...options
-}) => {
-  return createDbWithAdapter({
-    ...options,
-    log,
-    adapter: new NodePostgresAdapter(options)
-  });
+import pg, { DatabaseError } from "pg";
+import { AdapterClass, noop, returnArg } from "pqb/internal";
+import { createDbWithAdapter } from "pqb";
+const createDb = ({ log, ...options }) => {
+	return createDbWithAdapter({
+		...options,
+		log,
+		adapter: new AdapterClass({
+			driverAdapter: NodePostgresAdapter,
+			config: options
+		})
+	});
 };
 const { types } = pg;
 const defaultTypeParsers = {};
 for (const key in types.builtins) {
-  const id = types.builtins[key];
-  defaultTypeParsers[id] = types.getTypeParser(id);
+	const id = types.builtins[key];
+	defaultTypeParsers[id] = types.getTypeParser(id);
 }
 [
-  types.builtins.DATE,
-  types.builtins.TIMESTAMP,
-  types.builtins.TIMESTAMPTZ,
-  types.builtins.CIRCLE,
-  types.builtins.BYTEA
+	types.builtins.DATE,
+	types.builtins.TIMESTAMP,
+	types.builtins.TIMESTAMPTZ,
+	types.builtins.CIRCLE,
+	types.builtins.BYTEA
 ].forEach((id) => {
-  delete defaultTypeParsers[id];
+	delete defaultTypeParsers[id];
 });
-class NodePostgresAdapter {
-  constructor(config) {
-    this.config = config;
-    this.errorClass = DatabaseError;
-    this.pool = this.configure(config);
-    this.locals = this.searchPath ? { search_path: this.searchPath } : emptyObject;
-  }
-  isInTransaction() {
-    return false;
-  }
-  configure(config) {
-    let searchPath = config.searchPath;
-    if (config.databaseURL) {
-      const url = new URL(config.databaseURL);
-      const ssl = url.searchParams.get("ssl");
-      if (ssl === "false") {
-        url.searchParams.delete("ssl");
-      } else if (!config.ssl && ssl === "true") {
-        config.ssl = true;
-      }
-      if (!searchPath) {
-        searchPath = url.searchParams.get("searchPath") || void 0;
-      }
-      config.databaseURL = url.toString();
-      config.connectionString = config.databaseURL;
-    }
-    if (searchPath)
-      this.searchPath = searchPath === "public" ? void 0 : searchPath;
-    const pool = new pg.Pool(config);
-    if (config.connectRetry) {
-      setConnectRetryConfig(
-        this,
-        config.connectRetry === true ? emptyObject : config.connectRetry
-      );
-      this.connect = wrapAdapterFnWithConnectRetry(
-        this,
-        () => this.pool.connect()
-      );
-    }
-    return pool;
-  }
-  getURL() {
-    return this.config.databaseURL ? new URL(this.config.databaseURL) : void 0;
-  }
-  async updateConfig(config) {
-    await this.close();
-    this.configure({ ...this.config, ...config });
-  }
-  reconfigure(params) {
-    const url = this.getURL();
-    if (url) {
-      if ("database" in params) {
-        url.pathname = `/${params.database}`;
-      }
-      if (params.user !== void 0) {
-        url.username = params.user;
-      }
-      if (params.password !== void 0) {
-        url.password = params.password;
-      }
-      if (params.searchPath !== void 0) {
-        url.searchParams.set("searchPath", params.searchPath);
-      }
-      return new NodePostgresAdapter({
-        ...this.config,
-        databaseURL: url.toString()
-      });
-    } else {
-      return new NodePostgresAdapter({ ...this.config, ...params });
-    }
-  }
-  getDatabase() {
-    const url = this.getURL();
-    return url ? url.pathname.slice(1) : this.config.database;
-  }
-  getUser() {
-    const url = this.getURL();
-    return url ? url.username : this.config.user;
-  }
-  getSearchPath() {
-    return this.searchPath;
-  }
-  getHost() {
-    const url = this.getURL();
-    return url ? url.hostname : this.config.host;
-  }
-  getSchema() {
-    return this.config.schema;
-  }
-  connect() {
-    return this.pool.connect();
-  }
-  query(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this,
-      void 0,
-      text,
-      values,
-      startingSavepoint,
-      releasingSavepoint,
-      false,
-      sqlSessionState,
-      true
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  arrays(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this,
-      void 0,
-      text,
-      values,
-      startingSavepoint,
-      releasingSavepoint,
-      true,
-      sqlSessionState,
-      true
-    );
-  }
-  async transaction(...args) {
-    const client = await this.connect();
-    const { cb, options } = getTransactionArgs(args);
-    try {
-      await performQueryOnClient(
-        client,
-        options?.options ? "BEGIN " + options.options : "BEGIN"
-      );
-      if (options?.sqlSessionState) {
-        const { role, setConfig } = options.sqlSessionState;
-        if (role) {
-          await performQueryOnClient(client, `SET ROLE ${role}`);
-        }
-        if (setConfig && Object.keys(setConfig).length > 0) {
-          const setColumns = Object.entries(setConfig).map(
-            ([key, value]) => `set_config('${key.replace(/'/g, "''")}', '${typeof value === "string" ? value.replace(/'/g, "''") : value}', true)`
-          ).join(", ");
-          await performQueryOnClient(client, `SELECT ${setColumns}`);
-        }
-      }
-      const localsSql = getSetLocalsSql(options);
-      if (localsSql) {
-        await client.query(localsSql);
-      }
-      const locals = mergeLocals(this.locals, options);
-      let result;
-      try {
-        result = await cb(
-          new NodePostgresTransactionAdapter(this, client, this, locals)
-        );
-      } catch (err) {
-        await performQueryOnClient(client, "ROLLBACK");
-        throw err;
-      }
-      await performQueryOnClient(client, "COMMIT");
-      return result;
-    } finally {
-      client.release();
-    }
-  }
-  close() {
-    const { pool } = this;
-    this.pool = new pg.Pool(this.config);
-    return pool.end();
-  }
-  assignError(to, dbError) {
-    const from = dbError;
-    to.message = from.message;
-    to.length = from.length;
-    to.name = from.name;
-    to.severity = from.severity;
-    to.code = from.code;
-    to.detail = from.detail;
-    to.hint = from.hint;
-    to.position = from.position;
-    to.internalPosition = from.internalPosition;
-    to.internalQuery = from.internalQuery;
-    to.where = from.where;
-    to.schema = from.schema;
-    to.table = from.table;
-    to.column = from.column;
-    to.dataType = from.dataType;
-    to.constraint = from.constraint;
-    to.file = from.file;
-    to.line = from.line;
-    to.routine = from.routine;
-  }
-}
-const defaultTypesConfig = {
-  getTypeParser(id) {
-    return defaultTypeParsers[id] || returnArg;
-  }
-};
-const setSearchPath = (client, searchPath) => {
-  if (client.connection.searchPath !== searchPath) {
-    client.connection.searchPath = searchPath;
-    return client.query(`SET search_path = ${searchPath || "public"}`);
-  }
-  return;
-};
-const queryWithSqlSession = async (adapter, client, text, values, startingSavepoint, releasingSavepoint, arraysMode, sessionState, borrowConnection = false) => {
-  const setup = sqlSessionContextComputeSetup(sessionState);
-  if (!setup) {
-    if (borrowConnection) {
-      const conn2 = await adapter.connect();
-      try {
-        await setSearchPath(conn2, adapter.searchPath);
-        return await performQueryOnClient(
-          conn2,
-          text,
-          values,
-          arraysMode ? "array" : void 0,
-          startingSavepoint,
-          releasingSavepoint
-        );
-      } finally {
-        conn2.release();
-      }
-    }
-    return performQueryOnClient(
-      client,
-      text,
-      values,
-      arraysMode ? "array" : void 0,
-      startingSavepoint,
-      releasingSavepoint
-    );
-  }
-  const conn = borrowConnection ? await adapter.connect() : client;
-  const queryFn = (sql, vals) => {
-    return conn.query({ text: sql, values: vals, rowMode: "array" }).then((res) => ({
-      rows: res.rows,
-      rowCount: res.rowCount ?? 0,
-      fields: res.fields.map((f) => ({ name: f.name }))
-    }));
-  };
-  const releaseFn = borrowConnection ? async () => {
-    conn.release();
-  } : void 0;
-  const mainQuery = () => performQueryOnClient(
-    conn,
-    text,
-    values,
-    arraysMode ? "array" : void 0,
-    startingSavepoint,
-    releasingSavepoint
-  );
-  if (borrowConnection) {
-    try {
-      await setSearchPath(conn, adapter.searchPath);
-      return await sqlSessionContextExecute(
-        queryFn,
-        setup,
-        mainQuery,
-        releaseFn
-      );
-    } catch (err) {
-      conn.release();
-      throw err;
-    }
-  }
-  return sqlSessionContextExecute(queryFn, setup, mainQuery);
-};
-const performQueryOnClient = async (client, text, values, rowMode, startingSavepoint, releasingSavepoint) => {
-  const params = {
-    text,
-    values,
-    rowMode,
-    types: defaultTypesConfig
-  };
-  const { __lock } = client;
-  if (__lock) {
-    let resolve;
-    client.__lock = new Promise((res) => {
-      resolve = () => {
-        res();
-      };
-    });
-    return __lock.then(() => {
-      const promise2 = startingSavepoint || releasingSavepoint ? performQueryOnClientWithSavepoint(
-        client,
-        params,
-        startingSavepoint,
-        releasingSavepoint
-      ) : client.query(params);
-      promise2.then(resolve, resolve);
-      return promise2;
-    });
-  }
-  const promise = startingSavepoint || releasingSavepoint ? performQueryOnClientWithSavepoint(
-    client,
-    params,
-    startingSavepoint,
-    releasingSavepoint
-  ) : client.query(params);
-  client.__lock = promise.catch(noop);
-  return promise;
+const NodePostgresAdapter = {
+	manualPool: true,
+	errorClass: DatabaseError,
+	errorFields: {
+		message: "message",
+		length: "length",
+		name: "name",
+		severity: "severity",
+		code: "code",
+		detail: "detail",
+		hint: "hint",
+		position: "position",
+		internalPosition: "internalPosition",
+		internalQuery: "internalQuery",
+		where: "where",
+		schema: "schema",
+		table: "table",
+		column: "column",
+		dataType: "dataType",
+		constraint: "constraint",
+		file: "file",
+		line: "line",
+		routine: "routine"
+	},
+	configure(config) {
+		if (config.databaseURL) config.connectionString = config.databaseURL;
+		if (config.locals?.search_path) config = {
+			...config,
+			options: `${config.options ? `${config.options} ` : ""}-c search_path="${config.locals.search_path}"`
+		};
+		return new pg.Pool(config);
+	},
+	queryClient(client, text, values, startingSavepoint, releasingSavepoint, arraysMode) {
+		const params = {
+			text,
+			values,
+			rowMode: arraysMode ? "array" : void 0,
+			types: defaultTypesConfig
+		};
+		const { __lock } = client;
+		if (__lock) {
+			let resolve;
+			client.__lock = new Promise((res) => {
+				resolve = () => {
+					res();
+				};
+			});
+			return __lock.then(() => {
+				const promise = startingSavepoint || releasingSavepoint ? performQueryOnClientWithSavepoint(client, params, startingSavepoint, releasingSavepoint) : client.query(params);
+				promise.then(resolve, resolve);
+				return promise;
+			});
+		}
+		const promise = startingSavepoint || releasingSavepoint ? performQueryOnClientWithSavepoint(client, params, startingSavepoint, releasingSavepoint) : client.query(params);
+		client.__lock = promise.catch(noop);
+		return promise;
+	},
+	borrow(pool) {
+		return pool.connect();
+	},
+	release(client) {
+		client.release();
+	},
+	async begin(pool, cb, options) {
+		const client = await pool.connect();
+		try {
+			await this.queryClient(client, options ? "BEGIN " + options : "BEGIN");
+			let result;
+			try {
+				result = await cb(client);
+			} catch (err) {
+				await this.queryClient(client, "ROLLBACK");
+				throw err;
+			}
+			await this.queryClient(client, "COMMIT");
+			return result;
+		} finally {
+			client.release();
+		}
+	},
+	close(pool) {
+		return pool.end();
+	}
 };
+const defaultTypesConfig = { getTypeParser(id) {
+	return defaultTypeParsers[id] || returnArg;
+} };
 const performQueryOnClientWithSavepoint = (client, params, startingSavepoint, releasingSavepoint) => {
-  let promise = startingSavepoint ? client.query(`SAVEPOINT "${startingSavepoint}"`).then(() => client.query(params)) : client.query(params);
-  if (releasingSavepoint) {
-    promise = promise.then(
-      async (res) => {
-        await client.query(`RELEASE SAVEPOINT "${releasingSavepoint}"`);
-        return res;
-      },
-      async (err) => {
-        await client.query(`ROLLBACK TO SAVEPOINT "${releasingSavepoint}"`);
-        throw err;
-      }
-    );
-  }
-  return promise;
+	let promise = startingSavepoint ? client.query(`SAVEPOINT "${startingSavepoint}"`).then(() => client.query(params)) : client.query(params);
+	if (releasingSavepoint) promise = promise.then(async (res) => {
+		await client.query(`RELEASE SAVEPOINT "${releasingSavepoint}"`);
+		return res;
+	}, async (err) => {
+		await client.query(`ROLLBACK TO SAVEPOINT "${releasingSavepoint}"`);
+		throw err;
+	});
+	return promise;
 };
-class NodePostgresTransactionAdapter {
-  constructor(adapter, client, parent, locals) {
-    this.adapter = adapter;
-    this.client = client;
-    this.parent = parent;
-    this.locals = locals;
-    this.errorClass = DatabaseError;
-    this.pool = adapter.pool;
-    this.config = adapter.config;
-    this.searchPath = adapter.searchPath;
-  }
-  isInTransaction() {
-    return true;
-  }
-  updateConfig(config) {
-    return this.adapter.updateConfig(config);
-  }
-  reconfigure(params) {
-    return this.adapter.reconfigure(params);
-  }
-  getDatabase() {
-    return this.adapter.getDatabase();
-  }
-  getUser() {
-    return this.adapter.getUser();
-  }
-  getSearchPath() {
-    return this.adapter.getSearchPath();
-  }
-  getHost() {
-    return this.adapter.getHost();
-  }
-  getSchema() {
-    return this.adapter.getSchema();
-  }
-  connect() {
-    return Promise.resolve(this.client);
-  }
-  async query(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this.adapter,
-      this.client,
-      text,
-      values,
-      startingSavepoint,
-      releasingSavepoint,
-      false,
-      sqlSessionState,
-      false
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async arrays(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this.adapter,
-      this.client,
-      text,
-      values,
-      startingSavepoint,
-      releasingSavepoint,
-      true,
-      sqlSessionState,
-      false
-    );
-  }
-  async transaction(...args) {
-    const { cb, options } = getTransactionArgs(args);
-    let capturedRole;
-    const capturedConfigs = {};
-    const sqlSession = options?.sqlSessionState;
-    if (sqlSession) {
-      if (sqlSession.role) {
-        const roleResult = await this.query(
-          "SELECT current_role as role"
-        );
-        capturedRole = roleResult.rows[0].role;
-      }
-      if (sqlSession.setConfig && Object.keys(sqlSession.setConfig).length > 0) {
-        for (const key of Object.keys(sqlSession.setConfig)) {
-          const configResult = await this.query(
-            `SELECT current_setting('${key.replace(/'/g, "''")}', true) as val`
-          );
-          capturedConfigs[key] = configResult.rows[0].val;
-        }
-      }
-    }
-    const localsSql = getSetLocalsSql(options);
-    if (localsSql) {
-      await this.query(localsSql);
-    }
-    const locals = mergeLocals(this.locals, options);
-    let res;
-    try {
-      res = await cb(
-        new NodePostgresTransactionAdapter(
-          this.adapter,
-          this.client,
-          this,
-          locals
-        )
-      );
-    } finally {
-      if (sqlSession) {
-        if (capturedRole !== void 0) {
-          await this.query(`SET ROLE ${capturedRole}`);
-        }
-        for (const [key, value] of Object.entries(capturedConfigs)) {
-          const restoreValue = value === null ? "" : value;
-          await this.query(
-            `SELECT set_config('${key.replace(/'/g, "''")}', '${restoreValue.replace(/'/g, "''")}', true)`
-          );
-        }
-      }
-      const resetLocalsSql = getResetLocalsSql(this.locals, options);
-      if (resetLocalsSql) {
-        await this.query(resetLocalsSql);
-      }
-    }
-    return res;
-  }
-  close() {
-    return this.adapter.close();
-  }
-  assignError(to, from) {
-    return this.adapter.assignError(to, from);
-  }
-}
+export { NodePostgresAdapter, createDb };
 
-export { NodePostgresAdapter, NodePostgresTransactionAdapter, createDb };
-//# sourceMappingURL=node-postgres.mjs.map
+//# sourceMappingURL=node-postgres.mjs.map