dataiku-sdk 0.4.0 → 0.5.1

package/dist/src/resources/data-quality.js

@@ -0,0 +1,119 @@
+import { DataQualityComputeResultSchema, DataQualityProjectStatusSchema, DataQualityRuleArraySchema, DataQualityRuleResultArraySchema, DataQualityRuleSchema, DataQualityRulesSchema, DataQualityStatusByPartitionSchema, DataQualityStatusSchema, DataQualityTimelineSchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
+import { BaseResource, } from "./base.js";
+function datasetPath(projectKey, datasetName) {
+    return `/public/api/projects/${encodeURIComponent(projectKey)}/datasets/${encodeURIComponent(datasetName)}/data-quality`;
+}
+function addQuery(params, name, value) {
+    if (value !== undefined)
+        params.set(name, String(value));
+}
+function queryString(params) {
+    const raw = params.toString();
+    return raw ? `?${raw}` : "";
+}
+function partitionValue(partition) {
+    return partition && partition.trim().length > 0 ? partition : "NP";
+}
+function projectPath(projectKey) {
+    return `/public/api/projects/${encodeURIComponent(projectKey)}/data-quality`;
+}
+export class DataQualityResource extends BaseResource {
+    async rules(datasetName, projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        const raw = await this.client.get(`${datasetPath(pk, datasetName)}/rules`);
+        return this.client.safeParse(DataQualityRulesSchema, raw, "dataQuality.rules");
+    }
+    async listRules(datasetName, projectKey) {
+        const rules = await this.rules(datasetName, projectKey);
+        return this.client.safeParse(DataQualityRuleArraySchema, rules.checks, "dataQuality.listRules");
+    }
+    async createRule(datasetName, opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const raw = await this.client.post(`${datasetPath(pk, datasetName)}/rules`, opts.config);
+        return this.client.safeParse(DataQualityRuleSchema, raw, "dataQuality.createRule");
+    }
+    async updateRule(datasetName, ruleId, opts) {
+        const current = await this.getRule(datasetName, ruleId, opts.projectKey);
+        const next = deepMerge(current, opts.data);
+        const pk = this.resolveProjectKey(opts.projectKey);
+        await this.client.putVoid(`${datasetPath(pk, datasetName)}/rules/${encodeURIComponent(ruleId)}`, next);
+        return this.client.safeParse(DataQualityRuleSchema, next, "dataQuality.updateRule");
+    }
+    async deleteRule(datasetName, ruleId, projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        const params = new URLSearchParams();
+        params.set("ruleId", ruleId);
+        await this.client.del(`${datasetPath(pk, datasetName)}/rules/${encodeURIComponent(ruleId)}${queryString(params)}`);
+    }
+    async getRule(datasetName, ruleId, projectKey) {
+        const rules = await this.listRules(datasetName, projectKey);
+        const rule = rules.find((candidate) => candidate.id === ruleId);
+        if (!rule)
+            throw new Error(`Data quality rule not found: ${ruleId}`);
+        return rule;
+    }
+    async status(datasetName, projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        const raw = await this.client.get(`${datasetPath(pk, datasetName)}/status`);
+        return this.client.safeParse(DataQualityStatusSchema, raw, "dataQuality.status");
+    }
+    async statusByPartition(datasetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        addQuery(params, "includeAllPartitions", opts.includeAllPartitions);
+        const raw = await this.client.get(`${datasetPath(pk, datasetName)}/status-by-partition${queryString(params)}`);
+        return this.client.safeParse(DataQualityStatusByPartitionSchema, raw, "dataQuality.statusByPartition");
+    }
+    async lastResults(datasetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        addQuery(params, "partition", partitionValue(opts.partition));
+        addQuery(params, "ruleId", opts.ruleId);
+        const raw = await this.client.get(`${datasetPath(pk, datasetName)}/last-rules-result${queryString(params)}`);
+        return this.client.safeParse(DataQualityRuleResultArraySchema, raw, "dataQuality.lastResults");
+    }
+    async history(datasetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        addQuery(params, "minTimestamp", opts.minTimestamp);
+        addQuery(params, "maxTimestamp", opts.maxTimestamp);
+        addQuery(params, "resultsPerPage", opts.resultsPerPage);
+        addQuery(params, "page", opts.page);
+        addQuery(params, "ruleId", opts.ruleId);
+        const raw = await this.client.get(`${datasetPath(pk, datasetName)}/rules-history${queryString(params)}`);
+        return this.client.safeParse(DataQualityRuleResultArraySchema, raw, "dataQuality.history");
+    }
+    async computeRules(datasetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        addQuery(params, "partition", partitionValue(opts.partition));
+        addQuery(params, "ruleId", opts.ruleId);
+        const raw = await this.client.post(`${datasetPath(pk, datasetName)}/actions/compute-rules${queryString(params)}`);
+        return this.client.safeParse(DataQualityComputeResultSchema, raw, "dataQuality.computeRules");
+    }
+    async computeRulesAndWait(datasetName, opts = {}) {
+        const future = await this.computeRules(datasetName, opts);
+        if (!future.jobId)
+            throw new Error("Data quality compute did not return a future jobId.");
+        return this.client.futures.wait(future.jobId, {
+            pollIntervalMs: opts.pollIntervalMs,
+            timeoutMs: opts.timeoutMs,
+        });
+    }
+    async projectStatus(opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        addQuery(params, "onlyMonitored", opts.onlyMonitored);
+        const raw = await this.client.get(`${projectPath(pk)}/status${queryString(params)}`);
+        return this.client.safeParse(DataQualityProjectStatusSchema, raw, "dataQuality.projectStatus");
+    }
+    async projectTimeline(opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        addQuery(params, "minTimestamp", opts.minTimestamp);
+        addQuery(params, "maxTimestamp", opts.maxTimestamp);
+        const raw = await this.client.get(`${projectPath(pk)}/timeline${queryString(params)}`);
+        return this.client.safeParse(DataQualityTimelineSchema, raw, "dataQuality.projectTimeline");
+    }
+}

package/dist/src/resources/datasets.js

@@ -289,7 +289,7 @@ function buildDatasetCreateBody(opts) {
         type: opts.dsType,
         params: {
             connection: opts.connection,
-            path: `${opts.projectKey}/${opts.datasetName}`,
+            path: `/dataiku/${opts.projectKey}/${opts.datasetName}`,
         },
         formatType: opts.formatType ?? "csv",
         formatParams: opts.formatParams ?? {

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

@@ -0,0 +1,25 @@
+import type { FlowZone, FlowZoneCreateOptions, FlowZoneObjectType, FlowZoneUpdateOptions } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export type FlowZoneItemInput = {
+    objectId: string;
+    objectType: FlowZoneObjectType;
+    projectKey?: string;
+};
+export declare class FlowZonesResource extends BaseResource {
+    /** List all flow zones in a project. */
+    list(projectKey?: string): Promise<FlowZone[]>;
+    /** Get one flow zone by id. */
+    get(zoneId: string, projectKey?: string): Promise<FlowZone>;
+    /** Create a flow zone. */
+    create(opts: FlowZoneCreateOptions): Promise<FlowZone>;
+    /** Update flow zone settings such as name and color. */
+    update(zoneId: string, opts: FlowZoneUpdateOptions): Promise<FlowZone>;
+    /** 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. */
+    moveItems(zoneId: string, items: FlowZoneItemInput[], projectKey?: string): Promise<FlowZone>;
+    /** Move a single item into a flow zone. */
+    moveItem(zoneId: string, item: FlowZoneItemInput, projectKey?: string): Promise<FlowZone>;
+    /** Get the graph for a single flow zone. */
+    graph(zoneId: string, projectKey?: string): Promise<unknown>;
+}

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

@@ -0,0 +1,59 @@
+import { FlowZoneArraySchema, FlowZoneSchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
+import { BaseResource, } from "./base.js";
+function normalizeZoneItem(item) {
+    return {
+        objectId: item.objectId,
+        objectType: item.objectType,
+        ...(item.projectKey ? { projectKey: item.projectKey, } : {}),
+    };
+}
+export class FlowZonesResource extends BaseResource {
+    /** List all flow zones in a project. */
+    async list(projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/flow/zones`);
+        return this.client.safeParse(FlowZoneArraySchema, raw, "flowZones.list");
+    }
+    /** Get one flow zone by id. */
+    async get(zoneId, projectKey) {
+        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. */
+    async create(opts) {
+        const raw = await this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/flow/zones`, {
+            name: opts.name,
+            color: opts.color ?? "#2ab1ac",
+        });
+        return this.client.safeParse(FlowZoneSchema, raw, "flowZones.create");
+    }
+    /** Update flow zone settings such as name and color. */
+    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, } : {}),
+        });
+        await this.client.putVoid(`/public/api/projects/${this.enc(opts.projectKey)}/flow/zones/${encodeURIComponent(zoneId)}`, merged);
+        return this.get(zoneId, opts.projectKey);
+    }
+    /** 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)}`);
+    }
+    /** Move items into a flow zone. */
+    async moveItems(zoneId, items, projectKey) {
+        if (items.length === 0)
+            throw new Error("flowZones.moveItems requires at least one item");
+        const raw = await this.client.post(`/public/api/projects/${this.enc(projectKey)}/flow/zones/${encodeURIComponent(zoneId)}/add-items`, items.map(normalizeZoneItem));
+        return this.client.safeParse(FlowZoneSchema, raw, "flowZones.moveItems");
+    }
+    /** Move a single item into a flow zone. */
+    async moveItem(zoneId, item, projectKey) {
+        return this.moveItems(zoneId, [item,], projectKey);
+    }
+    /** Get the graph for a single flow zone. */
+    async graph(zoneId, projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/flow/zones/${encodeURIComponent(zoneId)}/graph`);
+    }
+}

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

@@ -1,9 +1,11 @@
-import type { FolderDetails, FolderItem, FolderSummary } from "../schemas.js";
+import type { FolderCreateOptions, FolderDetails, FolderItem, FolderSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export declare class FoldersResource extends BaseResource {
+    create(opts: FolderCreateOptions): Promise<FolderDetails>;
     list(projectKey?: string): Promise<FolderSummary[]>;
     resolveId(nameOrId: string, projectKey?: string): Promise<string>;
     get(folderId: string, projectKey?: string): Promise<FolderDetails>;
+    update(folderId: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
     contents(folderId: string, opts?: {
         projectKey?: string;
     }): Promise<FolderItem[]>;
@@ -13,4 +15,5 @@ export declare class FoldersResource extends BaseResource {
     }): Promise<string>;
     upload(folderId: string, path: string, localPath: string, projectKey?: string): Promise<void>;
     deleteFile(folderId: string, path: string, projectKey?: string): Promise<void>;
+    delete(folderId: string, projectKey?: string): Promise<void>;
 }

package/dist/src/resources/folders.js

@@ -3,6 +3,7 @@ import { resolve, } from "node:path";
 import { Readable, } from "node:stream";
 import { pipeline, } from "node:stream/promises";
 import { FolderDetailsSchema, FolderItemArraySchema, FolderSummaryArraySchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
 function normalizeRemotePath(path) {
@@ -17,6 +18,21 @@ function inferDownloadFileName(remotePath) {
 // Resource
 // ---------------------------------------------------------------------------
 export class FoldersResource extends BaseResource {
+    async create(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const path = opts.path?.trim() || `/dataiku/${pk}/${opts.name}`;
+        const raw = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/managedfolders/`, {
+            name: opts.name,
+            projectKey: pk,
+            type: opts.type,
+            params: {
+                ...opts.params,
+                connection: opts.connection,
+                path,
+            },
+        });
+        return this.client.safeParse(FolderDetailsSchema, raw, "folders.create");
+    }
     async list(projectKey) {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/managedfolders/`);
         return this.client.safeParse(FolderSummaryArraySchema, raw, "folders.list");
@@ -34,6 +50,13 @@ export class FoldersResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/managedfolders/${fEnc}`);
         return this.client.safeParse(FolderDetailsSchema, raw, "folders.get");
     }
