@dbx-tools/appkit 0.3.44 → 0.4.1

package/lib/src/provision.js

@@ -0,0 +1,133 @@
+/**
+ * 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 { createLakebasePool, getWorkspaceClient, ValidationError } from "@databricks/appkit";
+import { error, log } from "@dbx-tools/shared-core";
+import { isAppEnv } from "./databricks.js";
+const defaultLogger = log.logger("provision");
+/** AppKit persistent-cache schema (see AppKit's `PersistentStorage`). */
+const CACHE_SCHEMA = "appkit";
+/**
+ * Characters a Lakebase Postgres role can legitimately contain: workspace
+ * identities are emails, service principals are UUIDs.
+ */
+const ROLE_PATTERN = /^[A-Za-z0-9._@+-]{1,255}$/;
+/**
+ * Provisioning runs at boot as the local developer identity, before any plugin
+ * exists, so it is outside AppKit's interceptor chain and inherits no timeout
+ * from it. Both bounds are explicit for that reason.
+ */
+const CONNECT_TIMEOUT_MS = 10_000;
+const STATEMENT_TIMEOUT_MS = 15_000;
+/**
+ * Quote a Postgres identifier: wrap in double quotes and double any embedded
+ * quote. Schema and role names are identifiers, and Postgres does not accept a
+ * bind parameter in an identifier position, so quoting is the only defense
+ * available for these statements. Lakebase role names are usually emails
+ * (`user@host`), which must be quoted to be a valid identifier at all.
+ */
+function quoteIdent(ident) {
+    return `"${ident.replace(/"/g, '""')}"`;
+}
+/**
+ * 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 function cacheGrantStatements(role) {
+    if (!ROLE_PATTERN.test(role)) {
+        throw ValidationError.invalidValue("role", role, "a Postgres role name");
+    }
+    const schema = quoteIdent(CACHE_SCHEMA);
+    const target = quoteIdent(role);
+    return [
+        `GRANT USAGE, CREATE ON SCHEMA ${schema} TO ${target}`,
+        `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ${schema} TO ${target}`,
+        `GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA ${schema} TO ${target}`,
+        `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON TABLES TO ${target}`,
+        `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON SEQUENCES TO ${target}`,
+    ];
+}
+/**
+ * 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 async function provisionCacheSchema(role, logger = defaultLogger) {
+    if (isAppEnv()) {
+        logger.debug("autopg: skip cache provisioning (inside a Databricks App)");
+        return;
+    }
+    if (!role) {
+        logger.warn("autopg: skip cache provisioning (could not resolve connecting role)");
+        return;
+    }
+    // Pass `user` explicitly: autopg resolves the connection target
+    // (host/database/endpoint) but not the identity, so `createLakebasePool`'s
+    // synchronous username lookup would otherwise throw. `getWorkspaceClient({})`
+    // returns a fresh default-auth client - literally `new WorkspaceClient({})`,
+    // but built against the SDK version AppKit's `createLakebasePool` expects
+    // (importing the SDK class directly here pulls a newer, type-incompatible copy).
+    const pool = createLakebasePool({
+        user: role,
+        workspaceClient: getWorkspaceClient({}),
+        connectionTimeoutMillis: CONNECT_TIMEOUT_MS,
+        statement_timeout: STATEMENT_TIMEOUT_MS,
+    });
+    try {
+        const found = await pool.query("SELECT 1 FROM information_schema.schemata WHERE schema_name = $1", [CACHE_SCHEMA]);
+        if (found.rowCount === 0) {
+            logger.debug("autopg: skip cache provisioning (schema absent)", { schema: CACHE_SCHEMA });
+            return;
+        }
+        for (const sql of cacheGrantStatements(role)) {
+            await pool.query(sql);
+        }
+        logger.info("autopg: granted cache schema", { schema: CACHE_SCHEMA, role });
+    }
+    catch (err) {
+        logger.warn("autopg: cache provisioning failed (continuing)", {
+            schema: CACHE_SCHEMA,
+            error: error.errorMessage(err),
+        });
+    }
+    finally {
+        await pool.end().catch(() => { });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provision.js","sourceRoot":"","sources":["../../src/provision.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lakebase cache-schema grant fix-up.\n *\n * AppKit's persistent cache (`CacheManager` -> `PersistentStorage`) uses a\n * schema `appkit` and a table `appkit.appkit_cache_entries`. When the connecting\n * Databricks identity lacks privileges on that schema, the cache migration\n * throws, and because AppKit is typically run with `cache.strictPersistence:\n * true`, the cache is silently switched to a disabled in-memory stub - so every\n * persistent read (chart long-poll, history, etc.) misses and 404s.\n *\n * This grants the connecting role full rights on the cache schema, but only when\n * the schema ALREADY EXISTS - it never creates the schema itself. Run from a\n * LOCAL identity that owns the schema (or holds grant option on it); it is\n * skipped inside a Databricks App, where the app SP cannot grant and its\n * Postgres role does not exist until its first connection.\n *\n * Must run AFTER {@link applyLakebaseToEnv} has written the resolved connection\n * to `process.env` (so `createLakebasePool` picks up host / database / endpoint)\n * and BEFORE `createApp` initializes the cache.\n *\n * @module\n */\n\nimport { createLakebasePool, getWorkspaceClient, ValidationError } from \"@databricks/appkit\";\nimport { error, log } from \"@dbx-tools/shared-core\";\n\nimport { isAppEnv } from \"./databricks\";\n\nconst defaultLogger = log.logger(\"provision\");\n\n/** AppKit persistent-cache schema (see AppKit's `PersistentStorage`). */\nconst CACHE_SCHEMA = \"appkit\";\n\n/**\n * Characters a Lakebase Postgres role can legitimately contain: workspace\n * identities are emails, service principals are UUIDs.\n */\nconst ROLE_PATTERN = /^[A-Za-z0-9._@+-]{1,255}$/;\n\n/**\n * Provisioning runs at boot as the local developer identity, before any plugin\n * exists, so it is outside AppKit's interceptor chain and inherits no timeout\n * from it. Both bounds are explicit for that reason.\n */\nconst CONNECT_TIMEOUT_MS = 10_000;\nconst STATEMENT_TIMEOUT_MS = 15_000;\n\n/**\n * Quote a Postgres identifier: wrap in double quotes and double any embedded\n * quote. Schema and role names are identifiers, and Postgres does not accept a\n * bind parameter in an identifier position, so quoting is the only defense\n * available for these statements. Lakebase role names are usually emails\n * (`user@host`), which must be quoted to be a valid identifier at all.\n */\nfunction quoteIdent(ident: string): string {\n  return `\"${ident.replace(/\"/g, '\"\"')}\"`;\n}\n\n/**\n * Idempotent grants that make the (already-existing) AppKit cache schema fully\n * usable by `role`. The `ALTER DEFAULT PRIVILEGES` lines cover the cache table\n * whenever the schema owner creates it later.\n *\n * Throws a {@link ValidationError} when `role` is not a plausible Postgres role\n * name, since the value lands in an identifier position.\n */\nexport function cacheGrantStatements(role: string): readonly string[] {\n  if (!ROLE_PATTERN.test(role)) {\n    throw ValidationError.invalidValue(\"role\", role, \"a Postgres role name\");\n  }\n  const schema = quoteIdent(CACHE_SCHEMA);\n  const target = quoteIdent(role);\n  return [\n    `GRANT USAGE, CREATE ON SCHEMA ${schema} TO ${target}`,\n    `GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA ${schema} TO ${target}`,\n    `GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA ${schema} TO ${target}`,\n    `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON TABLES TO ${target}`,\n    `ALTER DEFAULT PRIVILEGES IN SCHEMA ${schema} GRANT ALL ON SEQUENCES TO ${target}`,\n  ];\n}\n\n/**\n * Grant `role` rights on the AppKit cache schema, but only when that schema\n * already exists.\n *\n * No-ops inside a Databricks App env, when `role` is undefined, or when the\n * schema is absent. Best-effort otherwise: any failure (e.g. the local identity\n * doesn't own the schema) is logged and swallowed so it never blocks startup -\n * a disabled cache is degraded, not fatal.\n *\n * @param role - Postgres role to grant to and connect as (the resolved\n *   workspace-client identity); skips when undefined.\n * @param logger - Logger to report progress on. Defaults to this module's.\n *\n * @example\n * import { provision } from \"@dbx-tools/appkit\";\n *\n * await provision.provisionCacheSchema(\"app-service-principal@databricks.com\");\n */\nexport async function provisionCacheSchema(\n  role: string | undefined,\n  logger: log.Logger = defaultLogger,\n): Promise<void> {\n  if (isAppEnv()) {\n    logger.debug(\"autopg: skip cache provisioning (inside a Databricks App)\");\n    return;\n  }\n  if (!role) {\n    logger.warn(\"autopg: skip cache provisioning (could not resolve connecting role)\");\n    return;\n  }\n  // Pass `user` explicitly: autopg resolves the connection target\n  // (host/database/endpoint) but not the identity, so `createLakebasePool`'s\n  // synchronous username lookup would otherwise throw. `getWorkspaceClient({})`\n  // returns a fresh default-auth client - literally `new WorkspaceClient({})`,\n  // but built against the SDK version AppKit's `createLakebasePool` expects\n  // (importing the SDK class directly here pulls a newer, type-incompatible copy).\n  const pool = createLakebasePool({\n    user: role,\n    workspaceClient: getWorkspaceClient({}),\n    connectionTimeoutMillis: CONNECT_TIMEOUT_MS,\n    statement_timeout: STATEMENT_TIMEOUT_MS,\n  });\n  try {\n    const found = await pool.query(\n      \"SELECT 1 FROM information_schema.schemata WHERE schema_name = $1\",\n      [CACHE_SCHEMA],\n    );\n    if (found.rowCount === 0) {\n      logger.debug(\"autopg: skip cache provisioning (schema absent)\", { schema: CACHE_SCHEMA });\n      return;\n    }\n    for (const sql of cacheGrantStatements(role)) {\n      await pool.query(sql);\n    }\n    logger.info(\"autopg: granted cache schema\", { schema: CACHE_SCHEMA, role });\n  } catch (err) {\n    logger.warn(\"autopg: cache provisioning failed (continuing)\", {\n      schema: CACHE_SCHEMA,\n      error: error.errorMessage(err),\n    });\n  } finally {\n    await pool.end().catch(() => {});\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

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

package/package.json

@@ -18,24 +18,28 @@
     "@databricks/sdk-experimental": "^0.17.0",
     "yaml": "^2.9.0",
     "zod": "4.3.6",
-    "@dbx-tools/core": "0.3.44",
-    "@dbx-tools/shared-core": "0.3.44"
+    "@dbx-tools/core": "0.4.1",
+    "@dbx-tools/shared-core": "0.4.1"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.44",
-  "types": "index.ts",
+  "version": "0.4.1",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "peerDependenciesMeta": {
     "@databricks/appkit": {