@dbx-tools/appkit 0.6.69 → 0.6.71

package/README.md

@@ -50,16 +50,16 @@ Use this package when the friction is around bootstrapping and reuse:
 
 ## Create An Auto-Configured App
 
-`createApp.createApp` is a drop-in wrapper around AppKit `createApp` with the
+`appkit.createApp` is a drop-in wrapper around AppKit `createApp` with the
 same config and the same typed plugin-export map. It runs
-`createApp.autoConfigure()` first so enabled capabilities can populate
+`appkit.autoConfigure()` first so enabled capabilities can populate
 environment variables before plugin setup runs.
 
 ```ts
 import { lakebase, server } from "@databricks/appkit";
-import { createApp } from "@dbx-tools/appkit";
+import { appkit } from "@dbx-tools/appkit";
 
-await createApp.createApp({
+await appkit.createApp({
   plugins: [server(), lakebase()],
 });
 ```
@@ -76,7 +76,7 @@ Databricks Asset Bundle validation, and deployed Apps.
 
 Boot-time resolution runs as the service principal before any plugin exists, so
 it sits outside AppKit's interceptor chain. It carries its own timeout, and
-`createApp.autoConfigure()` accepts an `AbortSignal` when a caller wants to
+`appkit.autoConfigure()` accepts an `AbortSignal` when a caller wants to
 cancel it earlier.
 
 Use the lower-level functions when you need to inspect or customize the result:
@@ -110,7 +110,7 @@ reason.
 
 ## Configuration
 
-`createApp.createApp()` accepts everything AppKit's `createApp` does, plus:
+`appkit.createApp()` accepts everything AppKit's `createApp` does, plus:
 
 | Option          | Type                            | Default       | Description                                                                                                                                                                                                                                                                                                                 |
 | --------------- | ------------------------------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -324,11 +324,10 @@ is shared. `@dbx-tools/appkit-mastra` exposes this as its `genieIdentity` option
 
 | Module             | Responsibility                                                                                                                                  |
 | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
-| `createApp`        | `createApp()` wrapper and `autoConfigure()`.                                                                                                    |
+| `appkit`           | `createApp()` / `autoConfigure()`, plus execution context lookup and initialization.                                                            |
 | `lakebaseResolver` | Lakebase connection discovery, default picking, optional auto-create, and env application (`applyLakebaseEnv()` for the full set a pool needs). |
 | `pgaddress`        | Permissive Lakebase/Postgres address parser.                                                                                                    |
 | `config`           | Local/env/bundle/app-yaml config lookup.                                                                                                        |
-| `appkit`           | Execution context lookup and initialization.                                                                                                    |
 | `databricks`       | App env detection and SDK context cancellation adapters.                                                                                        |
 | `plugin`           | Typed AppKit plugin data, instance, and required-instance lookup.                                                                               |
 | `provision`        | Cache schema provisioning helpers.                                                                                                              |

package/index.ts

@@ -4,7 +4,6 @@
 
 export * as appkit from "./src/appkit.ts";
 export * as config from "./src/config.ts";
-export * as createApp from "./src/create-app.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -12,9 +11,8 @@ export * as lakebaseResolver from "./src/lakebase-resolver.ts";
 export * as pgaddress from "./src/pgaddress.ts";
 export * as plugin from "./src/plugin.ts";
 export * as provision from "./src/provision.ts";
