@event-driven-io/dumbo 0.13.0-beta.35 → 0.13.0-beta.36

package/dist/chunk-H2JBS7HM.js

@@ -1,2944 +0,0 @@
-// 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/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();
-
-// 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/schema/databaseMetadata/databaseMetadata.ts
-var DumboDatabaseMetadataRegistry = () => {
-  const infos = /* @__PURE__ */ new Map();
-  const register = (databaseType, info) => {
-    const entry = infos.get(databaseType);
-    if (entry && (typeof entry !== "function" || typeof info === "function")) {
-      return;
-    }
-    infos.set(databaseType, info);
-  };
-  const tryResolve = async (databaseType) => {
-    const entry = infos.get(databaseType);
-    if (!entry) return null;
-    if (typeof entry !== "function") return entry;
-    const resolved = await entry();
-    register(databaseType, resolved);
-    return resolved;
-  };
-  const tryGet = (databaseType) => {
-    const entry = infos.get(databaseType);
-    return entry && typeof entry !== "function" ? entry : null;
-  };
-  const has = (databaseType) => infos.has(databaseType);
-  return {
-    register,
-    tryResolve,
-    tryGet,
-    has,
-    get databaseTypes() {
-      return Array.from(infos.keys());
-    }
-  };
-};
-var dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry = globalThis.dumboDatabaseMetadataRegistry ?? DumboDatabaseMetadataRegistry();
-var getDatabaseMetadata = (driverType) => {
-  const { databaseType } = fromDatabaseDriverType(driverType);
-  return dumboDatabaseMetadataRegistry.tryGet(databaseType);
-};
-var resolveDatabaseMetadata = async (driverType, driverOverride) => {
-  if (driverOverride) return driverOverride;
-  const { databaseType } = fromDatabaseDriverType(driverType);
-  return dumboDatabaseMetadataRegistry.tryResolve(databaseType);
-};
-var getDefaultDatabase = (driverType) => {
-  const metadata = getDatabaseMetadata(driverType);
-  return metadata?.defaultDatabaseName;
-};
-var getDefaultDatabaseAsync = async (driverType) => {
-  const metadata = await resolveDatabaseMetadata(driverType);
-  return metadata?.defaultDatabaseName;
-};
-
-// 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/serializer/json/index.ts
-var bigIntReplacer = (_key, value) => {
-  return typeof value === "bigint" ? value.toString() : value;
-};
-var dateReplacer = (_key, value) => {
-  return value instanceof Date ? value.toISOString() : value;
-};
-var isFirstLetterNumeric = (str) => {
-  const c = str.charCodeAt(0);
-  return c >= 48 && c <= 57;
-};
-var isFirstLetterNumericOrMinus = (str) => {
-  const c = str.charCodeAt(0);
-  return c >= 48 && c <= 57 || c === 45;
-};
-var bigIntReviver = (_key, value, context) => {
-  if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
-    try {
-      return BigInt(context?.source ?? value.toString());
-    } catch {
-      return value;
-    }
-  }
-  if (typeof value === "string" && value.length > 15) {
-    if (isFirstLetterNumericOrMinus(value)) {
-      const num = Number(value);
-      if (Number.isFinite(num) && !Number.isSafeInteger(num)) {
-        try {
-          return BigInt(value);
-        } catch {
-        }
-      }
-    }
-  }
-  return value;
-};
-var dateReviver = (_key, value) => {
-  if (typeof value === "string" && value.length === 24 && isFirstLetterNumeric(value) && value[10] === "T" && value[23] === "Z") {
-    const date = new Date(value);
-    if (!isNaN(date.getTime())) {
-      return date;
-    }
-  }
-  return value;
-};
-var composeJSONReplacers = (...replacers) => {
-  const filteredReplacers = replacers.filter((r) => r !== void 0);
-  if (filteredReplacers.length === 0) return void 0;
-  return (key, value) => (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    filteredReplacers.reduce(
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (accValue, replacer) => replacer(key, accValue),
-      value
-    )
-  );
-};
-var composeJSONRevivers = (...revivers) => {
-  const filteredRevivers = revivers.filter((r) => r !== void 0);
-  if (filteredRevivers.length === 0) return void 0;
-  return (key, value, context) => (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    filteredRevivers.reduce(
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      (accValue, reviver) => reviver(key, accValue, context),
-      value
-    )
-  );
-};
-var JSONReplacer = (opts) => composeJSONReplacers(
-  opts?.replacer,
-  opts?.failOnBigIntSerialization !== true ? JSONReplacers.bigInt : void 0,
-  opts?.useDefaultDateSerialization !== true ? JSONReplacers.date : void 0
-);
-var JSONReviver = (opts) => composeJSONRevivers(
-  opts?.reviver,
-  opts?.parseBigInts === true ? JSONRevivers.bigInt : void 0,
-  opts?.parseDates === true ? JSONRevivers.date : void 0
-);
-var JSONReplacers = {
-  bigInt: bigIntReplacer,
-  date: dateReplacer
-};
-var JSONRevivers = {
-  bigInt: bigIntReviver,
-  date: dateReviver
-};
-var jsonSerializer = (options) => {
-  const defaultReplacer = JSONReplacer(options);
-  const defaultReviver = JSONReviver(options);
-  return {
-    serialize: (object, serializerOptions) => JSON.stringify(
-      object,
-      serializerOptions ? JSONReplacer(serializerOptions) : defaultReplacer
-    ),
-    deserialize: (payload, deserializerOptions) => JSON.parse(
-      payload,
-      deserializerOptions ? JSONReviver(deserializerOptions) : defaultReviver
-    )
-  };
-};
-var JSONSerializer = Object.assign(jsonSerializer(), {
-  from: (options) => options?.serialization?.serializer ?? (options?.serialization?.options ? jsonSerializer(options?.serialization?.options) : JSONSerializer)
-});
-var JSONCodec = (options) => {
-  const serializer = "serializer" in options ? options.serializer : jsonSerializer(
-    "serializerOptions" in options ? options.serializerOptions : void 0
-  );
-  const upcast = options.upcast ?? ((doc) => doc);
-  const downcast = options.downcast ?? ((doc) => doc);
-  return {
-    decode: (payload, decodeOptions) => {
-      const deserialized = decodeOptions ? serializer.deserialize(payload, decodeOptions) : serializer.deserialize(payload);
-      return upcast(deserialized);
-    },
-    encode: (object, encodeOptions) => {
-      const downcasted = downcast(object);
-      return encodeOptions ? serializer.serialize(downcasted, encodeOptions) : serializer.serialize(downcasted);
-    }
-  };
-};
-
-// 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", (input) => {
-  if (Array.isArray(input)) {
-    return { value: input };
-  }
-  return input.mode !== void 0 ? { value: input.value, mode: input.mode } : { value: input.value };
-});
-var SQLIn = SQLToken(
-  "SQL_IN",
-  ({ column, values, mode }) => mode !== void 0 ? {
-    column: SQLIdentifier.from(column),
-    values: SQLArray.from(values),
-    mode
-  } : {
-    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, serializer, 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, serializer));
-  }
-});
-var ExpandSQLInProcessor = SQLProcessor({
-  canHandle: "SQL_IN",
-  handle: (token, context) => {
-    const { builder, mapper, processorsRegistry, serializer } = context;
-    const { values: inValues, column } = token;
-    if (inValues.value.length === 0) {
-      builder.addParam(mapper.mapValue(false, serializer));
-      return;
-    }
-    builder.addSQL(mapper.mapValue(column.value, serializer));
-    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,
-      serializer
-    });
-    builder.addSQL(`)`);
-  }
-});
-var FormatIdentifierProcessor = SQLProcessor({
-  canHandle: "SQL_IDENTIFIER",
-  handle: (token, { builder, mapper, serializer }) => {
-    builder.addSQL(mapper.mapValue(token, serializer));
-  }
-});
-var MapLiteralProcessor = SQLProcessor({
-  canHandle: "SQL_LITERAL",
-  handle: (token, { builder, mapper, serializer }) => builder.addParam(mapper.mapValue(token.value, serializer))
-});
-
-// 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/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, serializer, mapOptions) => mapSQLParamValue(value, serializer, {
-      ...mapSQLParamValueOptions,
-      ...mapOptions
-    }),
-    mapPlaceholder: mapSQLParamValueOptions.mapPlaceholder,
-    mapIdentifier: mapSQLParamValueOptions.mapIdentifier
-  };
-  return resultMapper;
-};
-function mapSQLParamValue(value, serializer, 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, serializer, 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) : `${serializer.serialize(value).replace(/'/g, "''")}`;
-  } else {
-    return serializer.serialize(value);
-  }
-}
-
-// src/core/sql/formatters/sqlFormatter.ts
-var SQLFormatter = ({
-  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,
-      methodOptions?.serializer ?? JSONSerializer,
-      {
-        ...options,
-        ...methodOptions ?? {}
-      }
-    )),
-    describe: describe ?? ((sql, methodOptions) => describeSQL(
-      sql,
-      resultFormatter,
-      methodOptions?.serializer ?? JSONSerializer,
-      {
-        ...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, serializer, 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,
-      serializer,
-      mapper
-    });
-  }
-  return builder.build();
-}
-var describeSQL = (sql, formatter, serializer, options) => formatSQL(sql, formatter, serializer, {
-  ...options ?? {},
-  mapper: {
-    mapPlaceholder: (_, value) => serializer.serialize(value)
-  }
-}).query;
-
-// src/core/sql/sql.ts
-function SQL(strings, ...values) {
-  const parametrized = TokenizedSQL(strings, values);
-  return parametrized;
-}
-function RawSQL(strings, ...values) {
-  let result = "";
-  for (let i = 0; i < strings.length; i++) {
-    result += strings[i];
-    if (i < values.length) {
-      result += String(values[i]);
-    }
-  }
-  return {
-    __brand: "tokenized-sql",
-    sqlChunks: [result],
-    sqlTokens: []
-  };
-}
-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?.serializer ?? JSONSerializer, options);
-SQL.describe = (sql, formatter, options) => describeSQL(sql, formatter, options?.serializer ?? JSONSerializer, options);
-SQL.in = (column, values, options) => options?.mode ? SQLIn.from({ column, values, mode: options.mode }) : SQLIn.from({ column, values });
-SQL.array = (values, options) => SQLArray.from(options?.mode ? { value: values, mode: options.mode } : 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/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 getEnvVariable = (name) => {
-  try {
-    if (typeof process !== "undefined" && process.env) {
-      return process.env[name];
-    }
-    return void 0;
-  } catch {
-    return void 0;
-  }
-};
-var shouldLog = (logLevel) => {
-  const definedLogLevel = getEnvVariable("DUMBO_LOG_LEVEL") ?? LogLevel.ERROR;
-  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, serializer = JSONSerializer) => (event) => {
-  switch (logStyle) {
-    case "RAW":
-      return serializer.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,
-    getEnvVariable("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/sqlMigration.ts
-var sqlMigration = (name, sqls) => ({
-  name,
-  sqls
-});
-
-// src/core/errors/index.ts
-var isNumber = (val) => typeof val === "number" && val === val;
-var isString = (val) => typeof val === "string";
-var DumboError = class _DumboError extends Error {
-  static ErrorCode = 500;
-  static ErrorType = "DumboError";
-  errorCode;
-  errorType;
-  innerError;
-  constructor(options) {
-    const errorCode = options && typeof options === "object" && "errorCode" in options ? options.errorCode : isNumber(options) ? options : _DumboError.ErrorCode;
-    const errorType = options && typeof options === "object" && "errorType" in options ? options.errorType ?? _DumboError.ErrorType : _DumboError.ErrorType;
-    const message = options && typeof options === "object" && "message" in options ? options.message : isString(options) ? options : `Error with status code '${errorCode}' ocurred during DumboError processing`;
-    const innerError = options && typeof options === "object" && "innerError" in options ? options.innerError : void 0;
-    super(message, { cause: innerError });
-    this.errorCode = errorCode;
-    this.errorType = errorType;
-    this.innerError = innerError;
-    Object.setPrototypeOf(this, _DumboError.prototype);
-  }
-  static isInstanceOf(error, options) {
-    if (typeof error !== "object" || error === null || !("errorCode" in error) || !isNumber(error.errorCode) || !("errorType" in error) || !isString(error.errorType))
-      return false;
-    if (!options) return true;
-    if (options.errorCode !== void 0 && error.errorCode !== options.errorCode)
-      return false;
-    if (options.errorType !== void 0 && error.errorType !== options.errorType)
-      return false;
-    return true;
-  }
-};
-var ConcurrencyError = class _ConcurrencyError extends DumboError {
-  static ErrorCode = 412;
-  static ErrorType = "ConcurrencyError";
-  constructor(message, innerError) {
-    super({
-      errorCode: _ConcurrencyError.ErrorCode,
-      errorType: _ConcurrencyError.ErrorType,
-      message: message ?? `Expected document state does not match current one!`,
-      innerError
-    });
-    Object.setPrototypeOf(this, _ConcurrencyError.prototype);
-  }
-};
-var TransientDatabaseError = class _TransientDatabaseError extends DumboError {
-  static ErrorCode = 503;
-  static ErrorType = "TransientDatabaseError";
-  constructor(message, innerError) {
-    super({
-      errorCode: _TransientDatabaseError.ErrorCode,
-      errorType: _TransientDatabaseError.ErrorType,
-      message: message ?? `A transient error occurred during database operation. Retrying the operation might succeed.`,
-      innerError
-    });
-    Object.setPrototypeOf(this, _TransientDatabaseError.prototype);
-  }
-};
-var ConnectionError = class _ConnectionError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "ConnectionError";
-  constructor(message, innerError) {
-    super(
-      message ?? `A connection error occurred during database operation.`,
-      innerError
-    );
-    this.errorType = _ConnectionError.ErrorType;
-    Object.setPrototypeOf(this, _ConnectionError.prototype);
-  }
-};
-var SerializationError = class _SerializationError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "SerializationError";
-  constructor(message, innerError) {
-    super(
-      message ?? `A serialization failure occurred. The transaction can be retried.`,
-      innerError
-    );
-    this.errorType = _SerializationError.ErrorType;
-    Object.setPrototypeOf(this, _SerializationError.prototype);
-  }
-};
-var DeadlockError = class _DeadlockError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "DeadlockError";
-  constructor(message, innerError) {
-    super(
-      message ?? `A deadlock was detected. The transaction can be retried.`,
-      innerError
-    );
-    this.errorType = _DeadlockError.ErrorType;
-    Object.setPrototypeOf(this, _DeadlockError.prototype);
-  }
-};
-var LockNotAvailableError = class _LockNotAvailableError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "LockNotAvailableError";
-  constructor(message, innerError) {
-    super(message ?? `The requested lock is not available.`, innerError);
-    this.errorType = _LockNotAvailableError.ErrorType;
-    Object.setPrototypeOf(this, _LockNotAvailableError.prototype);
-  }
-};
-var InsufficientResourcesError = class _InsufficientResourcesError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "InsufficientResourcesError";
-  constructor(message, innerError) {
-    super(
-      message ?? `Insufficient resources to complete the database operation (e.g. disk full, out of memory, too many connections).`,
-      innerError
-    );
-    this.errorType = _InsufficientResourcesError.ErrorType;
-    Object.setPrototypeOf(this, _InsufficientResourcesError.prototype);
-  }
-};
-var SystemError = class _SystemError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "SystemError";
-  constructor(message, innerError) {
-    super(
-      message ?? `A system-level error occurred (e.g. I/O error).`,
-      innerError
-    );
-    this.errorType = _SystemError.ErrorType;
-    Object.setPrototypeOf(this, _SystemError.prototype);
-  }
-};
-var AdminShutdownError = class _AdminShutdownError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "AdminShutdownError";
-  constructor(message, innerError) {
-    super(
-      message ?? `The database server is shutting down or restarting.`,
-      innerError
-    );
-    this.errorType = _AdminShutdownError.ErrorType;
-    Object.setPrototypeOf(this, _AdminShutdownError.prototype);
-  }
-};
-var QueryCanceledError = class _QueryCanceledError extends TransientDatabaseError {
-  static ErrorCode = 503;
-  static ErrorType = "QueryCanceledError";
-  constructor(message, innerError) {
-    super(
-      message ?? `The query was canceled, e.g. due to statement timeout or user request.`,
-      innerError
-    );
-    this.errorType = _QueryCanceledError.ErrorType;
-    Object.setPrototypeOf(this, _QueryCanceledError.prototype);
-  }
-};
-var IntegrityConstraintViolationError = class _IntegrityConstraintViolationError extends DumboError {
-  static ErrorCode = 409;
-  static ErrorType = "IntegrityConstraintViolationError";
-  constructor(message, innerError) {
-    super({
-      errorCode: _IntegrityConstraintViolationError.ErrorCode,
-      errorType: _IntegrityConstraintViolationError.ErrorType,
-      message: message ?? `An integrity constraint violation occurred!`,
-      innerError
-    });
-    Object.setPrototypeOf(this, _IntegrityConstraintViolationError.prototype);
-  }
-};
-var UniqueConstraintError = class _UniqueConstraintError extends IntegrityConstraintViolationError {
-  static ErrorCode = 409;
-  static ErrorType = "UniqueConstraintError";
-  constructor(message, innerError) {
-    super(message ?? `Unique constraint violation occurred!`, innerError);
-    this.errorType = _UniqueConstraintError.ErrorType;
-    Object.setPrototypeOf(this, _UniqueConstraintError.prototype);
-  }
-};
-var ForeignKeyViolationError = class _ForeignKeyViolationError extends IntegrityConstraintViolationError {
-  static ErrorCode = 409;
-  static ErrorType = "ForeignKeyViolationError";
-  constructor(message, innerError) {
-    super(message ?? `Foreign key constraint violation occurred!`, innerError);
-    this.errorType = _ForeignKeyViolationError.ErrorType;
-    Object.setPrototypeOf(this, _ForeignKeyViolationError.prototype);
-  }
-};
-var NotNullViolationError = class _NotNullViolationError extends IntegrityConstraintViolationError {
-  static ErrorCode = 409;
-  static ErrorType = "NotNullViolationError";
-  constructor(message, innerError) {
-    super(message ?? `NOT NULL constraint violation occurred!`, innerError);
-    this.errorType = _NotNullViolationError.ErrorType;
-    Object.setPrototypeOf(this, _NotNullViolationError.prototype);
-  }
-};
-var CheckViolationError = class _CheckViolationError extends IntegrityConstraintViolationError {
-  static ErrorCode = 409;
-  static ErrorType = "CheckViolationError";
-  constructor(message, innerError) {
-    super(message ?? `CHECK constraint violation occurred!`, innerError);
-    this.errorType = _CheckViolationError.ErrorType;
-    Object.setPrototypeOf(this, _CheckViolationError.prototype);
-  }
-};
-var ExclusionViolationError = class _ExclusionViolationError extends IntegrityConstraintViolationError {
-  static ErrorCode = 409;
-  static ErrorType = "ExclusionViolationError";
-  constructor(message, innerError) {
-    super(message ?? `Exclusion constraint violation occurred!`, innerError);
-    this.errorType = _ExclusionViolationError.ErrorType;
-    Object.setPrototypeOf(this, _ExclusionViolationError.prototype);
-  }
-};
-var DataError = class _DataError extends DumboError {
-  static ErrorCode = 400;
-  static ErrorType = "DataError";
-  constructor(message, innerError) {
-    super({
-      errorCode: _DataError.ErrorCode,
-      errorType: _DataError.ErrorType,
-      message: message ?? `A data error occurred (e.g. invalid value, type mismatch).`,
-      innerError
-    });
-    Object.setPrototypeOf(this, _DataError.prototype);
-  }
-};
-var InvalidOperationError = class _InvalidOperationError extends DumboError {
-  static ErrorCode = 400;
-  static ErrorType = "InvalidOperationError";
-  constructor(message, innerError) {
-    super({
-      errorCode: _InvalidOperationError.ErrorCode,
-      errorType: _InvalidOperationError.ErrorType,
-      message: message ?? `Invalid operation (e.g. syntax error, insufficient privileges, undefined table).`,
-      innerError
-    });
-    Object.setPrototypeOf(this, _InvalidOperationError.prototype);
-  }
-};
-
-// src/core/execute/execute.ts
-var mapColumnToJSON = (column, serializer, options) => ({
-  [column]: (value) => {
-    if (typeof value === "string") {
-      try {
-        return serializer.deserialize(value, options);
-      } catch {
-      }
-    }
-    return value;
-  }
-});
-var mapColumnToBigint = (column) => ({
-  [column]: (value) => {
-    if (typeof value === "number" || typeof value === "string") {
-      return BigInt(value);
-    }
-    return value;
-  }
-});
-var mapColumnToDate = (column) => ({
-  [column]: (value) => {
-    if (typeof value === "number" || typeof value === "string") {
-      return new Date(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 BatchCommandNoChangesError = class _BatchCommandNoChangesError extends DumboError {
-  statementIndex;
-  constructor(statementIndex) {
-    super({
-      errorCode: 409,
-      message: `Batch command at index ${statementIndex} affected no rows`
-    });
-    this.name = "BatchCommandNoChangesError";
-    this.statementIndex = statementIndex;
-    Object.setPrototypeOf(this, _BatchCommandNoChangesError.prototype);
-  }
-};
-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();
-    const withTx = connection.withTransaction;
-    return wrapInConnectionClosure(connection, () => withTx(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();
-    const withTx = connection.withTransaction;
-    return withTx(handle, options);
-  }
-});
-var transactionFactoryWithAsyncAmbientConnection = (driverType, connect, close) => {
-  close ??= () => Promise.resolve();
-  return {
-    transaction: (options) => {
-      let conn = null;
-      let innerTx = null;
-      let connectingPromise = null;
-      const ensureConnection = async () => {
-        if (conn) return innerTx;
-        if (!connectingPromise) {
-          connectingPromise = (async () => {
-            conn = await connect();
-            innerTx = conn.transaction(options);
-          })();
-        }
-        await connectingPromise;
-        return innerTx;
-      };
-      const tx = {
-        driverType,
-        get connection() {
-          if (!conn) {
-            throw new Error("Transaction not started - call begin() first");
-          }
-          return conn;
-        },
-        execute: {
-          query: async (sql, queryOptions) => {
-            const tx2 = await ensureConnection();
-            return tx2.execute.query(sql, queryOptions);
-          },
-          batchQuery: async (sqls, queryOptions) => {
-            const tx2 = await ensureConnection();
-            return tx2.execute.batchQuery(sqls, queryOptions);
-          },
-          command: async (sql, commandOptions) => {
-            const tx2 = await ensureConnection();
-            return tx2.execute.command(sql, commandOptions);
-          },
-          batchCommand: async (sqls, commandOptions) => {
-            const tx2 = await ensureConnection();
-            return tx2.execute.batchCommand(sqls, commandOptions);
-          }
-        },
-        begin: async () => {
-          const tx2 = await ensureConnection();
-          return tx2.begin();
-        },
-        commit: async () => {
-          if (!innerTx) {
-            throw new Error("Transaction not started");
-          }
-          try {
-            return await innerTx.commit();
-          } finally {
-            if (conn) await close(conn);
-          }
-        },
-        rollback: async (error) => {
-          if (!innerTx) {
-            if (conn) await close(conn);
-            return;
-          }
-          try {
-            return await innerTx.rollback(error);
-          } finally {
-            if (conn) await close(conn);
-          }
-        },
-        _transactionOptions: void 0
-      };
-      return tx;
-    },
-    withTransaction: async (handle, options) => {
-      const conn = await connect();
-      try {
-        const withTx = conn.withTransaction;
-        return await withTx(handle, options);
-      } finally {
-        await close(conn);
-      }
-    }
-  };
-};
-
-// src/core/connections/connection.ts
-var createAmbientConnection = (options) => {
-  const { driverType, client, executor, initTransaction, serializer } = 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({ serializer }), { connect: open }),
-    _transactionType: void 0
-  };
-  const typedConnection = connection;
-  return typedConnection;
-};
-var createSingletonConnection = (options) => {
-  const { driverType, connect, close, initTransaction, executor, serializer } = 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({ serializer }), { connect: getClient }),
-    _transactionType: void 0
-  };
-  const typedConnection = connection;
-  return typedConnection;
-};
-var createTransientConnection = (options) => {
-  const { driverType, open, close, initTransaction, executor, serializer } = options;
-  const connection = {
-    driverType,
-    open,
-    close,
-    ...transactionFactoryWithDbClient(
-      open,
-      initTransaction(() => typedConnection)
-    ),
-    execute: sqlExecutor(executor({ serializer }), { connect: open }),
-    _transactionType: void 0
-  };
-  const typedConnection = connection;
-  return typedConnection;
-};
-var createConnection = (options) => {
-  const { driverType, connect, close, initTransaction, executor, serializer } = 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({ serializer }), { connect: getClient }),
-    _transactionType: void 0
-  };
-  const typedConnection = connection;
-  return typedConnection;
-};
-
-// src/core/taskProcessing/executionGuards.ts
-import { v7 as uuid } from "uuid";
-
-// src/core/taskProcessing/taskProcessor.ts
-var TaskProcessor = class {
-  queue = [];
-  isProcessing = false;
-  activeTasks = 0;
-  activeGroups = /* @__PURE__ */ new Set();
-  options;
-  stopped = false;
-  constructor(options) {
-    this.options = options;
-  }
-  enqueue(task, options) {
-    if (this.stopped) {
-      return Promise.reject(new DumboError("TaskProcessor has been stopped"));
-    }
-    if (this.queue.length >= this.options.maxQueueSize) {
-      return Promise.reject(
-        new TransientDatabaseError(
-          "Too many pending connections. Please try again later."
-        )
-      );
-    }
-    return this.schedule(task, options);
-  }
-  waitForEndOfProcessing() {
-    return this.schedule(({ ack }) => Promise.resolve(ack()));
-  }
-  async stop(options) {
-    if (this.stopped) return;
-    this.stopped = true;
-    this.queue.length = 0;
-    this.activeGroups.clear();
-    if (!options?.force) {
-      await this.waitForEndOfProcessing();
-    }
-  }
-  schedule(task, options) {
-    return promiseWithDeadline(
-      (resolve, reject) => {
-        const taskWithContext = () => {
-          return new Promise((resolveTask, failTask) => {
-            const taskPromise = task({
-              ack: resolveTask
-            });
-            taskPromise.then(resolve).catch((err) => {
-              failTask(err);
-              reject(err);
-            });
-          });
-        };
-        this.queue.push({ task: taskWithContext, options });
-        if (!this.isProcessing) {
-          this.ensureProcessing();
-        }
-      },
-      { deadline: this.options.maxTaskIdleTime }
-    );
-  }
-  ensureProcessing() {
-    if (this.isProcessing) return;
-    this.isProcessing = true;
-    this.processQueue();
-  }
-  processQueue() {
-    try {
-      while (this.activeTasks < this.options.maxActiveTasks && this.queue.length > 0) {
-        const item = this.takeFirstAvailableItem();
-        if (item === null) return;
-        const groupId = item.options?.taskGroupId;
-        if (groupId) {
-          this.activeGroups.add(groupId);
-        }
-        this.activeTasks++;
-        void this.executeItem(item);
-      }
-    } catch (error) {
-      console.error(error);
-      throw error;
-    } finally {
-      this.isProcessing = false;
-      if (this.hasItemsToProcess() && this.activeTasks < this.options.maxActiveTasks) {
-        this.ensureProcessing();
-      }
-    }
-  }
-  async executeItem({ task, options }) {
-    try {
-      await task();
-    } finally {
-      this.activeTasks--;
-      if (options && options.taskGroupId) {
-        this.activeGroups.delete(options.taskGroupId);
-      }
-      this.ensureProcessing();
-    }
-  }
-  takeFirstAvailableItem = () => {
-    const taskIndex = this.queue.findIndex(
-      (item2) => !item2.options?.taskGroupId || !this.activeGroups.has(item2.options.taskGroupId)
-    );
-    if (taskIndex === -1) {
-      return null;
-    }
-    const [item] = this.queue.splice(taskIndex, 1);
-    return item ?? null;
-  };
-  hasItemsToProcess = () => this.queue.findIndex(
-    (item) => !item.options?.taskGroupId || !this.activeGroups.has(item.options.taskGroupId)
-  ) !== -1;
-};
-var DEFAULT_PROMISE_DEADLINE = 2147483647;
-var promiseWithDeadline = (executor, options) => {
-  return new Promise((resolve, reject) => {
-    let taskStarted = false;
-    let timeoutId = null;
-    const deadline = options.deadline ?? DEFAULT_PROMISE_DEADLINE;
-    timeoutId = setTimeout(() => {
-      if (!taskStarted) {
-        reject(
-          new Error("Task was not started within the maximum waiting time")
-        );
-      }
-    }, deadline);
-    timeoutId.unref();
-    executor(
-      (value) => {
-        taskStarted = true;
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        timeoutId = null;
-        resolve(value);
-      },
-      (reason) => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        timeoutId = null;
-        reject(reason);
-      }
-    );
-  });
-};
-
-// src/core/taskProcessing/executionGuards.ts
-var guardBoundedAccess = (getResource, options) => {
-  let isStopped = false;
-  const taskProcessor = new TaskProcessor({
-    maxActiveTasks: options.maxResources,
-    maxQueueSize: options.maxQueueSize ?? 1e3
-  });
-  const resourcePool = [];
-  const allResources = /* @__PURE__ */ new Set();
-  const ackCallbacks = /* @__PURE__ */ new Map();
-  const acquire = async () => taskProcessor.enqueue(async ({ ack }) => {
-    try {
-      let resource;
-      if (options.reuseResources) {
-        resource = resourcePool.pop();
-      }
-      if (!resource) {
-        resource = await getResource();
-        allResources.add(resource);
-      }
-      ackCallbacks.set(resource, ack);
-      return resource;
-    } catch (e) {
-      ack();
-      throw e;
-    }
-  });
-  const release = (resource) => {
-    const ack = ackCallbacks.get(resource);
-    if (ack) {
-      ackCallbacks.delete(resource);
-      if (options.reuseResources) {
-        resourcePool.push(resource);
-      }
-      ack();
-    }
-  };
-  const execute = async (operation) => {
-    const resource = await acquire();
-    try {
-      return await operation(resource);
-    } finally {
-      release(resource);
-    }
-  };
-  return {
-    acquire,
-    release,
-    execute,
-    waitForIdle: () => taskProcessor.waitForEndOfProcessing(),
-    stop: async (stopOptions) => {
-      if (isStopped) return;
-      isStopped = true;
-      if (options?.closeResource) {
-        const resources = [...allResources];
-        allResources.clear();
-        resourcePool.length = 0;
-        await Promise.all(
-          resources.map(
-            async (resource) => await options.closeResource(resource)
-          )
-        );
-      }
-      await taskProcessor.stop(stopOptions);
-    }
-  };
-};
-var guardInitializedOnce = (initialize, options) => {
-  let initPromise = null;
-  const taskProcessor = new TaskProcessor({
-    maxActiveTasks: 1,
-    maxQueueSize: options?.maxQueueSize ?? 1e3
-  });
-  const ensureInitialized = async (retryCount = 0) => {
-    if (initPromise !== null) {
-      return initPromise;
-    }
-    return taskProcessor.enqueue(
-      async ({ ack }) => {
-        if (initPromise !== null) {
-          ack();
-          return initPromise;
-        }
-        try {
-          const promise = initialize();
-          initPromise = promise;
-          const result = await promise;
-          ack();
-          return result;
-        } catch (error) {
-          initPromise = null;
-          ack();
-          const maxRetries = options?.maxRetries ?? 3;
-          if (retryCount < maxRetries) {
-            return ensureInitialized(retryCount + 1);
-          }
-          throw error;
-        }
-      },
-      { taskGroupId: uuid() }
-    );
-  };
-  return {
-    ensureInitialized,
-    reset: () => {
-      initPromise = null;
-    },
-    stop: (options2) => taskProcessor.stop(options2)
-  };
-};
-
-// src/core/connections/pool.ts
-var wrapPooledConnection = (conn, onClose) => ({ ...conn, close: onClose });
-var createAmbientConnectionPool = (options) => {
-  const { driverType, connection } = options;
-  return createConnectionPool({
-    driverType,
-    getConnection: () => connection,
-    execute: connection.execute,
-    transaction: (options2) => connection.transaction(
-      options2
-    ),
-    withConnection: (handle, _options) => handle(connection),
-    withTransaction: (handle, options2) => {
-      const withTx = connection.withTransaction;
-      return withTx(handle, options2);
-    }
-  });
-};
-var createSingletonConnectionPool = (options) => {
-  const { driverType, getConnection } = options;
-  let connectionPromise = null;
-  const getExistingOrNewConnection = () => {
-    if (!connectionPromise) {
-      connectionPromise ??= Promise.resolve(getConnection());
-    }
-    return connectionPromise;
-  };
-  const result = {
-    driverType,
-    connection: () => getExistingOrNewConnection().then(
-      (conn) => wrapPooledConnection(conn, () => Promise.resolve())
-    ),
-    execute: sqlExecutorInAmbientConnection({
-      driverType,
-      connection: getExistingOrNewConnection
-    }),
-    withConnection: (handle, _options) => executeInAmbientConnection(handle, {
-      connection: getExistingOrNewConnection
-    }),
-    ...transactionFactoryWithAsyncAmbientConnection(
-      options.driverType,
-      getExistingOrNewConnection,
-      options.closeConnection
-    ),
-    close: async () => {
-      if (!connectionPromise) return;
-      const connection = await connectionPromise;
-      await connection.close();
-    }
-  };
-  return result;
-};
-var createBoundedConnectionPool = (options) => {
-  const { driverType, maxConnections } = options;
-  const guardMaxConnections = guardBoundedAccess(options.getConnection, {
-    maxResources: maxConnections,
-    reuseResources: true
-  });
-  let closed = false;
-  const executeWithPooling = async (operation) => {
-    const conn = await guardMaxConnections.acquire();
-    try {
-      return await operation(conn);
-    } finally {
-      guardMaxConnections.release(conn);
-    }
-  };
-  return {
-    driverType,
-    connection: async () => {
-      const conn = await guardMaxConnections.acquire();
-      return wrapPooledConnection(
-        conn,
-        () => Promise.resolve(guardMaxConnections.release(conn))
-      );
-    },
-    execute: {
-      query: (sql, opts) => executeWithPooling((c) => c.execute.query(sql, opts)),
-      batchQuery: (sqls, opts) => executeWithPooling((c) => c.execute.batchQuery(sqls, opts)),
-      command: (sql, opts) => executeWithPooling((c) => c.execute.command(sql, opts)),
-      batchCommand: (sqls, opts) => executeWithPooling((c) => c.execute.batchCommand(sqls, opts))
-    },
-    withConnection: executeWithPooling,
-    ...transactionFactoryWithAsyncAmbientConnection(
-      driverType,
-      guardMaxConnections.acquire,
-      guardMaxConnections.release
-    ),
-    close: async () => {
-      if (closed) return;
-      closed = true;
-      await guardMaxConnections.stop({ force: true });
-    }
-  };
-};
-var createSingletonClientConnectionPool = (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, _options) => 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/index.ts
-SQL.columnN = Object.assign(dumboSchema.column, {
-  type: SQLColumnTypeTokensFactory
-});
-
-// 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,
-    ignoreMigrationHashMismatch: defaultOptions.ignoreMigrationHashMismatch ?? partialOptions?.ignoreMigrationHashMismatch,
-    migrationTimeoutMs: defaultOptions.migrationTimeoutMs ?? partialOptions?.migrationTimeoutMs
-  };
-  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;
-  const result = { applied: [], skipped: [] };
-  await databaseLock.withAcquire(
-    execute,
-    async () => {
-      for (const migration of coreMigrations) {
-        await execute.batchCommand(migration.sqls, {
-          timeoutMs: options.migrationTimeoutMs
-        });
-      }
-      for (const migration of migrations) {
-        const wasApplied = await runSQLMigration(
-          databaseType,
-          execute,
-          migration,
-          {
-            ignoreMigrationHashMismatch: options.ignoreMigrationHashMismatch ?? false,
-            migrationTimeoutMs: options.migrationTimeoutMs
-          }
-        );
-        if (wasApplied) {
-          result.applied.push(migration);
-        } else {
-          result.skipped.push(migration);
-        }
-      }
-    },
-    lockOptions
-  );
-  return { success: options.dryRun ? false : true, result };
-});
-var runSQLMigration = async (databaseType, execute, migration, options) => {
-  const sqls = combineMigrations(migration);
-  const sqlHash = await getMigrationHash(migration, getFormatter(databaseType));
-  try {
-    const newMigration = {
-      name: migration.name,
-      sqlHash
-    };
-    const checkResult = await ensureMigrationWasNotAppliedYet(
-      execute,
-      newMigration
-    );
-    if (checkResult.exists === true) {
-      if (checkResult.hashesMatch === true) {
-        tracer.info("migration-already-applied", {
-          migrationName: migration.name
-        });
-        return false;
-      }
-      if (options?.ignoreMigrationHashMismatch !== true)
-        throw new Error(
-          `Migration hash mismatch for "${migration.name}". Aborting migration.`
-        );
-      tracer.warn("migration-hash-mismatch", {
-        migrationName: migration.name,
-        expectedHash: sqlHash,
-        actualHash: checkResult.hashFromDB
-      });
-      await updateMigrationHash(execute, newMigration);
-      return false;
-    }
-    await execute.batchCommand(sqls, {
-      timeoutMs: options?.migrationTimeoutMs
-    });
-    await recordMigration(execute, newMigration);
-    return true;
-  } catch (error) {
-    tracer.error("migration-error", {
-      migationName: migration.name,
-      error
-    });
-    throw error;
-  }
-};
-var getMigrationHash = async (sqlMigration2, sqlFormatter) => {
-  const content = sqlFormatter.describe(sqlMigration2.sqls, {
-    serializer: JSONSerializer
-  });
-  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 as "sqlHash" FROM dmb_migrations WHERE name = ${migration.name}`
-    )
-  );
-  if (result === null) return { exists: false };
-  const { sqlHash } = result;
-  return {
-    exists: true,
-    hashesMatch: sqlHash === migration.sqlHash,
-    hashFromDB: sqlHash
-  };
-};
-var recordMigration = async (execute, migration) => {
-  await execute.command(
-    SQL`
-      INSERT INTO dmb_migrations (name, sql_hash)
-      VALUES (${migration.name}, ${migration.sqlHash})`
-  );
-};
-var updateMigrationHash = async (execute, migration) => {
-  await execute.command(
-    SQL`
-      UPDATE dmb_migrations
-      SET sql_hash = ${migration.sqlHash}, timestamp = ${/* @__PURE__ */ new Date()}
-      WHERE name = ${migration.name}
-      `
-  );
-};
-
-// src/core/schema/migrators/schemaComponentMigrator.ts
-var { AutoIncrement, Varchar, Timestamp } = SQL.column.type;
-var migrationTableSQL = SQL`
-  CREATE TABLE IF NOT EXISTS dmb_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}`
-        )
-      );
-    }
-  };
-};
-
-export {
-  schemaComponent,
-  isSchemaComponentOfType,
-  filterSchemaComponentsOfType,
-  mapSchemaComponentsOfType,
-  findSchemaComponentsOfType,
-  ColumnURNType,
-  ColumnURN,
-  columnSchemaComponent,
-  IndexURNType,
-  IndexURN,
-  indexSchemaComponent,
-  TableURNType,
-  TableURN,
-  tableSchemaComponent,
-  DatabaseSchemaURNType,
-  DatabaseSchemaURN,
-  databaseSchemaSchemaComponent,
-  DatabaseURNType,
-  DatabaseURN,
-  databaseSchemaComponent,
-  relationship,
-  schemaComponentURN,
-  canHandleDriverWithConnectionString,
-  DumboDatabaseDriverRegistry,
-  dumboDatabaseDriverRegistry,
-  toDatabaseDriverType,
-  fromDatabaseDriverType,
-  getDatabaseDriverName,
-  getDatabaseType,
-  DumboDatabaseMetadataRegistry,
-  dumboDatabaseMetadataRegistry,
-  getDatabaseMetadata,
-  resolveDatabaseMetadata,
-  getDefaultDatabase,
-  getDefaultDatabaseAsync,
-  dumboSchema,
-  defaultDatabaseLockOptions,
-  NoDatabaseLock,
-  mapRows,
-  toCamelCase,
-  mapToCamelCase,
-  firstOrNull,
-  first,
-  singleOrNull,
-  single,
-  count,
-  exists,
-  composeJSONReplacers,
-  composeJSONRevivers,
-  JSONReplacer,
-  JSONReviver,
-  JSONReplacers,
-  JSONRevivers,
-  jsonSerializer,
-  JSONSerializer,
-  JSONCodec,
-  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,
-  RawSQL,
-  isSQL,
-  ansiSqlReservedMap,
-  ANSISQLParamPlaceholder,
-  ANSISQLIdentifierQuote,
-  mapANSISQLParamPlaceholder,
-  mapSQLIdentifier,
-  DefaultMapSQLParamValueOptions,
-  SQLValueMapper,
-  mapSQLParamValue,
-  SQLFormatter,
-  registerFormatter,
-  getFormatter,
-  formatSQL,
-  describeSQL,
-  color,
-  prettyJson,
-  tracer,
-  LogLevel,
-  LogStyle,
-  sqlMigration,
-  migrationTableSchemaComponent,
-  SchemaComponentMigrator,
-  MIGRATIONS_LOCK_ID,
-  registerDefaultMigratorOptions,
-  getDefaultMigratorOptionsFromRegistry,
-  runSQLMigrations,
-  combineMigrations,
-  DumboError,
-  ConcurrencyError,
-  TransientDatabaseError,
-  ConnectionError,
-  SerializationError,
-  DeadlockError,
-  LockNotAvailableError,
-  InsufficientResourcesError,
-  SystemError,
-  AdminShutdownError,
-  QueryCanceledError,
-  IntegrityConstraintViolationError,
-  UniqueConstraintError,
-  ForeignKeyViolationError,
-  NotNullViolationError,
-  CheckViolationError,
-  ExclusionViolationError,
-  DataError,
-  InvalidOperationError,
-  mapColumnToJSON,
-  mapColumnToBigint,
-  mapColumnToDate,
-  mapSQLQueryResult,
-  BatchCommandNoChangesError,
-  sqlExecutor,
-  sqlExecutorInNewConnection,
-  sqlExecutorInAmbientConnection,
-  executeInNewDbClient,
-  executeInNewConnection,
-  executeInAmbientConnection,
-  executeInTransaction,
-  transactionFactoryWithDbClient,
-  transactionFactoryWithNewConnection,
-  transactionFactoryWithAmbientConnection,
-  transactionFactoryWithAsyncAmbientConnection,
-  createAmbientConnection,
-  createSingletonConnection,
-  createTransientConnection,
-  createConnection,
-  guardInitializedOnce,
-  createAmbientConnectionPool,
-  createSingletonConnectionPool,
-  createBoundedConnectionPool,
-  createSingletonClientConnectionPool,
-  createAlwaysNewConnectionPool,
-  createConnectionPool
-};
-//# sourceMappingURL=chunk-H2JBS7HM.js.map