dataiku-sdk 0.10.0 → 0.11.0

package/dist/src/cli/commands/continuous-activity.js

@@ -0,0 +1,38 @@
+import { jsonInput, } from "../coerce.js";
+import { requireArgs, } from "../usage.js";
+export const continuousActivityCommands = {
+    list: {
+        handler: (c, _a, f) => c.continuousActivities.list(f["project-key"]),
+        usage: "dss continuous-activity list [--project-key KEY]",
+        description: "List continuous activities in a project.",
+        examples: ["dss continuous-activity list",],
+    },
+    status: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss continuous-activity status <recipeId> [--project-key KEY]");
+            return c.continuousActivities.getStatus(a[0], f["project-key"]);
+        },
+        usage: "dss continuous-activity status <recipeId> [--project-key KEY]",
+        description: "Get a continuous recipe's desired and effective state.",
+        examples: ["dss continuous-activity status compute_stream",],
+    },
+    start: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss continuous-activity start <recipeId> [--data JSON|--data-file PATH|--stdin] [--project-key KEY]");
+            return c.continuousActivities.start(a[0], jsonInput(f), f["project-key"]);
+        },
+        usage: "dss continuous-activity start <recipeId> [--data JSON|--data-file PATH|--stdin] [--project-key KEY]",
+        description: "Start a continuous recipe (optional loop restart params via JSON).",
+        examples: ["dss continuous-activity start compute_stream",],
+    },
+    stop: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss continuous-activity stop <recipeId> [--project-key KEY]");
+            await c.continuousActivities.stop(a[0], f["project-key"]);
+            return { stopped: a[0], };
+        },
+        usage: "dss continuous-activity stop <recipeId> [--project-key KEY]",
+        description: "Stop a continuous recipe.",
+        examples: ["dss continuous-activity stop compute_stream",],
+    },
+};

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

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

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

@@ -0,0 +1,99 @@
+import { deepMerge, } from "../../utils/deep-merge.js";
+import { jsonInput, } from "../coerce.js";
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+export const dashboardCommands = {
+    list: {
+        handler: (c, _a, f) => c.dashboards.list(f["project-key"]),
+        usage: "dss dashboard list [--project-key KEY]",
+        description: "List project dashboards.",
+        examples: ["dss dashboard list",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss dashboard get <id>");
+            return c.dashboards.get(a[0], f["project-key"]);
+        },
+        usage: "dss dashboard get <id> [--project-key KEY]",
+        description: "Get dashboard definition.",
+        examples: ["dss dashboard get DASHBOARD_ID",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const name = f["name"];
+            if (!name)
+                throw new UsageError("--name is required. Usage: dss dashboard create --name NAME");
+            const settings = jsonInput(f);
+            const pk = f["project-key"];
+            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+                const existing = (await c.dashboards.list(pk)).find((dashboard) => dashboard.name === name);
+                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                    return skipResult("dashboard", existing.id, "exists", { current: existing, });
+                }
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "create",
+                        resource: "dashboard",
+                        name,
+                        payload: settings ?? { pages: [], },
+                        ...(existing ? { current: existing, } : {}),
+                    };
+                }
+            }
+            const created = await c.dashboards.create({
+                name,
+                settings,
+                projectKey: pk,
+            });
+            return { created: created.id, resource: "dashboard", ...created, };
+        },
+        usage: "dss dashboard create --name NAME [--data JSON|--data-file PATH|--stdin] [--if-not-exists] [--dry-run] [--project-key KEY]",
+        description: "Create a dashboard. Defaults to an empty pages array.",
+        examples: ["dss dashboard create --name 'Agent dashboard' --dry-run",],
+    },
+    update: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss dashboard update <id> [--name NAME|--data JSON]");
+            const name = f["name"];
+            const data = jsonInput(f);
+            if (!name && !data) {
+                throw new UsageError("--name, --data, --data-file, or --stdin is required.");
+            }
+            if (f["dry-run"] === true) {
+                const current = await c.dashboards.get(a[0], f["project-key"]);
+                const next = deepMerge(current, data ?? {});
+                if (name !== undefined)
+                    next.name = name;
+                return { dryRun: true, action: "update", resource: "dashboard", id: a[0], current, next, };
+            }
+            return c.dashboards.update(a[0], {
+                name,
+                data,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss dashboard update <id> [--name NAME|--data JSON|--data-file PATH|--stdin] [--dry-run] [--project-key KEY]",
+        description: "Update dashboard settings via merge.",
+        examples: ["dss dashboard update DASHBOARD_ID --name 'New name' --dry-run",],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss dashboard delete <id>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.dashboards.get(a[0], pk));
+                if (!current)
+                    return skipResult("dashboard", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "dashboard", id: a[0], current, };
+                }
+            }
+            await c.dashboards.delete(a[0], pk);
+            return { deleted: a[0], resource: "dashboard", };
+        },
+        usage: "dss dashboard delete <id> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a dashboard.",
+        examples: ["dss dashboard delete DASHBOARD_ID --dry-run",],
+    },
+};

