@dbx-tools/appkit 0.6.70 → 0.6.72

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

@@ -0,0 +1,24 @@
+/**
+ * Soft-fail Lakebase cache storage for AppKit's persistent cache.
+ *
+ * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on
+ * any step failure. With `cache.strictPersistence: true` that throw makes
+ * `CacheManager` silently disable the cache. This wraps the same storage,
+ * still runs its migrations, but logs a failed step instead of throwing so a
+ * usable table keeps serving.
+ *
+ * `PersistentStorage` is not on AppKit's public export map. The deep load is
+ * lazy and best-effort: if the installed AppKit layout changes, this returns
+ * `undefined` and `createApp` leaves AppKit on its default cache path.
+ *
+ * @module
+ */
+import { type CacheConfig } from "@databricks/appkit";
+type CacheStorage = NonNullable<CacheConfig["storage"]>;
+/**
+ * Build a soft-fail Lakebase cache storage when a pool can be created and
+ * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so
+ * AppKit can fall through to its normal cache path.
+ */
+export declare function createSoftPersistentStorage(cache: CacheConfig | undefined): Promise<CacheStorage | undefined>;
+export {};

package/lib/src/_cache-storage.js

@@ -0,0 +1,121 @@
+/**
+ * Soft-fail Lakebase cache storage for AppKit's persistent cache.
+ *
+ * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on
+ * any step failure. With `cache.strictPersistence: true` that throw makes
+ * `CacheManager` silently disable the cache. This wraps the same storage,
+ * still runs its migrations, but logs a failed step instead of throwing so a
+ * usable table keeps serving.
+ *
+ * `PersistentStorage` is not on AppKit's public export map. The deep load is
+ * lazy and best-effort: if the installed AppKit layout changes, this returns
+ * `undefined` and `createApp` leaves AppKit on its default cache path.
+ *
+ * @module
+ */
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { createLakebasePool, getWorkspaceClient } from "@databricks/appkit";
+import { error, log } from "@dbx-tools/shared-core";
+const logger = log.logger("cache-storage");
+/** Process-wide dedupe for soft migration warnings. */
+const loggedMigrationErrors = new Set();
+/** Whether `LOG_LEVEL` is currently at or below debug. */
+function isDebugEnabled() {
+    return log.isLevelEnabled("debug");
+}
+let persistentStorageCtor = null;
+/**
+ * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`
+ * means the lookup already failed; `undefined` means not attempted yet.
+ */
+function loadPersistentStorage() {
+    if (persistentStorageCtor !== null) {
+        return persistentStorageCtor;
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const modulePath = join(dirname(require.resolve("@databricks/appkit")), "cache/storage/persistent.js");
+        const loaded = require(modulePath).PersistentStorage;
+        if (typeof loaded !== "function") {
+            logger.debug("soft persistent cache skipped (PersistentStorage missing)");
+            persistentStorageCtor = undefined;
+            return undefined;
+        }
+        persistentStorageCtor = loaded;
+        return loaded;
+    }
+    catch (err) {
+        logger.debug("soft persistent cache skipped (PersistentStorage unavailable)", {
+            error: error.errorMessage(err),
+        });
+        persistentStorageCtor = undefined;
+        return undefined;
+    }
+}
+/** Soften `initialize()` so a migration failure is logged once, not thrown. */
+function softenInitialize(storage) {
+    const originalInitialize = storage.initialize.bind(storage);
+    let softInitPromise;
+    storage.initialize = async () => {
+        if (storage.initialized)
+            return;
+        softInitPromise ??= (async () => {
+            try {
+                await originalInitialize();
+            }
+            catch (err) {
+                storage.initialized = true;
+                const message = error.errorMessage(err);
+                if (!loggedMigrationErrors.has(message)) {
+                    loggedMigrationErrors.add(message);
+                    if (isDebugEnabled()) {
+                        logger.error("persistent cache migration failed", err);
+                    }
+                    else {
+                        logger.warn("persistent cache migration failed", { error: message });
+                    }
+                }
+            }
+        })();
+        try {
+            await softInitPromise;
+        }
+        finally {
+            storage.initialized = true;
+        }
+    };
+}
+/**
+ * Build a soft-fail Lakebase cache storage when a pool can be created and
+ * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so
+ * AppKit can fall through to its normal cache path.
+ */
+export async function createSoftPersistentStorage(cache) {
+    const PersistentStorage = loadPersistentStorage();
+    if (!PersistentStorage) {
+        return undefined;
+    }
+    let pool;
+    try {
+        pool = createLakebasePool({ workspaceClient: getWorkspaceClient({}) });
+        const storage = new PersistentStorage(cache ?? {}, pool);
+        softenInitialize(storage);
+        if (!(await storage.healthCheck())) {
+            await storage.close().catch(() => { });
+            return undefined;
+        }
+        await storage.initialize();
+        return storage;
+    }
+    catch (err) {
+        logger.debug("soft persistent cache unavailable", {
+            error: error.errorMessage(err),
+        });
+        if (pool) {
+            await pool.end().catch(() => { });
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_cache-storage.js","sourceRoot":"","sources":["../../src/_cache-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAoB,MAAM,oBAAoB,CAAC;AAC9F,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAEpD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AAE3C,uDAAuD;AACvD,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAU,CAAC;AAEhD,0DAA0D;AAC1D,SAAS,cAAc;IACrB,OAAO,GAAG,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;AACrC,CAAC;AAgBD,IAAI,qBAAqB,GAAoD,IAAI,CAAC;AAElF;;;GAGG;AACH,SAAS,qBAAqB;IAC5B,IAAI,qBAAqB,KAAK,IAAI,EAAE,CAAC;QACnC,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,UAAU,GAAG,IAAI,CACrB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,EAC9C,6BAA6B,CAC9B,CAAC;QACF,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,iBACO,CAAC;QAC3C,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YACjC,MAAM,CAAC,KAAK,CAAC,2DAA2D,CAAC,CAAC;YAC1E,qBAAqB,GAAG,SAAS,CAAC;YAClC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,qBAAqB,GAAG,MAAM,CAAC;QAC/B,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,+DAA+D,EAAE;YAC5E,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC;SAC/B,CAAC,CAAC;QACH,qBAAqB,GAAG,SAAS,CAAC;QAClC,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,+EAA+E;AAC/E,SAAS,gBAAgB,CAAC,OAA8B;IACtD,MAAM,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5D,IAAI,eAA0C,CAAC;IAE/C,OAAO,CAAC,UAAU,GAAG,KAAK,IAAI,EAAE;QAC9B,IAAI,OAAO,CAAC,WAAW;YAAE,OAAO;QAChC,eAAe,KAAK,CAAC,KAAK,IAAI,EAAE;YAC9B,IAAI,CAAC;gBACH,MAAM,kBAAkB,EAAE,CAAC;YAC7B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;gBAC3B,MAAM,OAAO,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;gBACxC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;oBACxC,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;oBACnC,IAAI,cAAc,EAAE,EAAE,CAAC;wBACrB,MAAM,CAAC,KAAK,CAAC,mCAAmC,EAAE,GAAG,CAAC,CAAC;oBACzD,CAAC;yBAAM,CAAC;wBACN,MAAM,CAAC,IAAI,CAAC,mCAAmC,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;oBACvE,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QACL,IAAI,CAAC;YACH,MAAM,eAAe,CAAC;QACxB,CAAC;gBAAS,CAAC;YACT,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;QAC7B,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,KAA8B;IAE9B,MAAM,iBAAiB,GAAG,qBAAqB,EAAE,CAAC;IAClD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,IAA8B,CAAC;IACnC,IAAI,CAAC;QACH,IAAI,GAAG,kBAAkB,CAAC,EAAE,eAAe,EAAE,kBAAkB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACvE,MAAM,OAAO,GAAG,IAAI,iBAAiB,CAAC,KAAK,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;QACzD,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC1B,IAAI,CAAC,CAAC,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YACnC,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YACtC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC;QAC3B,OAAO,OAAO,CAAC;IACjB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,mCAAmC,EAAE;YAChD,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC;SAC/B,CAAC,CAAC;QACH,IAAI,IAAI,EAAE,CAAC;YACT,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC","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 { error, log } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"cache-storage\");\n\n/** Process-wide dedupe for soft migration warnings. */\nconst loggedMigrationErrors = new Set<string>();\n\n/** Whether `LOG_LEVEL` is currently at or below debug. */\nfunction isDebugEnabled(): boolean {\n  return log.isLevelEnabled(\"debug\");\n}\n\ntype LakebasePool = ReturnType<typeof createLakebasePool>;\ntype CacheStorage = NonNullable<CacheConfig[\"storage\"]>;\n\n/** AppKit's internal persistent storage surface. */\ntype PersistentStorageBase = CacheStorage & {\n  initialize(): Promise<void>;\n  initialized: boolean;\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 the lookup already failed; `undefined` means not attempted yet.\n */\nfunction 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: error.errorMessage(err),\n    });\n    persistentStorageCtor = undefined;\n    return undefined;\n  }\n}\n\n/** Soften `initialize()` so a migration failure is logged once, not thrown. */\nfunction softenInitialize(storage: PersistentStorageBase): 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        await originalInitialize();\n      } catch (err) {\n        storage.initialized = true;\n        const message = error.errorMessage(err);\n        if (!loggedMigrationErrors.has(message)) {\n          loggedMigrationErrors.add(message);\n          if (isDebugEnabled()) {\n            logger.error(\"persistent cache migration failed\", err);\n          } else {\n            logger.warn(\"persistent cache migration failed\", { error: message });\n          }\n        }\n      }\n    })();\n    try {\n      await softInitPromise;\n    } finally {\n      storage.initialized = true;\n    }\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    pool = createLakebasePool({ workspaceClient: getWorkspaceClient({}) });\n    const storage = new PersistentStorage(cache ?? {}, pool);\n    softenInitialize(storage);\n    if (!(await storage.healthCheck())) {\n      await storage.close().catch(() => {});\n      return undefined;\n    }\n    await storage.initialize();\n    return storage;\n  } catch (err) {\n    logger.debug(\"soft persistent cache unavailable\", {\n      error: error.errorMessage(err),\n    });\n    if (pool) {\n      await pool.end().catch(() => {});\n    }\n    return undefined;\n  }\n}\n"]}

package/lib/src/appkit.js

@@ -29,6 +29,7 @@
 import { createApp as appkitCreateApp, getExecutionContext, InitializationError, } from "@databricks/appkit";
 import { async, log } from "@dbx-tools/shared-core";
 import { createInterceptorContext, lifecycleBridge, } from "./interceptor.js";
+import { createSoftPersistentStorage } from "./_cache-storage.js";
 import { applyLakebaseEnv } from "./lakebase-resolver.js";
 import { provisionCacheSchema } from "./provision.js";
 const logger = log.logger("appkit");
@@ -134,6 +135,20 @@ async function autoConfigureLakebase(provision, signal) {
     }
     return resolved;
 }
