@dbx-tools/appkit 0.6.58 → 0.6.60

package/lib/src/interceptor.js

@@ -0,0 +1,141 @@
+/**
+ * The `createApp` INTERCEPTOR context: an in-process handle an app hands to
+ * add-ons (the tunnel, chiefly) so they can read the env auto-configuration
+ * computed, hook AppKit's lifecycle, and supervise sibling child processes as one
+ * 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.
+ *
+ * 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.
+ *
+ * @module
+ */
+import { Plugin, toPlugin } from "@databricks/appkit";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("interceptor");
+/** How long bound children get to exit on `SIGTERM` before the app force-exits. */
+const TEARDOWN_GRACE_MS = 3000;
+/** The signals that trigger teardown when the MAIN process receives them. */
+const TEARDOWN_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+/**
+ * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.
+ *
+ * Teardown is the generalized `superviseExit`: the first child exit or main-process
+ * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,
+ * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it
+ * never itself holds the loop open). The process-signal listeners are installed
+ * lazily on the first `bindProcess` so an app that binds nothing is untouched.
+ */
+export function createInterceptorContext(env) {
+    const handlers = new Map();
+    const children = new Set();
+    let shuttingDown = false;
+    let signalsBound = false;
+    const teardown = (code) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        for (const child of children) {
+            if (!child.killed)
+                child.kill("SIGTERM");
+        }
+        setTimeout(() => process.exit(code), TEARDOWN_GRACE_MS).unref();
+    };
+    const broadcastSignal = (signal) => {
+        for (const child of children) {
+            if (!child.killed)
+                child.kill(signal);
+        }
+        teardown(0);
+    };
+    const bindProcessSignals = () => {
+        if (signalsBound)
+            return;
+        signalsBound = true;
+        for (const signal of TEARDOWN_SIGNALS) {
+            process.on(signal, () => broadcastSignal(signal));
+        }
+    };
+    const bindProcess = (child) => {
+        bindProcessSignals();
+        children.add(child);
+        child.once("exit", (code) => {
+            logger.warn("bound process exited; tearing down the app", { code });
+            teardown(typeof code === "number" ? code : 1);
+        });
+    };
+    const onLifecycle = (event, fn) => {
+        const list = handlers.get(event);
+        if (list)
+            list.push(fn);
+        else
+            handlers.set(event, [fn]);
+    };
+    const emitLifecycle = async (event) => {
+        const list = handlers.get(event);
+        if (!list)
+            return;
+        for (const fn of list) {
+            try {
+                await fn();
+            }
+            catch (error) {
+                // Match AppKit: a failing lifecycle handler is logged, never fatal, and
+                // never blocks its siblings.
+                logger.warn("lifecycle handler failed", { event, error });
+            }
+        }
+    };
+    const context = {
+        env,
+        onLifecycle,
+        broadcastSignal,
+        bindProcess,
+    };
+    return { context, emitLifecycle };
+}
+function hasOnLifecycle(context) {
+    return typeof context?.onLifecycle === "function";
+}
+/**
+ * The internal plugin {@link 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
+ * events. It owns no routes, config surface, or exports.
+ */
+export class LifecycleBridgePlugin extends Plugin {
+    static manifest = {
+        name: "dbxToolsLifecycleBridge",
+        displayName: "Lifecycle Bridge",
+        description: "Relays AppKit lifecycle events to the createApp interceptor context.",
+        stability: "beta",
+        hidden: true,
+        resources: { required: [], optional: [] },
+    };
+    async setup() {
+        const runtime = this.config.runtime;
+        if (!runtime)
+            return;
+        if (!hasOnLifecycle(this.context)) {
+            logger.debug("no PluginContext.onLifecycle to bridge; interceptor lifecycle events inert");
+            return;
+        }
+        const events = ["setup:complete", "server:ready", "shutdown"];
+        for (const event of events) {
+            this.context.onLifecycle(event, () => runtime.emitLifecycle(event));
+        }
+    }
+}
+/** Factory for the injected {@link LifecycleBridgePlugin}. */
+export const lifecycleBridge = toPlugin(LifecycleBridgePlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interceptor.js","sourceRoot":"","sources":["../../src/interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The `createApp` INTERCEPTOR context: an in-process handle an app hands to\n * add-ons (the tunnel, chiefly) so they can read the env auto-configuration\n * computed, hook AppKit's lifecycle, and supervise sibling child processes as one\n * unit - concurrently-style, where any death takes the whole set down.\n *\n * An interceptor is a plain function `(ctx) => void | Promise<void>` passed to\n * {@link CreateAppConfig.interceptor} (\"one or many\"). {@link createApp} runs each\n * one AFTER auto-configuration has populated `process.env` but as part of booting\n * the app, so an interceptor sees the resolved connection and can bind processes\n * before or during setup.\n *\n * The names here mirror AppKit's own vocabulary rather than inventing parallel\n * ones: {@link LifecycleEvent} and {@link InterceptorContext.onLifecycle} are the\n * exact shape of `PluginContext.onLifecycle` (`setup:complete` / `server:ready` /\n * `shutdown`). The bridge that makes that hook reachable from OUTSIDE a plugin -\n * where interceptors run - is {@link lifecycleBridge}, a tiny internal plugin\n * {@link createApp} injects to capture `this.context` and relay its events.\n *\n * @module\n */\n\nimport type { ChildProcess } from \"node:child_process\";\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { LakebaseConnection } from \"./lakebase-resolver.ts\";\n\nconst logger = log.logger(\"interceptor\");\n\n/**\n * AppKit's plugin-lifecycle events, verbatim from `PluginContext`\n * (`node_modules/@databricks/appkit/.../core/plugin-context.d.ts`). Re-declared\n * structurally rather than imported because `PluginContext` is not in the\n * package's `exports` map (the same reason {@link PluginContextLike} exists in\n * `./plugin`).\n *\n * - `setup:complete` - every plugin's `setup()` has resolved.\n * - `server:ready` - the `server()` plugin is listening (never fires for a\n *   serverless app, e.g. the tunnel gate).\n * - `shutdown` - the app is tearing down.\n */\nexport type LifecycleEvent = \"setup:complete\" | \"server:ready\" | \"shutdown\";\n\n/** A lifecycle subscriber. Errors are logged, not propagated (matches AppKit). */\nexport type LifecycleHandler = () => void | Promise<void>;\n\n/**\n * The env auto-configuration resolved before boot, exposed to interceptors so\n * they read COMPUTED values instead of re-reading `process.env` themselves.\n *\n * `lakebase` is the resolved Postgres connection when Lakebase auto-config ran\n * (see `create-app`'s `autoConfigure`), else `undefined`. `databricksHost` is the\n * workspace host as resolved into the environment (`DATABRICKS_HOST`), which the\n * tunnel interceptor both reads and, when it must, sets.\n */\nexport interface ResolvedAppEnv {\n  /** Resolved Lakebase connection, when auto-config resolved one. */\n  readonly lakebase?: LakebaseConnection;\n  /** Resolved Databricks workspace host (`DATABRICKS_HOST`), when known. */\n  readonly databricksHost?: string;\n}\n\n/**\n * A process {@link InterceptorContext.bindProcess} can supervise. A bare\n * `node:child_process` `ChildProcess` (e.g. portr) satisfies this, and so does\n * `@dbx-tools/core`'s `spawn()` result (a `ChildProcessResult` IS a\n * `ChildProcess`) - one code path handles both.\n */\nexport type BindableProcess = Pick<ChildProcess, \"pid\" | \"kill\" | \"killed\" | \"once\">;\n\n/**\n * The handle passed to each interceptor.\n *\n * @example\n * import { createApp } from \"@dbx-tools/appkit\";\n *\n * await createApp({\n *   plugins: [server()],\n *   interceptor: (ctx) => {\n *     const portr = spawnPortr(ctx.env.databricksHost);\n *     ctx.bindProcess(portr);            // app <-> portr live/die together\n *     ctx.onLifecycle(\"shutdown\", () => portr.kill(\"SIGTERM\"));\n *   },\n * });\n */\nexport interface InterceptorContext {\n  /** The env auto-configuration computed before boot. */\n  readonly env: ResolvedAppEnv;\n  /**\n   * Subscribe to an AppKit lifecycle event. Mirrors `PluginContext.onLifecycle`;\n   * the injected {@link lifecycleBridge} relays the real events here once the app\n   * boots. A handler registered for an event that already fired is NOT called\n   * retroactively (same semantics as AppKit).\n   */\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n  /**\n   * Broadcast a termination signal from the main app to every bound process.\n   * Called automatically when this process receives `SIGINT`/`SIGTERM`/`SIGHUP`;\n   * exposed so an interceptor can trigger teardown itself.\n   */\n  broadcastSignal(signal: NodeJS.Signals): void;\n  /**\n   * Supervise a child process alongside the app, concurrently-style: signals pass\n   * through, and if EITHER the child or the app dies the whole set comes down.\n   * Generalizes the tunnel's old hand-rolled `superviseExit`. Safe to call for\n   * several children; teardown is idempotent.\n   */\n  bindProcess(child: BindableProcess): void;\n}\n\n/** A single interceptor, or several. The `createApp` `interceptor?:` option. */\nexport type Interceptor = (ctx: InterceptorContext) => void | Promise<void>;\n\n/** How long bound children get to exit on `SIGTERM` before the app force-exits. */\nconst TEARDOWN_GRACE_MS = 3000;\n\n/** The signals that trigger teardown when the MAIN process receives them. */\nconst TEARDOWN_SIGNALS = [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"] as const;\n\n/**\n * The mutable machinery behind an {@link InterceptorContext}. Split out so\n * {@link createInterceptorContext} can hand the public context to interceptors\n * while `create-app` retains the `emitLifecycle` side-channel the bridge drives.\n */\nexport interface InterceptorRuntime {\n  /** The context handed to each interceptor. */\n  readonly context: InterceptorContext;\n  /** Fire a lifecycle event to every subscriber (called by {@link lifecycleBridge}). */\n  emitLifecycle(event: LifecycleEvent): Promise<void>;\n}\n\n/**\n * Build an {@link InterceptorContext} + its {@link InterceptorRuntime}.\n *\n * Teardown is the generalized `superviseExit`: the first child exit or main-process\n * termination signal flips a one-shot guard, `SIGTERM`s the other bound children,\n * then `process.exit`s after {@link TEARDOWN_GRACE_MS} (an `unref`'d timer, so it\n * never itself holds the loop open). The process-signal listeners are installed\n * lazily on the first `bindProcess` so an app that binds nothing is untouched.\n */\nexport function createInterceptorContext(env: ResolvedAppEnv): InterceptorRuntime {\n  const handlers = new Map<LifecycleEvent, LifecycleHandler[]>();\n  const children = new Set<BindableProcess>();\n  let shuttingDown = false;\n  let signalsBound = false;\n\n  const teardown = (code: number): void => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n    for (const child of children) {\n      if (!child.killed) child.kill(\"SIGTERM\");\n    }\n    setTimeout(() => process.exit(code), TEARDOWN_GRACE_MS).unref();\n  };\n\n  const broadcastSignal = (signal: NodeJS.Signals): void => {\n    for (const child of children) {\n      if (!child.killed) child.kill(signal);\n    }\n    teardown(0);\n  };\n\n  const bindProcessSignals = (): void => {\n    if (signalsBound) return;\n    signalsBound = true;\n    for (const signal of TEARDOWN_SIGNALS) {\n      process.on(signal, () => broadcastSignal(signal));\n    }\n  };\n\n  const bindProcess = (child: BindableProcess): void => {\n    bindProcessSignals();\n    children.add(child);\n    child.once(\"exit\", (code) => {\n      logger.warn(\"bound process exited; tearing down the app\", { code });\n      teardown(typeof code === \"number\" ? code : 1);\n    });\n  };\n\n  const onLifecycle = (event: LifecycleEvent, fn: LifecycleHandler): void => {\n    const list = handlers.get(event);\n    if (list) list.push(fn);\n    else handlers.set(event, [fn]);\n  };\n\n  const emitLifecycle = async (event: LifecycleEvent): Promise<void> => {\n    const list = handlers.get(event);\n    if (!list) return;\n    for (const fn of list) {\n      try {\n        await fn();\n      } catch (error) {\n        // Match AppKit: a failing lifecycle handler is logged, never fatal, and\n        // never blocks its siblings.\n        logger.warn(\"lifecycle handler failed\", { event, error });\n      }\n    }\n  };\n\n  const context: InterceptorContext = {\n    env,\n    onLifecycle,\n    broadcastSignal,\n    bindProcess,\n  };\n\n  return { context, emitLifecycle };\n}\n\n/** Config for {@link LifecycleBridgePlugin}: the sink its captured events flow to. */\ninterface LifecycleBridgeConfig extends BasePluginConfig {\n  /** The runtime whose `emitLifecycle` receives the real AppKit events. */\n  runtime?: InterceptorRuntime;\n}\n\n/**\n * Structural shape of the `PluginContext.onLifecycle` we bridge. Mirrors only the\n * one method we touch (like {@link PluginContextLike} in `./plugin`), since\n * AppKit's `PluginContext` is not importable from the package's `exports`.\n */\ninterface LifecycleContextLike {\n  onLifecycle(event: LifecycleEvent, fn: LifecycleHandler): void;\n}\n\nfunction hasOnLifecycle(context: unknown): context is LifecycleContextLike {\n  return typeof (context as LifecycleContextLike | undefined)?.onLifecycle === \"function\";\n}\n\n/**\n * The internal plugin {@link createApp} injects to make AppKit's lifecycle\n * reachable from interceptor code. On `setup()` it reads its own `this.context`\n * (the real `PluginContext`) and forwards each {@link LifecycleEvent} to the\n * interceptor runtime, so `ctx.onLifecycle(...)` handlers fire on the genuine\n * events. It owns no routes, config surface, or exports.\n */\nexport class LifecycleBridgePlugin extends Plugin<LifecycleBridgeConfig> {\n  static manifest = {\n    name: \"dbxToolsLifecycleBridge\",\n    displayName: \"Lifecycle Bridge\",\n    description: \"Relays AppKit lifecycle events to the createApp interceptor context.\",\n    stability: \"beta\",\n    hidden: true,\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"dbxToolsLifecycleBridge\">;\n\n  override async setup(): Promise<void> {\n    const runtime = this.config.runtime;\n    if (!runtime) return;\n    if (!hasOnLifecycle(this.context)) {\n      logger.debug(\"no PluginContext.onLifecycle to bridge; interceptor lifecycle events inert\");\n      return;\n    }\n    const events: LifecycleEvent[] = [\"setup:complete\", \"server:ready\", \"shutdown\"];\n    for (const event of events) {\n      this.context.onLifecycle(event, () => runtime.emitLifecycle(event));\n    }\n  }\n}\n\n/** Factory for the injected {@link LifecycleBridgePlugin}. */\nexport const lifecycleBridge = toPlugin(LifecycleBridgePlugin);\n"]}

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

@@ -118,5 +118,35 @@ export declare function resolveLakebaseConnection(config?: LakebaseResolverInput
  * (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.
+ *
+ * This does NOT set `PGUSER`, which needs an await - see
+ * {@link applyLakebaseEnv} for the complete set a Postgres pool requires.
  */
 export declare function applyLakebaseToEnv(resolved: LakebaseConnection): void;
+/**
+ * Resolve the connection AND apply every Postgres env var a Lakebase pool needs,
+ * returning the resolved connection plus the username that was applied.
+ *
+ * This is the whole set, which is the point of having one function for it:
+ * `createLakebasePool()` throws unless `LAKEBASE_ENDPOINT`, `PGHOST`,
+ * `PGDATABASE`, **and** a username (`PGUSER`, or `DATABRICKS_CLIENT_ID` for a
+ * service principal) are all present, and a Databricks App `postgres` resource
+ * binding supplies only the first. Anything that wants a working pool - the
+ * `lakebase` plugin, or AppKit's PERSISTENT cache, which quietly degrades to
+ * in-memory when the pool cannot be built - needs all four, so callers should not
+ * pair {@link applyLakebaseToEnv} with their own username lookup.
+ *
+ * `PGUSER` is applied with `??=` like the rest, so an explicitly configured value
+ * stays authoritative. The lookup returns `undefined` rather than throwing when it
+ * cannot determine a user, leaving the pool to resolve its own.
+ *
+ * @example
+ * import { lakebaseResolver } from "@dbx-tools/appkit";
+ *
+ * // Enough for `createLakebasePool()` to build a pool.
+ * const { user } = await lakebaseResolver.applyLakebaseEnv({ autoCreate: false });
+ */
+export declare function applyLakebaseEnv(config?: LakebaseResolverInputs, signal?: AbortSignal): Promise<{
+    resolved: LakebaseConnection;
+    user?: string;
+}>;

package/lib/src/lakebase-resolver.js

@@ -34,7 +34,7 @@
  *
  * @module
  */
-import { ConfigurationError, ExecutionError, getWorkspaceClient, ValidationError, } from "@databricks/appkit";
+import { ConfigurationError, ExecutionError, getUsernameWithApiLookup, getWorkspaceClient, ValidationError, } from "@databricks/appkit";
 import { project } from "@dbx-tools/core";
 import { async, log, object, string } from "@dbx-tools/shared-core";
 import { z } from "zod";
@@ -306,6 +306,9 @@ export async function resolveLakebaseConnection(config, signal) {
  * (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.
+ *
+ * This does NOT set `PGUSER`, which needs an await - see
+ * {@link applyLakebaseEnv} for the complete set a Postgres pool requires.
  */
 export function applyLakebaseToEnv(resolved) {
     if (resolved.endpoint)
@@ -317,6 +320,37 @@ export function applyLakebaseToEnv(resolved) {
     process.env.PGPORT ??= String(resolved.port);
     process.env.PGSSLMODE ??= resolved.sslMode;
 }
+/**
+ * Resolve the connection AND apply every Postgres env var a Lakebase pool needs,
+ * returning the resolved connection plus the username that was applied.
+ *
+ * This is the whole set, which is the point of having one function for it:
+ * `createLakebasePool()` throws unless `LAKEBASE_ENDPOINT`, `PGHOST`,
+ * `PGDATABASE`, **and** a username (`PGUSER`, or `DATABRICKS_CLIENT_ID` for a
+ * service principal) are all present, and a Databricks App `postgres` resource
+ * binding supplies only the first. Anything that wants a working pool - the
+ * `lakebase` plugin, or AppKit's PERSISTENT cache, which quietly degrades to
+ * in-memory when the pool cannot be built - needs all four, so callers should not
+ * pair {@link applyLakebaseToEnv} with their own username lookup.
+ *
+ * `PGUSER` is applied with `??=` like the rest, so an explicitly configured value
+ * stays authoritative. The lookup returns `undefined` rather than throwing when it
+ * cannot determine a user, leaving the pool to resolve its own.
+ *
+ * @example
+ * import { lakebaseResolver } from "@dbx-tools/appkit";
+ *
+ * // Enough for `createLakebasePool()` to build a pool.
+ * const { user } = await lakebaseResolver.applyLakebaseEnv({ autoCreate: false });
+ */
+export async function applyLakebaseEnv(config, signal) {
+    const resolved = await resolveLakebaseConnection(config, signal);
+    applyLakebaseToEnv(resolved);
+    const user = await getUsernameWithApiLookup({});
+    if (user)
+        process.env.PGUSER ??= user;
+    return { resolved, ...(user ? { user } : {}) };
+}
 /**
  * Adapt an {@link AbortSignal} into the api client's cancellation context.
  * AppKit resolves a different copy of `@databricks/sdk-experimental` than this
@@ -676,4 +710,4 @@ async function pickDatabase(ws, project, branch, signal) {
     logger.debug("autopg: resolved database", { database: choice });
     return choice;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lakebase-resolver.js","sourceRoot":"","sources":["../../src/lakebase-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lakebase Postgres connection resolver.\n *\n * Reads the same env vars the `lakebase` plugin consumes (`PGHOST`,\n * `PGDATABASE`, `PGPORT`, `PGSSLMODE`, `LAKEBASE_ENDPOINT`) and fills in\n * whichever pieces are missing using the Lakebase Autoscaling REST API\n * under `/api/2.0/postgres/` via the Databricks workspace client.\n *\n * `LAKEBASE_ENDPOINT` (and `config.endpoint`) accept anything\n * {@link parseAddress} understands - canonical resource paths, Postgres\n * URIs, bare hostnames, or bare project ids. The resolver layers\n * whatever pieces fall out of parsing under explicit config / env\n * values, then fills the remaining gaps via the API:\n *\n *   1. Reverse-lookup: when a host is known but no resource path is,\n *      scan projects -> branches -> endpoints for a matching\n *      `status.hosts.host` and recover the owning project/branch/endpoint.\n *   2. Pick: when a project is known but child resources aren't, prefer\n *      the server-side default (`status.default`, `ENDPOINT_TYPE_READ_WRITE`,\n *      `databricks_postgres`) and fall back to \"the only one\" when a\n *      listing returns a single result.\n *   3. Auto-create: when no projects exist at all, create one whose\n *      id defaults to `project.name()` slugified (override\n *      with `config.autoCreate: \"my-id\"` or disable with\n *      `config.autoCreate: false`). The create call is idempotent - an\n *      `ALREADY_EXISTS` response from a concurrent boot is treated as\n *      success. Then poll the default endpoint until it reports\n *      `current_state` `READY` or `IDLE`.\n *\n * {@link applyLakebaseToEnv} writes the resolved values back to\n * `process.env` so the downstream `lakebase` plugin picks them up.\n *\n * @see https://docs.databricks.com/api/workspace/postgres\n *\n * @module\n */\n\nimport {\n  ConfigurationError,\n  ExecutionError,\n  getWorkspaceClient,\n  ValidationError,\n} from \"@databricks/appkit\";\nimport { project } from \"@dbx-tools/core\";\nimport { async, log, object, string } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\nimport { resolveConfigValue } from \"./config.ts\";\n\nimport { MAX_TCP_PORT, toContext } from \"./databricks.ts\";\nimport {\n  parseAddress,\n  parseResourcePath,\n  SSL_MODES,\n  type LakebaseConnectionInputs,\n  type SslMode,\n} from \"./pgaddress.ts\";\n\nconst logger = log.logger(\"lakebase-resolver\");\nconst API_BASE = \"/api/2.0/postgres\";\nconst DEFAULT_PORT = 5432;\nconst DEFAULT_SSL_MODE: SslMode = \"require\";\nconst DEFAULT_PG_VERSION = 17;\n/** Lakebase project ids: `^[a-z][a-z0-9-]{0,61}[a-z0-9]$`. */\nconst PROJECT_ID_MAX_LEN = 63;\nconst OPERATION_TIMEOUT_MS = 5 * 60_000;\nconst OPERATION_POLL_MS = 2_000;\nconst ENDPOINT_READY_TIMEOUT_MS = 5 * 60_000;\nconst ENDPOINT_READY_POLL_MS = 2_000;\n/** Ceiling on a single backoff step, so a long wait still polls regularly. */\nconst POLL_MAX_DELAY_MS = 15_000;\nconst POLL_BACKOFF_FACTOR = 1.5;\n/** Fraction of each delay applied as +/- jitter, so concurrent boots desynchronize. */\nconst POLL_JITTER_RATIO = 0.2;\n/** Endpoint `status.endpoint_type` for the writable primary. */\nconst READ_WRITE_ENDPOINT_TYPE = \"ENDPOINT_TYPE_READ_WRITE\";\n/** Endpoint `status.current_state` values that will accept a connection. */\nconst CONNECTABLE_ENDPOINT_STATES = new Set([\"READY\", \"IDLE\"]);\n/** Endpoint `status.current_state` before a hostname is meaningful. */\nconst INITIALIZING_ENDPOINT_STATE = \"INITIALIZING\";\n/** Lakebase's own default Postgres database name. */\nconst DEFAULT_DATABASE = \"databricks_postgres\";\n\n/**\n * User-supplied Lakebase inputs (config or env) before any API resolution.\n * Extends {@link LakebaseConnectionInputs} with resolver-only options.\n * {@link resolveLakebaseConnection} fills gaps from the Lakebase API when\n * it has enough context (typically a `project`).\n */\nexport interface LakebaseResolverInputs extends LakebaseConnectionInputs {\n  /**\n   * What to do when no project exists in the workspace at all.\n   * - `undefined` (default): derive a project id from\n   *   {@link project.name} (the host repo's `package.json`\n   *   name) slugified to Lakebase id constraints, then create it.\n   * - `string`: create a new project with this exact id.\n   * - `false`: skip creation and throw with a clear error message.\n   */\n  autoCreate?: string | false;\n}\n\n/** Fully-resolved Lakebase Postgres connection. */\nexport interface LakebaseConnection extends LakebaseConnectionInputs {\n  port: number;\n  sslMode: SslMode;\n}\n\n/**\n * Every field of the Lakebase REST payloads is modelled as optional and\n * validated at the boundary rather than asserted with a cast: the pickers below\n * branch on `status.*`, and a shape change upstream should surface as one loud\n * error here instead of an `undefined` three frames away. Enum-shaped fields\n * stay `string` so a newly added state does not fail the whole response.\n */\nconst projectSchema = z.object({\n  // Full resource path: `projects/{p}`.\n  name: z.string().optional(),\n});\ntype Project = z.infer<typeof projectSchema>;\n\nconst endpointSchema = z.object({\n  // Full resource path: `projects/{p}/branches/{b}/endpoints/{e}`.\n  name: z.string().optional(),\n  uid: z.string().optional(),\n  // Server-side state. All connection info lives here - the spec block\n  // only carries the desired configuration, not the runtime hostnames.\n  status: z\n    .object({\n      endpoint_type: z.string().optional(),\n      // Resolved hostnames; `hosts.host` is the writable primary.\n      hosts: z\n        .object({\n          host: z.string().optional(),\n          read_only_host: z.string().optional(),\n        })\n        .optional(),\n      // Compute state: `INITIALIZING`, `STARTING`, `READY`, `IDLE`, ...\n      current_state: z.string().optional(),\n    })\n    .optional(),\n});\ntype Endpoint = z.infer<typeof endpointSchema>;\n\nconst branchSchema = z.object({\n  // Full resource path: `projects/{p}/branches/{b}`.\n  name: z.string().optional(),\n  status: z\n    .object({\n      // True for the project's default branch (e.g. `production`).\n      default: z.boolean().optional(),\n      current_state: z.string().optional(),\n    })\n    .optional(),\n});\ntype Branch = z.infer<typeof branchSchema>;\n\nconst databaseSchema = z.object({\n  // Full resource path: `projects/{p}/branches/{b}/databases/{d}`.\n  name: z.string().optional(),\n  status: z\n    .object({\n      // Actual Postgres database name (used as `PGDATABASE`). May differ\n      // from the resource id - e.g. resource `databricks-postgres`\n      // surfaces as Postgres database `databricks_postgres`.\n      postgres_database: z.string().optional(),\n    })\n    .optional(),\n});\ntype Database = z.infer<typeof databaseSchema>;\n\n/**\n * Lakebase REST list responses follow the Google AIP convention:\n * `{ <plural-resource>: T[], next_page_token?: string }`. We only read\n * the first page; for auto-config's \"pick something sensible\" semantics the\n * cap is fine.\n */\nconst listResponseSchema = z.object({\n  next_page_token: z.string().optional(),\n  projects: z.array(projectSchema).optional(),\n  branches: z.array(branchSchema).optional(),\n  endpoints: z.array(endpointSchema).optional(),\n  databases: z.array(databaseSchema).optional(),\n});\n\n/**\n * Long-running operation envelope returned by mutating REST calls.\n * `done: true` means terminal; check `error` before reading `response`.\n */\nconst operationSchema = z.object({\n  name: z.string().optional(),\n  done: z.boolean().optional(),\n  error: z.unknown().optional(),\n  response: z.unknown().optional(),\n});\ntype Operation = z.infer<typeof operationSchema>;\n\n/** `PGPORT` must land inside the TCP port range. */\nconst portSchema = z.coerce.number().int().min(1).max(MAX_TCP_PORT);\n\nconst sslModeSchema = z.enum(SSL_MODES);\n\n/**\n * Validate a `PGPORT`-shaped value. Returns `undefined` when unset, and throws\n * a {@link ValidationError} naming `PGPORT` for anything that is not a TCP\n * port, so a typo cannot reach the connection record as `NaN`.\n */\nexport function parsePort(value: string | number | undefined): number | undefined {\n  if (value === undefined || value === \"\") return undefined;\n  const parsed = portSchema.safeParse(value);\n  if (!parsed.success) {\n    throw ValidationError.invalidValue(\"PGPORT\", value, `a TCP port between 1 and ${MAX_TCP_PORT}`);\n  }\n  return parsed.data;\n}\n\n/**\n * Validate a `PGSSLMODE`-shaped value. Returns `undefined` when unset, and\n * throws a {@link ValidationError} naming `PGSSLMODE` for an unsupported mode\n * rather than handing `pg` a value it will reject at connect time.\n */\nexport function parseSslMode(value: string | undefined): SslMode | undefined {\n  if (value === undefined || value === \"\") return undefined;\n  const parsed = sslModeSchema.safeParse(value.trim().toLowerCase());\n  if (!parsed.success) {\n    throw ValidationError.invalidValue(\"PGSSLMODE\", value, SSL_MODES.join(\", \"));\n  }\n  return parsed.data;\n}\n\n/**\n * Delay before the next poll attempt: exponential backoff capped at\n * {@link POLL_MAX_DELAY_MS}, plus jitter so several apps booting against the\n * same workspace do not retry in lockstep.\n */\nexport function nextPollDelay(attempt: number, baseMs: number): number {\n  const backoff = Math.min(baseMs * POLL_BACKOFF_FACTOR ** attempt, POLL_MAX_DELAY_MS);\n  const jitter = backoff * POLL_JITTER_RATIO * (Math.random() * 2 - 1);\n  return Math.max(0, Math.round(backoff + jitter));\n}\n\n/**\n * Wait out {@link nextPollDelay} before the next attempt. Rejects with the\n * signal's reason when the caller cancels mid-wait, so a poll loop unwinds\n * instead of finishing its backoff first.\n */\nexport function pollDelay(attempt: number, baseMs: number, signal?: AbortSignal): Promise<void> {\n  return async.sleep(nextPollDelay(attempt, baseMs), signal);\n}\n\n/**\n * Pull resolver inputs from `process.env`, parse the address blob, and\n * layer explicit config on top with this precedence:\n *\n *   `config.<field>` > `config.resolveConfigValue` (`env`, then bundle\n *   validate JSON) > whatever {@link parseAddress} recovered from the\n *   `endpoint` / `LAKEBASE_ENDPOINT` blob.\n *\n * Set `config.endpoint` (or `LAKEBASE_ENDPOINT`) to any input\n * {@link parseAddress} understands: canonical resource paths, Postgres\n * URIs, bare hostnames, or bare project ids.\n */\nexport async function readLakebaseInputs(\n  config?: LakebaseResolverInputs,\n): Promise<LakebaseResolverInputs> {\n  const rawAddress = config?.endpoint ?? (await resolveConfigValue(\"LAKEBASE_ENDPOINT\"));\n  const parsed = parseAddress(rawAddress);\n  const portEnv = parsePort(await resolveConfigValue(\"PGPORT\"));\n  const sslModeEnv = parseSslMode(await resolveConfigValue(\"PGSSLMODE\"));\n  return {\n    project: config?.project ?? parsed.project,\n    branch: config?.branch ?? parsed.branch,\n    // Only canonical endpoint resource paths survive here; URIs and\n    // bare hostnames set `host` instead and leave `endpoint` undefined\n    // until the REST resolver fills it in.\n    endpoint: parsed.endpoint,\n    database: config?.database ?? (await resolveConfigValue(\"PGDATABASE\")) ?? parsed.database,\n    host: config?.host ?? (await resolveConfigValue(\"PGHOST\")) ?? parsed.host,\n    port: config?.port ?? portEnv ?? parsed.port,\n    sslMode: config?.sslMode ?? sslModeEnv ?? parsed.sslMode,\n    autoCreate: config?.autoCreate,\n  };\n}\n\n/**\n * Resolve a fully-populated Postgres connection record from config + env.\n *\n * Returns immediately without network traffic when env already supplies\n * `endpoint`, `host`, and `database`. Otherwise issues REST calls and\n * may auto-create a project (see module docstring).\n *\n * `signal` cancels every REST call and inter-poll sleep.\n *\n * @example\n * import { lakebaseResolver } from \"@dbx-tools/appkit\";\n *\n * const resolved = await lakebaseResolver.resolveLakebaseConnection(\n *   { autoCreate: false },\n *   AbortSignal.timeout(60_000),\n * );\n * lakebaseResolver.applyLakebaseToEnv(resolved);\n */\nexport async function resolveLakebaseConnection(\n  config?: LakebaseResolverInputs,\n  signal?: AbortSignal,\n): Promise<LakebaseConnection> {\n  const inputs = await readLakebaseInputs(config);\n  let { project, branch, endpoint, database, host } = inputs;\n  const port = inputs.port ?? DEFAULT_PORT;\n  const sslMode = inputs.sslMode ?? DEFAULT_SSL_MODE;\n\n  // Resource paths may carry redundant info; harvest project/branch\n  // from any canonical path that snuck in via PGDATABASE or similar.\n  if (endpoint && (!project || !branch)) {\n    const parsedEndpoint = parseAddress(endpoint);\n    project ??= parsedEndpoint.project;\n    branch ??= parsedEndpoint.branch;\n  }\n  if (database && (!project || !branch)) {\n    const parsedDatabase = parseAddress(database);\n    project ??= parsedDatabase.project;\n    branch ??= parsedDatabase.branch;\n    if (parsedDatabase.databaseResourceId) {\n      database = parsedDatabase.databaseResourceId;\n    }\n  }\n\n  // Already complete: skip every REST call.\n  if (endpoint && host && database) {\n    return { project, branch, endpoint, database, host, port, sslMode };\n  }\n\n  const ws = getWorkspaceClient({});\n\n  // Host known but no resource path: scan the workspace to find which\n  // endpoint owns this host so we can populate LAKEBASE_ENDPOINT.\n  if (!project && host) {\n    const found = await findEndpointByHost(ws, host, signal);\n    if (found) {\n      project = found.project;\n      branch = found.branch;\n      endpoint ??= found.endpoint;\n    }\n  }\n\n  // No project anywhere in config/env/address: list, pick, or create.\n  if (!project) {\n    project = await pickOrCreateProject(ws, config?.autoCreate, signal);\n  }\n\n  if (!branch) {\n    branch = await pickBranch(ws, project, signal);\n  }\n\n  if (!endpoint) {\n    const ep = await pickEndpoint(ws, project, branch, signal);\n    endpoint = ep.name;\n    host ??= ep.host;\n  }\n\n  if (!host && endpoint) {\n    const parsedEndpoint = parseAddress(endpoint);\n    if (parsedEndpoint.project && parsedEndpoint.branch && parsedEndpoint.endpointId) {\n      const ep = await waitEndpointReady(\n        ws,\n        parsedEndpoint.project,\n        parsedEndpoint.branch,\n        parsedEndpoint.endpointId,\n        signal,\n      );\n      host = ep.status?.hosts?.host;\n      logger.debug(\"autopg: resolved host from endpoint\", { host });\n    }\n  }\n\n  if (!database) {\n    database = await pickDatabase(ws, project, branch, signal);\n  }\n\n  return { project, branch, endpoint, database, host, port, sslMode };\n}\n\n/**\n * Write resolved values back to `process.env` so the `lakebase` plugin\n * (which reads env directly) picks them up during its own `setup()`.\n * Existing env values are preserved; only missing keys are filled in,\n * which keeps explicit overrides authoritative.\n */\nexport function applyLakebaseToEnv(resolved: LakebaseConnection): void {\n  if (resolved.endpoint) process.env.LAKEBASE_ENDPOINT ??= resolved.endpoint;\n  if (resolved.host) process.env.PGHOST ??= resolved.host;\n  if (resolved.database) process.env.PGDATABASE ??= resolved.database;\n  process.env.PGPORT ??= String(resolved.port);\n  process.env.PGSSLMODE ??= resolved.sslMode;\n}\n\ntype WorkspaceClient = ReturnType<typeof getWorkspaceClient>;\n\n/** The SDK `Context` accepted by the workspace client's own copy of the SDK. */\ntype ApiRequestContext = NonNullable<Parameters<WorkspaceClient[\"apiClient\"][\"request\"]>[1]>;\n\n/**\n * Adapt an {@link AbortSignal} into the api client's cancellation context.\n * AppKit resolves a different copy of `@databricks/sdk-experimental` than this\n * package does, and `Context` carries a private field, so the two declarations\n * are nominally incompatible even though the api client only reads\n * `cancellationToken` and `logger` off the object.\n */\nfunction requestContext(signal: AbortSignal | undefined): ApiRequestContext | undefined {\n  return signal ? (toContext(signal) as unknown as ApiRequestContext) : undefined;\n}\n\n/**\n * Validate a Lakebase REST body. The full payload is logged rather than thrown\n * so a client never receives upstream detail.\n */\nfunction parseResponse<T>(schema: z.ZodType<T>, path: string, body: unknown): T {\n  const parsed = schema.safeParse(body);\n  if (parsed.success) return parsed.data;\n  logger.error(\"autopg: unexpected Lakebase API response\", {\n    path,\n    issues: parsed.error.issues,\n  });\n  throw new ExecutionError(\"Lakebase API returned an unexpected response\", { context: { path } });\n}\n\n/** GET helper that validates the JSON body and forwards cancellation. */\nasync function getJson<T>(\n  ws: WorkspaceClient,\n  path: string,\n  schema: z.ZodType<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const res = await ws.apiClient.request(\n    {\n      path,\n      method: \"GET\",\n      headers: new Headers({ Accept: \"application/json\" }),\n      raw: false,\n    },\n    requestContext(signal),\n  );\n  return parseResponse(schema, path, res);\n}\n\n/** POST helper for create / mutate calls; validates the JSON body. */\nasync function postJson<T>(\n  ws: WorkspaceClient,\n  path: string,\n  schema: z.ZodType<T>,\n  body: unknown,\n  query?: Record<string, string>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const res = await ws.apiClient.request(\n    {\n      path,\n      method: \"POST\",\n      query,\n      headers: new Headers({\n        Accept: \"application/json\",\n        \"Content-Type\": \"application/json\",\n      }),\n      raw: false,\n      payload: body,\n    },\n    requestContext(signal),\n  );\n  return parseResponse(schema, path, res);\n}\n\nasync function listProjects(ws: WorkspaceClient, signal?: AbortSignal): Promise<Project[]> {\n  const res = await getJson(ws, `${API_BASE}/projects`, listResponseSchema, signal);\n  return res.projects ?? [];\n}\n\nasync function listBranches(\n  ws: WorkspaceClient,\n  project: string,\n  signal?: AbortSignal,\n): Promise<Branch[]> {\n  const res = await getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches`,\n    listResponseSchema,\n    signal,\n  );\n  return res.branches ?? [];\n}\n\nasync function listEndpoints(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<Endpoint[]> {\n  const res = await getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches/${branch}/endpoints`,\n    listResponseSchema,\n    signal,\n  );\n  return res.endpoints ?? [];\n}\n\nasync function listDatabases(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<Database[]> {\n  const res = await getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches/${branch}/databases`,\n    listResponseSchema,\n    signal,\n  );\n  return res.databases ?? [];\n}\n\nasync function getEndpoint(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  endpointId: string,\n  signal?: AbortSignal,\n): Promise<Endpoint> {\n  return getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches/${branch}/endpoints/${endpointId}`,\n    endpointSchema,\n    signal,\n  );\n}\n\n/**\n * Scan the workspace for an endpoint whose `status.hosts.host` matches\n * the provided hostname. Used to recover the owning project/branch/\n * endpoint resource path when the caller only supplied a Postgres URI.\n *\n * O(projects * branches * endpoints) - fine for typical workspaces\n * (single digits per tier); pagination is intentionally not followed\n * since this is a best-effort fallback.\n */\nasync function findEndpointByHost(\n  ws: WorkspaceClient,\n  host: string,\n  signal?: AbortSignal,\n): Promise<{ project: string; branch: string; endpoint: string } | null> {\n  const projects = await listProjects(ws, signal);\n  for (const p of projects) {\n    const projectId = parseResourcePath(p.name).project;\n    if (!projectId) continue;\n    const branches = await listBranches(ws, projectId, signal);\n    for (const b of branches) {\n      const branchId = parseResourcePath(b.name).branch;\n      if (!branchId) continue;\n      const endpoints = await listEndpoints(ws, projectId, branchId, signal);\n      const match = endpoints.find((e) => e.status?.hosts?.host === host);\n      if (match?.name) {\n        logger.debug(\"autopg: matched endpoint by host\", {\n          host,\n          endpoint: match.name,\n        });\n        return {\n          project: projectId,\n          branch: branchId,\n          endpoint: match.name,\n        };\n      }\n    }\n  }\n  logger.debug(\"autopg: no endpoint matched host\", { host });\n  return null;\n}\n\n/**\n * Pick the project to use, or create one when the workspace is empty.\n *\n * Selection order:\n * 1. Exactly one project listed -> use it.\n * 2. Zero projects AND `autoCreate !== false` -> ensure a project with\n *    the resolved id exists, then return its id.\n * 3. Zero projects AND `autoCreate === false` -> throw.\n * 4. Multiple projects -> throw with the candidate list (set\n *    `config.project` or pin a project id in `LAKEBASE_ENDPOINT`).\n */\nasync function pickOrCreateProject(\n  ws: WorkspaceClient,\n  autoCreate: string | false | undefined,\n  signal?: AbortSignal,\n): Promise<string> {\n  const projects = await listProjects(ws, signal);\n  if (projects.length === 1) {\n    const id = parseResourcePath(projects[0]!.name).project;\n    if (id) {\n      logger.debug(\"autopg: using only project\", { project: id });\n      return id;\n    }\n  }\n  if (projects.length === 0) {\n    if (autoCreate === false) {\n      throw ConfigurationError.resourceNotFound(\n        \"Lakebase project\",\n        \"autoCreate is false; create a project or set config.project / LAKEBASE_ENDPOINT.\",\n      );\n    }\n    const id = autoCreate ?? (await defaultProjectId());\n    return ensureProject(ws, id, signal);\n  }\n  const candidates = projects\n    .map((p) => parseResourcePath(p.name).project)\n    .filter((id): id is string => Boolean(id))\n    .join(\", \");\n  throw ConfigurationError.invalidConnection(\n    \"Lakebase\",\n    `Multiple projects found; set config.project or pin a project id in LAKEBASE_ENDPOINT. Candidates: ${candidates}`,\n  );\n}\n\n/**\n * Derive a Lakebase project id from the host repo's `package.json`\n * name (via {@link project.name}) slugified to satisfy the\n * Lakebase id constraint (`^[a-z][a-z0-9-]{0,61}[a-z0-9]$`).\n *\n * Throws when the slug ends up empty or starts with a digit, since the\n * server would reject it anyway - callers should pass an explicit\n * `autoCreate` id in that case.\n */\nasync function defaultProjectId(): Promise<string> {\n  const name = project.name();\n  const slug = string.toSlugWithOptions({ maxLength: PROJECT_ID_MAX_LEN }, name);\n  if (!slug || !/^[a-z]/.test(slug)) {\n    logger.warn(\"autopg: project name does not slugify to a Lakebase project id\", { name });\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      \"Could not derive a project id from the package name; pass autoCreate explicitly.\",\n    );\n  }\n  return slug;\n}\n\n/**\n * Ensure a Lakebase project with `projectId` exists. Creates it and\n * waits for the create operation to complete. An `ALREADY_EXISTS`\n * response is treated as success - someone else (a concurrent boot,\n * a sibling process) won the race and the project we wanted is now\n * sitting there ready for downstream pickers.\n *\n * Project creation typically provisions a default `production` branch\n * alongside; downstream pickers handle the rest.\n */\nasync function ensureProject(\n  ws: WorkspaceClient,\n  projectId: string,\n  signal?: AbortSignal,\n): Promise<string> {\n  logger.warn(\"autopg: no projects found; creating\", { project: projectId });\n  try {\n    const op = await postJson(\n      ws,\n      `${API_BASE}/projects`,\n      operationSchema,\n      { spec: { pg_version: DEFAULT_PG_VERSION } },\n      { project_id: projectId },\n      signal,\n    );\n    await waitForOperation(ws, op, signal);\n    logger.info(\"autopg: created project\", { project: projectId });\n  } catch (err) {\n    if (!isAlreadyExistsError(err)) throw err;\n    logger.info(\"autopg: project already exists (race); proceeding\", {\n      project: projectId,\n    });\n  }\n  return projectId;\n}\n\n/**\n * Recognize the Databricks SDK's `ALREADY_EXISTS` failure modes so a\n * lost race during `ensureProject` becomes a no-op instead of an error.\n *\n * The SDK throws `ApiError { errorCode, statusCode }` for structured\n * server errors and `HttpError { code }` for transport-layer 4xx/5xx.\n * Both surface a human message that often carries \"already exists\" so\n * we use that as a final fallback for forward compatibility.\n */\nfunction isAlreadyExistsError(error: unknown): boolean {\n  if (!error || typeof error !== \"object\") return false;\n  const e = error as {\n    statusCode?: number;\n    code?: number;\n    errorCode?: string;\n    message?: string;\n  };\n  if (e.statusCode === 409 || e.code === 409) return true;\n  if (e.errorCode && /already.?exists/i.test(e.errorCode)) return true;\n  if (e.message && /already.?exists/i.test(e.message)) return true;\n  return false;\n}\n\n/**\n * Reduce a Lakebase operation failure to an error safe to propagate: the\n * operation name plus whatever code the payload carries. The payload itself can\n * echo request context, so it goes to the log instead.\n */\nfunction operationFailed(opName: string, opError: unknown): ExecutionError {\n  logger.error(\"autopg: operation failed\", { operation: opName, error: opError });\n  const code = object.isRecord(opError) ? (opError.code ?? opError.reason) : undefined;\n  return new ExecutionError(`Lakebase operation failed: ${opName}`, {\n    context: {\n      operation: opName,\n      errorCode: typeof code === \"string\" || typeof code === \"number\" ? String(code) : \"unknown\",\n    },\n  });\n}\n\n/**\n * Poll a Lakebase long-running operation until `done: true`. Returns\n * the final operation envelope (which may carry `response` or `error`).\n *\n * Throws when:\n *   - the response carries an `error` field;\n *   - `op.name` is missing (nothing to poll);\n *   - the timeout elapses before `done: true`;\n *   - `signal` aborts mid-wait.\n */\nasync function waitForOperation(\n  ws: WorkspaceClient,\n  op: Operation,\n  signal?: AbortSignal,\n): Promise<Operation> {\n  if (op.done) {\n    if (op.error) {\n      throw operationFailed(op.name ?? \"unknown\", op.error);\n    }\n    return op;\n  }\n  const opName = op.name;\n  if (!opName) {\n    throw ExecutionError.missingData(\"operation name\");\n  }\n  const start = Date.now();\n  for (let attempt = 0; Date.now() - start < OPERATION_TIMEOUT_MS; attempt++) {\n    await pollDelay(attempt, OPERATION_POLL_MS, signal);\n    const current = await getJson(ws, `${API_BASE}/${opName}`, operationSchema, signal);\n    logger.debug(\"autopg: operation status\", { op: opName, done: current.done });\n    if (current.done) {\n      if (current.error) {\n        throw operationFailed(opName, current.error);\n      }\n      return current;\n    }\n  }\n  throw new ExecutionError(`Lakebase operation did not complete: ${opName}`, {\n    context: { operation: opName, timeoutMs: OPERATION_TIMEOUT_MS },\n  });\n}\n\n/**\n * Poll `getEndpoint` until the compute reports a usable\n * `status.current_state`. `READY` and `IDLE` are both acceptable -\n * `IDLE` just means the compute has scaled to zero but a connection\n * will wake it. Returns the final endpoint payload (with `hosts.host`).\n */\nasync function waitEndpointReady(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  endpointId: string,\n  signal?: AbortSignal,\n): Promise<Endpoint> {\n  const start = Date.now();\n  let last: Endpoint | null = null;\n  for (let attempt = 0; Date.now() - start < ENDPOINT_READY_TIMEOUT_MS; attempt++) {\n    last = await getEndpoint(ws, project, branch, endpointId, signal);\n    const state = last.status?.current_state;\n    if (state && CONNECTABLE_ENDPOINT_STATES.has(state)) return last;\n    if (last.status?.hosts?.host && state !== INITIALIZING_ENDPOINT_STATE) {\n      // Compute is in some other state (STARTING, etc.) but hostname is\n      // already published - good enough to connect; lakebase's OAuth\n      // token request will wake it.\n      return last;\n    }\n    logger.debug(\"autopg: waiting for endpoint\", { endpointId, state });\n    await pollDelay(attempt, ENDPOINT_READY_POLL_MS, signal);\n  }\n  throw new ExecutionError(`Lakebase endpoint did not become ready: ${endpointId}`, {\n    context: {\n      project,\n      branch,\n      endpointId,\n      timeoutMs: ENDPOINT_READY_TIMEOUT_MS,\n      lastState: last?.status?.current_state ?? \"unknown\",\n    },\n  });\n}\n\n/**\n * Pick the default branch for a project. Prefers the branch flagged\n * `status.default: true` (server-side default, typically `production`\n * unless the project owner changed it). Falls back to the only branch\n * when there's exactly one. Otherwise throws with the candidate list.\n */\nasync function pickBranch(\n  ws: WorkspaceClient,\n  project: string,\n  signal?: AbortSignal,\n): Promise<string> {\n  const branches = await listBranches(ws, project, signal);\n  if (branches.length === 0) {\n    throw ConfigurationError.resourceNotFound(\n      `Lakebase branch in project '${project}'`,\n      \"The project has no branches; create one or set config.branch.\",\n    );\n  }\n  const flagged = branches.find((b) => b.status?.default === true);\n  const choice =\n    parseResourcePath(flagged?.name).branch ??\n    (branches.length === 1 ? parseResourcePath(branches[0]!.name).branch : undefined);\n  if (!choice) {\n    const candidates = branches\n      .map((b) => parseResourcePath(b.name).branch)\n      .filter((id): id is string => Boolean(id))\n      .join(\", \");\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      `Project '${project}' has multiple branches and none marked default; set config.branch or include the branch in LAKEBASE_ENDPOINT. Candidates: ${candidates}`,\n    );\n  }\n  logger.debug(\"autopg: resolved branch\", { project, branch: choice });\n  return choice;\n}\n\n/**\n * Pick the primary endpoint for a (project, branch). Prefers\n * `status.endpoint_type === ENDPOINT_TYPE_READ_WRITE`; falls back to\n * the only endpoint when there's exactly one. Returns `{ name, host }`\n * so the caller can populate both `LAKEBASE_ENDPOINT` and `PGHOST`\n * from a single call.\n */\nasync function pickEndpoint(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<{ name: string; host?: string }> {\n  const endpoints = await listEndpoints(ws, project, branch, signal);\n  if (endpoints.length === 0) {\n    throw ConfigurationError.resourceNotFound(\n      `Lakebase endpoint in 'projects/${project}/branches/${branch}'`,\n      \"The branch has no endpoints; create one or set LAKEBASE_ENDPOINT.\",\n    );\n  }\n  const primary =\n    endpoints.find((e) => e.status?.endpoint_type === READ_WRITE_ENDPOINT_TYPE) ??\n    (endpoints.length === 1 ? endpoints[0] : undefined);\n  if (!primary?.name) {\n    const names = endpoints.map((e) => e.name).filter(Boolean);\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      `Branch has no primary read-write endpoint; set LAKEBASE_ENDPOINT or config.endpoint. Candidates: ${names.join(\", \")}`,\n    );\n  }\n  const host = primary.status?.hosts?.host;\n  logger.debug(\"autopg: resolved endpoint\", { endpoint: primary.name, host });\n  return { name: primary.name, host };\n}\n\n/**\n * Pick the default postgres database for a (project, branch). The\n * Postgres database NAME (`status.postgres_database`) is what\n * `PGDATABASE` needs - this differs from the resource id, which can\n * use a different separator (e.g. resource `databricks-postgres`\n * surfaces as database `databricks_postgres`). Prefers\n * `databricks_postgres` (the Lakebase default), otherwise the only\n * database.\n */\nasync function pickDatabase(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<string> {\n  const databases = await listDatabases(ws, project, branch, signal);\n  if (databases.length === 0) {\n    throw ConfigurationError.resourceNotFound(\n      `Lakebase database in 'projects/${project}/branches/${branch}'`,\n      \"The branch has no databases; create one or set PGDATABASE.\",\n    );\n  }\n  const names = databases\n    .map((d) => d.status?.postgres_database)\n    .filter((n): n is string => Boolean(n));\n  const choice =\n    names.find((n) => n === DEFAULT_DATABASE) ?? (names.length === 1 ? names[0] : undefined);\n  if (!choice) {\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      `Multiple databases and no '${DEFAULT_DATABASE}'; set PGDATABASE or config.database. Candidates: ${names.join(\", \")}`,\n    );\n  }\n  logger.debug(\"autopg: resolved database\", { database: choice });\n  return choice;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lakebase-resolver.js","sourceRoot":"","sources":["../../src/lakebase-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lakebase Postgres connection resolver.\n *\n * Reads the same env vars the `lakebase` plugin consumes (`PGHOST`,\n * `PGDATABASE`, `PGPORT`, `PGSSLMODE`, `LAKEBASE_ENDPOINT`) and fills in\n * whichever pieces are missing using the Lakebase Autoscaling REST API\n * under `/api/2.0/postgres/` via the Databricks workspace client.\n *\n * `LAKEBASE_ENDPOINT` (and `config.endpoint`) accept anything\n * {@link parseAddress} understands - canonical resource paths, Postgres\n * URIs, bare hostnames, or bare project ids. The resolver layers\n * whatever pieces fall out of parsing under explicit config / env\n * values, then fills the remaining gaps via the API:\n *\n *   1. Reverse-lookup: when a host is known but no resource path is,\n *      scan projects -> branches -> endpoints for a matching\n *      `status.hosts.host` and recover the owning project/branch/endpoint.\n *   2. Pick: when a project is known but child resources aren't, prefer\n *      the server-side default (`status.default`, `ENDPOINT_TYPE_READ_WRITE`,\n *      `databricks_postgres`) and fall back to \"the only one\" when a\n *      listing returns a single result.\n *   3. Auto-create: when no projects exist at all, create one whose\n *      id defaults to `project.name()` slugified (override\n *      with `config.autoCreate: \"my-id\"` or disable with\n *      `config.autoCreate: false`). The create call is idempotent - an\n *      `ALREADY_EXISTS` response from a concurrent boot is treated as\n *      success. Then poll the default endpoint until it reports\n *      `current_state` `READY` or `IDLE`.\n *\n * {@link applyLakebaseToEnv} writes the resolved values back to\n * `process.env` so the downstream `lakebase` plugin picks them up.\n *\n * @see https://docs.databricks.com/api/workspace/postgres\n *\n * @module\n */\n\nimport {\n  ConfigurationError,\n  ExecutionError,\n  getUsernameWithApiLookup,\n  getWorkspaceClient,\n  ValidationError,\n} from \"@databricks/appkit\";\nimport { project } from \"@dbx-tools/core\";\nimport { async, log, object, string } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\nimport { resolveConfigValue } from \"./config.ts\";\n\nimport { MAX_TCP_PORT, toContext } from \"./databricks.ts\";\nimport {\n  parseAddress,\n  parseResourcePath,\n  SSL_MODES,\n  type LakebaseConnectionInputs,\n  type SslMode,\n} from \"./pgaddress.ts\";\n\nconst logger = log.logger(\"lakebase-resolver\");\nconst API_BASE = \"/api/2.0/postgres\";\nconst DEFAULT_PORT = 5432;\nconst DEFAULT_SSL_MODE: SslMode = \"require\";\nconst DEFAULT_PG_VERSION = 17;\n/** Lakebase project ids: `^[a-z][a-z0-9-]{0,61}[a-z0-9]$`. */\nconst PROJECT_ID_MAX_LEN = 63;\nconst OPERATION_TIMEOUT_MS = 5 * 60_000;\nconst OPERATION_POLL_MS = 2_000;\nconst ENDPOINT_READY_TIMEOUT_MS = 5 * 60_000;\nconst ENDPOINT_READY_POLL_MS = 2_000;\n/** Ceiling on a single backoff step, so a long wait still polls regularly. */\nconst POLL_MAX_DELAY_MS = 15_000;\nconst POLL_BACKOFF_FACTOR = 1.5;\n/** Fraction of each delay applied as +/- jitter, so concurrent boots desynchronize. */\nconst POLL_JITTER_RATIO = 0.2;\n/** Endpoint `status.endpoint_type` for the writable primary. */\nconst READ_WRITE_ENDPOINT_TYPE = \"ENDPOINT_TYPE_READ_WRITE\";\n/** Endpoint `status.current_state` values that will accept a connection. */\nconst CONNECTABLE_ENDPOINT_STATES = new Set([\"READY\", \"IDLE\"]);\n/** Endpoint `status.current_state` before a hostname is meaningful. */\nconst INITIALIZING_ENDPOINT_STATE = \"INITIALIZING\";\n/** Lakebase's own default Postgres database name. */\nconst DEFAULT_DATABASE = \"databricks_postgres\";\n\n/**\n * User-supplied Lakebase inputs (config or env) before any API resolution.\n * Extends {@link LakebaseConnectionInputs} with resolver-only options.\n * {@link resolveLakebaseConnection} fills gaps from the Lakebase API when\n * it has enough context (typically a `project`).\n */\nexport interface LakebaseResolverInputs extends LakebaseConnectionInputs {\n  /**\n   * What to do when no project exists in the workspace at all.\n   * - `undefined` (default): derive a project id from\n   *   {@link project.name} (the host repo's `package.json`\n   *   name) slugified to Lakebase id constraints, then create it.\n   * - `string`: create a new project with this exact id.\n   * - `false`: skip creation and throw with a clear error message.\n   */\n  autoCreate?: string | false;\n}\n\n/** Fully-resolved Lakebase Postgres connection. */\nexport interface LakebaseConnection extends LakebaseConnectionInputs {\n  port: number;\n  sslMode: SslMode;\n}\n\n/**\n * Every field of the Lakebase REST payloads is modelled as optional and\n * validated at the boundary rather than asserted with a cast: the pickers below\n * branch on `status.*`, and a shape change upstream should surface as one loud\n * error here instead of an `undefined` three frames away. Enum-shaped fields\n * stay `string` so a newly added state does not fail the whole response.\n */\nconst projectSchema = z.object({\n  // Full resource path: `projects/{p}`.\n  name: z.string().optional(),\n});\ntype Project = z.infer<typeof projectSchema>;\n\nconst endpointSchema = z.object({\n  // Full resource path: `projects/{p}/branches/{b}/endpoints/{e}`.\n  name: z.string().optional(),\n  uid: z.string().optional(),\n  // Server-side state. All connection info lives here - the spec block\n  // only carries the desired configuration, not the runtime hostnames.\n  status: z\n    .object({\n      endpoint_type: z.string().optional(),\n      // Resolved hostnames; `hosts.host` is the writable primary.\n      hosts: z\n        .object({\n          host: z.string().optional(),\n          read_only_host: z.string().optional(),\n        })\n        .optional(),\n      // Compute state: `INITIALIZING`, `STARTING`, `READY`, `IDLE`, ...\n      current_state: z.string().optional(),\n    })\n    .optional(),\n});\ntype Endpoint = z.infer<typeof endpointSchema>;\n\nconst branchSchema = z.object({\n  // Full resource path: `projects/{p}/branches/{b}`.\n  name: z.string().optional(),\n  status: z\n    .object({\n      // True for the project's default branch (e.g. `production`).\n      default: z.boolean().optional(),\n      current_state: z.string().optional(),\n    })\n    .optional(),\n});\ntype Branch = z.infer<typeof branchSchema>;\n\nconst databaseSchema = z.object({\n  // Full resource path: `projects/{p}/branches/{b}/databases/{d}`.\n  name: z.string().optional(),\n  status: z\n    .object({\n      // Actual Postgres database name (used as `PGDATABASE`). May differ\n      // from the resource id - e.g. resource `databricks-postgres`\n      // surfaces as Postgres database `databricks_postgres`.\n      postgres_database: z.string().optional(),\n    })\n    .optional(),\n});\ntype Database = z.infer<typeof databaseSchema>;\n\n/**\n * Lakebase REST list responses follow the Google AIP convention:\n * `{ <plural-resource>: T[], next_page_token?: string }`. We only read\n * the first page; for auto-config's \"pick something sensible\" semantics the\n * cap is fine.\n */\nconst listResponseSchema = z.object({\n  next_page_token: z.string().optional(),\n  projects: z.array(projectSchema).optional(),\n  branches: z.array(branchSchema).optional(),\n  endpoints: z.array(endpointSchema).optional(),\n  databases: z.array(databaseSchema).optional(),\n});\n\n/**\n * Long-running operation envelope returned by mutating REST calls.\n * `done: true` means terminal; check `error` before reading `response`.\n */\nconst operationSchema = z.object({\n  name: z.string().optional(),\n  done: z.boolean().optional(),\n  error: z.unknown().optional(),\n  response: z.unknown().optional(),\n});\ntype Operation = z.infer<typeof operationSchema>;\n\n/** `PGPORT` must land inside the TCP port range. */\nconst portSchema = z.coerce.number().int().min(1).max(MAX_TCP_PORT);\n\nconst sslModeSchema = z.enum(SSL_MODES);\n\n/**\n * Validate a `PGPORT`-shaped value. Returns `undefined` when unset, and throws\n * a {@link ValidationError} naming `PGPORT` for anything that is not a TCP\n * port, so a typo cannot reach the connection record as `NaN`.\n */\nexport function parsePort(value: string | number | undefined): number | undefined {\n  if (value === undefined || value === \"\") return undefined;\n  const parsed = portSchema.safeParse(value);\n  if (!parsed.success) {\n    throw ValidationError.invalidValue(\"PGPORT\", value, `a TCP port between 1 and ${MAX_TCP_PORT}`);\n  }\n  return parsed.data;\n}\n\n/**\n * Validate a `PGSSLMODE`-shaped value. Returns `undefined` when unset, and\n * throws a {@link ValidationError} naming `PGSSLMODE` for an unsupported mode\n * rather than handing `pg` a value it will reject at connect time.\n */\nexport function parseSslMode(value: string | undefined): SslMode | undefined {\n  if (value === undefined || value === \"\") return undefined;\n  const parsed = sslModeSchema.safeParse(value.trim().toLowerCase());\n  if (!parsed.success) {\n    throw ValidationError.invalidValue(\"PGSSLMODE\", value, SSL_MODES.join(\", \"));\n  }\n  return parsed.data;\n}\n\n/**\n * Delay before the next poll attempt: exponential backoff capped at\n * {@link POLL_MAX_DELAY_MS}, plus jitter so several apps booting against the\n * same workspace do not retry in lockstep.\n */\nexport function nextPollDelay(attempt: number, baseMs: number): number {\n  const backoff = Math.min(baseMs * POLL_BACKOFF_FACTOR ** attempt, POLL_MAX_DELAY_MS);\n  const jitter = backoff * POLL_JITTER_RATIO * (Math.random() * 2 - 1);\n  return Math.max(0, Math.round(backoff + jitter));\n}\n\n/**\n * Wait out {@link nextPollDelay} before the next attempt. Rejects with the\n * signal's reason when the caller cancels mid-wait, so a poll loop unwinds\n * instead of finishing its backoff first.\n */\nexport function pollDelay(attempt: number, baseMs: number, signal?: AbortSignal): Promise<void> {\n  return async.sleep(nextPollDelay(attempt, baseMs), signal);\n}\n\n/**\n * Pull resolver inputs from `process.env`, parse the address blob, and\n * layer explicit config on top with this precedence:\n *\n *   `config.<field>` > `config.resolveConfigValue` (`env`, then bundle\n *   validate JSON) > whatever {@link parseAddress} recovered from the\n *   `endpoint` / `LAKEBASE_ENDPOINT` blob.\n *\n * Set `config.endpoint` (or `LAKEBASE_ENDPOINT`) to any input\n * {@link parseAddress} understands: canonical resource paths, Postgres\n * URIs, bare hostnames, or bare project ids.\n */\nexport async function readLakebaseInputs(\n  config?: LakebaseResolverInputs,\n): Promise<LakebaseResolverInputs> {\n  const rawAddress = config?.endpoint ?? (await resolveConfigValue(\"LAKEBASE_ENDPOINT\"));\n  const parsed = parseAddress(rawAddress);\n  const portEnv = parsePort(await resolveConfigValue(\"PGPORT\"));\n  const sslModeEnv = parseSslMode(await resolveConfigValue(\"PGSSLMODE\"));\n  return {\n    project: config?.project ?? parsed.project,\n    branch: config?.branch ?? parsed.branch,\n    // Only canonical endpoint resource paths survive here; URIs and\n    // bare hostnames set `host` instead and leave `endpoint` undefined\n    // until the REST resolver fills it in.\n    endpoint: parsed.endpoint,\n    database: config?.database ?? (await resolveConfigValue(\"PGDATABASE\")) ?? parsed.database,\n    host: config?.host ?? (await resolveConfigValue(\"PGHOST\")) ?? parsed.host,\n    port: config?.port ?? portEnv ?? parsed.port,\n    sslMode: config?.sslMode ?? sslModeEnv ?? parsed.sslMode,\n    autoCreate: config?.autoCreate,\n  };\n}\n\n/**\n * Resolve a fully-populated Postgres connection record from config + env.\n *\n * Returns immediately without network traffic when env already supplies\n * `endpoint`, `host`, and `database`. Otherwise issues REST calls and\n * may auto-create a project (see module docstring).\n *\n * `signal` cancels every REST call and inter-poll sleep.\n *\n * @example\n * import { lakebaseResolver } from \"@dbx-tools/appkit\";\n *\n * const resolved = await lakebaseResolver.resolveLakebaseConnection(\n *   { autoCreate: false },\n *   AbortSignal.timeout(60_000),\n * );\n * lakebaseResolver.applyLakebaseToEnv(resolved);\n */\nexport async function resolveLakebaseConnection(\n  config?: LakebaseResolverInputs,\n  signal?: AbortSignal,\n): Promise<LakebaseConnection> {\n  const inputs = await readLakebaseInputs(config);\n  let { project, branch, endpoint, database, host } = inputs;\n  const port = inputs.port ?? DEFAULT_PORT;\n  const sslMode = inputs.sslMode ?? DEFAULT_SSL_MODE;\n\n  // Resource paths may carry redundant info; harvest project/branch\n  // from any canonical path that snuck in via PGDATABASE or similar.\n  if (endpoint && (!project || !branch)) {\n    const parsedEndpoint = parseAddress(endpoint);\n    project ??= parsedEndpoint.project;\n    branch ??= parsedEndpoint.branch;\n  }\n  if (database && (!project || !branch)) {\n    const parsedDatabase = parseAddress(database);\n    project ??= parsedDatabase.project;\n    branch ??= parsedDatabase.branch;\n    if (parsedDatabase.databaseResourceId) {\n      database = parsedDatabase.databaseResourceId;\n    }\n  }\n\n  // Already complete: skip every REST call.\n  if (endpoint && host && database) {\n    return { project, branch, endpoint, database, host, port, sslMode };\n  }\n\n  const ws = getWorkspaceClient({});\n\n  // Host known but no resource path: scan the workspace to find which\n  // endpoint owns this host so we can populate LAKEBASE_ENDPOINT.\n  if (!project && host) {\n    const found = await findEndpointByHost(ws, host, signal);\n    if (found) {\n      project = found.project;\n      branch = found.branch;\n      endpoint ??= found.endpoint;\n    }\n  }\n\n  // No project anywhere in config/env/address: list, pick, or create.\n  if (!project) {\n    project = await pickOrCreateProject(ws, config?.autoCreate, signal);\n  }\n\n  if (!branch) {\n    branch = await pickBranch(ws, project, signal);\n  }\n\n  if (!endpoint) {\n    const ep = await pickEndpoint(ws, project, branch, signal);\n    endpoint = ep.name;\n    host ??= ep.host;\n  }\n\n  if (!host && endpoint) {\n    const parsedEndpoint = parseAddress(endpoint);\n    if (parsedEndpoint.project && parsedEndpoint.branch && parsedEndpoint.endpointId) {\n      const ep = await waitEndpointReady(\n        ws,\n        parsedEndpoint.project,\n        parsedEndpoint.branch,\n        parsedEndpoint.endpointId,\n        signal,\n      );\n      host = ep.status?.hosts?.host;\n      logger.debug(\"autopg: resolved host from endpoint\", { host });\n    }\n  }\n\n  if (!database) {\n    database = await pickDatabase(ws, project, branch, signal);\n  }\n\n  return { project, branch, endpoint, database, host, port, sslMode };\n}\n\n/**\n * Write resolved values back to `process.env` so the `lakebase` plugin\n * (which reads env directly) picks them up during its own `setup()`.\n * Existing env values are preserved; only missing keys are filled in,\n * which keeps explicit overrides authoritative.\n *\n * This does NOT set `PGUSER`, which needs an await - see\n * {@link applyLakebaseEnv} for the complete set a Postgres pool requires.\n */\nexport function applyLakebaseToEnv(resolved: LakebaseConnection): void {\n  if (resolved.endpoint) process.env.LAKEBASE_ENDPOINT ??= resolved.endpoint;\n  if (resolved.host) process.env.PGHOST ??= resolved.host;\n  if (resolved.database) process.env.PGDATABASE ??= resolved.database;\n  process.env.PGPORT ??= String(resolved.port);\n  process.env.PGSSLMODE ??= resolved.sslMode;\n}\n\n/**\n * Resolve the connection AND apply every Postgres env var a Lakebase pool needs,\n * returning the resolved connection plus the username that was applied.\n *\n * This is the whole set, which is the point of having one function for it:\n * `createLakebasePool()` throws unless `LAKEBASE_ENDPOINT`, `PGHOST`,\n * `PGDATABASE`, **and** a username (`PGUSER`, or `DATABRICKS_CLIENT_ID` for a\n * service principal) are all present, and a Databricks App `postgres` resource\n * binding supplies only the first. Anything that wants a working pool - the\n * `lakebase` plugin, or AppKit's PERSISTENT cache, which quietly degrades to\n * in-memory when the pool cannot be built - needs all four, so callers should not\n * pair {@link applyLakebaseToEnv} with their own username lookup.\n *\n * `PGUSER` is applied with `??=` like the rest, so an explicitly configured value\n * stays authoritative. The lookup returns `undefined` rather than throwing when it\n * cannot determine a user, leaving the pool to resolve its own.\n *\n * @example\n * import { lakebaseResolver } from \"@dbx-tools/appkit\";\n *\n * // Enough for `createLakebasePool()` to build a pool.\n * const { user } = await lakebaseResolver.applyLakebaseEnv({ autoCreate: false });\n */\nexport async function applyLakebaseEnv(\n  config?: LakebaseResolverInputs,\n  signal?: AbortSignal,\n): Promise<{ resolved: LakebaseConnection; user?: string }> {\n  const resolved = await resolveLakebaseConnection(config, signal);\n  applyLakebaseToEnv(resolved);\n  const user = await getUsernameWithApiLookup({});\n  if (user) process.env.PGUSER ??= user;\n  return { resolved, ...(user ? { user } : {}) };\n}\n\ntype WorkspaceClient = ReturnType<typeof getWorkspaceClient>;\n\n/** The SDK `Context` accepted by the workspace client's own copy of the SDK. */\ntype ApiRequestContext = NonNullable<Parameters<WorkspaceClient[\"apiClient\"][\"request\"]>[1]>;\n\n/**\n * Adapt an {@link AbortSignal} into the api client's cancellation context.\n * AppKit resolves a different copy of `@databricks/sdk-experimental` than this\n * package does, and `Context` carries a private field, so the two declarations\n * are nominally incompatible even though the api client only reads\n * `cancellationToken` and `logger` off the object.\n */\nfunction requestContext(signal: AbortSignal | undefined): ApiRequestContext | undefined {\n  return signal ? (toContext(signal) as unknown as ApiRequestContext) : undefined;\n}\n\n/**\n * Validate a Lakebase REST body. The full payload is logged rather than thrown\n * so a client never receives upstream detail.\n */\nfunction parseResponse<T>(schema: z.ZodType<T>, path: string, body: unknown): T {\n  const parsed = schema.safeParse(body);\n  if (parsed.success) return parsed.data;\n  logger.error(\"autopg: unexpected Lakebase API response\", {\n    path,\n    issues: parsed.error.issues,\n  });\n  throw new ExecutionError(\"Lakebase API returned an unexpected response\", { context: { path } });\n}\n\n/** GET helper that validates the JSON body and forwards cancellation. */\nasync function getJson<T>(\n  ws: WorkspaceClient,\n  path: string,\n  schema: z.ZodType<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const res = await ws.apiClient.request(\n    {\n      path,\n      method: \"GET\",\n      headers: new Headers({ Accept: \"application/json\" }),\n      raw: false,\n    },\n    requestContext(signal),\n  );\n  return parseResponse(schema, path, res);\n}\n\n/** POST helper for create / mutate calls; validates the JSON body. */\nasync function postJson<T>(\n  ws: WorkspaceClient,\n  path: string,\n  schema: z.ZodType<T>,\n  body: unknown,\n  query?: Record<string, string>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const res = await ws.apiClient.request(\n    {\n      path,\n      method: \"POST\",\n      query,\n      headers: new Headers({\n        Accept: \"application/json\",\n        \"Content-Type\": \"application/json\",\n      }),\n      raw: false,\n      payload: body,\n    },\n    requestContext(signal),\n  );\n  return parseResponse(schema, path, res);\n}\n\nasync function listProjects(ws: WorkspaceClient, signal?: AbortSignal): Promise<Project[]> {\n  const res = await getJson(ws, `${API_BASE}/projects`, listResponseSchema, signal);\n  return res.projects ?? [];\n}\n\nasync function listBranches(\n  ws: WorkspaceClient,\n  project: string,\n  signal?: AbortSignal,\n): Promise<Branch[]> {\n  const res = await getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches`,\n    listResponseSchema,\n    signal,\n  );\n  return res.branches ?? [];\n}\n\nasync function listEndpoints(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<Endpoint[]> {\n  const res = await getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches/${branch}/endpoints`,\n    listResponseSchema,\n    signal,\n  );\n  return res.endpoints ?? [];\n}\n\nasync function listDatabases(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<Database[]> {\n  const res = await getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches/${branch}/databases`,\n    listResponseSchema,\n    signal,\n  );\n  return res.databases ?? [];\n}\n\nasync function getEndpoint(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  endpointId: string,\n  signal?: AbortSignal,\n): Promise<Endpoint> {\n  return getJson(\n    ws,\n    `${API_BASE}/projects/${project}/branches/${branch}/endpoints/${endpointId}`,\n    endpointSchema,\n    signal,\n  );\n}\n\n/**\n * Scan the workspace for an endpoint whose `status.hosts.host` matches\n * the provided hostname. Used to recover the owning project/branch/\n * endpoint resource path when the caller only supplied a Postgres URI.\n *\n * O(projects * branches * endpoints) - fine for typical workspaces\n * (single digits per tier); pagination is intentionally not followed\n * since this is a best-effort fallback.\n */\nasync function findEndpointByHost(\n  ws: WorkspaceClient,\n  host: string,\n  signal?: AbortSignal,\n): Promise<{ project: string; branch: string; endpoint: string } | null> {\n  const projects = await listProjects(ws, signal);\n  for (const p of projects) {\n    const projectId = parseResourcePath(p.name).project;\n    if (!projectId) continue;\n    const branches = await listBranches(ws, projectId, signal);\n    for (const b of branches) {\n      const branchId = parseResourcePath(b.name).branch;\n      if (!branchId) continue;\n      const endpoints = await listEndpoints(ws, projectId, branchId, signal);\n      const match = endpoints.find((e) => e.status?.hosts?.host === host);\n      if (match?.name) {\n        logger.debug(\"autopg: matched endpoint by host\", {\n          host,\n          endpoint: match.name,\n        });\n        return {\n          project: projectId,\n          branch: branchId,\n          endpoint: match.name,\n        };\n      }\n    }\n  }\n  logger.debug(\"autopg: no endpoint matched host\", { host });\n  return null;\n}\n\n/**\n * Pick the project to use, or create one when the workspace is empty.\n *\n * Selection order:\n * 1. Exactly one project listed -> use it.\n * 2. Zero projects AND `autoCreate !== false` -> ensure a project with\n *    the resolved id exists, then return its id.\n * 3. Zero projects AND `autoCreate === false` -> throw.\n * 4. Multiple projects -> throw with the candidate list (set\n *    `config.project` or pin a project id in `LAKEBASE_ENDPOINT`).\n */\nasync function pickOrCreateProject(\n  ws: WorkspaceClient,\n  autoCreate: string | false | undefined,\n  signal?: AbortSignal,\n): Promise<string> {\n  const projects = await listProjects(ws, signal);\n  if (projects.length === 1) {\n    const id = parseResourcePath(projects[0]!.name).project;\n    if (id) {\n      logger.debug(\"autopg: using only project\", { project: id });\n      return id;\n    }\n  }\n  if (projects.length === 0) {\n    if (autoCreate === false) {\n      throw ConfigurationError.resourceNotFound(\n        \"Lakebase project\",\n        \"autoCreate is false; create a project or set config.project / LAKEBASE_ENDPOINT.\",\n      );\n    }\n    const id = autoCreate ?? (await defaultProjectId());\n    return ensureProject(ws, id, signal);\n  }\n  const candidates = projects\n    .map((p) => parseResourcePath(p.name).project)\n    .filter((id): id is string => Boolean(id))\n    .join(\", \");\n  throw ConfigurationError.invalidConnection(\n    \"Lakebase\",\n    `Multiple projects found; set config.project or pin a project id in LAKEBASE_ENDPOINT. Candidates: ${candidates}`,\n  );\n}\n\n/**\n * Derive a Lakebase project id from the host repo's `package.json`\n * name (via {@link project.name}) slugified to satisfy the\n * Lakebase id constraint (`^[a-z][a-z0-9-]{0,61}[a-z0-9]$`).\n *\n * Throws when the slug ends up empty or starts with a digit, since the\n * server would reject it anyway - callers should pass an explicit\n * `autoCreate` id in that case.\n */\nasync function defaultProjectId(): Promise<string> {\n  const name = project.name();\n  const slug = string.toSlugWithOptions({ maxLength: PROJECT_ID_MAX_LEN }, name);\n  if (!slug || !/^[a-z]/.test(slug)) {\n    logger.warn(\"autopg: project name does not slugify to a Lakebase project id\", { name });\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      \"Could not derive a project id from the package name; pass autoCreate explicitly.\",\n    );\n  }\n  return slug;\n}\n\n/**\n * Ensure a Lakebase project with `projectId` exists. Creates it and\n * waits for the create operation to complete. An `ALREADY_EXISTS`\n * response is treated as success - someone else (a concurrent boot,\n * a sibling process) won the race and the project we wanted is now\n * sitting there ready for downstream pickers.\n *\n * Project creation typically provisions a default `production` branch\n * alongside; downstream pickers handle the rest.\n */\nasync function ensureProject(\n  ws: WorkspaceClient,\n  projectId: string,\n  signal?: AbortSignal,\n): Promise<string> {\n  logger.warn(\"autopg: no projects found; creating\", { project: projectId });\n  try {\n    const op = await postJson(\n      ws,\n      `${API_BASE}/projects`,\n      operationSchema,\n      { spec: { pg_version: DEFAULT_PG_VERSION } },\n      { project_id: projectId },\n      signal,\n    );\n    await waitForOperation(ws, op, signal);\n    logger.info(\"autopg: created project\", { project: projectId });\n  } catch (err) {\n    if (!isAlreadyExistsError(err)) throw err;\n    logger.info(\"autopg: project already exists (race); proceeding\", {\n      project: projectId,\n    });\n  }\n  return projectId;\n}\n\n/**\n * Recognize the Databricks SDK's `ALREADY_EXISTS` failure modes so a\n * lost race during `ensureProject` becomes a no-op instead of an error.\n *\n * The SDK throws `ApiError { errorCode, statusCode }` for structured\n * server errors and `HttpError { code }` for transport-layer 4xx/5xx.\n * Both surface a human message that often carries \"already exists\" so\n * we use that as a final fallback for forward compatibility.\n */\nfunction isAlreadyExistsError(error: unknown): boolean {\n  if (!error || typeof error !== \"object\") return false;\n  const e = error as {\n    statusCode?: number;\n    code?: number;\n    errorCode?: string;\n    message?: string;\n  };\n  if (e.statusCode === 409 || e.code === 409) return true;\n  if (e.errorCode && /already.?exists/i.test(e.errorCode)) return true;\n  if (e.message && /already.?exists/i.test(e.message)) return true;\n  return false;\n}\n\n/**\n * Reduce a Lakebase operation failure to an error safe to propagate: the\n * operation name plus whatever code the payload carries. The payload itself can\n * echo request context, so it goes to the log instead.\n */\nfunction operationFailed(opName: string, opError: unknown): ExecutionError {\n  logger.error(\"autopg: operation failed\", { operation: opName, error: opError });\n  const code = object.isRecord(opError) ? (opError.code ?? opError.reason) : undefined;\n  return new ExecutionError(`Lakebase operation failed: ${opName}`, {\n    context: {\n      operation: opName,\n      errorCode: typeof code === \"string\" || typeof code === \"number\" ? String(code) : \"unknown\",\n    },\n  });\n}\n\n/**\n * Poll a Lakebase long-running operation until `done: true`. Returns\n * the final operation envelope (which may carry `response` or `error`).\n *\n * Throws when:\n *   - the response carries an `error` field;\n *   - `op.name` is missing (nothing to poll);\n *   - the timeout elapses before `done: true`;\n *   - `signal` aborts mid-wait.\n */\nasync function waitForOperation(\n  ws: WorkspaceClient,\n  op: Operation,\n  signal?: AbortSignal,\n): Promise<Operation> {\n  if (op.done) {\n    if (op.error) {\n      throw operationFailed(op.name ?? \"unknown\", op.error);\n    }\n    return op;\n  }\n  const opName = op.name;\n  if (!opName) {\n    throw ExecutionError.missingData(\"operation name\");\n  }\n  const start = Date.now();\n  for (let attempt = 0; Date.now() - start < OPERATION_TIMEOUT_MS; attempt++) {\n    await pollDelay(attempt, OPERATION_POLL_MS, signal);\n    const current = await getJson(ws, `${API_BASE}/${opName}`, operationSchema, signal);\n    logger.debug(\"autopg: operation status\", { op: opName, done: current.done });\n    if (current.done) {\n      if (current.error) {\n        throw operationFailed(opName, current.error);\n      }\n      return current;\n    }\n  }\n  throw new ExecutionError(`Lakebase operation did not complete: ${opName}`, {\n    context: { operation: opName, timeoutMs: OPERATION_TIMEOUT_MS },\n  });\n}\n\n/**\n * Poll `getEndpoint` until the compute reports a usable\n * `status.current_state`. `READY` and `IDLE` are both acceptable -\n * `IDLE` just means the compute has scaled to zero but a connection\n * will wake it. Returns the final endpoint payload (with `hosts.host`).\n */\nasync function waitEndpointReady(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  endpointId: string,\n  signal?: AbortSignal,\n): Promise<Endpoint> {\n  const start = Date.now();\n  let last: Endpoint | null = null;\n  for (let attempt = 0; Date.now() - start < ENDPOINT_READY_TIMEOUT_MS; attempt++) {\n    last = await getEndpoint(ws, project, branch, endpointId, signal);\n    const state = last.status?.current_state;\n    if (state && CONNECTABLE_ENDPOINT_STATES.has(state)) return last;\n    if (last.status?.hosts?.host && state !== INITIALIZING_ENDPOINT_STATE) {\n      // Compute is in some other state (STARTING, etc.) but hostname is\n      // already published - good enough to connect; lakebase's OAuth\n      // token request will wake it.\n      return last;\n    }\n    logger.debug(\"autopg: waiting for endpoint\", { endpointId, state });\n    await pollDelay(attempt, ENDPOINT_READY_POLL_MS, signal);\n  }\n  throw new ExecutionError(`Lakebase endpoint did not become ready: ${endpointId}`, {\n    context: {\n      project,\n      branch,\n      endpointId,\n      timeoutMs: ENDPOINT_READY_TIMEOUT_MS,\n      lastState: last?.status?.current_state ?? \"unknown\",\n    },\n  });\n}\n\n/**\n * Pick the default branch for a project. Prefers the branch flagged\n * `status.default: true` (server-side default, typically `production`\n * unless the project owner changed it). Falls back to the only branch\n * when there's exactly one. Otherwise throws with the candidate list.\n */\nasync function pickBranch(\n  ws: WorkspaceClient,\n  project: string,\n  signal?: AbortSignal,\n): Promise<string> {\n  const branches = await listBranches(ws, project, signal);\n  if (branches.length === 0) {\n    throw ConfigurationError.resourceNotFound(\n      `Lakebase branch in project '${project}'`,\n      \"The project has no branches; create one or set config.branch.\",\n    );\n  }\n  const flagged = branches.find((b) => b.status?.default === true);\n  const choice =\n    parseResourcePath(flagged?.name).branch ??\n    (branches.length === 1 ? parseResourcePath(branches[0]!.name).branch : undefined);\n  if (!choice) {\n    const candidates = branches\n      .map((b) => parseResourcePath(b.name).branch)\n      .filter((id): id is string => Boolean(id))\n      .join(\", \");\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      `Project '${project}' has multiple branches and none marked default; set config.branch or include the branch in LAKEBASE_ENDPOINT. Candidates: ${candidates}`,\n    );\n  }\n  logger.debug(\"autopg: resolved branch\", { project, branch: choice });\n  return choice;\n}\n\n/**\n * Pick the primary endpoint for a (project, branch). Prefers\n * `status.endpoint_type === ENDPOINT_TYPE_READ_WRITE`; falls back to\n * the only endpoint when there's exactly one. Returns `{ name, host }`\n * so the caller can populate both `LAKEBASE_ENDPOINT` and `PGHOST`\n * from a single call.\n */\nasync function pickEndpoint(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<{ name: string; host?: string }> {\n  const endpoints = await listEndpoints(ws, project, branch, signal);\n  if (endpoints.length === 0) {\n    throw ConfigurationError.resourceNotFound(\n      `Lakebase endpoint in 'projects/${project}/branches/${branch}'`,\n      \"The branch has no endpoints; create one or set LAKEBASE_ENDPOINT.\",\n    );\n  }\n  const primary =\n    endpoints.find((e) => e.status?.endpoint_type === READ_WRITE_ENDPOINT_TYPE) ??\n    (endpoints.length === 1 ? endpoints[0] : undefined);\n  if (!primary?.name) {\n    const names = endpoints.map((e) => e.name).filter(Boolean);\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      `Branch has no primary read-write endpoint; set LAKEBASE_ENDPOINT or config.endpoint. Candidates: ${names.join(\", \")}`,\n    );\n  }\n  const host = primary.status?.hosts?.host;\n  logger.debug(\"autopg: resolved endpoint\", { endpoint: primary.name, host });\n  return { name: primary.name, host };\n}\n\n/**\n * Pick the default postgres database for a (project, branch). The\n * Postgres database NAME (`status.postgres_database`) is what\n * `PGDATABASE` needs - this differs from the resource id, which can\n * use a different separator (e.g. resource `databricks-postgres`\n * surfaces as database `databricks_postgres`). Prefers\n * `databricks_postgres` (the Lakebase default), otherwise the only\n * database.\n */\nasync function pickDatabase(\n  ws: WorkspaceClient,\n  project: string,\n  branch: string,\n  signal?: AbortSignal,\n): Promise<string> {\n  const databases = await listDatabases(ws, project, branch, signal);\n  if (databases.length === 0) {\n    throw ConfigurationError.resourceNotFound(\n      `Lakebase database in 'projects/${project}/branches/${branch}'`,\n      \"The branch has no databases; create one or set PGDATABASE.\",\n    );\n  }\n  const names = databases\n    .map((d) => d.status?.postgres_database)\n    .filter((n): n is string => Boolean(n));\n  const choice =\n    names.find((n) => n === DEFAULT_DATABASE) ?? (names.length === 1 ? names[0] : undefined);\n  if (!choice) {\n    throw ConfigurationError.invalidConnection(\n      \"Lakebase\",\n      `Multiple databases and no '${DEFAULT_DATABASE}'; set PGDATABASE or config.database. Candidates: ${names.join(\", \")}`,\n    );\n  }\n  logger.debug(\"autopg: resolved database\", { database: choice });\n  return choice;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

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