package/dist/src/cli/commands/data-quality.d.ts

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

package/dist/src/cli/commands/data-quality.js

@@ -0,0 +1,235 @@
+import { deepMerge, } from "../../utils/deep-merge.js";
+import { num, parseBooleanOption, requiredJsonInput, } from "../coerce.js";
+import { encodedProjectEndpoint, readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+export const dataQualityCommands = {
+    rules: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality rules <dataset>");
+            return c.dataQuality.listRules(a[0], f["project-key"]);
+        },
+        usage: "dss data-quality rules <dataset> [--project-key KEY]",
+        description: "List data quality rules for a dataset.",
+        examples: ["dss data-quality rules orders",],
+    },
+    "get-rule": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss data-quality get-rule <dataset> <rule-id>");
+            return c.dataQuality.getRule(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss data-quality get-rule <dataset> <rule-id> [--project-key KEY]",
+        description: "Get one data quality rule by id.",
+        examples: ["dss data-quality get-rule orders RULE_ID",],
+    },
+    status: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality status <dataset>");
+            return c.dataQuality.status(a[0], f["project-key"]);
+        },
+        usage: "dss data-quality status <dataset> [--project-key KEY]",
+        description: "Get the aggregate data quality status for a dataset.",
+        examples: ["dss data-quality status orders",],
+    },
+    "create-rule": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality create-rule <dataset> --data JSON");
+            const config = requiredJsonInput(f, "--data, --data-file, or --stdin is required.");
+            const pk = f["project-key"];
+            const identity = typeof config.id === "string"
+                ? config.id
+                : typeof config.displayName === "string"
+                    ? config.displayName
+                    : undefined;
+            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+                const existing = identity
+                    ? (await c.dataQuality.listRules(a[0], pk)).find((rule) => rule.id === identity || rule.displayName === identity)
+                    : undefined;
+                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                    return skipResult("data-quality", identity ?? existing.id, "exists", {
+                        dataset: a[0],
+                        current: existing,
+                    });
+                }
+                if (f["if-not-exists"] === true && !identity && f["dry-run"] !== true) {
+                    throw new UsageError("--if-not-exists requires rule id or displayName in the rule JSON.");
+                }
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "create-rule",
+                        resource: "data-quality",
+                        dataset: a[0],
+                        payload: config,
+                        ...(existing ? { current: existing, } : {}),
+                    };
+                }
+            }
+            const created = await c.dataQuality.createRule(a[0], {
+                config,
+                projectKey: pk,
+            });
+            return {
+                created: created.id ?? identity ?? "rule",
+                dataset: a[0],
+                resource: "data-quality",
+                ...created,
+            };
+        },
+        usage: "dss data-quality create-rule <dataset> (--data JSON|--data-file PATH|--stdin) [--if-not-exists] [--dry-run] [--project-key KEY]",
+        description: "Create a data quality rule from raw rule config.",
+        examples: [
+            'dss data-quality create-rule orders --data \'{"type":"RecordCountInRangeRule","softMinimum":1,"softMinimumEnabled":true,"displayName":"Has rows"}\' --dry-run',
+        ],
+    },
+    "update-rule": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss data-quality update-rule <dataset> <rule-id> --data JSON");
+            const data = requiredJsonInput(f, "--data, --data-file, or --stdin is required.");
+            if (f["dry-run"] === true) {
+                const current = await c.dataQuality.getRule(a[0], a[1], f["project-key"]);
+                const next = deepMerge(current, data);
+                return {
+                    dryRun: true,
+                    action: "update-rule",
+                    resource: "data-quality",
+                    dataset: a[0],
+                    ruleId: a[1],
+                    current,
+                    next,
+                };
+            }
+            return c.dataQuality.updateRule(a[0], a[1], {
+                data,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss data-quality update-rule <dataset> <rule-id> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]",
+        description: "Update a data quality rule via GET-before-PUT merge.",
+        examples: [
+            "dss data-quality update-rule orders RULE_ID --data '{\"enabled\":false}' --dry-run",
+        ],
+    },
+    "delete-rule": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss data-quality delete-rule <dataset> <rule-id>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.dataQuality.getRule(a[0], a[1], pk));
+                if (!current)
+                    return skipResult("data-quality", a[1], "missing", { dataset: a[0], });
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "delete-rule",
+                        resource: "data-quality",
+                        dataset: a[0],
+                        ruleId: a[1],
+                        current,
+                    };
+                }
+            }
+            await c.dataQuality.deleteRule(a[0], a[1], pk);
+            return { deleted: a[1], dataset: a[0], resource: "data-quality", };
+        },
+        usage: "dss data-quality delete-rule <dataset> <rule-id> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a data quality rule.",
+        examples: ["dss data-quality delete-rule orders RULE_ID --dry-run",],
+    },
+    "status-by-partition": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality status-by-partition <dataset>");
+            return c.dataQuality.statusByPartition(a[0], {
+                includeAllPartitions: f["include-all-partitions"] === true,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss data-quality status-by-partition <dataset> [--include-all-partitions] [--project-key KEY]",
+        description: "Get data quality status by dataset partition.",
+        examples: ["dss data-quality status-by-partition orders --include-all-partitions",],
+    },
+    "last-results": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality last-results <dataset>");
+            return c.dataQuality.lastResults(a[0], {
+                partition: f["partition"],
+                ruleId: f["rule-id"],
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss data-quality last-results <dataset> [--partition P] [--rule-id ID] [--project-key KEY]",
+        description: "Get latest data quality rule results for a dataset.",
+        examples: ["dss data-quality last-results orders",],
+    },
+    history: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality history <dataset>");
+            return c.dataQuality.history(a[0], {
+                minTimestamp: num(f["min-timestamp"]),
+                maxTimestamp: num(f["max-timestamp"]),
+                resultsPerPage: num(f["results-per-page"]),
+                page: num(f["page"]),
+                ruleId: f["rule-id"],
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss data-quality history <dataset> [--rule-id ID] [--min-timestamp MS] [--max-timestamp MS] [--results-per-page N] [--page N] [--project-key KEY]",
+        description: "Get data quality rule execution history.",
+        examples: ["dss data-quality history orders --results-per-page 100",],
+    },
+    "project-status": {
+        handler: (c, _a, f) => c.dataQuality.projectStatus({
+            onlyMonitored: parseBooleanOption(f["only-monitored"], "--only-monitored"),
+            projectKey: f["project-key"],
+        }),
+        usage: "dss data-quality project-status [--only-monitored true|false] [--project-key KEY]",
+        description: "Get project-level data quality status by dataset.",
+        examples: ["dss data-quality project-status --only-monitored false",],
+    },
+    "project-timeline": {
+        handler: (c, _a, f) => c.dataQuality.projectTimeline({
+            minTimestamp: num(f["min-timestamp"]),
+            maxTimestamp: num(f["max-timestamp"]),
+            projectKey: f["project-key"],
+        }),
+        usage: "dss data-quality project-timeline [--min-timestamp MS] [--max-timestamp MS] [--project-key KEY]",
+        description: "Get project-level data quality timeline aggregates.",
+        examples: ["dss data-quality project-timeline --min-timestamp 1714521600000",],
+    },
+    compute: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality compute <dataset>");
+            const pk = f["project-key"];
+            const options = {
+                partition: f["partition"],
+                pollIntervalMs: num(f["poll-interval"]),
+                ruleId: f["rule-id"],
+                projectKey: pk,
+                timeoutMs: num(f["timeout"]),
+            };
+            if (f["dry-run"] === true) {
+                const params = new URLSearchParams();
+                params.set("partition", options.partition?.trim() ? options.partition : "NP");
+                if (options.ruleId !== undefined)
+                    params.set("ruleId", options.ruleId);
+                return {
+                    dryRun: true,
+                    action: "compute",
+                    resource: "data-quality",
+                    dataset: a[0],
+                    ...options,
+                    endpoint: encodedProjectEndpoint(c, pk, `/datasets/${encodeURIComponent(a[0])}/data-quality/actions/compute-rules?${params.toString()}`),
+                    method: "POST",
+                };
+            }
+            if (f["wait"] === true)
+                return c.dataQuality.computeRulesAndWait(a[0], options);
+            return c.dataQuality.computeRules(a[0], options);
+        },
+        usage: "dss data-quality compute <dataset> [--partition P] [--rule-id ID] [--wait] [--timeout MS] [--poll-interval MS] [--dry-run] [--project-key KEY]",
+        description: "Start data quality rule computation, optionally waiting on the returned DSS future.",
+        examples: [
+            "dss data-quality compute orders --dry-run",
+            "dss data-quality compute orders --wait",
+        ],
+    },
+};

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

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