dataiku-sdk 0.10.1 → 0.12.0

package/dist/src/cli/commands/variable.js

@@ -0,0 +1,49 @@
+import { json, } from "../coerce.js";
+import { UsageError, } from "../usage.js";
+export const variableCommands = {
+    get: {
+        handler: (c, _a, f) => c.variables.get(f["project-key"]),
+        usage: "dss variable get [--project-key KEY]",
+        description: "Get project variables (standard and local).",
+        examples: ["dss variable get", "dss variable get --project-key MYPROJ",],
+    },
+    set: {
+        handler: async (c, _a, f) => {
+            const standard = json(f["standard"]);
+            const local = json(f["local"]);
+            const pk = f["project-key"];
+            if (standard === undefined && local === undefined) {
+                throw new UsageError("--standard and/or --local is required.");
+            }
+            if (f["dry-run"] === true) {
+                const current = await c.variables.get(pk);
+                const next = f["replace"] === true
+                    ? { standard: standard ?? {}, local: local ?? {}, }
+                    : {
+                        standard: { ...current.standard, ...standard, },
+                        local: { ...current.local, ...local, },
+                    };
+                return {
+                    dryRun: true,
+                    action: "set",
+                    resource: "variable",
+                    projectKey: pk,
+                    current,
+                    next,
+                };
+            }
+            return c.variables.set({
+                standard,
+                local,
+                replace: f["replace"] === true,
+                projectKey: pk,
+            });
+        },
+        usage: `dss variable set --standard '{"k":"v"}' --local '{"k":"v"}' [--replace] [--dry-run] [--project-key KEY]`,
+        description: "Set project variables via JSON merge (or full replace with --replace).",
+        examples: [
+            'dss variable set --standard \'{"env":"staging"}\' --dry-run',
+            "dss variable set --local '{\"debug\":true}' --replace",
+        ],
+    },
+};

package/dist/src/cli/commands/webapp.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const webappCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/webapp.js

@@ -0,0 +1,67 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { requireArgs, } from "../usage.js";
+export const webappCommands = {
+    list: {
+        handler: (c, _a, f) => c.webapps.list(f["project-key"]),
+        usage: "dss webapp list [--project-key KEY]",
+        description: "List webapps in a project.",
+        examples: ["dss webapp list",],
+    },
+    "get-settings": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss webapp get-settings <webappId> [--project-key KEY]");
+            return c.webapps.getSettings(a[0], f["project-key"]);
+        },
+        usage: "dss webapp get-settings <webappId> [--project-key KEY]",
+        description: "Get a webapp's settings.",
+        examples: ["dss webapp get-settings WEBAPP_ID",],
+    },
+    create: {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (webapp definition).");
+            return c.webapps.create(body, f["project-key"]);
+        },
+        usage: "dss webapp create (--data JSON|--data-file PATH|--stdin) [--project-key KEY]",
+        description: "Create a webapp from a JSON definition.",
+        examples: ["dss webapp create --data-file webapp.json",],
+    },
+    "update-settings": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss webapp update-settings <webappId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (webapp settings).");
+            return c.webapps.updateSettings(a[0], body, f["project-key"]);
+        },
+        usage: "dss webapp update-settings <webappId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]",
+        description: "Replace a webapp's settings.",
+        examples: ["dss webapp update-settings WEBAPP_ID --data-file webapp.json",],
+    },
+    "stop-backend": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss webapp stop-backend <webappId> [--project-key KEY]");
+            await c.webapps.stopBackend(a[0], f["project-key"]);
+            return { stopped: true, };
+        },
+        usage: "dss webapp stop-backend <webappId> [--project-key KEY]",
+        description: "Stop a webapp's backend.",
+        examples: ["dss webapp stop-backend WEBAPP_ID",],
+    },
+    "restart-backend": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss webapp restart-backend <webappId> [--project-key KEY]");
+            await c.webapps.startOrRestartBackend(a[0], f["project-key"]);
+            return { restarted: true, };
+        },
+        usage: "dss webapp restart-backend <webappId> [--project-key KEY]",
+        description: "Start or restart a webapp's backend.",
+        examples: ["dss webapp restart-backend WEBAPP_ID",],
+    },
+    "backend-state": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss webapp backend-state <webappId> [--project-key KEY]");
+            return c.webapps.getBackendState(a[0], f["project-key"]);
+        },
+        usage: "dss webapp backend-state <webappId> [--project-key KEY]",
+        description: "Get a webapp backend's runtime state.",
+        examples: ["dss webapp backend-state WEBAPP_ID",],
+    },
+};

