@dbx-tools/appkit 0.3.44 → 0.4.1

package/lib/src/pgaddress.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Flexible address parser for Lakebase Postgres connection inputs.
+ *
+ * Accepts whatever shape a user is likely to paste into
+ * `LAKEBASE_ENDPOINT` (or the matching config field) and extracts
+ * every recognizable piece. Whatever it can't recover is left for the
+ * Lakebase resolver to discover.
+ *
+ * Recognized formats:
+ *
+ * - **Postgres URI** -
+ *   `postgresql://user@host:port/db?sslmode=require` (also `postgres://`).
+ *   Yields `user`, `host`, `port`, `database`, `sslMode`.
+ *
+ * - **Canonical endpoint resource path** -
+ *   `projects/{p}/branches/{b}/endpoints/{e}` -
+ *   yields `project`, `branch`, `endpointId`, and the original string as
+ *   `endpoint` (already in lakebase's expected form).
+ *
+ * - **Database resource path** -
+ *   `projects/{p}/branches/{b}/databases/{d}` -
+ *   yields `project`, `branch`, and `databaseResourceId` (the UC
+ *   resource leaf, not `PGDATABASE`; the resolver looks up the real
+ *   Postgres name via REST).
+ *
+ * - **Branch resource path** -
+ *   `projects/{p}/branches/{b}` - yields `project`, `branch`.
+ *
+ * - **Project resource path** -
+ *   `projects/{p}` - yields `project`.
+ *
+ * - **Bare hostname** -
+ *   `ep-steep-forest-e199v43w.database.eastus2.azuredatabricks.net` -
+ *   yields `host` only; the resolver reverse-looks up the owning
+ *   endpoint to recover the resource path.
+ *
+ * - **Bare project id** -
+ *   `dbx-tools-demo` (1-63 chars, lowercase letters/digits/hyphens) -
+ *   yields `project`.
+ *
+ * Returns an empty object for inputs it doesn't recognize.
+ *
+ * @module
+ */
+/** Postgres TLS modes accepted by {@link SslMode}, in `PGSSLMODE` spelling. */
+export declare const SSL_MODES: readonly ["require", "disable", "prefer"];
+/** Postgres TLS mode passed through to `pg`. */
+export type SslMode = (typeof SSL_MODES)[number];
+/**
+ * Optional Lakebase Postgres connection fields shared by parsed addresses,
+ * resolver/env inputs, and resolved connections.
+ */
+export interface LakebaseConnectionInputs {
+    /** Lakebase project id. Resolved from the workspace when unset. */
+    project?: string;
+    /** Branch id within the project. Defaults to the project's default branch. */
+    branch?: string;
+    /**
+     * Canonical endpoint resource path (`projects/.../endpoints/...`), from
+     * `LAKEBASE_ENDPOINT`. Defaults to the branch's read-write endpoint.
+     */
+    endpoint?: string;
+    /** Postgres database name (`PGDATABASE`). Defaults to `databricks_postgres`. */
+    database?: string;
+    /** Postgres hostname (`PGHOST`). Defaults to the resolved endpoint's host. */
+    host?: string;
+    /** Postgres port (`PGPORT`). Defaults to 5432. */
+    port?: number;
+    /** Postgres TLS mode (`PGSSLMODE`). Defaults to `require`. */
+    sslMode?: SslMode;
+}
+/** Pieces recovered from parsing a single address or resource-path input. */
+export interface ParsedAddress extends LakebaseConnectionInputs {
+    /** Endpoint leaf id (last segment of an endpoint resource path). */
+    endpointId?: string;
+    /**
+     * Database resource id leaf from a `.../databases/{id}` path. Not the
+     * Postgres database name.
+     */
+    databaseResourceId?: string;
+    /** Postgres user (URI-decoded if encoded). */
+    user?: string;
+}
+/**
+ * Parse a Lakebase connection input into whatever pieces it carries.
+ * See module docstring for the supported formats. Returns `{}` for
+ * `undefined`, empty strings, and unrecognized inputs.
+ *
+ * @example
+ * import { pgaddress } from "@dbx-tools/appkit";
+ *
+ * pgaddress.parseAddress("projects/demo/branches/production/endpoints/ep-1");
+ * // { project: "demo", branch: "production", endpointId: "ep-1", endpoint: "projects/..." }
+ *
+ * pgaddress.parseAddress("postgresql://me@ep-1.database.azuredatabricks.net/app?sslmode=require");
+ * // { host: "ep-1.database.azuredatabricks.net", user: "me", database: "app", sslMode: "require" }
+ */
+export declare function parseAddress(input: string | undefined | null): ParsedAddress;
+/**
+ * Parse a Lakebase `projects/...` resource path. Returns `{}` when the
+ * input is not a resource path (so bare branch ids are not mistaken for
+ * project ids).
+ */
+export declare function parseResourcePath(input: string | undefined | null): ParsedAddress;

package/lib/src/pgaddress.js

@@ -0,0 +1,171 @@
+/**
+ * Flexible address parser for Lakebase Postgres connection inputs.
+ *
+ * Accepts whatever shape a user is likely to paste into
+ * `LAKEBASE_ENDPOINT` (or the matching config field) and extracts
+ * every recognizable piece. Whatever it can't recover is left for the
+ * Lakebase resolver to discover.
+ *
+ * Recognized formats:
+ *
+ * - **Postgres URI** -
+ *   `postgresql://user@host:port/db?sslmode=require` (also `postgres://`).
+ *   Yields `user`, `host`, `port`, `database`, `sslMode`.
+ *
+ * - **Canonical endpoint resource path** -
+ *   `projects/{p}/branches/{b}/endpoints/{e}` -
+ *   yields `project`, `branch`, `endpointId`, and the original string as
+ *   `endpoint` (already in lakebase's expected form).
+ *
+ * - **Database resource path** -
+ *   `projects/{p}/branches/{b}/databases/{d}` -
+ *   yields `project`, `branch`, and `databaseResourceId` (the UC
+ *   resource leaf, not `PGDATABASE`; the resolver looks up the real
+ *   Postgres name via REST).
+ *
+ * - **Branch resource path** -
+ *   `projects/{p}/branches/{b}` - yields `project`, `branch`.
+ *
+ * - **Project resource path** -
+ *   `projects/{p}` - yields `project`.
+ *
+ * - **Bare hostname** -
+ *   `ep-steep-forest-e199v43w.database.eastus2.azuredatabricks.net` -
+ *   yields `host` only; the resolver reverse-looks up the owning
+ *   endpoint to recover the resource path.
+ *
+ * - **Bare project id** -
+ *   `dbx-tools-demo` (1-63 chars, lowercase letters/digits/hyphens) -
+ *   yields `project`.
+ *
+ * Returns an empty object for inputs it doesn't recognize.
+ *
+ * @module
+ */
+/** Postgres TLS modes accepted by {@link SslMode}, in `PGSSLMODE` spelling. */
+export const SSL_MODES = ["require", "disable", "prefer"];
+const URL_SCHEME_RE = /^(postgres|postgresql):\/\//i;
+const PROJECT_ID_RE = /^[a-z][a-z0-9-]{0,61}[a-z0-9]$|^[a-z]$/;
+const HOSTNAME_HINT_RE = /^[a-z0-9][a-z0-9-]*(\.[a-z0-9][a-z0-9-]*)+$/i;
+/**
+ * Parse a Lakebase connection input into whatever pieces it carries.
+ * See module docstring for the supported formats. Returns `{}` for
+ * `undefined`, empty strings, and unrecognized inputs.
+ *
+ * @example
+ * import { pgaddress } from "@dbx-tools/appkit";
+ *
+ * pgaddress.parseAddress("projects/demo/branches/production/endpoints/ep-1");
+ * // { project: "demo", branch: "production", endpointId: "ep-1", endpoint: "projects/..." }
+ *
+ * pgaddress.parseAddress("postgresql://me@ep-1.database.azuredatabricks.net/app?sslmode=require");
+ * // { host: "ep-1.database.azuredatabricks.net", user: "me", database: "app", sslMode: "require" }
+ */
+export function parseAddress(input) {
+    if (!input)
+        return {};
+    const s = input.trim();
+    if (!s)
+        return {};
+    if (URL_SCHEME_RE.test(s))
+        return parseUri(s);
+    if (s.startsWith("projects/"))
+        return parseResourcePathSegments(s);
+    // Resource ids never contain dots; a dotted input must be a hostname.
+    if (HOSTNAME_HINT_RE.test(s) && s.includes("."))
+        return { host: s };
+    if (PROJECT_ID_RE.test(s))
+        return { project: s };
+    return {};
+}
+/**
+ * Parse a Lakebase `projects/...` resource path. Returns `{}` when the
+ * input is not a resource path (so bare branch ids are not mistaken for
+ * project ids).
+ */
+export function parseResourcePath(input) {
+    if (!input)
+        return {};
+    const s = input.trim();
+    if (!s.startsWith("projects/"))
+        return {};
+    return parseResourcePathSegments(s);
+}
+function parseUri(s) {
+    let url;
+    try {
+        url = new URL(s);
+    }
+    catch {
+        return {};
+    }
+    const result = {};
+    if (url.hostname)
+        result.host = url.hostname;
+    if (url.port) {
+        const port = Number.parseInt(url.port, 10);
+        if (!Number.isNaN(port))
+            result.port = port;
+    }
+    if (url.username) {
+        try {
+            result.user = decodeURIComponent(url.username);
+        }
+        catch {
+            result.user = url.username;
+        }
+    }
+    const db = url.pathname.replace(/^\//, "");
+    if (db)
+        result.database = decodeURIComponent(db);
+    const sslmodeRaw = url.searchParams.get("sslmode") ?? url.searchParams.get("sslMode");
+    const sslmode = sslmodeRaw?.toLowerCase();
+    if (isSslMode(sslmode)) {
+        result.sslMode = sslmode;
+    }
+    return result;
+}
+function isSslMode(value) {
+    return SSL_MODES.some((mode) => mode === value);
+}
+function parseResourcePathSegments(s) {
+    const parts = s.split("/");
+    if (parts[0] !== "projects" || parts.length < 2) {
+        return {};
+    }
+    const project = parts[1];
+    if (!project) {
+        return {};
+    }
+    if (parts.length === 2) {
+        return { project };
+    }
+    if (parts.length === 4 && parts[2] === "branches" && parts[3]) {
+        return { project, branch: parts[3] };
+    }
+    if (parts.length === 6 &&
+        parts[2] === "branches" &&
+        parts[4] === "endpoints" &&
+        parts[3] &&
+        parts[5]) {
+        return {
+            project,
+            branch: parts[3],
+            endpointId: parts[5],
+            endpoint: s,
+        };
+    }
+    if (parts.length === 6 &&
+        parts[2] === "branches" &&
+        parts[4] === "databases" &&
+        parts[3] &&
+        parts[5]) {
+        return {
+            project,
+            branch: parts[3],
+            databaseResourceId: parts[5],
+        };
+    }
+    return {};
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pgaddress.js","sourceRoot":"","sources":["../../src/pgaddress.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Flexible address parser for Lakebase Postgres connection inputs.\n *\n * Accepts whatever shape a user is likely to paste into\n * `LAKEBASE_ENDPOINT` (or the matching config field) and extracts\n * every recognizable piece. Whatever it can't recover is left for the\n * Lakebase resolver to discover.\n *\n * Recognized formats:\n *\n * - **Postgres URI** -\n *   `postgresql://user@host:port/db?sslmode=require` (also `postgres://`).\n *   Yields `user`, `host`, `port`, `database`, `sslMode`.\n *\n * - **Canonical endpoint resource path** -\n *   `projects/{p}/branches/{b}/endpoints/{e}` -\n *   yields `project`, `branch`, `endpointId`, and the original string as\n *   `endpoint` (already in lakebase's expected form).\n *\n * - **Database resource path** -\n *   `projects/{p}/branches/{b}/databases/{d}` -\n *   yields `project`, `branch`, and `databaseResourceId` (the UC\n *   resource leaf, not `PGDATABASE`; the resolver looks up the real\n *   Postgres name via REST).\n *\n * - **Branch resource path** -\n *   `projects/{p}/branches/{b}` - yields `project`, `branch`.\n *\n * - **Project resource path** -\n *   `projects/{p}` - yields `project`.\n *\n * - **Bare hostname** -\n *   `ep-steep-forest-e199v43w.database.eastus2.azuredatabricks.net` -\n *   yields `host` only; the resolver reverse-looks up the owning\n *   endpoint to recover the resource path.\n *\n * - **Bare project id** -\n *   `dbx-tools-demo` (1-63 chars, lowercase letters/digits/hyphens) -\n *   yields `project`.\n *\n * Returns an empty object for inputs it doesn't recognize.\n *\n * @module\n */\n\n/** Postgres TLS modes accepted by {@link SslMode}, in `PGSSLMODE` spelling. */\nexport const SSL_MODES = [\"require\", \"disable\", \"prefer\"] as const;\n\n/** Postgres TLS mode passed through to `pg`. */\nexport type SslMode = (typeof SSL_MODES)[number];\n\n/**\n * Optional Lakebase Postgres connection fields shared by parsed addresses,\n * resolver/env inputs, and resolved connections.\n */\nexport interface LakebaseConnectionInputs {\n  /** Lakebase project id. Resolved from the workspace when unset. */\n  project?: string;\n  /** Branch id within the project. Defaults to the project's default branch. */\n  branch?: string;\n  /**\n   * Canonical endpoint resource path (`projects/.../endpoints/...`), from\n   * `LAKEBASE_ENDPOINT`. Defaults to the branch's read-write endpoint.\n   */\n  endpoint?: string;\n  /** Postgres database name (`PGDATABASE`). Defaults to `databricks_postgres`. */\n  database?: string;\n  /** Postgres hostname (`PGHOST`). Defaults to the resolved endpoint's host. */\n  host?: string;\n  /** Postgres port (`PGPORT`). Defaults to 5432. */\n  port?: number;\n  /** Postgres TLS mode (`PGSSLMODE`). Defaults to `require`. */\n  sslMode?: SslMode;\n}\n\n/** Pieces recovered from parsing a single address or resource-path input. */\nexport interface ParsedAddress extends LakebaseConnectionInputs {\n  /** Endpoint leaf id (last segment of an endpoint resource path). */\n  endpointId?: string;\n  /**\n   * Database resource id leaf from a `.../databases/{id}` path. Not the\n   * Postgres database name.\n   */\n  databaseResourceId?: string;\n  /** Postgres user (URI-decoded if encoded). */\n  user?: string;\n}\n\nconst URL_SCHEME_RE = /^(postgres|postgresql):\\/\\//i;\nconst PROJECT_ID_RE = /^[a-z][a-z0-9-]{0,61}[a-z0-9]$|^[a-z]$/;\nconst HOSTNAME_HINT_RE = /^[a-z0-9][a-z0-9-]*(\\.[a-z0-9][a-z0-9-]*)+$/i;\n\n/**\n * Parse a Lakebase connection input into whatever pieces it carries.\n * See module docstring for the supported formats. Returns `{}` for\n * `undefined`, empty strings, and unrecognized inputs.\n *\n * @example\n * import { pgaddress } from \"@dbx-tools/appkit\";\n *\n * pgaddress.parseAddress(\"projects/demo/branches/production/endpoints/ep-1\");\n * // { project: \"demo\", branch: \"production\", endpointId: \"ep-1\", endpoint: \"projects/...\" }\n *\n * pgaddress.parseAddress(\"postgresql://me@ep-1.database.azuredatabricks.net/app?sslmode=require\");\n * // { host: \"ep-1.database.azuredatabricks.net\", user: \"me\", database: \"app\", sslMode: \"require\" }\n */\nexport function parseAddress(input: string | undefined | null): ParsedAddress {\n  if (!input) return {};\n  const s = input.trim();\n  if (!s) return {};\n\n  if (URL_SCHEME_RE.test(s)) return parseUri(s);\n  if (s.startsWith(\"projects/\")) return parseResourcePathSegments(s);\n  // Resource ids never contain dots; a dotted input must be a hostname.\n  if (HOSTNAME_HINT_RE.test(s) && s.includes(\".\")) return { host: s };\n  if (PROJECT_ID_RE.test(s)) return { project: s };\n  return {};\n}\n\n/**\n * Parse a Lakebase `projects/...` resource path. Returns `{}` when the\n * input is not a resource path (so bare branch ids are not mistaken for\n * project ids).\n */\nexport function parseResourcePath(input: string | undefined | null): ParsedAddress {\n  if (!input) return {};\n  const s = input.trim();\n  if (!s.startsWith(\"projects/\")) return {};\n  return parseResourcePathSegments(s);\n}\n\nfunction parseUri(s: string): ParsedAddress {\n  let url: URL;\n  try {\n    url = new URL(s);\n  } catch {\n    return {};\n  }\n  const result: ParsedAddress = {};\n  if (url.hostname) result.host = url.hostname;\n  if (url.port) {\n    const port = Number.parseInt(url.port, 10);\n    if (!Number.isNaN(port)) result.port = port;\n  }\n  if (url.username) {\n    try {\n      result.user = decodeURIComponent(url.username);\n    } catch {\n      result.user = url.username;\n    }\n  }\n  const db = url.pathname.replace(/^\\//, \"\");\n  if (db) result.database = decodeURIComponent(db);\n  const sslmodeRaw = url.searchParams.get(\"sslmode\") ?? url.searchParams.get(\"sslMode\");\n  const sslmode = sslmodeRaw?.toLowerCase();\n  if (isSslMode(sslmode)) {\n    result.sslMode = sslmode;\n  }\n  return result;\n}\n\nfunction isSslMode(value: string | undefined): value is SslMode {\n  return SSL_MODES.some((mode) => mode === value);\n}\n\nfunction parseResourcePathSegments(s: string): ParsedAddress {\n  const parts = s.split(\"/\");\n  if (parts[0] !== \"projects\" || parts.length < 2) {\n    return {};\n  }\n\n  const project = parts[1];\n  if (!project) {\n    return {};\n  }\n\n  if (parts.length === 2) {\n    return { project };\n  }\n\n  if (parts.length === 4 && parts[2] === \"branches\" && parts[3]) {\n    return { project, branch: parts[3] };\n  }\n\n  if (\n    parts.length === 6 &&\n    parts[2] === \"branches\" &&\n    parts[4] === \"endpoints\" &&\n    parts[3] &&\n    parts[5]\n  ) {\n    return {\n      project,\n      branch: parts[3],\n      endpointId: parts[5],\n      endpoint: s,\n    };\n  }\n\n  if (\n    parts.length === 6 &&\n    parts[2] === \"branches\" &&\n    parts[4] === \"databases\" &&\n    parts[3] &&\n    parts[5]\n  ) {\n    return {\n      project,\n      branch: parts[3],\n      databaseResourceId: parts[5],\n    };\n  }\n\n  return {};\n}\n"]}

package/lib/src/plugin.d.ts

@@ -0,0 +1,90 @@
+/**
+ * AppKit plugin lookup: typed access to sibling plugins registered on the
+ * AppKit plugin context (`this.context` on any class that extends `Plugin`).
+ *
+ * Why these live here instead of in `@databricks/appkit`: AppKit exposes
+ * `this.context.getPlugins()`, which returns `ReadonlyMap<string, BasePlugin>`,
+ * but provides no typed lookup helper. Every caller ends up writing the same
+ * `as InstanceType<ReturnType<typeof someFactory>["plugin"]>` cast. These
+ * wrappers absorb that boilerplate.
+ *
+ * API shape: pass the plugin's factory (`lakebase`, `serving`, `genie`, or any
+ * `toPlugin(...)` result) directly. TypeScript infers both the instance type
+ * (so `.exports()` resolves) and the registered name (so the runtime lookup
+ * works) from that single value. No `<T>` annotation or string literal needed
+ * at the call site.
+ *
+ * Generic AppKit runtime (execution context, `WorkspaceClientLike`) lives in
+ * `./appkit`; this module is plugin-lookup only.
+ *
+ * @module
+ */
+import { type NameLike } from "@dbx-tools/shared-core";
+/**
+ * Minimal structural shape of `this.context`. We mirror only the method we
+ * touch instead of depending on AppKit's `PluginContext` type, which is not
+ * part of the package's `exports` map and therefore cannot be imported. Any
+ * compatible object (real `PluginContext`, mocks, tests) satisfies this shape.
+ */
+export interface PluginContextLike {
+    getPlugins(): ReadonlyMap<string, unknown>;
+}
+type PluginData = {
+    plugin: abstract new (...args: never[]) => unknown;
+    name: string;
+};
+/**
+ * Structural shape of an AppKit plugin factory (the result of
+ * `toPlugin(SomePluginClass)`). Calling it returns a `PluginData` tuple whose
+ * `plugin` field is the *class constructor* and whose `name` field carries the
+ * registered plugin name as a literal string.
+ *
+ * Defined structurally so we don't pull `@databricks/appkit` into this as a
+ * type dependency for the bound. Any function returning the same shape (e.g.
+ * `lakebase`, `serving`, `genie`, or a user-defined `toPlugin(MyPlugin)`)
+ * satisfies it.
+ */
+type PluginDataFactory = (...args: never[]) => PluginData;
+/**
+ * Maps a plugin factory back to the *instance* type of its plugin class.
+ * Mirrors the inline pattern users would otherwise write:
+ * `InstanceType<ReturnType<typeof factory>["plugin"]>`.
+ */
+type PluginInstanceOf<F extends PluginDataFactory> = InstanceType<ReturnType<F>["plugin"]>;
+/**
+ * Returns the static `{ plugin, name }` descriptor for an AppKit plugin
+ * factory, caching per factory so repeated lookups do not allocate.
+ */
+export declare function data<F extends PluginDataFactory, D extends ReturnType<F>>(factory: F): D;
+/**
+ * Look up a sibling plugin instance from the AppKit plugin context, keyed off
+ * the factory's registered name and typed via its plugin class.
+ *
+ * Returns `undefined` when the context is missing or the plugin is not
+ * registered. For required siblings prefer {@link require}.
+ *
+ * @example
+ * import { lakebase } from "@databricks/appkit";
+ * import { plugin } from "@dbx-tools/appkit";
+ *
+ * const lake = plugin.instance(this.context, lakebase);
+ * //    ^^ inferred as LakebasePlugin | undefined
+ * lake?.exports().pool;
+ */
+export declare function instance<F extends PluginDataFactory>(ctx: PluginContextLike | undefined, factory: F): PluginInstanceOf<F> | undefined;
+/**
+ * Like {@link instance} but throws when the plugin is not registered. Use for
+ * siblings whose absence is a wiring bug rather than a runtime condition (e.g.
+ * requiring `lakebase` when the caller has `storage` / `memory` enabled).
+ *
+ * `caller` is prepended to the error message so cross-plugin failures are easy
+ * to attribute in logs.
+ *
+ * @example
+ * import { lakebase } from "@databricks/appkit";
+ * import { plugin } from "@dbx-tools/appkit";
+ *
+ * const pool = plugin.require(this.context, lakebase, "mastra").exports().pool;
+ */
+export declare function require<F extends PluginDataFactory>(ctx: PluginContextLike | undefined, factory: F, caller?: NameLike | string): PluginInstanceOf<F>;
+export {};

package/lib/src/plugin.js

@@ -0,0 +1,97 @@
+/**
+ * AppKit plugin lookup: typed access to sibling plugins registered on the
+ * AppKit plugin context (`this.context` on any class that extends `Plugin`).
+ *
+ * Why these live here instead of in `@databricks/appkit`: AppKit exposes
+ * `this.context.getPlugins()`, which returns `ReadonlyMap<string, BasePlugin>`,
+ * but provides no typed lookup helper. Every caller ends up writing the same
+ * `as InstanceType<ReturnType<typeof someFactory>["plugin"]>` cast. These
+ * wrappers absorb that boilerplate.
+ *
+ * API shape: pass the plugin's factory (`lakebase`, `serving`, `genie`, or any
+ * `toPlugin(...)` result) directly. TypeScript infers both the instance type
+ * (so `.exports()` resolves) and the registered name (so the runtime lookup
+ * works) from that single value. No `<T>` annotation or string literal needed
+ * at the call site.
+ *
+ * Generic AppKit runtime (execution context, `WorkspaceClientLike`) lives in
+ * `./appkit`; this module is plugin-lookup only.
+ *
+ * @module
+ */
+import { ConfigurationError } from "@databricks/appkit";
+import { log } from "@dbx-tools/shared-core";
+const logger = log.logger("plugin");
+/**
+ * Registry name returned by `factory().name`, keyed by the factory function.
+ * Typical AppKit factories return stable metadata; caching avoids invoking
+ * `factory()` on every sibling lookup (which would allocate a fresh descriptor
+ * tuple each time).
+ */
+const dataCache = new WeakMap();
+/**
+ * Returns the static `{ plugin, name }` descriptor for an AppKit plugin
+ * factory, caching per factory so repeated lookups do not allocate.
+ */
+export function data(factory) {
+    const cached = dataCache.get(factory);
+    // The cache is keyed by the erased `PluginDataFactory` bound, so `WeakMap`
+    // hands back the widened `PluginData`; only the caller's `F` knows the exact
+    // descriptor type.
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = factory();
+    dataCache.set(factory, result);
+    return result;
+}
+/**
+ * Look up a sibling plugin instance from the AppKit plugin context, keyed off
+ * the factory's registered name and typed via its plugin class.
+ *
+ * Returns `undefined` when the context is missing or the plugin is not
+ * registered. For required siblings prefer {@link require}.
+ *
+ * @example
+ * import { lakebase } from "@databricks/appkit";
+ * import { plugin } from "@dbx-tools/appkit";
+ *
+ * const lake = plugin.instance(this.context, lakebase);
+ * //    ^^ inferred as LakebasePlugin | undefined
+ * lake?.exports().pool;
+ */
+export function instance(ctx, factory) {
+    if (!ctx)
+        return undefined;
+    const name = data(factory).name;
+    // AppKit's registry is a `Map<string, unknown>`, so the instance type is only
+    // recoverable from the factory the caller passed.
+    return ctx.getPlugins().get(name);
+}
+/**
+ * Like {@link instance} but throws when the plugin is not registered. Use for
+ * siblings whose absence is a wiring bug rather than a runtime condition (e.g.
+ * requiring `lakebase` when the caller has `storage` / `memory` enabled).
+ *
+ * `caller` is prepended to the error message so cross-plugin failures are easy
+ * to attribute in logs.
+ *
+ * @example
+ * import { lakebase } from "@databricks/appkit";
+ * import { plugin } from "@dbx-tools/appkit";
+ *
+ * const pool = plugin.require(this.context, lakebase, "mastra").exports().pool;
+ */
+export function require(ctx, factory, caller) {
+    const found = instance(ctx, factory);
+    if (found)
+        return found;
+    const prefix = typeof caller === "string" ? `${caller}: ` : caller?.name ? `${caller.name}: ` : "";
+    const registeredName = data(factory).name;
+    logger.debug("required plugin not registered", {
+        plugin: registeredName,
+        registered: [...(ctx?.getPlugins().keys() ?? [])],
+    });
+    throw ConfigurationError.resourceNotFound(`${prefix}plugin '${registeredName}'`, `Add ${registeredName}() to the plugins passed to createApp.`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,GAAG,EAAiB,MAAM,wBAAwB,CAAC;AAE5D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;AAqCpC;;;;;GAKG;AACH,MAAM,SAAS,GAAG,IAAI,OAAO,EAAiC,CAAC;AAE/D;;;GAGG;AACH,MAAM,UAAU,IAAI,CAAuD,OAAU;IACnF,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACtC,2EAA2E;IAC3E,6EAA6E;IAC7E,mBAAmB;IACnB,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,MAAW,CAAC;IACrB,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,EAAE,CAAC;IACzB,SAAS,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,MAAW,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,QAAQ,CACtB,GAAkC,EAClC,OAAU;IAEV,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC;IAChC,8EAA8E;IAC9E,kDAAkD;IAClD,OAAO,GAAG,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,IAAI,CAAoC,CAAC;AACvE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CACrB,GAAkC,EAClC,OAAU,EACV,MAA0B;IAE1B,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACrC,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IACxB,MAAM,MAAM,GACV,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACtF,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC;IAC1C,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE;QAC7C,MAAM,EAAE,cAAc;QACtB,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;KAClD,CAAC,CAAC;IACH,MAAM,kBAAkB,CAAC,gBAAgB,CACvC,GAAG,MAAM,WAAW,cAAc,GAAG,EACrC,OAAO,cAAc,wCAAwC,CAC9D,CAAC;AACJ,CAAC","sourcesContent":["/**\n * AppKit plugin lookup: typed access to sibling plugins registered on the\n * AppKit plugin context (`this.context` on any class that extends `Plugin`).\n *\n * Why these live here instead of in `@databricks/appkit`: AppKit exposes\n * `this.context.getPlugins()`, which returns `ReadonlyMap<string, BasePlugin>`,\n * but provides no typed lookup helper. Every caller ends up writing the same\n * `as InstanceType<ReturnType<typeof someFactory>[\"plugin\"]>` cast. These\n * wrappers absorb that boilerplate.\n *\n * API shape: pass the plugin's factory (`lakebase`, `serving`, `genie`, or any\n * `toPlugin(...)` result) directly. TypeScript infers both the instance type\n * (so `.exports()` resolves) and the registered name (so the runtime lookup\n * works) from that single value. No `<T>` annotation or string literal needed\n * at the call site.\n *\n * Generic AppKit runtime (execution context, `WorkspaceClientLike`) lives in\n * `./appkit`; this module is plugin-lookup only.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { log, type NameLike } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"plugin\");\n\n/**\n * Minimal structural shape of `this.context`. We mirror only the method we\n * touch instead of depending on AppKit's `PluginContext` type, which is not\n * part of the package's `exports` map and therefore cannot be imported. Any\n * compatible object (real `PluginContext`, mocks, tests) satisfies this shape.\n */\nexport interface PluginContextLike {\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\ntype PluginData = {\n  plugin: abstract new (...args: never[]) => unknown;\n  name: string;\n};\n\n/**\n * Structural shape of an AppKit plugin factory (the result of\n * `toPlugin(SomePluginClass)`). Calling it returns a `PluginData` tuple whose\n * `plugin` field is the *class constructor* and whose `name` field carries the\n * registered plugin name as a literal string.\n *\n * Defined structurally so we don't pull `@databricks/appkit` into this as a\n * type dependency for the bound. Any function returning the same shape (e.g.\n * `lakebase`, `serving`, `genie`, or a user-defined `toPlugin(MyPlugin)`)\n * satisfies it.\n */\ntype PluginDataFactory = (...args: never[]) => PluginData;\n\n/**\n * Maps a plugin factory back to the *instance* type of its plugin class.\n * Mirrors the inline pattern users would otherwise write:\n * `InstanceType<ReturnType<typeof factory>[\"plugin\"]>`.\n */\ntype PluginInstanceOf<F extends PluginDataFactory> = InstanceType<ReturnType<F>[\"plugin\"]>;\n\n/**\n * Registry name returned by `factory().name`, keyed by the factory function.\n * Typical AppKit factories return stable metadata; caching avoids invoking\n * `factory()` on every sibling lookup (which would allocate a fresh descriptor\n * tuple each time).\n */\nconst dataCache = new WeakMap<PluginDataFactory, PluginData>();\n\n/**\n * Returns the static `{ plugin, name }` descriptor for an AppKit plugin\n * factory, caching per factory so repeated lookups do not allocate.\n */\nexport function data<F extends PluginDataFactory, D extends ReturnType<F>>(factory: F): D {\n  const cached = dataCache.get(factory);\n  // The cache is keyed by the erased `PluginDataFactory` bound, so `WeakMap`\n  // hands back the widened `PluginData`; only the caller's `F` knows the exact\n  // descriptor type.\n  if (cached !== undefined) {\n    return cached as D;\n  }\n  const result = factory();\n  dataCache.set(factory, result);\n  return result as D;\n}\n\n/**\n * Look up a sibling plugin instance from the AppKit plugin context, keyed off\n * the factory's registered name and typed via its plugin class.\n *\n * Returns `undefined` when the context is missing or the plugin is not\n * registered. For required siblings prefer {@link require}.\n *\n * @example\n * import { lakebase } from \"@databricks/appkit\";\n * import { plugin } from \"@dbx-tools/appkit\";\n *\n * const lake = plugin.instance(this.context, lakebase);\n * //    ^^ inferred as LakebasePlugin | undefined\n * lake?.exports().pool;\n */\nexport function instance<F extends PluginDataFactory>(\n  ctx: PluginContextLike | undefined,\n  factory: F,\n): PluginInstanceOf<F> | undefined {\n  if (!ctx) return undefined;\n  const name = data(factory).name;\n  // AppKit's registry is a `Map<string, unknown>`, so the instance type is only\n  // recoverable from the factory the caller passed.\n  return ctx.getPlugins().get(name) as PluginInstanceOf<F> | undefined;\n}\n\n/**\n * Like {@link instance} but throws when the plugin is not registered. Use for\n * siblings whose absence is a wiring bug rather than a runtime condition (e.g.\n * requiring `lakebase` when the caller has `storage` / `memory` enabled).\n *\n * `caller` is prepended to the error message so cross-plugin failures are easy\n * to attribute in logs.\n *\n * @example\n * import { lakebase } from \"@databricks/appkit\";\n * import { plugin } from \"@dbx-tools/appkit\";\n *\n * const pool = plugin.require(this.context, lakebase, \"mastra\").exports().pool;\n */\nexport function require<F extends PluginDataFactory>(\n  ctx: PluginContextLike | undefined,\n  factory: F,\n  caller?: NameLike | string,\n): PluginInstanceOf<F> {\n  const found = instance(ctx, factory);\n  if (found) return found;\n  const prefix =\n    typeof caller === \"string\" ? `${caller}: ` : caller?.name ? `${caller.name}: ` : \"\";\n  const registeredName = data(factory).name;\n  logger.debug(\"required plugin not registered\", {\n    plugin: registeredName,\n    registered: [...(ctx?.getPlugins().keys() ?? [])],\n  });\n  throw ConfigurationError.resourceNotFound(\n    `${prefix}plugin '${registeredName}'`,\n    `Add ${registeredName}() to the plugins passed to createApp.`,\n  );\n}\n"]}

package/lib/src/provision.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Lakebase cache-schema grant fix-up.
+ *
+ * AppKit's persistent cache (`CacheManager` -> `PersistentStorage`) uses a
+ * schema `appkit` and a table `appkit.appkit_cache_entries`. When the connecting
+ * Databricks identity lacks privileges on that schema, the cache migration
+ * throws, and because AppKit is typically run with `cache.strictPersistence:
+ * true`, the cache is silently switched to a disabled in-memory stub - so every
+ * persistent read (chart long-poll, history, etc.) misses and 404s.
+ *
+ * This grants the connecting role full rights on the cache schema, but only when
+ * the schema ALREADY EXISTS - it never creates the schema itself. Run from a
+ * LOCAL identity that owns the schema (or holds grant option on it); it is
+ * skipped inside a Databricks App, where the app SP cannot grant and its
+ * Postgres role does not exist until its first connection.
+ *
+ * Must run AFTER {@link applyLakebaseToEnv} has written the resolved connection
+ * to `process.env` (so `createLakebasePool` picks up host / database / endpoint)
+ * and BEFORE `createApp` initializes the cache.
+ *
+ * @module
+ */
+import { log } from "@dbx-tools/shared-core";
+/**
+ * Idempotent grants that make the (already-existing) AppKit cache schema fully
+ * usable by `role`. The `ALTER DEFAULT PRIVILEGES` lines cover the cache table
+ * whenever the schema owner creates it later.
+ *
+ * Throws a {@link ValidationError} when `role` is not a plausible Postgres role
+ * name, since the value lands in an identifier position.
+ */
+export declare function cacheGrantStatements(role: string): readonly string[];
+/**
+ * Grant `role` rights on the AppKit cache schema, but only when that schema
+ * already exists.
+ *
+ * No-ops inside a Databricks App env, when `role` is undefined, or when the
+ * schema is absent. Best-effort otherwise: any failure (e.g. the local identity
+ * doesn't own the schema) is logged and swallowed so it never blocks startup -
+ * a disabled cache is degraded, not fatal.
+ *
+ * @param role - Postgres role to grant to and connect as (the resolved
+ *   workspace-client identity); skips when undefined.
+ * @param logger - Logger to report progress on. Defaults to this module's.
+ *
+ * @example
+ * import { provision } from "@dbx-tools/appkit";
+ *
+ * await provision.provisionCacheSchema("app-service-principal@databricks.com");
+ */
+export declare function provisionCacheSchema(role: string | undefined, logger?: log.Logger): Promise<void>;