@event-driven-io/dumbo 0.13.0-beta.3 → 0.13.0-beta.30

package/dist/{chunk-N7RWT46K.js → chunk-JKE6SULM.js}

@@ -1,1718 +1,2487 @@
-// src/core/drivers/index.ts
-function toDatabaseDriverType(databaseType, driverName) {
-  return `${databaseType}:${driverName}`;
-}
-function fromDatabaseDriverType(databaseDriverType) {
-  const parts = databaseDriverType.split(":");
+// 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 {
-    databaseType: parts[0],
-    driverName: parts[1]
+    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);
+    }
   };
-}
-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 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 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 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;
 };
-var JSONRevivers = {
-  bigInt: bigIntReviver
+
+// 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;
 };
-var jsonSerializer = (options) => {
-  const defaultReplacer = JSONReplacer(options);
-  const defaultReviver = JSONReviver(options);
+
+// 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 {
-    serialize: (object, options2) => JSON.stringify(object, options2 ? JSONReplacer(options2) : defaultReplacer),
-    deserialize: (payload, options2) => JSON.parse(payload, options2 ? JSONReviver(options2) : defaultReviver)
+    ...sc,
+    indexName,
+    get columnNames() {
+      return columnNames;
+    },
+    addColumn: (column) => columnNames.push(typeof column === "string" ? column : column.columnName),
+    isUnique
   };
 };
-var JSONSerializer = jsonSerializer({ disableBigIntSerialization: false });
-var RawJSONSerializer = jsonSerializer({ disableBigIntSerialization: true });
 
