dataiku-sdk 0.10.1 → 0.12.0

package/dist/src/cli/commands/saved-model.js

@@ -0,0 +1,85 @@
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+export const savedModelCommands = {
+    list: {
+        handler: (c, _a, f) => c.savedModels.list(f["project-key"]),
+        usage: "dss saved-model list [--project-key KEY]",
+        description: "List saved models in a project.",
+        examples: ["dss saved-model list --project-key PROJECT",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss saved-model get <modelId> [--project-key KEY]");
+            return c.savedModels.get(a[0], f["project-key"]);
+        },
+        usage: "dss saved-model get <modelId> [--project-key KEY]",
+        description: "Get a saved model.",
+        examples: ["dss saved-model get MODEL_ID --project-key PROJECT",],
+    },
+    "list-versions": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss saved-model list-versions <modelId> [--project-key KEY]");
+            return c.savedModels.listVersions(a[0], f["project-key"]);
+        },
+        usage: "dss saved-model list-versions <modelId> [--project-key KEY]",
+        description: "List versions of a saved model.",
+        examples: ["dss saved-model list-versions MODEL_ID --project-key PROJECT",],
+    },
+    "version-details": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss saved-model version-details <modelId> <versionId> [--project-key KEY]");
+            return c.savedModels.versionDetails(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss saved-model version-details <modelId> <versionId> [--project-key KEY]",
+        description: "Get details for one saved-model version.",
+        examples: [
+            "dss saved-model version-details MODEL_ID VERSION_ID --project-key PROJECT",
+        ],
+    },
+    "set-active": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss saved-model set-active <modelId> <versionId> [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "set-active",
+                    resource: "saved-model",
+                    id: a[0],
+                    versionId: a[1],
+                    projectKey,
+                    payload: { versionId: a[1], },
+                };
+            }
+            return c.savedModels.setActiveVersion(a[0], a[1], projectKey);
+        },
+        usage: "dss saved-model set-active <modelId> <versionId> [--dry-run] [--project-key KEY]",
+        description: "Set the active version of a saved model.",
+        examples: [
+            "dss saved-model set-active MODEL_ID VERSION_ID --project-key PROJECT",
+            "dss saved-model set-active MODEL_ID VERSION_ID --dry-run --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss saved-model delete <modelId> [--if-exists] [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.savedModels.get(a[0], projectKey));
+                if (!current)
+                    return skipResult("saved-model", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "saved-model", id: a[0], current, };
+                }
+            }
+            await c.savedModels.delete(a[0], projectKey);
+            return { deleted: a[0], resource: "saved-model", };
+        },
+        usage: "dss saved-model delete <modelId> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a saved model.",
+        examples: [
+            "dss saved-model delete MODEL_ID --if-exists --project-key PROJECT",
+            "dss saved-model delete MODEL_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};

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

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

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

@@ -0,0 +1,190 @@
+import { scenarioUpdatePreview, } from "../../resources/scenarios.js";
+import { jsonInput, num, } from "../coerce.js";
+import { encodedProjectEndpoint, readIfExists, skipResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+export const scenarioCommands = {
+    list: {
+        handler: (c, _a, f) => c.scenarios.list(f["project-key"]),
+        usage: "dss scenario list [--project-key KEY]",
+        description: "List all scenarios in a project.",
+        examples: ["dss scenario list",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss scenario get <id>");
+            return c.scenarios.get(a[0], { projectKey: f["project-key"], });
+        },
+        usage: "dss scenario get <id> [--project-key KEY]",
+        description: "Get raw scenario definition. For step-based scenario edits, patch params.steps; rawParams.params is DSS echo data.",
+        examples: ["dss scenario get my_scenario",],
+    },
+    run: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss scenario run <id>");
+            const pk = f["project-key"];
+            const options = {
+                pollIntervalMs: num(f["poll-interval"]),
+                timeoutMs: num(f["timeout"]),
+            };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "run",
+                    resource: "scenario",
+                    id: a[0],
+                    ...options,
+                    endpoint: encodedProjectEndpoint(c, pk, `/scenarios/${encodeURIComponent(a[0])}/run/`),
+                    method: "POST",
+                };
+            }
+            if (f["wait"] === true) {
+                return c.scenarios.runAndWait(a[0], { ...options, projectKey: pk, });
+            }
+            return c.scenarios.run(a[0], pk);
+        },
+        usage: "dss scenario run <id> [--wait] [--timeout MS] [--poll-interval MS] [--dry-run] [--project-key KEY]",
+        description: "Trigger a scenario run, optionally waiting for completion.",
+        examples: ["dss scenario run my_scenario", "dss scenario run my_scenario --wait",],
+    },
+    "run-and-wait": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss scenario run-and-wait <id>");
+            const pk = f["project-key"];
+            const options = {
+                pollIntervalMs: num(f["poll-interval"]),
+                timeoutMs: num(f["timeout"]),
+            };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "run-and-wait",
+                    resource: "scenario",
+                    id: a[0],
+                    ...options,
+                    endpoint: encodedProjectEndpoint(c, pk, `/scenarios/${encodeURIComponent(a[0])}/run/`),
+                    method: "POST",
+                };
+            }
+            return c.scenarios.runAndWait(a[0], { ...options, projectKey: pk, });
+        },
+        usage: "dss scenario run-and-wait <id> [--timeout MS] [--poll-interval MS] [--dry-run] [--project-key KEY]",
+        description: "Run a scenario and wait for completion.",
+        examples: [
+            "dss scenario run-and-wait my_scenario",
+            "dss scenario run-and-wait my_scenario --timeout 300000",
+        ],
+    },
+    status: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss scenario status <id>");
+            return c.scenarios.status(a[0], f["project-key"]);
+        },
+        usage: "dss scenario status <id> [--project-key KEY]",
+        description: "Get the current run status of a scenario.",
+        examples: ["dss scenario status my_scenario",],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss scenario delete <id>");
+            const pk = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.scenarios.get(a[0], { projectKey: pk, }));
+                if (!current)
+                    return skipResult("scenario", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "scenario", id: a[0], current, };
+                }
+            }
+            await c.scenarios.delete(a[0], pk);
+            return { deleted: a[0], resource: "scenario", };
+        },
+        usage: "dss scenario delete <id> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a scenario.",
+        examples: ["dss scenario delete my_scenario", "dss scenario delete my_scenario --if-exists",],
+    },
+    create: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss scenario create <id> <name>");
+            const pk = f["project-key"];
+            const payload = {
+                scenarioId: a[0],
+                name: a[1],
+                scenarioType: f["type"],
+                projectKey: pk,
+            };
+            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+                const list = await c.scenarios.list(pk);
+                const existing = list.find((s) => s.id === a[0]);
+                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                    return skipResult("scenario", a[0], "exists", { current: existing, });
+                }
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "create",
+                        resource: "scenario",
+                        id: a[0],
+                        payload,
+                        ...(existing ? { current: existing, } : {}),
+                    };
+                }
+            }
+            await c.scenarios.create(a[0], a[1], {
+                scenarioType: payload.scenarioType,
+                projectKey: pk,
+            });
+            return { created: a[0], name: a[1], resource: "scenario", };
+        },
+        usage: "dss scenario create <id> <name> [--type step_based|custom_python] [--if-not-exists] [--dry-run] [--project-key KEY]",
+        description: "Create a new scenario.",
+        examples: [
+            'dss scenario create my_scenario "My Scenario"',
+            'dss scenario create my_scenario "My Scenario" --type custom_python --dry-run',
+        ],
+    },
+    update: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss scenario update <id> [--data '{...}' | --data-file PATH | --stdin]");
+            const data = jsonInput(f);
+            if (data === undefined) {
+                throw new UsageError("--data, --data-file, or --stdin is required. Usage: dss scenario update <id> [--data '{...}' | --data-file PATH | --stdin]");
+            }
+            const pk = f["project-key"];
+            if (f["dry-run"] === true) {
+                const current = await c.scenarios.get(a[0], { projectKey: pk, });
+                const preview = scenarioUpdatePreview(current, data);
+                return {
+                    dryRun: true,
+                    action: "update",
+                    resource: "scenario",
+                    id: a[0],
+                    canonicalEditableFields: preview.canonicalEditableFields,
+                    normalization: preview.normalization,
+                    normalizedData: preview.normalizedData,
+                    changes: preview.changes,
+                    unchangedPaths: preview.unchangedPaths,
+                    current: preview.current,
+                    next: preview.next,
+                };
+            }
+            const result = await c.scenarios.update(a[0], data, pk);
+            return {
+                updated: a[0],
+                resource: "scenario",
+                verified: result.verified,
+                changed: result.changes.length > 0,
+                canonicalEditableFields: result.canonicalEditableFields,
+                normalization: result.normalization,
+                ...(result.normalization.length > 0 ? { normalizedData: result.normalizedData, } : {}),
+                changes: result.changes,
+                unchangedPaths: result.unchangedPaths,
+            };
+        },
+        usage: "dss scenario update <id> [--data '{...}' | --data-file PATH | --stdin] [--dry-run] [--project-key KEY]",
+        description: "Update scenario settings via JSON merge; edit step-based scenario steps at params.steps, not rawParams.params.steps.",
+        examples: [
+            'dss scenario update my_scenario --data \'{"params":{"steps":[]}}\' --dry-run',
+            "dss scenario update my_scenario --data-file settings.json --dry-run",
+        ],
+    },
+};

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

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

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

