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

package/dist/chunk-N7RWT46K.js

@@ -1,2011 +0,0 @@
-// 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) => 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/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: 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 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 = 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 = options?.quote ?? ANSISQLIdentifierQuote;
-  if (/^[a-z_][a-z0-9_$]*$/.test(ident) && !isReserved(ident, options?.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,
-    ...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 = options?.mapValue ?? mapSQLParamValue;
-    return options?.mapArray ? options.mapArray(value, mapValue) : value.map((item) => mapValue(item, options));
-  } else if (typeof value === "boolean") {
-    return options?.mapBoolean ? options.mapBoolean(value) : value;
-  } else if (typeof value === "bigint") {
-    return options?.mapBigInt ? options.mapBigInt(value) : value.toString();
-  } else if (value instanceof Date) {
-    return options?.mapDate ? options.mapDate(value) : value.toISOString();
-  } else if (SQL.check.isIdentifier(value)) {
-    return (options?.mapIdentifier ?? mapSQLIdentifier)(value.value);
-  } else if (typeof value === "object") {
-    return options?.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: processorsRegistry ?? defaultProcessorsRegistry
-  };
-  const resultFormatter = {
-    format: format ?? ((sql, methodOptions) => formatSQL(sql, resultFormatter, {
-      ...options,
-      ...methodOptions ?? {}
-    })),
-    describe: describe ?? ((sql, methodOptions) => describeSQL(sql, resultFormatter, {
-      ...options,
-      ...methodOptions ?? {}
-    })),
-    valueMapper
-  };
-  return resultFormatter;
-};
-var dumboSQLFormatters = globalThis.dumboSQLFormatters = 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 = context?.mapper == void 0 ? formatter.valueMapper : {
-    ...formatter.valueMapper,
-    ...context.mapper
-  };
-  const processorsRegistry = context?.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, {
-  ...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 {
-      }
-    }
-    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) => currentTransaction ?? (currentTransaction = initTransaction(connect(), {
-    close: () => {
-      currentTransaction = void 0;
-      return Promise.resolve();
-    },
-    ...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 = () => 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(
-    options.components?.map((comp) => [comp.schemaComponentKey, comp])
-  );
-  const migrations = [...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: migrationsOrComponents.migrations ?? [],
-    components: [...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: migrationsOrComponents.migrations ?? [],
-    components: [
-      ...migrationsOrComponents.components ?? [],
-      ...Object.values(columns)
-    ]
-  });
-  return {
-    ...base,
-    tableName,
-    primaryKey: 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: migrationsOrComponents.migrations ?? [],
-    components: [
-      ...migrationsOrComponents.components ?? [],
-      ...Object.values(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: migrationsOrComponents.migrations ?? [],
-    components: [
-      ...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: options?.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: columns ?? {},
-    primaryKey: primaryKey ?? [],
-    ...relationships !== void 0 ? { relationships } : {},
-    components,
-    ...options
-  });
-};
-function dumboDatabaseSchema(nameOrTables, tables, options) {
-  const schemaName = typeof nameOrTables === "string" ? nameOrTables : DEFAULT_DATABASE_SCHEMA_NAME;
-  const tablesMap = (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" ? 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) => g[1]?.toUpperCase() ?? "");
-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 ? 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 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
-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((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, 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 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,
-    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 = 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,
-      ...partialOptions?.schema ?? {}
-    },
-    lock: {
-      ...defaultOptions.lock,
-      ...partialOptions?.lock,
-      options: {
-        lockId: MIGRATIONS_LOCK_ID,
-        ...defaultOptions.lock?.options,
-        ...partialOptions?.lock?.options
-      }
-    },
-    dryRun: defaultOptions.dryRun ?? partialOptions?.dryRun
-  };
-  const { databaseLock: _, ...rest } = options.lock ?? {};
-  const databaseLock = options.lock?.databaseLock ?? NoDatabaseLock;
-  const lockOptions = {
-    lockId: MIGRATIONS_LOCK_ID,
-    ...rest
-  };
-  const migrationTable = options.schema?.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 = globalThis.dumboDatabaseDriverRegistry ?? DumboDatabaseDriverRegistry();
-
-export {
-  canHandleDriverWithConnectionString,
-  DumboDatabaseDriverRegistry,
-  dumboDatabaseDriverRegistry,
-  toDatabaseDriverType,
-  fromDatabaseDriverType,
-  getDatabaseDriverName,
-  getDatabaseType,
-  composeJSONReplacers,
-  composeJSONRevivers,
-  JSONReplacer,
-  JSONReviver,
-  JSONReplacers,
-  JSONRevivers,
-  jsonSerializer,
-  JSONSerializer,
-  RawJSONSerializer,
-  ParametrizedSQLBuilder,
-  SQLToken,
-  SQLIdentifier,
-  SQLPlain,
-  SQLLiteral,
-  SQLArray,
-  SQLIn,
-  ColumnTypeToken,
-  SerialToken,
-  BigSerialToken,
-  IntegerToken,
-  BigIntegerToken,
-  JSONBToken,
-  TimestampToken,
-  TimestamptzToken,
-  VarcharToken,
-  AutoIncrementSQLColumnToken,
-  SQLColumnTypeTokens,
-  SQLColumnTypeTokensFactory,
-  SQLColumnToken,
-  SQLProcessor,
-  ExpandArrayProcessor,
-  ExpandSQLInProcessor,
-  FormatIdentifierProcessor,
-  MapLiteralProcessor,
-  SQLProcessorsRegistry,
-  mapDefaultSQLColumnProcessors,
-  defaultProcessorsRegistry,
-  TokenizedSQL,
-  isTokenizedSQL,
-  SQL,
-  isSQL,
-  ansiSqlReservedMap,
-  ANSISQLParamPlaceholder,
-  ANSISQLIdentifierQuote,
-  mapANSISQLParamPlaceholder,
-  mapSQLIdentifier,
-  DefaultMapSQLParamValueOptions,
-  SQLValueMapper,
-  mapSQLParamValue,
-  SQLFormatter2 as SQLFormatter,
-  registerFormatter,
-  getFormatter,
-  formatSQL,
-  describeSQL,
-  mapColumnToJSON,
-  mapColumnToBigint,
-  mapSQLQueryResult,
-  sqlExecutor,
-  sqlExecutorInNewConnection,
-  sqlExecutorInAmbientConnection,
-  executeInNewDbClient,
-  executeInNewConnection,
-  executeInAmbientConnection,
-  executeInTransaction,
-  transactionFactoryWithDbClient,
-  transactionFactoryWithNewConnection,
-  transactionFactoryWithAmbientConnection,
-  createAmbientConnection,
-  createSingletonConnection,
-  createTransientConnection,
-  createConnection,
-  createAmbientConnectionPool,
-  createSingletonConnectionPool,
-  createSingletonClientPool,
-  createAlwaysNewConnectionPool,
-  createConnectionPool,
-  sqlMigration,
-  schemaComponent,
-  isSchemaComponentOfType,
-  filterSchemaComponentsOfType,
-  mapSchemaComponentsOfType,
-  findSchemaComponentsOfType,
-  ColumnURNType,
-  ColumnURN,
-  columnSchemaComponent,
-  IndexURNType,
-  IndexURN,
-  indexSchemaComponent,
-  TableURNType,
-  TableURN,
-  tableSchemaComponent,
-  DatabaseSchemaURNType,
-  DatabaseSchemaURN,
-  databaseSchemaSchemaComponent,
-  DatabaseURNType,
-  DatabaseURN,
-  databaseSchemaComponent,
-  relationship,
-  schemaComponentURN,
-  dumboSchema,
-  defaultDatabaseLockOptions,
-  NoDatabaseLock,
-  mapRows,
-  toCamelCase,
-  mapToCamelCase,
-  firstOrNull,
-  first,
-  singleOrNull,
-  single,
-  count,
-  exists,
-  color,
-  prettyJson,
-  tracer,
-  LogLevel,
-  LogStyle,
-  migrationTableSchemaComponent,
-  SchemaComponentMigrator,
-  MIGRATIONS_LOCK_ID,
-  registerDefaultMigratorOptions,
-  getDefaultMigratorOptionsFromRegistry,
-  runSQLMigrations,
-  combineMigrations
-};
-//# sourceMappingURL=chunk-N7RWT46K.js.map