-// src/core/sql/parametrizedSQL/parametrizedSQL.ts
-var ParametrizedSQLBuilder = ({
-  mapParamPlaceholder
+// src/core/schema/components/tableSchemaComponent.ts
+var TableURNType = "sc:dumbo:table";
+var TableURN = ({ name }) => `${TableURNType}:${name}`;
+var tableSchemaComponent = ({
+  tableName,
+  columns,
+  primaryKey,
+  relationships,
+  ...migrationsOrComponents
 }) => {
-  const sql = [];
-  const params = [];
+  columns ??= {};
+  relationships ??= {};
+  const base = schemaComponent(TableURN({ name: tableName }), {
+    migrations: migrationsOrComponents.migrations ?? [],
+    components: [
+      ...migrationsOrComponents.components ?? [],
+      ...Object.values(columns)
+    ]
+  });
   return {
-    addSQL(str) {
-      sql.push(str);
-      return this;
-    },
-    addParam(value) {
-      sql.push(mapParamPlaceholder(params.length, value));
-      params.push(value);
-      return this;
+    ...base,
+    tableName,
+    primaryKey: primaryKey ?? [],
+    relationships,
+    get columns() {
+      const columnsMap = mapSchemaComponentsOfType(
+        base.components,
+        ColumnURNType,
+        (c) => c.columnName
+      );
+      return Object.assign(columnsMap, columns);
     },
-    addParams(values) {
-      const placeholders = values.map(
-        (value, i) => mapParamPlaceholder(params.length + i, value)
+    get indexes() {
+      return mapSchemaComponentsOfType(
+        base.components,
+        IndexURNType,
+        (c) => c.indexName
       );
-      this.addSQL(`(${placeholders.join(", ")})`);
-      params.push(...values);
-      return this;
     },
-    build() {
-      return {
-        query: sql.join(""),
-        params
-      };
-    }
+    addColumn: (column) => base.addComponent(column),
+    addIndex: (index) => base.addComponent(index)
   };
 };
 
-// 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}`
+// 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 {
-      sqlTokenType,
-      [sqlTokenType]: true,
-      ...props
-    };
+      return Object.assign(tablesMap, tables);
+    },
+    addTable: (table) => base.addComponent(
+      typeof table === "string" ? tableSchemaComponent({ tableName: table }) : table
+    )
   };
-  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}`
+// 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 {
-      sqlTokenType,
-      [sqlTokenType]: true,
-      jsTypeName,
-      ...props
-    };
+      return Object.assign(schemasMap, schemas);
+    },
+    addSchema: (schema) => base.addComponent(
+      typeof schema === "string" ? databaseSchemaSchemaComponent({ schemaName: schema }) : schema
+    )
   };
-  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"
+
+// src/core/schema/components/relationships/relationshipTypes.ts
+var relationship = (columns, references, type) => {
+  return {
+    columns,
+    references,
+    type
+  };
 };
-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
+
+// 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] || "";
+  }
 };
-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
+
+// 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 SQLColumnToken = SQLToken("SQL_COLUMN");
+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/sql/processors/sqlProcessor.ts
-var SQLProcessor = (options) => options;
+// 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/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));
+// 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;
     }
-    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"
-      );
+    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());
     }
-    arrayProcessor.handle(inValues, { builder, mapper, processorsRegistry });
-  }
+  };
+};
+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 FormatIdentifierProcessor = SQLProcessor({
-  canHandle: "SQL_IDENTIFIER",
-  handle: (token, { builder, mapper }) => {
-    builder.addSQL(mapper.mapValue(token));
-  }
+var dumboIndex = (name, columnNames, options) => indexSchemaComponent({
+  indexName: name,
+  columnNames,
+  isUnique: options?.unique ?? false,
+  ...options
 });
-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)
+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 registry;
-  }
-  const registry = {
-    register,
-    get: (tokenType) => {
-      return processors.get(tokenType) ?? null;
+      return acc;
     },
-    all: () => processors
-  };
-  return registry;
+    {}
+  );
+  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/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/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/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;
-    }
-  };
+// src/core/query/mappers.ts
+var mapRows = async (getResult, map) => {
+  const result = await getResult;
+  return result.rows.map(map);
 };
-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)
-      );
+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 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: []
+  return newObj;
 };
 
-// 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);
+// src/core/query/selectors.ts
+var firstOrNull = async (getResult) => {
+  const result = await getResult;
+  return result.rows.length > 0 ? result.rows[0] ?? null : null;
 };
-var emptySQL = {
-  __brand: "tokenized-sql",
-  sqlChunks: [""],
-  sqlTokens: []
+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 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 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 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;
+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];
 };
-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 count = async (getResult) => {
+  const result = await single(getResult);
+  return Number(result.count);
 };
-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
+var exists = async (getResult) => {
+  const result = await single(getResult);
+  return result.exists === true || result.exists === 1;
 };
 
-// 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");
+// 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;
+    }
   }
-  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;
+  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 {
+        }
+      }
+    }
   }
-  let quoted = quoteSign;
-  for (let i = 0; i < ident.length; i++) {
-    const c = ident[i];
-    quoted += c === quoteSign ? c + c : c;
+  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;
+    }
   }
-  quoted += quoteSign;
-  return quoted;
+  return value;
 };
-var DefaultMapSQLParamValueOptions = {
-  mapPlaceholder: mapANSISQLParamPlaceholder,
-  mapIdentifier: mapSQLIdentifier
+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 SQLValueMapper = (options) => {
-  const mapSQLParamValueOptions = {
-    ...DefaultMapSQLParamValueOptions,
-    ...options ?? {}
-  };
-  const resultMapper = {
-    mapValue: (value) => mapSQLParamValue(value, mapSQLParamValueOptions),
-    mapPlaceholder: mapSQLParamValueOptions.mapPlaceholder,
-    mapIdentifier: mapSQLParamValueOptions.mapIdentifier
-  };
-  return resultMapper;
+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
+    )
+  );
 };
-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 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 dumboSQLFormatters = globalThis.dumboSQLFormatters = globalThis.dumboSQLFormatters ?? {};
-var registerFormatter = (dialect, formatter) => {
-  dumboSQLFormatters[dialect] = formatter;
+var JSONRevivers = {
+  bigInt: bigIntReviver,
+  date: dateReviver
 };
-var getFormatter = (dialect) => {
-  const formatterKey = dialect;
-  if (!dumboSQLFormatters[formatterKey]) {
-    throw new Error(`No SQL formatter registered for dialect: ${dialect}`);
-  }
-  return dumboSQLFormatters[formatterKey];
+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
+    )
+  };
 };
-function formatSQL(sql, formatter, context) {
-  const mapper = context?.mapper == void 0 ? formatter.valueMapper : {
-    ...formatter.valueMapper,
-    ...context.mapper
+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);
+    }
   };
-  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;
+};
+
+// 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
+      };
     }
-    const token = merged.sqlTokens[paramIndex++];
-    const processor = processorsRegistry.get(token.sqlTokenType);
-    if (!processor) {
+  };
+};
+
+// 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(
-        `No SQL processor registered for token type: ${token.sqlTokenType}`
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `Cannot create SQLToken of type ${sqlTokenType} with input: ${input}`
       );
     }
-    processor.handle(token, {
-      builder,
-      processorsRegistry,
-      mapper
-    });
+    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 builder.build();
-}
-var describeSQL = (sql, formatter, options) => formatSQL(sql, formatter, {
-  ...options ?? {},
-  mapper: {
-    mapPlaceholder: (_, value) => JSONSerializer.serialize(value)
+  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)
   }
-}).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);
+// 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 value;
-  }
-});
-var mapSQLQueryResult = (result, mapping) => {
-  if (typeof result !== "object" || result === null) return result;
-  const mappedResult = {
-    ...result
+    return {
+      sqlTokenType,
+      [sqlTokenType]: true,
+      jsTypeName,
+      ...props
+    };
   };
-  for (const column of Object.keys(mapping)) {
-    if (column in mappedResult) {
-      mappedResult[column] = mapping[column](mappedResult[column]);
-    }
-  }
-  return mappedResult;
+  const check = (token) => SQLToken.check(token) && token.sqlTokenType === sqlTokenType;
+  return { from: factory, check, type: sqlTokenType };
 };
-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 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 executeInNewConnection = async (handle, options) => {
-  const connection = await options.connection();
-  try {
-    return await handle(connection);
-  } finally {
-    await connection.close();
-  }
+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 executeInAmbientConnection = async (handle, options) => {
-  const connection = await options.connection();
-  try {
-    return await handle(connection);
-  } finally {
-  }
+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/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();
+// 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 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 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 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);
+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/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;
-      });
+// 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 connectPromise;
+    return registry;
+  }
+  const registry = {
+    register,
+    get: (tokenType) => {
+      return processors.get(tokenType) ?? null;
+    },
+    all: () => processors
   };
-  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;
+  return registry;
 };
 
-// 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();
+// src/core/sql/processors/columnProcessors.ts
+var mapDefaultSQLColumnProcessors = (mapColumnType) => ({
+  AutoIncrement: SQLProcessor({
+    canHandle: "SQL_COLUMN_AUTO_INCREMENT",
+    handle: (token, context) => {
+      mapColumnType(token, context);
     }
-  };
-  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
+  }),
+  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/schema/schemaComponent.ts
-var schemaComponent = (key, options) => {
-  const componentsMap = new Map(
-    options.components?.map((comp) => [comp.schemaComponentKey, comp])
-  );
-  const migrations = [...options.migrations ?? []];
+// 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 {
-    schemaComponentKey: key,
-    components: componentsMap,
-    get migrations() {
-      return [
-        ...migrations,
-        ...Array.from(componentsMap.values()).flatMap((c) => c.migrations)
-      ];
+    addSQL(str) {
+      sqlChunks.push(str);
     },
-    addComponent: (component) => {
-      componentsMap.set(component.schemaComponentKey, component);
-      migrations.push(...component.migrations);
-      return component;
+    addSQLs(str) {
+      sqlChunks.push(...str);
     },
-    addMigration: (migration) => {
-      migrations.push(migration);
+    addToken(value) {
+      sqlTokens.push(value);
+    },
+    addTokens(vals) {
+      sqlTokens.push(...vals);
+    },
+    build() {
+      return sqlChunks.length > 0 ? {
+        __brand: "tokenized-sql",
+        sqlChunks,
+        sqlTokens
+      } : TokenizedSQL.empty;
     }
   };
 };
-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);
+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)
+      );
     }
-  };
-  traverse(root);
-  return results;
+  }
+  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/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
+// 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 ?? {}
   };
-  return result;
+  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/schema/components/indexSchemaComponent.ts
-var IndexURNType = "sc:dumbo:index";
-var IndexURN = ({ name }) => `${IndexURNType}:${name}`;
-var indexSchemaComponent = ({
-  indexName,
-  columnNames,
-  isUnique,
-  ...migrationsOrComponents
+// src/core/sql/formatters/sqlFormatter.ts
+var SQLFormatter = ({
+  format,
+  describe,
+  valueMapper: valueMapperOptions,
+  processorsRegistry
 }) => {
-  const sc = schemaComponent(IndexURN({ name: indexName }), {
-    migrations: migrationsOrComponents.migrations ?? [],
-    components: [...migrationsOrComponents.components ?? []]
+  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 {
-    ...sc,
-    indexName,
-    get columnNames() {
-      return columnNames;
-    },
-    addColumn: (column) => columnNames.push(typeof column === "string" ? column : column.columnName),
-    isUnique
+    __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/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/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/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/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/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/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/schema/components/relationships/relationshipTypes.ts
-var relationship = (columns, references, type) => {
+// 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 {
-    columns,
-    references,
-    type
+    transaction: getOrInitCurrentTransaction,
+    withTransaction: (handle, options) => executeInTransaction(getOrInitCurrentTransaction(options), handle)
   };
 };
-
-// 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] || "";
+var wrapInConnectionClosure = async (connection, handle) => {
+  try {
+    return await handle();
+  } finally {
+    await connection.close();
   }
 };
-
-// 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 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 dumboIndex = (name, columnNames, options) => indexSchemaComponent({
-  indexName: name,
-  columnNames,
-  isUnique: options?.unique ?? false,
-  ...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 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;
+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;
     },
-    {}
-  );
-  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];
+    withTransaction: async (handle, options) => {
+      const conn = await connect();
+      try {
+        const withTx = conn.withTransaction;
+        return await withTx(handle, options);
+      } finally {
+        await close(conn);
+      }
     }
-  }
-  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];
+// 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 count = async (getResult) => {
-  const result = await single(getResult);
-  return Number(result.count);
+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 exists = async (getResult) => {
-  const result = await single(getResult);
-  return result.exists === true || result.exists === 1;
+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;
 };
-
-// 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 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;
 };
-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('"');
+// src/core/taskProcessing/taskProcessor.ts
+var TaskProcessor = class {
+  queue = [];
+  isProcessing = false;
+  activeTasks = 0;
+  activeGroups = /* @__PURE__ */ new Set();
+  options;
+  constructor(options) {
+    this.options = options;
   }
-  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);
+  enqueue(task, options) {
+    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);
   }
-  if (obj instanceof Promise) {
-    return COLOR_STRING("Promise {pending}");
+  waitForEndOfProcessing() {
+    return this.schedule(({ ack }) => Promise.resolve(ack()));
   }
-  if (Array.isArray(obj)) {
-    const arrayItems = obj.map(
-      (item) => formatJson(item, indentLevel + 1, handleMultiline)
+  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 }
     );
-    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 });
+  ensureProcessing() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+    this.processQueue();
   }
-};
-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));
+  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();
+      }
+    }
   }
-};
-var recordTraceEvent = (logLevel, eventName, attributes) => {
-  if (!shouldLog(LogLevel.LOG)) return;
-  const event = {
-    name: eventName,
-    timestamp: (/* @__PURE__ */ new Date()).getTime(),
-    ...attributes
+  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;
   };
-  const record = getTraceEventRecorder(
-    logLevel,
-    process.env.DUMBO_LOG_STYLE ?? "RAW"
-  );
-  record(event);
+  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;
+    const maxWaitingTime = options.deadline || DEFAULT_PROMISE_DEADLINE;
+    let timeoutId = setTimeout(() => {
+      if (!taskStarted) {
+        reject(
+          new Error("Task was not started within the maximum waiting time")
+        );
+      }
+    }, maxWaitingTime);
+    executor((value) => {
+      taskStarted = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = null;
+      resolve(value);
+    }, reject);
+  });
 };
-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 = [];
+// 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 memoizeConnection = (fn) => {
+  let promise = null;
+  return () => {
+    if (!promise) {
+      promise = Promise.resolve(fn()).catch((err) => {
+        promise = null;
+        throw err;
+      });
+    }
+    return promise;
+  };
+};
+var createBoundedConnectionPool = (options) => {
+  const { driverType, maxConnections } = options;
+  const getConnection = memoizeConnection(options.getConnection);
+  const pool = [];
+  const allConnections = /* @__PURE__ */ new Set();
+  const taskProcessor = new TaskProcessor({
+    maxActiveTasks: maxConnections,
+    maxQueueSize: 1e3
+  });
+  const ackCallbacks = /* @__PURE__ */ new Map();
+  let closed = false;
+  const acquire = async () => {
+    if (closed) throw new DumboError("Connection pool is closed");
+    return taskProcessor.enqueue(async ({ ack }) => {
+      try {
+        let conn = pool.pop();
+        if (!conn) {
+          conn = await getConnection();
+          allConnections.add(conn);
+        }
+        ackCallbacks.set(conn, ack);
+        return conn;
+      } catch (e) {
+        ack();
+        throw e;
+      }
+    });
+  };
+  const release = (conn) => {
+    const ack = ackCallbacks.get(conn);
+    if (ack) {
+      ackCallbacks.delete(conn);
+      pool.push(conn);
+      ack();
+    }
+  };
+  const executeWithPooling = async (operation) => {
+    const conn = await acquire();
+    try {
+      return await operation(conn);
+    } finally {
+      release(conn);
+    }
+  };
   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}`
-        )
-      );
+    driverType,
+    connection: async () => {
+      const conn = await acquire();
+      return wrapPooledConnection(conn, () => Promise.resolve(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,
+      acquire,
+      release
+    ),
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      for (const ack of ackCallbacks.values()) ack();
+      ackCallbacks.clear();
+      const connections = [...allConnections];
+      allConnections.clear();
+      pool.length = 0;
+      await Promise.all(connections.map((conn) => conn.close()));
     }
   };
 };