@@ -0,0 +1,109 @@
+import { readFileSync, } from "node:fs";
+import { mkdir, writeFile, } from "node:fs/promises";
+import { dirname, resolve, } from "node:path";
+import { readStdinText, stripUtf8Bom, } from "../coerce.js";
+import { UsageError, } from "../usage.js";
+const SQL_QUERY_USAGE = "dss sql query [SQL | --sql QUERY | --sql-file PATH | --sql - | --stdin] (--connection CONN | --dataset FULL_NAME) [--database DB] [--output PATH|--output-file PATH] [--preview N] [--request-timeout MS] [--project-key KEY]";
+const DEFAULT_SQL_PREVIEW_ROWS = 5;
+/**
+ * Parse `--preview N` into a non-negative row count. Rejects non-integers,
+ * negatives, and empty values loudly so a bad flag never silently degrades to a
+ * default. `--preview 0` is valid and yields an empty preview (explicit opt-out).
+ */
+function parseSqlPreviewCount(value) {
+    if (typeof value !== "string") {
+        throw new UsageError(`--preview requires an integer value. Usage: ${SQL_QUERY_USAGE}`, "validation_failed");
+    }
+    const trimmed = value.trim();
+    const parsed = Number(trimmed);
+    if (trimmed.length === 0 || !Number.isInteger(parsed) || parsed < 0) {
+        throw new UsageError(`--preview must be a non-negative integer (got "${value}"). Usage: ${SQL_QUERY_USAGE}`, "validation_failed");
+    }
+    return parsed;
+}
+function resolveSqlInput(args, flags) {
+    const sources = [];
+    if (typeof flags["sql"] === "string") {
+        sources.push({
+            label: flags["sql"] === "-" ? "--sql -" : "--sql",
+            read: () => flags["sql"] === "-" ? readStdinText() : String(flags["sql"]),
+        });
+    }
+    if (typeof flags["sql-file"] === "string") {
+        sources.push({
+            label: "--sql-file",
+            read: () => readFileSync(flags["sql-file"], "utf-8"),
+        });
+    }
+    if (flags["stdin"] === true) {
+        sources.push({ label: "--stdin", read: readStdinText, });
+    }
+    if (args.length > 1) {
+        throw new UsageError(`Expected at most one positional SQL argument. Quote the SQL or use --sql-file/--stdin.\nUsage: ${SQL_QUERY_USAGE}`);
+    }
+    if (args[0] !== undefined) {
+        sources.push({ label: "positional SQL", read: () => args[0], });
+    }
+    if (sources.length === 0) {
+        throw new UsageError(`SQL input is required. Usage: ${SQL_QUERY_USAGE}`);
+    }
+    if (sources.length > 1) {
+        throw new UsageError(`Choose exactly one SQL input source: --sql, --sql-file, --stdin, or one positional SQL argument. Usage: ${SQL_QUERY_USAGE}`);
+    }
+    const query = stripUtf8Bom(sources[0].read());
+    if (query.trim().length === 0) {
+        throw new UsageError(`SQL input from ${sources[0].label} must not be empty. Usage: ${SQL_QUERY_USAGE}`);
+    }
+    return query;
+}
+export const sqlCommands = {
+    query: {
+        handler: async (c, a, f) => {
+            const connection = f["connection"];
+            const datasetFullName = f["dataset"];
+            if ((connection ? 1 : 0) + (datasetFullName ? 1 : 0) !== 1) {
+                throw new UsageError(`Pass exactly one of --connection or --dataset. Usage: ${SQL_QUERY_USAGE}`);
+            }
+            const outputFile = f["output"]
+                ?? f["output-file"];
+            const previewProvided = f["preview"] !== undefined;
+            if (previewProvided && !outputFile) {
+                throw new UsageError(`--preview requires --output or --output-file. Usage: ${SQL_QUERY_USAGE}`, "validation_failed");
+            }
+            const previewCount = previewProvided
+                ? parseSqlPreviewCount(f["preview"])
+                : DEFAULT_SQL_PREVIEW_ROWS;
+            const query = resolveSqlInput(a, f);
+            const result = await c.sql.query({
+                query,
+                connection,
+                datasetFullName,
+                database: f["database"],
+                projectKey: f["project-key"],
+            });
+            if (!outputFile)
+                return result;
+            const outputPath = resolve(outputFile);
+            await mkdir(dirname(outputPath), { recursive: true, });
+            await writeFile(outputPath, `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+            return {
+                queryId: result.queryId,
+                schema: result.schema,
+                columns: result.columns ?? result.schema,
+                rowCount: result.rows.length,
+                preview: result.rows.slice(0, previewCount),
+                outputPath,
+                written: outputPath,
+            };
+        },
+        usage: SQL_QUERY_USAGE,
+        description: "Run a SQL query against a DSS connection or dataset.",
+        examples: [
+            "dss sql query 'SELECT * FROM orders LIMIT 10' --connection my_pg",
+            "dss sql query --sql-file query.sql --connection my_pg",
+            "echo 'SELECT 1' | dss sql query --stdin --dataset MYPROJ.orders",
+            "dss sql query --sql-file query.sql --connection my_pg --output results.json --request-timeout 120000",
+            "dss sql query --sql-file query.sql --connection my_pg --output results.json --preview 10",
+        ],
+    },
+};

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

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

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

@@ -0,0 +1,165 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { encodedProjectEndpoint, planResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+const STATISTICS_PLAN_EXIT_CODES = { usage: 1, error: 2, transient: 3, };
+const STATISTICS_FUTURE_PLAN_EXIT_CODES = {
+    ...STATISTICS_PLAN_EXIT_CODES,
+    longRunningFailure: 4,
+};
+function statisticsWorksheetsEndpoint(client, datasetName, projectKey) {
+    return encodedProjectEndpoint(client, projectKey, `/datasets/${encodeURIComponent(datasetName)}/statistics/worksheets/`);
+}
+function statisticsWorksheetEndpoint(client, datasetName, worksheetId, projectKey) {
+    return `${statisticsWorksheetsEndpoint(client, datasetName, projectKey)}${encodeURIComponent(worksheetId)}`;
+}
+function statisticsPlan(action, options) {
+    const asyncKind = options.asyncKind ?? "none";
+    return planResult("statistics", action, {
+        method: options.method,
+        endpoint: options.endpoint,
+        identifiers: options.identifiers,
+        ...(options.payload !== undefined ? { payload: options.payload, } : {}),
+        idempotency: "none",
+        asyncKind,
+        exitCodesOnFailure: asyncKind === "future"
+            ? STATISTICS_FUTURE_PLAN_EXIT_CODES
+            : STATISTICS_PLAN_EXIT_CODES,
+        plannedAndDryRun: true,
+    });
+}
+export const statisticsCommands = {
+    "list-worksheets": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss statistics list-worksheets <dataset> [--project-key KEY]");
+            return c.statistics.listWorksheets(a[0], f["project-key"]);
+        },
+        usage: "dss statistics list-worksheets <dataset> [--project-key KEY]",
+        description: "List EDA statistics worksheets for a dataset.",
+        examples: ["dss statistics list-worksheets customers",],
+    },
+    "get-worksheet": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss statistics get-worksheet <dataset> <worksheetId> [--project-key KEY]");
+            return c.statistics.getWorksheet(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss statistics get-worksheet <dataset> <worksheetId> [--project-key KEY]",
+        description: "Get one statistics worksheet definition.",
+        examples: ["dss statistics get-worksheet customers ws_1",],
+    },
+    "create-worksheet": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss statistics create-worksheet <dataset> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (worksheet definition).");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return statisticsPlan("create-worksheet", {
+                    method: "POST",
+                    endpoint: statisticsWorksheetsEndpoint(c, a[0], projectKey),
+                    identifiers: { dataset: a[0], },
+                    payload: body,
+                });
+            }
+            return c.statistics.createWorksheet(a[0], body, projectKey);
+        },
+        usage: "dss statistics create-worksheet <dataset> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]",
+        description: "Create a statistics worksheet from a JSON definition.",
+        examples: [
+            'dss statistics create-worksheet customers --data \'{"name":"Customer stats","dataSpec":{"inputDatasetSmartName":"customers","datasetSelection":{"partitionSelectionMethod":"ALL","maxRecords":30000,"samplingMethod":"FULL"}}}\'',
+        ],
+    },
+    "update-worksheet": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss statistics update-worksheet <dataset> <worksheetId> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (worksheet definition).");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return statisticsPlan("update-worksheet", {
+                    method: "PUT",
+                    endpoint: statisticsWorksheetEndpoint(c, a[0], a[1], projectKey),
+                    identifiers: { dataset: a[0], worksheetId: a[1], },
+                    payload: body,
+                });
+            }
+            return c.statistics.updateWorksheet(a[0], a[1], body, projectKey);
+        },
+        usage: "dss statistics update-worksheet <dataset> <worksheetId> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]",
+        description: "Replace a statistics worksheet definition.",
+        examples: ["dss statistics update-worksheet customers ws_1 --data-file ws.json",],
+    },
+    "delete-worksheet": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss statistics delete-worksheet <dataset> <worksheetId> [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return statisticsPlan("delete-worksheet", {
+                    method: "DELETE",
+                    endpoint: statisticsWorksheetEndpoint(c, a[0], a[1], projectKey),
+                    identifiers: { dataset: a[0], worksheetId: a[1], },
+                });
+            }
+            await c.statistics.deleteWorksheet(a[0], a[1], projectKey);
+            return { deleted: a[1], };
+        },
+        usage: "dss statistics delete-worksheet <dataset> <worksheetId> [--dry-run] [--project-key KEY]",
+        description: "Delete a statistics worksheet.",
+        examples: ["dss statistics delete-worksheet customers ws_1",],
+    },
+    "run-worksheet": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss statistics run-worksheet <dataset> <worksheetId> [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return statisticsPlan("run-worksheet", {
+                    method: "POST",
+                    endpoint: `${statisticsWorksheetEndpoint(c, a[0], a[1], projectKey)}/actions/run-card`,
+                    identifiers: { dataset: a[0], worksheetId: a[1], },
+                    asyncKind: "future",
+                });
+            }
+            return c.statistics.runWorksheet(a[0], a[1], projectKey);
+        },
+        usage: "dss statistics run-worksheet <dataset> <worksheetId> [--dry-run] [--project-key KEY]",
+        description: "Run a statistics worksheet and return the DSS future response.",
+        examples: ["dss statistics run-worksheet customers ws_1",],
+    },
+    "run-card": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss statistics run-card <dataset> <worksheetId> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]");
+            const card = requiredJsonInput(f, "--data, --data-file, or --stdin is required (card settings).");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return statisticsPlan("run-card", {
+                    method: "POST",
+                    endpoint: `${statisticsWorksheetEndpoint(c, a[0], a[1], projectKey)}/actions/run-card`,
+                    identifiers: { dataset: a[0], worksheetId: a[1], },
+                    payload: card,
+                    asyncKind: "future",
+                });
+            }
+            return c.statistics.runCard(a[0], a[1], card, projectKey);
+        },
+        usage: "dss statistics run-card <dataset> <worksheetId> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]",
+        description: "Run a single card in a worksheet context.",
+        examples: ["dss statistics run-card customers ws_1 --data-file card.json",],
+    },
+    "run-computation": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss statistics run-computation <dataset> <worksheetId> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]");
+            const computation = requiredJsonInput(f, "--data, --data-file, or --stdin is required (computation settings).");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return statisticsPlan("run-computation", {
+                    method: "POST",
+                    endpoint: `${statisticsWorksheetEndpoint(c, a[0], a[1], projectKey)}/actions/run-computation`,
+                    identifiers: { dataset: a[0], worksheetId: a[1], },
+                    payload: computation,
+                    asyncKind: "future",
+                });
+            }
+            return c.statistics.runComputation(a[0], a[1], computation, projectKey);
+        },
+        usage: "dss statistics run-computation <dataset> <worksheetId> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]",
+        description: "Run a single computation in a worksheet context.",
+        examples: ["dss statistics run-computation customers ws_1 --data-file comp.json",],
+    },
+};

package/dist/src/cli/commands/streaming-endpoint.d.ts

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

package/dist/src/cli/commands/streaming-endpoint.js

@@ -0,0 +1,50 @@
+import { jsonInput, requiredJsonInput, } from "../coerce.js";
+import { requireArgs, } from "../usage.js";
+export const streamingEndpointCommands = {
+    list: {
+        handler: (c, _a, f) => c.streamingEndpoints.list(f["project-key"]),
+        usage: "dss streaming-endpoint list [--project-key KEY]",
+        description: "List streaming endpoints in a project.",
+        examples: ["dss streaming-endpoint list",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss streaming-endpoint get <id> [--project-key KEY]");
+            return c.streamingEndpoints.getSettings(a[0], f["project-key"]);
+        },
+        usage: "dss streaming-endpoint get <id> [--project-key KEY]",
+        description: "Get a streaming endpoint's settings.",
+        examples: ["dss streaming-endpoint get my-stream",],
+    },
+    create: {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss streaming-endpoint create <id> <type> [--data JSON|--data-file PATH|--stdin] [--project-key KEY]");
+            const body = jsonInput(f) ?? {};
+            return c.streamingEndpoints.create(a[0], a[1], body, f["project-key"]);
+        },
+        usage: "dss streaming-endpoint create <id> <type> [--data JSON|--data-file PATH|--stdin] [--project-key KEY]",
+        description: "Create a streaming endpoint of the given type.",
+        examples: ["dss streaming-endpoint create my-stream kafka",],
+    },
+    "update-settings": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss streaming-endpoint update-settings <id> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (endpoint settings).");
+            await c.streamingEndpoints.updateSettings(a[0], body, f["project-key"]);
+            return { updated: a[0], };
+        },
+        usage: "dss streaming-endpoint update-settings <id> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]",
+        description: "Replace a streaming endpoint's settings.",
+        examples: ["dss streaming-endpoint update-settings my-stream --data-file settings.json",],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss streaming-endpoint delete <id> [--project-key KEY]");
+            await c.streamingEndpoints.delete(a[0], f["project-key"]);
+            return { deleted: a[0], };
+        },
+        usage: "dss streaming-endpoint delete <id> [--project-key KEY]",
+        description: "Delete a streaming endpoint.",
+        examples: ["dss streaming-endpoint delete my-stream",],
+    },
+};

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

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