package/dist/src/cli/commands/wiki.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const wikiCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/wiki.js

@@ -0,0 +1,123 @@
+import { deepMerge, } from "../../utils/deep-merge.js";
+import { jsonInput, textInput, } from "../coerce.js";
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+export const wikiCommands = {
+    settings: {
+        handler: (c, _a, f) => c.wiki.settings(f["project-key"]),
+        usage: "dss wiki settings [--project-key KEY]",
+        description: "Get project wiki settings and taxonomy.",
+        examples: ["dss wiki settings",],
+    },
+    list: {
+        handler: (c, _a, f) => c.wiki.list(f["project-key"]),
+        usage: "dss wiki list [--project-key KEY]",
+        description: "List wiki articles by walking the taxonomy.",
+        examples: ["dss wiki list",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss wiki get <id-or-name>");
+            return c.wiki.get(a[0], f["project-key"]);
+        },
+        usage: "dss wiki get <id-or-name> [--project-key KEY]",
+        description: "Get a wiki article including markdown body.",
+        examples: ["dss wiki get ARTICLE_ID",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const name = f["name"];
+            if (!name)
+                throw new UsageError("--name is required. Usage: dss wiki create --name NAME");
+            const content = textInput(f);
+            const pk = f["project-key"];
+            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+                const existing = (await c.wiki.list(pk)).find((article) => article.article.name === name);
+                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                    return skipResult("wiki", existing.article.id, "exists", { current: existing, });
+                }
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "create",
+                        resource: "wiki",
+                        name,
+                        payload: {
+                            name,
+                            parent: f["parent"],
+                            content,
+                        },
+                        ...(existing ? { current: existing, } : {}),
+                    };
+                }
+            }
+            const created = await c.wiki.create({
+                name,
+                parent: f["parent"],
+                content,
+                projectKey: pk,
+            });
+            return { created: created.article.id, resource: "wiki", ...created, };
+        },
+        usage: "dss wiki create --name NAME [--parent ID] [--content TEXT|--file PATH] [--if-not-exists] [--dry-run] [--project-key KEY]",
+        description: "Create a wiki article, optionally with markdown content.",
+        examples: [
+            "dss wiki create --name 'Agent notes' --content '# Notes'",
+            "dss wiki create --name 'Agent notes' --file article.md --dry-run",
+        ],
+    },
+    update: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss wiki update <id-or-name> [--name NAME] [--content TEXT|--file PATH|--data JSON]");
+            const data = jsonInput(f);
+            const content = textInput(f);
+            const name = f["name"];
+            if (!data && content === undefined && name === undefined) {
+                throw new UsageError("--name, --content, --file, --data, --data-file, or --stdin is required.");
+            }
+            if (f["dry-run"] === true) {
+                const current = await c.wiki.get(a[0], f["project-key"]);
+                const next = deepMerge(current, data ?? {});
+                if (name !== undefined) {
+                    next.article = {
+                        ...((next.article && typeof next.article === "object" && !Array.isArray(next.article))
+                            ? next.article
+                            : {}),
+                        name,
+                    };
+                }
+                if (content !== undefined)
+                    next.payload = content;
+                return { dryRun: true, action: "update", resource: "wiki", article: a[0], current, next, };
+            }
+            return c.wiki.update(a[0], {
+                name,
+                content,
+                data,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss wiki update <id-or-name> [--name NAME] [--content TEXT|--file PATH|--data JSON|--data-file PATH|--stdin] [--dry-run] [--project-key KEY]",
+        description: "Update wiki article metadata/body via merge.",
+        examples: ["dss wiki update ARTICLE_ID --content '# Updated' --dry-run",],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss wiki delete <id-or-name>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.wiki.get(a[0], pk));
+                if (!current)
+                    return skipResult("wiki", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "wiki", article: a[0], current, };
+                }
+            }
+            await c.wiki.delete(a[0], pk);
+            return { deleted: a[0], resource: "wiki", };
+        },
+        usage: "dss wiki delete <id-or-name> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a wiki article.",
+        examples: ["dss wiki delete ARTICLE_ID --dry-run",],
+    },
+};