+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;
@@ -1748,7 +2517,9 @@ var runSQLMigrations = (pool, migrations, partialOptions) => pool.withTransactio
         ...partialOptions?.lock?.options
       }
     },
-    dryRun: defaultOptions.dryRun ?? partialOptions?.dryRun
+    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;
@@ -1758,21 +2529,37 @@ var runSQLMigrations = (pool, migrations, partialOptions) => pool.withTransactio
   };
   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);
+        await execute.batchCommand(migration.sqls, {
+          timeoutMs: options.migrationTimeoutMs
+        });
       }
       for (const migration of migrations) {
-        await runSQLMigration(databaseType, execute, migration);
+        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: void 0 };
+  return { success: options.dryRun ? false : true, result };
 });
-var runSQLMigration = async (databaseType, execute, migration) => {
+var runSQLMigration = async (databaseType, execute, migration, options) => {
   const sqls = combineMigrations(migration);
   const sqlHash = await getMigrationHash(migration, getFormatter(databaseType));
   try {
@@ -1780,13 +2567,34 @@ var runSQLMigration = async (databaseType, execute, migration) => {
       name: migration.name,
       sqlHash
     };
-    const wasMigrationApplied = await ensureMigrationWasNotAppliedYet(
+    const checkResult = await ensureMigrationWasNotAppliedYet(
       execute,
       newMigration
     );
-    if (wasMigrationApplied) return;
-    await execute.batchCommand(sqls);
+    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,
@@ -1796,7 +2604,9 @@ var runSQLMigration = async (databaseType, execute, migration) => {
   }
 };
 var getMigrationHash = async (sqlMigration2, sqlFormatter) => {
-  const content = sqlFormatter.describe(sqlMigration2.sqls);
+  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);
@@ -1807,76 +2617,95 @@ 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}`
+      SQL`SELECT sql_hash as "sqlHash" FROM dmb_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;
+  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 migrations (name, sql_hash)
+      INSERT INTO dmb_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 updateMigrationHash = async (execute, migration) => {
+  await execute.command(
+    SQL`
+      UPDATE dmb_migrations
+      SET sql_hash = ${migration.sqlHash}, timestamp = ${/* @__PURE__ */ new Date()}
+      WHERE name = ${migration.name}
+      `
+  );
 };
-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)
+
+// 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
   );
