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

package/dist/index.js

@@ -1,1298 +1,92 @@
-// 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) => opts?.disableBigIntSerialization == true ? opts.replacer ? opts.replacer : void 0 : opts?.replacer ? composeJSONReplacers(JSONReplacers.bigInt, opts.replacer) : JSONReplacers.bigInt;
-var JSONReviver = (opts) => opts?.disableBigIntSerialization == true ? opts.reviver ? opts.reviver : void 0 : opts?.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 () => client ?? (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/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) => g[1]?.toUpperCase() ?? "");
-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 ? 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 ? 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
-import ansis from "ansis";
-var enableColors = true;
-var color = {
-  set level(value) {
-    enableColors = value === 1;
-  },
-  hex: (value) => (text) => enableColors ? ansis.hex(value)(text) : text,
-  red: (value) => enableColors ? ansis.red(value) : value,
-  green: (value) => enableColors ? ansis.green(value) : value,
-  blue: (value) => enableColors ? ansis.blue(value) : value,
-  cyan: (value) => enableColors ? ansis.cyan(value) : value,
-  yellow: (value) => enableColors ? ansis.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, options?.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 = 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,
-    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/postgres/core/connections/connectionString.ts
-import pgcs from "pg-connection-string";
-
-// src/postgres/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: {
-      ...options ?? {},
-      lockId: MIGRATIONS_LOCK_ID
-    }
-  },
-  dryRun: options?.dryRun
-});
-
-// src/postgres/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/postgres/core/connections/connectionString.ts
-var defaultPostgreSQLConenctionString = "postgresql://postgres@localhost:5432/postgres";
-var getDatabaseNameOrDefault = (connectionString) => pgcs.parse(connectionString).database ?? defaultPostgreSqlDatabase;
-
-// src/postgres/core/locks/advisoryLocks.ts
-var tryAcquireAdvisoryLock = async (execute, options) => {
-  const timeoutMs = 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 = 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,
-    ...acquireOptions ?? {}
-  }),
-  tryAcquire: (acquireOptions) => tryAcquireAdvisoryLock(execute, {
-    ...options,
-    ...acquireOptions ?? {}
-  }),
-  release: () => releaseAdvisoryLock(execute, options),
-  withAcquire: async (handle, acquireOptions) => {
-    await acquireAdvisoryLock(execute, {
-      ...options,
-      ...acquireOptions ?? {}
-    });
-    try {
-      return await handle();
-    } finally {
-      await releaseAdvisoryLock(execute, options);
-    }
-  }
-});
-
-// src/postgres/pg/connections/connection.ts
-import pg2 from "pg";
-
-// src/postgres/pg/execute/execute.ts
-import pg from "pg";
-var isNodePostgresNativePool = (poolOrClient) => {
-  return poolOrClient instanceof pg.Pool;
-};
-var isNodePostgresClient = (poolOrClient) => poolOrClient instanceof pg.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 (options?.timeoutMs) {
-    await client.query(`SET statement_timeout = ${options?.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/postgres/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 (options?.close) await options?.close(client);
-  },
-  rollback: async (error) => {
-    const client = await getClient;
-    await client.query("ROLLBACK");
-    if (options?.close) await options?.close(client, error);
-  },
-  execute: sqlExecutor(nodePostgresSQLExecutor(), {
-    connect: () => getClient
-  })
-});
-
-// src/postgres/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.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/postgres/pg/connections/pool.ts
-import pg4 from "pg";
-
-// src/postgres/pg/serialization/index.ts
-import pg3 from "pg";
-var setNodePostgresTypeParser = (jsonSerializer2) => {
-  pg3.types.setTypeParser(20, (val) => BigInt(val));
-  pg3.types.setTypeParser(3802, (val) => jsonSerializer2.deserialize(val));
-  pg3.types.setTypeParser(114, (val) => jsonSerializer2.deserialize(val));
-};
-
-// src/postgres/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 pg4.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(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 = poolOptions.database ?? (poolOptions.connectionString ? getDatabaseNameOrDefault(poolOptions.connectionString) : void 0);
-  const lookupKey = key(connectionString, database);
-  updatePoolUsageCounter(lookupKey, 1);
-  return pools.get(lookupKey) ?? pools.set(lookupKey, new pg4.Pool(poolOptions)).get(lookupKey);
-};
-var endPool = async ({
-  connectionString,
-  database,
-  force
-}) => {
-  database = 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}|${database ?? defaultPostgreSqlDatabase}`;
-var updatePoolUsageCounter = (lookupKey, by) => {
-  const currentCounter = usageCounter.get(lookupKey) ?? 0;
-  const newCounter = currentCounter + by;
-  usageCounter.set(lookupKey, currentCounter + by);
-  return newCounter;
-};
-
-// src/postgres/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);
+import {
+  AdvisoryLock,
+  JSONReplacer,
+  JSONReplacers,
+  JSONReviver,
+  JSONRevivers,
+  JSONSerializer,
+  LogLevel,
+  LogStyle,
+  MIGRATIONS_LOCK_ID,
+  NodePostgresConnectorType,
+  RawJSONSerializer,
+  SQL,
+  acquireAdvisoryLock,
+  advisoryLock,
+  checkConnection,
+  color,
+  combineMigrations,
+  composeJSONReplacers,
+  composeJSONRevivers,
+  connectionPool,
+  count,
+  createConnection,
+  createConnectionPool,
+  defaultDatabaseLockOptions,
+  defaultPostgreSQLConenctionString,
+  defaultPostgreSqlDatabase,
+  dumbo,
+  endAllPools,
+  endPool,
+  executeInNewConnection,
+  executeInNewDbClient,
+  executeInTransaction,
+  exists,
+  first,
+  firstOrNull,
+  fromConnectorType,
+  functionExists,
+  functionExistsSQL,
+  getDatabaseNameOrDefault,
+  getDriverName,
+  getPool,
+  identifier,
+  isNodePostgresClient,
+  isNodePostgresNativePool,
+  isNodePostgresPoolClient,
+  isSQL,
+  jsonSerializer,
+  literal,
+  mapRows,
+  mapToCamelCase,
+  migrationTableSchemaComponent,
+  nodePostgresAmbientClientPool,
+  nodePostgresAmbientConnectionPool,
+  nodePostgresAmbientNativePool,
+  nodePostgresClientConnection,
+  nodePostgresClientPool,
+  nodePostgresConnection,
+  nodePostgresExecute,
+  nodePostgresNativePool,
+  nodePostgresPool,
+  nodePostgresPoolClientConnection,
+  nodePostgresSQLExecutor,
+  nodePostgresTransaction,
+  onEndPool,
+  plainString,
+  postgresPool,
+  prettyJson,
+  rawSql,
+  releaseAdvisoryLock,
+  runPostgreSQLMigrations,
+  runSQLMigrations,
+  schemaComponent,
+  setNodePostgresTypeParser,
+  single,
+  singleOrNull,
+  sql,
+  sqlExecutor,
+  sqlExecutorInNewConnection,
+  sqlMigration,
+  tableExists,
+  tableExistsSQL,
+  toCamelCase,
+  toConnectorType,
+  tracer,
+  transactionFactoryWithDbClient,
+  transactionFactoryWithNewConnection,
+  tryAcquireAdvisoryLock
+} from "./chunk-IIFZU7RA.js";
 export {
   AdvisoryLock,
   JSONReplacer,
@@ -1329,9 +123,11 @@ export {
   exists,
   first,
   firstOrNull,
+  fromConnectorType,
   functionExists,
   functionExistsSQL,
   getDatabaseNameOrDefault,
+  getDriverName,
   getPool,
   identifier,
   isNodePostgresClient,
@@ -1374,6 +170,7 @@ export {
   tableExists,
   tableExistsSQL,
   toCamelCase,
+  toConnectorType,
   tracer,
   transactionFactoryWithDbClient,
   transactionFactoryWithNewConnection,