pqb 0.64.0 → 0.65.0

package/dist/postgres-js.mjs

@@ -1,555 +1,137 @@
-import postgres from 'postgres';
-import { returnArg, emptyObject, setConnectRetryConfig, wrapAdapterFnWithConnectRetry } 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();
-      }
-    }
-  }
-};
-
+import postgres from "postgres";
+import { AdapterClass, returnArg } from "pqb/internal";
+import { createDbWithAdapter } from "pqb";
 const createDb = (options) => {
-  return createDbWithAdapter({
-    ...options,
-    adapter: new PostgresJsAdapter(options)
-  });
+	return createDbWithAdapter({
+		...options,
+		adapter: new AdapterClass({
+			driverAdapter: PostgresJsAdapter,
+			config: options
+		})
+	});
+};
+var PostgresJsResult = class {
+	constructor(result) {
+		this.rowCount = result.count;
+		this.rows = result;
+		this.fields = result.statement.columns;
+	}
 };
-class PostgresJsResult {
-  constructor(result) {
-    this.rowCount = result.count;
-    this.rows = result;
-    this.fields = result.statement.columns;
-  }
-}
 const wrapResult = (result) => {
-  if (result.constructor === Array) {
-    return result.map(
-      (res) => new PostgresJsResult(res)
-    );
-  } else {
-    return new PostgresJsResult(result);
-  }
+	if (result.constructor === Array) return result.map((res) => new PostgresJsResult(res));
+	else return new PostgresJsResult(result);
 };
 const types = {
-  bytea: {
-    to: 17,
-    from: 17,
-    serialize: (x) => "\\x" + Buffer.from(x).toString("hex")
-    // omit parse, let bytea return a string, so it remains consistent with when it's selected via JSON
-  },
-  dateAndTimestampAsStrings: {
-    to: 25,
-    from: [1082, 1114, 1184],
-    parse: returnArg
-  },
-  interval: {
-    from: [1186],
-    serialize: returnArg,
-    parse(str) {
-      const [years, , months, , days, , time] = str.split(" ");
-      const [hours, minutes, seconds] = time.split(":");
-      return {
-        years: years ? Number(years) : 0,
-        months: months ? Number(months) : 0,
-        days: days ? Number(days) : 0,
-        hours: hours ? Number(hours) : 0,
-        minutes: minutes ? Number(minutes) : 0,
-        seconds: seconds ? Number(seconds) : 0
-      };
-    }
-  },
-  // overrides the built-in json type to not serialize it, because it incorrectly serializes
-  json: {
-    to: 114,
-    from: [114, 3802],
-    serialize: returnArg,
-    parse: (x) => {
-      return JSON.parse(x);
-    }
-  }
-};
-class PostgresJsAdapter {
-  constructor(config) {
-    this.errorClass = postgres.PostgresError;
-    this.config = { ...config, types };
-    this.sql = this.configure(config);
-    this.locals = config.searchPath ? {
-      search_path: config.searchPath
-    } : emptyObject;
-  }
-  isInTransaction() {
-    return false;
-  }
-  configure(config) {
-    this.searchPath = config.searchPath;
-    if (this.searchPath) {
-      this.config.connection = {
-        ...config.connection,
-        search_path: this.searchPath
-      };
-    }
-    let sql;
-    if (this.config.databaseURL) {
-      const urlString = this.config.databaseURL;
-      const url = new URL(urlString);
-      const ssl = url.searchParams.get("ssl");
-      if (ssl === "false" || ssl === "true") {
-        this.config.ssl = ssl === "true";
-      }
-      const searchPath = url.searchParams.get("searchPath");
-      if (searchPath) {
-        this.searchPath = searchPath;
-        url.searchParams.delete("searchPath");
-        this.config.connection = {
-          ...config.connection,
-          search_path: searchPath
-        };
-      }
-      sql = postgres(url.toString(), this.config);
-    } else {
-      sql = postgres(this.config);
-    }
-    if (config.connectRetry) {
-      setConnectRetryConfig(
-        this,
-        config.connectRetry === true ? emptyObject : config.connectRetry
-      );
-      if (!this.wrappedWithConnectRetry) {
-        this.query = wrapAdapterFnWithConnectRetry(this, this.query);
-        this.arrays = wrapAdapterFnWithConnectRetry(this, this.arrays);
-        this.wrappedWithConnectRetry = true;
-      }
-    }
-    return sql;
-  }
-  getURL() {
-    return this.config.databaseURL ? new URL(this.config.databaseURL) : void 0;
-  }
-  replaceSql(config) {
-    const { sql } = this;
-    this.sql = this.configure(config);
-    return sql.end();
-  }
-  async updateConfig(config) {
-    await this.replaceSql({ ...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 PostgresJsAdapter({
-        ...this.config,
-        databaseURL: url.toString()
-      });
-    } else {
-      return new PostgresJsAdapter({ ...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;
-  }
-  query(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this.sql,
-      text,
-      values,
-      sqlSessionState,
-      startingSavepoint,
-      releasingSavepoint,
-      false,
-      true
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  arrays(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this.sql,
-      text,
-      values,
-      sqlSessionState,
-      startingSavepoint,
-      releasingSavepoint,
-      true,
-      true
-    );
-  }
-  async transaction(...args) {
-    let ok;
-    let result;
-    const { cb, options } = getTransactionArgs(args);
-    const fn = (sql) => {
-      if (options?.sqlSessionState) {
-        const { role, setConfig } = options.sqlSessionState;
-        if (role) {
-          sql.unsafe(`SET ROLE ${role}`).execute();
-        }
-        if (setConfig && Object.keys(setConfig).length > 0) {
-          const setExpressions = Object.entries(setConfig).map(
-            ([key, value]) => `set_config('${key.replace(/'/g, "''")}', '${typeof value === "string" ? value.replace(/'/g, "''") : value}', true)`
-          ).join(", ");
-          sql.unsafe(`SELECT ${setExpressions}`).execute();
-        }
-      }
-      const localsSql = getSetLocalsSql(options);
-      if (localsSql) {
-        sql.unsafe(localsSql).execute();
-      }
-      const locals = mergeLocals(this.locals, options);
-      return cb(
-        new PostgresJsTransactionAdapter(this, sql, this, locals)
-      ).then((res) => {
-        ok = true;
-        return result = res;
-      });
-    };
-    return (options?.options ? this.sql.begin(options.options, fn) : this.sql.begin(fn)).catch((err) => {
-      if (ok) return result;
-      throw err;
-    });
-  }
-  close() {
-    return this.replaceSql(this.config);
-  }
-  assignError(to, dbError) {
-    const from = dbError;
-    to.message = from.message;
-    to.severity = from.severity;
-    to.code = from.code;
-    to.detail = from.detail;
-    to.schema = from.schema_name;
-    to.table = from.table_name;
-    to.constraint = from.constraint_name;
-    to.hint = from.hint;
-    to.position = from.position;
-    to.where = from.where;
-    to.file = from.file;
-    to.line = from.line;
-    to.routine = from.routine;
-  }
-}
-const query = (sql, text, values, startingSavepoint, releasingSavepoint, arrays) => {
-  let query2 = sql.unsafe(text, values);
-  if (arrays) query2 = query2.values();
-  if (!startingSavepoint && !releasingSavepoint) {
-    return query2.then(wrapResult);
-  }
-  return Promise.all([
-    startingSavepoint && sql.unsafe(`SAVEPOINT "${startingSavepoint}"`),
-    query2,
-    releasingSavepoint && sql.unsafe(`RELEASE SAVEPOINT "${releasingSavepoint}"`)
-  ]).then(
-    (results) => {
-      return wrapResult(results[1]);
-    },
-    (err) => {
-      if (!releasingSavepoint) {
-        throw err;
-      }
-      return sql.unsafe(`ROLLBACK TO SAVEPOINT "${releasingSavepoint}"`).then(() => {
-        throw err;
-      });
-    }
-  );
+	bytea: {
+		to: 17,
+		from: 17,
+		serialize: (x) => "\\x" + Buffer.from(x).toString("hex")
+	},
+	dateAndTimestampAsStrings: {
+		to: 25,
+		from: [
+			1082,
+			1114,
+			1184
+		],
+		parse: returnArg
+	},
+	interval: {
+		from: [1186],
+		serialize: returnArg,
+		parse(str) {
+			const [years, , months, , days, , time] = str.split(" ");
+			const [hours, minutes, seconds] = time.split(":");
+			return {
+				years: years ? Number(years) : 0,
+				months: months ? Number(months) : 0,
+				days: days ? Number(days) : 0,
+				hours: hours ? Number(hours) : 0,
+				minutes: minutes ? Number(minutes) : 0,
+				seconds: seconds ? Number(seconds) : 0
+			};
+		}
+	},
+	json: {
+		to: 114,
+		from: [114, 3802],
+		serialize: returnArg,
+		parse: (x) => {
+			return JSON.parse(x);
+		}
+	}
 };
-const queryWithSqlSession = async (sql, text, values, sessionState, startingSavepoint, releasingSavepoint, arraysMode, borrowConnection = false) => {
-  const setup = sqlSessionContextComputeSetup(sessionState);
-  if (!setup) {
-    return query(
-      sql,
-      text,
-      values,
-      startingSavepoint,
-      releasingSavepoint,
-      arraysMode
-    );
-  }
-  const connection = borrowConnection ? await sql.reserve() : sql;
-  const queryFn = async (sqlStr, vals) => {
-    const result = await connection.unsafe(sqlStr, vals).values();
-    return {
-      rows: result,
-      rowCount: result.length,
-      fields: []
-    };
-  };
-  const releaseFn = borrowConnection ? async () => {
-    await connection.release();
-  } : void 0;
-  const mainQuery = () => query(
-    connection,
-    text,
-    values,
-    startingSavepoint,
-    releasingSavepoint,
-    arraysMode
-  );
-  return sqlSessionContextExecute(queryFn, setup, mainQuery, releaseFn);
+const PostgresJsAdapter = {
+	manualPool: false,
+	errorClass: postgres.PostgresError,
+	errorFields: {
+		message: "message",
+		severity: "severity",
+		code: "code",
+		detail: "detail",
+		schema: "schema_name",
+		table: "table_name",
+		constraint: "constraint_name",
+		hint: "hint",
+		position: "position",
+		where: "where",
+		file: "file",
+		line: "line",
+		routine: "routine"
+	},
+	configure(params) {
+		const config = {
+			...params,
+			types
+		};
+		if (config.locals?.search_path) config.connection = {
+			...config.connection,
+			search_path: config.locals.search_path
+		};
+		let sql;
+		if (config.databaseURL) sql = postgres(config.databaseURL, config);
+		else sql = postgres(config);
+		return sql;
+	},
+	queryClient(client, text, values, startingSavepoint, releasingSavepoint, arraysMode) {
+		let query = client.unsafe(text, values);
+		if (arraysMode) query = query.values();
+		if (!startingSavepoint && !releasingSavepoint) return query.then(wrapResult);
+		return Promise.all([
+			startingSavepoint && client.unsafe(`SAVEPOINT "${startingSavepoint}"`),
+			query,
+			releasingSavepoint && client.unsafe(`RELEASE SAVEPOINT "${releasingSavepoint}"`)
+		]).then((results) => {
+			return wrapResult(results[1]);
+		}, (err) => {
+			if (!releasingSavepoint) throw err;
+			return client.unsafe(`ROLLBACK TO SAVEPOINT "${releasingSavepoint}"`).then(() => {
+				throw err;
+			});
+		});
+	},
+	borrow(client) {
+		return client.reserve();
+	},
+	release(client) {
+		client.release();
+	},
+	begin(client, cb, options) {
+		let ok;
+		let result;
+		const fn = (sql) => cb(sql).then((res) => {
+			ok = true;
+			return result = res;
+		});
+		return (options ? client.begin(options, fn) : client.begin(fn)).catch((err) => {
+			if (ok) return result;
+			throw err;
+		});
+	},
+	close(client) {
+		return client.end();
+	}
 };
-class PostgresJsTransactionAdapter {
-  constructor(adapter, sql, parent, locals) {
-    this.adapter = adapter;
-    this.sql = sql;
-    this.parent = parent;
-    this.locals = locals;
-    this.errorClass = postgres.PostgresError;
-  }
-  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.searchPath;
-  }
-  getHost() {
-    return this.adapter.getHost();
-  }
-  getSchema() {
-    return this.adapter.getSchema();
-  }
-  query(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this.sql,
-      text,
-      values,
-      sqlSessionState,
-      startingSavepoint,
-      releasingSavepoint,
-      false,
-      false
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  arrays(text, values, startingSavepoint, releasingSavepoint, sqlSessionState) {
-    return queryWithSqlSession(
-      this.sql,
-      text,
-      values,
-      sqlSessionState,
-      startingSavepoint,
-      releasingSavepoint,
-      true,
-      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) {
-      this.sql.unsafe(localsSql).execute();
-    }
-    const locals = mergeLocals(this.locals, options);
-    let res;
-    try {
-      res = await cb(
-        new PostgresJsTransactionAdapter(this.adapter, this.sql, 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.sql.unsafe(resetLocalsSql);
-      }
-    }
-    return res;
-  }
-  close() {
-    return this.sql.end();
-  }
-  assignError(to, from) {
-    return this.adapter.assignError(to, from);
-  }
-}
+export { PostgresJsAdapter, createDb };
 
-export { PostgresJsAdapter, PostgresJsTransactionAdapter, createDb };
-//# sourceMappingURL=postgres-js.mjs.map
+//# sourceMappingURL=postgres-js.mjs.map