dataiku-sdk 0.10.1 → 0.12.0

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

@@ -0,0 +1,202 @@
+import { deepMerge, } from "../../utils/deep-merge.js";
+import { jsonInput, } from "../coerce.js";
+import { addTransientTargetContext, encodedProjectEndpoint, readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+async function resolveFolderId(client, nameOrId, flags) {
+    return client.folders.resolveId(nameOrId, flags["project-key"]);
+}
+export const folderCommands = {
+    list: {
+        handler: (c, _a, f) => c.folders.list(f["project-key"]),
+        usage: "dss folder list [--project-key KEY]",
+        description: "List managed folders in a project.",
+        examples: ["dss folder list",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const name = f["name"];
+            const type = f["type"];
+            const connection = f["connection"];
+            const pk = f["project-key"];
+            if (!name || !type || !connection) {
+                throw new UsageError("--name, --type, and --connection are required. Usage: dss folder create --name NAME --type TYPE --connection CONN [--path PATH]");
+            }
+            const payload = {
+                name,
+                type,
+                connection,
+                path: f["path"],
+                projectKey: pk,
+            };
+            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+                const list = await c.folders.list(pk);
+                const existing = list.find((folder) => folder.name === name);
+                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                    return skipResult("folder", existing.id ?? name, "exists", { current: existing, });
+                }
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "create",
+                        resource: "folder",
+                        name,
+                        payload,
+                        ...(existing ? { current: existing, } : {}),
+                    };
+                }
+            }
+            const created = await c.folders.create(payload);
+            return { created: created.id ?? name, resource: "folder", ...created, };
+        },
+        usage: "dss folder create --name NAME --type TYPE --connection CONN [--path PATH] [--if-not-exists] [--dry-run] [--project-key KEY]",
+        description: "Create a managed folder.",
+        examples: [
+            "dss folder create --name exports --type S3 --connection s3_connection",
+            "dss folder create --name exports --type S3 --connection s3_connection --path /dataiku/MYPROJ/exports --dry-run",
+        ],
+    },
+    get: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss folder get <name-or-id>");
+            return c.folders.get(await resolveFolderId(c, a[0], f), f["project-key"]);
+        },
+        usage: "dss folder get <name-or-id> [--project-key KEY]",
+        description: "Get managed folder settings.",
+        examples: ["dss folder get my_folder",],
+    },
+    update: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss folder update <name-or-id> [--data '{...}' | --data-file PATH | --stdin]");
+            const data = jsonInput(f);
+            if (!data) {
+                throw new UsageError("--data, --data-file, or --stdin is required. Usage: dss folder update <name-or-id> [--data '{...}' | --data-file PATH | --stdin]");
+            }
+            const pk = f["project-key"];
+            const folderId = await resolveFolderId(c, a[0], f);
+            if (f["dry-run"] === true) {
+                const current = await c.folders.get(folderId, pk);
+                const next = deepMerge(current, data);
+                return {
+                    dryRun: true,
+                    action: "update",
+                    resource: "folder",
+                    folder: a[0],
+                    folderId,
+                    current,
+                    next,
+                };
+            }
+            await c.folders.update(folderId, data, pk);
+            return { updated: folderId, resource: "folder", };
+        },
+        usage: "dss folder update <name-or-id> [--data JSON | --data-file PATH | --stdin] [--dry-run] [--project-key KEY]",
+        description: "Update managed folder settings by deep-merging a JSON patch.",
+        examples: [
+            'dss folder update exports --data \'{"tags":["agent"]}\' --dry-run',
+            "dss folder update exports --data-file folder-patch.json",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss folder delete <name-or-id>");
+            const pk = f["project-key"];
+            const folderId = await resolveFolderId(c, a[0], f);
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.folders.get(folderId, pk));
+                if (!current)
+                    return skipResult("folder", folderId, "missing");
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "delete",
+                        resource: "folder",
+                        folder: a[0],
+                        folderId,
+                        current,
+                    };
+                }
+            }
+            await c.folders.delete(folderId, pk);
+            return { deleted: folderId, resource: "folder", };
+        },
+        usage: "dss folder delete <name-or-id> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a managed folder.",
+        examples: ["dss folder delete exports --if-exists",],
+    },
+    contents: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss folder contents <name-or-id>");
+            const startedAt = Date.now();
+            let folderId = a[0];
+            try {
+                folderId = await resolveFolderId(c, a[0], f);
+                return await c.folders.contents(folderId, {
+                    projectKey: f["project-key"],
+                });
+            }
+            catch (error) {
+                addTransientTargetContext(error, `folder:${folderId}`, Date.now() - startedAt);
+            }
+        },
+        usage: "dss folder contents <name-or-id> [--retries N] [--request-timeout MS] [--project-key KEY]",
+        description: "List files in a managed folder.",
+        examples: [
+            "dss folder contents my_folder",
+            "dss folder contents my_folder --retries 8 --request-timeout 60000",
+        ],
+    },
+    download: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss folder download <name-or-id> <remote-path> [local-path]");
+            const localPath = a[2] ?? f["output"];
+            return c.folders.download(await resolveFolderId(c, a[0], f), a[1], {
+                localPath,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss folder download <name-or-id> <remote-path> [local-path] [--output PATH] [--project-key KEY]",
+        description: "Download a file from a managed folder.",
+        examples: [
+            "dss folder download my_folder /data/report.csv",
+            "dss folder download my_folder /data/report.csv ./report.csv",
+        ],
+    },
+    upload: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 3, "dss folder upload <name-or-id> <path> <localPath>");
+            const pk = f["project-key"];
+            const folderId = await resolveFolderId(c, a[0], f);
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "upload",
+                    resource: "folder",
+                    folder: a[0],
+                    folderId,
+                    path: a[1],
+                    localPath: a[2],
+                    endpoint: encodedProjectEndpoint(c, pk, `/managedfolders/${encodeURIComponent(folderId)}/contents/${encodeURIComponent(a[1])}`),
+                    method: "POST",
+                };
+            }
+            await c.folders.upload(folderId, a[1], a[2], pk);
+            return { uploaded: a[1], folder: a[0], localPath: a[2], resource: "folder", };
+        },
+        usage: "dss folder upload <name-or-id> <path> <localPath> [--dry-run] [--project-key KEY]",
+        description: "Upload a local file to a managed folder.",
+        examples: ["dss folder upload my_folder /data/report.csv ./report.csv --dry-run",],
+    },
+    "delete-file": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss folder delete-file <name-or-id> <path>");
+            if (f["dry-run"] === true) {
+                return { dryRun: true, action: "delete-file", resource: "folder", folder: a[0], path: a[1], };
+            }
+            await c.folders.deleteFile(await resolveFolderId(c, a[0], f), a[1], f["project-key"]);
+            return { deleted: a[1], folder: a[0], resource: "folder", };
+        },
+        usage: "dss folder delete-file <name-or-id> <path> [--dry-run] [--project-key KEY]",
+        description: "Delete a file from a managed folder.",
+        examples: ["dss folder delete-file my_folder /data/report.csv",],
+    },
+};

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

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

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