+/**
+ * Whether `createApp` should inject soft-fail Lakebase cache storage.
+ *
+ * Skips when the caller disabled the cache, already supplied a storage
+ * backend (including in-memory), or Lakebase is not in play.
+ */
+function shouldInjectSoftPersistentCache(config, lakebase) {
+    const cache = config?.cache;
+    if (cache?.enabled === false)
+        return false;
+    if (cache?.storage)
+        return false;
+    return Boolean(lakebase) || usesPlugin(config, LAKEBASE_PLUGIN);
+}
 function redactLakebaseConnection(resolved) {
     return {
         project: resolved.project,
@@ -193,6 +208,17 @@ export async function createApp(config) {
     const appConfig = { ...config };
     delete appConfig.autoConfigure;
     delete appConfig.interceptor;
+    if (shouldInjectSoftPersistentCache(config, lakebase)) {
+        logger.debug("createApp: inject soft persistent cache storage");
+        const storage = await createSoftPersistentStorage(config?.cache);
+        if (storage) {
+            appConfig.cache = { ...config?.cache, storage };
+            logger.debug("createApp: soft persistent cache storage ready");
+        }
+        else {
+            logger.debug("createApp: soft persistent cache storage unavailable");
+        }
+    }
     if (interceptors.length === 0) {
         logger.debug("createApp: no interceptors; delegating to AppKit createApp", {
             plugins: pluginNames(appConfig),
@@ -275,4 +301,4 @@ export async function ensureInitialized() {
     await createApp({ plugins: [], autoConfigure: false });
     logger.debug("ensureInitialized: done");
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appkit.js","sourceRoot":"","sources":["../../src/appkit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit runtime glue: the auto-configuring `createApp` drop-in, plus the\n * per-request execution context helpers and types derived from it.\n *\n * `createApp` runs dbx-tools auto-configuration, then delegates to AppKit's own\n * `createApp` with the same arguments and the same typed plugin-export map.\n * Drop it in as a one-for-one replacement:\n *\n * ```ts\n * import { lakebase, server } from \"@databricks/appkit\";\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * await appkit.createApp({ plugins: [server(), lakebase()] });\n * ```\n *\n * Auto-configuration runs BEFORE delegating so plugins see a fully populated\n * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when\n * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set\n * explicitly on the config object.\n *\n * `getExecutionContext()` is AppKit's own accessor for the OBO-scoped workspace\n * client + request metadata; the wrappers here make it safe to call outside a\n * request scope ({@link tryGetExecutionContext}) and to lazily boot a bare app\n * ({@link ensureInitialized}), and re-export the derived types so add-on\n * packages can type a context / client without re-deriving them inline.\n *\n * @module\n */\n\nimport {\n  createApp as appkitCreateApp,\n  getExecutionContext,\n  InitializationError,\n} from \"@databricks/appkit\";\n// AppKit's root barrel re-exports `PluginData` but not `PluginMap`; the package\n// publishes this subpath for exactly that type.\nimport type { PluginMap } from \"@databricks/appkit/dist/shared/src/plugin\";\nimport { async, log } from \"@dbx-tools/shared-core\";\n\nimport {\n  createInterceptorContext,\n  type Interceptor,\n  type InterceptorRuntime,\n  lifecycleBridge,\n  type ResolvedAppEnv,\n} from \"./interceptor.ts\";\nimport { applyLakebaseEnv, type LakebaseConnection } from \"./lakebase-resolver.ts\";\nimport { provisionCacheSchema } from \"./provision.ts\";\n\nconst logger = log.logger(\"appkit\");\n\ntype AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;\ntype AppKitPlugins = NonNullable<AppKitCreateAppConfig[\"plugins\"]>;\n\n/**\n * What auto-configuration does before AppKit boots.\n *\n * - `\"provision\"`: resolve the Lakebase connection into `process.env`, then\n *   grant the AppKit cache schema to the connecting role.\n * - `\"env\"`: resolve the Lakebase connection into `process.env` only.\n *\n * Omit it to get `\"provision\"` gated on a `lakebase` plugin being registered;\n * set it explicitly to run regardless of the plugin list, or pass `false` to\n * skip auto-configuration entirely.\n *\n * Set it EXPLICITLY on an app that has no `lakebase()` plugin but still wants\n * AppKit's PERSISTENT cache. AppKit picks Lakebase for `CacheManager` only when\n * `createLakebasePool()` can build a pool, and that reads `LAKEBASE_ENDPOINT` /\n * `PGHOST` / `PGDATABASE` straight from `process.env` - so without this step the\n * cache silently falls back to in-memory, and anything it holds (a session\n * signing key, a one-time code) is lost on restart. `\"env\"` is the right mode\n * there: the app SP cannot grant on the cache schema anyway.\n */\nexport type AutoConfigureMode = \"env\" | \"provision\";\n\n/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */\nexport type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<\n  AppKitCreateAppConfig,\n  \"plugins\" | \"onPluginsReady\"\n> & {\n  plugins?: T;\n  onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;\n  /** Auto-configuration to run before AppKit boots. Defaults to `\"provision\"`. */\n  autoConfigure?: AutoConfigureMode | false;\n  /**\n   * One or many {@link Interceptor}s handed an {@link InterceptorContext} once\n   * auto-configuration has computed the env. Each receives the resolved env, an\n   * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -\n   * see `./interceptor`. The tunnel is the primary consumer.\n   */\n  interceptor?: Interceptor | Interceptor[];\n};\n\nconst LAKEBASE_PLUGIN = \"lakebase\";\nconst DEFAULT_AUTO_CONFIGURE: AutoConfigureMode = \"provision\";\n\n/**\n * Upper bound on boot-time auto-configuration. It runs as the service principal\n * before any plugin is constructed, so it sits outside AppKit's interceptor\n * chain and inherits no timeout, retry, or telemetry from it. The budget covers\n * the resolver's own worst case (create a project, then wait for its endpoint)\n * plus the cache-schema grants.\n */\nconst AUTO_CONFIGURE_TIMEOUT_MS = 11 * 60_000;\n\nfunction usesPlugin<T extends AppKitPlugins>(\n  config: CreateAppConfig<T> | undefined,\n  name: string,\n): boolean {\n  return Boolean(config?.plugins?.some((entry) => entry.name === name));\n}\n\n/** Plugin names for boot logs (order preserved). */\nfunction pluginNames(config: CreateAppConfig | undefined): string[] {\n  return (config?.plugins ?? []).map((entry) => entry.name);\n}\n\n/**\n * Run enabled auto-configuration steps without calling AppKit's `createApp`.\n *\n * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set\n * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`\n * cancels the resolution; it is combined with an internal boot timeout either\n * way.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.\n * await appkit.autoConfigure({ autoConfigure: \"env\" });\n */\nexport async function autoConfigure<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n  signal?: AbortSignal,\n): Promise<LakebaseConnection | undefined> {\n  const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;\n  const explicit = config?.autoConfigure !== undefined;\n  const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);\n  const plugins = pluginNames(config);\n  logger.debug(\"autoConfigure: start\", {\n    mode,\n    explicit,\n    lakebasePluginPresent,\n    plugins,\n    timeoutMs: AUTO_CONFIGURE_TIMEOUT_MS,\n    callerSignal: Boolean(signal),\n  });\n\n  if (mode === false || !(explicit || lakebasePluginPresent)) {\n    const skippedReason = mode === false ? \"disabled\" : \"no lakebase plugin\";\n    logger.debug(\"autoConfigure: skip\", { skippedReason, mode, lakebasePluginPresent, plugins });\n    logger.info(\"ready\", {\n      autoConfigure: mode,\n      lakebasePluginPresent,\n      provisioned: false,\n      skippedReason,\n    });\n    return undefined;\n  }\n\n  const controller = new AbortController();\n  async.tieAbortSignal(controller, signal);\n  async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));\n\n  const provision = mode === \"provision\";\n  logger.debug(\"autoConfigure: resolve lakebase\", { provision, mode });\n  const resolved = await autoConfigureLakebase(provision, controller.signal);\n  logger.debug(\"autoConfigure: done\", {\n    mode,\n    lakebasePluginPresent,\n    provisioned: provision,\n    ...redactLakebaseConnection(resolved),\n  });\n  logger.info(\"ready\", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });\n  return resolved;\n}\n\n/**\n * Resolve Lakebase Postgres connection info, write the resolved values to\n * `process.env`, and return the record. Used by {@link autoConfigure}; call\n * {@link applyLakebaseEnv} directly when finer control is needed (a different\n * `autoCreate` policy, or a caller that wants the env without booting AppKit).\n */\nasync function autoConfigureLakebase(\n  provision: boolean,\n  signal: AbortSignal,\n): Promise<LakebaseConnection> {\n  logger.debug(\"autoConfigureLakebase: applyLakebaseEnv\");\n  const { resolved, user } = await applyLakebaseEnv(undefined, signal);\n  logger.debug(\"autoConfigureLakebase: env applied\", {\n    ...redactLakebaseConnection(resolved),\n    user,\n    env: {\n      LAKEBASE_ENDPOINT: process.env.LAKEBASE_ENDPOINT,\n      PGHOST: process.env.PGHOST,\n      PGPORT: process.env.PGPORT,\n      PGDATABASE: process.env.PGDATABASE,\n      PGUSER: process.env.PGUSER,\n      PGSSLMODE: process.env.PGSSLMODE,\n    },\n  });\n  logger.info(\"env updated\", { ...redactLakebaseConnection(resolved), user });\n  if (provision) {\n    logger.debug(\"autoConfigureLakebase: provisionCacheSchema\", { user });\n    await provisionCacheSchema(user, logger);\n    logger.debug(\"autoConfigureLakebase: provisionCacheSchema done\");\n  } else {\n    logger.debug(\"autoConfigureLakebase: skip provision (mode=env)\");\n  }\n  return resolved;\n}\n\nfunction redactLakebaseConnection(resolved: LakebaseConnection): Record<string, unknown> {\n  return {\n    project: resolved.project,\n    branch: resolved.branch,\n    endpoint: resolved.endpoint,\n    database: resolved.database,\n    host: resolved.host,\n    port: resolved.port,\n    sslMode: resolved.sslMode,\n  };\n}\n\n/** Build the {@link ResolvedAppEnv} interceptors read, from the auto-config result. */\nfunction resolvedAppEnv(lakebase: LakebaseConnection | undefined): ResolvedAppEnv {\n  return {\n    ...(lakebase ? { lakebase } : {}),\n    ...(process.env.DATABRICKS_HOST ? { databricksHost: process.env.DATABRICKS_HOST } : {}),\n  };\n}\n\n/** Normalize the `interceptor?: Interceptor | Interceptor[]` option to an array. */\nfunction interceptorList(interceptor: CreateAppConfig[\"interceptor\"]): Interceptor[] {\n  if (!interceptor) return [];\n  return Array.isArray(interceptor) ? interceptor : [interceptor];\n}\n\n/**\n * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed\n * plugin-export map, with {@link autoConfigure} run first.\n *\n * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an\n * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE\n * AppKit boots - so an interceptor can read the resolved connection, register\n * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}\n * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit\n * events; it has no exports, so the returned {@link PluginMap} is unchanged.\n *\n * @example\n * import { lakebase, server } from \"@databricks/appkit\";\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * const app = await appkit.createApp({ plugins: [server(), lakebase()] });\n */\nexport async function createApp<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n): Promise<PluginMap<T>> {\n  const plugins = pluginNames(config);\n  const interceptors = interceptorList(config?.interceptor);\n  logger.debug(\"createApp: start\", {\n    plugins,\n    pluginCount: plugins.length,\n    interceptorCount: interceptors.length,\n    autoConfigure: config?.autoConfigure ?? \"(default)\",\n    hasOnPluginsReady: typeof config?.onPluginsReady === \"function\",\n  });\n\n  logger.debug(\"createApp: autoConfigure\");\n  const lakebase = await autoConfigure(config);\n  logger.debug(\"createApp: autoConfigure returned\", {\n    lakebase: lakebase ? redactLakebaseConnection(lakebase) : undefined,\n  });\n\n  const appConfig = { ...config };\n  delete appConfig.autoConfigure;\n  delete appConfig.interceptor;\n\n  if (interceptors.length === 0) {\n    logger.debug(\"createApp: no interceptors; delegating to AppKit createApp\", {\n      plugins: pluginNames(appConfig),\n    });\n    const result = await appkitCreateApp<T>(appConfig);\n    logger.debug(\"createApp: AppKit createApp returned\", {\n      exportKeys: Object.keys(result ?? {}),\n    });\n    return result;\n  }\n\n  // Build the context from the computed env, run each interceptor (they register\n  // lifecycle handlers + bind processes), then inject the bridge that relays the\n  // REAL AppKit lifecycle into `runtime.emitLifecycle` during its `setup()`.\n  const env = resolvedAppEnv(lakebase);\n  logger.debug(\"createApp: interceptor context\", {\n    hasLakebase: Boolean(env.lakebase),\n    databricksHost: env.databricksHost,\n    interceptorCount: interceptors.length,\n  });\n  const runtime: InterceptorRuntime = createInterceptorContext(env);\n  for (let i = 0; i < interceptors.length; i++) {\n    logger.debug(\"createApp: run interceptor\", { index: i, of: interceptors.length });\n    await interceptors[i]!(runtime.context);\n    logger.debug(\"createApp: interceptor done\", { index: i });\n  }\n  // Append the bridge to the plugins tuple. It is hidden and exports nothing, so\n  // the returned map still matches `PluginMap<T>`; the cast (through `unknown`) is\n  // only because appending widens the tuple type beyond `T`.\n  appConfig.plugins = [...(appConfig.plugins ?? []), lifecycleBridge({ runtime })] as unknown as T;\n  logger.debug(\"createApp: lifecycle bridge injected; delegating to AppKit createApp\", {\n    plugins: pluginNames(appConfig),\n  });\n  const result = await appkitCreateApp<T>(appConfig);\n  logger.debug(\"createApp: AppKit createApp returned\", {\n    exportKeys: Object.keys(result ?? {}),\n  });\n  return result;\n}\n\n/**\n * The AppKit per-request execution context returned by `getExecutionContext()`\n * - the OBO-scoped workspace client plus the surrounding request metadata.\n * Derived from AppKit's own return type so it tracks the installed version, and\n * re-exported here so add-on packages can type a context parameter without each\n * re-deriving the same `ReturnType<typeof getExecutionContext>` inline.\n */\nexport type ExecutionContextLike = ReturnType<typeof getExecutionContext>;\n\n/**\n * The auth-scoped Databricks workspace client carried on an\n * `ExecutionContextLike` (`getExecutionContext().client`). Typed structurally\n * off AppKit so consumers don't take a direct `@databricks/sdk-experimental`\n * dependency - the dep flows in transitively through `@databricks/appkit`.\n */\nexport type WorkspaceClientLike = ExecutionContextLike[\"client\"];\n\n/**\n * The current AppKit execution context, or `undefined` when AppKit isn't\n * initialized (outside a request scope). Swallows AppKit's\n * {@link InitializationError}; any other error propagates.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n * import { WorkspaceClient } from \"@databricks/sdk-experimental\";\n *\n * // OBO-scoped inside a request, service principal from a CLI or script.\n * const client = appkit.tryGetExecutionContext()?.client ?? new WorkspaceClient({});\n */\nexport function tryGetExecutionContext(): ExecutionContextLike | undefined {\n  try {\n    const ctx = getExecutionContext();\n    if (ctx?.client) {\n      return ctx;\n    }\n  } catch (error) {\n    if (!(error instanceof InitializationError)) {\n      throw error;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Initialize a bare AppKit app (no plugins) when none is running yet.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * await appkit.ensureInitialized();\n * const client = appkit.tryGetExecutionContext()?.client;\n */\nexport async function ensureInitialized(): Promise<void> {\n  if (tryGetExecutionContext()) {\n    logger.debug(\"ensureInitialized: already initialized\");\n    return;\n  }\n  logger.debug(\"ensureInitialized: booting bare AppKit app\");\n  await createApp({ plugins: [], autoConfigure: false });\n  logger.debug(\"ensureInitialized: done\");\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appkit.js","sourceRoot":"","sources":["../../src/appkit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit runtime glue: the auto-configuring `createApp` drop-in, plus the\n * per-request execution context helpers and types derived from it.\n *\n * `createApp` runs dbx-tools auto-configuration, then delegates to AppKit's own\n * `createApp` with the same arguments and the same typed plugin-export map.\n * Drop it in as a one-for-one replacement:\n *\n * ```ts\n * import { lakebase, server } from \"@databricks/appkit\";\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * await appkit.createApp({ plugins: [server(), lakebase()] });\n * ```\n *\n * Auto-configuration runs BEFORE delegating so plugins see a fully populated\n * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when\n * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set\n * explicitly on the config object.\n *\n * `getExecutionContext()` is AppKit's own accessor for the OBO-scoped workspace\n * client + request metadata; the wrappers here make it safe to call outside a\n * request scope ({@link tryGetExecutionContext}) and to lazily boot a bare app\n * ({@link ensureInitialized}), and re-export the derived types so add-on\n * packages can type a context / client without re-deriving them inline.\n *\n * @module\n */\n\nimport {\n  createApp as appkitCreateApp,\n  getExecutionContext,\n  InitializationError,\n} from \"@databricks/appkit\";\n// AppKit's root barrel re-exports `PluginData` but not `PluginMap`; the package\n// publishes this subpath for exactly that type.\nimport type { PluginMap } from \"@databricks/appkit/dist/shared/src/plugin\";\nimport { async, log } from \"@dbx-tools/shared-core\";\n\nimport {\n  createInterceptorContext,\n  type Interceptor,\n  type InterceptorRuntime,\n  lifecycleBridge,\n  type ResolvedAppEnv,\n} from \"./interceptor.ts\";\nimport { createSoftPersistentStorage } from \"./_cache-storage.ts\";\nimport { applyLakebaseEnv, type LakebaseConnection } from \"./lakebase-resolver.ts\";\nimport { provisionCacheSchema } from \"./provision.ts\";\n\nconst logger = log.logger(\"appkit\");\n\ntype AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;\ntype AppKitPlugins = NonNullable<AppKitCreateAppConfig[\"plugins\"]>;\n\n/**\n * What auto-configuration does before AppKit boots.\n *\n * - `\"provision\"`: resolve the Lakebase connection into `process.env`, then\n *   grant the AppKit cache schema to the connecting role.\n * - `\"env\"`: resolve the Lakebase connection into `process.env` only.\n *\n * Omit it to get `\"provision\"` gated on a `lakebase` plugin being registered;\n * set it explicitly to run regardless of the plugin list, or pass `false` to\n * skip auto-configuration entirely.\n *\n * Set it EXPLICITLY on an app that has no `lakebase()` plugin but still wants\n * AppKit's PERSISTENT cache. AppKit picks Lakebase for `CacheManager` only when\n * `createLakebasePool()` can build a pool, and that reads `LAKEBASE_ENDPOINT` /\n * `PGHOST` / `PGDATABASE` straight from `process.env` - so without this step the\n * cache silently falls back to in-memory, and anything it holds (a session\n * signing key, a one-time code) is lost on restart. `\"env\"` is the right mode\n * there: the app SP cannot grant on the cache schema anyway.\n */\nexport type AutoConfigureMode = \"env\" | \"provision\";\n\n/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */\nexport type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<\n  AppKitCreateAppConfig,\n  \"plugins\" | \"onPluginsReady\"\n> & {\n  plugins?: T;\n  onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;\n  /** Auto-configuration to run before AppKit boots. Defaults to `\"provision\"`. */\n  autoConfigure?: AutoConfigureMode | false;\n  /**\n   * One or many {@link Interceptor}s handed an {@link InterceptorContext} once\n   * auto-configuration has computed the env. Each receives the resolved env, an\n   * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -\n   * see `./interceptor`. The tunnel is the primary consumer.\n   */\n  interceptor?: Interceptor | Interceptor[];\n};\n\nconst LAKEBASE_PLUGIN = \"lakebase\";\nconst DEFAULT_AUTO_CONFIGURE: AutoConfigureMode = \"provision\";\n\n/**\n * Upper bound on boot-time auto-configuration. It runs as the service principal\n * before any plugin is constructed, so it sits outside AppKit's interceptor\n * chain and inherits no timeout, retry, or telemetry from it. The budget covers\n * the resolver's own worst case (create a project, then wait for its endpoint)\n * plus the cache-schema grants.\n */\nconst AUTO_CONFIGURE_TIMEOUT_MS = 11 * 60_000;\n\nfunction usesPlugin<T extends AppKitPlugins>(\n  config: CreateAppConfig<T> | undefined,\n  name: string,\n): boolean {\n  return Boolean(config?.plugins?.some((entry) => entry.name === name));\n}\n\n/** Plugin names for boot logs (order preserved). */\nfunction pluginNames(config: CreateAppConfig | undefined): string[] {\n  return (config?.plugins ?? []).map((entry) => entry.name);\n}\n\n/**\n * Run enabled auto-configuration steps without calling AppKit's `createApp`.\n *\n * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set\n * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`\n * cancels the resolution; it is combined with an internal boot timeout either\n * way.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.\n * await appkit.autoConfigure({ autoConfigure: \"env\" });\n */\nexport async function autoConfigure<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n  signal?: AbortSignal,\n): Promise<LakebaseConnection | undefined> {\n  const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;\n  const explicit = config?.autoConfigure !== undefined;\n  const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);\n  const plugins = pluginNames(config);\n  logger.debug(\"autoConfigure: start\", {\n    mode,\n    explicit,\n    lakebasePluginPresent,\n    plugins,\n    timeoutMs: AUTO_CONFIGURE_TIMEOUT_MS,\n    callerSignal: Boolean(signal),\n  });\n\n  if (mode === false || !(explicit || lakebasePluginPresent)) {\n    const skippedReason = mode === false ? \"disabled\" : \"no lakebase plugin\";\n    logger.debug(\"autoConfigure: skip\", { skippedReason, mode, lakebasePluginPresent, plugins });\n    logger.info(\"ready\", {\n      autoConfigure: mode,\n      lakebasePluginPresent,\n      provisioned: false,\n      skippedReason,\n    });\n    return undefined;\n  }\n\n  const controller = new AbortController();\n  async.tieAbortSignal(controller, signal);\n  async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));\n\n  const provision = mode === \"provision\";\n  logger.debug(\"autoConfigure: resolve lakebase\", { provision, mode });\n  const resolved = await autoConfigureLakebase(provision, controller.signal);\n  logger.debug(\"autoConfigure: done\", {\n    mode,\n    lakebasePluginPresent,\n    provisioned: provision,\n    ...redactLakebaseConnection(resolved),\n  });\n  logger.info(\"ready\", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });\n  return resolved;\n}\n\n/**\n * Resolve Lakebase Postgres connection info, write the resolved values to\n * `process.env`, and return the record. Used by {@link autoConfigure}; call\n * {@link applyLakebaseEnv} directly when finer control is needed (a different\n * `autoCreate` policy, or a caller that wants the env without booting AppKit).\n */\nasync function autoConfigureLakebase(\n  provision: boolean,\n  signal: AbortSignal,\n): Promise<LakebaseConnection> {\n  logger.debug(\"autoConfigureLakebase: applyLakebaseEnv\");\n  const { resolved, user } = await applyLakebaseEnv(undefined, signal);\n  logger.debug(\"autoConfigureLakebase: env applied\", {\n    ...redactLakebaseConnection(resolved),\n    user,\n    env: {\n      LAKEBASE_ENDPOINT: process.env.LAKEBASE_ENDPOINT,\n      PGHOST: process.env.PGHOST,\n      PGPORT: process.env.PGPORT,\n      PGDATABASE: process.env.PGDATABASE,\n      PGUSER: process.env.PGUSER,\n      PGSSLMODE: process.env.PGSSLMODE,\n    },\n  });\n  logger.info(\"env updated\", { ...redactLakebaseConnection(resolved), user });\n  if (provision) {\n    logger.debug(\"autoConfigureLakebase: provisionCacheSchema\", { user });\n    await provisionCacheSchema(user, logger);\n    logger.debug(\"autoConfigureLakebase: provisionCacheSchema done\");\n  } else {\n    logger.debug(\"autoConfigureLakebase: skip provision (mode=env)\");\n  }\n  return resolved;\n}\n\n/**\n * Whether `createApp` should inject soft-fail Lakebase cache storage.\n *\n * Skips when the caller disabled the cache, already supplied a storage\n * backend (including in-memory), or Lakebase is not in play.\n */\nfunction shouldInjectSoftPersistentCache(\n  config: CreateAppConfig | undefined,\n  lakebase: LakebaseConnection | undefined,\n): boolean {\n  const cache = config?.cache;\n  if (cache?.enabled === false) return false;\n  if (cache?.storage) return false;\n  return Boolean(lakebase) || usesPlugin(config, LAKEBASE_PLUGIN);\n}\n\nfunction redactLakebaseConnection(resolved: LakebaseConnection): Record<string, unknown> {\n  return {\n    project: resolved.project,\n    branch: resolved.branch,\n    endpoint: resolved.endpoint,\n    database: resolved.database,\n    host: resolved.host,\n    port: resolved.port,\n    sslMode: resolved.sslMode,\n  };\n}\n\n/** Build the {@link ResolvedAppEnv} interceptors read, from the auto-config result. */\nfunction resolvedAppEnv(lakebase: LakebaseConnection | undefined): ResolvedAppEnv {\n  return {\n    ...(lakebase ? { lakebase } : {}),\n    ...(process.env.DATABRICKS_HOST ? { databricksHost: process.env.DATABRICKS_HOST } : {}),\n  };\n}\n\n/** Normalize the `interceptor?: Interceptor | Interceptor[]` option to an array. */\nfunction interceptorList(interceptor: CreateAppConfig[\"interceptor\"]): Interceptor[] {\n  if (!interceptor) return [];\n  return Array.isArray(interceptor) ? interceptor : [interceptor];\n}\n\n/**\n * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed\n * plugin-export map, with {@link autoConfigure} run first.\n *\n * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an\n * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE\n * AppKit boots - so an interceptor can read the resolved connection, register\n * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}\n * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit\n * events; it has no exports, so the returned {@link PluginMap} is unchanged.\n *\n * @example\n * import { lakebase, server } from \"@databricks/appkit\";\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * const app = await appkit.createApp({ plugins: [server(), lakebase()] });\n */\nexport async function createApp<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n): Promise<PluginMap<T>> {\n  const plugins = pluginNames(config);\n  const interceptors = interceptorList(config?.interceptor);\n  logger.debug(\"createApp: start\", {\n    plugins,\n    pluginCount: plugins.length,\n    interceptorCount: interceptors.length,\n    autoConfigure: config?.autoConfigure ?? \"(default)\",\n    hasOnPluginsReady: typeof config?.onPluginsReady === \"function\",\n  });\n\n  logger.debug(\"createApp: autoConfigure\");\n  const lakebase = await autoConfigure(config);\n  logger.debug(\"createApp: autoConfigure returned\", {\n    lakebase: lakebase ? redactLakebaseConnection(lakebase) : undefined,\n  });\n\n  const appConfig = { ...config };\n  delete appConfig.autoConfigure;\n  delete appConfig.interceptor;\n\n  if (shouldInjectSoftPersistentCache(config, lakebase)) {\n    logger.debug(\"createApp: inject soft persistent cache storage\");\n    const storage = await createSoftPersistentStorage(config?.cache);\n    if (storage) {\n      appConfig.cache = { ...config?.cache, storage };\n      logger.debug(\"createApp: soft persistent cache storage ready\");\n    } else {\n      logger.debug(\"createApp: soft persistent cache storage unavailable\");\n    }\n  }\n\n  if (interceptors.length === 0) {\n    logger.debug(\"createApp: no interceptors; delegating to AppKit createApp\", {\n      plugins: pluginNames(appConfig),\n    });\n    const result = await appkitCreateApp<T>(appConfig);\n    logger.debug(\"createApp: AppKit createApp returned\", {\n      exportKeys: Object.keys(result ?? {}),\n    });\n    return result;\n  }\n\n  // Build the context from the computed env, run each interceptor (they register\n  // lifecycle handlers + bind processes), then inject the bridge that relays the\n  // REAL AppKit lifecycle into `runtime.emitLifecycle` during its `setup()`.\n  const env = resolvedAppEnv(lakebase);\n  logger.debug(\"createApp: interceptor context\", {\n    hasLakebase: Boolean(env.lakebase),\n    databricksHost: env.databricksHost,\n    interceptorCount: interceptors.length,\n  });\n  const runtime: InterceptorRuntime = createInterceptorContext(env);\n  for (let i = 0; i < interceptors.length; i++) {\n    logger.debug(\"createApp: run interceptor\", { index: i, of: interceptors.length });\n    await interceptors[i]!(runtime.context);\n    logger.debug(\"createApp: interceptor done\", { index: i });\n  }\n  // Append the bridge to the plugins tuple. It is hidden and exports nothing, so\n  // the returned map still matches `PluginMap<T>`; the cast (through `unknown`) is\n  // only because appending widens the tuple type beyond `T`.\n  appConfig.plugins = [...(appConfig.plugins ?? []), lifecycleBridge({ runtime })] as unknown as T;\n  logger.debug(\"createApp: lifecycle bridge injected; delegating to AppKit createApp\", {\n    plugins: pluginNames(appConfig),\n  });\n  const result = await appkitCreateApp<T>(appConfig);\n  logger.debug(\"createApp: AppKit createApp returned\", {\n    exportKeys: Object.keys(result ?? {}),\n  });\n  return result;\n}\n\n/**\n * The AppKit per-request execution context returned by `getExecutionContext()`\n * - the OBO-scoped workspace client plus the surrounding request metadata.\n * Derived from AppKit's own return type so it tracks the installed version, and\n * re-exported here so add-on packages can type a context parameter without each\n * re-deriving the same `ReturnType<typeof getExecutionContext>` inline.\n */\nexport type ExecutionContextLike = ReturnType<typeof getExecutionContext>;\n\n/**\n * The auth-scoped Databricks workspace client carried on an\n * `ExecutionContextLike` (`getExecutionContext().client`). Typed structurally\n * off AppKit so consumers don't take a direct `@databricks/sdk-experimental`\n * dependency - the dep flows in transitively through `@databricks/appkit`.\n */\nexport type WorkspaceClientLike = ExecutionContextLike[\"client\"];\n\n/**\n * The current AppKit execution context, or `undefined` when AppKit isn't\n * initialized (outside a request scope). Swallows AppKit's\n * {@link InitializationError}; any other error propagates.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n * import { WorkspaceClient } from \"@databricks/sdk-experimental\";\n *\n * // OBO-scoped inside a request, service principal from a CLI or script.\n * const client = appkit.tryGetExecutionContext()?.client ?? new WorkspaceClient({});\n */\nexport function tryGetExecutionContext(): ExecutionContextLike | undefined {\n  try {\n    const ctx = getExecutionContext();\n    if (ctx?.client) {\n      return ctx;\n    }\n  } catch (error) {\n    if (!(error instanceof InitializationError)) {\n      throw error;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Initialize a bare AppKit app (no plugins) when none is running yet.\n *\n * @example\n * import { appkit } from \"@dbx-tools/appkit\";\n *\n * await appkit.ensureInitialized();\n * const client = appkit.tryGetExecutionContext()?.client;\n */\nexport async function ensureInitialized(): Promise<void> {\n  if (tryGetExecutionContext()) {\n    logger.debug(\"ensureInitialized: already initialized\");\n    return;\n  }\n  logger.debug(\"ensureInitialized: booting bare AppKit app\");\n  await createApp({ plugins: [], autoConfigure: false });\n  logger.debug(\"ensureInitialized: done\");\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/appkit.ts","../src/config.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/pgaddress.ts","../src/plugin.ts","../src/provision.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_cache-storage.ts","../src/appkit.ts","../src/config.ts","../src/databricks.ts","../src/identity.ts","../src/interceptor.ts","../src/lakebase-resolver.ts","../src/pgaddress.ts","../src/plugin.ts","../src/provision.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -28,8 +28,8 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/core": "0.6.70",
-    "@dbx-tools/shared-core": "0.6.70",
+    "@dbx-tools/core": "0.6.72",
+    "@dbx-tools/shared-core": "0.6.72",
     "yaml": "^2.9.0",
     "zod": "4.3.6"
   },
@@ -47,7 +47,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.70",
+  "version": "0.6.72",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/_cache-storage.ts

@@ -0,0 +1,144 @@
+/**
+ * Soft-fail Lakebase cache storage for AppKit's persistent cache.
+ *
+ * AppKit's `PersistentStorage.initialize()` runs DDL migrations and throws on
+ * any step failure. With `cache.strictPersistence: true` that throw makes
+ * `CacheManager` silently disable the cache. This wraps the same storage,
+ * still runs its migrations, but logs a failed step instead of throwing so a
+ * usable table keeps serving.
+ *
+ * `PersistentStorage` is not on AppKit's public export map. The deep load is
+ * lazy and best-effort: if the installed AppKit layout changes, this returns
+ * `undefined` and `createApp` leaves AppKit on its default cache path.
+ *
+ * @module
+ */
+
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { createLakebasePool, getWorkspaceClient, type CacheConfig } from "@databricks/appkit";
+import { error, log } from "@dbx-tools/shared-core";
+
+const logger = log.logger("cache-storage");
+
+/** Process-wide dedupe for soft migration warnings. */
+const loggedMigrationErrors = new Set<string>();
+
+/** Whether `LOG_LEVEL` is currently at or below debug. */
+function isDebugEnabled(): boolean {
+  return log.isLevelEnabled("debug");
+}
+
+type LakebasePool = ReturnType<typeof createLakebasePool>;
+type CacheStorage = NonNullable<CacheConfig["storage"]>;
+
+/** AppKit's internal persistent storage surface. */
+type PersistentStorageBase = CacheStorage & {
+  initialize(): Promise<void>;
+  initialized: boolean;
+};
+
+type PersistentStorageConstructor = new (
+  config: CacheConfig,
+  pool: LakebasePool,
+) => PersistentStorageBase;
+
+let persistentStorageCtor: PersistentStorageConstructor | undefined | null = null;
+
+/**
+ * Lazily resolve AppKit's internal `PersistentStorage` constructor. `null`
+ * means the lookup already failed; `undefined` means not attempted yet.
+ */
+function loadPersistentStorage(): PersistentStorageConstructor | undefined {
+  if (persistentStorageCtor !== null) {
+    return persistentStorageCtor;
+  }
+  try {
+    const require = createRequire(import.meta.url);
+    const modulePath = join(
+      dirname(require.resolve("@databricks/appkit")),
+      "cache/storage/persistent.js",
+    );
+    const loaded = require(modulePath).PersistentStorage as
+      PersistentStorageConstructor | undefined;
+    if (typeof loaded !== "function") {
+      logger.debug("soft persistent cache skipped (PersistentStorage missing)");
+      persistentStorageCtor = undefined;
+      return undefined;
+    }
+    persistentStorageCtor = loaded;
+    return loaded;
+  } catch (err) {
+    logger.debug("soft persistent cache skipped (PersistentStorage unavailable)", {
+      error: error.errorMessage(err),
+    });
+    persistentStorageCtor = undefined;
+    return undefined;
+  }
+}
+
+/** Soften `initialize()` so a migration failure is logged once, not thrown. */
+function softenInitialize(storage: PersistentStorageBase): void {
+  const originalInitialize = storage.initialize.bind(storage);
+  let softInitPromise: Promise<void> | undefined;
+
+  storage.initialize = async () => {
+    if (storage.initialized) return;
+    softInitPromise ??= (async () => {
+      try {
+        await originalInitialize();
+      } catch (err) {
+        storage.initialized = true;
+        const message = error.errorMessage(err);
+        if (!loggedMigrationErrors.has(message)) {
+          loggedMigrationErrors.add(message);
+          if (isDebugEnabled()) {
+            logger.error("persistent cache migration failed", err);
+          } else {
+            logger.warn("persistent cache migration failed", { error: message });
+          }
+        }
+      }
+    })();
+    try {
+      await softInitPromise;
+    } finally {
+      storage.initialized = true;
+    }
+  };
+}
+
+/**
+ * Build a soft-fail Lakebase cache storage when a pool can be created and
+ * AppKit's PersistentStorage can be loaded. Returns `undefined` otherwise so
+ * AppKit can fall through to its normal cache path.
+ */
+export async function createSoftPersistentStorage(
+  cache: CacheConfig | undefined,
+): Promise<CacheStorage | undefined> {
+  const PersistentStorage = loadPersistentStorage();
+  if (!PersistentStorage) {
+    return undefined;
+  }
+
+  let pool: LakebasePool | undefined;
+  try {
+    pool = createLakebasePool({ workspaceClient: getWorkspaceClient({}) });
+    const storage = new PersistentStorage(cache ?? {}, pool);
+    softenInitialize(storage);
+    if (!(await storage.healthCheck())) {
+      await storage.close().catch(() => {});
+      return undefined;
+    }
+    await storage.initialize();
+    return storage;
+  } catch (err) {
+    logger.debug("soft persistent cache unavailable", {
+      error: error.errorMessage(err),
+    });
+    if (pool) {
+      await pool.end().catch(() => {});
+    }
+    return undefined;
+  }
+}

package/src/appkit.ts

@@ -44,6 +44,7 @@ import {
   lifecycleBridge,
   type ResolvedAppEnv,
 } from "./interceptor.ts";
+import { createSoftPersistentStorage } from "./_cache-storage.ts";
 import { applyLakebaseEnv, type LakebaseConnection } from "./lakebase-resolver.ts";
 import { provisionCacheSchema } from "./provision.ts";
 
@@ -210,6 +211,22 @@ async function autoConfigureLakebase(
   return resolved;
 }
 
+/**
+ * Whether `createApp` should inject soft-fail Lakebase cache storage.
+ *
+ * Skips when the caller disabled the cache, already supplied a storage
+ * backend (including in-memory), or Lakebase is not in play.
+ */
+function shouldInjectSoftPersistentCache(
+  config: CreateAppConfig | undefined,
+  lakebase: LakebaseConnection | undefined,
+): boolean {
+  const cache = config?.cache;
+  if (cache?.enabled === false) return false;
+  if (cache?.storage) return false;
+  return Boolean(lakebase) || usesPlugin(config, LAKEBASE_PLUGIN);
+}
+
 function redactLakebaseConnection(resolved: LakebaseConnection): Record<string, unknown> {
   return {
     project: resolved.project,
@@ -276,6 +293,17 @@ export async function createApp<T extends AppKitPlugins>(
   delete appConfig.autoConfigure;
   delete appConfig.interceptor;
 
+  if (shouldInjectSoftPersistentCache(config, lakebase)) {
+    logger.debug("createApp: inject soft persistent cache storage");
+    const storage = await createSoftPersistentStorage(config?.cache);
+    if (storage) {
+      appConfig.cache = { ...config?.cache, storage };
+      logger.debug("createApp: soft persistent cache storage ready");
+    } else {
+      logger.debug("createApp: soft persistent cache storage unavailable");
+    }
+  }
+
   if (interceptors.length === 0) {
     logger.debug("createApp: no interceptors; delegating to AppKit createApp", {
       plugins: pluginNames(appConfig),