@holo-js/db 0.2.4 → 0.2.5

package/dist/index.d.ts

@@ -692,24 +692,36 @@ declare function resetDatabaseQueryCacheBridge(): void;
 declare function onDatabaseDependencyInvalidated(listener: DatabaseDependencyInvalidationListener): () => void;
 declare function resetDatabaseDependencyInvalidationListeners(): void;
 declare function collectDatabaseQueryDependencies<TValue>(callback: () => TValue | Promise<TValue>): Promise<DatabaseDependencyCollectionResult<TValue>>;
+declare function hasActiveDatabaseDependencyCollector(): boolean;
 declare function recordDatabaseQueryDependencies(dependencies: readonly string[] | undefined): void;
+declare function hasDatabaseDependencyInvalidationListeners(): boolean;
 declare function notifyDatabaseDependencyInvalidationListeners(event: DatabaseDependencyInvalidationEvent): Promise<void>;
 declare function normalizeQueryCacheConfig(input: QueryCacheTtlInput | QueryCacheConfig): NormalizedQueryCacheConfig;
 declare function createDeterministicQueryCacheKey(statement: CompiledStatement, connectionName: string): string;
 declare function resolveQueryCacheKey(statement: CompiledStatement, connectionName: string, config: NormalizedQueryCacheConfig): string;
 declare function createTableCacheDependency(connectionName: string, tableName: string): string;
+declare function createTableRowCacheDependency(connectionName: string, tableName: string, columnName: string, value: unknown): string | undefined;
+declare function createTableRowWildcardCacheDependency(connectionName: string, tableName: string): string;
 declare function normalizeQueryCacheDependencies(connectionName: string, dependencies: readonly string[]): readonly string[];
 declare function supportsAutomaticPredicateInvalidation(predicate: QueryPredicateNode): boolean;
 declare function supportsAutomaticQueryCacheInvalidation(plan: SelectQueryPlan): boolean;
 declare function inferAutomaticQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string): readonly string[] | undefined;
+declare function inferAutomaticQueryCacheInvalidationDependencies(plan: SelectQueryPlan, connectionName: string): readonly string[];
+declare function inferAutomaticInsertCacheInvalidationDependencies(connectionName: string, tableName: string, rows: readonly Readonly<Record<string, unknown>>[], lastInsertId?: number | string): readonly string[];
 declare function resolveQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string, explicit?: readonly string[]): readonly string[] | undefined;
 declare const queryCacheInternals: {
     collectDatabaseQueryDependencies: typeof collectDatabaseQueryDependencies;
     configureDatabaseQueryCacheBridge: typeof configureDatabaseQueryCacheBridge;
     createDeterministicQueryCacheKey: typeof createDeterministicQueryCacheKey;
     createTableCacheDependency: typeof createTableCacheDependency;
+    createTableRowCacheDependency: typeof createTableRowCacheDependency;
+    createTableRowWildcardCacheDependency: typeof createTableRowWildcardCacheDependency;
     getQueryCacheBridgeState: typeof getQueryCacheBridgeState;
+    hasActiveDatabaseDependencyCollector: typeof hasActiveDatabaseDependencyCollector;
+    hasDatabaseDependencyInvalidationListeners: typeof hasDatabaseDependencyInvalidationListeners;
+    inferAutomaticInsertCacheInvalidationDependencies: typeof inferAutomaticInsertCacheInvalidationDependencies;
     inferAutomaticQueryCacheDependencies: typeof inferAutomaticQueryCacheDependencies;
+    inferAutomaticQueryCacheInvalidationDependencies: typeof inferAutomaticQueryCacheInvalidationDependencies;
     normalizeQueryCacheConfig: typeof normalizeQueryCacheConfig;
     normalizeQueryCacheDependencies: typeof normalizeQueryCacheDependencies;
     notifyDatabaseDependencyInvalidationListeners: typeof notifyDatabaseDependencyInvalidationListeners;
@@ -1017,7 +1029,8 @@ declare class TableQueryBuilder<TTableOrName extends TableReference = string, TS
     unsafeQuery<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: Omit<UnsafeStatement, 'source'>): Promise<DriverQueryResult<TRow>>;
     unsafeExecute(statement: Omit<UnsafeStatement, 'source'>): Promise<DriverExecutionResult>;
     private clone;
