@dbx-tools/appkit 0.3.44 → 0.4.1

package/lib/src/config.js

@@ -0,0 +1,403 @@
+/**
+ * Layered configuration resolution for local development against a Databricks
+ * App / Asset Bundle.
+ *
+ * Default sources: `explicit`, then `env`, then Databricks App `config.env`
+ * (from {@link bundle}) and hard-coded `app.yaml` env entries (from
+ * {@link appYaml}). Opt in to `cli` when a dev command wants flag overrides.
+ *
+ * Server-only (`node:child_process`, bundle root discovery). Databricks-app
+ * specific, so it lives in node-appkit rather than shared-core.
+ *
+ * @module
+ */
+import { spawnSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { ValidationError } from "@databricks/appkit";
+import { file, project } from "@dbx-tools/core";
+import { functionModule, json, object, log, string } from "@dbx-tools/shared-core";
+import { parse as parseYamlText } from "yaml";
+import { z } from "zod";
+import { isAppEnv } from "./databricks.js";
+const logger = log.logger("config");
+const defaultConfigSources = ["explicit", "env", "bundle"];
+const APP_YAML_NAMES = ["app.yaml", "app.yml"];
+const bundleValidateCache = new Map();
+const normalizedString = z
+    .string()
+    .transform((value) => value.trim())
+    .pipe(z.string().min(1));
+const bundleAppEnvEntrySchema = z.object({
+    name: normalizedString.optional(),
+    value: z.string().optional(),
+    value_from: normalizedString.optional(),
+});
+const bundleAppResourceSchema = z.object({
+    name: normalizedString.optional(),
+    sql_warehouse: z.object({ id: normalizedString.optional() }).optional(),
+    genie_space: z.object({ space_id: normalizedString.optional() }).optional(),
+    postgres: z
+        .object({
+        database: normalizedString.optional(),
+        branch: normalizedString.optional(),
+        endpoint: normalizedString.optional(),
+    })
+        .optional(),
+});
+const bundleAppSchema = z.object({
+    name: normalizedString.optional(),
+    source_code_path: z.string().optional(),
+    config: z.object({ env: z.array(bundleAppEnvEntrySchema).optional() }).optional(),
+    resources: z.array(bundleAppResourceSchema).optional(),
+});
+const bundleValidateAppsSchema = z.object({
+    resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),
+});
+const appYamlEnvEntrySchema = z.object({
+    name: normalizedString,
+    value: z.string().optional(),
+    valueFrom: normalizedString.optional(),
+});
+const appYamlResourceSchema = z
+    .object({
+    name: normalizedString,
+    sql_warehouse: z.object({ id: normalizedString.optional() }).optional(),
+    genie_space: z.object({ space_id: normalizedString.optional() }).optional(),
+    postgres: z
+        .object({
+        database: normalizedString.optional(),
+        branch: normalizedString.optional(),
+        endpoint: normalizedString.optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+const appYamlSchema = z.object({
+    env: z.array(appYamlEnvEntrySchema).optional(),
+    resources: z.array(appYamlResourceSchema).optional(),
+});
+const bundleDefault = functionModule.memoize(() => loadBundle(process.cwd()));
+const appYamlDefault = functionModule.memoize(() => loadAppYaml(process.cwd()));
+function envKeysForName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return object.sequence();
+    }
+    const keys = (function* () {
+        const modifiers = [
+            null,
+            () => trimmed.toUpperCase(),
+            () => Array.from(string.tokenize(trimmed)).join("_").toUpperCase(),
+        ];
+        for (const modifier of modifiers) {
+            yield modifier ? modifier(trimmed) : trimmed;
+        }
+    })();
+    return object.sequence(keys).cache().filter(Boolean).distinct();
+}
+function readEnv(keys) {
+    for (const key of keys) {
+        const value = process.env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readConfigMapValue(value) {
+    if (value == null)
+        return undefined;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const trimmed = item?.trim();
+            if (trimmed)
+                return trimmed;
+        }
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function readMap(keys, map) {
+    if (!map)
+        return undefined;
+    for (const key of keys) {
+        const value = readConfigMapValue(map[key]);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readAppEnv(keys, envMap) {
+    for (const key of keys) {
+        const value = envMap[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function parseYaml(text) {
+    return parseYamlText(text);
+}
+function pickAppResourceId(apps) {
+    const keys = Object.keys(apps);
+    return keys.length === 1 ? keys[0] : undefined;
+}
+/**
+ * Resolve the effective value a `value_from`/`valueFrom` entry points at:
+ * the first present of the warehouse id, Genie space id, or Postgres
+ * endpoint/database/branch on the named resource. Shared by both the
+ * `app.yaml` and `bundle validate` flatteners, whose resource shapes match.
+ */
+function resolveResourceValue(resource) {
+    return (resource?.sql_warehouse?.id ??
+        resource?.genie_space?.space_id ??
+        resource?.postgres?.endpoint ??
+        resource?.postgres?.database ??
+        resource?.postgres?.branch);
+}
+/**
+ * Flatten `env` entries from parsed `app.yaml` content. Literal `value` entries
+ * are returned as-is; `valueFrom` entries resolve against the sibling
+ * `resources` array when possible.
+ */
+export function flattenAppYamlEnv(data) {
+    const parsed = appYamlSchema.safeParse(data);
+    if (!parsed.success || !parsed.data.env?.length) {
+        return {};
+    }
+    const resourceByName = new Map((parsed.data.resources ?? []).map((resource) => [resource.name, resource]));
+    const out = {};
+    for (const entry of parsed.data.env) {
+        if (entry.value?.trim()) {
+            out[entry.name] = entry.value.trim();
+            continue;
+        }
+        if (!entry.valueFrom)
+            continue;
+        const resolved = resolveResourceValue(resourceByName.get(entry.valueFrom));
+        if (resolved)
+            out[entry.name] = resolved;
+    }
+    return out;
+}
+/**
+ * Flatten `resources.apps.<key>.config.env` into a `name -> value` map.
+ * Auto-picks the app only when the bundle defines exactly one.
+ */
+export function flattenAppEnv(data) {
+    const parsed = bundleValidateAppsSchema.safeParse(data);
+    if (!parsed.success)
+        return {};
+    const apps = parsed.data.resources?.apps;
+    if (!apps || Object.keys(apps).length === 0)
+        return {};
+    const key = pickAppResourceId(apps);
+    if (!key)
+        return {};
+    const app = apps[key];
+    if (!app?.config?.env?.length)
+        return {};
+    const resourceByName = new Map((app.resources ?? [])
+        .filter((resource) => resource.name)
+        .map((resource) => [resource.name, resource]));
+    const out = {};
+    for (const entry of app.config.env) {
+        if (!entry.name)
+            continue;
+        if (entry.value) {
+            out[entry.name] = entry.value;
+            continue;
+        }
+        if (!entry.value_from)
+            continue;
+        const resolved = resolveResourceValue(resourceByName.get(entry.value_from));
+        if (resolved)
+            out[entry.name] = resolved;
+    }
+    return out;
+}
+function validateBundle(root) {
+    const key = root;
+    if (bundleValidateCache.has(key)) {
+        return bundleValidateCache.get(key);
+    }
+    const args = ["bundle", "validate", "--output", "json"];
+    try {
+        const proc = spawnSync("databricks", args, {
+            cwd: root,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const text = proc.stdout?.trim();
+        if (!text) {
+            bundleValidateCache.set(key, undefined);
+            return undefined;
+        }
+        const data = json.parse(text);
+        bundleValidateCache.set(key, data);
+        return data;
+    }
+    catch {
+        bundleValidateCache.set(key, undefined);
+        return undefined;
+    }
+}
+async function loadBundle(cwd) {
+    const configFile = resolveConfigFile(cwd, "databricks.yml");
+    if (configFile) {
+        const data = validateBundle(dirname(configFile));
+        if (data)
+            return { path: configFile, data };
+    }
+    return undefined;
+}
+async function loadAppYaml(cwd) {
+    for (const fileName of APP_YAML_NAMES) {
+        const configFile = resolveConfigFile(cwd, fileName);
+        if (!configFile)
+            continue;
+        try {
+            const text = await readFile(configFile, "utf8");
+            const data = parseYaml(text);
+            if (!object.isRecord(data)) {
+                return undefined;
+            }
+            return { path: configFile, data };
+        }
+        catch {
+            logger.warn("failed to parse app yaml", { path: configFile });
+        }
+    }
+    return undefined;
+}
+function resolveConfigFile(cwd, configFile) {
+    if (isAppEnv())
+        return undefined;
+    for (const rootDir of project.resolveProjectRoots(cwd)) {
+        const bundlePath = resolve(rootDir, configFile);
+        if (file.statSync(bundlePath)?.isFile())
+            return bundlePath;
+    }
+    return undefined;
+}
+/**
+ * Locate the bundle root and run `databricks bundle validate --output json`.
+ * When `cwd` is omitted or equals `process.cwd()`, the result is memoized for
+ * the process lifetime. Returns `undefined` inside a Databricks App.
+ */
+export function bundle(cwd) {
+    if (isAppEnv())
+        return Promise.resolve(undefined);
+    return cwd && resolve(cwd) !== process.cwd() ? loadBundle(cwd) : bundleDefault();
+}
+/**
+ * Locate and parse `app.yaml` / `app.yml` from the bundle or project root. When
+ * `cwd` is omitted or equals `process.cwd()`, the result is memoized for the
+ * process lifetime. Returns `undefined` inside a Databricks App.
+ */
+export function appYaml(cwd) {
+    if (isAppEnv())
+        return Promise.resolve(undefined);
+    return cwd && resolve(cwd) !== process.cwd() ? loadAppYaml(cwd) : appYamlDefault();
+}
+/**
+ * Walk a dot-separated path through bundle validate JSON. When the terminal
+ * node is a bundle variable object (`{ value: "..." }`), the `value` field is
+ * returned.
+ */
+export function getBundlePath(data, path) {
+    const parts = path.split(".").filter(Boolean);
+    if (parts.length === 0)
+        return undefined;
+    let current = data;
+    for (let i = 0; i < parts.length; i++) {
+        if (!object.isRecord(current))
+            return undefined;
+        const part = parts[i];
+        const next = current[part];
+        if (i === parts.length - 1) {
+            if (typeof next === "string" && next)
+                return next;
+            if (object.isRecord(next)) {
+                const value = next.value;
+                return typeof value === "string" && value ? value : undefined;
+            }
+            return undefined;
+        }
+        current = next;
+    }
+    return undefined;
+}
+async function resolveAppEnvMap(options) {
+    const appData = options.appData ?? (await appYaml());
+    const bundleData = options.bundleData ?? (await bundle());
+    const fromYaml = appData ? flattenAppYamlEnv(appData.data) : {};
+    const fromBundle = bundleData ? flattenAppEnv(bundleData.data) : {};
+    return { ...fromYaml, ...fromBundle };
+}
+function resolveSources(options) {
+    const sources = [...(options.sources ?? defaultConfigSources)];
+    if (options.explicit !== undefined && !sources.includes("explicit")) {
+        sources.unshift("explicit");
+    }
+    return sources;
+}
+/**
+ * Resolve a configuration string from the configured sources. Returns the first
+ * non-empty value, or `undefined` when nothing matches.
+ *
+ * Precedence follows AppKit's: explicit config, then environment variable, then
+ * whatever the Databricks App / bundle definition supplies.
+ *
+ * @example
+ * import { config } from "@dbx-tools/appkit";
+ *
+ * const warehouseId = await config.resolveConfigValue("DATABRICKS_WAREHOUSE_ID", {
+ *   cli: { DATABRICKS_WAREHOUSE_ID: flags.warehouse },
+ *   sources: config.withCliSources(),
+ * });
+ */
+export async function resolveConfigValue(name, options = {}) {
+    const keys = envKeysForName(name).toArray();
+    if (keys.length === 0)
+        return undefined;
+    const sources = resolveSources(options);
+    let appEnvMap;
+    const values = (async function* () {
+        for (const source of sources) {
+            switch (source) {
+                case "explicit":
+                    yield readMap(keys, options.explicit);
+                    break;
+                case "cli":
+                    yield readMap(keys, options.cli);
+                    break;
+                case "env":
+                    yield readEnv(keys);
+                    break;
+                case "bundle":
+                    if (appEnvMap === undefined)
+                        appEnvMap = await resolveAppEnvMap(options);
+                    yield readAppEnv(keys, appEnvMap);
+                    break;
+                default:
+                    throw ValidationError.invalidValue("sources", source, "one of: explicit, cli, env, bundle");
+            }
+        }
+    })();
+    for await (const value of values) {
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * Sources with `cli` included, in CLI-first order. Use for dev commands that
+ * accept flag overrides.
+ */
+export function withCliSources(sources = defaultConfigSources) {
+    const rest = sources.filter((source) => source !== "cli" && source !== "explicit");
+    return ["cli", "explicit", ...rest];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Layered configuration resolution for local development against a Databricks\n * App / Asset Bundle.\n *\n * Default sources: `explicit`, then `env`, then Databricks App `config.env`\n * (from {@link bundle}) and hard-coded `app.yaml` env entries (from\n * {@link appYaml}). Opt in to `cli` when a dev command wants flag overrides.\n *\n * Server-only (`node:child_process`, bundle root discovery). Databricks-app\n * specific, so it lives in node-appkit rather than shared-core.\n *\n * @module\n */\n\nimport { spawnSync } from \"node:child_process\";\nimport { readFile } from \"node:fs/promises\";\nimport { dirname, resolve } from \"node:path\";\nimport { ValidationError } from \"@databricks/appkit\";\nimport { file, project } from \"@dbx-tools/core\";\nimport { functionModule, json, object, log, string } from \"@dbx-tools/shared-core\";\nimport { parse as parseYamlText } from \"yaml\";\nimport { z } from \"zod\";\n\nimport { isAppEnv } from \"./databricks\";\n\nconst logger = log.logger(\"config\");\n\n/** Parsed payload from `databricks bundle validate --output json`. */\nexport type BundleValidateJson = Record<string, unknown>;\n\n/** A config file discovered on disk with its parsed contents. */\nexport interface ConfigFile {\n  path: string;\n  data: Record<string, unknown>;\n}\n\n/** Supported configuration sources, consulted in array order. */\nexport type ConfigSource = \"explicit\" | \"cli\" | \"env\" | \"bundle\";\n\nconst defaultConfigSources: ConfigSource[] = [\"explicit\", \"env\", \"bundle\"];\n\nconst APP_YAML_NAMES = [\"app.yaml\", \"app.yml\"] as const;\n\nconst bundleValidateCache = new Map<string, BundleValidateJson | undefined>();\n\nconst normalizedString = z\n  .string()\n  .transform((value) => value.trim())\n  .pipe(z.string().min(1));\n\nconst bundleAppEnvEntrySchema = z.object({\n  name: normalizedString.optional(),\n  value: z.string().optional(),\n  value_from: normalizedString.optional(),\n});\n\nconst bundleAppResourceSchema = z.object({\n  name: normalizedString.optional(),\n  sql_warehouse: z.object({ id: normalizedString.optional() }).optional(),\n  genie_space: z.object({ space_id: normalizedString.optional() }).optional(),\n  postgres: z\n    .object({\n      database: normalizedString.optional(),\n      branch: normalizedString.optional(),\n      endpoint: normalizedString.optional(),\n    })\n    .optional(),\n});\n\nconst bundleAppSchema = z.object({\n  name: normalizedString.optional(),\n  source_code_path: z.string().optional(),\n  config: z.object({ env: z.array(bundleAppEnvEntrySchema).optional() }).optional(),\n  resources: z.array(bundleAppResourceSchema).optional(),\n});\n\nconst bundleValidateAppsSchema = z.object({\n  resources: z.object({ apps: z.record(z.string(), bundleAppSchema).optional() }).optional(),\n});\n\nconst appYamlEnvEntrySchema = z.object({\n  name: normalizedString,\n  value: z.string().optional(),\n  valueFrom: normalizedString.optional(),\n});\n\nconst appYamlResourceSchema = z\n  .object({\n    name: normalizedString,\n    sql_warehouse: z.object({ id: normalizedString.optional() }).optional(),\n    genie_space: z.object({ space_id: normalizedString.optional() }).optional(),\n    postgres: z\n      .object({\n        database: normalizedString.optional(),\n        branch: normalizedString.optional(),\n        endpoint: normalizedString.optional(),\n      })\n      .optional(),\n  })\n  .passthrough();\n\nconst appYamlSchema = z.object({\n  env: z.array(appYamlEnvEntrySchema).optional(),\n  resources: z.array(appYamlResourceSchema).optional(),\n});\n\ntype BundleApp = z.infer<typeof bundleAppSchema>;\n\n/** Single config map entry (string or repeated values, like headers). */\nexport type ConfigMapValue = string | string[] | undefined;\n\nexport interface ResolveConfigValueOptions {\n  /** Bundle validate JSON. Defaults to {@link bundle} (skipped inside a Databricks App). */\n  bundleData?: ConfigFile;\n  /** Parsed `app.yaml` contents. Defaults to {@link appYaml} (skipped inside a Databricks App). */\n  appData?: ConfigFile;\n  /**\n   * Sources to consult, first truthy string wins. Defaults to `explicit`, then\n   * `env`, then `bundle`.\n   */\n  sources?: ConfigSource[];\n  /** Programmatic overrides. When set, `explicit` is prepended to `sources` unless already listed. */\n  explicit?: Record<string, ConfigMapValue>;\n  /** CLI flag values (when `cli` is listed in `sources`). */\n  cli?: Record<string, ConfigMapValue>;\n}\n\nconst bundleDefault = functionModule.memoize(() => loadBundle(process.cwd()));\nconst appYamlDefault = functionModule.memoize(() => loadAppYaml(process.cwd()));\n\nfunction envKeysForName(name: string): object.Sequence<string> {\n  const trimmed = name.trim();\n  if (!trimmed) {\n    return object.sequence();\n  }\n  const keys = (function* () {\n    const modifiers: (((value: string) => string) | null)[] = [\n      null,\n      () => trimmed.toUpperCase(),\n      () => Array.from(string.tokenize(trimmed)).join(\"_\").toUpperCase(),\n    ];\n    for (const modifier of modifiers) {\n      yield modifier ? modifier(trimmed) : trimmed;\n    }\n  })();\n  return object.sequence(keys).cache().filter(Boolean).distinct();\n}\n\nfunction readEnv(keys: Iterable<string>): string | undefined {\n  for (const key of keys) {\n    const value = process.env[key]?.trim();\n    if (value) return value;\n  }\n  return undefined;\n}\n\nfunction readConfigMapValue(value: ConfigMapValue): string | undefined {\n  if (value == null) return undefined;\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      const trimmed = item?.trim();\n      if (trimmed) return trimmed;\n    }\n    return undefined;\n  }\n  const trimmed = value.trim();\n  return trimmed || undefined;\n}\n\nfunction readMap(\n  keys: Iterable<string>,\n  map: Record<string, ConfigMapValue> | undefined,\n): string | undefined {\n  if (!map) return undefined;\n  for (const key of keys) {\n    const value = readConfigMapValue(map[key]);\n    if (value) return value;\n  }\n  return undefined;\n}\n\nfunction readAppEnv(keys: Iterable<string>, envMap: Record<string, string>): string | undefined {\n  for (const key of keys) {\n    const value = envMap[key]?.trim();\n    if (value) return value;\n  }\n  return undefined;\n}\n\nfunction parseYaml(text: string): unknown {\n  return parseYamlText(text);\n}\n\nfunction pickAppResourceId(apps: Record<string, BundleApp>): string | undefined {\n  const keys = Object.keys(apps);\n  return keys.length === 1 ? keys[0] : undefined;\n}\n\n/**\n * Resolve the effective value a `value_from`/`valueFrom` entry points at:\n * the first present of the warehouse id, Genie space id, or Postgres\n * endpoint/database/branch on the named resource. Shared by both the\n * `app.yaml` and `bundle validate` flatteners, whose resource shapes match.\n */\nfunction resolveResourceValue(\n  resource: z.infer<typeof bundleAppResourceSchema> | undefined,\n): string | undefined {\n  return (\n    resource?.sql_warehouse?.id ??\n    resource?.genie_space?.space_id ??\n    resource?.postgres?.endpoint ??\n    resource?.postgres?.database ??\n    resource?.postgres?.branch\n  );\n}\n\n/**\n * Flatten `env` entries from parsed `app.yaml` content. Literal `value` entries\n * are returned as-is; `valueFrom` entries resolve against the sibling\n * `resources` array when possible.\n */\nexport function flattenAppYamlEnv(data: unknown): Record<string, string> {\n  const parsed = appYamlSchema.safeParse(data);\n  if (!parsed.success || !parsed.data.env?.length) {\n    return {};\n  }\n\n  const resourceByName = new Map(\n    (parsed.data.resources ?? []).map((resource) => [resource.name, resource]),\n  );\n\n  const out: Record<string, string> = {};\n  for (const entry of parsed.data.env) {\n    if (entry.value?.trim()) {\n      out[entry.name] = entry.value.trim();\n      continue;\n    }\n    if (!entry.valueFrom) continue;\n    const resolved = resolveResourceValue(resourceByName.get(entry.valueFrom));\n    if (resolved) out[entry.name] = resolved;\n  }\n  return out;\n}\n\n/**\n * Flatten `resources.apps.<key>.config.env` into a `name -> value` map.\n * Auto-picks the app only when the bundle defines exactly one.\n */\nexport function flattenAppEnv(data: unknown): Record<string, string> {\n  const parsed = bundleValidateAppsSchema.safeParse(data);\n  if (!parsed.success) return {};\n\n  const apps = parsed.data.resources?.apps;\n  if (!apps || Object.keys(apps).length === 0) return {};\n\n  const key = pickAppResourceId(apps);\n  if (!key) return {};\n\n  const app = apps[key];\n  if (!app?.config?.env?.length) return {};\n\n  const resourceByName = new Map(\n    (app.resources ?? [])\n      .filter((resource) => resource.name)\n      .map((resource) => [resource.name!, resource]),\n  );\n\n  const out: Record<string, string> = {};\n  for (const entry of app.config.env) {\n    if (!entry.name) continue;\n    if (entry.value) {\n      out[entry.name] = entry.value;\n      continue;\n    }\n    if (!entry.value_from) continue;\n    const resolved = resolveResourceValue(resourceByName.get(entry.value_from));\n    if (resolved) out[entry.name] = resolved;\n  }\n  return out;\n}\n\nfunction validateBundle(root: string): BundleValidateJson | undefined {\n  const key = root;\n  if (bundleValidateCache.has(key)) {\n    return bundleValidateCache.get(key);\n  }\n\n  const args = [\"bundle\", \"validate\", \"--output\", \"json\"];\n  try {\n    const proc = spawnSync(\"databricks\", args, {\n      cwd: root,\n      encoding: \"utf8\",\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n    });\n    const text = proc.stdout?.trim();\n    if (!text) {\n      bundleValidateCache.set(key, undefined);\n      return undefined;\n    }\n    const data = json.parse<BundleValidateJson>(text);\n    bundleValidateCache.set(key, data);\n    return data;\n  } catch {\n    bundleValidateCache.set(key, undefined);\n    return undefined;\n  }\n}\n\nasync function loadBundle(cwd: string): Promise<ConfigFile | undefined> {\n  const configFile = resolveConfigFile(cwd, \"databricks.yml\");\n  if (configFile) {\n    const data = validateBundle(dirname(configFile));\n    if (data) return { path: configFile, data };\n  }\n  return undefined;\n}\n\nasync function loadAppYaml(cwd: string): Promise<ConfigFile | undefined> {\n  for (const fileName of APP_YAML_NAMES) {\n    const configFile = resolveConfigFile(cwd, fileName);\n    if (!configFile) continue;\n    try {\n      const text = await readFile(configFile, \"utf8\");\n      const data = parseYaml(text);\n      if (!object.isRecord(data)) {\n        return undefined;\n      }\n      return { path: configFile, data };\n    } catch {\n      logger.warn(\"failed to parse app yaml\", { path: configFile });\n    }\n  }\n  return undefined;\n}\n\nfunction resolveConfigFile(cwd: string, configFile: string): string | undefined {\n  if (isAppEnv()) return undefined;\n  for (const rootDir of project.resolveProjectRoots(cwd)) {\n    const bundlePath = resolve(rootDir, configFile);\n    if (file.statSync(bundlePath)?.isFile()) return bundlePath;\n  }\n  return undefined;\n}\n\n/**\n * Locate the bundle root and run `databricks bundle validate --output json`.\n * When `cwd` is omitted or equals `process.cwd()`, the result is memoized for\n * the process lifetime. Returns `undefined` inside a Databricks App.\n */\nexport function bundle(cwd?: string): Promise<ConfigFile | undefined> {\n  if (isAppEnv()) return Promise.resolve(undefined);\n  return cwd && resolve(cwd) !== process.cwd() ? loadBundle(cwd) : bundleDefault();\n}\n\n/**\n * Locate and parse `app.yaml` / `app.yml` from the bundle or project root. When\n * `cwd` is omitted or equals `process.cwd()`, the result is memoized for the\n * process lifetime. Returns `undefined` inside a Databricks App.\n */\nexport function appYaml(cwd?: string): Promise<ConfigFile | undefined> {\n  if (isAppEnv()) return Promise.resolve(undefined);\n  return cwd && resolve(cwd) !== process.cwd() ? loadAppYaml(cwd) : appYamlDefault();\n}\n\n/**\n * Walk a dot-separated path through bundle validate JSON. When the terminal\n * node is a bundle variable object (`{ value: \"...\" }`), the `value` field is\n * returned.\n */\nexport function getBundlePath(data: BundleValidateJson, path: string): string | undefined {\n  const parts = path.split(\".\").filter(Boolean);\n  if (parts.length === 0) return undefined;\n\n  let current: unknown = data;\n  for (let i = 0; i < parts.length; i++) {\n    if (!object.isRecord(current)) return undefined;\n    const part = parts[i]!;\n    const next = current[part];\n    if (i === parts.length - 1) {\n      if (typeof next === \"string\" && next) return next;\n      if (object.isRecord(next)) {\n        const value = next.value;\n        return typeof value === \"string\" && value ? value : undefined;\n      }\n      return undefined;\n    }\n    current = next;\n  }\n  return undefined;\n}\n\nasync function resolveAppEnvMap(\n  options: ResolveConfigValueOptions,\n): Promise<Record<string, string>> {\n  const appData = options.appData ?? (await appYaml());\n  const bundleData = options.bundleData ?? (await bundle());\n  const fromYaml = appData ? flattenAppYamlEnv(appData.data) : {};\n  const fromBundle = bundleData ? flattenAppEnv(bundleData.data) : {};\n  return { ...fromYaml, ...fromBundle };\n}\n\nfunction resolveSources(options: ResolveConfigValueOptions): ConfigSource[] {\n  const sources = [...(options.sources ?? defaultConfigSources)];\n  if (options.explicit !== undefined && !sources.includes(\"explicit\")) {\n    sources.unshift(\"explicit\");\n  }\n  return sources;\n}\n\n/**\n * Resolve a configuration string from the configured sources. Returns the first\n * non-empty value, or `undefined` when nothing matches.\n *\n * Precedence follows AppKit's: explicit config, then environment variable, then\n * whatever the Databricks App / bundle definition supplies.\n *\n * @example\n * import { config } from \"@dbx-tools/appkit\";\n *\n * const warehouseId = await config.resolveConfigValue(\"DATABRICKS_WAREHOUSE_ID\", {\n *   cli: { DATABRICKS_WAREHOUSE_ID: flags.warehouse },\n *   sources: config.withCliSources(),\n * });\n */\nexport async function resolveConfigValue(\n  name: string,\n  options: ResolveConfigValueOptions = {},\n): Promise<string | undefined> {\n  const keys = envKeysForName(name).toArray();\n  if (keys.length === 0) return undefined;\n  const sources = resolveSources(options);\n  let appEnvMap: Record<string, string> | undefined;\n  const values = (async function* () {\n    for (const source of sources) {\n      switch (source) {\n        case \"explicit\":\n          yield readMap(keys, options.explicit);\n          break;\n        case \"cli\":\n          yield readMap(keys, options.cli);\n          break;\n        case \"env\":\n          yield readEnv(keys);\n          break;\n        case \"bundle\":\n          if (appEnvMap === undefined) appEnvMap = await resolveAppEnvMap(options);\n          yield readAppEnv(keys, appEnvMap);\n          break;\n        default:\n          throw ValidationError.invalidValue(\n            \"sources\",\n            source,\n            \"one of: explicit, cli, env, bundle\",\n          );\n      }\n    }\n  })();\n  for await (const value of values) {\n    if (value) return value;\n  }\n  return undefined;\n}\n\n/**\n * Sources with `cli` included, in CLI-first order. Use for dev commands that\n * accept flag overrides.\n */\nexport function withCliSources(sources: ConfigSource[] = defaultConfigSources): ConfigSource[] {\n  const rest = sources.filter((source) => source !== \"cli\" && source !== \"explicit\");\n  return [\"cli\", \"explicit\", ...rest];\n}\n"]}

package/lib/src/create-app.d.ts

@@ -0,0 +1,72 @@
+/**
+ * `createApp` wrapper: runs dbx-tools auto-configuration, then delegates to
+ * AppKit's own `createApp` with the exact same arguments.
+ *
+ * Drop it in as a one-for-one replacement for `@databricks/appkit`'s
+ * `createApp` - same parameters, same return type, full plugin-export inference
+ * preserved:
+ *
+ * ```ts
+ * import { createApp } from "@dbx-tools/appkit";
+ * import { lakebase, server } from "@databricks/appkit";
+ *
+ * await createApp.createApp({ plugins: [server(), lakebase()] });
+ * ```
+ *
+ * Auto-configuration runs BEFORE delegating so plugins see a fully populated
+ * `process.env` during their synchronous `setup()`. Lakebase Postgres runs when
+ * a `lakebase` plugin is present, or when {@link AutoConfigureMode} is set
+ * explicitly on the config object.
+ *
+ * @module
+ */
+import { createApp as appkitCreateApp } from "@databricks/appkit";
+import type { PluginMap } from "@databricks/appkit/dist/shared/src/plugin";
+type AppKitCreateAppConfig = NonNullable<Parameters<typeof appkitCreateApp>[0]>;
+type AppKitPlugins = NonNullable<AppKitCreateAppConfig["plugins"]>;
+/**
+ * What auto-configuration does before AppKit boots.
+ *
+ * - `"provision"`: resolve the Lakebase connection into `process.env`, then
+ *   grant the AppKit cache schema to the connecting role.
+ * - `"env"`: resolve the Lakebase connection into `process.env` only.
+ *
+ * Omit it to get `"provision"` gated on a `lakebase` plugin being registered;
+ * set it explicitly to run regardless of the plugin list, or pass `false` to
+ * skip auto-configuration entirely.
+ */
+export type AutoConfigureMode = "env" | "provision";
+/** AppKit's `createApp` config plus the dbx-tools auto-configuration switch. */
+export type CreateAppConfig<T extends AppKitPlugins = AppKitPlugins> = Omit<AppKitCreateAppConfig, "plugins" | "onPluginsReady"> & {
+    plugins?: T;
+    onPluginsReady?: (appkit: PluginMap<T>) => void | Promise<void>;
+    /** Auto-configuration to run before AppKit boots. Defaults to `"provision"`. */
+    autoConfigure?: AutoConfigureMode | false;
+};
+/**
+ * Run enabled auto-configuration steps without calling AppKit's `createApp`.
+ *
+ * Lakebase Postgres resolves when {@link CreateAppConfig.autoConfigure} is set
+ * explicitly or a `lakebase` plugin is listed in `config.plugins`. `signal`
+ * cancels the resolution; it is combined with an internal boot timeout either
+ * way.
+ *
+ * @example
+ * import { createApp } from "@dbx-tools/appkit";
+ *
+ * // Populate PGHOST / PGDATABASE / LAKEBASE_ENDPOINT without booting AppKit.
+ * await createApp.autoConfigure({ autoConfigure: "env" });
+ */
+export declare function autoConfigure<T extends AppKitPlugins>(config?: CreateAppConfig<T>, signal?: AbortSignal): Promise<void>;
+/**
+ * Auto-configuring drop-in for AppKit's `createApp`: same config, same typed
+ * plugin-export map, with {@link autoConfigure} run first.
+ *
+ * @example
+ * import { createApp } from "@dbx-tools/appkit";
+ * import { lakebase, server } from "@databricks/appkit";
+ *
+ * const app = await createApp.createApp({ plugins: [server(), lakebase()] });
+ */
+export declare function createApp<T extends AppKitPlugins>(config?: CreateAppConfig<T>): Promise<PluginMap<T>>;
+export {};