@holo-js/db 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -119,6 +119,151 @@ function redactSql(sql, policy) {
   return "[SQL REDACTED]";
 }
 
+// src/cache.ts
+import { createHash } from "crypto";
+function getQueryCacheBridgeState() {
+  const runtime = globalThis;
+  runtime.__holoDbQueryCacheBridge__ ??= {};
+  return runtime.__holoDbQueryCacheBridge__;
+}
+function configureDatabaseQueryCacheBridge(bridge) {
+  getQueryCacheBridgeState().bridge = bridge;
+}
+function getDatabaseQueryCacheBridge() {
+  return getQueryCacheBridgeState().bridge;
+}
+function resetDatabaseQueryCacheBridge() {
+  getQueryCacheBridgeState().bridge = void 0;
+}
+function normalizeQueryCacheConfig(input) {
+  if (typeof input === "number" || input instanceof Date) {
+    return Object.freeze({
+      ttl: input
+    });
+  }
+  const ttl = input.ttl;
+  const flexible = input.flexible;
+  if (typeof ttl === "undefined" && typeof flexible === "undefined") {
+    throw new ConfigurationError('[@holo-js/db] Query cache config requires "ttl" or "flexible".');
+  }
+  if (typeof ttl !== "undefined" && typeof flexible !== "undefined") {
+    throw new ConfigurationError('[@holo-js/db] Query cache config cannot define both "ttl" and "flexible".');
+  }
+  const key = input.key?.trim();
+  if (typeof input.key !== "undefined" && !key) {
+    throw new ConfigurationError("[@holo-js/db] Query cache keys must be non-empty strings.");
+  }
+  const driver = input.driver?.trim();
+  if (typeof input.driver !== "undefined" && !driver) {
+    throw new ConfigurationError("[@holo-js/db] Query cache driver names must be non-empty strings.");
+  }
+  const invalidate = input.invalidate ? Object.freeze(input.invalidate.map((dependency) => {
+    const normalized = dependency.trim();
+    if (!normalized) {
+      throw new ConfigurationError("[@holo-js/db] Query cache invalidation dependencies must be non-empty strings.");
+    }
+    return normalized;
+  })) : void 0;
+  return Object.freeze({
+    ttl,
+    key,
+    driver,
+    flexible,
+    invalidate
+  });
+}
+function createDeterministicQueryCacheKey(statement, connectionName) {
+  const digest = createHash("sha256").update(JSON.stringify({
+    connectionName,
+    sql: statement.sql,
+    bindings: statement.bindings ?? []
+  })).digest("hex");
+  return `db:query:${digest}`;
+}
+function resolveQueryCacheKey(statement, connectionName, config) {
+  return config.key ?? createDeterministicQueryCacheKey(statement, connectionName);
+}
+function createTableCacheDependency(connectionName, tableName) {
+  return `db:${connectionName}:${tableName}`;
+}
+function normalizeQueryCacheDependencies(connectionName, dependencies) {
+  return Object.freeze(dependencies.map((dependency) => {
+    return dependency.startsWith("db:") ? dependency : createTableCacheDependency(connectionName, dependency);
+  }));
+}
+function supportsAutomaticPredicateInvalidation(predicate) {
+  switch (predicate.kind) {
+    case "comparison":
+    case "column":
+    case "null":
+    case "date":
+    case "json":
+    case "fulltext":
+    case "vector":
+      return true;
+    case "group":
+      return predicate.predicates.every((child) => supportsAutomaticPredicateInvalidation(child));
+    case "exists":
+    case "subquery":
+    case "raw":
+      return false;
+    default:
+      return false;
+  }
+}
+function supportsAutomaticQueryCacheInvalidation(plan) {
+  if (plan.joins.length > 0 || plan.unions.length > 0 || plan.having.length > 0) {
+    return false;
+  }
+  if (plan.selections.some((selection) => selection.kind === "raw" || selection.kind === "subquery")) {
+    return false;
+  }
+  if (plan.orderBy.some((order) => order.kind === "raw")) {
+    return false;
+  }
+  return plan.predicates.every((predicate) => supportsAutomaticPredicateInvalidation(predicate));
+}
+function inferAutomaticQueryCacheDependencies(plan, connectionName) {
+  if (!supportsAutomaticQueryCacheInvalidation(plan)) {
+    return void 0;
+  }
+  return Object.freeze([
+    createTableCacheDependency(connectionName, plan.source.tableName)
+  ]);
+}
+function resolveQueryCacheDependencies(plan, connectionName, explicit) {
+  if (explicit && explicit.length > 0) {
+    return normalizeQueryCacheDependencies(connectionName, explicit);
+  }
+  return inferAutomaticQueryCacheDependencies(plan, connectionName);
+}
+async function invalidateQueryCacheDependencies(connection, dependencies) {
+  const bridge = getDatabaseQueryCacheBridge();
+  if (!bridge || dependencies.length === 0) {
+    return;
+  }
+  if (connection.getScope().kind === "root") {
+    await bridge.invalidateDependencies(dependencies);
+    return;
+  }
+  connection.afterCommit(async () => {
+    await bridge.invalidateDependencies(dependencies);
+  });
+}
+var queryCacheInternals = {
+  configureDatabaseQueryCacheBridge,
+  createDeterministicQueryCacheKey,
+  createTableCacheDependency,
+  getQueryCacheBridgeState,
+  inferAutomaticQueryCacheDependencies,
+  normalizeQueryCacheConfig,
+  normalizeQueryCacheDependencies,
+  resolveQueryCacheDependencies,
+  resolveQueryCacheKey,
+  supportsAutomaticPredicateInvalidation,
+  supportsAutomaticQueryCacheInvalidation
+};
+
 // src/query/chunkOrdering.ts
 function compareChunkValuesAscending(a, b) {
   if (a === b) return 0;
@@ -228,6 +373,43 @@ function attachMethods(target, methods) {
   );
 }
 
