dataiku-sdk 0.12.7 → 1.1.0

package/dist/src/cli/coerce.js

@@ -1,10 +1,31 @@
 import { readFileSync, } from "node:fs";
 import { UsageError, } from "./usage.js";
-export function num(v) {
-    if (typeof v !== "string")
+function safeValuePreview(value) {
+    return value.length <= 32 ? value : `${value.slice(0, 32)}…`;
+}
+export function num(v, flagName) {
+    if (v === undefined || v === false)
         return undefined;
+    if (typeof v !== "string") {
+        throw new UsageError(`${flagName ?? "Numeric flag"} requires a value.`, "invalid_flag_value", undefined, flagName ? { flag: flagName, } : {});
+    }
+    if (v.trim().length === 0) {
+        throw new UsageError(`Invalid numeric value for ${flagName ?? "flag"}.`, "invalid_flag_value", undefined, flagName ? { flag: flagName, } : {});
+    }
     const n = Number(v);
-    return Number.isFinite(n) ? n : undefined;
+    if (!Number.isFinite(n)) {
+        throw new UsageError(`Invalid numeric value for ${flagName ?? "flag"}: ${safeValuePreview(v)}.`, "invalid_flag_value", undefined, {
+            ...(flagName ? { flag: flagName, } : {}),
+            value: safeValuePreview(v),
+        });
+    }
+    return n;
+}
+export function numFlag(flags, flagNames) {
+    const flagName = flagNames.find((name) => flags[name] !== undefined && flags[name] !== false);
+    if (flagName === undefined)
+        return undefined;
+    return num(flags[flagName], `--${flagName}`);
 }
 export function jobBuildTargetType(v) {
     if (v === undefined)
@@ -21,7 +42,7 @@ export function jobBuildTargetTypeFromFlags(flags) {
     return jobBuildTargetType(flags["target-type"] ?? flags["type"]);
 }
 export function maxLogLinesFromFlags(flags) {
-    return num(flags["max-log-lines"] ?? flags["max-lines"]);
+    return numFlag(flags, ["max-log-lines", "max-lines",]);
 }
 export function jobLogFilterFromFlag(v) {
     if (v === undefined)
@@ -124,32 +145,62 @@ export function parseJsonObject(text, source) {
     return expectJsonObject(parseJsonValue(text, source), source);
 }
 export function json(v, source = "JSON flag") {
-    if (typeof v !== "string")
+    if (v === undefined || v === false)
         return undefined;
+    if (typeof v !== "string" || v.trim().length === 0) {
+        throw new UsageError(`${source} requires a JSON value.`, "invalid_flag_value");
+    }
     return parseJsonObject(v, source);
 }
 export function readStdinText() {
     return readFileSync(0, "utf-8");
 }
-export function jsonInput(flags) {
-    if (flags["stdin"] === true)
-        return parseJsonObject(readStdinText(), "stdin");
-    if (typeof flags["data-file"] === "string") {
-        return parseJsonObject(readFileSync(flags["data-file"], "utf-8"), flags["data-file"]);
+const JSON_SOURCE_FLAGS = ["stdin", "data-file", "data",];
+const TEXT_SOURCE_FLAGS = ["content", "file",];
+function selectSingleSource(flags, sourceFlags) {
+    const provided = sourceFlags.filter((name) => {
+        const value = flags[name];
+        if (value === undefined || value === false)
+            return false;
+        return name === "stdin" ? parseBooleanOption(value, "--stdin") === true : true;
+    });
+    if (provided.length > 1) {
+        throw new UsageError(`Conflicting input sources: ${provided.map((name) => `--${name}`).join(" or ")}. Provide exactly one.`, "conflicting_input_sources", undefined, { sources: provided, });
     }
-    if (typeof flags["data"] === "string")
-        return parseJsonObject(flags["data"], "--data");
-    return undefined;
+    return provided[0];
 }
-export function unknownJsonInput(flags) {
-    if (flags["stdin"] === true)
-        return parseJsonValue(readStdinText(), "stdin");
-    if (typeof flags["data-file"] === "string") {
-        return parseJsonValue(readFileSync(flags["data-file"], "utf-8"), flags["data-file"]);
+function resolveJsonSourceText(flags, kind) {
+    const source = selectSingleSource(flags, JSON_SOURCE_FLAGS);
+    if (source === undefined)
+        return undefined;
+    if (source === "stdin") {
+        const jsonText = readStdinText();
+        return kind === "object"
+            ? parseJsonObject(jsonText, "stdin")
+            : parseJsonValue(jsonText, "stdin");
     }
-    if (typeof flags["data"] === "string")
-        return parseJsonValue(flags["data"], "--data");
-    return undefined;
+    if (source === "data-file") {
+        const fileValue = flags["data-file"];
+        if (typeof fileValue === "string") {
+            const jsonText = readFileSync(fileValue, "utf-8");
+            return kind === "object"
+                ? parseJsonObject(jsonText, fileValue)
+                : parseJsonValue(jsonText, fileValue);
+        }
+    }
+    const dataValue = flags["data"];
+    if (typeof dataValue === "string") {
+        return kind === "object"
+            ? parseJsonObject(dataValue, "--data")
+            : parseJsonValue(dataValue, "--data");
+    }
+    throw new UsageError("JSON input source is present but has no value.", "invalid_flag_value");
+}
+export function jsonInput(flags) {
+    return resolveJsonSourceText(flags, "object");
+}
+export function unknownJsonInput(flags) {
+    return resolveJsonSourceText(flags, "any");
 }
 export function schemaColumnsInput(flags, usage) {
     const input = unknownJsonInput(flags);
@@ -184,11 +235,18 @@ export function schemaColumnsInput(flags, usage) {
     });
 }
 export function textInput(flags) {
-    if (typeof flags["content"] === "string")
-        return flags["content"];
-    if (typeof flags["file"] === "string")
-        return readFileSync(flags["file"], "utf-8");
-    return undefined;
+    const source = selectSingleSource(flags, TEXT_SOURCE_FLAGS);
+    if (source === undefined)
+        return undefined;
+    if (source === "file") {
+        const fileValue = flags["file"];
+        if (typeof fileValue === "string")
+            return readFileSync(fileValue, "utf-8");
+    }
+    const contentValue = flags["content"];
+    if (typeof contentValue === "string")
+        return contentValue;
+    throw new UsageError("Text input source is present but has no value.", "invalid_flag_value");
 }
 export function requiredJsonInput(flags, message) {
     const data = jsonInput(flags);

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

@@ -264,8 +264,8 @@ export const appCommands = {
             let waited;
             try {
                 waited = await c.futures.wait(jobId, {
-                    pollIntervalMs: num(f["poll-interval"]),
-                    timeoutMs: num(f["timeout"]),
+                    pollIntervalMs: num(f["poll-interval"], "--poll-interval"),
+                    timeoutMs: num(f["timeout"], "--timeout"),
                 });
             }
             catch (error) {
@@ -353,8 +353,8 @@ export const appCommands = {
                 ...(f["name"] !== undefined ? { name: f["name"], } : {}),
                 copyPermissions: parseBooleanOption(f["copy-permissions"], "--copy-permissions") ?? false,
                 dryRun: parseBooleanOption(f["dry-run"], "--dry-run") ?? false,
-                timeoutMs: num(f["timeout"]),
-                pollIntervalMs: num(f["poll-interval"]),
+                timeoutMs: num(f["timeout"], "--timeout"),
+                pollIntervalMs: num(f["poll-interval"], "--poll-interval"),
             }, CREATE_SUCCESSOR_USAGE);
         },
         usage: CREATE_SUCCESSOR_USAGE,
@@ -550,8 +550,8 @@ export const appCommands = {
             let waited;
             try {
                 waited = await c.futures.wait(futureId, {
-                    pollIntervalMs: num(f["poll-interval"]),
-                    timeoutMs: num(f["timeout"]),
+                    pollIntervalMs: num(f["poll-interval"], "--poll-interval"),
+                    timeoutMs: num(f["timeout"], "--timeout"),
                 });
             }
             catch (error) {

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

@@ -32,9 +32,9 @@ export const codeCommands = {
             const run = await c.scenarios.runScript(script, {
                 envName: f["env"],
                 projectKey: f["project-key"],
-                timeoutMs: num(f["timeout"]),
+                timeoutMs: num(f["timeout"], "--timeout"),
                 keepScenario: f["keep"] === true,
-                maxLogBytes: num(f["max-log-bytes"]),
+                maxLogBytes: num(f["max-log-bytes"], "--max-log-bytes"),
             });
             const result = {
                 outcome: run.outcome,

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

@@ -2,6 +2,18 @@ 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";
+/**
+ * A data quality result counts as passing only when it actually carries a
+ * verdict and every verdict it carries reports OK. A result with no outcome
+ * and no status has proven nothing, and a result whose fields disagree
+ * (outcome ERROR alongside status OK) is a failure — never a pass.
+ */
+function resultReportsOk(result) {
+    const verdicts = [result.outcome, result.status,]
+        .filter((value) => typeof value === "string" && value.trim().length > 0)
+        .map((value) => value.trim().toUpperCase());
+    return verdicts.length > 0 && verdicts.every((value) => value === "OK");
+}
 export const dataQualityCommands = {
     rules: {
         handler: (c, a, f) => {
@@ -160,14 +172,44 @@ export const dataQualityCommands = {
         description: "Get latest data quality rule results for a dataset.",
         examples: ["dss data-quality last-results orders",],
     },
+    "assert-results": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss data-quality assert-results <dataset>");
+            const ruleId = f["rule-id"];
+            const pk = f["project-key"];
+            const results = await c.dataQuality.lastResults(a[0], { ruleId, projectKey: pk, });
+            const selected = results.filter((result) => ruleId === undefined || result.id === ruleId || result.ruleId === ruleId);
+            const failed = selected
+                .filter((result) => !resultReportsOk(result))
+                .map((result) => ({
+                ruleId: result.id ?? result.ruleId ?? result.name ?? null,
+                outcome: result.outcome ?? null,
+                status: result.status ?? null,
+            }));
+            return {
+                satisfied: selected.length > 0 && failed.length === 0,
+                dataset: a[0],
+                ...(ruleId !== undefined ? { ruleId, } : {}),
+                checked: selected.length,
+                failed,
+                ...(selected.length === 0 ? { reason: "no_results", } : {}),
+            };
+        },
+        usage: "dss data-quality assert-results <dataset> [--rule-id ID] [--project-key KEY]",
+        description: "Assert the latest data quality results: at least one selected rule must exist and every selected result must report OK. Returns { satisfied, checked, failed } with failed rule ids/outcomes only; a failed assertion exits 4 with assertion_failed.",
+        examples: [
+            "dss data-quality assert-results orders",
+            "dss data-quality assert-results orders --rule-id RULE_ID",
+        ],
+    },
     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"]),
+                minTimestamp: num(f["min-timestamp"], "--min-timestamp"),
+                maxTimestamp: num(f["max-timestamp"], "--max-timestamp"),
+                resultsPerPage: num(f["results-per-page"], "--results-per-page"),
+                page: num(f["page"], "--page"),
                 ruleId: f["rule-id"],
                 projectKey: f["project-key"],
             });
@@ -187,8 +229,8 @@ export const dataQualityCommands = {
     },
     "project-timeline": {
         handler: (c, _a, f) => c.dataQuality.projectTimeline({
-            minTimestamp: num(f["min-timestamp"]),
-            maxTimestamp: num(f["max-timestamp"]),
+            minTimestamp: num(f["min-timestamp"], "--min-timestamp"),
+            maxTimestamp: num(f["max-timestamp"], "--max-timestamp"),
             projectKey: f["project-key"],
         }),
         usage: "dss data-quality project-timeline [--min-timestamp MS] [--max-timestamp MS] [--project-key KEY]",
@@ -201,10 +243,10 @@ export const dataQualityCommands = {
             const pk = f["project-key"];
             const options = {
                 partition: f["partition"],
-                pollIntervalMs: num(f["poll-interval"]),
+                pollIntervalMs: num(f["poll-interval"], "--poll-interval"),
                 ruleId: f["rule-id"],
                 projectKey: pk,
-                timeoutMs: num(f["timeout"]),
+                timeoutMs: num(f["timeout"], "--timeout"),
             };
             if (f["dry-run"] === true) {
                 const params = new URLSearchParams();

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

@@ -1,2 +1,25 @@
 import type { CommandMeta } from "../types.js";
+export interface DatasetSchemaDifference {
+    /** Path from the schema root in dot/bracket notation, e.g. `columns[2].type`. */
+    path: string;
+    kind: "added" | "removed" | "changed";
+    /** SHA-256 of the deterministic JSON rendering of the expected subtree. */
+    expectedHash?: string;
+    /** SHA-256 of the deterministic JSON rendering of the actual subtree. */
+    actualHash?: string;
+}
+export interface DatasetSchemaComparison {
+    equal: boolean;
+    expectedHash: string;
+    actualHash: string;
+    differences: DatasetSchemaDifference[];
+    totalDifferences: number;
+    differencesTruncated: boolean;
+}
+/**
+ * Compare two schema values deterministically — object key order never matters
+ * — and report each structural difference as a concise per-path entry carrying
+ * subtree hashes instead of subtree values.
+ */
+export declare function compareDatasetSchemas(expected: unknown, actual: unknown): DatasetSchemaComparison;
 export declare const datasetCommands: Record<string, CommandMeta>;

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

@@ -1,10 +1,102 @@
 import { buildDatasetCloneSettings, } from "../../resources/datasets.js";
 import { deepMerge, } from "../../utils/deep-merge.js";
-import { jsonInput, num, schemaColumnsInput, } from "../coerce.js";
+import { compareStrings, stableHash, } from "../../utils/stable-hash.js";
+import { jsonInput, num, schemaColumnsInput, unknownJsonInput, } from "../coerce.js";
 import { datasetSourceSummary, } from "../helpers/dataset.js";
 import { moveCreatedItemsToZone, resolveFlowZoneIdFromFlags, } from "../helpers/flow-zone.js";
 import { enqueueCliWarning, readIfExists, skipResult, } from "../output.js";
 import { requireArgs, UsageError, } from "../usage.js";
+const MAX_SCHEMA_DIFFERENCES = 50;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function appendSchemaPath(parent, key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
+        ? (parent ? `${parent}.${key}` : key)
+        : `${parent}[${JSON.stringify(key)}]`;
+}
+function collectSchemaDifferences(expected, actual, path, acc) {
+    // Hash equality is the deterministic equivalence test: structurally equal
+    // subtrees (any key order) match exactly and are never descended into.
+    if (stableHash(expected) === stableHash(actual))
+        return;
+    if (isPlainObject(expected) && isPlainObject(actual)) {
+        const keys = [...new Set([...Object.keys(expected), ...Object.keys(actual),]),].sort(compareStrings);
+        for (const key of keys) {
+            const nextPath = appendSchemaPath(path, key);
+            const hasExpected = key in expected;
+            const hasActual = key in actual;
+            if (hasExpected && hasActual) {
+                collectSchemaDifferences(expected[key], actual[key], nextPath, acc);
+                continue;
+            }
+            acc.total += 1;
+            if (acc.items.length < MAX_SCHEMA_DIFFERENCES) {
+                acc.items.push({
+                    path: nextPath,
+                    kind: hasActual ? "added" : "removed",
+                    ...(hasActual
+                        ? { actualHash: stableHash(actual[key]), }
+                        : { expectedHash: stableHash(expected[key]), }),
+                });
+            }
+        }
+        return;
+    }
+    if (Array.isArray(expected) && Array.isArray(actual)) {
+        const shared = Math.min(expected.length, actual.length);
+        for (let i = 0; i < shared; i++) {
+            collectSchemaDifferences(expected[i], actual[i], `${path}[${i}]`, acc);
+        }
+        for (let i = shared; i < expected.length; i++) {
+            acc.total += 1;
+            if (acc.items.length < MAX_SCHEMA_DIFFERENCES) {
+                acc.items.push({
+                    path: `${path}[${i}]`,
+                    kind: "removed",
+                    expectedHash: stableHash(expected[i]),
+                });
+            }
+        }
+        for (let i = shared; i < actual.length; i++) {
+            acc.total += 1;
+            if (acc.items.length < MAX_SCHEMA_DIFFERENCES) {
+                acc.items.push({
+                    path: `${path}[${i}]`,
+                    kind: "added",
+                    actualHash: stableHash(actual[i]),
+                });
+            }
+        }
+        return;
+    }
+    acc.total += 1;
+    if (acc.items.length < MAX_SCHEMA_DIFFERENCES) {
+        acc.items.push({
+            path: path || "$",
+            kind: "changed",
+            expectedHash: stableHash(expected),
+            actualHash: stableHash(actual),
+        });
+    }
+}
+/**
+ * Compare two schema values deterministically — object key order never matters
+ * — and report each structural difference as a concise per-path entry carrying
+ * subtree hashes instead of subtree values.
+ */
+export function compareDatasetSchemas(expected, actual) {
+    const acc = { items: [], total: 0, };
+    collectSchemaDifferences(expected, actual, "", acc);
+    return {
+        equal: acc.items.length === 0,
+        expectedHash: stableHash(expected),
+        actualHash: stableHash(actual),
+        differences: acc.items,
+        totalDifferences: acc.total,
+        differencesTruncated: acc.items.length < acc.total,
+    };
+}
 export const datasetCommands = {
     list: {
         handler: (c, _a, f) => c.datasets.list(f["project-key"]),
@@ -69,6 +161,34 @@ export const datasetCommands = {
         description: "Show backing connection, catalog/schema/table, path, and format for a dataset.",
         examples: ["dss dataset source orders",],
     },
+    files: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss dataset files <name> [--project-key KEY]");
+            return c.datasets.listUploadedFiles(a[0], f["project-key"]);
+        },
+        usage: "dss dataset files <name> [--project-key KEY]",
+        description: "List files stored by an UploadedFiles dataset.",
+        examples: ["dss dataset files uploaded_input",],
+    },
+    "upload-file": {
+        handler: (c, a, f) => {
+            const usage = "dss dataset upload-file <name> <localPath> --file-name NAME [--project-key KEY]";
+            requireArgs(a, 2, usage);
+            const fileName = f["file-name"];
+            if (!fileName || fileName.trim() === "") {
+                throw new UsageError(`--file-name is required. Usage: ${usage}`);
+            }
+            return c.datasets.uploadDatasetFile(a[0], a[1], {
+                fileName,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: "dss dataset upload-file <name> <localPath> --file-name NAME [--project-key KEY]",
+        description: "Add one new file to an UploadedFiles dataset and verify the stored byte length.",
+        examples: [
+            "dss dataset upload-file uploaded_input ./input.csv --file-name input.csv",
+        ],
+    },
     "refresh-schema": {
         handler: async (c, a, f) => {
             const usage = "dss dataset refresh-schema <name> [--data JSON | --data-file PATH | --stdin] [--dry-run] [--project-key KEY]";
@@ -105,18 +225,79 @@ export const datasetCommands = {
         examples: ["dss dataset validate-build orders",],
     },
     preview: {
-        handler: (c, a, f) => {
-            requireArgs(a, 1, "dss dataset preview <name>");
-            return c.datasets.preview(a[0], {
-                maxRows: num(f["max-rows"]),
+        handler: async (c, a, f) => {
+            const previewUsage = "dss dataset preview <name> [--max-rows N] [--rows N] [--project-key KEY] [--timeout MS]";
+            requireArgs(a, 1, previewUsage);
+            const maxRows = num(f["max-rows"], "--max-rows");
+            if (maxRows !== undefined && (!Number.isSafeInteger(maxRows) || maxRows <= 0 || maxRows > 500)) {
+                throw new UsageError(`--max-rows must be a positive integer no greater than 500 (got "${String(f["max-rows"])}"). `
+                    + `Usage: ${previewUsage}`, "validation_failed");
+            }
+            const result = await c.datasets.preview(a[0], {
+                maxRows,
                 projectKey: f["project-key"],
-                timeoutMs: num(f["timeout"]),
+                timeoutMs: num(f["timeout"], "--timeout"),
             });
+            if (result.truncated) {
+                enqueueCliWarning({
+                    code: "dataset_preview_truncated",
+                    message: `Preview of '${a[0]}' stopped at the ${result.limit}-row cap; the dataset has more rows. ${result.limit >= 500
+                        ? "The preview cap of 500 rows is the public maximum; use `dss dataset download` for more rows."
+                        : "Re-run with --max-rows N (up to 500) for more rows."}`,
+                    dataset: a[0],
+                    rows: result.rowCount,
+                    limit: result.limit,
+                });
+            }
+            return result;
         },
         usage: "dss dataset preview <name> [--max-rows N] [--rows N] [--project-key KEY] [--timeout MS]",
-        description: "Preview dataset rows (--rows is an alias for --max-rows).",
+        description: "Preview dataset rows (--rows is an alias for --max-rows). Returns { columns, rows, rowCount, truncated, limit }; when the dataset has more rows than the cap, truncated is true and a dataset_preview_truncated warning is written to stderr.",
         examples: ["dss dataset preview orders", "dss dataset preview orders --rows 5",],
     },
+    "assert-count": {
+        handler: async (c, a, f) => {
+            const assertUsage = "dss dataset assert-count <dataset> --expected N [--project-key KEY]";
+            requireArgs(a, 1, assertUsage);
+            const expected = num(f["expected"], "--expected");
+            if (expected === undefined || !Number.isSafeInteger(expected) || expected < 0) {
+                throw new UsageError(`--expected must be a non-negative integer (got "${String(f["expected"])}"). `
+                    + `Usage: ${assertUsage}`, "validation_failed");
+            }
+            const result = await c.datasets.assertRowCount(a[0], expected, f["project-key"]);
+            return { ...result, dataset: a[0], };
+        },
+        usage: "dss dataset assert-count <dataset> --expected N [--project-key KEY]",
+        description: "Stream the dataset and assert it holds exactly --expected rows, probing at most N+1 rows. Returns { satisfied, expected, count, exact }; a mismatch exits 4 with assertion_failed.",
+        examples: ["dss dataset assert-count orders --expected 1000",],
+    },
+    "assert-schema": {
+        handler: async (c, a, f) => {
+            const assertUsage = "dss dataset assert-schema <dataset> (--data JSON | --data-file PATH | --stdin) [--project-key KEY]";
+            requireArgs(a, 1, assertUsage);
+            const expected = unknownJsonInput(f);
+            if (expected === undefined) {
+                throw new UsageError(`--data, --data-file, or --stdin is required. Usage: ${assertUsage}`);
+            }
+            const actual = await c.datasets.getSchemaObject(a[0], f["project-key"]);
+            const comparison = compareDatasetSchemas(expected, actual);
+            return {
+                satisfied: comparison.equal,
+                dataset: a[0],
+                expectedHash: comparison.expectedHash,
+                actualHash: comparison.actualHash,
+                totalDifferences: comparison.totalDifferences,
+                ...(comparison.differencesTruncated ? { differencesTruncated: true, } : {}),
+                differences: comparison.differences,
+            };
+        },
+        usage: "dss dataset assert-schema <dataset> (--data JSON | --data-file PATH | --stdin) [--project-key KEY]",
+        description: "Assert the dataset's full schema equals the expected schema object; reports concise per-path differences with sha256 subtree hashes. A mismatch exits 4 with assertion_failed.",
+        examples: [
+            `dss dataset assert-schema orders --data-file expected-schema.json`,
+            `dss dataset assert-schema orders --data '{"columns":[]}'`,
+        ],
+    },
     metadata: {
         handler: (c, a, f) => {
             requireArgs(a, 1, "dss dataset metadata <name>");
@@ -132,7 +313,7 @@ export const datasetCommands = {
             const result = await c.datasets.download(a[0], {
                 outputPath: f["output"],
                 projectKey: f["project-key"],
-                limit: num(f["limit"]),
+                limit: num(f["limit"], "--limit"),
             });
             if (result.truncated) {
                 enqueueCliWarning({
@@ -166,8 +347,11 @@ export const datasetCommands = {
             const name = f["name"];
             const connection = f["connection"];
             const dsType = f["type"];
-            if (!name || !connection || !dsType) {
-                throw new UsageError("--name, --connection, and --type are required. Usage: dss dataset create --name NAME --connection CONN --type TYPE");
+            if (!name || !dsType) {
+                throw new UsageError("--name and --type are required. Usage: dss dataset create --name NAME --type TYPE [--connection CONN]");
+            }
+            if (!connection && dsType.toLowerCase() !== "uploadedfiles") {
+                throw new UsageError("--connection is required unless --type is UploadedFiles.");
             }
             const payload = {
                 datasetName: name,
@@ -198,9 +382,10 @@ export const datasetCommands = {
             const moved = await moveCreatedItemsToZone(c, f, [{ objectId: name, objectType: "DATASET", },], pk);
             return { created: name, resource: "dataset", ...moved, };
         },
-        usage: "dss dataset create --name NAME --connection CONN --type TYPE [--zone ZONE|--zone-id ID] [--if-not-exists] [--dry-run] [--project-key KEY]",
-        description: "Create a new dataset.",
+        usage: "dss dataset create --name NAME --type TYPE [--connection CONN] [--zone ZONE|--zone-id ID] [--if-not-exists] [--dry-run] [--project-key KEY]",
+        description: "Create a new dataset. UploadedFiles uses the server's default upload connection when omitted.",
         examples: [
+            "dss dataset create --name uploads --type UploadedFiles",
             "dss dataset create --name orders --connection filesystem --type Filesystem",
             "dss dataset create --name orders --connection filesystem --type Filesystem --zone Experiments --dry-run",
         ],

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

@@ -18,8 +18,8 @@ export const folderCommands = {
             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]");
+            if (!name) {
+                throw new UsageError("--name is required. Usage: dss folder create --name NAME [--type TYPE] [--connection CONN] [--path PATH]");
             }
             const payload = {
                 name,
@@ -48,9 +48,10 @@ export const folderCommands = {
             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.",
+        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; when omitted, the connection is selected from writable managed-folder storage and DSS infers the folder type.",
         examples: [
+            "dss folder create --name exports",
             "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",
         ],

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

@@ -24,8 +24,8 @@ export const futureCommands = {
         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"]),
+                pollIntervalMs: num(f["poll-interval"], "--poll-interval"),
+                timeoutMs: num(f["timeout"], "--timeout"),
             });
         },
         usage: "dss future wait <id> [--timeout MS] [--poll-interval MS]",

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

@@ -24,6 +24,7 @@ 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 { projectGitCommands, } from "./project-git.js";
 import { projectLibraryCommands, } from "./project-library.js";
 import { projectCommands, } from "./project.js";
 import { recipeCommands, } from "./recipe.js";
@@ -49,6 +50,7 @@ export const commands = {
     "api-deployer": apiDeployerCommands,
     bundle: bundleCommands,
     "project-deployer": projectDeployerCommands,
+    "project-git": projectGitCommands,
     "project-library": projectLibraryCommands,
     "streaming-endpoint": streamingEndpointCommands,
     "continuous-activity": continuousActivityCommands,