-    private invalidateSourceTableQueries;
+    private invalidateInsertQueries;
+    private invalidateMutationQueries;
     private getCompiler;
     private getUnpaginatedRows;
     private resolvePrimaryKeyColumn;

package/dist/index.mjs

@@ -156,6 +156,9 @@ async function collectDatabaseQueryDependencies(callback) {
     dependencies: Object.freeze([...dependencies])
   });
 }
+function hasActiveDatabaseDependencyCollector() {
+  return typeof databaseDependencyCollector.getStore() !== "undefined";
+}
 function recordDatabaseQueryDependencies(dependencies) {
   if (!dependencies || dependencies.length === 0) {
     return;
@@ -168,6 +171,10 @@ function recordDatabaseQueryDependencies(dependencies) {
     active.add(dependency);
   }
 }
+function hasDatabaseDependencyInvalidationListeners() {
+  const listeners = getQueryCacheBridgeState().dependencyInvalidationListeners;
+  return typeof listeners !== "undefined" && listeners.size > 0;
+}
 async function notifyDatabaseDependencyInvalidationListeners(event) {
   const listeners = getQueryCacheBridgeState().dependencyInvalidationListeners;
   if (!listeners || listeners.size === 0) {
@@ -232,6 +239,15 @@ function resolveQueryCacheKey(statement, connectionName, config) {
 function createTableCacheDependency(connectionName, tableName) {
   return `db:${connectionName}:${tableName}`;
 }
+function createTableRowCacheDependency(connectionName, tableName, columnName, value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  return `db:${connectionName}:${tableName}:row:${columnName}:${encodeURIComponent(JSON.stringify(value))}`;
+}
+function createTableRowWildcardCacheDependency(connectionName, tableName) {
+  return `db:${connectionName}:${tableName}:row:*`;
+}
 function normalizeQueryCacheDependencies(connectionName, dependencies) {
   return Object.freeze(dependencies.map((dependency) => {
     return dependency.startsWith("db:") ? dependency : createTableCacheDependency(connectionName, dependency);
@@ -257,6 +273,42 @@ function supportsAutomaticPredicateInvalidation(predicate) {
       return false;
   }
 }
+function getColumnName(column2) {
+  const segments = column2.split(".");
+  return segments[segments.length - 1] ?? column2;
+}
+function getPrimaryKeyColumn(plan) {
+  const columns = plan.source.table?.columns;
+  if (!columns) {
+    return "id";
+  }
+  return Object.values(columns).find((column2) => column2.primaryKey)?.name ?? "id";
+}
+function hasDisjunctivePredicate(predicates) {
+  return predicates.some((predicate) => {
+    if (predicate.boolean === "or") {
+      return true;
+    }
+    if (predicate.kind !== "group") {
+      return false;
+    }
+    return predicate.negated === true || hasDisjunctivePredicate(predicate.predicates);
+  });
+}
+function findExactPrimaryKeyValue(predicates, primaryKeyColumn) {
+  for (const predicate of predicates) {
+    if (predicate.kind === "comparison" && predicate.operator === "=" && getColumnName(predicate.column) === primaryKeyColumn) {
+      return predicate.value;
+    }
+    if (predicate.kind === "group" && !predicate.negated && predicate.boolean !== "or") {
+      const value = findExactPrimaryKeyValue(predicate.predicates, primaryKeyColumn);
+      if (typeof value !== "undefined") {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
 function supportsAutomaticQueryCacheInvalidation(plan) {
   if (plan.joins.length > 0 || plan.unions.length > 0 || plan.having.length > 0) {
     return false;
@@ -273,10 +325,64 @@ function inferAutomaticQueryCacheDependencies(plan, connectionName) {
   if (!supportsAutomaticQueryCacheInvalidation(plan)) {
     return void 0;
   }
+  if (!hasDisjunctivePredicate(plan.predicates)) {
+    const primaryKeyColumn = getPrimaryKeyColumn(plan);
+    const primaryKeyValue = findExactPrimaryKeyValue(plan.predicates, primaryKeyColumn);
+    const primaryKeyDependency = createTableRowCacheDependency(
+      connectionName,
+      plan.source.tableName,
+      primaryKeyColumn,
+      primaryKeyValue
+    );
+    if (primaryKeyDependency) {
+      return Object.freeze([
+        primaryKeyDependency,
+        createTableRowWildcardCacheDependency(connectionName, plan.source.tableName)
+      ]);
+    }
+  }
   return Object.freeze([
     createTableCacheDependency(connectionName, plan.source.tableName)
   ]);
 }
+function inferAutomaticQueryCacheInvalidationDependencies(plan, connectionName) {
+  const dependencies = [
+    createTableCacheDependency(connectionName, plan.source.tableName)
+  ];
+  if (hasDisjunctivePredicate(plan.predicates)) {
+    dependencies.push(createTableRowWildcardCacheDependency(connectionName, plan.source.tableName));
+    return Object.freeze(dependencies);
+  }
+  const primaryKeyColumn = getPrimaryKeyColumn(plan);
+  const primaryKeyValue = findExactPrimaryKeyValue(plan.predicates, primaryKeyColumn);
+  const primaryKeyDependency = createTableRowCacheDependency(
+    connectionName,
+    plan.source.tableName,
+    primaryKeyColumn,
+    primaryKeyValue
+  );
+  dependencies.push(primaryKeyDependency ?? createTableRowWildcardCacheDependency(connectionName, plan.source.tableName));
+  return Object.freeze(dependencies);
+}
+function inferAutomaticInsertCacheInvalidationDependencies(connectionName, tableName, rows, lastInsertId) {
+  const dependencies = /* @__PURE__ */ new Set([
+    createTableCacheDependency(connectionName, tableName)
+  ]);
+  for (const row of rows) {
+    const dependency = createTableRowCacheDependency(connectionName, tableName, "id", row.id);
+    if (dependency) {
+      dependencies.add(dependency);
+    }
+  }
+  const lastInsertDependency = createTableRowCacheDependency(connectionName, tableName, "id", lastInsertId);
+  if (lastInsertDependency) {
+    dependencies.add(lastInsertDependency);
+  }
+  if (dependencies.size === 1) {
+    dependencies.add(createTableRowWildcardCacheDependency(connectionName, tableName));
+  }
+  return Object.freeze([...dependencies]);
+}
 function resolveQueryCacheDependencies(plan, connectionName, explicit) {
   if (explicit && explicit.length > 0) {
     return normalizeQueryCacheDependencies(connectionName, explicit);
@@ -306,8 +412,14 @@ var queryCacheInternals = {
   configureDatabaseQueryCacheBridge,
   createDeterministicQueryCacheKey,
   createTableCacheDependency,
+  createTableRowCacheDependency,
+  createTableRowWildcardCacheDependency,
   getQueryCacheBridgeState,
+  hasActiveDatabaseDependencyCollector,
+  hasDatabaseDependencyInvalidationListeners,
+  inferAutomaticInsertCacheInvalidationDependencies,
   inferAutomaticQueryCacheDependencies,
+  inferAutomaticQueryCacheInvalidationDependencies,
   normalizeQueryCacheConfig,
   normalizeQueryCacheDependencies,
   notifyDatabaseDependencyInvalidationListeners,
@@ -2809,7 +2921,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
   async get() {
     const statement = this.toSQL();
     const cacheConfig = this.queryCacheConfig;
-    const dependencies = this.plan.lockMode ? void 0 : resolveQueryCacheDependencies(
+    const dependencies = this.plan.lockMode || !cacheConfig && !hasActiveDatabaseDependencyCollector() ? void 0 : resolveQueryCacheDependencies(
       this.plan,
       this.connection.getConnectionName(),
       cacheConfig?.invalidate
@@ -3056,7 +3168,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
     const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createInsertQueryPlan(this.source, rows)
     ));
-    await this.invalidateSourceTableQueries();
+    await this.invalidateInsertQueries(rows, result.lastInsertId);
     return result;
   }
   async insertOrIgnore(values) {
@@ -3064,7 +3176,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
     const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createInsertQueryPlan(this.source, rows, { ignoreConflicts: true })
     ));
-    await this.invalidateSourceTableQueries();
+    await this.invalidateInsertQueries(rows, result.lastInsertId);
     return result;
   }
   async insertGetId(values) {
@@ -3076,7 +3188,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
     const result = await this.connection.executeCompiled(this.getCompiler().compile(
       createUpsertQueryPlan(this.source, rows, uniqueBy, updateColumns)
     ));
-    await this.invalidateSourceTableQueries();
+    await this.invalidateInsertQueries(rows, result.lastInsertId);
     return result;
   }
   async increment(column2, amount = 1, extraValues = {}) {
@@ -3090,7 +3202,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
       createUpdateQueryPlan(this.source, this.plan.predicates, this.normalizeUpdateValues(values))
     ));
     if (result.affectedRows !== 0) {
-      await this.invalidateSourceTableQueries();
+      await this.invalidateMutationQueries();
     }
     return result;
   }
@@ -3102,7 +3214,7 @@ var TableQueryBuilder = class _TableQueryBuilder {
       createDeleteQueryPlan(this.source, this.plan.predicates)
     ));
     if (result.affectedRows !== 0) {
-      await this.invalidateSourceTableQueries();
+      await this.invalidateMutationQueries();
     }
     return result;
   }
@@ -3124,10 +3236,28 @@ var TableQueryBuilder = class _TableQueryBuilder {
     const table = this.source.table ?? this.source.tableName;
     return new _TableQueryBuilder(table, this.connection, plan, this.queryCacheConfig);
   }
-  async invalidateSourceTableQueries() {
-    await invalidateQueryCacheDependencies(this.connection, [
-      `db:${this.connection.getConnectionName()}:${this.source.tableName}`
-    ]);
+  async invalidateInsertQueries(rows, lastInsertId) {
+    if (!getDatabaseQueryCacheBridge() && !hasDatabaseDependencyInvalidationListeners()) {
+      return;
+    }
+    await invalidateQueryCacheDependencies(
+      this.connection,
+      inferAutomaticInsertCacheInvalidationDependencies(
+        this.connection.getConnectionName(),
+        this.source.tableName,
+        rows,
+        lastInsertId
+      )
+    );
+  }
+  async invalidateMutationQueries() {
+    if (!getDatabaseQueryCacheBridge() && !hasDatabaseDependencyInvalidationListeners()) {
+      return;
+    }
+    await invalidateQueryCacheDependencies(
+      this.connection,
+      inferAutomaticQueryCacheInvalidationDependencies(this.plan, this.connection.getConnectionName())
+    );
   }
   getCompiler() {
     const dialect = this.connection.getDialect();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/db",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Holo-JS Framework - portable database, ORM, migrations, factories, and seeders",
   "type": "module",
   "license": "MIT",
@@ -28,9 +28,9 @@
     "uuid": "^12.0.0"
   },
   "peerDependencies": {
-    "@holo-js/db-mysql": "^0.2.4",
-    "@holo-js/db-postgres": "^0.2.4",
-    "@holo-js/db-sqlite": "^0.2.4"
+    "@holo-js/db-mysql": "^0.2.5",
+    "@holo-js/db-postgres": "^0.2.5",
+    "@holo-js/db-sqlite": "^0.2.5"
   },
   "peerDependenciesMeta": {
     "@holo-js/db-mysql": {
@@ -44,9 +44,9 @@
     }
   },
   "devDependencies": {
-    "@holo-js/db-mysql": "^0.2.4",
-    "@holo-js/db-postgres": "^0.2.4",
-    "@holo-js/db-sqlite": "^0.2.4",
+    "@holo-js/db-mysql": "^0.2.5",
+    "@holo-js/db-postgres": "^0.2.5",
+    "@holo-js/db-sqlite": "^0.2.5",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
   }