@dbx-tools/appkit 0.3.43 → 0.4.0

package/lib/src/create-app.js

@@ -0,0 +1,120 @@
+/**
+ * `createApp` wrapper: runs dbx-tools auto-configuration, then delegates to
+ * AppKit's own `createApp` with the exact same arguments.
+ *
+ * Drop it in as a one-for-one replacement for `@databricks/appkit`'s
+ * `createApp` - same parameters, same return type, full plugin-export inference
+ * preserved:
+ *
+ * ```ts
+ * import { createApp } from "@dbx-tools/appkit";
+ * import { lakebase, server } from "@databricks/appkit";
+ *
+ * await createApp.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.
+ *
+ * @module
+ */
+import { createApp as appkitCreateApp, getUsernameWithApiLookup } from "@databricks/appkit";
+import { async, log } from "@dbx-tools/shared-core";
+import { applyLakebaseToEnv, resolveLakebaseConnection, } from "./lakebase-resolver.js";
+import { provisionCacheSchema } from "./provision.js";
+const logger = log.logger("create-app");
+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));
+}
+/**
+ * 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 { createApp } from "@dbx-tools/appkit";
+ *
+ * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.
+ * await createApp.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);
+    if (mode === false || !(explicit || lakebasePluginPresent)) {
+        logger.info("ready", {
+            autoConfigure: mode,
+            lakebasePluginPresent,
+            provisioned: false,
+            skippedReason: mode === false ? "disabled" : "no lakebase plugin",
+        });
+        return;
+    }
+    const controller = new AbortController();
+    async.tieAbortSignal(controller, signal);
+    async.tieAbortSignal(controller, AbortSignal.timeout(AUTO_CONFIGURE_TIMEOUT_MS));
+    const provision = mode === "provision";
+    await autoConfigureLakebase(provision, controller.signal);
+    logger.info("ready", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });
+}
+/**
+ * Resolve Lakebase Postgres connection info, write the resolved values to
+ * `process.env`, and return the record. Used by {@link autoConfigure}; call
+ * {@link resolveLakebaseConnection} and {@link applyLakebaseToEnv} directly when
+ * finer control is needed.
+ */
+async function autoConfigureLakebase(provision, signal) {
+    const resolved = await resolveLakebaseConnection(undefined, signal);
+    applyLakebaseToEnv(resolved);
+    const user = await getUsernameWithApiLookup({});
+    if (user)
+        process.env.PGUSER ??= user;
+    logger.info("env updated", { ...redactLakebaseConnection(resolved), user });
+    if (provision) {
+        await provisionCacheSchema(user, logger);
+    }
+    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,
+    };
+}
+/**
+ * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
+ * plugin-export map, with {@link autoConfigure} run first.
+ *
+ * @example
+ * import { createApp } from "@dbx-tools/appkit";
+ * import { lakebase, server } from "@databricks/appkit";
+ *
+ * const app = await createApp.createApp({ plugins: [server(), lakebase()] });
+ */
+export async function createApp(config) {
+    await autoConfigure(config);
+    const appConfig = { ...config };
+    delete appConfig.autoConfigure;
+    return appkitCreateApp(appConfig);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-app.js","sourceRoot":"","sources":["../../src/create-app.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `createApp` wrapper: runs dbx-tools auto-configuration, then delegates to\n * AppKit's own `createApp` with the exact same arguments.\n *\n * Drop it in as a one-for-one replacement for `@databricks/appkit`'s\n * `createApp` - same parameters, same return type, full plugin-export inference\n * preserved:\n *\n * ```ts\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { lakebase, server } from \"@databricks/appkit\";\n *\n * await createApp.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 * @module\n */\n\nimport { createApp as appkitCreateApp, getUsernameWithApiLookup } 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  applyLakebaseToEnv,\n  resolveLakebaseConnection,\n  type LakebaseConnection,\n} from \"./lakebase-resolver\";\nimport { provisionCacheSchema } from \"./provision\";\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 */\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\nconst logger = log.logger(\"create-app\");\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/**\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 { createApp } from \"@dbx-tools/appkit\";\n *\n * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.\n * await createApp.autoConfigure({ autoConfigure: \"env\" });\n */\nexport async function autoConfigure<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n  signal?: AbortSignal,\n): Promise<void> {\n  const mode = config?.autoConfigure ?? DEFAULT_AUTO_CONFIGURE;\n  const explicit = config?.autoConfigure !== undefined;\n  const lakebasePluginPresent = usesPlugin(config, LAKEBASE_PLUGIN);\n  if (mode === false || !(explicit || lakebasePluginPresent)) {\n    logger.info(\"ready\", {\n      autoConfigure: mode,\n      lakebasePluginPresent,\n      provisioned: false,\n      skippedReason: mode === false ? \"disabled\" : \"no lakebase plugin\",\n    });\n    return;\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  await autoConfigureLakebase(provision, controller.signal);\n  logger.info(\"ready\", { autoConfigure: mode, lakebasePluginPresent, provisioned: provision });\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 resolveLakebaseConnection} and {@link applyLakebaseToEnv} directly when\n * finer control is needed.\n */\nasync function autoConfigureLakebase(\n  provision: boolean,\n  signal: AbortSignal,\n): Promise<LakebaseConnection> {\n  const resolved = await resolveLakebaseConnection(undefined, signal);\n  applyLakebaseToEnv(resolved);\n  const user = await getUsernameWithApiLookup({});\n  if (user) process.env.PGUSER ??= user;\n  logger.info(\"env updated\", { ...redactLakebaseConnection(resolved), user });\n  if (provision) {\n    await provisionCacheSchema(user, logger);\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/**\n * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed\n * plugin-export map, with {@link autoConfigure} run first.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n * import { lakebase, server } from \"@databricks/appkit\";\n *\n * const app = await createApp.createApp({ plugins: [server(), lakebase()] });\n */\nexport async function createApp<T extends AppKitPlugins>(\n  config?: CreateAppConfig<T>,\n): Promise<PluginMap<T>> {\n  await autoConfigure(config);\n  const appConfig = { ...config };\n  delete appConfig.autoConfigure;\n  return appkitCreateApp<T>(appConfig);\n}\n"]}

package/lib/src/databricks.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Generic Databricks SDK glue (no AppKit): adapt WHATWG cancellation
+ * (`AbortSignal` / `AbortController`) into the SDK's `Context` /
+ * `CancellationToken` shapes so a single `AbortController` can drive every
+ * in-flight SDK call, plus Databricks runtime-environment detection.
+ *
+ * Server-only: leans on the Databricks SDK `Context`. Lives in node-appkit so
+ * the browser-safe shared-core stays SDK-free.
+ *
+ * @module
+ */
+import { Context } from "@databricks/sdk-experimental";
+/** Highest valid TCP port number. */
+export declare const MAX_TCP_PORT = 65535;
+/**
+ * Detect the Databricks App runtime from environment shape: requires a
+ * non-empty `DATABRICKS_APP_NAME`, a `DATABRICKS_HOST` that parses as an
+ * `http`/`https` URL, and a `DATABRICKS_APP_PORT` that is a valid TCP port.
+ * Reads `process.env` when no `env` is passed.
+ *
+ * @example
+ * import { databricks } from "@dbx-tools/appkit";
+ *
+ * // Skip bundle / app.yaml discovery when the app is already deployed.
+ * const local = !databricks.isAppEnv();
+ */
+export declare function isAppEnv(env?: Record<string, string | undefined>): boolean;
+/** Either an SDK `Context` or a WHATWG `AbortSignal`. */
+export type ContextLike = Context | AbortSignal;
+/**
+ * Wrap a `Context` (returned as-is) or `AbortSignal` (adapted) as an SDK `Context`.
+ *
+ * @example
+ * import { databricks } from "@dbx-tools/appkit";
+ * import { getWorkspaceClient } from "@databricks/appkit";
+ *
+ * await getWorkspaceClient({}).apiClient.request(
+ *   { path: "/api/2.0/serving-endpoints", method: "GET", headers: new Headers(), raw: false },
+ *   databricks.toContext(request.signal),
+ * );
+ */
+export declare function toContext(input: ContextLike): Context;
+/**
+ * Derive an SDK `Context` from `controller.signal`, optionally tying `input`
+ * into the controller so the controller becomes the single cancellation
+ * source for downstream SDK calls:
+ *
+ *   - `AbortSignal`: aborting it propagates into `controller` (and from there
+ *     into every SDK call you pass the returned context to).
+ *   - `Context`: its `cancellationToken` is tied into `controller`, and its
+ *     other fields (`logger`, `opName`, `rootClassName`, `rootFnName`, `opId`)
+ *     are preserved in the returned `Context`. The returned context's
+ *     `cancellationToken` is replaced with one backed by `controller.signal`.
+ *
+ * The tie is one-way (parent -> child): aborting `controller` directly does
+ * NOT cancel `input`. So a request-level cancel (your loop's `try/finally {
+ * controller.abort() }`) won't tear down a caller-supplied AbortSignal it
+ * didn't own.
+ */
+export declare function toContext(controller: AbortController, input?: ContextLike): Context;

package/lib/src/databricks.js

@@ -0,0 +1,107 @@
+/**
+ * Generic Databricks SDK glue (no AppKit): adapt WHATWG cancellation
+ * (`AbortSignal` / `AbortController`) into the SDK's `Context` /
+ * `CancellationToken` shapes so a single `AbortController` can drive every
+ * in-flight SDK call, plus Databricks runtime-environment detection.
+ *
+ * Server-only: leans on the Databricks SDK `Context`. Lives in node-appkit so
+ * the browser-safe shared-core stays SDK-free.
+ *
+ * @module
+ */
+import { Context } from "@databricks/sdk-experimental";
+import { async, log } from "@dbx-tools/shared-core";
+const logger = log.logger("databricks");
+/** Highest valid TCP port number. */
+export const MAX_TCP_PORT = 65_535;
+/**
+ * Detect the Databricks App runtime from environment shape: requires a
+ * non-empty `DATABRICKS_APP_NAME`, a `DATABRICKS_HOST` that parses as an
+ * `http`/`https` URL, and a `DATABRICKS_APP_PORT` that is a valid TCP port.
+ * Reads `process.env` when no `env` is passed.
+ *
+ * @example
+ * import { databricks } from "@dbx-tools/appkit";
+ *
+ * // Skip bundle / app.yaml discovery when the app is already deployed.
+ * const local = !databricks.isAppEnv();
+ */
+export function isAppEnv(env = process.env) {
+    const appName = env.DATABRICKS_APP_NAME?.trim();
+    const host = env.DATABRICKS_HOST?.trim();
+    const port = env.DATABRICKS_APP_PORT?.trim();
+    if (!appName || !host || !port) {
+        return false;
+    }
+    try {
+        const url = new URL(host);
+        if (!["http:", "https:"].includes(url.protocol)) {
+            logger.debug("app env rejected: host is not an http(s) URL");
+            return false;
+        }
+    }
+    catch {
+        logger.debug("app env rejected: host is not a URL");
+        return false;
+    }
+    const portNumber = Number(port);
+    if (!Number.isInteger(portNumber) || portNumber < 1 || portNumber > MAX_TCP_PORT) {
+        logger.debug("app env rejected: DATABRICKS_APP_PORT is not a TCP port");
+        return false;
+    }
+    return true;
+}
+export function toContext(source, input) {
+    if (!(source instanceof AbortController)) {
+        if (source instanceof Context)
+            return source;
+        return new Context({ cancellationToken: signalToCancellationToken(source) });
+    }
+    if (input instanceof AbortSignal) {
+        async.tieAbortSignal(source, input);
+    }
+    else if (input instanceof Context) {
+        const token = input.cancellationToken;
+        if (token)
+            tieCancellationToken(source, token);
+        const merged = input.copy();
+        merged.setItems({ cancellationToken: signalToCancellationToken(source.signal) });
+        return merged;
+    }
+    return new Context({ cancellationToken: signalToCancellationToken(source.signal) });
+}
+/**
+ * Adapt a WHATWG `AbortSignal` to the Databricks SDK's `CancellationToken`
+ * interface. The SDK's `api-client.ts` internally creates an `AbortController`
+ * and wires `cancellationToken.onCancellationRequested` to it, so this adapter
+ * is the one-line bridge from "platform-standard cancellation" to "the SDK
+ * aborts the fetch on your behalf".
+ */
+function signalToCancellationToken(signal) {
+    return {
+        get isCancellationRequested() {
+            return signal.aborted;
+        },
+        onCancellationRequested(cb) {
+            if (signal.aborted) {
+                cb(signal.reason);
+                return;
+            }
+            signal.addEventListener("abort", () => cb(signal.reason), { once: true });
+        },
+    };
+}
+/**
+ * Tie the SDK's `CancellationToken` interface back into an `AbortController`.
+ * Mirrors `async.tieAbortSignal` but for the SDK's cancellation shape, used
+ * when a caller hands us a pre-built `Context` whose token we want to fold into
+ * our own controller.
+ */
+function tieCancellationToken(controller, token) {
+    if (token.isCancellationRequested) {
+        controller.abort();
+        return;
+    }
+    token.onCancellationRequested((reason) => controller.abort(reason));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"databricks.js","sourceRoot":"","sources":["../../src/databricks.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Generic Databricks SDK glue (no AppKit): adapt WHATWG cancellation\n * (`AbortSignal` / `AbortController`) into the SDK's `Context` /\n * `CancellationToken` shapes so a single `AbortController` can drive every\n * in-flight SDK call, plus Databricks runtime-environment detection.\n *\n * Server-only: leans on the Databricks SDK `Context`. Lives in node-appkit so\n * the browser-safe shared-core stays SDK-free.\n *\n * @module\n */\n\nimport type { CancellationToken } from \"@databricks/sdk-experimental\";\nimport { Context } from \"@databricks/sdk-experimental\";\nimport { async, log } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"databricks\");\n\n/** Highest valid TCP port number. */\nexport const MAX_TCP_PORT = 65_535;\n\n/**\n * Detect the Databricks App runtime from environment shape: requires a\n * non-empty `DATABRICKS_APP_NAME`, a `DATABRICKS_HOST` that parses as an\n * `http`/`https` URL, and a `DATABRICKS_APP_PORT` that is a valid TCP port.\n * Reads `process.env` when no `env` is passed.\n *\n * @example\n * import { databricks } from \"@dbx-tools/appkit\";\n *\n * // Skip bundle / app.yaml discovery when the app is already deployed.\n * const local = !databricks.isAppEnv();\n */\nexport function isAppEnv(env: Record<string, string | undefined> = process.env): boolean {\n  const appName = env.DATABRICKS_APP_NAME?.trim();\n  const host = env.DATABRICKS_HOST?.trim();\n  const port = env.DATABRICKS_APP_PORT?.trim();\n\n  if (!appName || !host || !port) {\n    return false;\n  }\n\n  try {\n    const url = new URL(host);\n    if (![\"http:\", \"https:\"].includes(url.protocol)) {\n      logger.debug(\"app env rejected: host is not an http(s) URL\");\n      return false;\n    }\n  } catch {\n    logger.debug(\"app env rejected: host is not a URL\");\n    return false;\n  }\n\n  const portNumber = Number(port);\n  if (!Number.isInteger(portNumber) || portNumber < 1 || portNumber > MAX_TCP_PORT) {\n    logger.debug(\"app env rejected: DATABRICKS_APP_PORT is not a TCP port\");\n    return false;\n  }\n\n  return true;\n}\n\n/** Either an SDK `Context` or a WHATWG `AbortSignal`. */\nexport type ContextLike = Context | AbortSignal;\n\n/**\n * Wrap a `Context` (returned as-is) or `AbortSignal` (adapted) as an SDK `Context`.\n *\n * @example\n * import { databricks } from \"@dbx-tools/appkit\";\n * import { getWorkspaceClient } from \"@databricks/appkit\";\n *\n * await getWorkspaceClient({}).apiClient.request(\n *   { path: \"/api/2.0/serving-endpoints\", method: \"GET\", headers: new Headers(), raw: false },\n *   databricks.toContext(request.signal),\n * );\n */\nexport function toContext(input: ContextLike): Context;\n/**\n * Derive an SDK `Context` from `controller.signal`, optionally tying `input`\n * into the controller so the controller becomes the single cancellation\n * source for downstream SDK calls:\n *\n *   - `AbortSignal`: aborting it propagates into `controller` (and from there\n *     into every SDK call you pass the returned context to).\n *   - `Context`: its `cancellationToken` is tied into `controller`, and its\n *     other fields (`logger`, `opName`, `rootClassName`, `rootFnName`, `opId`)\n *     are preserved in the returned `Context`. The returned context's\n *     `cancellationToken` is replaced with one backed by `controller.signal`.\n *\n * The tie is one-way (parent -> child): aborting `controller` directly does\n * NOT cancel `input`. So a request-level cancel (your loop's `try/finally {\n * controller.abort() }`) won't tear down a caller-supplied AbortSignal it\n * didn't own.\n */\nexport function toContext(controller: AbortController, input?: ContextLike): Context;\nexport function toContext(source: AbortController | ContextLike, input?: ContextLike): Context {\n  if (!(source instanceof AbortController)) {\n    if (source instanceof Context) return source;\n    return new Context({ cancellationToken: signalToCancellationToken(source) });\n  }\n  if (input instanceof AbortSignal) {\n    async.tieAbortSignal(source, input);\n  } else if (input instanceof Context) {\n    const token = input.cancellationToken;\n    if (token) tieCancellationToken(source, token);\n    const merged = input.copy();\n    merged.setItems({ cancellationToken: signalToCancellationToken(source.signal) });\n    return merged;\n  }\n  return new Context({ cancellationToken: signalToCancellationToken(source.signal) });\n}\n\n/**\n * Adapt a WHATWG `AbortSignal` to the Databricks SDK's `CancellationToken`\n * interface. The SDK's `api-client.ts` internally creates an `AbortController`\n * and wires `cancellationToken.onCancellationRequested` to it, so this adapter\n * is the one-line bridge from \"platform-standard cancellation\" to \"the SDK\n * aborts the fetch on your behalf\".\n */\nfunction signalToCancellationToken(signal: AbortSignal): CancellationToken {\n  return {\n    get isCancellationRequested() {\n      return signal.aborted;\n    },\n    onCancellationRequested(cb) {\n      if (signal.aborted) {\n        cb(signal.reason);\n        return;\n      }\n      signal.addEventListener(\"abort\", () => cb(signal.reason), { once: true });\n    },\n  };\n}\n\n/**\n * Tie the SDK's `CancellationToken` interface back into an `AbortController`.\n * Mirrors `async.tieAbortSignal` but for the SDK's cancellation shape, used\n * when a caller hands us a pre-built `Context` whose token we want to fold into\n * our own controller.\n */\nfunction tieCancellationToken(controller: AbortController, token: CancellationToken): void {\n  if (token.isCancellationRequested) {\n    controller.abort();\n    return;\n  }\n  token.onCancellationRequested((reason) => controller.abort(reason));\n}\n"]}

package/lib/src/lakebase-resolver.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Lakebase Postgres connection resolver.
+ *
+ * Reads the same env vars the `lakebase` plugin consumes (`PGHOST`,
+ * `PGDATABASE`, `PGPORT`, `PGSSLMODE`, `LAKEBASE_ENDPOINT`) and fills in
+ * whichever pieces are missing using the Lakebase Autoscaling REST API
+ * under `/api/2.0/postgres/` via the Databricks workspace client.
+ *
+ * `LAKEBASE_ENDPOINT` (and `config.endpoint`) accept anything
+ * {@link parseAddress} understands - canonical resource paths, Postgres
+ * URIs, bare hostnames, or bare project ids. The resolver layers
+ * whatever pieces fall out of parsing under explicit config / env
+ * values, then fills the remaining gaps via the API:
+ *
+ *   1. Reverse-lookup: when a host is known but no resource path is,
+ *      scan projects -> branches -> endpoints for a matching
+ *      `status.hosts.host` and recover the owning project/branch/endpoint.
+ *   2. Pick: when a project is known but child resources aren't, prefer
+ *      the server-side default (`status.default`, `ENDPOINT_TYPE_READ_WRITE`,
+ *      `databricks_postgres`) and fall back to "the only one" when a
+ *      listing returns a single result.
+ *   3. Auto-create: when no projects exist at all, create one whose
+ *      id defaults to `project.name()` slugified (override
+ *      with `config.autoCreate: "my-id"` or disable with
+ *      `config.autoCreate: false`). The create call is idempotent - an
+ *      `ALREADY_EXISTS` response from a concurrent boot is treated as
+ *      success. Then poll the default endpoint until it reports
+ *      `current_state` `READY` or `IDLE`.
+ *
+ * {@link applyLakebaseToEnv} writes the resolved values back to
+ * `process.env` so the downstream `lakebase` plugin picks them up.
+ *
+ * @see https://docs.databricks.com/api/workspace/postgres
+ *
+ * @module
+ */
+import { type LakebaseConnectionInputs, type SslMode } from "./pgaddress.js";
+/**
+ * User-supplied Lakebase inputs (config or env) before any API resolution.
+ * Extends {@link LakebaseConnectionInputs} with resolver-only options.
+ * {@link resolveLakebaseConnection} fills gaps from the Lakebase API when
+ * it has enough context (typically a `project`).
+ */
+export interface LakebaseResolverInputs extends LakebaseConnectionInputs {
+    /**
+     * What to do when no project exists in the workspace at all.
+     * - `undefined` (default): derive a project id from
+     *   {@link project.name} (the host repo's `package.json`
+     *   name) slugified to Lakebase id constraints, then create it.
+     * - `string`: create a new project with this exact id.
+     * - `false`: skip creation and throw with a clear error message.
+     */
+    autoCreate?: string | false;
+}
+/** Fully-resolved Lakebase Postgres connection. */
+export interface LakebaseConnection extends LakebaseConnectionInputs {
+    port: number;
+    sslMode: SslMode;
+}
+/**
+ * Validate a `PGPORT`-shaped value. Returns `undefined` when unset, and throws
+ * a {@link ValidationError} naming `PGPORT` for anything that is not a TCP
+ * port, so a typo cannot reach the connection record as `NaN`.
+ */
+export declare function parsePort(value: string | number | undefined): number | undefined;
+/**
+ * Validate a `PGSSLMODE`-shaped value. Returns `undefined` when unset, and
+ * throws a {@link ValidationError} naming `PGSSLMODE` for an unsupported mode
+ * rather than handing `pg` a value it will reject at connect time.
+ */
+export declare function parseSslMode(value: string | undefined): SslMode | undefined;
+/**
+ * Delay before the next poll attempt: exponential backoff capped at
+ * {@link POLL_MAX_DELAY_MS}, plus jitter so several apps booting against the
+ * same workspace do not retry in lockstep.
+ */
+export declare function nextPollDelay(attempt: number, baseMs: number): number;
+/**
+ * Wait out {@link nextPollDelay} before the next attempt. Rejects with the
+ * signal's reason when the caller cancels mid-wait, so a poll loop unwinds
+ * instead of finishing its backoff first.
+ */
+export declare function pollDelay(attempt: number, baseMs: number, signal?: AbortSignal): Promise<void>;
+/**
+ * Pull resolver inputs from `process.env`, parse the address blob, and
+ * layer explicit config on top with this precedence:
+ *
+ *   `config.<field>` > `config.resolveConfigValue` (`env`, then bundle
+ *   validate JSON) > whatever {@link parseAddress} recovered from the
+ *   `endpoint` / `LAKEBASE_ENDPOINT` blob.
+ *
+ * Set `config.endpoint` (or `LAKEBASE_ENDPOINT`) to any input
+ * {@link parseAddress} understands: canonical resource paths, Postgres
+ * URIs, bare hostnames, or bare project ids.
+ */
+export declare function readLakebaseInputs(config?: LakebaseResolverInputs): Promise<LakebaseResolverInputs>;
+/**
+ * Resolve a fully-populated Postgres connection record from config + env.
+ *
+ * Returns immediately without network traffic when env already supplies
+ * `endpoint`, `host`, and `database`. Otherwise issues REST calls and
+ * may auto-create a project (see module docstring).
+ *
+ * `signal` cancels every REST call and inter-poll sleep.
+ *
+ * @example
+ * import { lakebaseResolver } from "@dbx-tools/appkit";
+ *
+ * const resolved = await lakebaseResolver.resolveLakebaseConnection(
+ *   { autoCreate: false },
+ *   AbortSignal.timeout(60_000),
+ * );
+ * lakebaseResolver.applyLakebaseToEnv(resolved);
+ */
+export declare function resolveLakebaseConnection(config?: LakebaseResolverInputs, signal?: AbortSignal): Promise<LakebaseConnection>;
+/**
+ * Write resolved values back to `process.env` so the `lakebase` plugin
+ * (which reads env directly) picks them up during its own `setup()`.
+ * Existing env values are preserved; only missing keys are filled in,
+ * which keeps explicit overrides authoritative.
+ */
+export declare function applyLakebaseToEnv(resolved: LakebaseConnection): void;