@dbx-tools/appkit 0.9.73 → 0.9.79

package/README.md

@@ -131,6 +131,11 @@ one-time code) is lost on every restart. `"env"` is the right mode inside a
 deployed app, since the app service principal cannot grant on the cache schema
 anyway.
 
+The injected persistent storage includes a bounded process-local L1 powered by
+`lru-cache`. Warm hits avoid Lakebase reads and `last_accessed` writes; misses,
+expiry, deletion, and clear operations remain coherent with the persistent
+store.
+
 `lakebaseResolver.resolveLakebaseConnection()` accepts:
 
 | Option       | Type                                 | Default                                  | Description                                                                                                    |

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export const PACKAGE_VERSION = "0.9.73";
+export const PACKAGE_VERSION = "0.9.79";
 export * as appkit from "./src/appkit.ts";
 export * as brandContext from "./src/brand-context.ts";
 export * as bundle from "./src/bundle.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export declare const PACKAGE_VERSION = "0.9.73";
+export declare const PACKAGE_VERSION = "0.9.79";
 export * as appkit from "./src/appkit.ts";
 export * as brandContext from "./src/brand-context.ts";
 export * as bundle from "./src/bundle.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/appkit";
-export const PACKAGE_VERSION = "0.9.73";
+export const PACKAGE_VERSION = "0.9.79";
 export * as appkit from "./src/appkit.js";
 export * as brandContext from "./src/brand-context.js";
 export * as bundle from "./src/bundle.js";
@@ -25,4 +25,4 @@ export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES,
 export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.js";
 export { SSL_MODES } from "./src/pgaddress.js";
 export { ToolRegistryPlugin } from "./src/tool-provider.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_cache-storage.d.ts

@@ -16,6 +16,15 @@
 import { createLakebasePool, type CacheConfig } from "@databricks/appkit";
 type LakebasePool = ReturnType<typeof createLakebasePool>;
 type CacheStorage = NonNullable<CacheConfig["storage"]>;