+    async update(folderId, data, projectKey) {
+        const fEnc = encodeURIComponent(folderId);
+        const pkEnc = this.enc(projectKey);
+        const current = await this.client.get(`/public/api/projects/${pkEnc}/managedfolders/${fEnc}`);
+        const merged = deepMerge(current, data);
+        await this.client.put(`/public/api/projects/${pkEnc}/managedfolders/${fEnc}`, merged);
+    }
     async contents(folderId, opts) {
         const fEnc = encodeURIComponent(folderId);
         const response = await this.client.get(`/public/api/projects/${this.enc(opts?.projectKey)}/managedfolders/${fEnc}/contents/`);
@@ -63,4 +86,8 @@ export class FoldersResource extends BaseResource {
         const pEnc = encodeURIComponent(normalizedPath);
         return this.client.del(`/public/api/projects/${this.enc(projectKey)}/managedfolders/${fEnc}/contents/${pEnc}`);
     }
+    delete(folderId, projectKey) {
+        const fEnc = encodeURIComponent(folderId);
+        return this.client.del(`/public/api/projects/${this.enc(projectKey)}/managedfolders/${fEnc}`);
+    }
 }

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

@@ -0,0 +1,15 @@
+import type { FutureState, FutureWaitResult } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export interface FutureWaitOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+}
+export declare class FuturesResource extends BaseResource {
+    get(futureId: string): Promise<FutureState>;
+    peek(futureId: string): Promise<FutureState>;
+    state(futureId: string, opts?: {
+        peek?: boolean;
+    }): Promise<FutureState>;
+    abort(futureId: string): Promise<void>;
+    wait(futureId: string, opts?: FutureWaitOptions): Promise<FutureWaitResult>;
+}

