@dbx-tools/appkit 0.3.44 → 0.4.0

package/lib/src/lakebase-resolver.js

@@ -0,0 +1,679 @@
+/**
+ * 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 { ConfigurationError, ExecutionError, 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";
+import { resolveConfigValue } from "./config.js";
+import { MAX_TCP_PORT, toContext } from "./databricks.js";
+import { parseAddress, parseResourcePath, SSL_MODES, } from "./pgaddress.js";
+const logger = log.logger("lakebase-resolver");
+const API_BASE = "/api/2.0/postgres";
+const DEFAULT_PORT = 5432;
+const DEFAULT_SSL_MODE = "require";
+const DEFAULT_PG_VERSION = 17;
+/** Lakebase project ids: `^[a-z][a-z0-9-]{0,61}[a-z0-9]$`. */
+const PROJECT_ID_MAX_LEN = 63;
+const OPERATION_TIMEOUT_MS = 5 * 60_000;
+const OPERATION_POLL_MS = 2_000;
+const ENDPOINT_READY_TIMEOUT_MS = 5 * 60_000;
+const ENDPOINT_READY_POLL_MS = 2_000;
+/** Ceiling on a single backoff step, so a long wait still polls regularly. */
+const POLL_MAX_DELAY_MS = 15_000;
+const POLL_BACKOFF_FACTOR = 1.5;
+/** Fraction of each delay applied as +/- jitter, so concurrent boots desynchronize. */
+const POLL_JITTER_RATIO = 0.2;
+/** Endpoint `status.endpoint_type` for the writable primary. */
+const READ_WRITE_ENDPOINT_TYPE = "ENDPOINT_TYPE_READ_WRITE";
+/** Endpoint `status.current_state` values that will accept a connection. */
+const CONNECTABLE_ENDPOINT_STATES = new Set(["READY", "IDLE"]);
+/** Endpoint `status.current_state` before a hostname is meaningful. */
+const INITIALIZING_ENDPOINT_STATE = "INITIALIZING";
+/** Lakebase's own default Postgres database name. */
+const DEFAULT_DATABASE = "databricks_postgres";
+/**
+ * Every field of the Lakebase REST payloads is modelled as optional and
+ * validated at the boundary rather than asserted with a cast: the pickers below
+ * branch on `status.*`, and a shape change upstream should surface as one loud
+ * error here instead of an `undefined` three frames away. Enum-shaped fields
+ * stay `string` so a newly added state does not fail the whole response.
+ */
+const projectSchema = z.object({
+    // Full resource path: `projects/{p}`.
+    name: z.string().optional(),
+});
+const endpointSchema = z.object({
+    // Full resource path: `projects/{p}/branches/{b}/endpoints/{e}`.
+    name: z.string().optional(),
+    uid: z.string().optional(),
+    // Server-side state. All connection info lives here - the spec block
+    // only carries the desired configuration, not the runtime hostnames.
+    status: z
+        .object({
+        endpoint_type: z.string().optional(),
+        // Resolved hostnames; `hosts.host` is the writable primary.
+        hosts: z
+            .object({
+            host: z.string().optional(),
+            read_only_host: z.string().optional(),
+        })
+            .optional(),
+        // Compute state: `INITIALIZING`, `STARTING`, `READY`, `IDLE`, ...
+        current_state: z.string().optional(),
+    })
+        .optional(),
+});
+const branchSchema = z.object({
+    // Full resource path: `projects/{p}/branches/{b}`.
+    name: z.string().optional(),
+    status: z
+        .object({
+        // True for the project's default branch (e.g. `production`).
+        default: z.boolean().optional(),
+        current_state: z.string().optional(),
+    })
+        .optional(),
+});
+const databaseSchema = z.object({
+    // Full resource path: `projects/{p}/branches/{b}/databases/{d}`.
+    name: z.string().optional(),
+    status: z
+        .object({
+        // Actual Postgres database name (used as `PGDATABASE`). May differ
+        // from the resource id - e.g. resource `databricks-postgres`
+        // surfaces as Postgres database `databricks_postgres`.
+        postgres_database: z.string().optional(),
+    })
+        .optional(),
+});
+/**
+ * Lakebase REST list responses follow the Google AIP convention:
+ * `{ <plural-resource>: T[], next_page_token?: string }`. We only read
+ * the first page; for auto-config's "pick something sensible" semantics the
+ * cap is fine.
+ */
+const listResponseSchema = z.object({
+    next_page_token: z.string().optional(),
+    projects: z.array(projectSchema).optional(),
+    branches: z.array(branchSchema).optional(),
+    endpoints: z.array(endpointSchema).optional(),
+    databases: z.array(databaseSchema).optional(),
+});
+/**
+ * Long-running operation envelope returned by mutating REST calls.
+ * `done: true` means terminal; check `error` before reading `response`.
+ */
+const operationSchema = z.object({
+    name: z.string().optional(),
+    done: z.boolean().optional(),
+    error: z.unknown().optional(),
+    response: z.unknown().optional(),
+});
+/** `PGPORT` must land inside the TCP port range. */
+const portSchema = z.coerce.number().int().min(1).max(MAX_TCP_PORT);
+const sslModeSchema = z.enum(SSL_MODES);
+/**
+ * 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 function parsePort(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    const parsed = portSchema.safeParse(value);
+    if (!parsed.success) {
+        throw ValidationError.invalidValue("PGPORT", value, `a TCP port between 1 and ${MAX_TCP_PORT}`);
+    }
+    return parsed.data;
+}
+/**
+ * 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 function parseSslMode(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    const parsed = sslModeSchema.safeParse(value.trim().toLowerCase());
+    if (!parsed.success) {
+        throw ValidationError.invalidValue("PGSSLMODE", value, SSL_MODES.join(", "));
+    }
+    return parsed.data;
+}
+/**
+ * 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 function nextPollDelay(attempt, baseMs) {
+    const backoff = Math.min(baseMs * POLL_BACKOFF_FACTOR ** attempt, POLL_MAX_DELAY_MS);
+    const jitter = backoff * POLL_JITTER_RATIO * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(backoff + jitter));
+}
+/**
+ * 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 function pollDelay(attempt, baseMs, signal) {
+    return async.sleep(nextPollDelay(attempt, baseMs), signal);
+}
+/**
+ * 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 async function readLakebaseInputs(config) {
+    const rawAddress = config?.endpoint ?? (await resolveConfigValue("LAKEBASE_ENDPOINT"));
+    const parsed = parseAddress(rawAddress);
+    const portEnv = parsePort(await resolveConfigValue("PGPORT"));
+    const sslModeEnv = parseSslMode(await resolveConfigValue("PGSSLMODE"));
+    return {
+        project: config?.project ?? parsed.project,
+        branch: config?.branch ?? parsed.branch,
+        // Only canonical endpoint resource paths survive here; URIs and
+        // bare hostnames set `host` instead and leave `endpoint` undefined
+        // until the REST resolver fills it in.
+        endpoint: parsed.endpoint,
+        database: config?.database ?? (await resolveConfigValue("PGDATABASE")) ?? parsed.database,
+        host: config?.host ?? (await resolveConfigValue("PGHOST")) ?? parsed.host,
+        port: config?.port ?? portEnv ?? parsed.port,
+        sslMode: config?.sslMode ?? sslModeEnv ?? parsed.sslMode,
+        autoCreate: config?.autoCreate,
+    };
+}
+/**
+ * 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 async function resolveLakebaseConnection(config, signal) {
+    const inputs = await readLakebaseInputs(config);
+    let { project, branch, endpoint, database, host } = inputs;
+    const port = inputs.port ?? DEFAULT_PORT;
+    const sslMode = inputs.sslMode ?? DEFAULT_SSL_MODE;
+    // Resource paths may carry redundant info; harvest project/branch
+    // from any canonical path that snuck in via PGDATABASE or similar.
+    if (endpoint && (!project || !branch)) {
+        const parsedEndpoint = parseAddress(endpoint);
+        project ??= parsedEndpoint.project;
+        branch ??= parsedEndpoint.branch;
+    }
+    if (database && (!project || !branch)) {
+        const parsedDatabase = parseAddress(database);
+        project ??= parsedDatabase.project;
+        branch ??= parsedDatabase.branch;
+        if (parsedDatabase.databaseResourceId) {
+            database = parsedDatabase.databaseResourceId;
+        }
+    }
+    // Already complete: skip every REST call.
+    if (endpoint && host && database) {
+        return { project, branch, endpoint, database, host, port, sslMode };
+    }
+    const ws = getWorkspaceClient({});
+    // Host known but no resource path: scan the workspace to find which
+    // endpoint owns this host so we can populate LAKEBASE_ENDPOINT.
+    if (!project && host) {
+        const found = await findEndpointByHost(ws, host, signal);
+        if (found) {
+            project = found.project;
+            branch = found.branch;
+            endpoint ??= found.endpoint;
+        }
+    }
+    // No project anywhere in config/env/address: list, pick, or create.
+    if (!project) {
+        project = await pickOrCreateProject(ws, config?.autoCreate, signal);
+    }
+    if (!branch) {
+        branch = await pickBranch(ws, project, signal);
+    }
+    if (!endpoint) {
+        const ep = await pickEndpoint(ws, project, branch, signal);
+        endpoint = ep.name;
+        host ??= ep.host;
+    }
+    if (!host && endpoint) {
+        const parsedEndpoint = parseAddress(endpoint);
+        if (parsedEndpoint.project && parsedEndpoint.branch && parsedEndpoint.endpointId) {
+            const ep = await waitEndpointReady(ws, parsedEndpoint.project, parsedEndpoint.branch, parsedEndpoint.endpointId, signal);
+            host = ep.status?.hosts?.host;
+            logger.debug("autopg: resolved host from endpoint", { host });
+        }
+    }
+    if (!database) {
+        database = await pickDatabase(ws, project, branch, signal);
+    }
+    return { project, branch, endpoint, database, host, port, sslMode };
+}
+/**
+ * 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 function applyLakebaseToEnv(resolved) {
+    if (resolved.endpoint)
+        process.env.LAKEBASE_ENDPOINT ??= resolved.endpoint;
+    if (resolved.host)
+        process.env.PGHOST ??= resolved.host;
+    if (resolved.database)
+        process.env.PGDATABASE ??= resolved.database;
+    process.env.PGPORT ??= String(resolved.port);
+    process.env.PGSSLMODE ??= resolved.sslMode;
+}
+/**
+ * Adapt an {@link AbortSignal} into the api client's cancellation context.
+ * AppKit resolves a different copy of `@databricks/sdk-experimental` than this
+ * package does, and `Context` carries a private field, so the two declarations
+ * are nominally incompatible even though the api client only reads
+ * `cancellationToken` and `logger` off the object.
+ */
+function requestContext(signal) {
+    return signal ? toContext(signal) : undefined;
+}
+/**
+ * Validate a Lakebase REST body. The full payload is logged rather than thrown
+ * so a client never receives upstream detail.
+ */
+function parseResponse(schema, path, body) {
+    const parsed = schema.safeParse(body);
+    if (parsed.success)
+        return parsed.data;
+    logger.error("autopg: unexpected Lakebase API response", {
+        path,
+        issues: parsed.error.issues,
+    });
+    throw new ExecutionError("Lakebase API returned an unexpected response", { context: { path } });
+}
+/** GET helper that validates the JSON body and forwards cancellation. */
+async function getJson(ws, path, schema, signal) {
+    const res = await ws.apiClient.request({
+        path,
+        method: "GET",
+        headers: new Headers({ Accept: "application/json" }),
+        raw: false,
+    }, requestContext(signal));
+    return parseResponse(schema, path, res);
+}
+/** POST helper for create / mutate calls; validates the JSON body. */
+async function postJson(ws, path, schema, body, query, signal) {
+    const res = await ws.apiClient.request({
+        path,
+        method: "POST",
+        query,
+        headers: new Headers({
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        }),
+        raw: false,
+        payload: body,
+    }, requestContext(signal));
+    return parseResponse(schema, path, res);
+}
+async function listProjects(ws, signal) {
+    const res = await getJson(ws, `${API_BASE}/projects`, listResponseSchema, signal);
+    return res.projects ?? [];
+}
+async function listBranches(ws, project, signal) {
+    const res = await getJson(ws, `${API_BASE}/projects/${project}/branches`, listResponseSchema, signal);
+    return res.branches ?? [];
+}
+async function listEndpoints(ws, project, branch, signal) {
+    const res = await getJson(ws, `${API_BASE}/projects/${project}/branches/${branch}/endpoints`, listResponseSchema, signal);
+    return res.endpoints ?? [];
+}
+async function listDatabases(ws, project, branch, signal) {
+    const res = await getJson(ws, `${API_BASE}/projects/${project}/branches/${branch}/databases`, listResponseSchema, signal);
+    return res.databases ?? [];
+}
+async function getEndpoint(ws, project, branch, endpointId, signal) {
+    return getJson(ws, `${API_BASE}/projects/${project}/branches/${branch}/endpoints/${endpointId}`, endpointSchema, signal);
+}
+/**
+ * Scan the workspace for an endpoint whose `status.hosts.host` matches
+ * the provided hostname. Used to recover the owning project/branch/
+ * endpoint resource path when the caller only supplied a Postgres URI.
+ *
+ * O(projects * branches * endpoints) - fine for typical workspaces
+ * (single digits per tier); pagination is intentionally not followed
+ * since this is a best-effort fallback.
+ */
+async function findEndpointByHost(ws, host, signal) {
+    const projects = await listProjects(ws, signal);
+    for (const p of projects) {
+        const projectId = parseResourcePath(p.name).project;
+        if (!projectId)
+            continue;
+        const branches = await listBranches(ws, projectId, signal);
+        for (const b of branches) {
+            const branchId = parseResourcePath(b.name).branch;
+            if (!branchId)
+                continue;
+            const endpoints = await listEndpoints(ws, projectId, branchId, signal);
+            const match = endpoints.find((e) => e.status?.hosts?.host === host);
+            if (match?.name) {
+                logger.debug("autopg: matched endpoint by host", {
+                    host,
+                    endpoint: match.name,
+                });
+                return {
+                    project: projectId,
+                    branch: branchId,
+                    endpoint: match.name,
+                };
+            }
+        }
+    }
+    logger.debug("autopg: no endpoint matched host", { host });
+    return null;
+}
+/**
+ * Pick the project to use, or create one when the workspace is empty.
+ *
+ * Selection order:
+ * 1. Exactly one project listed -> use it.
+ * 2. Zero projects AND `autoCreate !== false` -> ensure a project with
+ *    the resolved id exists, then return its id.
+ * 3. Zero projects AND `autoCreate === false` -> throw.
+ * 4. Multiple projects -> throw with the candidate list (set
+ *    `config.project` or pin a project id in `LAKEBASE_ENDPOINT`).
+ */
+async function pickOrCreateProject(ws, autoCreate, signal) {
+    const projects = await listProjects(ws, signal);
+    if (projects.length === 1) {
+        const id = parseResourcePath(projects[0].name).project;
+        if (id) {
+            logger.debug("autopg: using only project", { project: id });
+            return id;
+        }
+    }
+    if (projects.length === 0) {
+        if (autoCreate === false) {
+            throw ConfigurationError.resourceNotFound("Lakebase project", "autoCreate is false; create a project or set config.project / LAKEBASE_ENDPOINT.");
+        }
+        const id = autoCreate ?? (await defaultProjectId());
+        return ensureProject(ws, id, signal);
+    }
+    const candidates = projects
+        .map((p) => parseResourcePath(p.name).project)
+        .filter((id) => Boolean(id))
+        .join(", ");
+    throw ConfigurationError.invalidConnection("Lakebase", `Multiple projects found; set config.project or pin a project id in LAKEBASE_ENDPOINT. Candidates: ${candidates}`);
+}
+/**
+ * Derive a Lakebase project id from the host repo's `package.json`
+ * name (via {@link project.name}) slugified to satisfy the
+ * Lakebase id constraint (`^[a-z][a-z0-9-]{0,61}[a-z0-9]$`).
+ *
+ * Throws when the slug ends up empty or starts with a digit, since the
+ * server would reject it anyway - callers should pass an explicit
+ * `autoCreate` id in that case.
+ */
+async function defaultProjectId() {
+    const name = project.name();
+    const slug = string.toSlugWithOptions({ maxLength: PROJECT_ID_MAX_LEN }, name);
+    if (!slug || !/^[a-z]/.test(slug)) {
+        logger.warn("autopg: project name does not slugify to a Lakebase project id", { name });
+        throw ConfigurationError.invalidConnection("Lakebase", "Could not derive a project id from the package name; pass autoCreate explicitly.");
+    }
+    return slug;
+}
+/**
+ * Ensure a Lakebase project with `projectId` exists. Creates it and
+ * waits for the create operation to complete. An `ALREADY_EXISTS`
+ * response is treated as success - someone else (a concurrent boot,
+ * a sibling process) won the race and the project we wanted is now
+ * sitting there ready for downstream pickers.
+ *
+ * Project creation typically provisions a default `production` branch
+ * alongside; downstream pickers handle the rest.
+ */
+async function ensureProject(ws, projectId, signal) {
+    logger.warn("autopg: no projects found; creating", { project: projectId });
+    try {
+        const op = await postJson(ws, `${API_BASE}/projects`, operationSchema, { spec: { pg_version: DEFAULT_PG_VERSION } }, { project_id: projectId }, signal);
+        await waitForOperation(ws, op, signal);
+        logger.info("autopg: created project", { project: projectId });
+    }
+    catch (err) {
+        if (!isAlreadyExistsError(err))
+            throw err;
+        logger.info("autopg: project already exists (race); proceeding", {
+            project: projectId,
+        });
+    }
+    return projectId;
+}
+/**
+ * Recognize the Databricks SDK's `ALREADY_EXISTS` failure modes so a
+ * lost race during `ensureProject` becomes a no-op instead of an error.
+ *
+ * The SDK throws `ApiError { errorCode, statusCode }` for structured
+ * server errors and `HttpError { code }` for transport-layer 4xx/5xx.
+ * Both surface a human message that often carries "already exists" so
+ * we use that as a final fallback for forward compatibility.
+ */
+function isAlreadyExistsError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const e = error;
+    if (e.statusCode === 409 || e.code === 409)
+        return true;
+    if (e.errorCode && /already.?exists/i.test(e.errorCode))
+        return true;
+    if (e.message && /already.?exists/i.test(e.message))
+        return true;
+    return false;
+}
+/**
+ * Reduce a Lakebase operation failure to an error safe to propagate: the
+ * operation name plus whatever code the payload carries. The payload itself can
+ * echo request context, so it goes to the log instead.
+ */
+function operationFailed(opName, opError) {
+    logger.error("autopg: operation failed", { operation: opName, error: opError });
+    const code = object.isRecord(opError) ? (opError.code ?? opError.reason) : undefined;
+    return new ExecutionError(`Lakebase operation failed: ${opName}`, {
+        context: {
+            operation: opName,
+            errorCode: typeof code === "string" || typeof code === "number" ? String(code) : "unknown",
+        },
+    });
+}
+/**
+ * Poll a Lakebase long-running operation until `done: true`. Returns
+ * the final operation envelope (which may carry `response` or `error`).
+ *
+ * Throws when:
+ *   - the response carries an `error` field;
+ *   - `op.name` is missing (nothing to poll);
+ *   - the timeout elapses before `done: true`;
+ *   - `signal` aborts mid-wait.
+ */
+async function waitForOperation(ws, op, signal) {
+    if (op.done) {
+        if (op.error) {
+            throw operationFailed(op.name ?? "unknown", op.error);
+        }
+        return op;
+    }
+    const opName = op.name;
+    if (!opName) {
+        throw ExecutionError.missingData("operation name");
+    }
+    const start = Date.now();
+    for (let attempt = 0; Date.now() - start < OPERATION_TIMEOUT_MS; attempt++) {
+        await pollDelay(attempt, OPERATION_POLL_MS, signal);
+        const current = await getJson(ws, `${API_BASE}/${opName}`, operationSchema, signal);
+        logger.debug("autopg: operation status", { op: opName, done: current.done });
+        if (current.done) {
+            if (current.error) {
+                throw operationFailed(opName, current.error);
+            }
+            return current;
+        }
+    }
+    throw new ExecutionError(`Lakebase operation did not complete: ${opName}`, {
+        context: { operation: opName, timeoutMs: OPERATION_TIMEOUT_MS },
+    });
+}
+/**
+ * Poll `getEndpoint` until the compute reports a usable
+ * `status.current_state`. `READY` and `IDLE` are both acceptable -
+ * `IDLE` just means the compute has scaled to zero but a connection
+ * will wake it. Returns the final endpoint payload (with `hosts.host`).
+ */
+async function waitEndpointReady(ws, project, branch, endpointId, signal) {
+    const start = Date.now();
+    let last = null;
+    for (let attempt = 0; Date.now() - start < ENDPOINT_READY_TIMEOUT_MS; attempt++) {
+        last = await getEndpoint(ws, project, branch, endpointId, signal);
+        const state = last.status?.current_state;
+        if (state && CONNECTABLE_ENDPOINT_STATES.has(state))
+            return last;
+        if (last.status?.hosts?.host && state !== INITIALIZING_ENDPOINT_STATE) {
+            // Compute is in some other state (STARTING, etc.) but hostname is
+            // already published - good enough to connect; lakebase's OAuth
+            // token request will wake it.
+            return last;
+        }
+        logger.debug("autopg: waiting for endpoint", { endpointId, state });
+        await pollDelay(attempt, ENDPOINT_READY_POLL_MS, signal);
+    }
+    throw new ExecutionError(`Lakebase endpoint did not become ready: ${endpointId}`, {
+        context: {
+            project,
+            branch,
+            endpointId,
+            timeoutMs: ENDPOINT_READY_TIMEOUT_MS,
+            lastState: last?.status?.current_state ?? "unknown",
+        },
+    });
+}
+/**
+ * Pick the default branch for a project. Prefers the branch flagged
+ * `status.default: true` (server-side default, typically `production`
+ * unless the project owner changed it). Falls back to the only branch
+ * when there's exactly one. Otherwise throws with the candidate list.
+ */
+async function pickBranch(ws, project, signal) {
+    const branches = await listBranches(ws, project, signal);
+    if (branches.length === 0) {
+        throw ConfigurationError.resourceNotFound(`Lakebase branch in project '${project}'`, "The project has no branches; create one or set config.branch.");
+    }
+    const flagged = branches.find((b) => b.status?.default === true);
+    const choice = parseResourcePath(flagged?.name).branch ??
+        (branches.length === 1 ? parseResourcePath(branches[0].name).branch : undefined);
+    if (!choice) {
+        const candidates = branches
+            .map((b) => parseResourcePath(b.name).branch)
+            .filter((id) => Boolean(id))
+            .join(", ");
+        throw ConfigurationError.invalidConnection("Lakebase", `Project '${project}' has multiple branches and none marked default; set config.branch or include the branch in LAKEBASE_ENDPOINT. Candidates: ${candidates}`);
+    }
+    logger.debug("autopg: resolved branch", { project, branch: choice });
+    return choice;
+}
+/**
+ * Pick the primary endpoint for a (project, branch). Prefers
+ * `status.endpoint_type === ENDPOINT_TYPE_READ_WRITE`; falls back to
+ * the only endpoint when there's exactly one. Returns `{ name, host }`
+ * so the caller can populate both `LAKEBASE_ENDPOINT` and `PGHOST`
+ * from a single call.
+ */
+async function pickEndpoint(ws, project, branch, signal) {
+    const endpoints = await listEndpoints(ws, project, branch, signal);
+    if (endpoints.length === 0) {
+        throw ConfigurationError.resourceNotFound(`Lakebase endpoint in 'projects/${project}/branches/${branch}'`, "The branch has no endpoints; create one or set LAKEBASE_ENDPOINT.");
+    }
+    const primary = endpoints.find((e) => e.status?.endpoint_type === READ_WRITE_ENDPOINT_TYPE) ??
+        (endpoints.length === 1 ? endpoints[0] : undefined);
+    if (!primary?.name) {
+        const names = endpoints.map((e) => e.name).filter(Boolean);
+        throw ConfigurationError.invalidConnection("Lakebase", `Branch has no primary read-write endpoint; set LAKEBASE_ENDPOINT or config.endpoint. Candidates: ${names.join(", ")}`);
+    }
+    const host = primary.status?.hosts?.host;
+    logger.debug("autopg: resolved endpoint", { endpoint: primary.name, host });
+    return { name: primary.name, host };
+}
+/**
+ * Pick the default postgres database for a (project, branch). The
+ * Postgres database NAME (`status.postgres_database`) is what
+ * `PGDATABASE` needs - this differs from the resource id, which can
+ * use a different separator (e.g. resource `databricks-postgres`
+ * surfaces as database `databricks_postgres`). Prefers
+ * `databricks_postgres` (the Lakebase default), otherwise the only
+ * database.
+ */
+async function pickDatabase(ws, project, branch, signal) {
+    const databases = await listDatabases(ws, project, branch, signal);
+    if (databases.length === 0) {
+        throw ConfigurationError.resourceNotFound(`Lakebase database in 'projects/${project}/branches/${branch}'`, "The branch has no databases; create one or set PGDATABASE.");
+    }
+    const names = databases
+        .map((d) => d.status?.postgres_database)
+        .filter((n) => Boolean(n));
+    const choice = names.find((n) => n === DEFAULT_DATABASE) ?? (names.length === 1 ? names[0] : undefined);
+    if (!choice) {
+        throw ConfigurationError.invalidConnection("Lakebase", `Multiple databases and no '${DEFAULT_DATABASE}'; set PGDATABASE or config.database. Candidates: ${names.join(", ")}`);
+    }
+    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\";\n\nimport { MAX_TCP_PORT, toContext } from \"./databricks\";\nimport {\n  parseAddress,\n  parseResourcePath,\n  SSL_MODES,\n  type LakebaseConnectionInputs,\n  type SslMode,\n} from \"./pgaddress\";\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"]}