dataiku-sdk 0.10.1 → 0.11.0

package/dist/src/cli/flags.js

@@ -0,0 +1,255 @@
+import { unsupportedHelpFlag, UsageError, } from "./usage.js";
+export const BOOLEAN_FLAGS = new Set([
+    "verbose",
+    "version",
+    "stdin",
+    "insecure",
+    "global",
+    "list-agents",
+    "include-raw",
+    "raw",
+    "include-payload",
+    "no-payload",
+    "include-logs",
+    "summary",
+    "replace",
+    "dry-run",
+    "plan",
+    "apply",
+    "capabilities",
+    "fast",
+    "include-all-partitions",
+    "wait",
+    "if-not-exists",
+    "if-exists",
+    "json",
+    "no-wait",
+    "force-rebuild",
+    "latest",
+    "copy-output-settings",
+    "continue-on-error",
+    "no-backup",
+    "payload-only",
+    "allow-same-path",
+    "sync",
+    "validate-objects",
+    "errors-only",
+    "keep",
+    "full-log",
+    "drop-data",
+]);
+export const SHORT_FLAGS = {
+    v: "verbose",
+    V: "version",
+    o: "output",
+};
+/** Long-flag aliases: these are normalized to the canonical name in parseArgs. */
+export const FLAG_ALIASES = {
+    project: "project-key",
+    dryrun: "dry-run",
+    "skip-tls-verify": "insecure",
+    "extra-ca-certs": "ca-cert",
+    explain: "plan",
+    "zone-name": "zone",
+    rows: "max-rows",
+};
+export const VALUE_FLAGS = new Set([
+    "fields",
+    "owner",
+    "topic",
+    "reply",
+    "text",
+    "partitions",
+    "since",
+    "activity",
+    "agent",
+    "api-key",
+    "build-mode",
+    "backup-dir",
+    "backup",
+    "ca-cert",
+    "catalog",
+    "cell-id",
+    "allow-types",
+    "color",
+    "connection",
+    "contains",
+    "content",
+    "content-type",
+    "data",
+    "active",
+    "deployment-mode",
+    "env-version",
+    "data-file",
+    "database",
+    "dataset",
+    "file",
+    "env",
+    "install-core-packages",
+    "folder",
+    "input",
+    "from",
+    "knowledge-bank",
+    "labeling-task",
+    "lang",
+    "package",
+    "packages",
+    "local",
+    "max-edges",
+    "max-lines",
+    "max-log-lines",
+    "max-log-bytes",
+    "listed",
+    "max-nodes",
+    "max-rows",
+    "limit",
+    "max-timestamp",
+    "only-monitored",
+    "min-timestamp",
+    "mode",
+    "log-filter",
+    "log-id",
+    "model-evaluation-store",
+    "name",
+    "object",
+    "metastore-table",
+    "output",
+    "output-file",
+    "output-connection",
+    "output-folder",
+    "page",
+    "partition",
+    "parent",
+    "path",
+    "preview",
+    "project-key",
+    "recipe",
+    "request-timeout",
+    "params",
+    "results-per-page",
+    "record-cleanup",
+    "rule-id",
+    "role",
+    "retries",
+    "poll-interval",
+    "python-interpreter",
+    "replace-input",
+    "replace-output",
+    "replace-payload-text",
+    "retain",
+    "saved-model",
+    "sql",
+    "schema",
+    "sql-file",
+    "standard",
+    "state",
+    "streaming-endpoint",
+    "target",
+    "target-type",
+    "timeout",
+    "table",
+    "type",
+    "url",
+    "until",
+    "to",
+    "zone",
+    "zone-id",
+]);
+export const REPEATABLE_VALUE_FLAGS = new Set([
+    "dataset",
+    "folder",
+    "input",
+    "object",
+    "package",
+    "recipe",
+    "replace-input",
+    "replace-output",
+    "replace-payload-text",
+]);
+export const KNOWN_LONG_FLAGS = new Set([
+    ...BOOLEAN_FLAGS,
+    ...VALUE_FLAGS,
+    ...Object.keys(FLAG_ALIASES),
+    ...Object.values(FLAG_ALIASES),
+]);
+export function normalizeLongFlag(rawFlagName) {
+    if (rawFlagName === "help")
+        throw unsupportedHelpFlag();
+    const flagName = FLAG_ALIASES[rawFlagName] ?? rawFlagName;
+    if (!KNOWN_LONG_FLAGS.has(rawFlagName) && !KNOWN_LONG_FLAGS.has(flagName)) {
+        throw new UsageError(`Unknown flag: --${rawFlagName}`, "unknown_flag");
+    }
+    return flagName;
+}
+export function isNegativeNumberToken(value) {
+    return value.startsWith("-") && Number.isFinite(Number(value));
+}
+export function requireFlagValue(flagLabel, next) {
+    if (next === undefined || (next !== "-" && next.startsWith("-") && !isNegativeNumberToken(next))) {
+        throw new UsageError(`Flag ${flagLabel} requires a value.`, "missing_required_flag");
+    }
+    return next;
+}
+export function setParsedFlagValue(flags, flagName, value) {
+    const current = flags[flagName];
+    if (REPEATABLE_VALUE_FLAGS.has(flagName) && typeof current === "string" && current.length > 0) {
+        flags[flagName] = `${current},${value}`;
+        return;
+    }
+    flags[flagName] = value;
+}
+export function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === "--") {
+            positional.push(...argv.slice(i + 1));
+            break;
+        }
+        if (arg.startsWith("--")) {
+            const eqIdx = arg.indexOf("=");
+            if (eqIdx !== -1) {
+                const raw = arg.slice(2, eqIdx);
+                const flagName = normalizeLongFlag(raw);
+                setParsedFlagValue(flags, flagName, arg.slice(eqIdx + 1));
+            }
+            else {
+                const rawFlagName = arg.slice(2);
+                const flagName = normalizeLongFlag(rawFlagName);
+                if (BOOLEAN_FLAGS.has(flagName)) {
+                    flags[flagName] = true;
+                }
+                else {
+                    const next = requireFlagValue(`--${rawFlagName}`, argv[i + 1]);
+                    setParsedFlagValue(flags, flagName, next);
+                    i++;
+                }
+            }
+        }
+        else if (arg.length === 2 && arg[0] === "-" && arg[1] !== "-") {
+            const long = SHORT_FLAGS[arg[1]];
+            if (long) {
+                if (BOOLEAN_FLAGS.has(long)) {
+                    flags[long] = true;
+                }
+                else {
+                    const next = requireFlagValue(`-${arg[1]}`, argv[i + 1]);
+                    setParsedFlagValue(flags, long, next);
+                    i++;
+                }
+            }
+            else {
+                if (arg[1] === "h")
+                    throw unsupportedHelpFlag();
+                throw new UsageError(`Unknown flag: -${arg[1]}`, "unknown_flag");
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+        i++;
+    }
+    return { positional, flags, };
+}

