@event-driven-io/dumbo 0.12.1 → 0.13.0-alpha.2

package/dist/chunk-DYX7V3LM.cjs

@@ -0,0 +1,1409 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+
+// src/core/serializer/json/index.ts
+var bigIntReplacer = (_key, value) => {
+  return typeof value === "bigint" ? value.toString() : value;
+};
+var bigIntReviver = (_key, value) => {
+  if (typeof value === "string" && /^[+-]?\d+n?$/.test(value)) {
+    return BigInt(value);
+  }
+  return value;
+};
+var composeJSONReplacers = (...replacers) => (key2, value) => (
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  replacers.reduce((accValue, replacer) => replacer(key2, accValue), value)
+);
+var composeJSONRevivers = (...revivers) => (key2, value) => (
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  revivers.reduce((accValue, reviver) => reviver(key2, accValue), value)
+);
+var JSONReplacer = (opts) => _optionalChain([opts, 'optionalAccess', _2 => _2.disableBigIntSerialization]) == true ? opts.replacer ? opts.replacer : void 0 : _optionalChain([opts, 'optionalAccess', _3 => _3.replacer]) ? composeJSONReplacers(JSONReplacers.bigInt, opts.replacer) : JSONReplacers.bigInt;
+var JSONReviver = (opts) => _optionalChain([opts, 'optionalAccess', _4 => _4.disableBigIntSerialization]) == true ? opts.reviver ? opts.reviver : void 0 : _optionalChain([opts, 'optionalAccess', _5 => _5.reviver]) ? composeJSONRevivers(JSONRevivers.bigInt, opts.reviver) : JSONRevivers.bigInt;
+var JSONReplacers = {
+  bigInt: bigIntReplacer
+};
+var JSONRevivers = {
+  bigInt: bigIntReviver
+};
+var jsonSerializer = (options) => {
+  const defaultReplacer = JSONReplacer(options);
+  const defaultReviver = JSONReviver(options);
+  return {
+    serialize: (object, options2) => JSON.stringify(object, options2 ? JSONReplacer(options2) : defaultReplacer),
+    deserialize: (payload, options2) => JSON.parse(payload, options2 ? JSONReviver(options2) : defaultReviver)
+  };
+};
+var JSONSerializer = jsonSerializer({ disableBigIntSerialization: false });
+var RawJSONSerializer = jsonSerializer({ disableBigIntSerialization: true });
+
+// src/core/sql/pg-format/reserved.ts
+var reservedMap = {
+  AES128: true,
+  AES256: true,
+  ALL: true,
+  ALLOWOVERWRITE: true,
+  ANALYSE: true,
+  ANALYZE: true,
+  AND: true,
+  ANY: true,
+  ARRAY: true,
+  AS: true,
+  ASC: true,
+  AUTHORIZATION: true,
+  BACKUP: true,
+  BETWEEN: true,
+  BINARY: true,
+  BLANKSASNULL: true,
+  BOTH: true,
+  BYTEDICT: true,
+  CASE: true,
+  CAST: true,
+  CHECK: true,
+  COLLATE: true,
+  COLUMN: true,
+  CONSTRAINT: true,
+  CREATE: true,
+  CREDENTIALS: true,
+  CROSS: true,
+  CURRENT_DATE: true,
+  CURRENT_TIME: true,
+  CURRENT_TIMESTAMP: true,
+  CURRENT_USER: true,
+  CURRENT_USER_ID: true,
+  DEFAULT: true,
+  DEFERRABLE: true,
+  DEFLATE: true,
+  DEFRAG: true,
+  DELTA: true,
+  DELTA32K: true,
+  DESC: true,
+  DISABLE: true,
+  DISTINCT: true,
+  DO: true,
+  ELSE: true,
+  EMPTYASNULL: true,
+  ENABLE: true,
+  ENCODE: true,
+  ENCRYPT: true,
+  ENCRYPTION: true,
+  END: true,
+  EXCEPT: true,
+  EXPLICIT: true,
+  FALSE: true,
+  FOR: true,
+  FOREIGN: true,
+  FREEZE: true,
+  FROM: true,
+  FULL: true,
+  GLOBALDICT256: true,
+  GLOBALDICT64K: true,
+  GRANT: true,
+  GROUP: true,
+  GZIP: true,
+  HAVING: true,
+  IDENTITY: true,
+  IGNORE: true,
+  ILIKE: true,
+  IN: true,
+  INITIALLY: true,
+  INNER: true,
+  INTERSECT: true,
+  INTO: true,
+  IS: true,
+  ISNULL: true,
+  JOIN: true,
+  LEADING: true,
+  LEFT: true,
+  LIKE: true,
+  LIMIT: true,
+  LOCALTIME: true,
+  LOCALTIMESTAMP: true,
+  LUN: true,
+  LUNS: true,
+  LZO: true,
+  LZOP: true,
+  MINUS: true,
+  MOSTLY13: true,
+  MOSTLY32: true,
+  MOSTLY8: true,
+  NATURAL: true,
+  NEW: true,
+  NOT: true,
+  NOTNULL: true,
+  NULL: true,
+  NULLS: true,
+  OFF: true,
+  OFFLINE: true,
+  OFFSET: true,
+  OLD: true,
+  ON: true,
+  ONLY: true,
+  OPEN: true,
+  OR: true,
+  ORDER: true,
+  OUTER: true,
+  OVERLAPS: true,
+  PARALLEL: true,
+  PARTITION: true,
+  PERCENT: true,
+  PLACING: true,
+  PRIMARY: true,
+  RAW: true,
+  READRATIO: true,
+  RECOVER: true,
+  REFERENCES: true,
+  REJECTLOG: true,
+  RESORT: true,
+  RESTORE: true,
+  RIGHT: true,
+  SELECT: true,
+  SESSION_USER: true,
+  SIMILAR: true,
+  SOME: true,
+  SYSDATE: true,
+  SYSTEM: true,
+  TABLE: true,
+  TAG: true,
+  TDES: true,
+  TEXT255: true,
+  TEXT32K: true,
+  THEN: true,
+  TO: true,
+  TOP: true,
+  TRAILING: true,
+  TRUE: true,
+  TRUNCATECOLUMNS: true,
+  UNION: true,
+  UNIQUE: true,
+  USER: true,
+  USING: true,
+  VERBOSE: true,
+  WALLET: true,
+  WHEN: true,
+  WHERE: true,
+  WITH: true,
+  WITHOUT: true
+};
+var reserved_default = reservedMap;
+
+// src/core/sql/pg-format/index.ts
+var fmtPattern = {
+  ident: "I",
+  literal: "L",
+  string: "s"
+};
+var formatDate = (date) => {
+  date = date.replace("T", " ");
+  date = date.replace("Z", "+00");
+  return date;
+};
+var isReserved = (value) => {
+  return !!reserved_default[value.toUpperCase()];
+};
+var arrayToList = (useSpace, array, formatter) => {
+  let sql2 = "";
+  sql2 += useSpace ? " (" : "(";
+  for (let i = 0; i < array.length; i++) {
+    sql2 += (i === 0 ? "" : ", ") + formatter(array[i]);
+  }
+  sql2 += ")";
+  return sql2;
+};
+var quoteIdent = (value) => {
+  if (value === void 0 || value === null) {
+    throw new Error("SQL identifier cannot be null or undefined");
+  } else if (value === false) {
+    return '"f"';
+  } else if (value === true) {
+    return '"t"';
+  } else if (value instanceof Date) {
+    return '"' + formatDate(value.toISOString()) + '"';
+  } else if (value instanceof Buffer) {
+    throw new Error("SQL identifier cannot be a buffer");
+  } else if (Array.isArray(value)) {
+    return value.map((v) => {
+      if (Array.isArray(v)) {
+        throw new Error(
+          "Nested array to grouped list conversion is not supported for SQL identifier"
+        );
+      }
+      return quoteIdent(v);
+    }).toString();
+  } else if (value === Object(value)) {
+    throw new Error("SQL identifier cannot be an object");
+  }
+  const ident = value.toString().slice(0);
+  if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident)) {
+    return ident;
+  }
+  let quoted = '"';
+  for (let i = 0; i < ident.length; i++) {
+    const c = ident[i];
+    quoted += c === '"' ? c + c : c;
+  }
+  quoted += '"';
+  return quoted;
+};
+var quoteLiteral = (value) => {
+  let literal2 = null;
+  let explicitCast = null;
+  if (value === void 0 || value === null) {
+    return "NULL";
+  } else if (value === false) {
+    return "'f'";
+  } else if (value === true) {
+    return "'t'";
+  } else if (value instanceof Date) {
+    return "'" + formatDate(value.toISOString()) + "'";
+  } else if (value instanceof Buffer) {
+    return "E'\\\\x" + value.toString("hex") + "'";
+  } else if (Array.isArray(value)) {
+    return value.map((v, i) => {
+      if (Array.isArray(v)) {
+        return arrayToList(i !== 0, v, quoteLiteral);
+      }
+      return quoteLiteral(v);
+    }).toString();
+  } else if (value === Object(value)) {
+    explicitCast = "jsonb";
+    literal2 = JSONSerializer.serialize(value);
+  } else {
+    literal2 = value.toString().slice(0);
+  }
+  let hasBackslash = false;
+  let quoted = "'";
+  for (let i = 0; i < literal2.length; i++) {
+    const c = literal2[i];
+    if (c === "'") {
+      quoted += c + c;
+    } else if (c === "\\") {
+      quoted += c + c;
+      hasBackslash = true;
+    } else {
+      quoted += c;
+    }
+  }
+  quoted += "'";
+  if (hasBackslash) {
+    quoted = "E" + quoted;
+  }
+  if (explicitCast) {
+    quoted += "::" + explicitCast;
+  }
+  return quoted;
+};
+var quoteString = (value) => {
+  if (value === void 0 || value === null) {
+    return "";
+  } else if (value === false) {
+    return "f";
+  } else if (value === true) {
+    return "t";
+  } else if (value instanceof Date) {
+    return formatDate(value.toISOString());
+  } else if (value instanceof Buffer) {
+    return "\\x" + value.toString("hex");
+  } else if (Array.isArray(value)) {
+    return value.map((v, i) => {
+      if (v !== null && v !== void 0) {
+        if (Array.isArray(v)) {
+          return arrayToList(i !== 0, v, quoteString);
+        }
+        return quoteString(v);
+      }
+      return "";
+    }).filter((v) => v !== "").toString();
+  } else if (value === Object(value)) {
+    return JSONSerializer.serialize(value);
+  }
+  return value.toString().slice(0);
+};
+var config = (cfg) => {
+  fmtPattern.ident = "I";
+  fmtPattern.literal = "L";
+  fmtPattern.string = "s";
+  if (cfg && cfg.pattern) {
+    if (cfg.pattern.ident) {
+      fmtPattern.ident = cfg.pattern.ident;
+    }
+    if (cfg.pattern.literal) {
+      fmtPattern.literal = cfg.pattern.literal;
+    }
+    if (cfg.pattern.string) {
+      fmtPattern.string = cfg.pattern.string;
+    }
+  }
+};
+var formatWithArray = (fmt, parameters) => {
+  let index = 0;
+  const params = parameters;
+  let re = "%(%|(\\d+\\$)?[";
+  re += fmtPattern.ident;
+  re += fmtPattern.literal;
+  re += fmtPattern.string;
+  re += "])";
+  re = new RegExp(re, "g");
+  return fmt.replace(re, (_, type) => {
+    if (type === "%") {
+      return "%";
+    }
+    let position = index;
+    const tokens = type.split("$");
+    if (tokens.length > 1) {
+      position = parseInt(tokens[0], 10) - 1;
+      type = tokens[1];
+    }
+    if (position < 0) {
+      throw new Error("specified argument 0 but arguments start at 1");
+    } else if (position > params.length - 1) {
+      throw new Error("too few arguments");
+    }
+    index = position + 1;
+    if (type === fmtPattern.ident) {
+      return quoteIdent(params[position]);
+    } else if (type === fmtPattern.literal) {
+      return quoteLiteral(params[position]);
+    } else if (type === fmtPattern.string) {
+      return quoteString(params[position]);
+    }
+    return void 0;
+  });
+};
+var format = (fmt, ...args) => {
+  return formatWithArray(fmt, args);
+};
+format.config = config;
+format.format = format;
+format.ident = quoteIdent;
+format.literal = quoteLiteral;
+format.string = quoteString;
+format.withArray = formatWithArray;
+var pg_format_default = format;
+
+// src/core/sql/index.ts
+var sql = (sqlQuery, ...params) => {
+  return pg_format_default(sqlQuery, ...params);
+};
+var rawSql = (sqlQuery) => {
+  return sqlQuery;
+};
+var isSQL = (literal2) => literal2 !== void 0 && literal2 !== null && typeof literal2 === "string";
+var literal = (value) => ({ type: "literal", value });
+var identifier = (value) => ({ type: "identifier", value });
+var plainString = (value) => ({ type: "plainString", value });
+var defaultFormat = (value) => {
+  if (typeof value === "string") {
+    return pg_format_default("%L", value);
+  } else if (typeof value === "number") {
+    return value.toString();
+  } else if (typeof value === "bigint") {
+    return pg_format_default("%L", value);
+  } else if (value instanceof Date) {
+    return pg_format_default("%L", value);
+  } else if (Array.isArray(value)) {
+    return pg_format_default("(%L)", value);
+  } else if (typeof value === "object") {
+    return pg_format_default("%s", JSON.stringify(value));
+  } else {
+    return pg_format_default("%L", value);
+  }
+};
+function SQL(strings, ...values) {
+  return strings.map((string, index) => {
+    let formattedValue = "";
+    if (index < values.length) {
+      const value = values[index];
+      if (value && typeof value === "object" && "type" in value && "value" in value) {
+        const sqlValue = value;
+        switch (sqlValue.type) {
+          case "literal":
+            formattedValue = pg_format_default("%L", sqlValue.value);
+            break;
+          case "identifier":
+            formattedValue = pg_format_default("%I", sqlValue.value);
+            break;
+          case "plainString":
+            formattedValue = sqlValue.value;
+            break;
+        }
+      } else {
+        formattedValue = defaultFormat(value);
+      }
+    }
+    return string + formattedValue;
+  }).join("");
+}
+
+// src/core/execute/execute.ts
+var sqlExecutor = (sqlExecutor2, options) => ({
+  query: (sql2, queryOptions) => executeInNewDbClient(
+    (client) => sqlExecutor2.query(client, sql2, queryOptions),
+    options
+  ),
+  batchQuery: (sqls, queryOptions) => executeInNewDbClient(
+    (client) => sqlExecutor2.batchQuery(client, sqls, queryOptions),
+    options
+  ),
+  command: (sql2, commandOptions) => executeInNewDbClient(
+    (client) => sqlExecutor2.command(client, sql2, commandOptions),
+    options
+  ),
+  batchCommand: (sqls, commandOptions) => executeInNewDbClient(
+    (client) => sqlExecutor2.batchQuery(client, sqls, commandOptions),
+    options
+  )
+});
+var sqlExecutorInNewConnection = (options) => ({
+  query: (sql2) => executeInNewConnection(
+    (connection) => connection.execute.query(sql2),
+    options
+  ),
+  batchQuery: (sqls) => executeInNewConnection(
+    (connection) => connection.execute.batchQuery(sqls),
+    options
+  ),
+  command: (sql2) => executeInNewConnection(
+    (connection) => connection.execute.command(sql2),
+    options
+  ),
+  batchCommand: (sqls) => executeInNewConnection(
+    (connection) => connection.execute.batchCommand(sqls),
+    options
+  )
+});
+var executeInNewDbClient = async (handle, options) => {
+  const { connect, close } = options;
+  const client = await connect();
+  try {
+    return await handle(client);
+  } catch (error) {
+    if (close) await close(client, error);
+    throw error;
+  }
+};
+var executeInNewConnection = async (handle, options) => {
+  const connection = await options.connection();
+  try {
+    return await handle(connection);
+  } finally {
+    await connection.close();
+  }
+};
+
+// src/core/connections/transaction.ts
+var toTransactionResult = (transactionResult) => transactionResult !== void 0 && transactionResult !== null && typeof transactionResult === "object" && "success" in transactionResult ? transactionResult : { success: true, result: transactionResult };
+var executeInTransaction = async (transaction, handle) => {
+  await transaction.begin();
+  try {
+    const { success, result } = toTransactionResult(await handle(transaction));
+    if (success) await transaction.commit();
+    else await transaction.rollback();
+    return result;
+  } catch (e) {
+    await transaction.rollback();
+    throw e;
+  }
+};
+var transactionFactoryWithDbClient = (connect, initTransaction) => ({
+  transaction: () => initTransaction(connect()),
+  withTransaction: (handle) => executeInTransaction(initTransaction(connect()), handle)
+});
+var wrapInConnectionClosure = async (connection, handle) => {
+  try {
+    return await handle();
+  } finally {
+    await connection.close();
+  }
+};
+var transactionFactoryWithNewConnection = (connect) => ({
+  transaction: () => {
+    const connection = connect();
+    const transaction = connection.transaction();
+    return {
+      ...transaction,
+      commit: () => wrapInConnectionClosure(connection, () => transaction.commit()),
+      rollback: () => wrapInConnectionClosure(connection, () => transaction.rollback())
+    };
+  },
+  withTransaction: (handle) => {
+    const connection = connect();
+    return wrapInConnectionClosure(
+      connection,
+      () => connection.withTransaction(handle)
+    );
+  }
+});
+
+// src/core/connections/connection.ts
+var createConnection = (options) => {
+  const { type, connect, close, initTransaction, executor } = options;
+  let client = null;
+  const getClient = async () => await _asyncNullishCoalesce(client, async () => ( (client = await connect)));
+  const connection = {
+    type,
+    open: getClient,
+    close: () => client ? close(client) : Promise.resolve(),
+    ...transactionFactoryWithDbClient(
+      getClient,
+      initTransaction(() => typedConnection)
+    ),
+    execute: sqlExecutor(executor(), { connect: getClient })
+  };
+  const typedConnection = connection;
+  return typedConnection;
+};
+
+// src/core/connections/pool.ts
+var createConnectionPool = (pool) => {
+  const { type, getConnection } = pool;
+  const connection = "connection" in pool ? pool.connection : () => Promise.resolve(getConnection());
+  const withConnection = "withConnection" in pool ? pool.withConnection : (handle) => executeInNewConnection(handle, {
+    connection
+  });
+  const close = "close" in pool ? pool.close : () => Promise.resolve();
+  const execute = "execute" in pool ? pool.execute : sqlExecutorInNewConnection({ connection });
+  const transaction = "transaction" in pool && "withTransaction" in pool ? {
+    transaction: pool.transaction,
+    withTransaction: pool.withTransaction
+  } : transactionFactoryWithNewConnection(getConnection);
+  const result = {
+    type,
+    connection,
+    withConnection,
+    close,
+    execute,
+    ...transaction
+  };
+  return result;
+};
+
+// src/core/connectors/index.ts
+function toConnectorType(databaseType, driverName) {
+  return `${databaseType}:${driverName}`;
+}
+function fromConnectorType(connectorType) {
+  const parts = connectorType.split(":");
+  return {
+    databaseType: parts[0],
+    driverName: parts[1]
+  };
+}
+function getDriverName(connectorType) {
+  const { driverName } = fromConnectorType(connectorType);
+  return driverName;
+}
+
+// src/core/query/mappers.ts
+var mapRows = async (getResult, map) => {
+  const result = await getResult;
+  return result.rows.map(map);
+};
+var toCamelCase = (snakeStr) => snakeStr.replace(/_([a-z])/g, (g) => _nullishCoalesce(_optionalChain([g, 'access', _6 => _6[1], 'optionalAccess', _7 => _7.toUpperCase, 'call', _8 => _8()]), () => ( "")));
+var mapToCamelCase = (obj) => {
+  const newObj = {};
+  for (const key2 in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key2)) {
+      newObj[toCamelCase(key2)] = obj[key2];
+    }
+  }
+  return newObj;
+};
+
+// src/core/query/selectors.ts
+var firstOrNull = async (getResult) => {
+  const result = await getResult;
+  return result.rows.length > 0 ? _nullishCoalesce(result.rows[0], () => ( null)) : null;
+};
+var first = async (getResult) => {
+  const result = await getResult;
+  if (result.rows.length === 0)
+    throw new Error("Query didn't return any result");
+  return result.rows[0];
+};
+var singleOrNull = async (getResult) => {
+  const result = await getResult;
+  if (result.rows.length > 1) throw new Error("Query had more than one result");
+  return result.rows.length > 0 ? _nullishCoalesce(result.rows[0], () => ( null)) : null;
+};
+var single = async (getResult) => {
+  const result = await getResult;
+  if (result.rows.length === 0)
+    throw new Error("Query didn't return any result");
+  if (result.rows.length > 1) throw new Error("Query had more than one result");
+  return result.rows[0];
+};
+var count = async (getResult) => {
+  const result = await single(getResult);
+  return result.count;
+};
+var exists = async (getResult) => {
+  const result = await single(getResult);
+  return result.exists === true;
+};
+
+// src/core/schema/migrations.ts
+var sqlMigration = (name, sqls) => ({
+  name,
+  sqls
+});
+var MIGRATIONS_LOCK_ID = 999956789;
+var runSQLMigrations = (pool, migrations, options) => pool.withTransaction(async ({ execute }) => {
+  const { databaseLock, ...rest } = options.lock;
+  const lockOptions = {
+    lockId: MIGRATIONS_LOCK_ID,
+    ...rest
+  };
+  const coreMigrations = options.schema.migrationTable.migrations({
+    connector: "PostgreSQL:pg"
+    // TODO: This will need to change to support more connectors
+  });
+  await databaseLock.withAcquire(
+    execute,
+    async () => {
+      for (const migration of coreMigrations) {
+        const sql2 = combineMigrations(migration);
+        await execute.command(rawSql(sql2));
+      }
+      for (const migration of migrations) {
+        await runSQLMigration(execute, migration);
+      }
+    },
+    lockOptions
+  );
+  return { success: options.dryRun ? false : true, result: void 0 };
+});
+var runSQLMigration = async (execute, migration) => {
+  const sql2 = combineMigrations(migration);
+  const sqlHash = await getMigrationHash(sql2);
+  try {
+    const newMigration = {
+      name: migration.name,
+      sqlHash
+    };
+    const wasMigrationApplied = await ensureMigrationWasNotAppliedYet(
+      execute,
+      newMigration
+    );
+    if (wasMigrationApplied) return;
+    await execute.command(rawSql(sql2));
+    await recordMigration(execute, newMigration);
+  } catch (error) {
+    tracer.error("migration-error", {
+      migationName: migration.name,
+      error
+    });
+    throw error;
+  }
+};
+var getMigrationHash = async (content) => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(content);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+var combineMigrations = (...migration) => migration.flatMap((m) => m.sqls).join("\n");
+var ensureMigrationWasNotAppliedYet = async (execute, migration) => {
+  const result = await singleOrNull(
+    execute.query(
+      sql(`SELECT sql_hash FROM migrations WHERE name = %L`, migration.name)
+    )
+  );
+  if (result === null) return false;
+  const { sqlHash } = mapToCamelCase(result);
+  if (sqlHash !== migration.sqlHash) {
+    throw new Error(
+      `Migration hash mismatch for "${migration.name}". Aborting migration.`
+    );
+  }
+  return true;
+};
+var recordMigration = async (execute, migration) => {
+  await execute.command(
+    sql(
+      `
+      INSERT INTO migrations (name, sql_hash)
+      VALUES (%L, %L)
+      `,
+      migration.name,
+      migration.sqlHash
+    )
+  );
+};
+
+// src/core/schema/schemaComponent.ts
+var schemaComponent = (type, migrationsOrComponents) => {
+  const components = "components" in migrationsOrComponents ? migrationsOrComponents.components : void 0;
+  const migrations = "migrations" in migrationsOrComponents ? migrationsOrComponents.migrations : void 0;
+  return {
+    schemaComponentType: type,
+    components,
+    migrations: (options) => [
+      ...migrations ? migrations(options) : [],
+      ...components ? components.flatMap((component) => component.migrations(options)) : []
+    ]
+  };
+};
+
+// src/core/tracing/printing/color.ts
+var _ansis = require('ansis'); var _ansis2 = _interopRequireDefault(_ansis);
+var enableColors = true;
+var color = {
+  set level(value) {
+    enableColors = value === 1;
+  },
+  hex: (value) => (text) => enableColors ? _ansis2.default.hex(value)(text) : text,
+  red: (value) => enableColors ? _ansis2.default.red(value) : value,
+  green: (value) => enableColors ? _ansis2.default.green(value) : value,
+  blue: (value) => enableColors ? _ansis2.default.blue(value) : value,
+  cyan: (value) => enableColors ? _ansis2.default.cyan(value) : value,
+  yellow: (value) => enableColors ? _ansis2.default.yellow(value) : value
+};
+var color_default = color;
+
+// src/core/tracing/printing/pretty.ts
+var TWO_SPACES = "  ";
+var COLOR_STRING = color_default.hex("#98c379");
+var COLOR_KEY = color_default.hex("#61afef");
+var COLOR_NUMBER_OR_DATE = color_default.hex("#d19a66");
+var COLOR_BOOLEAN = color_default.hex("#c678dd");
+var COLOR_NULL_OR_UNDEFINED = color_default.hex("#c678dd");
+var COLOR_BRACKETS = color_default.hex("#abb2bf");
+var processString = (str, indent, handleMultiline) => {
+  if (handleMultiline && str.includes("\n")) {
+    const lines = str.split("\n");
+    const indentedLines = lines.map(
+      (line) => indent + TWO_SPACES + COLOR_STRING(line)
+    );
+    return COLOR_STRING('"') + "\n" + indentedLines.join("\n") + "\n" + indent + COLOR_STRING('"');
+  }
+  return COLOR_STRING(`"${str}"`);
+};
+var shouldPrint = (obj) => typeof obj !== "function" && typeof obj !== "symbol";
+var formatJson = (obj, indentLevel = 0, handleMultiline = false) => {
+  const indent = TWO_SPACES.repeat(indentLevel);
+  if (obj === null) return COLOR_NULL_OR_UNDEFINED("null");
+  if (obj === void 0) return COLOR_NULL_OR_UNDEFINED("undefined");
+  if (typeof obj === "string")
+    return processString(obj, indent, handleMultiline);
+  if (typeof obj === "number" || typeof obj === "bigint" || obj instanceof Date)
+    return COLOR_NUMBER_OR_DATE(String(obj));
+  if (typeof obj === "boolean") return COLOR_BOOLEAN(String(obj));
+  if (obj instanceof Error) {
+    const errorObj = {};
+    const propNames = Object.getOwnPropertyNames(obj);
+    propNames.forEach((key2) => {
+      errorObj[key2] = obj[key2];
+    });
+    return formatJson(errorObj, indentLevel, handleMultiline);
+  }
+  if (obj instanceof Promise) {
+    return COLOR_STRING("Promise {pending}");
+  }
+  if (Array.isArray(obj)) {
+    const arrayItems = obj.map(
+      (item) => formatJson(item, indentLevel + 1, handleMultiline)
+    );
+    return `${COLOR_BRACKETS("[")}
+${indent}  ${arrayItems.join(
+      `,
+${indent}  `
+    )}
+${indent}${COLOR_BRACKETS("]")}`;
+  }
+  const entries = Object.entries(obj).filter(([_, value]) => shouldPrint(value)).map(
+    ([key2, value]) => `${COLOR_KEY(`"${key2}"`)}: ${formatJson(
+      value,
+      indentLevel + 1,
+      handleMultiline
+    )}`
+  );
+  return `${COLOR_BRACKETS("{")}
+${indent}  ${entries.join(
+    `,
+${indent}  `
+  )}
+${indent}${COLOR_BRACKETS("}")}`;
+};
+var prettyJson = (obj, options) => formatJson(obj, 0, _optionalChain([options, 'optionalAccess', _9 => _9.handleMultiline]));
+
+// src/core/tracing/index.ts
+var tracer = () => {
+};
+var LogLevel = {
+  DISABLED: "DISABLED",
+  INFO: "INFO",
+  LOG: "LOG",
+  WARN: "WARN",
+  ERROR: "ERROR"
+};
+var LogStyle = {
+  RAW: "RAW",
+  PRETTY: "PRETTY"
+};
+var shouldLog = (logLevel) => {
+  const definedLogLevel = _nullishCoalesce(process.env.DUMBO_LOG_LEVEL, () => ( LogLevel.DISABLED));
+  if (definedLogLevel === LogLevel.ERROR && logLevel === LogLevel.ERROR)
+    return true;
+  if (definedLogLevel === LogLevel.WARN && [LogLevel.ERROR, LogLevel.WARN].includes(logLevel))
+    return true;
+  if (definedLogLevel === LogLevel.LOG && [LogLevel.ERROR, LogLevel.WARN, LogLevel.LOG].includes(logLevel))
+    return true;
+  if (definedLogLevel === LogLevel.INFO && [LogLevel.ERROR, LogLevel.WARN, LogLevel.LOG, LogLevel.INFO].includes(
+    logLevel
+  ))
+    return true;
+  return false;
+};
+var nulloTraceEventRecorder = () => {
+};
+var getTraceEventFormatter = (logStyle) => (event) => {
+  switch (logStyle) {
+    case "RAW":
+      return JSONSerializer.serialize(event);
+    case "PRETTY":
+      return prettyJson(event, { handleMultiline: true });
+  }
+};
+var getTraceEventRecorder = (logLevel, logStyle) => {
+  const format2 = getTraceEventFormatter(logStyle);
+  switch (logLevel) {
+    case "DISABLED":
+      return nulloTraceEventRecorder;
+    case "INFO":
+      return (event) => console.info(format2(event));
+    case "LOG":
+      return (event) => console.log(format2(event));
+    case "WARN":
+      return (event) => console.warn(format2(event));
+    case "ERROR":
+      return (event) => console.error(format2(event));
+  }
+};
+var recordTraceEvent = (logLevel, eventName, attributes) => {
+  if (!shouldLog(LogLevel.LOG)) return;
+  const event = {
+    name: eventName,
+    timestamp: (/* @__PURE__ */ new Date()).getTime(),
+    ...attributes
+  };
+  const record = getTraceEventRecorder(
+    logLevel,
+    _nullishCoalesce(process.env.DUMBO_LOG_STYLE, () => ( "RAW"))
+  );
+  record(event);
+};
+tracer.info = (eventName, attributes) => recordTraceEvent(LogLevel.INFO, eventName, attributes);
+tracer.warn = (eventName, attributes) => recordTraceEvent(LogLevel.WARN, eventName, attributes);
+tracer.log = (eventName, attributes) => recordTraceEvent(LogLevel.LOG, eventName, attributes);
+tracer.error = (eventName, attributes) => recordTraceEvent(LogLevel.ERROR, eventName, attributes);
+
+// src/core/locks/databaseLock.ts
+var defaultDatabaseLockOptions = {
+  timeoutMs: 1e4
+};
+
+// src/storage/postgresql/core/connections/connectionString.ts
+var _pgconnectionstring = require('pg-connection-string'); var _pgconnectionstring2 = _interopRequireDefault(_pgconnectionstring);
+
+// src/storage/postgresql/core/schema/migrations.ts
+var migrationTableSQL = rawSql(`
+  CREATE TABLE IF NOT EXISTS migrations (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL UNIQUE,
+    application VARCHAR(255) NOT NULL DEFAULT 'default',
+    sql_hash VARCHAR(64) NOT NULL,
+    timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+  );
+`);
+var migrationTableSchemaComponent = schemaComponent(
+  "dumbo:schema-component:migrations-table",
+  {
+    migrations: () => [
+      sqlMigration("dumbo:migrationTable:001", [migrationTableSQL])
+    ]
+  }
+);
+var runPostgreSQLMigrations = (pool, migrations, options) => runSQLMigrations(pool, migrations, {
+  schema: {
+    migrationTable: migrationTableSchemaComponent
+  },
+  lock: {
+    databaseLock: AdvisoryLock,
+    options: {
+      ..._nullishCoalesce(options, () => ( {})),
+      lockId: MIGRATIONS_LOCK_ID
+    }
+  },
+  dryRun: _optionalChain([options, 'optionalAccess', _10 => _10.dryRun])
+});
+
+// src/storage/postgresql/core/schema/schema.ts
+var defaultPostgreSqlDatabase = "postgres";
+var tableExistsSQL = (tableName) => sql(
+  `
+  SELECT EXISTS (
+    SELECT FROM pg_tables
+    WHERE tablename = %L
+  ) AS exists;`,
+  tableName
+);
+var tableExists = async (pool, tableName) => exists(pool.execute.query(tableExistsSQL(tableName)));
+var functionExistsSQL = (functionName) => sql(
+  `
+      SELECT EXISTS (
+        SELECT FROM pg_proc 
+        WHERE 
+        proname = %L
+      ) AS exists;
+    `,
+  functionName
+);
+var functionExists = async (pool, tableName) => exists(pool.execute.query(functionExistsSQL(tableName)));
+
+// src/storage/postgresql/core/connections/connectionString.ts
+var defaultPostgreSQLConenctionString = "postgresql://postgres@localhost:5432/postgres";
+var getDatabaseNameOrDefault = (connectionString) => _nullishCoalesce(_pgconnectionstring2.default.parse(connectionString).database, () => ( defaultPostgreSqlDatabase));
+
+// src/storage/postgresql/core/locks/advisoryLocks.ts
+var tryAcquireAdvisoryLock = async (execute, options) => {
+  const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( defaultDatabaseLockOptions.timeoutMs));
+  const advisoryLock2 = options.mode === "Permanent" ? "pg_advisory_lock" : "pg_advisory_xact_lock";
+  try {
+    await single(
+      execute.query(
+        sql("SELECT %s(%s) AS locked", advisoryLock2, options.lockId),
+        { timeoutMs }
+      )
+    );
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "57014")
+      return false;
+    throw error;
+  }
+};
+var releaseAdvisoryLock = async (execute, options) => {
+  const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( defaultDatabaseLockOptions.timeoutMs));
+  try {
+    await single(
+      execute.query(
+        sql("SELECT pg_advisory_unlock(%s) AS locked", options.lockId),
+        { timeoutMs }
+      )
+    );
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "57014")
+      return false;
+    throw error;
+  }
+};
+var acquireAdvisoryLock = async (execute, options) => {
+  const lockAcquired = await tryAcquireAdvisoryLock(execute, options);
+  if (!lockAcquired) {
+    throw new Error(
+      "Failed to acquire advisory lock within the specified timeout. Migration aborted."
+    );
+  }
+};
+var AdvisoryLock = {
+  acquire: acquireAdvisoryLock,
+  tryAcquire: tryAcquireAdvisoryLock,
+  release: releaseAdvisoryLock,
+  withAcquire: async (execute, handle, options) => {
+    await acquireAdvisoryLock(execute, options);
+    try {
+      return await handle();
+    } finally {
+      if (options.mode === "Permanent")
+        await releaseAdvisoryLock(execute, options);
+    }
+  }
+};
+var advisoryLock = (execute, options) => ({
+  acquire: (acquireOptions) => acquireAdvisoryLock(execute, {
+    ...options,
+    ..._nullishCoalesce(acquireOptions, () => ( {}))
+  }),
+  tryAcquire: (acquireOptions) => tryAcquireAdvisoryLock(execute, {
+    ...options,
+    ..._nullishCoalesce(acquireOptions, () => ( {}))
+  }),
+  release: () => releaseAdvisoryLock(execute, options),
+  withAcquire: async (handle, acquireOptions) => {
+    await acquireAdvisoryLock(execute, {
+      ...options,
+      ..._nullishCoalesce(acquireOptions, () => ( {}))
+    });
+    try {
+      return await handle();
+    } finally {
+      await releaseAdvisoryLock(execute, options);
+    }
+  }
+});
+
+// src/storage/postgresql/pg/connections/connection.ts
+var _pg = require('pg'); var _pg2 = _interopRequireDefault(_pg);
+
+// src/storage/postgresql/pg/execute/execute.ts
+
+var isNodePostgresNativePool = (poolOrClient) => {
+  return poolOrClient instanceof _pg2.default.Pool;
+};
+var isNodePostgresClient = (poolOrClient) => poolOrClient instanceof _pg2.default.Client;
+var isNodePostgresPoolClient = (poolOrClient) => "release" in poolOrClient && typeof poolOrClient.release === "function";
+var nodePostgresExecute = async (poolOrClient, handle) => {
+  const client = isNodePostgresNativePool(poolOrClient) ? await poolOrClient.connect() : poolOrClient;
+  try {
+    return await handle(client);
+  } finally {
+    if (isNodePostgresNativePool(poolOrClient) && isNodePostgresPoolClient(client))
+      client.release();
+  }
+};
+var nodePostgresSQLExecutor = () => ({
+  type: NodePostgresConnectorType,
+  query: batch,
+  batchQuery: batch,
+  command: batch,
+  batchCommand: batch
+});
+async function batch(client, sqlOrSqls, options) {
+  const sqls = Array.isArray(sqlOrSqls) ? sqlOrSqls : [sqlOrSqls];
+  const results = Array(
+    sqls.length
+  );
+  if (_optionalChain([options, 'optionalAccess', _11 => _11.timeoutMs])) {
+    await client.query(`SET statement_timeout = ${_optionalChain([options, 'optionalAccess', _12 => _12.timeoutMs])}`);
+  }
+  for (let i = 0; i < sqls.length; i++) {
+    tracer.info("db:sql:query", { sql: sqls[i] });
+    const result = await client.query(sqls[i]);
+    results[i] = { rowCount: result.rowCount, rows: result.rows };
+  }
+  return Array.isArray(sqlOrSqls) ? results : results[0];
+}
+
+// src/storage/postgresql/pg/connections/transaction.ts
+var nodePostgresTransaction = (connection) => (getClient, options) => ({
+  connection: connection(),
+  type: NodePostgresConnectorType,
+  begin: async () => {
+    const client = await getClient;
+    await client.query("BEGIN");
+  },
+  commit: async () => {
+    const client = await getClient;
+    await client.query("COMMIT");
+    if (_optionalChain([options, 'optionalAccess', _13 => _13.close])) await _optionalChain([options, 'optionalAccess', _14 => _14.close, 'call', _15 => _15(client)]);
+  },
+  rollback: async (error) => {
+    const client = await getClient;
+    await client.query("ROLLBACK");
+    if (_optionalChain([options, 'optionalAccess', _16 => _16.close])) await _optionalChain([options, 'optionalAccess', _17 => _17.close, 'call', _18 => _18(client, error)]);
+  },
+  execute: sqlExecutor(nodePostgresSQLExecutor(), {
+    connect: () => getClient
+  })
+});
+
+// src/storage/postgresql/pg/connections/connection.ts
+var NodePostgresConnectorType = "PostgreSQL:pg";
+var nodePostgresClientConnection = (options) => {
+  const { connect, close } = options;
+  return createConnection({
+    type: NodePostgresConnectorType,
+    connect,
+    close,
+    initTransaction: (connection) => nodePostgresTransaction(connection),
+    executor: nodePostgresSQLExecutor
+  });
+};
+var nodePostgresPoolClientConnection = (options) => {
+  const { connect, close } = options;
+  return createConnection({
+    type: NodePostgresConnectorType,
+    connect,
+    close,
+    initTransaction: (connection) => nodePostgresTransaction(connection),
+    executor: nodePostgresSQLExecutor
+  });
+};
+function nodePostgresConnection(options) {
+  return options.type === "Client" ? nodePostgresClientConnection(options) : nodePostgresPoolClientConnection(options);
+}
+var checkConnection = async (connectionString) => {
+  const client = new _pg2.default.Client({
+    connectionString
+  });
+  try {
+    await client.connect();
+    return { successful: true };
+  } catch (error) {
+    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+    return {
+      successful: false,
+      errorType: code === "ECONNREFUSED" ? "ConnectionRefused" : code === "28P01" ? "Authentication" : "Unknown",
+      code,
+      error
+    };
+  } finally {
+    await client.end();
+  }
+};
+
+// src/storage/postgresql/pg/connections/pool.ts
+
+
+// src/storage/postgresql/pg/serialization/index.ts
+
+var setNodePostgresTypeParser = (jsonSerializer2) => {
+  _pg2.default.types.setTypeParser(20, (val) => BigInt(val));
+  _pg2.default.types.setTypeParser(3802, (val) => jsonSerializer2.deserialize(val));
+  _pg2.default.types.setTypeParser(114, (val) => jsonSerializer2.deserialize(val));
+};
+
+// src/storage/postgresql/pg/connections/pool.ts
+var nodePostgresNativePool = (options) => {
+  const { connectionString, database } = options;
+  const pool = getPool({ connectionString, database });
+  const getConnection = () => nodePostgresConnection({
+    type: "PoolClient",
+    connect: pool.connect(),
+    close: (client) => Promise.resolve(client.release())
+  });
+  const open = () => Promise.resolve(getConnection());
+  const close = () => endPool({ connectionString, database });
+  return createConnectionPool({
+    type: NodePostgresConnectorType,
+    connection: open,
+    close,
+    getConnection
+  });
+};
+var nodePostgresAmbientNativePool = (options) => {
+  const { pool } = options;
+  return createConnectionPool({
+    type: NodePostgresConnectorType,
+    getConnection: () => nodePostgresConnection({
+      type: "PoolClient",
+      connect: pool.connect(),
+      close: (client) => Promise.resolve(client.release())
+    })
+  });
+};
+var nodePostgresAmbientConnectionPool = (options) => {
+  const { connection } = options;
+  return createConnectionPool({
+    type: NodePostgresConnectorType,
+    getConnection: () => connection,
+    execute: connection.execute,
+    transaction: () => connection.transaction(),
+    withTransaction: (handle) => connection.withTransaction(handle)
+  });
+};
+var nodePostgresClientPool = (options) => {
+  const { connectionString, database } = options;
+  return createConnectionPool({
+    type: NodePostgresConnectorType,
+    getConnection: () => {
+      const connect = Promise.resolve(
+        new _pg2.default.Client({ connectionString, database })
+      ).then(async (client) => {
+        await client.connect();
+        return client;
+      });
+      return nodePostgresConnection({
+        type: "Client",
+        connect,
+        close: (client) => client.end()
+      });
+    }
+  });
+};
+var nodePostgresAmbientClientPool = (options) => {
+  const { client } = options;
+  const getConnection = () => {
+    const connect = Promise.resolve(client);
+    return nodePostgresConnection({
+      type: "Client",
+      connect,
+      close: () => Promise.resolve()
+    });
+  };
+  const open = () => Promise.resolve(getConnection());
+  const close = () => Promise.resolve();
+  return createConnectionPool({
+    type: NodePostgresConnectorType,
+    connection: open,
+    close,
+    getConnection
+  });
+};
+function nodePostgresPool(options) {
+  const { connectionString, database, serializer } = options;
+  setNodePostgresTypeParser(_nullishCoalesce(serializer, () => ( JSONSerializer)));
+  if ("client" in options && options.client)
+    return nodePostgresAmbientClientPool({ client: options.client });
+  if ("connection" in options && options.connection)
+    return nodePostgresAmbientConnectionPool({
+      connection: options.connection
+    });
+  if ("pooled" in options && options.pooled === false)
+    return nodePostgresClientPool({ connectionString, database });
+  if ("pool" in options && options.pool)
+    return nodePostgresAmbientNativePool({ pool: options.pool });
+  return nodePostgresNativePool({
+    connectionString,
+    database
+  });
+}
+var pools = /* @__PURE__ */ new Map();
+var usageCounter = /* @__PURE__ */ new Map();
+var getPool = (connectionStringOrOptions) => {
+  const connectionString = typeof connectionStringOrOptions === "string" ? connectionStringOrOptions : connectionStringOrOptions.connectionString;
+  const poolOptions = typeof connectionStringOrOptions === "string" ? { connectionString } : connectionStringOrOptions;
+  const database = _nullishCoalesce(poolOptions.database, () => ( (poolOptions.connectionString ? getDatabaseNameOrDefault(poolOptions.connectionString) : void 0)));
+  const lookupKey = key(connectionString, database);
+  updatePoolUsageCounter(lookupKey, 1);
+  return _nullishCoalesce(pools.get(lookupKey), () => ( pools.set(lookupKey, new _pg2.default.Pool(poolOptions)).get(lookupKey)));
+};
+var endPool = async ({
+  connectionString,
+  database,
+  force
+}) => {
+  database = _nullishCoalesce(database, () => ( getDatabaseNameOrDefault(connectionString)));
+  const lookupKey = key(connectionString, database);
+  const pool = pools.get(lookupKey);
+  if (pool && (updatePoolUsageCounter(lookupKey, -1) <= 0 || force === true)) {
+    await onEndPool(lookupKey, pool);
+  }
+};
+var onEndPool = async (lookupKey, pool) => {
+  try {
+    await pool.end();
+  } catch (error) {
+    tracer.error("connection-closing-error", { lookupKey, error });
+  }
+  pools.delete(lookupKey);
+};
+var endAllPools = () => Promise.all(
+  [...pools.entries()].map(([lookupKey, pool]) => onEndPool(lookupKey, pool))
+);
+var key = (connectionString, database) => `${connectionString}|${_nullishCoalesce(database, () => ( defaultPostgreSqlDatabase))}`;
+var updatePoolUsageCounter = (lookupKey, by) => {
+  const currentCounter = _nullishCoalesce(usageCounter.get(lookupKey), () => ( 0));
+  const newCounter = currentCounter + by;
+  usageCounter.set(lookupKey, currentCounter + by);
+  return newCounter;
+};
+
+// src/storage/postgresql/index.ts
+var postgresPool = nodePostgresPool;
+
+// src/index.ts
+var connectionPool = (options) => (
+  // TODO: this should have the pattern matching and verification
+  postgresPool(options)
+);
+var dumbo = (options) => connectionPool(options);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.__glob = __glob; exports.composeJSONReplacers = composeJSONReplacers; exports.composeJSONRevivers = composeJSONRevivers; exports.JSONReplacer = JSONReplacer; exports.JSONReviver = JSONReviver; exports.JSONReplacers = JSONReplacers; exports.JSONRevivers = JSONRevivers; exports.jsonSerializer = jsonSerializer; exports.JSONSerializer = JSONSerializer; exports.RawJSONSerializer = RawJSONSerializer; exports.sql = sql; exports.rawSql = rawSql; exports.isSQL = isSQL; exports.literal = literal; exports.identifier = identifier; exports.plainString = plainString; exports.SQL = SQL; exports.sqlExecutor = sqlExecutor; exports.sqlExecutorInNewConnection = sqlExecutorInNewConnection; exports.executeInNewDbClient = executeInNewDbClient; exports.executeInNewConnection = executeInNewConnection; exports.executeInTransaction = executeInTransaction; exports.transactionFactoryWithDbClient = transactionFactoryWithDbClient; exports.transactionFactoryWithNewConnection = transactionFactoryWithNewConnection; exports.createConnection = createConnection; exports.createConnectionPool = createConnectionPool; exports.toConnectorType = toConnectorType; exports.fromConnectorType = fromConnectorType; exports.getDriverName = getDriverName; exports.mapRows = mapRows; exports.toCamelCase = toCamelCase; exports.mapToCamelCase = mapToCamelCase; exports.firstOrNull = firstOrNull; exports.first = first; exports.singleOrNull = singleOrNull; exports.single = single; exports.count = count; exports.exists = exists; exports.sqlMigration = sqlMigration; exports.MIGRATIONS_LOCK_ID = MIGRATIONS_LOCK_ID; exports.runSQLMigrations = runSQLMigrations; exports.combineMigrations = combineMigrations; exports.schemaComponent = schemaComponent; exports.color = color; exports.prettyJson = prettyJson; exports.tracer = tracer; exports.LogLevel = LogLevel; exports.LogStyle = LogStyle; exports.defaultDatabaseLockOptions = defaultDatabaseLockOptions; exports.migrationTableSchemaComponent = migrationTableSchemaComponent; exports.runPostgreSQLMigrations = runPostgreSQLMigrations; exports.defaultPostgreSqlDatabase = defaultPostgreSqlDatabase; exports.tableExistsSQL = tableExistsSQL; exports.tableExists = tableExists; exports.functionExistsSQL = functionExistsSQL; exports.functionExists = functionExists; exports.defaultPostgreSQLConenctionString = defaultPostgreSQLConenctionString; exports.getDatabaseNameOrDefault = getDatabaseNameOrDefault; exports.tryAcquireAdvisoryLock = tryAcquireAdvisoryLock; exports.releaseAdvisoryLock = releaseAdvisoryLock; exports.acquireAdvisoryLock = acquireAdvisoryLock; exports.AdvisoryLock = AdvisoryLock; exports.advisoryLock = advisoryLock; exports.isNodePostgresNativePool = isNodePostgresNativePool; exports.isNodePostgresClient = isNodePostgresClient; exports.isNodePostgresPoolClient = isNodePostgresPoolClient; exports.nodePostgresExecute = nodePostgresExecute; exports.nodePostgresSQLExecutor = nodePostgresSQLExecutor; exports.nodePostgresTransaction = nodePostgresTransaction; exports.NodePostgresConnectorType = NodePostgresConnectorType; exports.nodePostgresClientConnection = nodePostgresClientConnection; exports.nodePostgresPoolClientConnection = nodePostgresPoolClientConnection; exports.nodePostgresConnection = nodePostgresConnection; exports.checkConnection = checkConnection; exports.setNodePostgresTypeParser = setNodePostgresTypeParser; exports.nodePostgresNativePool = nodePostgresNativePool; exports.nodePostgresAmbientNativePool = nodePostgresAmbientNativePool; exports.nodePostgresAmbientConnectionPool = nodePostgresAmbientConnectionPool; exports.nodePostgresClientPool = nodePostgresClientPool; exports.nodePostgresAmbientClientPool = nodePostgresAmbientClientPool; exports.nodePostgresPool = nodePostgresPool; exports.getPool = getPool; exports.endPool = endPool; exports.onEndPool = onEndPool; exports.endAllPools = endAllPools; exports.postgresPool = postgresPool; exports.connectionPool = connectionPool; exports.dumbo = dumbo;
+//# sourceMappingURL=chunk-DYX7V3LM.cjs.map