@dbx-tools/appkit 0.6.69 → 0.6.70

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/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 {};

package/lib/src/appkit.js

@@ -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,9 +26,211 @@
  *
  * @module
  */
-import { createApp, getExecutionContext, InitializationError } from "@databricks/appkit";
-import { log } from "@dbx-tools/shared-core";
+import { createApp as appkitCreateApp, getExecutionContext, InitializationError, } from "@databricks/appkit";
+import { async, log } from "@dbx-tools/shared-core";
+import { createInterceptorContext, lifecycleBridge, } from "./interceptor.js";
+import { applyLakebaseEnv } from "./lakebase-resolver.js";
+import { provisionCacheSchema } from "./provision.js";
 const logger = log.logger("appkit");
+const LAKEBASE_PLUGIN = "lakebase";
+const DEFAULT_AUTO_CONFIGURE = "provision";
+/**
+ * Upper bound on boot-time auto-configuration. It runs as the service principal
+ * before any plugin is constructed, so it sits outside AppKit's interceptor
+ * chain and inherits no timeout, retry, or telemetry from it. The budget covers
+ * the resolver's own worst case (create a project, then wait for its endpoint)
+ * plus the cache-schema grants.
+ */
+const AUTO_CONFIGURE_TIMEOUT_MS = 11 * 60_000;
+function usesPlugin(config, name) {
+    return Boolean(config?.plugins?.some((entry) => entry.name === name));
+}
+/** Plugin names for boot logs (order preserved). */
+function pluginNames(config) {
+    return (config?.plugins ?? []).map((entry) => entry.name);
+}
+/**
+ * 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 async function autoConfigure(config, signal) {
+    const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;
+    const explicit = config?.autoConfigure !== undefined;
+    const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);
+    const plugins = pluginNames(config);
+    logger.debug("autoConfigure: start", {
+        mode,
+        explicit,
+        lakebasePluginPresent,
+        plugins,
+        timeoutMs: AUTO_CONFIGURE_TIMEOUT_MS,
+        callerSignal: Boolean(signal),
+    });
+    if (mode === false || !(explicit || lakebasePluginPresent)) {
+        const skippedReason = mode === false ? "disabled" : "no lakebase plugin";
+        logger.debug("autoConfigure: skip", { skippedReason, mode, lakebasePluginPresent, plugins });
+        logger.info("ready", {
+            autoConfigure: mode,
+            lakebasePluginPresent,
+            provisioned: false,
+            skippedReason,
+        });
+        return undefined;
+    }
+    const controller = new AbortController();
+    async.tieAbortSignal(controller, signal);
+    async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));
+    const provision = mode === "provision";
+    logger.debug("autoConfigure: resolve lakebase", { provision, mode });
+    const resolved = await autoConfigureLakebase(provision, controller.signal);
+    logger.debug("autoConfigure: done", {
+        mode,
+        lakebasePluginPresent,
+        provisioned: provision,
+        ...redactLakebaseConnection(resolved),
+    });
+    logger.info("ready", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });
+    return resolved;
+}
+/**
+ * Resolve Lakebase Postgres connection info, write the resolved values to
+ * `process.env`, and return the record. Used by {@link autoConfigure}; call
+ * {@link applyLakebaseEnv} directly when finer control is needed (a different
+ * `autoCreate` policy, or a caller that wants the env without booting AppKit).
+ */
+async function autoConfigureLakebase(provision, signal) {
+    logger.debug("autoConfigureLakebase: applyLakebaseEnv");
+    const { resolved, user } = await applyLakebaseEnv(undefined, signal);
+    logger.debug("autoConfigureLakebase: env applied", {
+        ...redactLakebaseConnection(resolved),
+        user,
+        env: {
+            LAKEBASE_ENDPOINT: process.env.LAKEBASE_ENDPOINT,
+            PGHOST: process.env.PGHOST,
+            PGPORT: process.env.PGPORT,
+            PGDATABASE: process.env.PGDATABASE,
+            PGUSER: process.env.PGUSER,
+            PGSSLMODE: process.env.PGSSLMODE,
+        },
+    });
+    logger.info("env updated", { ...redactLakebaseConnection(resolved), user });
+    if (provision) {
+        logger.debug("autoConfigureLakebase: provisionCacheSchema", { user });
+        await provisionCacheSchema(user, logger);
+        logger.debug("autoConfigureLakebase: provisionCacheSchema done");
+    }
+    else {
+        logger.debug("autoConfigureLakebase: skip provision (mode=env)");
+    }
+    return resolved;
+}
+function redactLakebaseConnection(resolved) {
+    return {
+        project: resolved.project,
+        branch: resolved.branch,
+        endpoint: resolved.endpoint,
+        database: resolved.database,
+        host: resolved.host,
+        port: resolved.port,
+        sslMode: resolved.sslMode,
+    };
+}
+/** Build the {@link ResolvedAppEnv} interceptors read, from the auto-config result. */
+function resolvedAppEnv(lakebase) {
+    return {
+        ...(lakebase ? { lakebase } : {}),
+        ...(process.env.DATABRICKS_HOST ? { databricksHost: process.env.DATABRICKS_HOST } : {}),
+    };
+}
+/** Normalize the `interceptor?: Interceptor | Interceptor[]` option to an array. */
+function interceptorList(interceptor) {
+    if (!interceptor)
+        return [];
+    return Array.isArray(interceptor) ? interceptor : [interceptor];
+}
+/**
+ * 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 async function createApp(config) {
+    const plugins = pluginNames(config);
+    const interceptors = interceptorList(config?.interceptor);
+    logger.debug("createApp: start", {
+        plugins,
+        pluginCount: plugins.length,
+        interceptorCount: interceptors.length,
+        autoConfigure: config?.autoConfigure ?? "(default)",
+        hasOnPluginsReady: typeof config?.onPluginsReady === "function",
+    });
+    logger.debug("createApp: autoConfigure");
+    const lakebase = await autoConfigure(config);
+    logger.debug("createApp: autoConfigure returned", {
+        lakebase: lakebase ? redactLakebaseConnection(lakebase) : undefined,
+    });
+    const appConfig = { ...config };
+    delete appConfig.autoConfigure;
+    delete appConfig.interceptor;
+    if (interceptors.length === 0) {
+        logger.debug("createApp: no interceptors; delegating to AppKit createApp", {
+            plugins: pluginNames(appConfig),
+        });
+        const result = await appkitCreateApp(appConfig);
+        logger.debug("createApp: AppKit createApp returned", {
+            exportKeys: Object.keys(result ?? {}),
+        });
+        return result;
+    }
+    // Build the context from the computed env, run each interceptor (they register
+    // lifecycle handlers + bind processes), then inject the bridge that relays the
+    // REAL AppKit lifecycle into `runtime.emitLifecycle` during its `setup()`.
+    const env = resolvedAppEnv(lakebase);
+    logger.debug("createApp: interceptor context", {
+        hasLakebase: Boolean(env.lakebase),
+        databricksHost: env.databricksHost,
+        interceptorCount: interceptors.length,
+    });
+    const runtime = createInterceptorContext(env);
+    for (let i = 0; i < interceptors.length; i++) {
+        logger.debug("createApp: run interceptor", { index: i, of: interceptors.length });
+        await interceptors[i](runtime.context);
+        logger.debug("createApp: interceptor done", { index: i });
+    }
+    // Append the bridge to the plugins tuple. It is hidden and exports nothing, so
+    // the returned map still matches `PluginMap<T>`; the cast (through `unknown`) is
+    // only because appending widens the tuple type beyond `T`.
+    appConfig.plugins = [...(appConfig.plugins ?? []), lifecycleBridge({ runtime })];
+    logger.debug("createApp: lifecycle bridge injected; delegating to AppKit createApp", {
+        plugins: pluginNames(appConfig),
+    });
+    const result = await appkitCreateApp(appConfig);
+    logger.debug("createApp: AppKit createApp returned", {
+        exportKeys: Object.keys(result ?? {}),
+    });
+    return result;
+}
 /**
  * The current AppKit execution context, or `undefined` when AppKit isn't
  * initialized (outside a request scope). Swallows AppKit's
@@ -49,9 +267,12 @@ export function tryGetExecutionContext() {
  * const client = appkit.tryGetExecutionContext()?.client;
  */
 export async function ensureInitialized() {
-    if (!tryGetExecutionContext()) {
-        logger.debug("initializing a bare AppKit app");
-        await createApp({ plugins: [] });
+    if (tryGetExecutionContext()) {
+        logger.debug("ensureInitialized: already initialized");
+        return;
     }
+    logger.debug("ensureInitialized: booting bare AppKit app");
+    await createApp({ plugins: [], autoConfigure: false });
+    logger.debug("ensureInitialized: done");
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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"]}

package/lib/src/interceptor.d.ts

@@ -5,17 +5,17 @@
  * unit - concurrently-style, where any death takes the whole set down.
  *
  * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to
- * {@link CreateAppConfig.interceptor} ("one or many"). {@link createApp} runs each
- * one AFTER auto-configuration has populated `process.env` but as part of booting
- * the app, so an interceptor sees the resolved connection and can bind processes
- * before or during setup.
+ * `appkit.createApp`'s `interceptor` option ("one or many"). `appkit.createApp`
+ * runs each one AFTER auto-configuration has populated `process.env` but as part
+ * of booting the app, so an interceptor sees the resolved connection and can bind
+ * processes before or during setup.
  *
  * The names here mirror AppKit's own vocabulary rather than inventing parallel
  * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the
  * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /
  * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -
  * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin
- * {@link createApp} injects to capture `this.context` and relay its events.
+ * `appkit.createApp` injects to capture `this.context` and relay its events.
  *
  * @module
  */
@@ -42,7 +42,7 @@ export type LifecycleHandler = () => void | Promise<void>;
  * they read COMPUTED values instead of re-reading `process.env` themselves.
  *
  * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran
- * (see `create-app`'s `autoConfigure`), else `undefined`. `databricksHost` is the
+ * (see `appkit.autoConfigure`), else `undefined`. `databricksHost` is the
  * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the
  * tunnel interceptor both reads and, when it must, sets.
  */
@@ -63,9 +63,9 @@ export type BindableProcess = Pick<ChildProcess, "pid" | "kill" | "killed" | "on
  * The handle passed to each interceptor.
  *
  * @example
- * import { createApp } from "@dbx-tools/appkit";
+ * import { appkit } from "@dbx-tools/appkit";
  *
- * await createApp({
+ * await appkit.createApp({
  *   plugins: [server()],
  *   interceptor: (ctx) => {
  *     const portr = spawnPortr(ctx.env.databricksHost);
@@ -103,7 +103,7 @@ export type Interceptor = (ctx: InterceptorContext) => void | Promise<void>;
 /**
  * The mutable machinery behind an {@link InterceptorContext}. Split out so
  * {@link createInterceptorContext} can hand the public context to interceptors
- * while `create-app` retains the `emitLifecycle` side-channel the bridge drives.
+ * while `appkit.createApp` retains the `emitLifecycle` side-channel the bridge drives.
  */
 export interface InterceptorRuntime {
     /** The context handed to each interceptor. */
@@ -127,7 +127,7 @@ interface LifecycleBridgeConfig extends BasePluginConfig {
     runtime?: InterceptorRuntime;
 }
 /**
- * The internal plugin {@link createApp} injects to make AppKit's lifecycle
+ * The internal plugin `appkit.createApp` injects to make AppKit's lifecycle
  * reachable from interceptor code. On `setup()` it reads its own `this.context`
  * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the
  * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine