dataiku-sdk 3.6.1 → 3.7.0

package/dist/src/cli/list-shapes.js

@@ -0,0 +1,111 @@
+/**
+ * Compact `RESOURCE.list` item shapes, as plain data shared by the runtime
+ * mapper (src/cli/list-output.ts) and the discovery output schemas
+ * (src/cli/output-schemas.ts), so the advertised schema is the emitted shape.
+ */
+const STRING = { type: ["string", "null",], };
+const BOOLEAN = { type: ["boolean", "null",], };
+const NUMBER = { type: ["number", "null",], };
+const STRINGS = { type: "array", items: { type: "string", }, };
+const field = (path, schema) => ({
+    path,
+    schema,
+});
+/**
+ * Lists whose DSS objects are large: the identifier the follow-up get/build
+ * commands take, the kind, and the one or two attributes that decide what to
+ * call next. Lists not named here keep the DSS objects.
+ */
+export const COMPACT_LIST_FIELDS = {
+    project: {
+        projectKey: field("projectKey", STRING),
+        name: field("name", STRING),
+        ownerLogin: field("ownerLogin", STRING),
+    },
+    dataset: {
+        name: field("name", STRING),
+        type: field("type", STRING),
+        managed: field("managed", BOOLEAN),
+        connection: field("params.connection", STRING),
+    },
+    recipe: {
+        name: field("name", STRING),
+        type: field("type", STRING),
+        inputs: { path: "inputs", roleRefs: true, schema: STRINGS, },
+        outputs: { path: "outputs", roleRefs: true, schema: STRINGS, },
+    },
+    scenario: {
+        id: field("id", STRING),
+        name: field("name", STRING),
+        type: field("type", STRING),
+        active: field("active", BOOLEAN),
+        running: field("running", BOOLEAN),
+    },
+    folder: {
+        id: field("id", STRING),
+        name: field("name", STRING),
+        type: field("type", STRING),
+        connection: field("params.connection", STRING),
+    },
+    job: {
+        id: field("def.id", STRING),
+        name: field("def.name", STRING),
+        type: field("def.type", STRING),
+        state: field("state", STRING),
+        startTime: field("startTime", NUMBER),
+        endTime: field("endTime", NUMBER),
+    },
+    "code-env": {
+        envName: field("envName", STRING),
+        envLang: field("envLang", STRING),
+        deploymentMode: field("deploymentMode", STRING),
+    },
+    future: {
+        jobId: field("jobId", STRING),
+        owner: field("owner", STRING),
+        alive: field("alive", BOOLEAN),
+        hasResult: field("hasResult", BOOLEAN),
+        runningTime: field("runningTime", NUMBER),
+    },
+    user: {
+        login: field("login", STRING),
+        displayName: field("displayName", STRING),
+        userProfile: field("userProfile", STRING),
+        groups: field("groups", STRINGS),
+        enabled: field("enabled", BOOLEAN),
+    },
+    group: {
+        name: field("name", STRING),
+        description: field("description", STRING),
+        admin: field("admin", BOOLEAN),
+    },
+    plugin: {
+        id: field("id", STRING),
+        version: field("version", STRING),
+        label: field("meta.label", STRING),
+    },
+    macro: {
+        runnableType: field("runnableType", STRING),
+        ownerPluginId: field("ownerPluginId", STRING),
+        label: field("meta.label", STRING),
+    },
+    meaning: {
+        id: field("id", STRING),
+        label: field("label", STRING),
+        type: field("type", STRING),
+    },
+};
+/** Discovery output schemas of the compact `RESOURCE.list` defaults. */
+export function compactListOutputSchemas() {
+    return Object.fromEntries(Object.entries(COMPACT_LIST_FIELDS).map(([resource, fields,]) => [
+        `${resource}.list`,
+        {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: Object.fromEntries(Object.entries(fields).map(([name, spec,]) => [name, spec.schema,])),
+            },
+        },
+    ]));
+}

package/dist/src/cli/output-schemas.d.ts

@@ -1,17 +1,3 @@
-/**
- * Canonical discovery output schemas, keyed by `resource.action`.
- *
- * TypeBox definitions from `packages/types` plus the inline literal schemas
- * that exist only on the CLI side (code-env log envelope, code.run outcome,
- * project-library payloads, notebook saves, sql.query handoff envelope).
- * `scripts/generate-action-output-schemas.mjs` serializes this map into
- * `src/generated/action-output-schemas.json`; discovery (src/cli/contract.ts)
- * reads that generated JSON as plain data, so the TypeBox schema graph never
- * loads on the discovery path. SDK validation keeps using the TypeBox schema
- * objects from `packages/types` directly.
- *
- * Imported by the generator and the discovery parity test only.
- */
 /**
  * Canonical TypeBox-derived output schemas, keyed by `resource.action`. This is
  * the single source of truth for `src/generated/action-output-schemas.json`,

package/dist/src/cli/output-schemas.js

@@ -12,6 +12,7 @@
  *
  * Imported by the generator and the discovery parity test only.
  */
+import { compactListOutputSchemas, } from "./list-shapes.js";
 const PROJECT_LIBRARY_ITEM_OUTPUT_SCHEMA = {
     type: "object",
     additionalProperties: false,
@@ -62,9 +63,8 @@ let commandOutputSchemas;
 export function typeBoxCommandOutputSchemas() {
     if (commandOutputSchemas)
         return commandOutputSchemas;
-    const { CodeEnvDetailsSchema, CodeEnvLogSummaryArraySchema, CodeEnvSummaryArraySchema, CodeEnvUsageArraySchema, CodeEnvVersionForProjectSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, FlowZoneArraySchema, FlowZoneSchema, JobSummaryArraySchema, JobWaitResultSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, NotebookSessionArraySchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, RecipeSummaryArraySchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, SqlNotebookContentSchema, SqlNotebookHistorySchema, SqlNotebookSummaryArraySchema, SqlQueryResponseSchema, } = require("../schemas.js");
+    const { CodeEnvDetailsSchema, CodeEnvLogSummaryArraySchema, CodeEnvUsageArraySchema, CodeEnvVersionForProjectSchema, DatasetDetailsSchema, DatasetSchemaSchema, FlowZoneArraySchema, FlowZoneSchema, JobWaitResultSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, NotebookSessionArraySchema, ProjectDetailsSchema, ProjectMetadataSchema, ScenarioDetailsSchema, ScenarioStatusSchema, SqlNotebookContentSchema, SqlNotebookHistorySchema, SqlNotebookSummaryArraySchema, SqlQueryResponseSchema, } = require("../schemas.js");
     return commandOutputSchemas = {
-        "code-env.list": CodeEnvSummaryArraySchema,
         "code-env.get": CodeEnvDetailsSchema,
         "code-env.list-logs": CodeEnvLogSummaryArraySchema,
         "code-env.get-log": {
@@ -196,17 +196,12 @@ export function typeBoxCommandOutputSchemas() {
                 maxLines: { type: "integer", minimum: 0, },
             },
         },
-        "project.list": ProjectSummaryArraySchema,
         "project.get": ProjectDetailsSchema,
         "project.metadata": ProjectMetadataSchema,
-        "dataset.list": DatasetSummaryArraySchema,
         "dataset.get": DatasetDetailsSchema,
         "dataset.schema": DatasetSchemaSchema,
-        "recipe.list": RecipeSummaryArraySchema,
-        "job.list": JobSummaryArraySchema,
         "job.wait": JobWaitResultSchema,
         "job.monitor": JobWaitResultSchema,
-        "scenario.list": ScenarioSummaryArraySchema,
         "scenario.get": ScenarioDetailsSchema,
         "scenario.status": ScenarioStatusSchema,
         "flow-zone.list": FlowZoneArraySchema,
@@ -229,5 +224,7 @@ export function typeBoxCommandOutputSchemas() {
                 },
             ],
         },
+        // `*.list` defaults to compact items; `--full` returns the DSS objects.
+        ...compactListOutputSchemas(),
     };
 }

package/dist/src/cli/output.d.ts

@@ -12,7 +12,6 @@ export declare function pickResultFields(item: unknown, fields: string[]): unkno
  */
 export declare function projectResultFields(result: unknown, fields: string[], availableFieldNames?: () => string[]): unknown;
 export declare function writeCommandResult(result: unknown): void;
-export declare function transientBodyWithTargetContext(body: string, target: string, elapsedMs: number): string;
 export declare function addTransientTargetContext(error: unknown, target: string, elapsedMs: number): never;
 export declare function isFailedWaitResult(result: unknown): boolean;
 export declare function isAssertionFailureResult(result: unknown): boolean;

package/dist/src/cli/output.js

@@ -34,6 +34,29 @@ function resolveFieldPath(source, field) {
     }
     return { found: true, value: current ?? null, };
 }
+/**
+ * Keys available at the deepest parent object a dotted field actually reaches.
+ * A miss like `recipe.params` is ambiguous — the path may be unsupported or the
+ * key may merely be absent — so listing sibling keys under the resolved parent
+ * (`recipe.type`, `recipe.name`, ...) shows nested paths work and points at
+ * real alternatives; a plain top-level miss keeps listing top-level keys.
+ */
+function availableFieldsFor(records, field) {
+    const segments = field.split(".");
+    const parentPath = segments.slice(0, -1).join(".");
+    const keys = new Set();
+    for (const record of records) {
+        const parent = parentPath === ""
+            ? record
+            : resolveFieldPath(record, parentPath).value;
+        if (parent === null || typeof parent !== "object" || Array.isArray(parent))
+            continue;
+        for (const key of Object.keys(parent)) {
+            keys.add(parentPath === "" ? key : `${parentPath}.${key}`);
+        }
+    }
+    return [...keys,].sort();
+}
 export function pickResultFields(item, fields) {
     if (!item || typeof item !== "object" || Array.isArray(item))
         return item;
@@ -54,8 +77,9 @@ function warnUnknownProjectionFields(result, fields, availableFieldNames) {
     const unknownFields = fields.filter((field) => !records.some((record) => resolveFieldPath(record, field).found));
     if (unknownFields.length === 0)
         return;
-    const availableFields = availableFieldNames?.()
-        ?? [...new Set(records.flatMap((record) => Object.keys(record))),].sort();
+    const explicitNames = availableFieldNames?.();
+    const availableFields = explicitNames
+        ?? [...new Set(unknownFields.flatMap((field) => availableFieldsFor(records, field))),].sort();
     enqueueCliWarning({
         code: "field_projection_missing",
         fields: unknownFields,
@@ -81,25 +105,9 @@ export function writeCommandResult(result) {
     flushCliWarnings();
     process.stdout.write(`${JSON.stringify(projected ?? { ok: true, })}\n`);
 }
-export function transientBodyWithTargetContext(body, target, elapsedMs) {
-    try {
-        const parsed = JSON.parse(body);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            const record = parsed;
-            const message = typeof record.message === "string" && record.message.length > 0
-                ? `Target: ${target}\nElapsed: ${elapsedMs}ms\n${record.message}`
-                : `Target: ${target}\nElapsed: ${elapsedMs}ms`;
-            return JSON.stringify({ ...record, message, target, elapsedMs, });
-        }
-    }
-    catch {
-        // Non-JSON DSS bodies are wrapped as text below.
-    }
-    return `Target: ${target}\nElapsed: ${elapsedMs}ms\n${body}`;
-}
 export function addTransientTargetContext(error, target, elapsedMs) {
     if (error instanceof DataikuError && error.category === "transient") {
-        throw new DataikuError(error.status, error.statusText, transientBodyWithTargetContext(error.body, target, elapsedMs), error.retry, error.requestId, { target, elapsedMs, bodyTruncated: error.bodyTruncated, });
+        throw new DataikuError(error.status, error.statusText, error.body, error.retry, error.requestId, { target, elapsedMs, bodyTruncated: error.bodyTruncated, });
     }
     throw error;
 }

package/dist/src/cli/plans.d.ts

@@ -0,0 +1,14 @@
+import { type CommandRegistryEntry } from "./contract.js";
+import type { CommandMeta } from "./types.js";
+export declare function commandPlanShape(resource: string, action: string, args: string[], flags: Record<string, string | boolean>, entry: CommandRegistryEntry, projectKey: string | undefined): {
+    endpoint?: string;
+    exact?: boolean;
+    identifiers?: Record<string, unknown>;
+    method?: string;
+    payload?: unknown;
+    localWrites?: unknown;
+    reason?: string;
+    wait?: unknown;
+    requests?: unknown;
+};
+export declare function buildMutationPlan(resource: string, action: string, meta: CommandMeta, args: string[], flags: Record<string, string | boolean>): Record<string, unknown>;