+interface CacheEntry<T = unknown> {
+    expiry: number;
+    value: T;
+}
+/** Bounds for the process-local cache layered over persistent AppKit storage. */
+export interface L1CacheStorageOptions {
+    maxBytes?: number;
+    maxEntries?: number;
+}
 /** AppKit's internal persistent storage surface. */
 export type PersistentStorageBase = CacheStorage & {
     initialize(): Promise<void>;
@@ -24,6 +33,22 @@ export type PersistentStorageBase = CacheStorage & {
     tableName?: string;
 };
 type PersistentStorageConstructor = new (config: CacheConfig, pool: LakebasePool) => PersistentStorageBase;
+/** Process-local LRU that avoids a persistent cache query on every warm hit. */
+export declare class L1CacheStorage implements CacheStorage {
+    private readonly storage;
+    private readonly entries;
+    constructor(storage: CacheStorage, options?: L1CacheStorageOptions);
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    set<T>(key: string, entry: CacheEntry<T>): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    size(): Promise<number>;
+    isPersistent(): boolean;
+    healthCheck(): Promise<boolean>;
+    close(): Promise<void>;
+    private retain;
+}
 /**
  * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`
  * means not attempted yet; `undefined` means the lookup already failed.

package/lib/src/_cache-storage.js

@@ -18,9 +18,82 @@ import { dirname, join } from "node:path";
 import { createLakebasePool, getWorkspaceClient } from "@databricks/appkit";
 import { postgresConnectionOptions } from "@dbx-tools/postgres";
 import { errorUtils, hash, log } from "@dbx-tools/shared-core";
+import { LRUCache } from "lru-cache";
 import { handleOwnershipMigrationError } from "./migration.js";
 const logger = log.logger("cache-storage");
 let persistentStorageCtor = null;
+/** Process-local LRU that avoids a persistent cache query on every warm hit. */
+export class L1CacheStorage {
+    storage;
+    entries;
+    constructor(storage, options = {}) {
+        this.storage = storage;
+        this.entries = new LRUCache({
+            max: positiveBound(options.maxEntries, 1_000, "maxEntries"),
+            maxSize: positiveBound(options.maxBytes, 64 * 1024 * 1024, "maxBytes"),
+            sizeCalculation: (entry, key) => retainedSize(key, entry),
+        });
+    }
+    async get(key) {
+        const local = this.entries.get(key);
+        if (local)
+            return local;
+        const persisted = await this.storage.get(key);
+        if (persisted && persisted.expiry > Date.now())
+            this.retain(key, persisted);
+        return persisted;
+    }
+    async set(key, entry) {
+        await this.storage.set(key, entry);
+        this.retain(key, entry);
+    }
+    async delete(key) {
+        await this.storage.delete(key);
+        this.entries.delete(key);
+    }
+    async clear() {
+        await this.storage.clear();
+        this.entries.clear();
+    }
+    async has(key) {
+        if (this.entries.has(key))
+            return true;
+        return this.storage.has(key);
+    }
+    size() {
+        return this.storage.size();
+    }
+    isPersistent() {
+        return this.storage.isPersistent();
+    }
+    healthCheck() {
+        return this.storage.healthCheck();
+    }
+    async close() {
+        this.entries.clear();
+        await this.storage.close();
+    }
+    retain(key, entry) {
+        const ttl = entry.expiry - Date.now();
+        if (ttl > 0)
+            this.entries.set(key, entry, { ttl });
+    }
+}
+function positiveBound(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        throw new RangeError(`${name} must be a finite positive number`);
+    }
+    return Math.floor(resolved);
+}
+function retainedSize(key, entry) {
+    try {
+        return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry));
+    }
+    catch {
+        return Number.MAX_SAFE_INTEGER;
+    }
+}
 /**
  * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`
  * means not attempted yet; `undefined` means the lookup already failed.
@@ -139,7 +212,10 @@ export async function createSoftPersistentStorage(cache) {
         }
         await storage.initialize();
         await probeStorage(storage);
-        return storage;
+        return new L1CacheStorage(storage, {
+            maxBytes: cache?.maxBytes,
+            maxEntries: cache?.maxSize,
+        });
     }
     catch (err) {
         logger.debug("soft persistent cache unavailable", {
@@ -151,4 +227,4 @@ export async function createSoftPersistentStorage(cache) {
         return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_cache-storage.js","sourceRoot":"","sources":["../../src/_cache-storage.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Soft-fail Lakebase cache storage for AppKit's persistent cache.\n *\n * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on\n * any step failure. With `cache.strictPersistence: true` that throw makes\n * `CacheManager` silently disable the cache. This wraps the same storage,\n * still runs its migrations, but logs a failed step instead of throwing so a\n * usable table keeps serving.\n *\n * `PersistentStorage` is not on AppKit's public export map. The deep load is\n * lazy and best-effort: if the installed AppKit layout changes, this returns\n * `undefined` and `createApp` leaves AppKit on its default cache path.\n *\n * @module\n */\n\nimport { createRequire } from \"node:module\";\nimport { dirname, join } from \"node:path\";\nimport { createLakebasePool, getWorkspaceClient, type CacheConfig } from \"@databricks/appkit\";\nimport { postgresConnectionOptions } from \"@dbx-tools/postgres\";\nimport { errorUtils, hash, log } from \"@dbx-tools/shared-core\";\nimport { handleOwnershipMigrationError } from \"./migration.ts\";\n\nconst logger = log.logger(\"cache-storage\");\n\ntype LakebasePool = ReturnType<typeof createLakebasePool>;\ntype CacheStorage = NonNullable<CacheConfig[\"storage\"]>;\n\n/** AppKit's internal persistent storage surface. */\nexport type PersistentStorageBase = CacheStorage & {\n  initialize(): Promise<void>;\n  initialized: boolean;\n  schemaName?: string;\n  tableName?: string;\n};\n\ntype PersistentStorageConstructor = new (\n  config: CacheConfig,\n  pool: LakebasePool,\n) => PersistentStorageBase;\n\nlet persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;\n\n/**\n * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`\n * means not attempted yet; `undefined` means the lookup already failed.\n */\nexport function loadPersistentStorage(): PersistentStorageConstructor | undefined {\n  if (persistentStorageCtor !== null) {\n    return persistentStorageCtor;\n  }\n  try {\n    const require = createRequire(import.meta.url);\n    const modulePath = join(\n      dirname(require.resolve(\"@databricks/appkit\")),\n      \"cache/storage/persistent.js\",\n    );\n    const loaded = require(modulePath).PersistentStorage as\n      PersistentStorageConstructor | undefined;\n    if (typeof loaded !== \"function\") {\n      logger.debug(\"soft persistent cache skipped (PersistentStorage missing)\");\n      persistentStorageCtor = undefined;\n      return undefined;\n    }\n    persistentStorageCtor = loaded;\n    return loaded;\n  } catch (err) {\n    logger.debug(\"soft persistent cache skipped (PersistentStorage unavailable)\", {\n      error: errorUtils.errorMessage(err),\n    });\n    persistentStorageCtor = undefined;\n    return undefined;\n  }\n}\n\n/**\n * Whether an existing cache table belongs to another role.\n *\n * PostgreSQL allows granted reads/writes but reserves index DDL for the table\n * owner. Skip AppKit migrations in that case; {@link probeStorage} still proves\n * the existing table can serve the cache before it is accepted.\n */\nasync function tableOwnedByAnotherRole(\n  storage: PersistentStorageBase,\n  pool: LakebasePool,\n): Promise<boolean> {\n  if (!storage.schemaName || !storage.tableName) return false;\n  const result = await pool.query(\n    `SELECT pg_get_userbyid(c.relowner) = current_user AS owned\n     FROM pg_class c\n     JOIN pg_namespace n ON n.oid = c.relnamespace\n     WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r', 'p')`,\n    [storage.schemaName, storage.tableName],\n  );\n  if (result.rows[0]?.owned !== false) return false;\n  logger.warn(\"persistent cache migrations skipped (table owned by another role)\", {\n    schema: storage.schemaName,\n    table: storage.tableName,\n  });\n  return true;\n}\n\n/** Soften `initialize()` so an ownership-only migration failure is not fatal. */\nexport function softenInitialize(\n  storage: PersistentStorageBase,\n  skipMigrations?: () => Promise<boolean>,\n): void {\n  const originalInitialize = storage.initialize.bind(storage);\n  let softInitPromise: Promise<void> | undefined;\n\n  storage.initialize = async () => {\n    if (storage.initialized) return;\n    softInitPromise ??= (async () => {\n      try {\n        if (!(await skipMigrations?.())) await originalInitialize();\n      } catch (err) {\n        if (\n          !handleOwnershipMigrationError(err, {\n            scope: \"cache-storage\",\n            logger,\n            event: \"persistent cache migration failed\",\n          })\n        ) {\n          throw err;\n        }\n      }\n    })();\n    try {\n      await softInitPromise;\n      storage.initialized = true;\n    } catch (err) {\n      softInitPromise = undefined;\n      throw err;\n    }\n  };\n}\n\n/** Verify the migrated cache table can serve the reads and writes AppKit needs. */\nexport async function probeStorage(storage: PersistentStorageBase): Promise<void> {\n  const key = `dbx-tools:cache-probe:${hash.id()}`;\n  try {\n    await storage.set(key, { value: key, expiry: Date.now() + 60_000 });\n    const result = await storage.get(key);\n    if (result?.value !== key) {\n      throw new Error(\"persistent cache probe returned an unexpected value\");\n    }\n  } finally {\n    await storage.delete(key).catch(() => undefined);\n  }\n}\n\n/**\n * Build a soft-fail Lakebase cache storage when a pool can be created and\n * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so\n * AppKit can fall through to its normal cache path.\n */\nexport async function createSoftPersistentStorage(\n  cache: CacheConfig | undefined,\n): Promise<CacheStorage | undefined> {\n  const PersistentStorage = loadPersistentStorage();\n  if (!PersistentStorage) {\n    return undefined;\n  }\n\n  let pool: LakebasePool | undefined;\n  try {\n    const createdPool = createLakebasePool(\n      postgresConnectionOptions({ workspaceClient: getWorkspaceClient({}) }),\n    );\n    pool = createdPool;\n    const storage = new PersistentStorage(cache ?? {}, createdPool);\n    softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));\n    if (!(await storage.healthCheck())) {\n      await storage.close().catch(() => {});\n      return undefined;\n    }\n    await storage.initialize();\n    await probeStorage(storage);\n    return storage;\n  } catch (err) {\n    logger.debug(\"soft persistent cache unavailable\", {\n      error: errorUtils.errorMessage(err),\n    });\n    if (pool) {\n      await pool.end().catch(() => {});\n    }\n    return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_cache-storage.js","sourceRoot":"","sources":["../../src/_cache-storage.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Soft-fail Lakebase cache storage for AppKit's persistent cache.\n *\n * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on\n * any step failure. With `cache.strictPersistence: true` that throw makes\n * `CacheManager` silently disable the cache. This wraps the same storage,\n * still runs its migrations, but logs a failed step instead of throwing so a\n * usable table keeps serving.\n *\n * `PersistentStorage` is not on AppKit's public export map. The deep load is\n * lazy and best-effort: if the installed AppKit layout changes, this returns\n * `undefined` and `createApp` leaves AppKit on its default cache path.\n *\n * @module\n */\n\nimport { createRequire } from \"node:module\";\nimport { dirname, join } from \"node:path\";\nimport { createLakebasePool, getWorkspaceClient, type CacheConfig } from \"@databricks/appkit\";\nimport { postgresConnectionOptions } from \"@dbx-tools/postgres\";\nimport { errorUtils, hash, log } from \"@dbx-tools/shared-core\";\nimport { LRUCache } from \"lru-cache\";\nimport { handleOwnershipMigrationError } from \"./migration.ts\";\n\nconst logger = log.logger(\"cache-storage\");\n\ntype LakebasePool = ReturnType<typeof createLakebasePool>;\ntype CacheStorage = NonNullable<CacheConfig[\"storage\"]>;\n\ninterface CacheEntry<T = unknown> {\n  expiry: number;\n  value: T;\n}\n\n/** Bounds for the process-local cache layered over persistent AppKit storage. */\nexport interface L1CacheStorageOptions {\n  maxBytes?: number;\n  maxEntries?: number;\n}\n\n/** AppKit's internal persistent storage surface. */\nexport type PersistentStorageBase = CacheStorage & {\n  initialize(): Promise<void>;\n  initialized: boolean;\n  schemaName?: string;\n  tableName?: string;\n};\n\ntype PersistentStorageConstructor = new (\n  config: CacheConfig,\n  pool: LakebasePool,\n) => PersistentStorageBase;\n\nlet persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;\n\n/** Process-local LRU that avoids a persistent cache query on every warm hit. */\nexport class L1CacheStorage implements CacheStorage {\n  private readonly entries: LRUCache<string, CacheEntry>;\n\n  constructor(\n    private readonly storage: CacheStorage,\n    options: L1CacheStorageOptions = {},\n  ) {\n    this.entries = new LRUCache({\n      max: positiveBound(options.maxEntries, 1_000, \"maxEntries\"),\n      maxSize: positiveBound(options.maxBytes, 64 * 1024 * 1024, \"maxBytes\"),\n      sizeCalculation: (entry, key) => retainedSize(key, entry),\n    });\n  }\n\n  async get<T>(key: string): Promise<CacheEntry<T> | null> {\n    const local = this.entries.get(key);\n    if (local) return local as CacheEntry<T>;\n    const persisted = await this.storage.get<T>(key);\n    if (persisted && persisted.expiry > Date.now()) this.retain(key, persisted);\n    return persisted;\n  }\n\n  async set<T>(key: string, entry: CacheEntry<T>): Promise<void> {\n    await this.storage.set(key, entry);\n    this.retain(key, entry);\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.storage.delete(key);\n    this.entries.delete(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.storage.clear();\n    this.entries.clear();\n  }\n\n  async has(key: string): Promise<boolean> {\n    if (this.entries.has(key)) return true;\n    return this.storage.has(key);\n  }\n\n  size(): Promise<number> {\n    return this.storage.size();\n  }\n\n  isPersistent(): boolean {\n    return this.storage.isPersistent();\n  }\n\n  healthCheck(): Promise<boolean> {\n    return this.storage.healthCheck();\n  }\n\n  async close(): Promise<void> {\n    this.entries.clear();\n    await this.storage.close();\n  }\n\n  private retain<T>(key: string, entry: CacheEntry<T>): void {\n    const ttl = entry.expiry - Date.now();\n    if (ttl > 0) this.entries.set(key, entry, { ttl });\n  }\n}\n\nfunction positiveBound(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isFinite(resolved) || resolved <= 0) {\n    throw new RangeError(`${name} must be a finite positive number`);\n  }\n  return Math.floor(resolved);\n}\n\nfunction retainedSize(key: string, entry: CacheEntry): number {\n  try {\n    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry));\n  } catch {\n    return Number.MAX_SAFE_INTEGER;\n  }\n}\n\n/**\n * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`\n * means not attempted yet; `undefined` means the lookup already failed.\n */\nexport function loadPersistentStorage(): PersistentStorageConstructor | undefined {\n  if (persistentStorageCtor !== null) {\n    return persistentStorageCtor;\n  }\n  try {\n    const require = createRequire(import.meta.url);\n    const modulePath = join(\n      dirname(require.resolve(\"@databricks/appkit\")),\n      \"cache/storage/persistent.js\",\n    );\n    const loaded = require(modulePath).PersistentStorage as\n      PersistentStorageConstructor | undefined;\n    if (typeof loaded !== \"function\") {\n      logger.debug(\"soft persistent cache skipped (PersistentStorage missing)\");\n      persistentStorageCtor = undefined;\n      return undefined;\n    }\n    persistentStorageCtor = loaded;\n    return loaded;\n  } catch (err) {\n    logger.debug(\"soft persistent cache skipped (PersistentStorage unavailable)\", {\n      error: errorUtils.errorMessage(err),\n    });\n    persistentStorageCtor = undefined;\n    return undefined;\n  }\n}\n\n/**\n * Whether an existing cache table belongs to another role.\n *\n * PostgreSQL allows granted reads/writes but reserves index DDL for the table\n * owner. Skip AppKit migrations in that case; {@link probeStorage} still proves\n * the existing table can serve the cache before it is accepted.\n */\nasync function tableOwnedByAnotherRole(\n  storage: PersistentStorageBase,\n  pool: LakebasePool,\n): Promise<boolean> {\n  if (!storage.schemaName || !storage.tableName) return false;\n  const result = await pool.query(\n    `SELECT pg_get_userbyid(c.relowner) = current_user AS owned\n     FROM pg_class c\n     JOIN pg_namespace n ON n.oid = c.relnamespace\n     WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r', 'p')`,\n    [storage.schemaName, storage.tableName],\n  );\n  if (result.rows[0]?.owned !== false) return false;\n  logger.warn(\"persistent cache migrations skipped (table owned by another role)\", {\n    schema: storage.schemaName,\n    table: storage.tableName,\n  });\n  return true;\n}\n\n/** Soften `initialize()` so an ownership-only migration failure is not fatal. */\nexport function softenInitialize(\n  storage: PersistentStorageBase,\n  skipMigrations?: () => Promise<boolean>,\n): void {\n  const originalInitialize = storage.initialize.bind(storage);\n  let softInitPromise: Promise<void> | undefined;\n\n  storage.initialize = async () => {\n    if (storage.initialized) return;\n    softInitPromise ??= (async () => {\n      try {\n        if (!(await skipMigrations?.())) await originalInitialize();\n      } catch (err) {\n        if (\n          !handleOwnershipMigrationError(err, {\n            scope: \"cache-storage\",\n            logger,\n            event: \"persistent cache migration failed\",\n          })\n        ) {\n          throw err;\n        }\n      }\n    })();\n    try {\n      await softInitPromise;\n      storage.initialized = true;\n    } catch (err) {\n      softInitPromise = undefined;\n      throw err;\n    }\n  };\n}\n\n/** Verify the migrated cache table can serve the reads and writes AppKit needs. */\nexport async function probeStorage(storage: PersistentStorageBase): Promise<void> {\n  const key = `dbx-tools:cache-probe:${hash.id()}`;\n  try {\n    await storage.set(key, { value: key, expiry: Date.now() + 60_000 });\n    const result = await storage.get(key);\n    if (result?.value !== key) {\n      throw new Error(\"persistent cache probe returned an unexpected value\");\n    }\n  } finally {\n    await storage.delete(key).catch(() => undefined);\n  }\n}\n\n/**\n * Build a soft-fail Lakebase cache storage when a pool can be created and\n * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so\n * AppKit can fall through to its normal cache path.\n */\nexport async function createSoftPersistentStorage(\n  cache: CacheConfig | undefined,\n): Promise<CacheStorage | undefined> {\n  const PersistentStorage = loadPersistentStorage();\n  if (!PersistentStorage) {\n    return undefined;\n  }\n\n  let pool: LakebasePool | undefined;\n  try {\n    const createdPool = createLakebasePool(\n      postgresConnectionOptions({ workspaceClient: getWorkspaceClient({}) }),\n    );\n    pool = createdPool;\n    const storage = new PersistentStorage(cache ?? {}, createdPool);\n    softenInitialize(storage, () => tableOwnedByAnotherRole(storage, createdPool));\n    if (!(await storage.healthCheck())) {\n      await storage.close().catch(() => {});\n      return undefined;\n    }\n    await storage.initialize();\n    await probeStorage(storage);\n    return new L1CacheStorage(storage, {\n      maxBytes: cache?.maxBytes,\n      maxEntries: cache?.maxSize,\n    });\n  } catch (err) {\n    logger.debug(\"soft persistent cache unavailable\", {\n      error: errorUtils.errorMessage(err),\n    });\n    if (pool) {\n      await pool.end().catch(() => {});\n    }\n    return undefined;\n  }\n}\n"]}

