@dbx-tools/genie 0.6.61 → 0.6.63

package/README.md

@@ -142,6 +142,14 @@ const questions = space.genieSampleQuestions(genieSpace);
 metadata by default. `space.genieSampleQuestions()` extracts curated starter
 questions and returns `[]` when none are configured.
 
+The serialized blob needs `Can Edit` on the space, while `Can Run` is enough for
+title and description. When the workspace rejects the serialized request for
+lack of permission, `getGenieSpace()` retries once without it and logs
+`serialized-space:forbidden`, so an app service principal holding only `Can Run`
+still resolves the space and simply reports no starter questions. Every other
+failure - a cancelled request, a missing space, a retry that also fails - is
+thrown.
+
 ## Options
 
 `chat.GenieChatOptions` is shared by both drivers:

package/lib/src/space.d.ts

@@ -10,6 +10,14 @@
  * workspace client's raw `apiClient` since the typed request shape has no flag
  * for it.
  *
+ * The serialized blob is also more privileged than the listing surface: the
+ * workspace API requires `Can Edit` on the space to return it, while `Can Run`
+ * is enough for title / description. A caller that only holds `Can Run` - an
+ * app service principal granted just enough to ask questions is the common case
+ * - would otherwise lose the whole space lookup to a `PERMISSION_DENIED` it
+ * cannot act on, so the fetch degrades to the unserialized request instead of
+ * failing (see {@link getGenieSpace}).
+ *
  * @module
  */
 import { WorkspaceClient } from "@databricks/sdk-experimental";