package/dist/src/cli/commands/workspace.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const workspaceCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/workspace.js

@@ -0,0 +1,68 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { requireArgs, } from "../usage.js";
+export const workspaceCommands = {
+    list: {
+        handler: (c) => c.workspaces.list(),
+        usage: "dss workspace list",
+        description: "List collaboration workspaces on the instance.",
+        examples: ["dss workspace list",],
+    },
+    get: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss workspace get <workspaceKey>");
+            return c.workspaces.get(a[0]);
+        },
+        usage: "dss workspace get <workspaceKey>",
+        description: "Get a workspace's settings.",
+        examples: ["dss workspace get MY_WS",],
+    },
+    create: {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (workspace definition).");
+            return c.workspaces.create(body);
+        },
+        usage: "dss workspace create (--data JSON|--data-file PATH|--stdin)",
+        description: "Create a collaboration workspace.",
+        examples: ["dss workspace create --data-file ws.json",],
+    },
+    "update-settings": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss workspace update-settings <workspaceKey> (--data JSON|--data-file PATH|--stdin)");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (workspace settings).");
+            await c.workspaces.updateSettings(a[0], body);
+            return { updated: a[0], };
+        },
+        usage: "dss workspace update-settings <workspaceKey> (--data JSON|--data-file PATH|--stdin)",
+        description: "Replace a workspace's settings (admin).",
+        examples: ["dss workspace update-settings MY_WS --data-file ws.json",],
+    },
+    delete: {
+        handler: async (c, a) => {
+            requireArgs(a, 1, "dss workspace delete <workspaceKey>");
+            await c.workspaces.delete(a[0]);
+            return { deleted: a[0], };
+        },
+        usage: "dss workspace delete <workspaceKey>",
+        description: "Delete a workspace (admin).",
+        examples: ["dss workspace delete MY_WS",],
+    },
+    "list-objects": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss workspace list-objects <workspaceKey>");
+            return c.workspaces.listObjects(a[0]);
+        },
+        usage: "dss workspace list-objects <workspaceKey>",
+        description: "List objects shared in a workspace.",
+        examples: ["dss workspace list-objects MY_WS",],
+    },
+    "add-object": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss workspace add-object <workspaceKey> (--data JSON|--data-file PATH|--stdin)");
+            const object = requiredJsonInput(f, "--data, --data-file, or --stdin is required (object definition).");
+            return c.workspaces.addObject(a[0], object);
+        },
+        usage: "dss workspace add-object <workspaceKey> (--data JSON|--data-file PATH|--stdin)",
+        description: "Add an object (link or DSS object) to a workspace.",
+        examples: ["dss workspace add-object MY_WS --data-file object.json",],
+    },
+};

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