package/dist/src/cli/helpers/cleanup.d.ts

@@ -0,0 +1,3 @@
+import type { CleanupLedgerEntry } from "../../utils/cleanup-ledger.js";
+export declare function projectArg(projectKey: string | undefined): string[];
+export declare function cleanupLedgerEntry(resource: string, action: string, args: string[], flags: Record<string, string | boolean>, result: unknown, projectKey: string | undefined): CleanupLedgerEntry | undefined;

package/dist/src/cli/helpers/cleanup.js

@@ -0,0 +1,158 @@
+import { resultRecord, stringField, } from "../coerce.js";
+export function projectArg(projectKey) {
+    return projectKey ? ["--project-key", projectKey,] : [];
+}
+export function cleanupLedgerEntry(resource, action, args, flags, result, projectKey) {
+    if (!(action.startsWith("create") || action === "clone" || action === "upload"))
+        return undefined;
+    const record = resultRecord(result);
+    if (record.skipped !== undefined)
+        return undefined;
+    const project = flags["project-key"] ?? projectKey;
+    const withProject = projectArg(project);
+    const ts = new Date().toISOString();
+    const base = { ts, action, resource, ...(project ? { projectKey: project, } : {}), };
+    switch (`${resource}.${action}`) {
+        case "dataset.create": {
+            const name = stringField(record, ["created", "name",]) ?? flags["name"];
+            if (!name)
+                return undefined;
+            return {
+                ...base,
+                name,
+                cleanup: { argv: ["dataset", "delete", name, "--if-exists", ...withProject,], },
+            };
+        }
+        case "dataset.clone": {
+            const name = stringField(record, ["target", "created", "name",]) ?? args[1];
+            if (!name)
+                return undefined;
+            return {
+                ...base,
+                name,
+                cleanup: { argv: ["dataset", "delete", name, "--if-exists", ...withProject,], },
+            };
+        }
+        case "recipe.create": {
+            const name = stringField(record, ["created", "recipeName", "name",])
+                ?? flags["name"];
+            if (!name)
+                return undefined;
+            return {
+                ...base,
+                name,
+                cleanup: { argv: ["recipe", "delete", name, "--if-exists", ...withProject,], },
+            };
+        }
+        case "recipe.clone": {
+            const name = stringField(record, ["recipeName", "target", "created", "name",])
+                ?? flags["name"];
+            if (!name)
+                return undefined;
+            return {
+                ...base,
+                name,
+                cleanup: { argv: ["recipe", "delete", name, "--if-exists", ...withProject,], },
+            };
+        }
+        case "scenario.create": {
+            const id = args[0];
+            return {
+                ...base,
+                id,
+                name: args[1],
+                cleanup: { argv: ["scenario", "delete", id, "--if-exists", ...withProject,], },
+            };
+        }
+        case "flow-zone.create": {
+            const id = stringField(record, ["created", "id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                name: flags["name"],
+                cleanup: { argv: ["flow-zone", "delete", id, "--if-exists", ...withProject,], },
+            };
+        }
+        case "folder.create": {
+            const id = stringField(record, ["created", "id",]) ?? flags["name"];
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                name: flags["name"],
+                cleanup: { argv: ["folder", "delete", id, "--if-exists", ...withProject,], },
+            };
+        }
+        case "wiki.create": {
+            const article = record.article && typeof record.article === "object" && !Array.isArray(record.article)
+                ? record.article
+                : {};
+            const id = stringField(record, ["created",]) ?? stringField(article, ["id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                name: flags["name"],
+                cleanup: { argv: ["wiki", "delete", id, "--if-exists", ...withProject,], },
+            };
+        }
+        case "dashboard.create": {
+            const id = stringField(record, ["created", "id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                name: flags["name"],
+                cleanup: { argv: ["dashboard", "delete", id, "--if-exists", ...withProject,], },
+            };
+        }
+        case "insight.create": {
+            const id = stringField(record, ["created", "id",]);
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                name: flags["name"],
+                cleanup: { argv: ["insight", "delete", id, "--if-exists", ...withProject,], },
+            };
+        }
+        case "data-quality.create-rule": {
+            const ruleId = stringField(record, ["id", "created",]);
+            if (!ruleId)
+                return undefined;
+            return {
+                ...base,
+                id: ruleId,
+                name: args[0],
+                cleanup: {
+                    argv: ["data-quality", "delete-rule", args[0], ruleId, "--if-exists", ...withProject,],
+                },
+            };
+        }
+        case "code-env.create": {
+            const lang = args[0];
+            const name = args[1];
+            return {
+                ...base,
+                id: `${lang}:${name}`,
+                name,
+                cleanup: { argv: ["code-env", "delete", lang, name, "--if-exists",], },
+            };
+        }
+        case "folder.upload":
+            return {
+                ...base,
+                name: args[0],
+                path: args[1],
+                cleanup: { argv: ["folder", "delete-file", args[0], args[1], ...withProject,], },
+            };
+        default:
+            return undefined;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { DatasetDetails } from "../../schemas.js";
+export declare function datasetSourceSummary(details: DatasetDetails): Record<string, unknown>;

package/dist/src/cli/helpers/dataset.js

@@ -0,0 +1,17 @@
+export function datasetSourceSummary(details) {
+    const params = details.params ?? {};
+    return {
+        resource: "dataset",
+        name: details.name,
+        projectKey: details.projectKey,
+        type: details.type,
+        managed: details.managed,
+        connection: params.connection,
+        catalog: params.catalog,
+        schema: params.schema,
+        table: params.table,
+        path: params.path,
+        folderSmartId: params.folderSmartId,
+        formatType: details.formatType,
+    };
+}

package/dist/src/cli/helpers/flow-zone.d.ts

@@ -0,0 +1,69 @@
+import type { DataikuClient } from "../../client.js";
+import type { FlowZoneItemInput } from "../../resources/flow-zones.js";
+import type { FlowZone, FlowZoneObjectType, FlowZonePosition } from "../../schemas.js";
+export declare function flowZoneId(value: string): string;
+export declare function flowZoneName(value: string | boolean | undefined): string;
+export declare function flowZoneColor(value: string | boolean | undefined): string | undefined;
+export declare function flowZoneObjectType(value: string): FlowZoneObjectType;
+export declare function addFlowZoneFlagItems(items: FlowZoneItemInput[], flags: Record<string, string | boolean>, flagName: string, objectType: FlowZoneObjectType): void;
+export declare function parseFlowZoneObject(value: string): FlowZoneItemInput;
+export declare function flowZoneMoveItems(flags: Record<string, string | boolean>): FlowZoneItemInput[];
+export declare function flowZoneItems(zone: FlowZone): FlowZoneItemInput[];
+export declare function flowZoneContains(zone: FlowZone, object: FlowZoneItemInput): boolean;
+export declare function flowZoneSummary(zone: FlowZone, object?: FlowZoneItemInput): Record<string, unknown>;
+export declare function flowZoneDetailSummary(zone: FlowZone): Record<string, unknown>;
+export interface FlowZoneOrganizeZonePlan {
+    id?: string;
+    name?: string;
+    color?: string;
+    position?: FlowZonePosition;
+    items: FlowZoneItemInput[];
+}
+export interface FlowZoneOrganizePlan {
+    zones: FlowZoneOrganizeZonePlan[];
+}
+export interface FlowZoneOrganizeValidationIssue {
+    zone: string;
+    objectId: string;
+    objectType: FlowZoneObjectType;
+    projectKey?: string;
+    reason: string;
+}
+export interface FlowZoneOrganizeValidationResult {
+    valid: boolean;
+    missing: FlowZoneOrganizeValidationIssue[];
+}
+export interface FlowZoneOrganizeValidationIndex {
+    projectKey: string;
+    all: Set<string>;
+    datasets: Set<string>;
+    recipes: Set<string>;
+    folders: Set<string>;
+}
+export declare function flowZonePlanColor(value: unknown, source: string): string | undefined;
+export declare function flowZonePlanPosition(value: unknown, source: string): FlowZonePosition | undefined;
+export declare function flowZoneCurrentPosition(zone: FlowZone): FlowZonePosition | undefined;
+export declare function flowZoneSamePosition(a: FlowZonePosition | undefined, b: FlowZonePosition | undefined): boolean;
+export declare function parseFlowZonePlanItem(value: unknown, source: string): FlowZoneItemInput;
+export declare function addFlowZonePlanTypedItems(items: FlowZoneItemInput[], record: Record<string, unknown>, key: string, objectType: FlowZoneObjectType, source: string): void;
+export declare function flowZoneItemKey(item: FlowZoneItemInput): string;
+export declare function flowZonePlanLabel(plan: FlowZoneOrganizeZonePlan): string;
+export declare function dedupeFlowZonePlanItems(items: FlowZoneItemInput[]): FlowZoneItemInput[];
+export declare function flowZonePlanItemKeys(plan: FlowZoneOrganizePlan): Set<string>;
+export declare function validateUniqueFlowZoneAssignments(plan: FlowZoneOrganizePlan): void;
+export declare function parseFlowZoneOrganizePlan(input: Record<string, unknown>): FlowZoneOrganizePlan;
+export declare function readFlowZoneOrganizePlan(flags: Record<string, string | boolean>, usage: string): FlowZoneOrganizePlan;
+export declare function findFlowZoneForPlan(zones: FlowZone[], plan: FlowZoneOrganizeZonePlan): FlowZone | undefined;
+export declare function ensureFlowZonePlanTarget(plan: FlowZoneOrganizeZonePlan, existing: FlowZone | undefined): void;
+export declare function flowZoneExplicitItems(zone: FlowZone): FlowZoneItemInput[];
+export declare function flowZonePruneItems(existing: FlowZone | undefined, plannedItemKeys: Set<string>): FlowZoneItemInput[];
+export declare function flowZoneOrganizeStep(plan: FlowZoneOrganizeZonePlan, existing: FlowZone | undefined, sync: boolean, plannedItemKeys: Set<string>): Record<string, unknown>;
+export declare function flowZoneValidationBucket(index: FlowZoneOrganizeValidationIndex, objectType: FlowZoneObjectType): Set<string>;
+export declare function flowZoneValidationIndex(client: DataikuClient, projectKey: string | undefined): Promise<FlowZoneOrganizeValidationIndex>;
+export declare function validateFlowZoneOrganizeObjects(client: DataikuClient, plan: FlowZoneOrganizePlan, projectKey: string | undefined): Promise<FlowZoneOrganizeValidationResult>;
+export declare function throwFlowZoneValidationError(validation: FlowZoneOrganizeValidationResult): void;
+export declare function resolveFlowZoneIdFromFlags(client: DataikuClient, flags: Record<string, string | boolean>, projectKey?: string): Promise<string | undefined>;
+export declare function moveCreatedItemsToZone(client: DataikuClient, flags: Record<string, string | boolean>, items: FlowZoneItemInput[], projectKey?: string): Promise<{
+    zoneId?: string;
+    moved?: FlowZoneItemInput[];
+}>;