@@ -0,0 +1,57 @@
+import { num, } from "../coerce.js";
+import { planResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+export const futureCommands = {
+    get: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss future get <id>");
+            return c.futures.get(a[0]);
+        },
+        usage: "dss future get <id>",
+        description: "Get a DSS future state and retrieve the result if ready.",
+        examples: ["dss future get FUTURE_ID",],
+    },
+    peek: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss future peek <id>");
+            return c.futures.peek(a[0]);
+        },
+        usage: "dss future peek <id>",
+        description: "Peek at a DSS future state without consuming its result.",
+        examples: ["dss future peek FUTURE_ID",],
+    },
+    wait: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss future wait <id>");
+            return c.futures.wait(a[0], {
+                pollIntervalMs: num(f["poll-interval"]),
+                timeoutMs: num(f["timeout"]),
+            });
+        },
+        usage: "dss future wait <id> [--timeout MS] [--poll-interval MS]",
+        description: "Wait for a DSS future to finish.",
+        examples: ["dss future wait FUTURE_ID --timeout 60000",],
+    },
+    abort: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss future abort <id>");
+            const id = a[0];
+            if (f["dry-run"] === true) {
+                return planResult("future", "abort", {
+                    method: "POST",
+                    endpoint: `/public/api/futures/${encodeURIComponent(id)}/abort`,
+                    identifiers: { id, },
+                    idempotency: "none",
+                    asyncKind: "future",
+                    exitCodesOnFailure: { usage: 1, error: 2, transient: 3, longRunningFailure: 4, },
+                    plannedAndDryRun: true,
+                });
+            }
+            await c.futures.abort(id);
+            return { aborted: id, resource: "future", };
+        },
+        usage: "dss future abort <id> [--dry-run]",
+        description: "Abort a DSS future.",
+        examples: ["dss future abort FUTURE_ID --dry-run",],
+    },
+};

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

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

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