+// src/query/pagination.ts
+function assertPositiveInteger(value, kind, createError) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw createError(`${kind} must be a positive integer.`);
+  }
+}
+function normalizePaginationParameterName(value, fallback, createError) {
+  if (typeof value === "undefined") {
+    return fallback;
+  }
+  const trimmed = value.trim();
+  if (typeof value !== "string" || trimmed.length === 0) {
+    throw createError(
+      `${fallback === "cursor" ? "Cursor" : "Page"} parameter name must be a non-empty string.`
+    );
+  }
+  return trimmed;
+}
+function encodeOffsetCursor(offset) {
+  return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
+}
+function decodeOffsetCursor(cursor, createError) {
+  if (cursor === null) {
+    return 0;
+  }
+  try {
+    const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    const offset = decoded.offset;
+    if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
+      throw new Error("invalid offset");
+    }
+    return offset;
+  } catch {
+    throw createError("Cursor is malformed.");
+  }
+}
+
 // src/query/ast.ts
 function createTableSource(table) {
   if (typeof table === "string") {
@@ -1047,7 +1229,8 @@ var SQLQueryCompiler = class {
     const groupByClause = plan.groupBy.length === 0 ? "" : ` GROUP BY ${plan.groupBy.map((column2) => this.compileColumnReference(column2)).join(", ")}`;
     const havingClause = this.compileHaving(plan.having, bindings);
     const orderClause = plan.orderBy.length === 0 ? "" : ` ORDER BY ${plan.orderBy.map((orderBy) => this.compileOrderBy(orderBy, bindings)).join(", ")}`;
-    const lockClause = plan.lockMode ? ` ${this.compileLockClause(plan.lockMode)}` : "";
+    const compiledLockClause = plan.lockMode ? this.compileLockClause(plan.lockMode) : "";
+    const lockClause = compiledLockClause ? ` ${compiledLockClause}` : "";
     const limitClause = typeof plan.limit === "number" ? ` LIMIT ${plan.limit}` : "";
     const offsetClause = typeof plan.offset === "number" ? ` OFFSET ${plan.offset}` : "";
     return `${selectKeyword} ${selectList} FROM ${this.compileSource(plan.source)}${joinClause}${whereClause}${groupByClause}${havingClause}${unionClause}${orderClause}${lockClause}${limitClause}${offsetClause}`;
@@ -1516,6 +1699,9 @@ var SQLITE_JSON_HELPERS = Object.freeze({
 });
 var SQLITE_EMPTY_JSON_OBJECT = "json('{}')";
 var SQLiteQueryCompiler = class extends SQLQueryCompiler {
+  compileLockClause(_lockMode) {
+    return "";
+  }
   compileJsonPredicate(predicate, bindings) {
     const column2 = this.compileColumnReference(predicate.column);
     const pathLiteral = this.createJsonPathLiteral(predicate.path);
@@ -1844,9 +2030,21 @@ function normalizeDialectWriteValue(dialect, column2, value) {
 }
 
 // src/query/TableQueryBuilder.ts
+function normalizeAtomicQueryCacheTtl(ttl) {
+  if (ttl instanceof Date) {
+    const expiresAt = ttl.getTime();
+    if (Number.isNaN(expiresAt)) {
+      throw new ConfigurationError("[@holo-js/db] Query cache Date TTL must be valid.");
+    }
+    const seconds = Math.max(1, Math.ceil((expiresAt - Date.now()) / 1e3));
+    return [seconds, seconds];
+  }
+  return [ttl, ttl];
+}
 var TableQueryBuilder = class _TableQueryBuilder {
-  constructor(table, connection, plan) {
+  constructor(table, connection, plan, queryCacheConfig) {
     this.connection = connection;
+    this.queryCacheConfig = queryCacheConfig;
     this.source = createTableSource(table);
     this.plan = plan ?? createSelectQueryPlan(this.source);
   }
@@ -1868,7 +2066,8 @@ var TableQueryBuilder = class _TableQueryBuilder {
     return new _TableQueryBuilder(
       table,
       this.connection,
-      withSource(this.plan, createTableSource(table))
+      withSource(this.plan, createTableSource(table)),
+      this.queryCacheConfig
     );
   }
   select(...columns) {
@@ -2485,8 +2684,8 @@ var TableQueryBuilder = class _TableQueryBuilder {
     return this.limit(value);
   }
   forPage(page, perPage = 15) {
-    this.assertPositiveInteger(page, "Page");
-    this.assertPositiveInteger(perPage, "Per-page value");
+    assertPositiveInteger(page, "Page", (message) => new SecurityError(message));
+    assertPositiveInteger(perPage, "Per-page value", (message) => new SecurityError(message));
     return this.limit(perPage).offset((page - 1) * perPage);
   }
   toSQL() {
@@ -2517,9 +2716,60 @@ var TableQueryBuilder = class _TableQueryBuilder {
     console.log(this.debug());
     return this;
   }
+  cache(config) {
+    return new _TableQueryBuilder(
+      this.source.table ?? this.source.tableName,
+      this.connection,
+      this.plan,
+      normalizeQueryCacheConfig(config)
+    );
+  }
   async get() {
-    const result = await this.connection.queryCompiled(this.toSQL());
-    return result.rows;
+    const statement = this.toSQL();
+    const cacheConfig = this.queryCacheConfig;
+    if (!cacheConfig || this.plan.lockMode) {
+      const result = await this.connection.queryCompiled(statement);
+      return result.rows;
+    }
+    const bridge = getDatabaseQueryCacheBridge();
+    if (!bridge) {
+      throw new ConfigurationError("[@holo-js/db] Query caching requires @holo-js/cache to be installed and configured.");
+    }
+    const cacheKey = resolveQueryCacheKey(statement, this.connection.getConnectionName(), cacheConfig);
+    const dependencies = resolveQueryCacheDependencies(
+      this.plan,
+      this.connection.getConnectionName(),
+      cacheConfig.invalidate
+    );
+    if (cacheConfig.flexible) {
+      return bridge.flexible(
+        cacheKey,
+        cacheConfig.flexible,
+        async () => {
+          const result = await this.connection.queryCompiled(statement);
+          return result.rows;
+        },
+        {
+          driver: cacheConfig.driver,
+          dependencies
+        }
+      );
+    }
+    if (typeof cacheConfig.ttl === "undefined") {
+      throw new ConfigurationError('[@holo-js/db] Query cache config requires "ttl" or "flexible".');
+    }
+    return bridge.flexible(
+      cacheKey,
+      normalizeAtomicQueryCacheTtl(cacheConfig.ttl),
+      async () => {
+        const result = await this.connection.queryCompiled(statement);
+        return result.rows;
+      },
+      {
+        driver: cacheConfig.driver,
+        dependencies
+      }
+    );
   }
   async first() {
     const rows = await this.limit(1).get();
@@ -2533,9 +2783,9 @@ var TableQueryBuilder = class _TableQueryBuilder {
     return rows[0];
   }
   async paginate(perPage = 15, page = 1, options = {}) {
-    this.assertPositiveInteger(perPage, "Per-page value");
-    this.assertPositiveInteger(page, "Page");
-    const pageName = this.normalizePaginationParameterName(options.pageName, "page");
+    assertPositiveInteger(perPage, "Per-page value", (message) => new SecurityError(message));
+    assertPositiveInteger(page, "Page", (message) => new SecurityError(message));
+    const pageName = normalizePaginationParameterName(options.pageName, "page", (message) => new SecurityError(message));
     const rows = await this.getUnpaginatedRows();
     const total = rows.length;
     const offset = (page - 1) * perPage;
@@ -2554,9 +2804,9 @@ var TableQueryBuilder = class _TableQueryBuilder {
     });
   }
   async simplePaginate(perPage = 15, page = 1, options = {}) {
-    this.assertPositiveInteger(perPage, "Per-page value");
-    this.assertPositiveInteger(page, "Page");
-    const pageName = this.normalizePaginationParameterName(options.pageName, "page");
+    assertPositiveInteger(perPage, "Per-page value", (message) => new SecurityError(message));
+    assertPositiveInteger(page, "Page", (message) => new SecurityError(message));
+    const pageName = normalizePaginationParameterName(options.pageName, "page", (message) => new SecurityError(message));
     const rows = await this.getUnpaginatedRows();
     const offset = (page - 1) * perPage;
     const pageRows = rows.slice(offset, offset + perPage + 1);
@@ -2574,9 +2824,9 @@ var TableQueryBuilder = class _TableQueryBuilder {
     });
   }
   async cursorPaginate(perPage = 15, cursor = null, options = {}) {
-    this.assertPositiveInteger(perPage, "Per-page value");
-    const cursorName = this.normalizePaginationParameterName(options.cursorName, "cursor");
-    const offset = this.decodeCursor(cursor);
+    assertPositiveInteger(perPage, "Per-page value", (message) => new SecurityError(message));
+    const cursorName = normalizePaginationParameterName(options.cursorName, "cursor", (message) => new SecurityError(message));
+    const offset = decodeOffsetCursor(cursor, (message) => new SecurityError(message));
     const orderedQuery = this.prepareCursorPaginationQuery();
     const rows = await orderedQuery.getUnpaginatedRows();
     const pageRows = rows.slice(offset, offset + perPage + 1);
@@ -2585,12 +2835,12 @@ var TableQueryBuilder = class _TableQueryBuilder {
     return createCursorPaginator(data, {
       perPage,
       cursorName,
-      nextCursor: hasMorePages ? this.encodeCursor(offset + perPage) : null,
+      nextCursor: hasMorePages ? encodeOffsetCursor(offset + perPage) : null,
       prevCursor: cursor
     });
   }
   async chunk(size, callback) {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new SecurityError(message));
     const rows = await this.getUnpaginatedRows();
     let page = 1;
     for (let index = 0; index < rows.length; index += size) {
@@ -2602,7 +2852,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
     }
   }
   async chunkById(size, callback, column2 = "id") {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new SecurityError(message));
     const rows = await this.getUnpaginatedRows();
     const sortedRows = [...rows].sort((left, right) => {
       const a = left[column2];
@@ -2619,7 +2869,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
     }
   }
   async chunkByIdDesc(size, callback, column2 = "id") {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new SecurityError(message));
     const rows = await this.getUnpaginatedRows();
     const sortedRows = [...rows].sort((left, right) => {
       const a = left[column2];
@@ -2636,7 +2886,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
     }
   }
   async *lazy(size = 1e3) {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new SecurityError(message));
     const rows = await this.getUnpaginatedRows();
     for (let index = 0; index < rows.length; index += size) {
       for (const row of rows.slice(index, index + size)) {
@@ -2713,15 +2963,19 @@ var TableQueryBuilder = class _TableQueryBuilder {
   }
   async insert(values) {
     const rows = Array.isArray(values) ? values.map((value) => this.normalizeWriteRecord(value)) : [this.normalizeWriteRecord(values)];
-    return this.connection.executeCompiled(this.getCompiler().compile(
+    const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createInsertQueryPlan(this.source, rows)
     ));
+    await this.invalidateSourceTableQueries();
+    return result;
   }
   async insertOrIgnore(values) {
     const rows = Array.isArray(values) ? values.map((value) => this.normalizeWriteRecord(value)) : [this.normalizeWriteRecord(values)];
-    return this.connection.executeCompiled(this.getCompiler().compile(
+    const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createInsertQueryPlan(this.source, rows, { ignoreConflicts: true })
     ));
+    await this.invalidateSourceTableQueries();
+    return result;
   }
   async insertGetId(values) {
     const result = await this.insert(values);
@@ -2729,9 +2983,11 @@ var TableQueryBuilder = class _TableQueryBuilder {
   }
   async upsert(values, uniqueBy, updateColumns = []) {
     const rows = Array.isArray(values) ? values.map((value) => this.normalizeWriteRecord(value)) : [this.normalizeWriteRecord(values)];
-    return this.connection.executeCompiled(this.getCompiler().compile(
+    const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createUpsertQueryPlan(this.source, rows, uniqueBy, updateColumns)
     ));
+    await this.invalidateSourceTableQueries();
+    return result;
   }
   async increment(column2, amount = 1, extraValues = {}) {
     return this.adjustNumericColumn(column2, amount, extraValues);
@@ -2740,17 +2996,25 @@ var TableQueryBuilder = class _TableQueryBuilder {
     return this.adjustNumericColumn(column2, -amount, extraValues);
   }
   async update(values) {
-    return this.connection.executeCompiled(this.getCompiler().compile(
+    const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createUpdateQueryPlan(this.source, this.plan.predicates, this.normalizeUpdateValues(values))
     ));
+    if (result.affectedRows !== 0) {
+      await this.invalidateSourceTableQueries();
+    }
+    return result;
   }
   async updateJson(columnPath, value) {
     return this.update({ [columnPath]: value });
   }
   async delete() {
-    return this.connection.executeCompiled(this.getCompiler().compile(
+    const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createDeleteQueryPlan(this.source, this.plan.predicates)
     ));
+    if (result.affectedRows !== 0) {
+      await this.invalidateSourceTableQueries();
+    }
+    return result;
   }
   async unsafeQuery(statement) {
     return this.connection.unsafeQuery({
@@ -2768,7 +3032,12 @@ var TableQueryBuilder = class _TableQueryBuilder {
   }
   clone(plan) {
     const table = this.source.table ?? this.source.tableName;
-    return new _TableQueryBuilder(table, this.connection, plan);
+    return new _TableQueryBuilder(table, this.connection, plan, this.queryCacheConfig);
+  }
+  async invalidateSourceTableQueries() {
+    await invalidateQueryCacheDependencies(this.connection, [
+      `db:${this.connection.getConnectionName()}:${this.source.tableName}`
+    ]);
   }
   getCompiler() {
     const dialect = this.connection.getDialect();
@@ -2816,7 +3085,12 @@ var TableQueryBuilder = class _TableQueryBuilder {
       throw new SecurityError("Increment/decrement amount must be a valid number.");
     }
     const primaryKey = this.resolvePrimaryKeyColumn();
-    const rows = await this.select(primaryKey, column2).get();
+    const uncachedSelection = new _TableQueryBuilder(
+      this.source.table ?? this.source.tableName,
+      this.connection,
+      withSelections(this.plan, [primaryKey, column2])
+    );
+    const rows = await uncachedSelection.get();
     let affectedRows = 0;
     let lastInsertId;
     for (const row of rows) {
@@ -2874,22 +3148,6 @@ var TableQueryBuilder = class _TableQueryBuilder {
       minSimilarity
     })).orderByVectorSimilarity(column2, vector);
   }
-  assertPositiveInteger(value, kind) {
-    if (!Number.isInteger(value) || value <= 0) {
-      throw new SecurityError(`${kind} must be a positive integer.`);
-    }
-  }
-  normalizePaginationParameterName(value, fallback) {
-    if (typeof value === "undefined") {
-      return fallback;
-    }
-    if (typeof value !== "string" || value.trim().length === 0) {
-      throw new SecurityError(
-        `${fallback === "cursor" ? "Cursor" : "Page"} parameter name must be a non-empty string.`
-      );
-    }
-    return value;
-  }
   prepareCursorPaginationQuery() {
     if (this.plan.orderBy.some((orderBy) => orderBy.kind === "random")) {
       throw new SecurityError("Cursor pagination cannot use random ordering.");
@@ -2902,24 +3160,6 @@ var TableQueryBuilder = class _TableQueryBuilder {
     }
     return this;
   }
-  encodeCursor(offset) {
-    return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
-  }
-  decodeCursor(cursor) {
-    if (cursor === null) {
-      return 0;
-    }
-    try {
-      const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-      const offset = decoded.offset;
-      if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
-        throw new Error("invalid offset");
-      }
-      return offset;
-    } catch {
-      throw new SecurityError("Cursor is malformed.");
-    }
-  }
   async aggregateNumeric(column2, kind) {
     const rows = await this.get();
     if (rows.length === 0) {
@@ -6147,13 +6387,17 @@ function createModelEventService() {
 
 // src/concurrency/AsyncConnectionContext.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+function getAsyncConnectionStorage() {
+  const runtime = globalThis;
+  runtime.__holoAsyncConnectionStorage__ ??= new AsyncLocalStorage2();
+  return runtime.__holoAsyncConnectionStorage__;
+}
 var AsyncConnectionContext = class {
-  storage = new AsyncLocalStorage2();
   run(scope, callback) {
-    return this.storage.run(scope, callback);
+    return getAsyncConnectionStorage().run(scope, callback);
   }
   getActive() {
-    return this.storage.getStore();
+    return getAsyncConnectionStorage().getStore();
   }
 };
 var connectionAsyncContext = new AsyncConnectionContext();
@@ -6203,19 +6447,24 @@ function resetMorphRegistry() {
 }
 
 // src/facade/DB.ts
+function getDatabaseFacadeState() {
+  const runtime = globalThis;
+  runtime.__holoDatabaseFacade__ ??= {};
+  return runtime.__holoDatabaseFacade__;
+}
 var DatabaseFacade = class {
-  manager;
   configure(manager) {
-    this.manager = manager;
+    getDatabaseFacadeState().manager = manager;
   }
   reset() {
-    this.manager = void 0;
+    getDatabaseFacadeState().manager = void 0;
   }
   getManager() {
-    if (!this.manager) {
+    const manager = getDatabaseFacadeState().manager;
+    if (!manager) {
       throw new ConfigurationError("DB facade is not configured with a ConnectionManager.");
     }
-    return this.manager;
+    return manager;
   }
   connection(name) {
     if (!name) {
@@ -7528,40 +7777,16 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     return this.orWhereHas(relation, (query) => query.where(column2, operator, value));
   }
   whereMorphRelation(relation, types, column2, operator, value) {
-    this.assertMorphToRelation(relation);
-    return this.withRelationFilter({
-      relation,
-      negate: false,
-      boolean: "and",
-      morphTypes: this.normalizeMorphTypes(types),
-      constraint: (query) => query.where(column2, operator, value)
-    });
+    return this.applyMorphRelationFilter(relation, types, column2, operator, value, "and");
   }
   orWhereMorphRelation(relation, types, column2, operator, value) {
-    this.assertMorphToRelation(relation);
-    return this.withRelationFilter({
-      relation,
-      negate: false,
-      boolean: "or",
-      morphTypes: this.normalizeMorphTypes(types),
-      constraint: (query) => query.where(column2, operator, value)
-    });
+    return this.applyMorphRelationFilter(relation, types, column2, operator, value, "or");
   }
   whereBelongsTo(relatedEntity, relationName) {
-    const relation = this.resolveBelongsToRelation(relatedEntity, relationName);
-    const ownerValue = relatedEntity.get(relation.ownerKey);
-    return ownerValue === null || typeof ownerValue === "undefined" ? this.whereDoesntHave(this.resolveBelongsToRelationName(relatedEntity, relationName)) : this.whereHas(
-      this.resolveBelongsToRelationName(relatedEntity, relationName),
-      (query) => query.where(relation.ownerKey, ownerValue)
-    );
+    return this.applyBelongsToFilter(relatedEntity, relationName, "and");
   }
   orWhereBelongsTo(relatedEntity, relationName) {
-    const relation = this.resolveBelongsToRelation(relatedEntity, relationName);
-    const ownerValue = relatedEntity.get(relation.ownerKey);
-    return ownerValue === null || typeof ownerValue === "undefined" ? this.orWhereDoesntHave(this.resolveBelongsToRelationName(relatedEntity, relationName)) : this.orWhereHas(
-      this.resolveBelongsToRelationName(relatedEntity, relationName),
-      (query) => query.where(relation.ownerKey, ownerValue)
-    );
+    return this.applyBelongsToFilter(relatedEntity, relationName, "or");
   }
   whereMorphedTo(relation, target) {
     return this.applyMorphedToFilter(relation, target, false, "and");
@@ -7606,6 +7831,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     this.tableQuery.dump();
     return this;
   }
+  cache(config) {
+    return this.clone(this.tableQuery.cache(config));
+  }
   async get() {
     const rows = await this.tableQuery.get();
     const hasQueryCasts = Object.keys(this.queryCasts).length > 0;
@@ -7633,9 +7861,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     return entities[0];
   }
   async paginate(perPage = 15, page = 1, options = {}) {
-    this.assertPositiveInteger(perPage, "Per-page value");
-    this.assertPositiveInteger(page, "Page");
-    const pageName = this.normalizePaginationParameterName(options.pageName, "page");
+    assertPositiveInteger(perPage, "Per-page value", (message) => new HydrationError(message));
+    assertPositiveInteger(page, "Page", (message) => new HydrationError(message));
+    const pageName = normalizePaginationParameterName(options.pageName, "page", (message) => new HydrationError(message));
     const entities = await this.getUnpaginatedEntities();
     const total = entities.length;
     const offset = (page - 1) * perPage;
@@ -7654,9 +7882,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     });
   }
   async simplePaginate(perPage = 15, page = 1, options = {}) {
-    this.assertPositiveInteger(perPage, "Per-page value");
-    this.assertPositiveInteger(page, "Page");
-    const pageName = this.normalizePaginationParameterName(options.pageName, "page");
+    assertPositiveInteger(perPage, "Per-page value", (message) => new HydrationError(message));
+    assertPositiveInteger(page, "Page", (message) => new HydrationError(message));
+    const pageName = normalizePaginationParameterName(options.pageName, "page", (message) => new HydrationError(message));
     const entities = await this.getUnpaginatedEntities();
     const offset = (page - 1) * perPage;
     const pageEntities = entities.slice(offset, offset + perPage + 1);
@@ -7674,9 +7902,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     });
   }
   async cursorPaginate(perPage = 15, cursor = null, options = {}) {
-    this.assertPositiveInteger(perPage, "Per-page value");
-    const cursorName = this.normalizePaginationParameterName(options.cursorName, "cursor");
-    const offset = this.decodeCursor(cursor);
+    assertPositiveInteger(perPage, "Per-page value", (message) => new HydrationError(message));
+    const cursorName = normalizePaginationParameterName(options.cursorName, "cursor", (message) => new HydrationError(message));
+    const offset = decodeOffsetCursor(cursor, (message) => new HydrationError(message));
     const orderedQuery = this.prepareCursorPaginationQuery();
     const entities = await orderedQuery.getUnpaginatedEntities();
     const pageEntities = entities.slice(offset, offset + perPage + 1);
@@ -7685,12 +7913,12 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     return createCursorPaginator(this.repository.createCollection(data), {
       perPage,
       cursorName,
-      nextCursor: hasMorePages ? this.encodeCursor(offset + perPage) : null,
+      nextCursor: hasMorePages ? encodeOffsetCursor(offset + perPage) : null,
       prevCursor: cursor
     });
   }
   async chunk(size, callback) {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new HydrationError(message));
     const entities = await this.getUnpaginatedEntities();
     let page = 1;
     for (let index = 0; index < entities.length; index += size) {
@@ -7702,7 +7930,7 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     }
   }
   async chunkById(size, callback, column2 = this.repository.definition.primaryKey) {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new HydrationError(message));
     const entities = await this.getUnpaginatedEntities();
     const sorted = [...entities].sort((left, right) => {
       const a = left.get(column2);
@@ -7719,7 +7947,7 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     }
   }
   async chunkByIdDesc(size, callback, column2 = this.repository.definition.primaryKey) {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new HydrationError(message));
     const entities = await this.getUnpaginatedEntities();
     const sorted = [...entities].sort((left, right) => {
       const a = left.get(column2);
@@ -7736,7 +7964,7 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     }
   }
   async *lazy(size = 1e3) {
-    this.assertPositiveInteger(size, "Chunk size");
+    assertPositiveInteger(size, "Chunk size", (message) => new HydrationError(message));
     const entities = await this.getUnpaginatedEntities();
     for (let index = 0; index < entities.length; index += size) {
       for (const entity of entities.slice(index, index + size)) {
@@ -8019,6 +8247,16 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
       constraint
     });
   }
+  applyMorphRelationFilter(relation, types, column2, operator, value, boolean) {
+    this.assertMorphToRelation(relation);
+    return this.withRelationFilter({
+      relation,
+      negate: false,
+      boolean,
+      morphTypes: this.normalizeMorphTypes(types),
+      constraint: (query) => query.where(column2, operator, value)
+    });
+  }
   normalizeMorphedToTarget(target) {
     if (typeof target === "object" && target !== null && "definition" in target && target.definition) {
       return {
@@ -8090,6 +8328,15 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     }
     return relation;
   }
+  applyBelongsToFilter(relatedEntity, relationName, boolean) {
+    const resolvedRelationName = this.resolveBelongsToRelationName(relatedEntity, relationName);
+    const relation = this.resolveBelongsToRelation(relatedEntity, resolvedRelationName);
+    const ownerValue = relatedEntity.get(relation.ownerKey);
+    if (ownerValue === null || typeof ownerValue === "undefined") {
+      return boolean === "and" ? this.whereDoesntHave(resolvedRelationName) : this.orWhereDoesntHave(resolvedRelationName);
+    }
+    return boolean === "and" ? this.whereHas(resolvedRelationName, (query) => query.where(relation.ownerKey, ownerValue)) : this.orWhereHas(resolvedRelationName, (query) => query.where(relation.ownerKey, ownerValue));
+  }
   resolveBelongsToRelationName(relatedEntity, relationName) {
     if (relationName) {
       return relationName;
@@ -8124,40 +8371,6 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
   async getUnpaginatedEntities() {
     return this.clone(this.tableQuery.limit(void 0).offset(void 0)).get();
   }
-  encodeCursor(offset) {
-    return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
-  }
-  decodeCursor(cursor) {
-    if (cursor === null) {
-      return 0;
-    }
-    try {
-      const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-      const offset = decoded.offset;
-      if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
-        throw new Error("invalid offset");
-      }
-      return offset;
-    } catch {
-      throw new HydrationError("Cursor is malformed.");
-    }
-  }
-  assertPositiveInteger(value, kind) {
-    if (!Number.isInteger(value) || value <= 0) {
-      throw new HydrationError(`${kind} must be a positive integer.`);
-    }
-  }
-  normalizePaginationParameterName(value, fallback) {
-    if (typeof value === "undefined") {
-      return fallback;
-    }
-    if (typeof value !== "string" || value.trim().length === 0) {
-      throw new HydrationError(
-        `${fallback === "cursor" ? "Cursor" : "Page"} parameter name must be a non-empty string.`
-      );
-    }
-    return value;
-  }
   prepareCursorPaginationQuery() {
     const plan = this.tableQuery.getPlan();
     if (plan.orderBy.some((orderBy) => orderBy.kind === "random")) {
@@ -11615,512 +11828,243 @@ function createConnectionManager(options) {
   return new ConnectionManager(options);
 }
 
-// src/drivers/SQLiteAdapter.ts
-import Database from "better-sqlite3";
-var SQLiteAdapter = class {
-  database;
-  connected;
-  filename;
-  createDatabaseInstance;
-  constructor(options = {}) {
-    this.database = options.database;
-    this.connected = !!options.database;
-    this.filename = options.filename ?? ":memory:";
-    this.createDatabaseInstance = options.createDatabase ?? ((filename) => new Database(filename));
+// src/drivers/index.ts
+function isModuleNotFoundError(error) {
+  return !!error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND";
+}
+function dynamicImport(specifier) {
+  return import(
+    /* webpackIgnore: true */
+    specifier
+  );
+}
+async function importDriverModule(specifier, errorMessage) {
+  try {
+    return await dynamicImport(specifier);
+  } catch (error) {
+    if (isModuleNotFoundError(error)) {
+      throw new Error(errorMessage, { cause: error });
+    }
+    throw error;
+  }
+}
+var driverModuleInternals = {
+  importDriverModule
+};
+function unsupportedDriverMethod(name, method) {
+  return new Error(`[@holo-js/db] ${name} does not support ${method}().`);
+}
+var LazyDriverAdapter = class {
+  adapter;
+  pending;
+  connected = false;
+  async resolveAdapter() {
+    if (this.adapter) {
+      return this.adapter;
+    }
+    this.pending ??= this.createConcreteAdapter().then((adapter) => {
+      this.adapter = adapter;
+      return adapter;
+    }).finally(() => {
+      this.pending = void 0;
+    });
+    return this.pending;
   }
   async initialize() {
-    if (this.connected) {
-      return;
-    }
-    this.database = this.createDatabaseInstance(this.filename);
+    await (await this.resolveAdapter()).initialize();
     this.connected = true;
   }
   async disconnect() {
-    if (!this.connected || !this.database) {
+    if (!this.adapter && !this.pending) {
+      this.connected = false;
       return;
     }
-    this.database.close();
-    this.database = void 0;
+    await (await this.resolveAdapter()).disconnect();
     this.connected = false;
   }
   isConnected() {
-    return this.connected;
+    return this.adapter?.isConnected() ?? this.connected;
   }
-  async query(sql, bindings = []) {
-    const statement = this.getDatabase().prepare(sql);
-    const rows = this.invokeStatement(statement, "all", bindings);
-    return {
-      rows,
-      rowCount: rows.length
-    };
+  async runWithTransactionScope(callback) {
+    const adapter = await this.resolveAdapter();
+    if (typeof adapter.runWithTransactionScope !== "function") {
+      return callback();
+    }
+    return adapter.runWithTransactionScope(callback);
   }
-  async introspect(sql, bindings = []) {
-    return this.query(sql, bindings);
+  async introspect(sql, bindings, options) {
+    const adapter = await this.resolveAdapter();
+    if (typeof adapter.introspect !== "function") {
+      return adapter.query(sql, bindings, options);
+    }
+    return adapter.introspect(sql, bindings, options);
   }
-  async execute(sql, bindings = []) {
-    const statement = this.getDatabase().prepare(sql);
-    const result = this.invokeStatement(statement, "run", bindings);
-    return {
-      affectedRows: result.changes,
-      lastInsertId: typeof result.lastInsertRowid === "bigint" ? Number(result.lastInsertRowid) : result.lastInsertRowid
-    };
+  async query(sql, bindings, options) {
+    return (await this.resolveAdapter()).query(sql, bindings, options);
   }
-  async beginTransaction() {
-    this.getDatabase().exec("BEGIN");
+  async execute(sql, bindings, options) {
+    return (await this.resolveAdapter()).execute(sql, bindings, options);
   }
-  async commit() {
-    this.getDatabase().exec("COMMIT");
+  async beginTransaction(options) {
+    await (await this.resolveAdapter()).beginTransaction(options);
   }
-  async rollback() {
-    this.getDatabase().exec("ROLLBACK");
+  async commit(options) {
+    await (await this.resolveAdapter()).commit(options);
   }
-  async createSavepoint(name) {
-    this.getDatabase().exec(`SAVEPOINT ${this.normalizeSavepointName(name)}`);
+  async rollback(options) {
+    await (await this.resolveAdapter()).rollback(options);
   }
-  async rollbackToSavepoint(name) {
-    this.getDatabase().exec(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`);
+  async createSavepoint(name, options) {
+    const adapter = await this.resolveAdapter();
+    if (typeof adapter.createSavepoint !== "function") {
+      throw unsupportedDriverMethod(this.driverLabel, "createSavepoint");
+    }
+    await adapter.createSavepoint(name, options);
   }
-  async releaseSavepoint(name) {
-    this.getDatabase().exec(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`);
+  async rollbackToSavepoint(name, options) {
+    const adapter = await this.resolveAdapter();
+    if (typeof adapter.rollbackToSavepoint !== "function") {
+      throw unsupportedDriverMethod(this.driverLabel, "rollbackToSavepoint");
+    }
+    await adapter.rollbackToSavepoint(name, options);
   }
-  getDatabase() {
-    if (!this.connected || !this.database) {
-      this.database = this.createDatabaseInstance(this.filename);
-      this.connected = true;
+  async releaseSavepoint(name, options) {
+    const adapter = await this.resolveAdapter();
+    if (typeof adapter.releaseSavepoint !== "function") {
+      throw unsupportedDriverMethod(this.driverLabel, "releaseSavepoint");
     }
-    return this.database;
+    await adapter.releaseSavepoint(name, options);
   }
-  normalizeSavepointName(name) {
+};
+var SQLiteAdapter = class extends LazyDriverAdapter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.filename = options.filename ?? ":memory:";
+    this.connected = !!options.database;
+  }
+  driverLabel = "SQLiteAdapter";
+  filename;
+  async createConcreteAdapter() {
+    const module = await driverModuleInternals.importDriverModule(
+      "@holo-js/db-sqlite",
+      "[@holo-js/db] SQLite support requires @holo-js/db-sqlite to be installed."
+    );
+    return module.createSQLiteAdapter(this.options);
+  }
+  async createSavepoint(name, options) {
     if (!/^[A-Z_]\w*$/i.test(name)) {
       throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
-    return name;
+    await super.createSavepoint(name, options);
   }
-  invokeStatement(statement, method, bindings) {
-    try {
-      return statement[method](...bindings);
-    } catch (error) {
-      if (bindings.length > 0 && this.isBindingArityError(error)) {
-        return statement[method](bindings);
-      }
-      throw error;
+  async rollbackToSavepoint(name, options) {
+    if (!/^[A-Z_]\w*$/i.test(name)) {
+      throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
+    await super.rollbackToSavepoint(name, options);
   }
-  isBindingArityError(error) {
-    return error instanceof RangeError && (error.message.includes("Too many parameter values were provided") || error.message.includes("Too few parameter values were provided"));
+  async releaseSavepoint(name, options) {
+    if (!/^[A-Z_]\w*$/i.test(name)) {
+      throw new TransactionError(`Invalid savepoint name "${name}".`);
+    }
+    await super.releaseSavepoint(name, options);
   }
 };
 function createSQLiteAdapter(options = {}) {
   return new SQLiteAdapter(options);
 }
-
-// src/drivers/PostgresAdapter.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-import { Pool } from "pg";
-var PostgresAdapter = class {
-  pool;
-  directClient;
-  createPoolInstance;
-  config;
-  connected;
-  transactionClient;
-  leasedTransactionClient = false;
-  transactionScope = new AsyncLocalStorage3();
+var PostgresAdapter = class extends LazyDriverAdapter {
   constructor(options = {}) {
-    this.directClient = options.client;
-    this.pool = options.pool;
-    this.createPoolInstance = options.createPool ?? (options.client || options.pool ? void 0 : (config) => new Pool(config));
+    super();
+    this.options = options;
     this.config = options.config ?? (options.connectionString ? { connectionString: options.connectionString } : void 0);
     this.connected = !!(options.client || options.pool);
   }
-  async initialize() {
-    if (this.connected) {
-      return;
-    }
-    if (this.createPoolInstance) {
-      this.pool = this.createPoolInstance(this.config);
-    }
-    this.connected = true;
+  driverLabel = "PostgresAdapter";
+  config;
+  async createConcreteAdapter() {
+    const module = await driverModuleInternals.importDriverModule(
+      "@holo-js/db-postgres",
+      "[@holo-js/db] Postgres support requires @holo-js/db-postgres to be installed."
+    );
+    const createPostgresAdapter2 = module.createPostgresAdapter;
+    return createPostgresAdapter2(this.options);
   }
-  async disconnect() {
-    if (!this.connected) {
+  releaseScopedTransaction(state) {
+    if (state.released) {
       return;
     }
-    if (this.transactionClient && this.leasedTransactionClient) {
-      this.transactionClient.release?.();
-      this.transactionClient = void 0;
-      this.leasedTransactionClient = false;
-    }
-    if (this.pool) {
-      await this.pool.end();
-      this.pool = void 0;
-    } else if (this.directClient?.end) {
-      await this.directClient.end();
-    }
-    this.connected = false;
-  }
-  isConnected() {
-    return this.connected;
-  }
-  async runWithTransactionScope(callback) {
-    const active = this.transactionScope.getStore();
-    if (active) {
-      return callback();
-    }
-    await this.initialize();
-    if (this.directClient) {
-      return this.transactionScope.run({
-        client: this.directClient,
-        leased: false,
-        released: false
-      }, callback);
-    }
-    if (!this.pool) {
-      throw new TransactionError("Postgres adapter is not initialized with a pool or client.");
-    }
-    const state = {
-      client: await this.pool.connect(),
-      leased: true,
-      released: false
-    };
-    return this.transactionScope.run(state, async () => {
-      try {
-        return await callback();
-      } finally {
-        this.releaseScopedTransaction(state);
-      }
-    });
-  }
-  async query(sql, bindings = []) {
-    const client = await this.getQueryable();
-    const result = await client.query(sql, bindings);
-    return {
-      rows: result.rows,
-      rowCount: result.rowCount ?? result.rows.length
-    };
-  }
-  async introspect(sql, bindings = []) {
-    return this.query(sql, bindings);
-  }
-  async execute(sql, bindings = []) {
-    const client = await this.getQueryable();
-    const result = await client.query(sql, bindings);
-    const firstRow = result.rows[0];
-    const firstValue = firstRow ? Object.values(firstRow)[0] : void 0;
-    return {
-      affectedRows: result.rowCount ?? 0,
-      ...typeof firstValue !== "undefined" ? { lastInsertId: firstValue } : {}
-    };
-  }
-  async beginTransaction() {
-    const client = await this.leaseTransactionClient();
-    await client.query("BEGIN");
-  }
-  async commit() {
-    const client = this.requireTransactionClient();
-    await client.query("COMMIT");
-    this.releaseTransactionClient();
-  }
-  async rollback() {
-    const client = this.requireTransactionClient();
-    await client.query("ROLLBACK");
-    this.releaseTransactionClient();
-  }
-  async createSavepoint(name) {
-    await this.requireTransactionClient().query(`SAVEPOINT ${this.normalizeSavepointName(name)}`);
-  }
-  async rollbackToSavepoint(name) {
-    await this.requireTransactionClient().query(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`);
-  }
-  async releaseSavepoint(name) {
-    await this.requireTransactionClient().query(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`);
-  }
-  async getQueryable() {
-    const scoped = this.transactionScope.getStore();
-    if (scoped) {
-      return scoped.client;
-    }
-    if (this.transactionClient) {
-      return this.transactionClient;
-    }
-    await this.initialize();
-    if (this.directClient) {
-      return this.directClient;
-    }
-    if (!this.pool) {
-      throw new TransactionError("Postgres adapter is not initialized with a pool or client.");
+    if (state.leased) {
+      state.client.release?.();
     }
-    return this.pool;
-  }
-  async leaseTransactionClient() {
-    const scoped = this.transactionScope.getStore();
-    if (scoped) {
-      return scoped.client;
-    }
-    if (this.transactionClient) {
-      return this.transactionClient;
-    }
-    await this.initialize();
-    if (this.directClient) {
-      this.transactionClient = this.directClient;
-      this.leasedTransactionClient = false;
-      return this.transactionClient;
-    }
-    if (!this.pool) {
-      throw new TransactionError("Postgres adapter is not initialized with a pool or client.");
-    }
-    this.transactionClient = await this.pool.connect();
-    this.leasedTransactionClient = true;
-    return this.transactionClient;
-  }
-  requireTransactionClient() {
-    const scoped = this.transactionScope.getStore();
-    if (scoped) {
-      return scoped.client;
-    }
-    if (!this.transactionClient) {
-      throw new TransactionError("No active Postgres transaction client is available.");
-    }
-    return this.transactionClient;
+    state.released = true;
   }
-  releaseTransactionClient() {
-    if (this.transactionClient && this.leasedTransactionClient) {
-      this.transactionClient.release?.();
+  async createSavepoint(name, options) {
+    if (!/^[A-Z_]\w*$/i.test(name)) {
+      throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
-    this.transactionClient = void 0;
-    this.leasedTransactionClient = false;
+    await super.createSavepoint(name, options);
   }
-  releaseScopedTransaction(state) {
-    if (!state.leased || state.released) {
-      return;
+  async rollbackToSavepoint(name, options) {
+    if (!/^[A-Z_]\w*$/i.test(name)) {
+      throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
-    state.client.release?.();
-    state.released = true;
+    await super.rollbackToSavepoint(name, options);
   }
-  normalizeSavepointName(name) {
+  async releaseSavepoint(name, options) {
     if (!/^[A-Z_]\w*$/i.test(name)) {
       throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
-    return name;
+    await super.releaseSavepoint(name, options);
   }
 };
 function createPostgresAdapter(options = {}) {
   return new PostgresAdapter(options);
 }
-
-// src/drivers/MySQLAdapter.ts
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
-import mysql from "mysql2/promise";
-function toMutableBindings(bindings = []) {
-  return [...bindings];
-}
-function wrapMySQLClient(client) {
-  const rawClient = client;
-  return {
-    async query(sql, bindings = []) {
-      return rawClient.query(sql, toMutableBindings(bindings));
-    },
-    release: rawClient.release?.bind(rawClient),
-    end: rawClient.end?.bind(rawClient)
-  };
-}
-function wrapMySQLPool(pool) {
-  const rawPool = pool;
-  return {
-    async query(sql, bindings = []) {
-      return rawPool.query(sql, toMutableBindings(bindings));
-    },
-    async getConnection() {
-      return wrapMySQLClient(await rawPool.getConnection());
-    },
-    end: rawPool.end.bind(rawPool)
-  };
-}
-var MySQLAdapter = class {
-  pool;
-  directClient;
-  createPoolInstance;
-  config;
-  connected;
-  transactionClient;
-  leasedTransactionClient = false;
-  transactionScope = new AsyncLocalStorage4();
+var MySQLAdapter = class extends LazyDriverAdapter {
   constructor(options = {}) {
-    this.directClient = options.client ? wrapMySQLClient(options.client) : void 0;
-    this.pool = options.pool ? wrapMySQLPool(options.pool) : void 0;
-    this.createPoolInstance = options.createPool ?? (options.client || options.pool ? void 0 : (config) => wrapMySQLPool(mysql.createPool(config)));
+    super();
+    this.options = options;
     this.config = options.config ?? (options.uri ? { uri: options.uri } : {});
     this.connected = !!(options.client || options.pool);
   }
-  async initialize() {
-    if (this.connected) {
-      return;
-    }
-    if (this.createPoolInstance) {
-      this.pool = this.createPoolInstance(this.config);
-    }
-    this.connected = true;
+  driverLabel = "MySQLAdapter";
+  config;
+  async createConcreteAdapter() {
+    const module = await driverModuleInternals.importDriverModule(
+      "@holo-js/db-mysql",
+      "[@holo-js/db] MySQL support requires @holo-js/db-mysql to be installed."
+    );
+    const createMySQLAdapter2 = module.createMySQLAdapter;
+    return createMySQLAdapter2(this.options);
   }
-  async disconnect() {
-    if (!this.connected) {
+  releaseScopedTransaction(state) {
+    if (state.released) {
       return;
     }
-    if (this.transactionClient && this.leasedTransactionClient) {
-      this.transactionClient.release?.();
-      this.transactionClient = void 0;
-      this.leasedTransactionClient = false;
-    }
-    if (this.pool) {
-      await this.pool.end();
-      this.pool = void 0;
-    } else if (this.directClient?.end) {
-      await this.directClient.end();
-    }
-    this.connected = false;
-  }
-  isConnected() {
-    return this.connected;
-  }
-  async runWithTransactionScope(callback) {
-    const active = this.transactionScope.getStore();
-    if (active) {
-      return callback();
-    }
-    await this.initialize();
-    if (this.directClient) {
-      return this.transactionScope.run({
-        client: this.directClient,
-        leased: false,
-        released: false
-      }, callback);
-    }
-    if (!this.pool) {
-      throw new TransactionError("MySQL adapter is not initialized with a pool or client.");
-    }
-    const state = {
-      client: await this.pool.getConnection(),
-      leased: true,
-      released: false
-    };
-    return this.transactionScope.run(state, async () => {
-      try {
-        return await callback();
-      } finally {
-        this.releaseScopedTransaction(state);
-      }
-    });
-  }
-  async query(sql, bindings = []) {
-    const queryable = await this.getQueryable();
-    const [rows] = await queryable.query(sql, bindings);
-    const normalized = rows;
-    return {
-      rows: Array.isArray(normalized) ? [...normalized] : [],
-      rowCount: Array.isArray(normalized) ? normalized.length : 0
-    };
-  }
-  async introspect(sql, bindings = []) {
-    return this.query(sql, bindings);
-  }
-  async execute(sql, bindings = []) {
-    const queryable = await this.getQueryable();
-    const [result] = await queryable.query(sql, bindings);
-    const execution = result;
-    return {
-      affectedRows: typeof execution.affectedRows === "number" ? execution.affectedRows : 0,
-      lastInsertId: execution.insertId
-    };
-  }
-  async beginTransaction() {
-    const client = await this.leaseTransactionClient();
-    await client.query("START TRANSACTION");
-  }
-  async commit() {
-    const client = this.requireTransactionClient();
-    await client.query("COMMIT");
-    this.releaseTransactionClient();
-  }
-  async rollback() {
-    const client = this.requireTransactionClient();
-    await client.query("ROLLBACK");
-    this.releaseTransactionClient();
-  }
-  async createSavepoint(name) {
-    await this.requireTransactionClient().query(`SAVEPOINT ${this.normalizeSavepointName(name)}`);
-  }
-  async rollbackToSavepoint(name) {
-    await this.requireTransactionClient().query(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`);
-  }
-  async releaseSavepoint(name) {
-    await this.requireTransactionClient().query(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`);
-  }
-  async getQueryable() {
-    const scoped = this.transactionScope.getStore();
-    if (scoped) {
-      return scoped.client;
+    if (state.leased) {
+      state.client.release?.();
     }
-    if (this.transactionClient) {
-      return this.transactionClient;
-    }
-    await this.initialize();
-    if (this.directClient) {
-      return this.directClient;
-    }
-    if (!this.pool) {
-      throw new TransactionError("MySQL adapter is not initialized with a pool or client.");
-    }
-    return this.pool;
-  }
-  async leaseTransactionClient() {
-    const scoped = this.transactionScope.getStore();
-    if (scoped) {
-      return scoped.client;
-    }
-    if (this.transactionClient) {
-      return this.transactionClient;
-    }
-    await this.initialize();
-    if (this.directClient) {
-      this.transactionClient = this.directClient;
-      this.leasedTransactionClient = false;
-      return this.transactionClient;
-    }
-    if (!this.pool) {
-      throw new TransactionError("MySQL adapter is not initialized with a pool or client.");
-    }
-    this.transactionClient = await this.pool.getConnection();
-    this.leasedTransactionClient = true;
-    return this.transactionClient;
-  }
-  requireTransactionClient() {
-    const scoped = this.transactionScope.getStore();
-    if (scoped) {
-      return scoped.client;
-    }
-    if (!this.transactionClient) {
-      throw new TransactionError("No active MySQL transaction client is available.");
-    }
-    return this.transactionClient;
+    state.released = true;
   }
-  releaseTransactionClient() {
-    if (this.transactionClient && this.leasedTransactionClient) {
-      this.transactionClient.release?.();
+  async createSavepoint(name, options) {
+    if (!/^[A-Z_]\w*$/i.test(name)) {
+      throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
-    this.transactionClient = void 0;
-    this.leasedTransactionClient = false;
+    await super.createSavepoint(name, options);
   }
-  releaseScopedTransaction(state) {
-    if (!state.leased || state.released) {
-      return;
+  async rollbackToSavepoint(name, options) {
+    if (!/^[A-Z_]\w*$/i.test(name)) {
+      throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
-    state.client.release?.();
-    state.released = true;
+    await super.rollbackToSavepoint(name, options);
   }
-  normalizeSavepointName(name) {
+  async releaseSavepoint(name, options) {
     if (!/^[A-Z_]\w*$/i.test(name)) {
       throw new TransactionError(`Invalid savepoint name "${name}".`);
     }
-    return name;
+    await super.releaseSavepoint(name, options);
   }
 };
 function createMySQLAdapter(options = {}) {
@@ -13051,7 +12995,7 @@ function defineFactory(model, definition) {
 }
 
 // src/model/casts.ts
-import { createCipheriv, createDecipheriv, createHash, randomBytes } from "crypto";
+import { createCipheriv, createDecipheriv, createHash as createHash2, randomBytes } from "crypto";
 function enumCast(enumObject) {
   const values = Object.entries(enumObject).filter(([key]) => !/^\d+$/.test(key)).map(([, value]) => value).filter((value, index, items) => items.indexOf(value) === index);
   return Object.freeze({
@@ -13089,7 +13033,7 @@ function binaryCast() {
   });
 }
 function encryptedCast(secret) {
-  const key = createHash("sha256").update(secret).digest();
+  const key = createHash2("sha256").update(secret).digest();
   return Object.freeze({
     get(value) {
       if (value == null) {
@@ -14136,7 +14080,9 @@ var DEFAULT_HOLO_PROJECT_PATHS = Object.freeze({
   commands: "server/commands",
   jobs: "server/jobs",
   events: "server/events",
-  listeners: "server/listeners"
+  listeners: "server/listeners",
+  authorizationPolicies: "server/policies",
+  authorizationAbilities: "server/abilities"
 });
 function normalizeHoloProjectConfig(config = {}) {
   return Object.freeze({
@@ -14215,6 +14161,7 @@ export {
   column,
   compileDialectDefaultLiteral,
   configureDB,
+  configureDatabaseQueryCacheBridge,
   connectionAsyncContext,
   createAdapter,
   createCapabilities,
@@ -14267,6 +14214,7 @@ export {
   generateSnowflake,
   generateUlid,
   generateUuidV7,
+  getDatabaseQueryCacheBridge,
   getGeneratedTableDefinition,
   getModelDefinition,
   hasMany,
@@ -14293,6 +14241,7 @@ export {
   oldestMorphOne,
   oldestOfMany,
   parseDatabaseDriver,
+  queryCacheInternals,
   redactBindings,
   redactSql,
   registerGeneratedTables,
@@ -14302,6 +14251,7 @@ export {
   renderGeneratedSchemaModule,
   renderGeneratedSchemaPlaceholder,
   resetDB,
+  resetDatabaseQueryCacheBridge,
   resetMorphRegistry,
   resolveDialectColumnType,
   resolveDialectIdStrategyType,