package/dist/src/resources/futures.js

@@ -0,0 +1,86 @@
+import { FutureStateSchema, FutureWaitResultSchema, } from "../schemas.js";
+import { BaseResource, } from "./base.js";
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const DEFAULT_TIMEOUT_MS = 120_000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isFinished(state) {
+    return state.hasResult === true
+        || state.aborted === true
+        || state.alive === false
+        || state.unknown === true;
+}
+function waitState(state) {
+    if (state.hasResult === true)
+        return "DONE";
+    if (state.aborted === true)
+        return "ABORTED";
+    if (state.unknown === true)
+        return "UNKNOWN";
+    if (state.alive === false)
+        return "FAILED";
+    return "RUNNING";
+}
+export class FuturesResource extends BaseResource {
+    async get(futureId) {
+        return this.state(futureId, { peek: false, });
+    }
+    async peek(futureId) {
+        return this.state(futureId, { peek: true, });
+    }
+    async state(futureId, opts = {}) {
+        const params = new URLSearchParams();
+        params.set("peek", String(opts.peek === true));
+        const raw = await this.client.get(`/public/api/futures/${encodeURIComponent(futureId)}?${params.toString()}`);
+        return this.client.safeParse(FutureStateSchema, raw, "futures.state");
+    }
+    async abort(futureId) {
+        await this.client.del(`/public/api/futures/${encodeURIComponent(futureId)}`);
+    }
+    async wait(futureId, opts = {}) {
+        const baseIntervalMs = Math.max(1, opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+        const timeoutMs = Math.max(baseIntervalMs, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        const startedAt = Date.now();
+        let pollCount = 0;
+        while (true) {
+            pollCount += 1;
+            const state = await this.get(futureId);
+            const elapsedMs = Date.now() - startedAt;
+            const status = waitState(state);
+            if (isFinished(state)) {
+                const result = {
+                    futureId,
+                    jobId: state.jobId,
+                    state: status,
+                    elapsedMs,
+                    pollCount,
+                    success: state.hasResult === true,
+                    hasResult: state.hasResult === true,
+                    alive: state.alive,
+                    aborted: state.aborted,
+                    unknown: state.unknown,
+                    ...(state.result !== undefined ? { result: state.result, } : {}),
+                };
+                return this.client.safeParse(FutureWaitResultSchema, result, "futures.wait");
+            }
+            if (elapsedMs >= timeoutMs) {
+                const result = {
+                    futureId,
+                    jobId: state.jobId,
+                    state: status,
+                    elapsedMs,
+                    pollCount,
+                    success: false,
+                    timedOut: true,
+                    hasResult: state.hasResult === true,
+                    alive: state.alive,
+                    aborted: state.aborted,
+                    unknown: state.unknown,
+                };
+                return this.client.safeParse(FutureWaitResultSchema, result, "futures.wait");
+            }
+            await sleep(baseIntervalMs);
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { InsightDetails, InsightSummary } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export interface InsightCreateOptions {
+    name?: string;
+    type?: string;
+    listed?: boolean;
+    params?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    contentType?: string;
+    payload?: string;
+    projectKey?: string;
+}
+export interface InsightUpdateOptions {
+    name?: string;
+    listed?: boolean;
+    params?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    contentType?: string;
+    payload?: string;
+    projectKey?: string;
+}
+export declare class InsightsResource extends BaseResource {
+    list(projectKey?: string): Promise<InsightSummary[]>;
+    get(insightId: string, projectKey?: string): Promise<InsightDetails>;
+    create(opts: InsightCreateOptions): Promise<InsightDetails>;
+    update(insightId: string, opts: InsightUpdateOptions): Promise<InsightDetails>;
+    delete(insightId: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/insights.js

@@ -0,0 +1,64 @@
+import { InsightDetailsSchema, InsightSummaryArraySchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
+import { BaseResource, } from "./base.js";
+function hasCreateShape(data) {
+    return typeof data.name === "string" && typeof data.type === "string";
+}
+function applyInsightFields(base, fields) {
+    const next = { ...base, };
+    if (fields.name !== undefined)
+        next.name = fields.name;
+    if (fields.type !== undefined)
+        next.type = fields.type;
+    if (fields.listed !== undefined)
+        next.listed = fields.listed;
+    if (fields.params !== undefined) {
+        const currentParams = next.params;
+        next.params = currentParams && typeof currentParams === "object" && !Array.isArray(currentParams)
+            ? deepMerge(currentParams, fields.params)
+            : fields.params;
+    }
+    return next;
+}
+export class InsightsResource extends BaseResource {
+    async list(projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/insights/`);
+        return this.client.safeParse(InsightSummaryArraySchema, raw, "insights.list");
+    }
+    async get(insightId, projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/insights/${encodeURIComponent(insightId)}/`);
+        return this.client.safeParse(InsightDetailsSchema, raw, "insights.get");
+    }
+    async create(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const prototype = applyInsightFields(opts.data ?? {}, opts);
+        if (!hasCreateShape(prototype)) {
+            throw new Error("Insight create requires name and type, either as options or in data.");
+        }
+        if (prototype.projectKey === undefined)
+            prototype.projectKey = pk;
+        const created = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/insights/`, {
+            insightPrototype: prototype,
+            ...(opts.contentType !== undefined ? { contentType: opts.contentType, } : {}),
+            ...(opts.payload !== undefined ? { payload: opts.payload, } : {}),
+        });
+        if (typeof created.id !== "string" || created.id.length === 0) {
+            throw new Error("Insight create response did not include an id.");
+        }
+        return this.get(created.id, pk);
+    }
+    async update(insightId, opts) {
+        const current = await this.get(insightId, opts.projectKey);
+        const next = applyInsightFields(deepMerge(current, opts.data ?? {}), opts);
+        const pk = this.resolveProjectKey(opts.projectKey);
+        await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/insights/${encodeURIComponent(insightId)}/`, {
+            insight: next,
+            ...(opts.contentType !== undefined ? { contentType: opts.contentType, } : {}),
+            ...(opts.payload !== undefined ? { payload: opts.payload, } : {}),
+        });
+        return this.get(insightId, pk);
+    }
+    async delete(insightId, projectKey) {
+        await this.client.del(`/public/api/projects/${this.enc(projectKey)}/insights/${encodeURIComponent(insightId)}/`);
+    }
+}

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

@@ -1,5 +1,6 @@
 import type { BuildMode, JobSummary, JobWaitResult } from "../schemas.js";
 import { BaseResource } from "./base.js";
+export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER";
 interface ComputeNextPollDelayMsOptions {
     pollCount: number;
     baseIntervalMs: number;
@@ -27,21 +28,22 @@ export declare class JobsResource extends BaseResource {
         projectKey?: string;
     }): Promise<string>;
     /**
-     * Start a dataset build job.
+     * Start a build job for a dataset or managed folder.
      * Returns the new job's ID.
      */
-    build(datasetName: string, opts?: {
+    build(targetId: string, opts?: {
         buildMode?: BuildMode;
         autoUpdateSchema?: boolean;
         projectKey?: string;
+        targetType?: JobBuildTargetType;
     }): Promise<{
         jobId: string;
     }>;
     /**
-     * Build a dataset and wait for the job to reach a terminal state.
+     * Build a dataset or managed folder and wait for the job to reach a terminal state.
      * Combines {@link build} then {@link wait}.
      */
-    buildAndWait(datasetName: string, opts?: {
+    buildAndWait(targetId: string, opts?: {
         buildMode?: BuildMode;
         autoUpdateSchema?: boolean;
         activity?: string;
@@ -50,6 +52,7 @@ export declare class JobsResource extends BaseResource {
         pollIntervalMs?: number;
         timeoutMs?: number;
         projectKey?: string;
+        targetType?: JobBuildTargetType;
     }): Promise<JobWaitResult>;
     /**
      * Poll a job until it reaches a terminal state or times out.

package/dist/src/resources/jobs.js

@@ -69,31 +69,33 @@ export class JobsResource extends BaseResource {
         return log;
     }
     /**
-     * Start a dataset build job.
+     * Start a build job for a dataset or managed folder.
      * Returns the new job's ID.
      */
-    async build(datasetName, opts) {
+    async build(targetId, opts) {
         const pk = this.resolveProjectKey(opts?.projectKey);
         const enc = encodeURIComponent(pk);
+        const targetType = opts?.targetType ?? "DATASET";
         const jobDef = {
-            outputs: [{ projectKey: pk, id: datasetName, type: "DATASET", },],
+            outputs: [{ projectKey: pk, id: targetId, type: targetType, },],
             type: opts?.buildMode ?? "NON_RECURSIVE_FORCED_BUILD",
         };
-        if (opts?.autoUpdateSchema) {
+        if (opts?.autoUpdateSchema && targetType === "DATASET") {
             jobDef.autoUpdateSchemaBeforeEachRecipeRun = true;
         }
         const job = await this.client.post(`/public/api/projects/${enc}/jobs/`, jobDef);
         return { jobId: job.id, };
     }
     /**
-     * Build a dataset and wait for the job to reach a terminal state.
+     * Build a dataset or managed folder and wait for the job to reach a terminal state.
      * Combines {@link build} then {@link wait}.
      */
-    async buildAndWait(datasetName, opts) {
-        const { jobId, } = await this.build(datasetName, {
+    async buildAndWait(targetId, opts) {
+        const { jobId, } = await this.build(targetId, {
             buildMode: opts?.buildMode,
             autoUpdateSchema: opts?.autoUpdateSchema,
             projectKey: opts?.projectKey,
+            targetType: opts?.targetType,
         });
         return this.wait(jobId, {
             activity: opts?.activity,

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

@@ -10,8 +10,9 @@ export declare class NotebooksResource extends BaseResource {
     /**
      * Delete a Jupyter notebook.
      *
-     * DSS public APIs can delete notebooks but do not expose notebook creation, so
-     * this can only target notebooks created outside this SDK (for example in the UI).
+     * The SDK intentionally does not expose notebook creation as a first-class
+     * resource method yet; integration tests create disposable notebooks through
+     * the documented project-level create endpoint.
      */
     deleteJupyter(name: string, projectKey?: string): Promise<void>;
     /**
@@ -26,8 +27,9 @@ export declare class NotebooksResource extends BaseResource {
     /**
      * Unload (stop) a running Jupyter notebook session.
      *
-     * DSS public APIs do not expose notebook or session creation, so this only
-     * works for sessions started outside this SDK.
+     * DSS public APIs expose session listing and unloading, but this SDK has no
+     * path to start a disposable kernel session; live unload coverage therefore
+     * requires an externally-started disposable session fixture.
      */
     unloadJupyter(name: string, sessionId: string, projectKey?: string): Promise<void>;
     /** List all SQL notebooks in a project. */

package/dist/src/resources/notebooks.js

@@ -21,8 +21,9 @@ export class NotebooksResource extends BaseResource {
     /**
      * Delete a Jupyter notebook.
      *
-     * DSS public APIs can delete notebooks but do not expose notebook creation, so
-     * this can only target notebooks created outside this SDK (for example in the UI).
+     * The SDK intentionally does not expose notebook creation as a first-class
+     * resource method yet; integration tests create disposable notebooks through
+     * the documented project-level create endpoint.
      */
     async deleteJupyter(name, projectKey) {
         const nameEnc = encodeURIComponent(name);
@@ -52,8 +53,9 @@ export class NotebooksResource extends BaseResource {
     /**
      * Unload (stop) a running Jupyter notebook session.
      *
-     * DSS public APIs do not expose notebook or session creation, so this only
-     * works for sessions started outside this SDK.
+     * DSS public APIs expose session listing and unloading, but this SDK has no
+     * path to start a disposable kernel session; live unload coverage therefore
+     * requires an externally-started disposable session fixture.
      */
     async unloadJupyter(name, sessionId, projectKey) {
         const nameEnc = encodeURIComponent(name);