@@ -0,0 +1,78 @@
+import { analysisCommands, } from "./analysis.js";
+import { apiDeployerCommands, } from "./api-deployer.js";
+import { apiServiceCommands, } from "./api-service.js";
+import { appCommands, } from "./app.js";
+import { bundleCommands, } from "./bundle.js";
+import { businessAppCommands, } from "./business-app.js";
+import { codeEnvCommands, } from "./code-env.js";
+import { codeCommands, } from "./code.js";
+import { connectionCommands, } from "./connection.js";
+import { continuousActivityCommands, } from "./continuous-activity.js";
+import { dashboardCommands, } from "./dashboard.js";
+import { dataQualityCommands, } from "./data-quality.js";
+import { datasetCommands, } from "./dataset.js";
+import { discussionCommands, } from "./discussion.js";
+import { doctorCommands, } from "./doctor.js";
+import { flowZoneCommands, } from "./flow-zone.js";
+import { folderCommands, } from "./folder.js";
+import { futureCommands, } from "./future.js";
+import { insightCommands, } from "./insight.js";
+import { jobCommands, } from "./job.js";
+import { meaningCommands, } from "./meaning.js";
+import { metricsCommands, } from "./metrics.js";
+import { mlTaskCommands, } from "./ml-task.js";
+import { modelEvaluationStoreCommands, } from "./model-evaluation-store.js";
+import { notebookCommands, } from "./notebook.js";
+import { projectDeployerCommands, } from "./project-deployer.js";
+import { projectLibraryCommands, } from "./project-library.js";
+import { projectCommands, } from "./project.js";
+import { recipeCommands, } from "./recipe.js";
+import { savedModelCommands, } from "./saved-model.js";
+import { scenarioCommands, } from "./scenario.js";
+import { sqlCommands, } from "./sql.js";
+import { statisticsCommands, } from "./statistics.js";
+import { streamingEndpointCommands, } from "./streaming-endpoint.js";
+import { variableCommands, } from "./variable.js";
+import { webappCommands, } from "./webapp.js";
+import { wikiCommands, } from "./wiki.js";
+import { workspaceCommands, } from "./workspace.js";
+export const commands = {
+    project: projectCommands,
+    analysis: analysisCommands,
+    "ml-task": mlTaskCommands,
+    "saved-model": savedModelCommands,
+    "model-evaluation-store": modelEvaluationStoreCommands,
+    app: appCommands,
+    "business-app": businessAppCommands,
+    webapp: webappCommands,
+    "api-service": apiServiceCommands,
+    "api-deployer": apiDeployerCommands,
+    bundle: bundleCommands,
+    "project-deployer": projectDeployerCommands,
+    "project-library": projectLibraryCommands,
+    "streaming-endpoint": streamingEndpointCommands,
+    "continuous-activity": continuousActivityCommands,
+    statistics: statisticsCommands,
+    discussion: discussionCommands,
+    meaning: meaningCommands,
+    workspace: workspaceCommands,
+    metrics: metricsCommands,
+    doctor: doctorCommands,
+    wiki: wikiCommands,
+    dashboard: dashboardCommands,
+    insight: insightCommands,
+    "data-quality": dataQualityCommands,
+    future: futureCommands,
+    "flow-zone": flowZoneCommands,
+    dataset: datasetCommands,
+    recipe: recipeCommands,
+    job: jobCommands,
+    scenario: scenarioCommands,
+    folder: folderCommands,
+    variable: variableCommands,
+    connection: connectionCommands,
+    "code-env": codeEnvCommands,
+    sql: sqlCommands,
+    code: codeCommands,
+    notebook: notebookCommands,
+};

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

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

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