-  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);
+`;
+var migrationTableSchemaComponent = schemaComponent(
+  "dumbo:schema-component:migrations-table",
+  {
+    migrations: [sqlMigration("dumbo:migrationTable:001", [migrationTableSQL])]
+  }
+);
+var SchemaComponentMigrator = (component, dumbo) => {
+  const completedMigrations = [];
   return {
-    register,
-    tryResolve,
-    tryGet,
-    has,
-    get databaseDriverTypes() {
-      return Array.from(drivers.keys());
+    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}`
+        )
+      );
     }
   };
 };
-var dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry = globalThis.dumboDatabaseDriverRegistry ?? DumboDatabaseDriverRegistry();
 
 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,
@@ -1884,6 +2713,24 @@ export {
   fromDatabaseDriverType,
   getDatabaseDriverName,
   getDatabaseType,
+  DumboDatabaseMetadataRegistry,
+  dumboDatabaseMetadataRegistry,
+  getDatabaseMetadata,
+  resolveDatabaseMetadata,
+  getDefaultDatabase,
+  getDefaultDatabaseAsync,
+  dumboSchema,
+  defaultDatabaseLockOptions,
+  NoDatabaseLock,
+  mapRows,
+  toCamelCase,
+  mapToCamelCase,
+  firstOrNull,
+  first,
+  singleOrNull,
+  single,
+  count,
+  exists,
   composeJSONReplacers,
   composeJSONRevivers,
   JSONReplacer,
@@ -1892,7 +2739,7 @@ export {
   JSONRevivers,
   jsonSerializer,
   JSONSerializer,
-  RawJSONSerializer,
+  JSONCodec,
   ParametrizedSQLBuilder,
   SQLToken,
   SQLIdentifier,
@@ -1924,6 +2771,7 @@ export {
   TokenizedSQL,
   isTokenizedSQL,
   SQL,
+  RawSQL,
   isSQL,
   ansiSqlReservedMap,
   ANSISQLParamPlaceholder,
@@ -1933,14 +2781,48 @@ export {
   DefaultMapSQLParamValueOptions,
   SQLValueMapper,
   mapSQLParamValue,
-  SQLFormatter2 as SQLFormatter,
+  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,
@@ -1951,61 +2833,17 @@ export {
   transactionFactoryWithDbClient,
   transactionFactoryWithNewConnection,
   transactionFactoryWithAmbientConnection,
+  transactionFactoryWithAsyncAmbientConnection,
   createAmbientConnection,
   createSingletonConnection,
   createTransientConnection,
   createConnection,
+  TaskProcessor,
   createAmbientConnectionPool,
   createSingletonConnectionPool,
-  createSingletonClientPool,
+  createBoundedConnectionPool,
+  createSingletonClientConnectionPool,
   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
+  createConnectionPool
 };
-//# sourceMappingURL=chunk-N7RWT46K.js.map
+//# sourceMappingURL=chunk-JKE6SULM.js.map