-export type { ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
+export type { AutoConfigureMode, CreateAppConfig, ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
 export type { BundleValidateJson, ConfigFile, ConfigSource, ConfigMapValue, ResolveConfigValueOptions } from "./src/config.ts";
-export type { AutoConfigureMode, CreateAppConfig } from "./src/create-app.ts";
 export { MAX_TCP_PORT } from "./src/databricks.ts";
 export type { ContextLike } from "./src/databricks.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";

package/lib/index.d.ts

@@ -1,6 +1,5 @@
 export * as appkit from "./src/appkit.ts";
 export * as config from "./src/config.ts";
-export * as createApp from "./src/create-app.ts";
 export * as databricks from "./src/databricks.ts";
 export * as identity from "./src/identity.ts";
 export * as interceptor from "./src/interceptor.ts";
@@ -8,9 +7,8 @@ export * as lakebaseResolver from "./src/lakebase-resolver.ts";
 export * as pgaddress from "./src/pgaddress.ts";
 export * as plugin from "./src/plugin.ts";
 export * as provision from "./src/provision.ts";
-export type { ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
+export type { AutoConfigureMode, CreateAppConfig, ExecutionContextLike, WorkspaceClientLike } from "./src/appkit.ts";
 export type { BundleValidateJson, ConfigFile, ConfigSource, ConfigMapValue, ResolveConfigValueOptions } from "./src/config.ts";
-export type { AutoConfigureMode, CreateAppConfig } from "./src/create-app.ts";
 export { MAX_TCP_PORT } from "./src/databricks.ts";
 export type { ContextLike } from "./src/databricks.ts";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.ts";

package/lib/index.js

@@ -3,7 +3,6 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as appkit from "./src/appkit.js";
 export * as config from "./src/config.js";
-export * as createApp from "./src/create-app.js";
 export * as databricks from "./src/databricks.js";
 export * as identity from "./src/identity.js";
 export * as interceptor from "./src/interceptor.js";
@@ -15,4 +14,4 @@ export { MAX_TCP_PORT } from "./src/databricks.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER, IDENTITY_MODES, DEFAULT_IDENTITY_MODE } from "./src/identity.js";
 export { LifecycleBridgePlugin, lifecycleBridge } from "./src/interceptor.js";
 export { SSL_MODES } from "./src/pgaddress.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

@@ -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,106 @@
+/**
+ * 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");
+/** 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, not thrown. */
+function softenInitialize(storage) {
+    const originalInitialize = storage.initialize.bind(storage);
+    storage.initialize = async () => {
+        try {
+            await originalInitialize();
+        }
+        catch (err) {
+            if (isDebugEnabled()) {
+                logger.error("persistent cache migration failed", err);
+            }
+            else {
+                logger.warn("persistent cache migration failed", {
+                    error: error.errorMessage(err),
+                });
+            }
+            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":"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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 { error, log } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"cache-storage\");\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, not thrown. */\nfunction softenInitialize(storage: PersistentStorageBase): void {\n  const originalInitialize = storage.initialize.bind(storage);\n  storage.initialize = async () => {\n    try {\n      await originalInitialize();\n    } catch (err) {\n      if (isDebugEnabled()) {\n        logger.error(\"persistent cache migration failed\", err);\n      } else {\n        logger.warn(\"persistent cache migration failed\", {\n          error: error.errorMessage(err),\n        });\n      }\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.d.ts

@@ -1,6 +1,22 @@
 /**
- * Generic AppKit runtime glue: the per-request execution context and the types
- * derived from it. Not plugin-specific - that lives in `./plugin`.
+ * AppKit runtime glue: the auto-configuring `createApp` drop-in, plus the
+ * per-request execution context helpers and types derived from it.
+ *
+ * `createApp` runs dbx-tools auto-configuration, then delegates to AppKit's own
+ * `createApp` with the same arguments and the same typed plugin-export map.
+ * Drop it in as a one-for-one replacement:
+ *
+ * ```ts
+ * import { lakebase, server } from "@databricks/appkit";
+ * import { appkit } from "@dbx-tools/appkit";
+ *
+ * await appkit.createApp({ plugins: [server(), lakebase()] });
+ * ```
+ *
+ * Auto-configuration runs BEFORE delegating so plugins see a fully populated
+ * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when
+ * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set
+ * explicitly on the config object.
  *
  * `getExecutionContext()` is AppKit's own accessor for the OBO-scoped workspace
  * client + request metadata; the wrappers here make it safe to call outside a
@@ -10,7 +26,79 @@
  *
  * @module
  */
-import { getExecutionContext } from "@databricks/appkit";
+import { createApp as appkitCreateApp, getExecutionContext } from "@databricks/appkit";
+import type { PluginMap } from "@databricks/appkit/dist/shared/src/plugin";
+import { type Interceptor } from "./interceptor.ts";
+import { type LakebaseConnection } from "./lakebase-resolver.ts";
+type AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;
+type AppKitPlugins = NonNullable<AppKitCreateAppConfig["plugins"]>;
+/**
+ * What auto-configuration does before AppKit boots.
+ *
+ * - `"provision"`: resolve the Lakebase connection into `process.env`, then
+ *   grant the AppKit cache schema to the connecting role.
+ * - `"env"`: resolve the Lakebase connection into `process.env` only.
+ *
+ * Omit it to get `"provision"` gated on a `lakebase` plugin being registered;
+ * set it explicitly to run regardless of the plugin list, or pass `false` to
+ * skip auto-configuration entirely.
+ *
+ * Set it EXPLICITLY on an app that has no `lakebase()` plugin but still wants
+ * AppKit's PERSISTENT cache. AppKit picks Lakebase for `CacheManager` only when
+ * `createLakebasePool()` can build a pool, and that reads `LAKEBASE_ENDPOINT` /
+ * `PGHOST` / `PGDATABASE` straight from `process.env` - so without this step the
+ * cache silently falls back to in-memory, and anything it holds (a session
+ * signing key, a one-time code) is lost on restart. `"env"` is the right mode
+ * there: the app SP cannot grant on the cache schema anyway.
+ */
+export type AutoConfigureMode = "env" | "provision";
+/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */
+export type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<AppKitCreateAppConfig, "plugins" | "onPluginsReady"> & {
+    plugins?: T;
+    onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;
+    /** Auto-configuration to run before AppKit boots. Defaults to `"provision"`. */
+    autoConfigure?: AutoConfigureMode | false;
+    /**
+     * One or many {@link Interceptor}s handed an {@link InterceptorContext} once
+     * auto-configuration has computed the env. Each receives the resolved env, an
+     * AppKit-lifecycle hook, and `bindProcess` for concurrently-style supervision -
+     * see `./interceptor`. The tunnel is the primary consumer.
+     */
+    interceptor?: Interceptor | Interceptor[];
+};
+/**
+ * Run enabled auto-configuration steps without calling AppKit's `createApp`.
+ *
+ * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set
+ * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`
+ * cancels the resolution; it is combined with an internal boot timeout either
+ * way.
+ *
+ * @example
+ * import { appkit } from "@dbx-tools/appkit";
+ *
+ * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.
+ * await appkit.autoConfigure({ autoConfigure: "env" });
+ */
+export declare function autoConfigure<T extends AppKitPlugins>(config?: CreateAppConfig<T>, signal?: AbortSignal): Promise<LakebaseConnection | undefined>;
+/**
+ * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
+ * plugin-export map, with {@link autoConfigure} run first.
+ *
+ * When {@link CreateAppConfig.interceptor}s are given, each is invoked with an
+ * {@link InterceptorContext} AFTER auto-configuration computes the env and BEFORE
+ * AppKit boots - so an interceptor can read the resolved connection, register
+ * lifecycle handlers, and `bindProcess` a child. A hidden {@link lifecycleBridge}
+ * plugin is injected so those `onLifecycle` handlers fire on the genuine AppKit
+ * events; it has no exports, so the returned {@link PluginMap} is unchanged.
+ *
+ * @example
+ * import { lakebase, server } from "@databricks/appkit";
+ * import { appkit } from "@dbx-tools/appkit";
+ *
+ * const app = await appkit.createApp({ plugins: [server(), lakebase()] });
+ */
+export declare function createApp<T extends AppKitPlugins>(config?: CreateAppConfig<T>): Promise<PluginMap<T>>;
 /**
  * The AppKit per-request execution context returned by `getExecutionContext()`
  * - the OBO-scoped workspace client plus the surrounding request metadata.
@@ -49,3 +137,4 @@ export declare function tryGetExecutionContext(): ExecutionContextLike | undefin
  * const client = appkit.tryGetExecutionContext()?.client;
  */
 export declare function ensureInitialized(): Promise<void>;
+export {};