dataiku-sdk 3.7.0 → 3.8.0

package/dist/src/resources/dataset-create.js

@@ -9,6 +9,60 @@ export function assertDatasetTypeCreatable(dsType) {
         return;
     throw new ClientValidationError("Inline (editable) datasets cannot be created here: the DSS public API cannot write their rows, and an Inline dataset without rows fails every downstream build (SourceDatasetNotReadyException). For a small static table, create an UploadedFiles dataset and upload a CSV with dss dataset upload-file, or write the rows from a python recipe into a managed dataset.", "validation_failed");
 }
+/**
+ * Dataset types that read from a SQL connection. These are the types DSS
+ * detects schemas for through `testAndDetectSettings/externalSQL` (the list
+ * dataikuapi's `DSSDataset.autodetect_settings` uses).
+ */
+export const SQL_DATASET_TYPES = [
+    "JDBC",
+    "PostgreSQL",
+    "MySQL",
+    "Vertica",
+    "Snowflake",
+    "Redshift",
+    "Greenplum",
+    "Teradata",
+    "Oracle",
+    "SQLServer",
+    "SAPHANA",
+    "Netezza",
+    "BigQuery",
+    "Athena",
+    "hiveserver2",
+    "Synapse",
+    "FabricWarehouse",
+    "Databricks",
+    "DatabricksLakebase",
+];
+export function isSqlDatasetType(dsType) {
+    const lower = dsType.toLowerCase();
+    return SQL_DATASET_TYPES.some((type) => type.toLowerCase() === lower);
+}
+/**
+ * Validate the SQL source options (`table`/`dbSchema`/`catalog`/`query`) of a
+ * dataset creation against its type. Shared by `dataset create`, its plan, and
+ * the SDK so every entry point rejects the same combinations.
+ */
+export function assertSqlDatasetSource(dsType, source) {
+    const hasTable = source.table !== undefined;
+    const hasQuery = source.query !== undefined;
+    if (hasTable && hasQuery) {
+        throw new ClientValidationError("Pass either a table or a query for a SQL dataset, not both.", "conflicting_input_sources");
+    }
+    if (!hasTable && (source.dbSchema !== undefined || source.catalog !== undefined)) {
+        throw new ClientValidationError("A schema or catalog only applies together with a table.", "validation_failed", "Add --table, or drop --schema/--catalog (a query names its own tables).");
+    }
+    if (hasTable && source.table.trim() === "") {
+        throw new ClientValidationError("table must be a non-empty table name.", "invalid_flag_value");
+    }
+    if (hasQuery && source.query.trim() === "") {
+        throw new ClientValidationError("query must be a non-empty SQL query.", "invalid_flag_value");
+    }
+    if ((hasTable || hasQuery) && !isSqlDatasetType(dsType)) {
+        throw new ClientValidationError(`A table or query only applies to SQL dataset types, not "${dsType}".`, "validation_failed", `SQL types: ${SQL_DATASET_TYPES.join(", ")}.`);
+    }
+}
 /** Wire body for POST /datasets/; shared with `dataset create --plan` so the plan matches the request. */
 export function buildDatasetCreateBody(opts) {
     assertDatasetTypeCreatable(opts.dsType);
@@ -23,6 +77,21 @@ export function buildDatasetCreateBody(opts) {
     if (!opts.connection) {
         throw new ClientValidationError("connection is required unless dsType is UploadedFiles.");
     }
+    if (opts.query !== undefined) {
+        if (opts.table !== undefined) {
+            throw new ClientValidationError("Pass either a table or a query for a SQL dataset, not both.", "conflicting_input_sources");
+        }
+        if (opts.query.trim() === "") {
+            throw new ClientValidationError("query must be a non-empty SQL query.", "invalid_flag_value");
+        }
+        return {
+            projectKey: opts.projectKey,
+            name: opts.datasetName,
+            type: opts.dsType,
+            params: { connection: opts.connection, mode: "query", query: opts.query, },
+            managed: opts.managed ?? false,
+        };
+    }
     if (opts.table) {
         const params = {
             connection: opts.connection,

package/dist/src/resources/datasets.d.ts

@@ -55,6 +55,18 @@ export interface DatasetManagedCreateResult {
     projectKey: string;
     creationSettings: Record<string, unknown>;
 }
+/** Outcome of {@link DatasetsResource.detectSqlSchema}. */
+export interface DatasetSqlSchemaDetection {
+    /** True when DSS suggested a schema and it was stored on the dataset. */
+    detected: boolean;
+    /** Stored columns (empty when detection failed). */
+    columns: Array<{
+        name: string;
+        type: string;
+    }>;
+    /** Why detection failed. */
+    error?: string;
+}
 export interface DatasetCloneOptions {
     projectKey?: string;
     path?: string;
@@ -106,6 +118,15 @@ export declare class DatasetsResource extends BaseResource {
     schema(datasetName: string, projectKey?: string): Promise<DatasetSchema>;
     /** Replace dataset schema columns directly through the schema endpoint. */
     updateSchema(datasetName: string, columns: DatasetSchemaColumnInput[], projectKey?: string): Promise<void>;
+    /**
+     * Detect the schema of a SQL dataset (table or query mode) with DSS and
+     * store it: `POST /actions/testAndDetectSettings/externalSQL` (what
+     * dataikuapi's `autodetect_settings` calls), then `PUT /schema` with the
+     * suggested schema. DSS reports connection, table, and query problems in the
+     * response body (HTTP 200), so a failed detection is returned with
+     * `detected: false` and the reason instead of thrown.
+     */
+    detectSqlSchema(datasetName: string, projectKey?: string): Promise<DatasetSqlSchemaDetection>;
     /**
      * Get the raw dataset schema object exactly as the DSS schema endpoint
      * returns it, without schema validation — used for deterministic comparison.

package/dist/src/resources/datasets.js

@@ -4,6 +4,7 @@ import { StringDecoder, } from "node:string_decoder";
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
+import { isRecord, } from "../utils/records.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
 import { resolveAdminManagedStorageConnection, } from "./connections.js";
@@ -519,6 +520,28 @@ function cloneDatasetParams(params) {
     }
     return cloned;
 }
+/** Explain an empty detection result from the first error DSS put in the response body. */
+function describeSqlDetectionFailure(raw) {
+    if (!isRecord(raw))
+        return "DSS returned no schema detection result.";
+    for (const [key, value,] of Object.entries(raw)) {
+        if (!key.endsWith("Error"))
+            continue;
+        if (typeof value === "string" && value !== "")
+            return value;
+        if (isRecord(value)) {
+            const message = value["detailedMessage"] ?? value["message"];
+            if (typeof message === "string" && message !== "")
+                return message;
+        }
+    }
+    const failedChecks = Object.entries(raw)
+        .filter(([key, value,]) => key.endsWith("OK") && value === false)
+        .map(([key,]) => key);
+    return failedChecks.length > 0
+        ? `DSS detected no columns (failed checks: ${failedChecks.join(", ")}).`
+        : "DSS detected no columns.";
+}
 function parseUploadedFiles(raw, datasetName) {
     if (!Array.isArray(raw)) {
         throw new ClientValidationError(`DSS returned an invalid uploaded-files list for dataset ${datasetName}.`, "validation_failed", "Expected an array from the UploadedFiles dataset file endpoint.");
@@ -592,6 +615,40 @@ export class DatasetsResource extends BaseResource {
         const dsEnc = encodeURIComponent(datasetName);
         await this.client.put(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`, { columns, });
     }
+    /**
+     * Detect the schema of a SQL dataset (table or query mode) with DSS and
+     * store it: `POST /actions/testAndDetectSettings/externalSQL` (what
+     * dataikuapi's `autodetect_settings` calls), then `PUT /schema` with the
+     * suggested schema. DSS reports connection, table, and query problems in the
+     * response body (HTTP 200), so a failed detection is returned with
+     * `detected: false` and the reason instead of thrown.
+     */
+    async detectSqlSchema(datasetName, projectKey) {
+        const base = `/public/api/projects/${this.enc(projectKey)}/datasets/${encodeURIComponent(datasetName)}`;
+        try {
+            const raw = await this.client.post(`${base}/actions/testAndDetectSettings/externalSQL`);
+            const detection = isRecord(raw) ? raw["schemaDetection"] : undefined;
+            const newSchema = isRecord(detection) ? detection["newSchema"] : undefined;
+            const rawColumns = isRecord(newSchema) && Array.isArray(newSchema["columns"])
+                ? newSchema["columns"]
+                : [];
+            const columns = rawColumns.flatMap((column) => isRecord(column) && typeof column["name"] === "string"
+                && typeof column["type"] === "string"
+                ? [{ name: column["name"], type: column["type"], },]
+                : []);
+            if (!isRecord(newSchema) || columns.length === 0) {
+                return { detected: false, columns: [], error: describeSqlDetectionFailure(raw), };
+            }
+            await this.client.put(`${base}/schema`, newSchema);
+            return { detected: true, columns, };
+        }
+        catch (error) {
+            if (error instanceof DataikuError) {
+                return { detected: false, columns: [], error: error.message.split("\n")[0] ?? "", };
+            }
+            throw error;
+        }
+    }
     /**
      * Get the raw dataset schema object exactly as the DSS schema endpoint
      * returns it, without schema validation — used for deterministic comparison.
@@ -859,7 +916,7 @@ export class DatasetsResource extends BaseResource {
         const enc = encodeURIComponent(pk);
         const explicitType = opts.dsType;
         let dsType = explicitType
-            ?? (opts.table ? DEFAULT_DATABASE_DATASET_TYPE : DEFAULT_FILESYSTEM_DATASET_TYPE);
+            ?? (opts.table || opts.query ? DEFAULT_DATABASE_DATASET_TYPE : DEFAULT_FILESYSTEM_DATASET_TYPE);
         let body = buildDatasetCreateBody({
             projectKey: pk,
             datasetName: opts.datasetName,
@@ -868,6 +925,7 @@ export class DatasetsResource extends BaseResource {
             table: opts.table,
             dbSchema: opts.dbSchema,
             catalog: opts.catalog,
+            query: opts.query,
             formatType: opts.formatType,
             formatParams: opts.formatParams,
             managed: opts.managed,
@@ -899,6 +957,7 @@ export class DatasetsResource extends BaseResource {
                     table: opts.table,
                     dbSchema: opts.dbSchema,
                     catalog: opts.catalog,
+                    query: opts.query,
                     formatType: opts.formatType,
                     formatParams: opts.formatParams,
                     managed: opts.managed,
@@ -923,6 +982,7 @@ export class DatasetsResource extends BaseResource {
                 table: opts.table,
                 dbSchema: opts.dbSchema,
                 catalog: opts.catalog,
+                query: opts.query,
                 formatType: opts.formatType,
                 formatParams: opts.formatParams,
                 managed: opts.managed,

package/dist/src/resources/flow-zones.d.ts

@@ -1,11 +1,21 @@
 import type { DataikuGetOptions } from "../client.js";
-import type { FlowZone, FlowZoneCreateOptions, FlowZoneObjectType, FlowZoneUpdateOptions } from "../schemas.js";
+import type { FlowZone, FlowZoneCreateOptions, FlowZoneObjectType, FlowZonePosition, FlowZoneUpdateOptions } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export type FlowZoneItemInput = {
     objectId: string;
     objectType: FlowZoneObjectType;
     projectKey?: string;
 };
+export type FlowZoneRecreateOptions = {
+    position: FlowZonePosition;
+    name?: string;
+    color?: string;
+    projectKey?: string;
+};
+export type FlowZoneRecreateResult = {
+    zone: FlowZone;
+    replacedZoneId: string;
+};
 export declare class FlowZonesResource extends BaseResource {
     /**
      * List all flow zones in a project. Pass `timeoutMs` to bound the whole
@@ -14,10 +24,26 @@ export declare class FlowZonesResource extends BaseResource {
     list(projectKey?: string, options?: DataikuGetOptions): Promise<FlowZone[]>;
     /** Get one flow zone by id. */
     get(zoneId: string, projectKey?: string): Promise<FlowZone>;
-    /** Create a flow zone. */
+    /**
+     * Create a flow zone. DSS stores `position` only while the project's manual
+     * zone positioning is off; with it on, DSS auto-places the zone.
+     */
     create(opts: FlowZoneCreateOptions): Promise<FlowZone>;
-    /** Update flow zone settings such as name, color, and manual position. */
+    /**
+     * Update flow zone name and color. DSS's public API ignores `position` on
+     * this endpoint; use {@link recreate} to move an existing zone.
+     */
     update(zoneId: string, opts: FlowZoneUpdateOptions): Promise<FlowZone>;
+    /**
+     * Replace a zone with a new one at `position`: DSS honors a zone position
+     * only on creation, and only while the project's manual zone positioning is
+     * off (otherwise it auto-places the new zone). The replacement receives the
+     * old zone's name, color, metadata (tags, custom fields, checklists, ...),
+     * items, and shared items; the old zone is deleted once it is empty. The zone
+     * id changes, so anything referencing the old id (for example scenario zone
+     * builds) must be updated.
+     */
+    recreate(zoneId: string, opts: FlowZoneRecreateOptions): Promise<FlowZoneRecreateResult>;
     /** Delete a flow zone. DSS moves its items back to the default zone. */
     delete(zoneId: string, projectKey?: string): Promise<void>;
     /** Move items into a flow zone. */

package/dist/src/resources/flow-zones.js

@@ -23,7 +23,10 @@ export class FlowZonesResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/flow/zones/${encodeURIComponent(zoneId)}`);
         return this.client.safeParse(FlowZoneSchema, raw, "flowZones.get");
     }
-    /** Create a flow zone. */
+    /**
+     * Create a flow zone. DSS stores `position` only while the project's manual
+     * zone positioning is off; with it on, DSS auto-places the zone.
+     */
     async create(opts) {
         const raw = await this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/flow/zones`, {
             name: opts.name,
@@ -32,17 +35,64 @@ export class FlowZonesResource extends BaseResource {
         });
         return this.client.safeParse(FlowZoneSchema, raw, "flowZones.create");
     }
-    /** Update flow zone settings such as name, color, and manual position. */
+    /**
+     * Update flow zone name and color. DSS's public API ignores `position` on
+     * this endpoint; use {@link recreate} to move an existing zone.
+     */
     async update(zoneId, opts) {
         const current = await this.get(zoneId, opts.projectKey);
         const merged = deepMerge(current, {
             ...(opts.name !== undefined ? { name: opts.name, } : {}),
             ...(opts.color !== undefined ? { color: opts.color, } : {}),
-            ...(opts.position !== undefined ? { position: opts.position, } : {}),
         });
         await this.client.putVoid(`/public/api/projects/${this.enc(opts.projectKey)}/flow/zones/${encodeURIComponent(zoneId)}`, merged);
         return this.get(zoneId, opts.projectKey);
     }
+    /**
+     * Replace a zone with a new one at `position`: DSS honors a zone position
+     * only on creation, and only while the project's manual zone positioning is
+     * off (otherwise it auto-places the new zone). The replacement receives the
+     * old zone's name, color, metadata (tags, custom fields, checklists, ...),
+     * items, and shared items; the old zone is deleted once it is empty. The zone
+     * id changes, so anything referencing the old id (for example scenario zone
+     * builds) must be updated.
+     */
+    async recreate(zoneId, opts) {
+        const base = `/public/api/projects/${this.enc(opts.projectKey)}/flow/zones`;
+        const old = await this.get(zoneId, opts.projectKey);
+        const created = await this.create({
+            name: opts.name ?? old.name,
+            color: opts.color ?? old.color,
+            position: opts.position,
+            projectKey: opts.projectKey,
+        });
+        const completed = ["create",];
+        try {
+            const { id: _id, items, shared, position: _position, ...metadata } = old;
+            await this.client.putVoid(`${base}/${encodeURIComponent(created.id)}`, {
+                ...created,
+                ...metadata,
+                id: created.id,
+                name: created.name,
+                color: created.color,
+                position: created.position,
+            });
+            completed.push("metadata");
+            if (items && items.length > 0) {
+                await this.moveItems(created.id, items, opts.projectKey);
+            }
+            completed.push("items");
+            for (const item of shared ?? []) {
+                await this.client.post(`${base}/${encodeURIComponent(created.id)}/shared`, normalizeZoneItem(item));
+            }
+            completed.push("shared");
+            await this.delete(old.id, opts.projectKey);
+        }
+        catch (error) {
+            throw new ClientValidationError(`Recreating flow zone ${old.id} at a new position stopped after ${completed.at(-1)}; both zones may now exist.`, "ambiguous_outcome", "Inspect both zones with dss flow-zone list, then move remaining items and delete the zone you no longer need.", { replacedZoneId: old.id, zoneId: created.id, completed, }, { cause: error, });
+        }
+        return { zone: await this.get(created.id, opts.projectKey), replacedZoneId: old.id, };
+    }
     /** Delete a flow zone. DSS moves its items back to the default zone. */
     async delete(zoneId, projectKey) {
         await this.client.del(`/public/api/projects/${this.enc(projectKey)}/flow/zones/${encodeURIComponent(zoneId)}`);

package/dist/src/resources/jobs.d.ts

@@ -23,12 +23,30 @@ export interface JobLogSummary {
 }
 /** Why a requested job log could not be retrieved. */
 export type JobLogUnavailableReason = "not_found" | "error";
+/**
+ * A requested build target that no flow object can ever produce: a managed
+ * dataset with no recipe writing it.
+ */
+export interface JobUnbuildableTarget {
+    type: "DATASET";
+    id: string;
+    projectKey: string;
+    reason: "no_producing_recipe";
+}
+/** Why a job that ended DONE is reported as failed because it built nothing. */
+export interface JobNothingToBuildFailure {
+    code: "nothing_to_build";
+    message: string;
+    targets: JobUnbuildableTarget[];
+}
 /** Result of a completed job wait, including log-unavailable metadata. */
 export type JobWaitOutcome = JobWaitResult & {
     logSummary?: JobLogSummary;
     logUnavailable?: JobLogUnavailableReason;
     /** True when the job itself no longer exists on the server. */
     removed?: boolean;
+    /** Set (with `success: false`) when a DONE job ran no activity and a target has no producer. */
+    failure?: JobNothingToBuildFailure;
 };
 export interface JobBuildTarget {
     id: string;
@@ -120,6 +138,12 @@ export declare class JobsResource extends BaseResource {
      * confirmed gone. Explicit `includeLogs`/`summary` requests stay honest:
      * `log`/`logSummary` are only present when logs were actually retrieved.
      *
+     * A DONE job that ran no activity (`progress.total === 0`) is also what DSS
+     * reports for an already-up-to-date build, so it stays successful unless an
+     * output is a managed dataset that no recipe writes: then nothing can ever
+     * build it, and the outcome is `success: false` with
+     * `failure.code === "nothing_to_build"`.
+     *
      * On timeout, returns `{ success: false, ... }` rather than throwing.
      */
     wait(jobId: string, opts?: {
@@ -133,6 +157,16 @@ export declare class JobsResource extends BaseResource {
         timeoutMs?: number;
         projectKey?: string;
     }): Promise<JobWaitOutcome>;
+    /**
+     * Dataset outputs of a job that ran no activity which nothing can produce.
+     * DSS ends such a job DONE exactly like an already-up-to-date build, so the
+     * job status cannot tell them apart; the flow graph can: a target is
+     * unbuildable when it is a managed dataset (DSS owns its storage, so a
+     * recipe is the only way to fill it) that no recipe writes. Unmanaged
+     * datasets (uploads, external tables) are sources and legitimately build
+     * nothing. Lookups that fail leave the DONE outcome untouched.
+     */
+    private unbuildableTargets;
     /**
      * Probe whether a job still exists. Returns `true` when the server reports
      * it as not found, `false` when it is still visible, and `undefined` when

package/dist/src/resources/jobs.js

@@ -1,6 +1,7 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { JobSummaryArraySchema, } from "../schemas.js";
 import { computeNextPollDelayMs, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, isRequestDeadlineError, } from "../utils/polling.js";
+import { asRecord, } from "../utils/records.js";
 import { BaseResource, } from "./base.js";
 const DEFAULT_MAX_LOG_LINES = 500;
 /**
@@ -263,6 +264,10 @@ function summarizeJobLog(state, log, maxLines, elapsedMs) {
         ...(progress ? { progress, } : {}),
     };
 }
+function nothingToBuildMessage(targets) {
+    const names = targets.map((target) => `${target.projectKey}.${target.id}`).join(", ");
+    return `The job ran no activity: ${names} ${targets.length === 1 ? "is a managed dataset" : "are managed datasets"} that no recipe produces, so nothing was built. Create a recipe that writes ${targets.length === 1 ? "it" : "them"} or build the recipe's output instead.`;
+}
 export class JobsResource extends BaseResource {
     /** List jobs in a project. */
     async list(projectKey) {
@@ -375,6 +380,12 @@ export class JobsResource extends BaseResource {
      * confirmed gone. Explicit `includeLogs`/`summary` requests stay honest:
      * `log`/`logSummary` are only present when logs were actually retrieved.
      *
+     * A DONE job that ran no activity (`progress.total === 0`) is also what DSS
+     * reports for an already-up-to-date build, so it stays successful unless an
+     * output is a managed dataset that no recipe writes: then nothing can ever
+     * build it, and the outcome is `success: false` with
+     * `failure.code === "nothing_to_build"`.
+     *
      * On timeout, returns `{ success: false, ... }` rather than throwing.
      */
     async wait(jobId, opts) {
@@ -492,8 +503,18 @@ export class JobsResource extends BaseResource {
                         }
                     }
                 }
+                const unbuildable = success && gs.total === 0
+                    ? await this.unbuildableTargets(def.outputs, def.projectKey ?? opts?.projectKey)
+                    : [];
+                const failure = unbuildable.length > 0
+                    ? {
+                        code: "nothing_to_build",
+                        message: nothingToBuildMessage(unbuildable),
+                        targets: unbuildable,
+                    }
+                    : undefined;
                 return {
-                    success,
+                    success: success && failure === undefined,
                     jobId: def.id ?? jobId,
                     state,
                     type: def.type ?? "unknown",
@@ -505,6 +526,7 @@ export class JobsResource extends BaseResource {
                         running: gs.running ?? 0,
                         total: gs.total ?? null,
                     },
+                    ...(failure !== undefined ? { failure, } : {}),
                     ...(log !== undefined ? { log, } : {}),
                     ...(logSummary !== undefined ? { logSummary, } : {}),
                     ...(logUnavailable !== undefined ? { logUnavailable, } : {}),
@@ -523,6 +545,51 @@ export class JobsResource extends BaseResource {
             await sleep(Math.min(nextDelayMs, timeout - elapsedMs));
         }
     }
+    /**
+     * Dataset outputs of a job that ran no activity which nothing can produce.
+     * DSS ends such a job DONE exactly like an already-up-to-date build, so the
+     * job status cannot tell them apart; the flow graph can: a target is
+     * unbuildable when it is a managed dataset (DSS owns its storage, so a
+     * recipe is the only way to fill it) that no recipe writes. Unmanaged
+     * datasets (uploads, external tables) are sources and legitimately build
+     * nothing. Lookups that fail leave the DONE outcome untouched.
+     */
+    async unbuildableTargets(outputs, fallbackProjectKey) {
+        if (!Array.isArray(outputs))
+            return [];
+        const writtenByProject = new Map();
+        const unbuildable = [];
+        for (const output of outputs) {
+            const record = asRecord(output);
+            if (record?.type !== "DATASET" || typeof record.targetDataset !== "string")
+                continue;
+            const id = record.targetDataset;
+            const projectKey = typeof record.targetDatasetProjectKey === "string"
+                ? record.targetDatasetProjectKey
+                : fallbackProjectKey;
+            if (projectKey === undefined)
+                continue;
+            try {
+                const details = await this.client.datasets.get(id, projectKey);
+                if (details.managed !== true)
+                    continue;
+                let written = writtenByProject.get(projectKey);
+                if (written === undefined) {
+                    const { graph, } = await this.client.projects.flowTopology(projectKey);
+                    written = new Set(graph.edges.filter((edge) => edge.relation === "writes").map((edge) => edge.to));
+                    writtenByProject.set(projectKey, written);
+                }
+                if (!written.has(id)) {
+                    unbuildable.push({ type: "DATASET", id, projectKey, reason: "no_producing_recipe", });
+                }
+            }
+            catch (error) {
+                if (!(error instanceof DataikuError || error instanceof ClientValidationError))
+                    throw error;
+            }
+        }
+        return unbuildable;
+    }
     /**
      * Probe whether a job still exists. Returns `true` when the server reports
      * it as not found, `false` when it is still visible, and `undefined` when

package/dist/src/resources/projects.d.ts

@@ -1,5 +1,6 @@
 import type { FlowMapOptions, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectTags } from "../schemas.js";
 import type { AnalyzedFlowMap, FlowMapRendering } from "../utils/flow-analysis.js";
+import type { NormalizedFlowMap } from "../utils/flow-map.js";
 import { BaseResource } from "./base.js";
 interface FlowMapTruncationSummary {
     truncated: boolean;
@@ -150,6 +151,14 @@ export declare class ProjectsResource extends BaseResource {
     setTags(projectKey: string | undefined, tags: ProjectTags): Promise<void>;
     /** Get the raw flow graph for a project. */
     flow(projectKey?: string): Promise<unknown>;
+    /**
+     * Normalized flow topology (nodes and edges, no metadata lookups) plus its
+     * stable fingerprint, excluding visual metadata.
+     */
+    flowTopology(projectKey?: string): Promise<{
+        graph: NormalizedFlowMap;
+        topologyFingerprint: string;
+    }>;
     /** Compute a stable fingerprint of flow nodes and edges, excluding visual metadata. */
     topologyFingerprint(projectKey?: string): Promise<string>;
     /**

package/dist/src/resources/projects.js

@@ -340,11 +340,18 @@ export class ProjectsResource extends BaseResource {
         const enc = this.enc(projectKey);
         return this.client.get(`/public/api/projects/${enc}/flow/graph/`);
     }
+    /**
+     * Normalized flow topology (nodes and edges, no metadata lookups) plus its
+     * stable fingerprint, excluding visual metadata.
+     */
+    async flowTopology(projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        const graph = normalizeFlowGraph(await this.flow(pk), pk);
+        return { graph, topologyFingerprint: flowTopologyFingerprint(graph), };
+    }
     /** Compute a stable fingerprint of flow nodes and edges, excluding visual metadata. */
     async topologyFingerprint(projectKey) {
-        const pk = this.resolveProjectKey(projectKey);
-        const rawGraph = await this.flow(pk);
-        return flowTopologyFingerprint(normalizeFlowGraph(rawGraph, pk));
+        return (await this.flowTopology(projectKey)).topologyFingerprint;
     }
     /**
      * Build a normalized, optionally truncated flow map for a project.

package/dist/src/resources/recipe-create.d.ts

@@ -33,12 +33,26 @@ export declare function groupingPayloadConfig(opts: RecipeCreateOptions): Groupi
  * aggregate flags (and `orderColumn` for first/last).
  */
 export declare function applyGroupingPayload(payload: Record<string, unknown>, config: GroupingPayloadConfig): Record<string, unknown>;
+/** Prepare option groups, in the default step order. */
+export declare const PREPARE_STEP_KINDS: readonly ["rename", "fillEmpty", "formula", "filter", "dropColumns", "keepColumns"];
+export type PrepareStepKind = (typeof PREPARE_STEP_KINDS)[number];
 /**
- * Prepare (shaker) steps from create options, in a fixed order: rename,
- * fill empty, formula column, row filter, drop columns, keep columns. Later
- * steps see renamed columns. Empty when no prepare option was given.
+ * Prepare (shaker) steps from create options: rename, fill empty, formula
+ * column, row filter, drop columns, keep columns. They run in `stepOrder`
+ * (flag order on the CLI), defaulting to that sequence, so a step sees the
+ * columns the steps before it produced. Empty when no prepare option was given.
  */
 export declare function prepareSteps(opts: RecipeCreateOptions): Record<string, unknown>[];
+export interface RecipeCreateWarning {
+    code: string;
+    [key: string]: unknown;
+}
+/**
+ * Warnings about the prepare options that DSS cannot report itself: a
+ * `--formula`/`--filter` that runs after a `--rename` but still names a
+ * column that rename removed (it would fail or read an empty column).
+ */
+export declare function recipeCreateWarnings(opts: RecipeCreateOptions): RecipeCreateWarning[];
 /**
  * Pure request construction for POST /recipes/ (no DSS calls). Shared with
  * `recipe create --plan` so the plan equals the request the command sends.