package/package.json

@@ -20,7 +20,7 @@
   },
   "devDependencies": {
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/projen": "^0.9.73",
+    "@dbx-tools/projen": "^0.9.79",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3",
     "vitest": "3.2.4"
@@ -30,11 +30,12 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/auth": "^0.9.73",
-    "@dbx-tools/core": "^0.9.73",
-    "@dbx-tools/lakebase": "^0.9.73",
-    "@dbx-tools/postgres": "^0.9.73",
-    "@dbx-tools/shared-core": "^0.9.73",
+    "@dbx-tools/auth": "^0.9.79",
+    "@dbx-tools/core": "^0.9.79",
+    "@dbx-tools/lakebase": "^0.9.79",
+    "@dbx-tools/postgres": "^0.9.79",
+    "@dbx-tools/shared-core": "^0.9.79",
+    "lru-cache": "11.5.3",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -115,7 +116,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.73",
+  "version": "0.9.79",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [

package/src/_cache-storage.ts

@@ -19,6 +19,7 @@ import { dirname, join } from "node:path";
 import { createLakebasePool, getWorkspaceClient, type CacheConfig } from "@databricks/appkit";
 import { postgresConnectionOptions } from "@dbx-tools/postgres";
 import { errorUtils, hash, log } from "@dbx-tools/shared-core";
+import { LRUCache } from "lru-cache";
 import { handleOwnershipMigrationError } from "./migration.ts";
 
 const logger = log.logger("cache-storage");
@@ -26,6 +27,17 @@ const logger = log.logger("cache-storage");
 type LakebasePool = ReturnType<typeof createLakebasePool>;
 type CacheStorage = NonNullable<CacheConfig["storage"]>;
 
+interface CacheEntry<T = unknown> {
+  expiry: number;
+  value: T;
+}
+
+/** Bounds for the process-local cache layered over persistent AppKit storage. */
+export interface L1CacheStorageOptions {
+  maxBytes?: number;
+  maxEntries?: number;
+}
+
 /** AppKit's internal persistent storage surface. */
 export type PersistentStorageBase = CacheStorage & {
   initialize(): Promise<void>;
@@ -41,6 +53,88 @@ type PersistentStorageConstructor = new (
 
 let persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;
 
+/** Process-local LRU that avoids a persistent cache query on every warm hit. */
+export class L1CacheStorage implements CacheStorage {
+  private readonly entries: LRUCache<string, CacheEntry>;
+
+  constructor(
+    private readonly storage: CacheStorage,
+    options: L1CacheStorageOptions = {},
+  ) {
+    this.entries = new LRUCache({
+      max: positiveBound(options.maxEntries, 1_000, "maxEntries"),
+      maxSize: positiveBound(options.maxBytes, 64 * 1024 * 1024, "maxBytes"),
+      sizeCalculation: (entry, key) => retainedSize(key, entry),
+    });
+  }
+
+  async get<T>(key: string): Promise<CacheEntry<T> | null> {
+    const local = this.entries.get(key);
+    if (local) return local as CacheEntry<T>;
+    const persisted = await this.storage.get<T>(key);
+    if (persisted && persisted.expiry > Date.now()) this.retain(key, persisted);
+    return persisted;
+  }
+
+  async set<T>(key: string, entry: CacheEntry<T>): Promise<void> {
+    await this.storage.set(key, entry);
+    this.retain(key, entry);
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.storage.delete(key);
+    this.entries.delete(key);
+  }
+
+  async clear(): Promise<void> {
+    await this.storage.clear();
+    this.entries.clear();
+  }
+
+  async has(key: string): Promise<boolean> {
+    if (this.entries.has(key)) return true;
+    return this.storage.has(key);
+  }
+
+  size(): Promise<number> {
+    return this.storage.size();
+  }
+
+  isPersistent(): boolean {
+    return this.storage.isPersistent();
+  }
+
+  healthCheck(): Promise<boolean> {
+    return this.storage.healthCheck();
+  }
+
+  async close(): Promise<void> {
+    this.entries.clear();
+    await this.storage.close();
+  }
+
+  private retain<T>(key: string, entry: CacheEntry<T>): void {
+    const ttl = entry.expiry - Date.now();
+    if (ttl > 0) this.entries.set(key, entry, { ttl });
+  }
+}
+
+function positiveBound(value: number | undefined, fallback: number, name: string): number {
+  const resolved = value ?? fallback;
+  if (!Number.isFinite(resolved) || resolved <= 0) {
+    throw new RangeError(`${name} must be a finite positive number`);
+  }
+  return Math.floor(resolved);
+}
+
+function retainedSize(key: string, entry: CacheEntry): number {
+  try {
+    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(entry));
+  } catch {
+    return Number.MAX_SAFE_INTEGER;
+  }
+}
+
 /**
  * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`
  * means not attempted yet; `undefined` means the lookup already failed.
@@ -176,7 +270,10 @@ export async function createSoftPersistentStorage(
     }
     await storage.initialize();
     await probeStorage(storage);
-    return storage;
+    return new L1CacheStorage(storage, {
+      maxBytes: cache?.maxBytes,
+      maxEntries: cache?.maxSize,
+    });
   } catch (err) {
     logger.debug("soft persistent cache unavailable", {
       error: errorUtils.errorMessage(err),