@@ -0,0 +1,156 @@
+import { deepMerge, } from "../../utils/deep-merge.js";
+import { json, jsonInput, parseBooleanOption, textInput, } from "../coerce.js";
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+export const insightCommands = {
+    list: {
+        handler: (c, _a, f) => c.insights.list(f["project-key"]),
+        usage: "dss insight list [--project-key KEY]",
+        description: "List project insights.",
+        examples: ["dss insight list",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss insight get <id>");
+            return c.insights.get(a[0], f["project-key"]);
+        },
+        usage: "dss insight get <id> [--project-key KEY]",
+        description: "Get insight definition.",
+        examples: ["dss insight get INSIGHT_ID",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const data = jsonInput(f);
+            const name = f["name"];
+            const type = f["type"];
+            const params = json(f["params"]);
+            const listed = parseBooleanOption(f["listed"], "--listed");
+            const contentType = f["content-type"];
+            const payload = textInput(f);
+            if (!data && (!name || !type)) {
+                throw new UsageError("--data or both --name and --type are required. Usage: dss insight create --name NAME --type TYPE");
+            }
+            const prototype = { ...data, };
+            if (name !== undefined)
+                prototype.name = name;
+            if (type !== undefined)
+                prototype.type = type;
+            if (listed !== undefined)
+                prototype.listed = listed;
+            if (params !== undefined)
+                prototype.params = params;
+            const pk = f["project-key"];
+            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+                const existing = name
+                    ? (await c.insights.list(pk)).find((insight) => insight.name === name)
+                    : undefined;
+                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                    return skipResult("insight", existing.id, "exists", { current: existing, });
+                }
+                if (f["if-not-exists"] === true && !name && f["dry-run"] !== true) {
+                    throw new UsageError("--if-not-exists requires --name for insight create.");
+                }
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "create",
+                        resource: "insight",
+                        name,
+                        payload: prototype,
+                        contentType,
+                        content: payload,
+                        ...(existing ? { current: existing, } : {}),
+                    };
+                }
+            }
+            const created = await c.insights.create({
+                data,
+                name,
+                type,
+                listed,
+                params,
+                contentType,
+                payload,
+                projectKey: pk,
+            });
+            return { created: created.id, resource: "insight", ...created, };
+        },
+        usage: "dss insight create (--data JSON|--data-file PATH|--stdin | --name NAME --type TYPE [--params JSON] [--listed true|false]) [--content TEXT|--file PATH --content-type MIME] [--if-not-exists] [--dry-run] [--project-key KEY]",
+        description: "Create an insight from a raw prototype or minimal name/type fields.",
+        examples: [
+            "dss insight create --name 'Agent chart' --type chart --params '{\"dataset\":\"orders\"}' --dry-run",
+            "dss insight create --data-file insight-prototype.json --dry-run",
+        ],
+    },
+    update: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss insight update <id> [--name NAME|--params JSON|--data JSON]");
+            const data = jsonInput(f);
+            const name = f["name"];
+            const params = json(f["params"]);
+            const listed = parseBooleanOption(f["listed"], "--listed");
+            const contentType = f["content-type"];
+            const payload = textInput(f);
+            if (!data && name === undefined && params === undefined && listed === undefined
+                && contentType === undefined && payload === undefined) {
+                throw new UsageError("--name, --listed, --params, --content, --file, --data, --data-file, or --stdin is required.");
+            }
+            if (f["dry-run"] === true) {
+                const current = await c.insights.get(a[0], f["project-key"]);
+                const next = deepMerge(current, data ?? {});
+                if (name !== undefined)
+                    next.name = name;
+                if (listed !== undefined)
+                    next.listed = listed;
+                if (params !== undefined) {
+                    const currentParams = next.params;
+                    next.params =
+                        currentParams && typeof currentParams === "object" && !Array.isArray(currentParams)
+                            ? deepMerge(currentParams, params)
+                            : params;
+                }
+                return {
+                    dryRun: true,
+                    action: "update",
+                    resource: "insight",
+                    id: a[0],
+                    current,
+                    next,
+                    contentType,
+                    payload,
+                };
+            }
+            return c.insights.update(a[0], {
+                data,
+                name,
+                listed,
+                params,
+                contentType,
+                payload,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss insight update <id> [--name NAME] [--listed true|false] [--params JSON] [--content TEXT|--file PATH --content-type MIME] [--data JSON|--data-file PATH|--stdin] [--dry-run] [--project-key KEY]",
+        description: "Update an insight using GET-before-POST merge semantics.",
+        examples: ["dss insight update INSIGHT_ID --name 'Updated' --dry-run",],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss insight delete <id>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.insights.get(a[0], pk));
+                if (!current)
+                    return skipResult("insight", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "insight", id: a[0], current, };
+                }
+            }
+            await c.insights.delete(a[0], pk);
+            return { deleted: a[0], resource: "insight", };
+        },
+        usage: "dss insight delete <id> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete an insight.",
+        examples: ["dss insight delete INSIGHT_ID --dry-run",],
+    },
+};

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

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