@@ -0,0 +1,104 @@
+import type { CommandFlagChoice, CommandMeta, CommandPayloadSchema } from "./types.js";
+export declare const AUTH_ACTIONS: Record<string, {
+    handler: (flags: Record<string, string | boolean>) => Promise<unknown>;
+    usage: string;
+    description?: string;
+    examples?: string[];
+    requiredFlags?: string[];
+}>;
+export type CommandSideEffect = "read" | "write" | "auth";
+export type CommandOutputShape = "object" | "array" | "string" | "void";
+export type CommandDestructiveLevel = "none" | "reversible" | "destructive";
+export type CommandAsyncKind = "none" | "job" | "future";
+export type CommandIdempotency = "safe" | "convergent" | "if-not-exists" | "if-exists" | "none";
+export interface CommandInputContract {
+    stdin?: boolean;
+    dataFlag?: boolean;
+    dataFileFlag?: boolean;
+}
+export interface CommandExitCodes {
+    ok: 0;
+    usage: 1;
+    error: 2;
+    transient: 3;
+    longRunningFailure?: 4;
+}
+export type CommandFlagMetadata = {
+    name: string;
+    kind: "boolean" | "value";
+    valueType?: string;
+    enumValues?: string[];
+    aliases?: string[];
+};
+export interface CommandStructuredExample {
+    shell: string;
+    argv?: string[];
+    payload?: unknown;
+}
+export interface CommandUnsafeOutput {
+    condition: string;
+    kind: "raw-stdout" | "local-file";
+    detail: string;
+    safeAlternative?: string;
+}
+export interface CommandAgentSchemas {
+    argv: Record<string, unknown>;
+    input?: Record<string, unknown>;
+    output: Record<string, unknown>;
+}
+export interface CommandRegistryEntry {
+    resource: string;
+    action: string;
+    usage: string;
+    description?: string;
+    examples?: string[];
+    structuredExamples: CommandStructuredExample[];
+    flags: CommandFlagMetadata[];
+    positionals: string[];
+    sideEffect: CommandSideEffect;
+    requiresAuth: boolean;
+    requiresProject: boolean;
+    outputShape: CommandOutputShape;
+    inputContract: CommandInputContract;
+    destructive: CommandDestructiveLevel;
+    producesLocalFile: boolean;
+    mutatesDss: boolean;
+    async: CommandAsyncKind;
+    idempotency: CommandIdempotency;
+    dryRun: boolean;
+    requiredFlags: string[];
+    requiredOneOf?: CommandFlagChoice[];
+    optionalFlags: string[];
+    payloadSchema?: CommandPayloadSchema;
+    schemas: CommandAgentSchemas;
+    unsafeOutputs?: CommandUnsafeOutput[];
+    examplePayload?: unknown;
+    cleanupCommand?: string;
+    exitCodes: CommandExitCodes;
+    cleanupHint?: string;
+    agentContractVersion: number;
+}
+export declare const COMMANDS_USAGE = "dss commands run [--json]";
+export declare const AGENT_CONTRACT_USAGE = "dss agent contract";
+export declare const CLEANUP_USAGE = "dss cleanup --file PATH [--dry-run|--apply] [--continue-on-error]";
+export declare function isAllowedCleanupAction(resource: string, action: string): boolean;
+export declare function buildCommandSchemas(resource: string, action: string, flags: CommandFlagMetadata[], positionals: string[], requiredFlags: string[], requiredOneOf: CommandFlagChoice[], payloadSchema: CommandPayloadSchema | undefined, outputShape: CommandOutputShape): CommandAgentSchemas;
+export declare function inferRequiresProject(resource: string, _action: string, usage: string): boolean;
+export declare function inferInputContract(usage: string): CommandInputContract;
+export declare function supportsCleanupLedger(resource: string, action: string): boolean;
+export declare function inferCleanupHint(resource: string, action: string): string | undefined;
+export declare function buildCommandRegistry(): Record<string, Record<string, CommandRegistryEntry>>;
+export declare function agentContractJsonSchema(): Record<string, unknown>;
+export declare function buildAgentContract(): Record<string, unknown>;
+export declare function commandPlanShape(resource: string, action: string, args: string[], flags: Record<string, string | boolean>, entry: CommandRegistryEntry, projectKey: string | undefined): {
+    endpoint?: string;
+    identifiers?: Record<string, unknown>;
+    method?: string;
+    payload?: unknown;
+    localWrites?: unknown;
+    wait?: unknown;
+};
+export declare function buildMutationPlan(resource: string, action: string, meta: CommandMeta, args: string[], flags: Record<string, string | boolean>): Record<string, unknown>;
+export declare const BATCH_USAGE = "dss batch (--data JSON|--data-file PATH|--stdin) [--continue-on-error] [--dry-run]";
+export declare const BATCH_HINT = "Pass a JSON array of argv arrays, e.g. [[\"dataset\",\"list\"],[\"recipe\",\"update\",\"r\",\"--data-file\",\"p.json\"]].";
+export declare const BATCH_EXAMPLE_PAYLOAD: string[][];