@@ -27,6 +35,10 @@ export interface GetGenieSpaceOptions {
      * Request the `serialized_space` blob (catalogs, tables, sample questions,
      * prompts). Defaults to `true` - the only reason to skip it is when the
      * caller just needs title / description and wants the smaller payload.
+     *
+     * Requesting it is best-effort: the blob needs `Can Edit` on the space, so a
+     * caller without it gets the unserialized space back rather than an error,
+     * and {@link genieSampleQuestions} then reports no suggestions.
      */
     serialized?: boolean;
     /**
@@ -41,6 +53,13 @@ export interface GetGenieSpaceOptions {
  * through the raw `apiClient`, then validates the response against
  * {@link GenieSpaceSchema} (unknown fields like `etag` /
  * `parent_path` are stripped).
+ *
+ * When the serialized request is rejected for lack of permission (`403`, or a
+ * `PERMISSION_DENIED` / `Can Edit` message - the workspace API gates the blob
+ * behind `Can Edit`), it retries once without the flag so the caller still gets
+ * the space. Any other failure, and a retry that fails too, is rethrown: a
+ * cancelled request or a missing space must not look like an unserialized
+ * space.
  */
 export declare function getGenieSpace(spaceId: string, options?: GetGenieSpaceOptions): Promise<GenieSpace>;
 /**

package/lib/src/space.js

@@ -10,11 +10,19 @@
  * workspace client's raw `apiClient` since the typed request shape has no flag
  * for it.
  *
+ * The serialized blob is also more privileged than the listing surface: the
+ * workspace API requires `Can Edit` on the space to return it, while `Can Run`
+ * is enough for title / description. A caller that only holds `Can Run` - an
+ * app service principal granted just enough to ask questions is the common case
+ * - would otherwise lose the whole space lookup to a `PERMISSION_DENIED` it
+ * cannot act on, so the fetch degrades to the unserialized request instead of
+ * failing (see {@link getGenieSpace}).
+ *
  * @module
  */
 import { WorkspaceClient } from "@databricks/sdk-experimental";
 import { databricks } from "@dbx-tools/appkit";
-import { json, log, object, string } from "@dbx-tools/shared-core";
+import { error, json, log, object, string } from "@dbx-tools/shared-core";
 import { genieModel } from "@dbx-tools/shared-genie";
 const logger = log.logger("genie/space");
 /**
@@ -23,20 +31,52 @@ const logger = log.logger("genie/space");
  * through the raw `apiClient`, then validates the response against
  * {@link GenieSpaceSchema} (unknown fields like `etag` /
  * `parent_path` are stripped).
+ *
+ * When the serialized request is rejected for lack of permission (`403`, or a
+ * `PERMISSION_DENIED` / `Can Edit` message - the workspace API gates the blob
+ * behind `Can Edit`), it retries once without the flag so the caller still gets
+ * the space. Any other failure, and a retry that fails too, is rethrown: a
+ * cancelled request or a missing space must not look like an unserialized
+ * space.
  */
 export async function getGenieSpace(spaceId, options) {
     const client = options?.workspaceClient ?? new WorkspaceClient({});
     const serialized = options?.serialized !== false;
     const ctx = options?.context ? databricks.toContext(options.context) : undefined;
-    const raw = await client.apiClient.request({
+    const request = (includeSerialized) => client.apiClient.request({
         path: `/api/2.0/genie/spaces/${encodeURIComponent(spaceId)}`,
         method: "GET",
-        query: serialized ? { include_serialized_space: true } : {},
+        query: includeSerialized ? { include_serialized_space: true } : {},
         headers: new Headers(),
         raw: false,
     }, ctx);
+    let raw;
+    try {
+        raw = await request(serialized);
+    }
+    catch (err) {
+        if (!serialized || !isSerializedSpaceForbidden(err))
+            throw err;
+        logger.debug("serialized-space:forbidden", {
+            spaceId,
+            error: error.errorMessage(err),
+        });
+        raw = await request(false);
+    }
     return genieModel.GenieSpaceSchema.parse(raw);
 }
+/**
+ * True when a failed space request was rejected for lack of permission, the one
+ * failure the unserialized retry can recover from. Matches on `403` and on the
+ * `PERMISSION_DENIED` / `Can Edit` wording the workspace API returns, since the
+ * SDK surfaces the error code without always carrying a status.
+ */
+function isSerializedSpaceForbidden(err) {
+    const context = error.errorContext(err);
+    return (context.hasStatusCode(403) ||
+        context.hasMessage("permission denied") ||
+        context.hasMessage("can edit"));
+}
 /**
  * Extract the curated starter questions an author configured on a Genie space.
  * Reads `serialized_space -> config.sample_questions[*].question`. Returns `[]`
@@ -66,4 +106,4 @@ export function genieSampleQuestions(space) {
             .distinct(),
     ];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"space.js","sourceRoot":"","sources":["../../src/space.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Genie space metadata helpers.\n *\n * Fetches a Genie space's definition (including the opt-in `serialized_space`\n * blob) and extracts the curated starter questions an author configured on the\n * space. The typed SDK `client.genie.getSpace` only returns the\n * directory-listing surface (`title` / `description` / `warehouse_id`); the\n * sample questions live inside `serialized_space`, which the REST API returns\n * only when `include_serialized_space=true`. We hit that endpoint through the\n * workspace client's raw `apiClient` since the typed request shape has no flag\n * for it.\n *\n * The serialized blob is also more privileged than the listing surface: the\n * workspace API requires `Can Edit` on the space to return it, while `Can Run`\n * is enough for title / description. A caller that only holds `Can Run` - an\n * app service principal granted just enough to ask questions is the common case\n * - would otherwise lose the whole space lookup to a `PERMISSION_DENIED` it\n * cannot act on, so the fetch degrades to the unserialized request instead of\n * failing (see {@link getGenieSpace}).\n *\n * @module\n */\n\nimport { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { error, json, log, object, string } from \"@dbx-tools/shared-core\";\nimport { genieModel, type GenieSpace } from \"@dbx-tools/shared-genie\";\n\nconst logger = log.logger(\"genie/space\");\n\n/** Options for {@link getGenieSpace}. */\nexport interface GetGenieSpaceOptions {\n  /**\n   * Explicit `WorkspaceClient`. Defaults to a fresh `new WorkspaceClient({})`\n   * (env-var auth). Server callers should pass their OBO-scoped client so the\n   * lookup runs as the user.\n   */\n  workspaceClient?: WorkspaceClient;\n  /**\n   * Request the `serialized_space` blob (catalogs, tables, sample questions,\n   * prompts). Defaults to `true` - the only reason to skip it is when the\n   * caller just needs title / description and wants the smaller payload.\n   *\n   * Requesting it is best-effort: the blob needs `Can Edit` on the space, so a\n   * caller without it gets the unserialized space back rather than an error,\n   * and {@link genieSampleQuestions} then reports no suggestions.\n   */\n  serialized?: boolean;\n  /**\n   * External cancellation. Accepts a WHATWG `AbortSignal` or a fully-built SDK\n   * `Context` (see `databricks.ContextLike`).\n   */\n  context?: databricks.ContextLike;\n}\n\n/**\n * Fetch a Genie space by id, optionally including its serialized definition.\n * Hits `GET /api/2.0/genie/spaces/<id>` with `include_serialized_space=true`\n * through the raw `apiClient`, then validates the response against\n * {@link GenieSpaceSchema} (unknown fields like `etag` /\n * `parent_path` are stripped).\n *\n * When the serialized request is rejected for lack of permission (`403`, or a\n * `PERMISSION_DENIED` / `Can Edit` message - the workspace API gates the blob\n * behind `Can Edit`), it retries once without the flag so the caller still gets\n * the space. Any other failure, and a retry that fails too, is rethrown: a\n * cancelled request or a missing space must not look like an unserialized\n * space.\n */\nexport async function getGenieSpace(\n  spaceId: string,\n  options?: GetGenieSpaceOptions,\n): Promise<GenieSpace> {\n  const client = options?.workspaceClient ?? new WorkspaceClient({});\n  const serialized = options?.serialized !== false;\n  const ctx = options?.context ? databricks.toContext(options.context) : undefined;\n  const request = (includeSerialized: boolean): Promise<unknown> =>\n    client.apiClient.request(\n      {\n        path: `/api/2.0/genie/spaces/${encodeURIComponent(spaceId)}`,\n        method: \"GET\",\n        query: includeSerialized ? { include_serialized_space: true } : {},\n        headers: new Headers(),\n        raw: false,\n      },\n      ctx,\n    );\n\n  let raw: unknown;\n  try {\n    raw = await request(serialized);\n  } catch (err) {\n    if (!serialized || !isSerializedSpaceForbidden(err)) throw err;\n    logger.debug(\"serialized-space:forbidden\", {\n      spaceId,\n      error: error.errorMessage(err),\n    });\n    raw = await request(false);\n  }\n  return genieModel.GenieSpaceSchema.parse(raw);\n}\n\n/**\n * True when a failed space request was rejected for lack of permission, the one\n * failure the unserialized retry can recover from. Matches on `403` and on the\n * `PERMISSION_DENIED` / `Can Edit` wording the workspace API returns, since the\n * SDK surfaces the error code without always carrying a status.\n */\nfunction isSerializedSpaceForbidden(err: unknown): boolean {\n  const context = error.errorContext(err);\n  return (\n    context.hasStatusCode(403) ||\n    context.hasMessage(\"permission denied\") ||\n    context.hasMessage(\"can edit\")\n  );\n}\n\n/**\n * One entry in a serialized space's `config.sample_questions`. The\n * author-facing field is `question`, which the wire format models as a string\n * array (a single multi-line question is split across entries); we treat the\n * first non-empty entry as the displayable question text.\n */\ninterface SerializedSampleQuestion {\n  question?: unknown;\n}\n\n/**\n * Extract the curated starter questions an author configured on a Genie space.\n * Reads `serialized_space -> config.sample_questions[*].question`. Returns `[]`\n * when the space carries no serialized blob, the blob is unparseable, or no\n * sample questions are configured - so a missing or misconfigured space\n * degrades to \"no suggestions\" rather than throwing. Order is preserved (the\n * author's ordering) and duplicates are dropped.\n */\nexport function genieSampleQuestions(space: GenieSpace): string[] {\n  const serialized = space.serialized_space;\n  if (!serialized) return [];\n  const parsed = json.parse(serialized);\n  if (parsed === undefined) {\n    logger.warn(\"serialized-space:parse-error\", { spaceId: space.space_id });\n    return [];\n  }\n  const sampleQuestions = (parsed as { config?: { sample_questions?: unknown } } | null)?.config\n    ?.sample_questions;\n  if (!Array.isArray(sampleQuestions)) return [];\n\n  return [\n    ...object\n      .sequence(sampleQuestions as SerializedSampleQuestion[])\n      .map((entry) => string.firstNonEmpty(entry?.question))\n      .nonNull()\n      .distinct(),\n  ];\n}\n"]}

package/package.json

@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/appkit": "0.6.61",
-    "@dbx-tools/shared-core": "0.6.61",
-    "@dbx-tools/shared-genie": "0.6.61"
+    "@dbx-tools/appkit": "0.6.63",
+    "@dbx-tools/shared-core": "0.6.63",
+    "@dbx-tools/shared-genie": "0.6.63"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
@@ -46,7 +46,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.61",
+  "version": "0.6.63",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/space.ts

@@ -10,12 +10,20 @@
  * workspace client's raw `apiClient` since the typed request shape has no flag
  * for it.
  *
+ * The serialized blob is also more privileged than the listing surface: the
+ * workspace API requires `Can Edit` on the space to return it, while `Can Run`
+ * is enough for title / description. A caller that only holds `Can Run` - an
+ * app service principal granted just enough to ask questions is the common case
+ * - would otherwise lose the whole space lookup to a `PERMISSION_DENIED` it
+ * cannot act on, so the fetch degrades to the unserialized request instead of
+ * failing (see {@link getGenieSpace}).
+ *
  * @module
  */
 
 import { WorkspaceClient } from "@databricks/sdk-experimental";
 import { databricks } from "@dbx-tools/appkit";
-import { json, log, object, string } from "@dbx-tools/shared-core";
+import { error, json, log, object, string } from "@dbx-tools/shared-core";
 import { genieModel, type GenieSpace } from "@dbx-tools/shared-genie";
 
 const logger = log.logger("genie/space");
@@ -32,6 +40,10 @@ export interface GetGenieSpaceOptions {
    * Request the `serialized_space` blob (catalogs, tables, sample questions,
    * prompts). Defaults to `true` - the only reason to skip it is when the
    * caller just needs title / description and wants the smaller payload.
+   *
+   * Requesting it is best-effort: the blob needs `Can Edit` on the space, so a
+   * caller without it gets the unserialized space back rather than an error,
+   * and {@link genieSampleQuestions} then reports no suggestions.
    */
   serialized?: boolean;
   /**
@@ -47,6 +59,13 @@ export interface GetGenieSpaceOptions {
  * through the raw `apiClient`, then validates the response against
  * {@link GenieSpaceSchema} (unknown fields like `etag` /
  * `parent_path` are stripped).
+ *
+ * When the serialized request is rejected for lack of permission (`403`, or a
+ * `PERMISSION_DENIED` / `Can Edit` message - the workspace API gates the blob
+ * behind `Can Edit`), it retries once without the flag so the caller still gets
+ * the space. Any other failure, and a retry that fails too, is rethrown: a
+ * cancelled request or a missing space must not look like an unserialized
+ * space.
  */
 export async function getGenieSpace(
   spaceId: string,
@@ -55,19 +74,47 @@ export async function getGenieSpace(
   const client = options?.workspaceClient ?? new WorkspaceClient({});
   const serialized = options?.serialized !== false;
   const ctx = options?.context ? databricks.toContext(options.context) : undefined;
-  const raw = await client.apiClient.request(
-    {
-      path: `/api/2.0/genie/spaces/${encodeURIComponent(spaceId)}`,
-      method: "GET",
-      query: serialized ? { include_serialized_space: true } : {},
-      headers: new Headers(),
-      raw: false,
-    },
-    ctx,
-  );
+  const request = (includeSerialized: boolean): Promise<unknown> =>
+    client.apiClient.request(
+      {
+        path: `/api/2.0/genie/spaces/${encodeURIComponent(spaceId)}`,
+        method: "GET",
+        query: includeSerialized ? { include_serialized_space: true } : {},
+        headers: new Headers(),
+        raw: false,
+      },
+      ctx,
+    );
+
+  let raw: unknown;
+  try {
+    raw = await request(serialized);
+  } catch (err) {
+    if (!serialized || !isSerializedSpaceForbidden(err)) throw err;
+    logger.debug("serialized-space:forbidden", {
+      spaceId,
+      error: error.errorMessage(err),
+    });
+    raw = await request(false);
+  }
   return genieModel.GenieSpaceSchema.parse(raw);
 }
 
+/**
+ * True when a failed space request was rejected for lack of permission, the one
+ * failure the unserialized retry can recover from. Matches on `403` and on the
+ * `PERMISSION_DENIED` / `Can Edit` wording the workspace API returns, since the
+ * SDK surfaces the error code without always carrying a status.
+ */
+function isSerializedSpaceForbidden(err: unknown): boolean {
+  const context = error.errorContext(err);
+  return (
+    context.hasStatusCode(403) ||
+    context.hasMessage("permission denied") ||
+    context.hasMessage("can edit")
+  );
+}
+
 /**
  * One entry in a serialized space's `config.sample_questions`. The
  * author-facing field is `question`, which the wire format models as a string