@event-driven-io/dumbo 0.13.0-beta.4 → 0.13.0-beta.41

package/dist/chunk-OJ34O3Q2.cjs

@@ -1,2011 +0,0 @@
-"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(); } } 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; }// src/core/drivers/index.ts
-function toDatabaseDriverType(databaseType, driverName) {
-  return `${databaseType}:${driverName}`;
-}
-function fromDatabaseDriverType(databaseDriverType) {
-  const parts = databaseDriverType.split(":");
-  return {
-    databaseType: parts[0],
-    driverName: parts[1]
-  };
-}
-function getDatabaseDriverName(databaseDriverType) {
-  const { driverName } = fromDatabaseDriverType(databaseDriverType);
-  return driverName;
-}
-function getDatabaseType(databaseDriverType) {
-  const { databaseType } = fromDatabaseDriverType(databaseDriverType);
-  return databaseType;
-}
-
-// 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) => (key, value) => (
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  replacers.reduce((accValue, replacer) => replacer(key, accValue), value)
-);
-var composeJSONRevivers = (...revivers) => (key, value) => (
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  revivers.reduce((accValue, reviver) => reviver(key, 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/parametrizedSQL/parametrizedSQL.ts
-var ParametrizedSQLBuilder = ({
-  mapParamPlaceholder
-}) => {
-  const sql = [];
-  const params = [];
-  return {
-    addSQL(str) {
-      sql.push(str);
-      return this;
-    },
-    addParam(value) {
-      sql.push(mapParamPlaceholder(params.length, value));
-      params.push(value);
-      return this;
-    },
-    addParams(values) {
-      const placeholders = values.map(
-        (value, i) => mapParamPlaceholder(params.length + i, value)
-      );
-      this.addSQL(`(${placeholders.join(", ")})`);
-      params.push(...values);
-      return this;
-    },
-    build() {
-      return {
-        query: sql.join(""),
-        params
-      };
-    }
-  };
-};
-
-// src/core/sql/tokens/sqlToken.ts
-var SQLToken = (sqlTokenType, map) => {
-  const factory = (input) => {
-    let props;
-    if (map !== void 0) {
-      props = map(input);
-    } else if (input === void 0 || input === null) {
-      props = {};
-    } else if (typeof input === "object" && !Array.isArray(input)) {
-      props = input;
-    } else {
-      throw new Error(
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        `Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`
-      );
-    }
-    return {
-      sqlTokenType,
-      [sqlTokenType]: true,
-      ...props
-    };
-  };
-  const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
-  return { from: factory, check, type: sqlTokenType };
-};
-SQLToken.check = (token) => token !== null && typeof token === "object" && "sqlTokenType" in token;
-var SQLIdentifier = SQLToken(
-  "SQL_IDENTIFIER",
-  (value) => ({
-    value
-  })
-);
-var SQLPlain = SQLToken("SQL_RAW", (value) => ({
-  value
-}));
-var SQLLiteral = SQLToken(
-  "SQL_LITERAL",
-  (value) => ({
-    value
-  })
-);
-var SQLArray = SQLToken("SQL_ARRAY", (value) => ({
-  value
-}));
-var SQLIn = SQLToken(
-  "SQL_IN",
-  ({ column, values }) => ({
-    column: SQLIdentifier.from(column),
-    values: SQLArray.from(values)
-  })
-);
-
-// src/core/sql/tokens/columnTokens.ts
-var ColumnTypeToken = (sqlTokenType, jsTypeName, map) => {
-  const factory = (input) => {
-    let props;
-    if (map !== void 0) {
-      props = map(input);
-    } else if (input === void 0 || input === null) {
-      props = {};
-    } else if (typeof input === "object" && !Array.isArray(input)) {
-      props = input;
-    } else {
-      throw new Error(
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        `Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`
-      );
-    }
-    return {
-      sqlTokenType,
-      [sqlTokenType]: true,
-      jsTypeName,
-      ...props
-    };
-  };
-  const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
-  return { from: factory, check, type: sqlTokenType };
-};
-var SerialToken = ColumnTypeToken(
-  "SQL_COLUMN_SERIAL",
-  "value_type:js:number"
-);
-var BigSerialToken = ColumnTypeToken(
-  "SQL_COLUMN_BIGSERIAL",
-  "value_type:js:bigint"
-);
-var IntegerToken = ColumnTypeToken(
-  "SQL_COLUMN_INTEGER",
-  "value_type:js:number"
-);
-var BigIntegerToken = ColumnTypeToken(
-  "SQL_COLUMN_BIGINT",
-  "value_type:js:bigint"
-);
-var JSONBToken = {
-  type: "SQL_COLUMN_JSONB",
-  from: () => {
-    return {
-      sqlTokenType: "SQL_COLUMN_JSONB",
-      ["SQL_COLUMN_JSONB"]: true
-    };
-  },
-  check: (token) => SQLToken.check(token) && token.sqlTokenType === "SQL_COLUMN_JSONB"
-};
-var TimestampToken = ColumnTypeToken(
-  "SQL_COLUMN_TIMESTAMP",
-  "value_type:js:date"
-);
-var TimestamptzToken = ColumnTypeToken(
-  "SQL_COLUMN_TIMESTAMPTZ",
-  "value_type:js:date"
-);
-var VarcharToken = ColumnTypeToken(
-  "SQL_COLUMN_VARCHAR",
-  "value_type:js:string",
-  (length) => ({
-    length: _nullishCoalesce(length, () => ( "max")),
-    jsTypeName: "value_type:js:string"
-  })
-);
-var AutoIncrementSQLColumnToken = ColumnTypeToken(
-  "SQL_COLUMN_AUTO_INCREMENT",
-  "value_type:js:bigint"
-);
-var SQLColumnTypeTokens = {
-  AutoIncrement: AutoIncrementSQLColumnToken,
-  BigInteger: BigIntegerToken,
-  BigSerial: BigSerialToken,
-  Integer: IntegerToken,
-  JSONB: JSONBToken,
-  Serial: SerialToken,
-  Timestamp: TimestampToken,
-  Timestamptz: TimestamptzToken,
-  Varchar: VarcharToken
-};
-var SQLColumnTypeTokensFactory = {
-  AutoIncrement: AutoIncrementSQLColumnToken.from,
-  BigInteger: BigIntegerToken.from(),
-  BigSerial: BigSerialToken.from(),
-  Integer: IntegerToken.from(),
-  JSONB: JSONBToken.from,
-  Serial: SerialToken.from(),
-  Timestamp: TimestampToken.from(),
-  Timestamptz: TimestamptzToken.from(),
-  Varchar: VarcharToken.from
-};
-var SQLColumnToken = SQLToken("SQL_COLUMN");
-
-// src/core/sql/processors/sqlProcessor.ts
-var SQLProcessor = (options) => options;
-
-// src/core/sql/processors/defaultProcessors.ts
-var ExpandArrayProcessor = SQLProcessor({
-  canHandle: "SQL_ARRAY",
-  handle: (token, { builder, mapper }) => {
-    if (token.value.length === 0) {
-      throw new Error(
-        "Empty arrays are not supported. If you're using it with SELECT IN statement Use SQL.in(column, array) helper instead."
-      );
-    }
-    builder.addParams(mapper.mapValue(token.value));
-  }
-});
-var ExpandSQLInProcessor = SQLProcessor({
-  canHandle: "SQL_IN",
-  handle: (token, context) => {
-    const { builder, mapper, processorsRegistry } = context;
-    const { values: inValues, column } = token;
-    if (inValues.value.length === 0) {
-      builder.addParam(mapper.mapValue(false));
-      return;
-    }
-    builder.addSQL(mapper.mapValue(column.value));
-    builder.addSQL(` IN `);
-    const arrayProcessor = processorsRegistry.get(SQLArray.type);
-    if (!arrayProcessor) {
-      throw new Error(
-        "No sql processor registered for an array. Cannot expand IN statement"
-      );
-    }
-    arrayProcessor.handle(inValues, { builder, mapper, processorsRegistry });
-  }
-});
-var FormatIdentifierProcessor = SQLProcessor({
-  canHandle: "SQL_IDENTIFIER",
-  handle: (token, { builder, mapper }) => {
-    builder.addSQL(mapper.mapValue(token));
-  }
-});
-var MapLiteralProcessor = SQLProcessor({
-  canHandle: "SQL_LITERAL",
-  handle: (token, { builder, mapper }) => builder.addParam(mapper.mapValue(token.value))
-});
-
-// src/core/sql/processors/sqlProcessorRegistry.ts
-var SQLProcessorsRegistry = (options) => {
-  const processors = options ? new Map(options.from.all()) : /* @__PURE__ */ new Map();
-  function register(...args) {
-    if (args.length === 1 && typeof args[0] === "object" && !Array.isArray(args[0])) {
-      Object.entries(args[0]).forEach(
-        ([_, processor]) => {
-          processors.set(processor.canHandle, processor);
-        }
-      );
-    } else {
-      args.forEach(
-        (p) => processors.set(p.canHandle, p)
-      );
-    }
-    return registry;
-  }
-  const registry = {
-    register,
-    get: (tokenType) => {
-      return _nullishCoalesce(processors.get(tokenType), () => ( null));
-    },
-    all: () => processors
-  };
-  return registry;
-};
-
-// src/core/sql/processors/columnProcessors.ts
-var mapDefaultSQLColumnProcessors = (mapColumnType) => ({
-  AutoIncrement: SQLProcessor({
-    canHandle: "SQL_COLUMN_AUTO_INCREMENT",
-    handle: (token, context) => {
-      mapColumnType(token, context);
-    }
-  }),
-  BigInteger: SQLProcessor({
-    canHandle: "SQL_COLUMN_BIGINT",
-    handle: (token, context) => mapColumnType(token, context)
-  }),
-  BigSerial: SQLProcessor({
-    canHandle: "SQL_COLUMN_BIGSERIAL",
-    handle: (token, context) => mapColumnType(token, context)
-  }),
-  Serial: SQLProcessor({
-    canHandle: "SQL_COLUMN_SERIAL",
-    handle: (token, context) => mapColumnType(token, context)
-  }),
-  Integer: SQLProcessor({
-    canHandle: "SQL_COLUMN_INTEGER",
-    handle: (token, context) => mapColumnType(token, context)
-  }),
-  JSONB: SQLProcessor({
-    canHandle: "SQL_COLUMN_JSONB",
-    handle: (token, context) => mapColumnType(token, context)
-  }),
-  Timestamp: SQLProcessor({
-    canHandle: "SQL_COLUMN_TIMESTAMP",
-    handle: (token, context) => mapColumnType(token, context)
-  }),
-  Timestamptz: SQLProcessor({
-    canHandle: "SQL_COLUMN_TIMESTAMPTZ",
-    handle: (token, context) => mapColumnType(token, context)
-  }),
-  Varchar: SQLProcessor({
-    canHandle: "SQL_COLUMN_VARCHAR",
-    handle: (token, context) => mapColumnType(token, context)
-  })
-});
-
-// src/core/sql/processors/index.ts
-var defaultProcessorsRegistry = globalThis.defaultProcessorsRegistry = _nullishCoalesce(globalThis.defaultProcessorsRegistry, () => ( SQLProcessorsRegistry().register(
-  FormatIdentifierProcessor,
-  MapLiteralProcessor,
-  ExpandArrayProcessor,
-  ExpandSQLInProcessor
-)));
-
-// src/core/sql/tokenizedSQL/tokenizedSQL.ts
-var TokenizedSQLBuilder = () => {
-  const sqlChunks = [];
-  const sqlTokens = [];
-  return {
-    addSQL(str) {
-      sqlChunks.push(str);
-    },
-    addSQLs(str) {
-      sqlChunks.push(...str);
-    },
-    addToken(value) {
-      sqlTokens.push(value);
-    },
-    addTokens(vals) {
-      sqlTokens.push(...vals);
-    },
-    build() {
-      return sqlChunks.length > 0 ? {
-        __brand: "tokenized-sql",
-        sqlChunks,
-        sqlTokens
-      } : TokenizedSQL.empty;
-    }
-  };
-};
-var TokenizedSQL = (strings, values) => {
-  const builder = TokenizedSQLBuilder();
-  for (let i = 0; i < strings.length; i++) {
-    if (strings[i] !== "") builder.addSQL(strings[i]);
-    if (i >= values.length) break;
-    const value = values[i];
-    if (isTokenizedSQL(value)) {
-      builder.addSQLs(value.sqlChunks);
-      builder.addTokens(value.sqlTokens);
-    } else if (SQLPlain.check(value)) {
-      builder.addSQL(value.value);
-    } else {
-      builder.addSQL(TokenizedSQL.paramPlaceholder);
-      builder.addToken(
-        SQLToken.check(value) ? value : Array.isArray(value) ? SQLArray.from(value) : SQLLiteral.from(value)
-      );
-    }
-  }
-  return builder.build();
-};
-var isTokenizedSQL = (value) => {
-  return value !== null && typeof value === "object" && "__brand" in value && value.__brand === "tokenized-sql";
-};
-TokenizedSQL.paramPlaceholder = `__P__`;
-TokenizedSQL.empty = {
-  __brand: "tokenized-sql",
-  sqlChunks: [""],
-  sqlTokens: []
-};
-
-// src/core/sql/sql.ts
-function SQL(strings, ...values) {
-  const parametrized = TokenizedSQL(strings, values);
-  return parametrized;
-}
-var isSQL = (value) => {
-  if (value === void 0 || value === null) {
-    return false;
-  }
-  return isTokenizedSQL(value);
-};
-var emptySQL = {
-  __brand: "tokenized-sql",
-  sqlChunks: [""],
-  sqlTokens: []
-};
-var mergeSQL = (sqls, separator = " ") => {
-  const parametrized = sqls.filter((sql) => !isEmpty(sql)).map((sql) => sql);
-  const params = parametrized.flatMap((p) => p.sqlTokens);
-  const sqlChunks = parametrized.flatMap(
-    (p, i) => i == parametrized.length - 1 || separator === "" ? p.sqlChunks : [...p.sqlChunks, separator]
-  );
-  const merged = sqlChunks.length > 0 ? {
-    __brand: "tokenized-sql",
-    sqlChunks,
-    sqlTokens: params
-  } : TokenizedSQL.empty;
-  return merged;
-};
-var concatSQL = (...sqls) => mergeSQL(sqls, "");
-var isEmpty = (sql) => {
-  if (isTokenizedSQL(sql)) {
-    const parametrized = sql;
-    return parametrized.sqlChunks.every((chunk) => chunk.trim() === "") && parametrized.sqlTokens.length === 0;
-  }
-  return false;
-};
-SQL.EMPTY = emptySQL;
-SQL.concat = concatSQL;
-SQL.merge = mergeSQL;
-SQL.format = (sql, formatter, options) => formatSQL(sql, formatter, options);
-SQL.describe = (sql, formatter, options) => describeSQL(sql, formatter, options);
-SQL.in = (column, values) => SQLIn.from({ column, values });
-SQL.identifier = SQLIdentifier.from;
-SQL.plain = SQLPlain.from;
-SQL.check = {
-  isSQL,
-  isTokenizedSQL: (value) => isTokenizedSQL(value),
-  isEmpty,
-  isIdentifier: SQLIdentifier.check,
-  isPlain: SQLPlain.check,
-  isSQLIn: SQLIn.check
-};
-var columnFactory = SQLColumnToken.from;
-columnFactory.type = SQLColumnTypeTokensFactory;
-SQL.column = columnFactory;
-
-// src/core/sql/valueMappers/reservedSqlWords.ts
-var ansiSqlReservedMap = {
-  ALL: true,
-  AND: true,
-  ANY: true,
-  ARRAY: true,
-  AS: true,
-  ASC: true,
-  AUTHORIZATION: true,
-  BETWEEN: true,
-  BINARY: true,
-  BOTH: true,
-  CASE: true,
-  CAST: true,
-  CHECK: true,
-  COLLATE: true,
-  COLUMN: true,
-  CONSTRAINT: true,
-  CREATE: true,
-  CROSS: true,
-  CURRENT_DATE: true,
-  CURRENT_TIME: true,
-  CURRENT_TIMESTAMP: true,
-  CURRENT_USER: true,
-  DEFAULT: true,
-  DEFERRABLE: true,
-  DESC: true,
-  DISTINCT: true,
-  DO: true,
-  ELSE: true,
-  END: true,
-  EXCEPT: true,
-  FALSE: true,
-  FOR: true,
-  FOREIGN: true,
-  FROM: true,
-  FULL: true,
-  GRANT: true,
-  GROUP: true,
-  HAVING: true,
-  IN: true,
-  INITIALLY: true,
-  INNER: true,
-  INTERSECT: true,
-  INTO: true,
-  IS: true,
-  JOIN: true,
-  LEADING: true,
-  LEFT: true,
-  LIKE: true,
-  LOCALTIME: true,
-  LOCALTIMESTAMP: true,
-  NATURAL: true,
-  NEW: true,
-  NOT: true,
-  NULL: true,
-  NULLS: true,
-  OLD: true,
-  ON: true,
-  ONLY: true,
-  OPEN: true,
-  OR: true,
-  ORDER: true,
-  OUTER: true,
-  OVERLAPS: true,
-  PARTITION: true,
-  PLACING: true,
-  PRIMARY: true,
-  REFERENCES: true,
-  RIGHT: true,
-  SELECT: true,
-  SESSION_USER: true,
-  SIMILAR: true,
-  SOME: true,
-  TABLE: true,
-  THEN: true,
-  TO: true,
-  TRAILING: true,
-  TRUE: true,
-  UNION: true,
-  UNIQUE: true,
-  USER: true,
-  USING: true,
-  WHEN: true,
-  WHERE: true,
-  WITH: true,
-  WITHOUT: true,
-  ADD: true,
-  ALTER: true,
-  ARE: true,
-  AT: true,
-  BEGIN: true,
-  BY: true,
-  CASCADE: true,
-  CLOSE: true,
-  COMMIT: true,
-  CONNECT: true,
-  CONTINUE: true,
-  CORRESPONDING: true,
-  CURSOR: true,
-  DEALLOCATE: true,
-  DECLARE: true,
-  DELETE: true,
-  DESCRIBE: true,
-  DISCONNECT: true,
-  DROP: true,
-  ESCAPE: true,
-  EXECUTE: true,
-  EXISTS: true,
-  FETCH: true,
-  FIRST: true,
-  FLOAT: true,
-  GET: true,
-  GLOBAL: true,
-  GO: true,
-  GOTO: true,
-  HOUR: true,
-  IMMEDIATE: true,
-  INDICATOR: true,
-  INPUT: true,
-  INSERT: true,
-  INT: true,
-  INTEGER: true,
-  INTERVAL: true,
-  LANGUAGE: true,
-  LAST: true,
-  LOCAL: true,
-  MATCH: true,
-  MINUTE: true,
-  MODULE: true,
-  MONTH: true,
-  NATIONAL: true,
-  NEXT: true,
-  NO: true,
-  OF: true,
-  OUTPUT: true,
-  PARTIAL: true,
-  PREPARE: true,
-  PRESERVE: true,
-  PRIOR: true,
-  PRIVILEGES: true,
-  PROCEDURE: true,
-  PUBLIC: true,
-  READ: true,
-  REAL: true,
-  RESTRICT: true,
-  REVOKE: true,
-  ROLLBACK: true,
-  ROWS: true,
-  SCHEMA: true,
-  SCROLL: true,
-  SECOND: true,
-  SECTION: true,
-  SET: true,
-  SIZE: true,
-  SMALLINT: true,
-  SQL: true,
-  SQLCODE: true,
-  SQLERROR: true,
-  SQLSTATE: true,
-  TEMPORARY: true,
-  TIMEZONE_HOUR: true,
-  TIMEZONE_MINUTE: true,
-  TRANSACTION: true,
-  TRANSLATE: true,
-  TRANSLATION: true,
-  UNKNOWN: true,
-  UPDATE: true,
-  VALUE: true,
-  VALUES: true,
-  VARCHAR: true,
-  VARYING: true,
-  VIEW: true,
-  WHENEVER: true,
-  WORK: true,
-  WRITE: true,
-  YEAR: true,
-  ZONE: true
-};
-
-// src/core/sql/valueMappers/sqlValueMapper.ts
-var ANSISQLParamPlaceholder = "?";
-var ANSISQLIdentifierQuote = '"';
-var mapANSISQLParamPlaceholder = () => ANSISQLParamPlaceholder;
-var isReserved = (value, reserved) => !!reserved[value.toUpperCase()];
-var mapSQLIdentifier = (value, options) => {
-  if (value === void 0 || value === null) {
-    throw new Error("SQL identifier cannot be null or undefined");
-  }
-  const ident = value.toString().slice(0);
-  const quoteSign = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.quote]), () => ( ANSISQLIdentifierQuote));
-  if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.reservedWords]), () => ( ansiSqlReservedMap)))) {
-    return ident;
-  }
-  let quoted = quoteSign;
-  for (let i = 0; i < ident.length; i++) {
-    const c = ident[i];
-    quoted += c === quoteSign ? c + c : c;
-  }
-  quoted += quoteSign;
-  return quoted;
-};
-var DefaultMapSQLParamValueOptions = {
-  mapPlaceholder: mapANSISQLParamPlaceholder,
-  mapIdentifier: mapSQLIdentifier
-};
-var SQLValueMapper = (options) => {
-  const mapSQLParamValueOptions = {
-    ...DefaultMapSQLParamValueOptions,
-    ..._nullishCoalesce(options, () => ( {}))
-  };
-  const resultMapper = {
-    mapValue: (value) => mapSQLParamValue(value, mapSQLParamValueOptions),
-    mapPlaceholder: mapSQLParamValueOptions.mapPlaceholder,
-    mapIdentifier: mapSQLParamValueOptions.mapIdentifier
-  };
-  return resultMapper;
-};
-function mapSQLParamValue(value, options) {
-  if (value === null || value === void 0) {
-    return null;
-  } else if (typeof value === "number") {
-    return value;
-  } else if (typeof value === "string") {
-    return value;
-  } else if (Array.isArray(value)) {
-    const mapValue = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.mapValue]), () => ( mapSQLParamValue));
-    return _optionalChain([options, 'optionalAccess', _9 => _9.mapArray]) ? options.mapArray(value, mapValue) : value.map((item) => mapValue(item, options));
-  } else if (typeof value === "boolean") {
-    return _optionalChain([options, 'optionalAccess', _10 => _10.mapBoolean]) ? options.mapBoolean(value) : value;
-  } else if (typeof value === "bigint") {
-    return _optionalChain([options, 'optionalAccess', _11 => _11.mapBigInt]) ? options.mapBigInt(value) : value.toString();
-  } else if (value instanceof Date) {
-    return _optionalChain([options, 'optionalAccess', _12 => _12.mapDate]) ? options.mapDate(value) : value.toISOString();
-  } else if (SQL.check.isIdentifier(value)) {
-    return (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.mapIdentifier]), () => ( mapSQLIdentifier)))(value.value);
-  } else if (typeof value === "object") {
-    return _optionalChain([options, 'optionalAccess', _14 => _14.mapObject]) ? options.mapObject(value) : `${JSONSerializer.serialize(value).replace(/'/g, "''")}`;
-  } else {
-    return JSONSerializer.serialize(value);
-  }
-}
-
-// src/core/sql/formatters/sqlFormatter.ts
-var SQLFormatter2 = ({
-  format,
-  describe,
-  valueMapper: valueMapperOptions,
-  processorsRegistry
-}) => {
-  const valueMapper = SQLValueMapper(valueMapperOptions);
-  const options = {
-    builder: ParametrizedSQLBuilder({
-      mapParamPlaceholder: valueMapper.mapPlaceholder
-    }),
-    mapper: valueMapper,
-    processorsRegistry: _nullishCoalesce(processorsRegistry, () => ( defaultProcessorsRegistry))
-  };
-  const resultFormatter = {
-    format: _nullishCoalesce(format, () => ( ((sql, methodOptions) => formatSQL(sql, resultFormatter, {
-      ...options,
-      ..._nullishCoalesce(methodOptions, () => ( {}))
-    })))),
-    describe: _nullishCoalesce(describe, () => ( ((sql, methodOptions) => describeSQL(sql, resultFormatter, {
-      ...options,
-      ..._nullishCoalesce(methodOptions, () => ( {}))
-    })))),
-    valueMapper
-  };
-  return resultFormatter;
-};
-var dumboSQLFormatters = globalThis.dumboSQLFormatters = _nullishCoalesce(globalThis.dumboSQLFormatters, () => ( {}));
-var registerFormatter = (dialect, formatter) => {
-  dumboSQLFormatters[dialect] = formatter;
-};
-var getFormatter = (dialect) => {
-  const formatterKey = dialect;
-  if (!dumboSQLFormatters[formatterKey]) {
-    throw new Error(`No SQL formatter registered for dialect: ${dialect}`);
-  }
-  return dumboSQLFormatters[formatterKey];
-};
-function formatSQL(sql, formatter, context) {
-  const mapper = _optionalChain([context, 'optionalAccess', _15 => _15.mapper]) == void 0 ? formatter.valueMapper : {
-    ...formatter.valueMapper,
-    ...context.mapper
-  };
-  const processorsRegistry = _nullishCoalesce(_optionalChain([context, 'optionalAccess', _16 => _16.processorsRegistry]), () => ( defaultProcessorsRegistry));
-  const merged = Array.isArray(sql) ? SQL.merge(sql, "\n") : sql;
-  if (!isTokenizedSQL(merged)) {
-    throw new Error("Expected TokenizedSQL, got string-based SQL");
-  }
-  const builder = ParametrizedSQLBuilder({
-    mapParamPlaceholder: mapper.mapPlaceholder
-  });
-  let paramIndex = 0;
-  for (let i = 0; i < merged.sqlChunks.length; i++) {
-    const sqlChunk = merged.sqlChunks[i];
-    if (sqlChunk !== TokenizedSQL.paramPlaceholder) {
-      builder.addSQL(sqlChunk);
-      continue;
-    }
-    const token = merged.sqlTokens[paramIndex++];
-    const processor = processorsRegistry.get(token.sqlTokenType);
-    if (!processor) {
-      throw new Error(
-        `No SQL processor registered for token type: ${token.sqlTokenType}`
-      );
-    }
-    processor.handle(token, {
-      builder,
-      processorsRegistry,
-      mapper
-    });
-  }
-  return builder.build();
-}
-var describeSQL = (sql, formatter, options) => formatSQL(sql, formatter, {
-  ..._nullishCoalesce(options, () => ( {})),
-  mapper: {
-    mapPlaceholder: (_, value) => JSONSerializer.serialize(value)
-  }
-}).query;
-
-// src/core/execute/execute.ts
-var mapColumnToJSON = (column, options) => ({
-  [column]: (value) => {
-    if (typeof value === "string") {
-      try {
-        return JSONSerializer.deserialize(value, options);
-      } catch (e2) {
-      }
-    }
-    return value;
-  }
-});
-var mapColumnToBigint = (column) => ({
-  [column]: (value) => {
-    if (typeof value === "number" || typeof value === "string") {
-      return BigInt(value);
-    }
-    return value;
-  }
-});
-var mapSQLQueryResult = (result, mapping) => {
-  if (typeof result !== "object" || result === null) return result;
-  const mappedResult = {
-    ...result
-  };
-  for (const column of Object.keys(mapping)) {
-    if (column in mappedResult) {
-      mappedResult[column] = mapping[column](mappedResult[column]);
-    }
-  }
-  return mappedResult;
-};
-var sqlExecutor = (sqlExecutor2, options) => ({
-  query: (sql, queryOptions) => executeInNewDbClient(
-    (client) => sqlExecutor2.query(client, sql, queryOptions),
-    options
-  ),
-  batchQuery: (sqls, queryOptions) => executeInNewDbClient(
-    (client) => sqlExecutor2.batchQuery(client, sqls, queryOptions),
-    options
-  ),
-  command: (sql, commandOptions) => executeInNewDbClient(
-    (client) => sqlExecutor2.command(client, sql, commandOptions),
-    options
-  ),
-  batchCommand: (sqls, commandOptions) => executeInNewDbClient(
-    (client) => sqlExecutor2.batchCommand(client, sqls, commandOptions),
-    options
-  )
-});
-var sqlExecutorInNewConnection = (options) => ({
-  query: (sql, queryOptions) => executeInNewConnection(
-    (connection) => connection.execute.query(sql, queryOptions),
-    options
-  ),
-  batchQuery: (sqls, queryOptions) => executeInNewConnection(
-    (connection) => connection.execute.batchQuery(sqls, queryOptions),
-    options
-  ),
-  command: (sql, commandOptions) => executeInNewConnection(
-    (connection) => connection.execute.command(sql, commandOptions),
-    options
-  ),
-  batchCommand: (sqls, commandOptions) => executeInNewConnection(
-    (connection) => connection.execute.batchCommand(sqls, commandOptions),
-    options
-  )
-});
-var sqlExecutorInAmbientConnection = (options) => ({
-  query: (sql, queryOptions) => executeInAmbientConnection(
-    (connection) => connection.execute.query(sql, queryOptions),
-    options
-  ),
-  batchQuery: (sqls, queryOptions) => executeInAmbientConnection(
-    (connection) => connection.execute.batchQuery(sqls, queryOptions),
-    options
-  ),
-  command: (sql, commandOptions) => executeInAmbientConnection(
-    (connection) => connection.execute.command(sql, commandOptions),
-    options
-  ),
-  batchCommand: (sqls, commandOptions) => executeInAmbientConnection(
-    (connection) => connection.execute.batchCommand(sqls, commandOptions),
-    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();
-  }
-};
-var executeInAmbientConnection = async (handle, options) => {
-  const connection = await options.connection();
-  try {
-    return await handle(connection);
-  } finally {
-  }
-};
-
-// 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) => {
-  let currentTransaction = void 0;
-  const getOrInitCurrentTransaction = (options) => _nullishCoalesce(currentTransaction, () => ( (currentTransaction = initTransaction(connect(), {
-    close: () => {
-      currentTransaction = void 0;
-      return Promise.resolve();
-    },
-    ..._nullishCoalesce(options, () => ( {}))
-  }))));
-  return {
-    transaction: getOrInitCurrentTransaction,
-    withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
-  };
-};
-var wrapInConnectionClosure = async (connection, handle) => {
-  try {
-    return await handle();
-  } finally {
-    await connection.close();
-  }
-};
-var transactionFactoryWithNewConnection = (connect) => ({
-  transaction: (options) => {
-    const connection = connect();
-    const transaction = connection.transaction(options);
-    return {
-      ...transaction,
-      commit: () => wrapInConnectionClosure(connection, () => transaction.commit()),
-      rollback: () => wrapInConnectionClosure(connection, () => transaction.rollback())
-    };
-  },
-  withTransaction: (handle, options) => {
-    const connection = connect();
-    return wrapInConnectionClosure(
-      connection,
-      () => connection.withTransaction(handle, options)
-    );
-  }
-});
-var transactionFactoryWithAmbientConnection = (connect) => ({
-  transaction: (options) => {
-    const connection = connect();
-    const transaction = connection.transaction(options);
-    return {
-      ...transaction,
-      commit: () => transaction.commit(),
-      rollback: () => transaction.rollback()
-    };
-  },
-  withTransaction: (handle, options) => {
-    const connection = connect();
-    return connection.withTransaction(handle, options);
-  }
-});
-
-// src/core/connections/connection.ts
-var createAmbientConnection = (options) => {
-  const { driverType, client, executor, initTransaction } = options;
-  const clientPromise = Promise.resolve(client);
-  const closePromise = Promise.resolve();
-  const open = () => clientPromise;
-  const close = () => closePromise;
-  const connection = {
-    driverType,
-    open,
-    close,
-    ...transactionFactoryWithDbClient(
-      open,
-      initTransaction(() => typedConnection)
-    ),
-    execute: sqlExecutor(executor(), { connect: open })
-  };
-  const typedConnection = connection;
-  return typedConnection;
-};
-var createSingletonConnection = (options) => {
-  const { driverType, connect, close, initTransaction, executor } = options;
-  let client = null;
-  let connectPromise = null;
-  const getClient = async () => {
-    if (client) return client;
-    if (!connectPromise) {
-      connectPromise = connect().then((c) => {
-        client = c;
-        return c;
-      });
-    }
-    return connectPromise;
-  };
-  const connection = {
-    driverType,
-    open: getClient,
-    close: () => client ? close(client) : Promise.resolve(),
-    ...transactionFactoryWithDbClient(
-      getClient,
-      initTransaction(() => typedConnection)
-    ),
-    execute: sqlExecutor(executor(), { connect: getClient })
-  };
-  const typedConnection = connection;
-  return typedConnection;
-};
-var createTransientConnection = (options) => {
-  const { driverType, open, close, initTransaction, executor } = options;
-  const connection = {
-    driverType,
-    open,
-    close,
-    ...transactionFactoryWithDbClient(
-      open,
-      initTransaction(() => typedConnection)
-    ),
-    execute: sqlExecutor(executor(), { connect: open })
-  };
-  const typedConnection = connection;
-  return typedConnection;
-};
-var createConnection = (options) => {
-  const { driverType, connect, close, initTransaction, executor } = options;
-  let client = null;
-  let connectPromise = null;
-  const getClient = async () => {
-    if (client) return client;
-    if (!connectPromise) {
-      connectPromise = connect().then((c) => {
-        client = c;
-        return c;
-      });
-    }
-    return connectPromise;
-  };
-  const connection = {
-    driverType,
-    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 createAmbientConnectionPool = (options) => {
-  const { driverType, connection } = options;
-  return createConnectionPool({
-    driverType,
-    getConnection: () => connection,
-    execute: connection.execute,
-    transaction: (options2) => connection.transaction(options2),
-    withTransaction: (handle, options2) => connection.withTransaction(handle, options2)
-  });
-};
-var createSingletonConnectionPool = (options) => {
-  const { driverType, getConnection } = options;
-  let connection = null;
-  const getExistingOrNewConnection = () => _nullishCoalesce(connection, () => ( (connection = getConnection())));
-  const getExistingOrNewConnectionAsync = () => Promise.resolve(getExistingOrNewConnection());
-  const result = {
-    driverType,
-    connection: getExistingOrNewConnectionAsync,
-    execute: sqlExecutorInAmbientConnection({
-      driverType,
-      connection: getExistingOrNewConnectionAsync
-    }),
-    withConnection: (handle) => executeInAmbientConnection(handle, {
-      connection: getExistingOrNewConnectionAsync
-    }),
-    ...transactionFactoryWithAmbientConnection(getExistingOrNewConnection),
-    close: () => {
-      return connection !== null ? connection.close() : Promise.resolve();
-    }
-  };
-  return result;
-};
-var createSingletonClientPool = (options) => {
-  const { driverType, dbClient } = options;
-  return createSingletonConnectionPool({
-    getConnection: () => options.connectionFactory({ dbClient }),
-    driverType
-  });
-};
-var createAlwaysNewConnectionPool = (options) => {
-  const { driverType, getConnection, connectionOptions } = options;
-  return createConnectionPool({
-    driverType,
-    getConnection: () => connectionOptions ? getConnection(connectionOptions) : getConnection()
-  });
-};
-var createConnectionPool = (pool) => {
-  const { driverType, 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({
-    driverType,
-    connection
-  });
-  const transaction = "transaction" in pool && "withTransaction" in pool ? {
-    transaction: pool.transaction,
-    withTransaction: pool.withTransaction
-  } : transactionFactoryWithNewConnection(getConnection);
-  const result = {
-    driverType,
-    connection,
-    withConnection,
-    close,
-    execute,
-    ...transaction
-  };
-  return result;
-};
-
-// src/core/schema/sqlMigration.ts
-var sqlMigration = (name, sqls) => ({
-  name,
-  sqls
-});
-
-// src/core/schema/schemaComponent.ts
-var schemaComponent = (key, options) => {
-  const componentsMap = new Map(
-    _optionalChain([options, 'access', _17 => _17.components, 'optionalAccess', _18 => _18.map, 'call', _19 => _19((comp) => [comp.schemaComponentKey, comp])])
-  );
-  const migrations = [..._nullishCoalesce(options.migrations, () => ( []))];
-  return {
-    schemaComponentKey: key,
-    components: componentsMap,
-    get migrations() {
-      return [
-        ...migrations,
-        ...Array.from(componentsMap.values()).flatMap((c) => c.migrations)
-      ];
-    },
-    addComponent: (component) => {
-      componentsMap.set(component.schemaComponentKey, component);
-      migrations.push(...component.migrations);
-      return component;
-    },
-    addMigration: (migration) => {
-      migrations.push(migration);
-    }
-  };
-};
-var isSchemaComponentOfType = (component, prefix) => component.schemaComponentKey.startsWith(prefix);
-var filterSchemaComponentsOfType = (components, prefix) => mapSchemaComponentsOfType(components, prefix);
-var mapSchemaComponentsOfType = (components, prefix, keyMapper) => new Map(
-  Array.from(components.entries()).filter(([urn]) => urn.startsWith(prefix)).map(([urn, component]) => [
-    keyMapper ? keyMapper(component) : urn,
-    component
-  ])
-);
-var findSchemaComponentsOfType = (root, prefix) => {
-  const results = [];
-  const traverse = (component) => {
-    if (component.schemaComponentKey.startsWith(prefix)) {
-      results.push(component);
-    }
-    for (const child of component.components.values()) {
-      traverse(child);
-    }
-  };
-  traverse(root);
-  return results;
-};
-
-// src/core/schema/components/columnSchemaComponent.ts
-var ColumnURNType = "sc:dumbo:column";
-var ColumnURN = ({
-  name
-}) => `${ColumnURNType}:${name}`;
-var columnSchemaComponent = (params) => {
-  const {
-    columnName,
-    type,
-    notNull,
-    unique,
-    primaryKey,
-    default: defaultValue,
-    ...schemaOptions
-  } = params;
-  const sc = schemaComponent(ColumnURN({ name: columnName }), schemaOptions);
-  const result = {
-    ...sc,
-    columnName,
-    notNull,
-    unique,
-    primaryKey,
-    defaultValue,
-    sqlTokenType: "SQL_COLUMN",
-    name: columnName,
-    type
-  };
-  return result;
-};
-
-// src/core/schema/components/indexSchemaComponent.ts
-var IndexURNType = "sc:dumbo:index";
-var IndexURN = ({ name }) => `${IndexURNType}:${name}`;
-var indexSchemaComponent = ({
-  indexName,
-  columnNames,
-  isUnique,
-  ...migrationsOrComponents
-}) => {
-  const sc = schemaComponent(IndexURN({ name: indexName }), {
-    migrations: _nullishCoalesce(migrationsOrComponents.migrations, () => ( [])),
-    components: [..._nullishCoalesce(migrationsOrComponents.components, () => ( []))]
-  });
-  return {
-    ...sc,
-    indexName,
-    get columnNames() {
-      return columnNames;
-    },
-    addColumn: (column) => columnNames.push(typeof column === "string" ? column : column.columnName),
-    isUnique
-  };
-};
-
-// src/core/schema/components/tableSchemaComponent.ts
-var TableURNType = "sc:dumbo:table";
-var TableURN = ({ name }) => `${TableURNType}:${name}`;
-var tableSchemaComponent = ({
-  tableName,
-  columns,
-  primaryKey,
-  relationships,
-  ...migrationsOrComponents
-}) => {
-  columns ??= {};
-  relationships ??= {};
-  const base = schemaComponent(TableURN({ name: tableName }), {
-    migrations: _nullishCoalesce(migrationsOrComponents.migrations, () => ( [])),
-    components: [
-      ..._nullishCoalesce(migrationsOrComponents.components, () => ( [])),
-      ...Object.values(columns)
-    ]
-  });
-  return {
-    ...base,
-    tableName,
-    primaryKey: _nullishCoalesce(primaryKey, () => ( [])),
-    relationships,
-    get columns() {
-      const columnsMap = mapSchemaComponentsOfType(
-        base.components,
-        ColumnURNType,
-        (c) => c.columnName
-      );
-      return Object.assign(columnsMap, columns);
-    },
-    get indexes() {
-      return mapSchemaComponentsOfType(
-        base.components,
-        IndexURNType,
-        (c) => c.indexName
-      );
-    },
-    addColumn: (column) => base.addComponent(column),
-    addIndex: (index) => base.addComponent(index)
-  };
-};
-
-// src/core/schema/components/databaseSchemaSchemaComponent.ts
-var DatabaseSchemaURNType = "sc:dumbo:database_schema";
-var DatabaseSchemaURN = ({
-  name
-}) => `${DatabaseSchemaURNType}:${name}`;
-var databaseSchemaSchemaComponent = ({
-  schemaName,
-  tables,
-  ...migrationsOrComponents
-}) => {
-  const base = schemaComponent(DatabaseSchemaURN({ name: schemaName }), {
-    migrations: _nullishCoalesce(migrationsOrComponents.migrations, () => ( [])),
-    components: [
-      ..._nullishCoalesce(migrationsOrComponents.components, () => ( [])),
-      ...Object.values(_nullishCoalesce(tables, () => ( {})))
-    ]
-  });
-  return {
-    ...base,
-    schemaName,
-    get tables() {
-      const tablesMap = mapSchemaComponentsOfType(
-        base.components,
-        TableURNType,
-        (c) => c.tableName
-      );
-      return Object.assign(tablesMap, tables);
-    },
-    addTable: (table) => base.addComponent(
-      typeof table === "string" ? tableSchemaComponent({ tableName: table }) : table
-    )
-  };
-};
-
-// src/core/schema/components/databaseSchemaComponent.ts
-var DatabaseURNType = "sc:dumbo:database";
-var DatabaseURN = ({ name }) => `${DatabaseURNType}:${name}`;
-var databaseSchemaComponent = ({
-  databaseName,
-  schemas,
-  ...migrationsOrComponents
-}) => {
-  schemas ??= {};
-  const base = schemaComponent(DatabaseURN({ name: databaseName }), {
-    migrations: _nullishCoalesce(migrationsOrComponents.migrations, () => ( [])),
-    components: [
-      ..._nullishCoalesce(migrationsOrComponents.components, () => ( [])),
-      ...Object.values(schemas)
-    ]
-  });
-  return {
-    ...base,
-    databaseName,
-    get schemas() {
-      const schemasMap = mapSchemaComponentsOfType(
-        base.components,
-        DatabaseSchemaURNType,
-        (c) => c.schemaName
-      );
-      return Object.assign(schemasMap, schemas);
-    },
-    addSchema: (schema) => base.addComponent(
-      typeof schema === "string" ? databaseSchemaSchemaComponent({ schemaName: schema }) : schema
-    )
-  };
-};
-
-// src/core/schema/components/relationships/relationshipTypes.ts
-var relationship = (columns, references, type) => {
-  return {
-    columns,
-    references,
-    type
-  };
-};
-
-// src/core/schema/components/index.ts
-var schemaComponentURN = {
-  database: DatabaseURN,
-  schema: DatabaseSchemaURN,
-  table: TableURN,
-  column: ColumnURN,
-  index: IndexURN,
-  extractName: (urn) => {
-    const parts = urn.split(":");
-    return parts[parts.length - 1] || "";
-  }
-};
-
-// src/core/schema/dumboSchema/dumboSchema.ts
-var DEFAULT_DATABASE_NAME = "__default_database__";
-var DEFAULT_DATABASE_SCHEMA_NAME = "__default_database_schema__";
-var dumboColumn = (name, type, options) => columnSchemaComponent({
-  columnName: name,
-  type,
-  ...options
-});
-var dumboIndex = (name, columnNames, options) => indexSchemaComponent({
-  indexName: name,
-  columnNames,
-  isUnique: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.unique]), () => ( false)),
-  ...options
-});
-var dumboTable = (name, definition) => {
-  const { columns, indexes, primaryKey, relationships, ...options } = definition;
-  const components = [...indexes ? Object.values(indexes) : []];
-  return tableSchemaComponent({
-    tableName: name,
-    columns: _nullishCoalesce(columns, () => ( {})),
-    primaryKey: _nullishCoalesce(primaryKey, () => ( [])),
-    ...relationships !== void 0 ? { relationships } : {},
-    components,
-    ...options
-  });
-};
-function dumboDatabaseSchema(nameOrTables, tables, options) {
-  const schemaName = typeof nameOrTables === "string" ? nameOrTables : DEFAULT_DATABASE_SCHEMA_NAME;
-  const tablesMap = _nullishCoalesce((typeof nameOrTables === "string" ? tables : nameOrTables), () => ( {}));
-  return databaseSchemaSchemaComponent({
-    schemaName,
-    tables: tablesMap,
-    ...options
-  });
-}
-dumboDatabaseSchema.from = (schemaName, tableNames) => {
-  const tables = tableNames.reduce(
-    (acc, tableName) => {
-      acc[tableName] = dumboTable(tableName, {});
-      return acc;
-    },
-    {}
-  );
-  return schemaName ? dumboDatabaseSchema(schemaName, tables) : dumboDatabaseSchema(tables);
-};
-function dumboDatabase(nameOrSchemas, schemasOrOptions, options) {
-  const databaseName = typeof nameOrSchemas === "string" ? nameOrSchemas : DEFAULT_DATABASE_NAME;
-  const schemasOrSchema = typeof nameOrSchemas === "string" ? _nullishCoalesce(schemasOrOptions, () => ( {})) : nameOrSchemas;
-  const schemaMap = "schemaComponentKey" in schemasOrSchema && isSchemaComponentOfType(
-    schemasOrSchema,
-    "sc:dumbo:database_schema"
-  ) ? {
-    [DEFAULT_DATABASE_SCHEMA_NAME]: schemasOrSchema
-  } : schemasOrSchema;
-  const dbOptions = typeof nameOrSchemas === "string" ? options : schemasOrOptions;
-  return databaseSchemaComponent({
-    databaseName,
-    schemas: schemaMap,
-    ...dbOptions
-  });
-}
-dumboDatabase.from = (databaseName, schemaNames) => {
-  const schemas = schemaNames.reduce(
-    (acc, schemaName) => {
-      acc[schemaName] = dumboDatabaseSchema(
-        schemaName,
-        {}
-      );
-      return acc;
-    },
-    {}
-  );
-  return databaseName ? dumboDatabase(databaseName, schemas) : dumboDatabase(schemas);
-};
-dumboDatabase.defaultName = DEFAULT_DATABASE_NAME;
-dumboDatabaseSchema.defaultName = DEFAULT_DATABASE_SCHEMA_NAME;
-var dumboSchema = {
-  database: dumboDatabase,
-  schema: dumboDatabaseSchema,
-  table: dumboTable,
-  column: dumboColumn,
-  index: dumboIndex
-};
-
-// src/core/locks/databaseLock.ts
-var defaultDatabaseLockOptions = {
-  timeoutMs: 1e4
-};
-var NoDatabaseLock = {
-  acquire: () => Promise.resolve(),
-  tryAcquire: () => Promise.resolve(true),
-  release: () => Promise.resolve(true),
-  withAcquire: (_execute, handle, _options) => handle()
-};
-
-// 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', _21 => _21[1], 'optionalAccess', _22 => _22.toUpperCase, 'call', _23 => _23()]), () => ( "")));
-var mapToCamelCase = (obj) => {
-  const newObj = {};
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      newObj[toCamelCase(key)] = obj[key];
-    }
-  }
-  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 Number(result.count);
-};
-var exists = async (getResult) => {
-  const result = await single(getResult);
-  return result.exists === true || result.exists === 1;
-};
-
-// 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((key) => {
-      errorObj[key] = obj[key];
-    });
-    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(
-    ([key, value]) => `${COLOR_KEY(`"${key}"`)}: ${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', _24 => _24.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 format = getTraceEventFormatter(logStyle);
-  switch (logLevel) {
-    case "DISABLED":
-      return nulloTraceEventRecorder;
-    case "INFO":
-      return (event) => console.info(format(event));
-    case "LOG":
-      return (event) => console.log(format(event));
-    case "WARN":
-      return (event) => console.warn(format(event));
-    case "ERROR":
-      return (event) => console.error(format(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/schema/migrators/schemaComponentMigrator.ts
-var { AutoIncrement, Varchar, Timestamp } = SQL.column.type;
-var migrationTableSQL = SQL`
-  CREATE TABLE IF NOT EXISTS migrations (
-    id ${AutoIncrement({ primaryKey: true })},
-    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 SchemaComponentMigrator = (component, dumbo) => {
-  const completedMigrations = [];
-  return {
-    component,
-    run: async (options) => {
-      const pendingMigrations = component.migrations.filter(
-        (m) => !completedMigrations.includes(
-          `${component.schemaComponentKey}:${m.name}`
-        )
-      );
-      if (pendingMigrations.length === 0) return;
-      await runSQLMigrations(dumbo, pendingMigrations, options);
-      completedMigrations.push(
-        ...pendingMigrations.map(
-          (m) => `${component.schemaComponentKey}:${m.name}`
-        )
-      );
-    }
-  };
-};
-
-// src/core/schema/migrators/migrator.ts
-var MIGRATIONS_LOCK_ID = 999956789;
-var defaultMigratorOptions = globalThis.defaultMigratorOptions = _nullishCoalesce(globalThis.defaultMigratorOptions, () => ( {}));
-var registerDefaultMigratorOptions = (databaseType, options) => {
-  defaultMigratorOptions[databaseType] = options;
-};
-var getDefaultMigratorOptionsFromRegistry = (databaseType) => {
-  if (!defaultMigratorOptions[databaseType]) {
-    throw new Error(
-      `No default migrator options registered for database type: ${databaseType}`
-    );
-  }
-  return defaultMigratorOptions[databaseType];
-};
-var runSQLMigrations = (pool, migrations, partialOptions) => pool.withTransaction(async ({ execute }) => {
-  const databaseType = fromDatabaseDriverType(pool.driverType).databaseType;
-  const defaultOptions = getDefaultMigratorOptionsFromRegistry(databaseType);
-  partialOptions ??= {};
-  const options = {
-    ...defaultOptions,
-    ...partialOptions,
-    schema: {
-      ...defaultOptions.schema,
-      ..._nullishCoalesce(_optionalChain([partialOptions, 'optionalAccess', _25 => _25.schema]), () => ( {}))
-    },
-    lock: {
-      ...defaultOptions.lock,
-      ..._optionalChain([partialOptions, 'optionalAccess', _26 => _26.lock]),
-      options: {
-        lockId: MIGRATIONS_LOCK_ID,
-        ..._optionalChain([defaultOptions, 'access', _27 => _27.lock, 'optionalAccess', _28 => _28.options]),
-        ..._optionalChain([partialOptions, 'optionalAccess', _29 => _29.lock, 'optionalAccess', _30 => _30.options])
-      }
-    },
-    dryRun: _nullishCoalesce(defaultOptions.dryRun, () => ( _optionalChain([partialOptions, 'optionalAccess', _31 => _31.dryRun])))
-  };
-  const { databaseLock: _, ...rest } = _nullishCoalesce(options.lock, () => ( {}));
-  const databaseLock = _nullishCoalesce(_optionalChain([options, 'access', _32 => _32.lock, 'optionalAccess', _33 => _33.databaseLock]), () => ( NoDatabaseLock));
-  const lockOptions = {
-    lockId: MIGRATIONS_LOCK_ID,
-    ...rest
-  };
-  const migrationTable = _nullishCoalesce(_optionalChain([options, 'access', _34 => _34.schema, 'optionalAccess', _35 => _35.migrationTable]), () => ( migrationTableSchemaComponent));
-  const coreMigrations = migrationTable.migrations;
-  await databaseLock.withAcquire(
-    execute,
-    async () => {
-      for (const migration of coreMigrations) {
-        await execute.batchCommand(migration.sqls);
-      }
-      for (const migration of migrations) {
-        await runSQLMigration(databaseType, execute, migration);
-      }
-    },
-    lockOptions
-  );
-  return { success: options.dryRun ? false : true, result: void 0 };
-});
-var runSQLMigration = async (databaseType, execute, migration) => {
-  const sqls = combineMigrations(migration);
-  const sqlHash = await getMigrationHash(migration, getFormatter(databaseType));
-  try {
-    const newMigration = {
-      name: migration.name,
-      sqlHash
-    };
-    const wasMigrationApplied = await ensureMigrationWasNotAppliedYet(
-      execute,
-      newMigration
-    );
-    if (wasMigrationApplied) return;
-    await execute.batchCommand(sqls);
-    await recordMigration(execute, newMigration);
-  } catch (error) {
-    tracer.error("migration-error", {
-      migationName: migration.name,
-      error
-    });
-    throw error;
-  }
-};
-var getMigrationHash = async (sqlMigration2, sqlFormatter) => {
-  const content = sqlFormatter.describe(sqlMigration2.sqls);
-  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);
-var ensureMigrationWasNotAppliedYet = async (execute, migration) => {
-  const result = await singleOrNull(
-    execute.query(
-      SQL`SELECT sql_hash FROM migrations WHERE name = ${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 (${migration.name}, ${migration.sqlHash})`
-  );
-};
-
-// src/core/index.ts
-SQL.columnN = Object.assign(dumboSchema.column, {
-  type: SQLColumnTypeTokensFactory
-});
-
-// src/core/drivers/databaseDriver.ts
-var canHandleDriverWithConnectionString = (driver, tryParseConnectionString) => (options) => {
-  if ("driverType" in options) return options.driverType === driver;
-  if ("connectionString" in options && typeof options.connectionString === "string")
-    return tryParseConnectionString(options.connectionString) !== null;
-  return false;
-};
-var DumboDatabaseDriverRegistry = () => {
-  const drivers = /* @__PURE__ */ new Map();
-  const register = (driverType, plugin) => {
-    const entry = drivers.get(driverType);
-    if (entry && (typeof entry !== "function" || typeof plugin === "function")) {
-      return;
-    }
-    drivers.set(driverType, plugin);
-  };
-  const getDriver = (options) => options.driverType ? drivers.get(options.driverType) : [...drivers.values()].find(
-    (d) => typeof d !== "function" && d.canHandle(options)
-  );
-  const tryResolve = async (options) => {
-    const driver = getDriver(options);
-    if (!driver) return null;
-    if (typeof driver !== "function") return driver;
-    const plugin = await driver();
-    register(plugin.driverType, plugin);
-    return plugin;
-  };
-  const tryGet = (options) => {
-    const driver = getDriver(options);
-    return driver && typeof driver !== "function" ? driver : null;
-  };
-  const has = (driverType) => drivers.has(driverType);
-  return {
-    register,
-    tryResolve,
-    tryGet,
-    has,
-    get databaseDriverTypes() {
-      return Array.from(drivers.keys());
-    }
-  };
-};
-var dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry = _nullishCoalesce(globalThis.dumboDatabaseDriverRegistry, () => ( DumboDatabaseDriverRegistry()));
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.canHandleDriverWithConnectionString = canHandleDriverWithConnectionString; exports.DumboDatabaseDriverRegistry = DumboDatabaseDriverRegistry; exports.dumboDatabaseDriverRegistry = dumboDatabaseDriverRegistry; exports.toDatabaseDriverType = toDatabaseDriverType; exports.fromDatabaseDriverType = fromDatabaseDriverType; exports.getDatabaseDriverName = getDatabaseDriverName; exports.getDatabaseType = getDatabaseType; 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.ParametrizedSQLBuilder = ParametrizedSQLBuilder; exports.SQLToken = SQLToken; exports.SQLIdentifier = SQLIdentifier; exports.SQLPlain = SQLPlain; exports.SQLLiteral = SQLLiteral; exports.SQLArray = SQLArray; exports.SQLIn = SQLIn; exports.ColumnTypeToken = ColumnTypeToken; exports.SerialToken = SerialToken; exports.BigSerialToken = BigSerialToken; exports.IntegerToken = IntegerToken; exports.BigIntegerToken = BigIntegerToken; exports.JSONBToken = JSONBToken; exports.TimestampToken = TimestampToken; exports.TimestamptzToken = TimestamptzToken; exports.VarcharToken = VarcharToken; exports.AutoIncrementSQLColumnToken = AutoIncrementSQLColumnToken; exports.SQLColumnTypeTokens = SQLColumnTypeTokens; exports.SQLColumnTypeTokensFactory = SQLColumnTypeTokensFactory; exports.SQLColumnToken = SQLColumnToken; exports.SQLProcessor = SQLProcessor; exports.ExpandArrayProcessor = ExpandArrayProcessor; exports.ExpandSQLInProcessor = ExpandSQLInProcessor; exports.FormatIdentifierProcessor = FormatIdentifierProcessor; exports.MapLiteralProcessor = MapLiteralProcessor; exports.SQLProcessorsRegistry = SQLProcessorsRegistry; exports.mapDefaultSQLColumnProcessors = mapDefaultSQLColumnProcessors; exports.defaultProcessorsRegistry = defaultProcessorsRegistry; exports.TokenizedSQL = TokenizedSQL; exports.isTokenizedSQL = isTokenizedSQL; exports.SQL = SQL; exports.isSQL = isSQL; exports.ansiSqlReservedMap = ansiSqlReservedMap; exports.ANSISQLParamPlaceholder = ANSISQLParamPlaceholder; exports.ANSISQLIdentifierQuote = ANSISQLIdentifierQuote; exports.mapANSISQLParamPlaceholder = mapANSISQLParamPlaceholder; exports.mapSQLIdentifier = mapSQLIdentifier; exports.DefaultMapSQLParamValueOptions = DefaultMapSQLParamValueOptions; exports.SQLValueMapper = SQLValueMapper; exports.mapSQLParamValue = mapSQLParamValue; exports.SQLFormatter = SQLFormatter2; exports.registerFormatter = registerFormatter; exports.getFormatter = getFormatter; exports.formatSQL = formatSQL; exports.describeSQL = describeSQL; exports.mapColumnToJSON = mapColumnToJSON; exports.mapColumnToBigint = mapColumnToBigint; exports.mapSQLQueryResult = mapSQLQueryResult; exports.sqlExecutor = sqlExecutor; exports.sqlExecutorInNewConnection = sqlExecutorInNewConnection; exports.sqlExecutorInAmbientConnection = sqlExecutorInAmbientConnection; exports.executeInNewDbClient = executeInNewDbClient; exports.executeInNewConnection = executeInNewConnection; exports.executeInAmbientConnection = executeInAmbientConnection; exports.executeInTransaction = executeInTransaction; exports.transactionFactoryWithDbClient = transactionFactoryWithDbClient; exports.transactionFactoryWithNewConnection = transactionFactoryWithNewConnection; exports.transactionFactoryWithAmbientConnection = transactionFactoryWithAmbientConnection; exports.createAmbientConnection = createAmbientConnection; exports.createSingletonConnection = createSingletonConnection; exports.createTransientConnection = createTransientConnection; exports.createConnection = createConnection; exports.createAmbientConnectionPool = createAmbientConnectionPool; exports.createSingletonConnectionPool = createSingletonConnectionPool; exports.createSingletonClientPool = createSingletonClientPool; exports.createAlwaysNewConnectionPool = createAlwaysNewConnectionPool; exports.createConnectionPool = createConnectionPool; exports.sqlMigration = sqlMigration; exports.schemaComponent = schemaComponent; exports.isSchemaComponentOfType = isSchemaComponentOfType; exports.filterSchemaComponentsOfType = filterSchemaComponentsOfType; exports.mapSchemaComponentsOfType = mapSchemaComponentsOfType; exports.findSchemaComponentsOfType = findSchemaComponentsOfType; exports.ColumnURNType = ColumnURNType; exports.ColumnURN = ColumnURN; exports.columnSchemaComponent = columnSchemaComponent; exports.IndexURNType = IndexURNType; exports.IndexURN = IndexURN; exports.indexSchemaComponent = indexSchemaComponent; exports.TableURNType = TableURNType; exports.TableURN = TableURN; exports.tableSchemaComponent = tableSchemaComponent; exports.DatabaseSchemaURNType = DatabaseSchemaURNType; exports.DatabaseSchemaURN = DatabaseSchemaURN; exports.databaseSchemaSchemaComponent = databaseSchemaSchemaComponent; exports.DatabaseURNType = DatabaseURNType; exports.DatabaseURN = DatabaseURN; exports.databaseSchemaComponent = databaseSchemaComponent; exports.relationship = relationship; exports.schemaComponentURN = schemaComponentURN; exports.dumboSchema = dumboSchema; exports.defaultDatabaseLockOptions = defaultDatabaseLockOptions; exports.NoDatabaseLock = NoDatabaseLock; 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.color = color; exports.prettyJson = prettyJson; exports.tracer = tracer; exports.LogLevel = LogLevel; exports.LogStyle = LogStyle; exports.migrationTableSchemaComponent = migrationTableSchemaComponent; exports.SchemaComponentMigrator = SchemaComponentMigrator; exports.MIGRATIONS_LOCK_ID = MIGRATIONS_LOCK_ID; exports.registerDefaultMigratorOptions = registerDefaultMigratorOptions; exports.getDefaultMigratorOptionsFromRegistry = getDefaultMigratorOptionsFromRegistry; exports.runSQLMigrations = runSQLMigrations; exports.combineMigrations = combineMigrations;
-//# sourceMappingURL=chunk-OJ34O3Q2.cjs.map