dataiku-sdk 0.4.0 → 0.5.1

package/dist/src/resources/recipes.js

@@ -22,6 +22,10 @@ function asRecord(value) {
         return undefined;
     return value;
 }
+const RECIPE_DEFINITION_FIELDS = new Set(["params", "inputs", "outputs", "scriptSettings",]);
+function rootRecipeDefinitionFields(data) {
+    return Object.keys(data).filter((key) => RECIPE_DEFINITION_FIELDS.has(key));
+}
 function inferRecipeCodeExtension(recipeType) {
     const normalized = typeof recipeType === "string" ? recipeType.trim().toLowerCase() : "";
     if (!normalized)
@@ -86,18 +90,19 @@ export class RecipesResource extends BaseResource {
         if (!result || !recipe) {
             throw new DataikuError(404, "Not Found", `Recipe "${recipeName}" not found in project "${this.resolveProjectKey(opts?.projectKey)}" (DSS returned empty response).`);
         }
-        return { ...result, recipe, };
+        return opts?.includePayload ? { ...result, recipe, } : { recipe, };
     }
     /** Create a recipe, with optional output dataset provisioning and join configuration. */
     async create(opts) {
         const pk = this.resolveProjectKey(opts.projectKey);
         const enc = encodeURIComponent(pk);
         const { type, payload, outputConnection: rawConnection, joinType: rawJoinType, } = opts;
+        const outputFolder = asString(opts.outputFolder);
         // Build inputs/outputs from simple form (inputDatasets + outputDataset) or
         // advanced form (inputs + outputs); both may coexist — simple form wins when
         // the advanced form is absent.
         const inputDatasets = asStringArray(opts.inputDatasets);
-        const outputDataset = asString(opts.outputDataset);
+        const requestedOutputDataset = asString(opts.outputDataset);
         let inputs = asRecord(opts.inputs);
         let outputs = asRecord(opts.outputs);
         if (!inputs && inputDatasets) {
@@ -107,6 +112,15 @@ export class RecipesResource extends BaseResource {
                 },
             };
         }
+        // Auto-generate name if not provided
+        const outputNameForDefaultRecipe = requestedOutputDataset ?? outputFolder;
+        const name = opts.name ?? (type && outputNameForDefaultRecipe
+            ? `${type}_${outputNameForDefaultRecipe}`
+            : undefined);
+        const temporaryOutputDataset = outputFolder && !requestedOutputDataset && name
+            ? `${name}_folder_output_marker`
+            : undefined;
+        const outputDataset = requestedOutputDataset ?? temporaryOutputDataset;
         if (!outputs && outputDataset) {
             outputs = {
                 main: {
@@ -114,10 +128,8 @@ export class RecipesResource extends BaseResource {
                 },
             };
         }
-        // Auto-generate name if not provided
-        const name = opts.name ?? (type && outputDataset ? `${type}_${outputDataset}` : undefined);
         if (!type || !name || !inputs || !outputs) {
-            throw new Error("type and (inputDatasets + outputDataset) or (name + inputs + outputs) are required for create.");
+            throw new Error("type and (inputDatasets + outputDataset/outputFolder) or (name + inputs + outputs) are required for create.");
         }
         const recipePrototype = {
             type,
@@ -136,15 +148,7 @@ export class RecipesResource extends BaseResource {
         });
         const createdDatasets = [];
         let usedOutputProvisioningFallback = false;
-        try {
-            await createRecipe();
-        }
-        catch (error) {
-            if (!shouldRetryRecipeCreateWithOutputProvisioning(error)) {
-                throw error;
-            }
-            usedOutputProvisioningFallback = true;
-            // Fetch existing datasets to infer output connection and type
+        const provisionOutputDatasets = async () => {
             const existingDs = await this.client.get(`/public/api/projects/${enc}/datasets/`);
             let outputConnection = asString(rawConnection);
             if (!outputConnection) {
@@ -153,61 +157,75 @@ export class RecipesResource extends BaseResource {
                     outputConnection = managedDs.params.connection;
                 }
             }
-            if (outputConnection) {
-                const existingNames = new Set(existingDs.map((d) => d.name));
-                const connectionSample = existingDs.find((d) => d.params?.connection === outputConnection && d.type);
-                const inferredOutputType = connectionSample?.type ?? "Filesystem";
-                const outputRoles = outputs;
-                for (const role of Object.values(outputRoles)) {
-                    for (const item of role.items ?? []) {
-                        if (item.ref && !existingNames.has(item.ref)) {
-                            const datasetBody = inferredOutputType === "Filesystem"
-                                ? {
-                                    projectKey: pk,
-                                    name: item.ref,
-                                    type: inferredOutputType,
-                                    params: {
-                                        connection: outputConnection,
-                                        path: `\${projectKey}/${item.ref}`,
-                                    },
-                                    formatType: "csv",
-                                    formatParams: {
-                                        style: "excel",
-                                        charset: "utf8",
-                                        separator: "\t",
-                                        quoteChar: '"',
-                                        escapeChar: "\\",
-                                        dateSerializationFormat: "ISO",
-                                        arrayMapFormat: "json",
-                                        parseHeaderRow: true,
-                                        compress: "gz",
-                                    },
-                                    managed: true,
-                                }
-                                : {
-                                    projectKey: pk,
-                                    name: item.ref,
-                                    type: inferredOutputType,
-                                    params: {
-                                        connection: outputConnection,
-                                        mode: "table",
-                                        table: item.ref,
-                                        ...(connectionSample?.params?.schema
-                                            ? { schema: connectionSample.params.schema, }
-                                            : {}),
-                                        ...(connectionSample?.params?.catalog
-                                            ? { catalog: connectionSample.params.catalog, }
-                                            : {}),
-                                    },
-                                    managed: connectionSample?.managed ?? false,
-                                };
-                            await this.client.post(`/public/api/projects/${enc}/datasets/`, datasetBody);
-                            existingNames.add(item.ref);
-                            createdDatasets.push(item.ref);
+            if (!outputConnection)
+                return;
+            const existingNames = new Set([...existingDs.map((d) => d.name), ...createdDatasets,]);
+            const connectionSample = existingDs.find((d) => d.params?.connection === outputConnection && d.type);
+            const inferredOutputType = connectionSample?.type ?? "Filesystem";
+            const outputRoles = outputs;
+            for (const role of Object.values(outputRoles)) {
+                for (const item of role.items ?? []) {
+                    if (!item.ref || existingNames.has(item.ref))
+                        continue;
+                    const datasetBody = inferredOutputType === "Filesystem"
+                        ? {
+                            projectKey: pk,
+                            name: item.ref,
+                            type: inferredOutputType,
+                            params: {
+                                connection: outputConnection,
+                                path: `/dataiku/${pk}/${item.ref}`,
+                                metastoreTableName: item.ref,
+                            },
+                            formatType: "csv",
+                            formatParams: {
+                                style: "excel",
+                                charset: "utf8",
+                                separator: "\t",
+                                quoteChar: '"',
+                                escapeChar: "\\",
+                                dateSerializationFormat: "ISO",
+                                arrayMapFormat: "json",
+                                parseHeaderRow: true,
+                                compress: "gz",
+                            },
+                            managed: true,
                         }
-                    }
+                        : {
+                            projectKey: pk,
+                            name: item.ref,
+                            type: inferredOutputType,
+                            params: {
+                                connection: outputConnection,
+                                mode: "table",
+                                table: item.ref,
+                                ...(connectionSample?.params?.schema
+                                    ? { schema: connectionSample.params.schema, }
+                                    : {}),
+                                ...(connectionSample?.params?.catalog
+                                    ? { catalog: connectionSample.params.catalog, }
+                                    : {}),
+                            },
+                            managed: connectionSample?.managed ?? false,
+                        };
+                    await this.client.post(`/public/api/projects/${enc}/datasets/`, datasetBody);
+                    existingNames.add(item.ref);
+                    if (!createdDatasets.includes(item.ref))
+                        createdDatasets.push(item.ref);
                 }
             }
+        };
+        try {
+            if (rawConnection)
+                await provisionOutputDatasets();
+            await createRecipe();
+        }
+        catch (error) {
+            if (!shouldRetryRecipeCreateWithOutputProvisioning(error)) {
+                throw error;
+            }
+            usedOutputProvisioningFallback = true;
+            await provisionOutputDatasets();
             await createRecipe();
         }
         // For join recipes: configure join conditions after creation
@@ -254,12 +272,39 @@ export class RecipesResource extends BaseResource {
             await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, updatedFull);
             joinConfigured = true;
         }
+        let temporaryOutputDatasetDeleted;
+        if (outputFolder) {
+            await this.update(name, {
+                recipe: {
+                    outputs: {
+                        main: {
+                            items: [{ ref: outputFolder, appendMode: false, },],
+                        },
+                    },
+                },
+            }, pk);
+            if (temporaryOutputDataset) {
+                try {
+                    await this.client.del(`/public/api/projects/${enc}/datasets/${encodeURIComponent(temporaryOutputDataset)}`);
+                    temporaryOutputDatasetDeleted = true;
+                    const createdIndex = createdDatasets.indexOf(temporaryOutputDataset);
+                    if (createdIndex !== -1)
+                        createdDatasets.splice(createdIndex, 1);
+                }
+                catch {
+                    temporaryOutputDatasetDeleted = false;
+                }
+            }
+        }
         return {
             recipeName: name,
             type,
             createdDatasets,
             joinConfigured,
             outputProvisioningFallbackUsed: usedOutputProvisioningFallback,
+            ...(outputFolder ? { outputFolder, } : {}),
+            ...(temporaryOutputDataset ? { temporaryOutputDataset, } : {}),
+            ...(temporaryOutputDatasetDeleted !== undefined ? { temporaryOutputDatasetDeleted, } : {}),
         };
     }
     /**
@@ -274,6 +319,10 @@ export class RecipesResource extends BaseResource {
         if (!currentRecipe) {
             throw new Error(`Recipe "${recipeName}" was not found or returned an empty definition.`);
         }
+        const misplacedRecipeFields = rootRecipeDefinitionFields(data);
+        if (misplacedRecipeFields.length > 0) {
+            throw new Error(`Recipe fields ${misplacedRecipeFields.join(", ")} must be nested under "recipe". Example: {"recipe":{"outputs":{...},"params":{...}}}`);
+        }
         const mergedRecipe = deepMerge(currentRecipe, asRecord(data.recipe) ?? {});
         const merged = { ...current, ...data, recipe: mergedRecipe, };
         await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, merged);

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

@@ -0,0 +1,22 @@
+import type { WikiArticleData, WikiSettings } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export interface WikiArticleCreateOptions {
+    name: string;
+    parent?: string;
+    content?: string;
+    projectKey?: string;
+}
+export interface WikiArticleUpdateOptions {
+    name?: string;
+    content?: string;
+    data?: Record<string, unknown>;
+    projectKey?: string;
+}
+export declare class WikiResource extends BaseResource {
+    settings(projectKey?: string): Promise<WikiSettings>;
+    list(projectKey?: string): Promise<WikiArticleData[]>;
+    get(articleIdOrName: string, projectKey?: string): Promise<WikiArticleData>;
+    create(opts: WikiArticleCreateOptions): Promise<WikiArticleData>;
+    update(articleIdOrName: string, opts: WikiArticleUpdateOptions): Promise<WikiArticleData>;
+    delete(articleIdOrName: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/wiki.js

@@ -0,0 +1,73 @@
+import { WikiArticleDataArraySchema, WikiArticleDataSchema, WikiSettingsSchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
+import { BaseResource, } from "./base.js";
+const WIKI_LIST_CONCURRENCY = 4;
+function taxonomyIds(nodes) {
+    const ids = [];
+    for (const node of nodes ?? []) {
+        if (!node || typeof node !== "object" || Array.isArray(node))
+            continue;
+        const record = node;
+        if (typeof record.id === "string" && record.id.length > 0)
+            ids.push(record.id);
+        if (Array.isArray(record.children))
+            ids.push(...taxonomyIds(record.children));
+    }
+    return ids;
+}
+async function mapWithConcurrency(items, limit, mapper) {
+    const results = [];
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex++;
+            results[index] = await mapper(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length), }, () => worker()));
+    return results;
+}
+export class WikiResource extends BaseResource {
+    async settings(projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/wiki/`);
+        return this.client.safeParse(WikiSettingsSchema, raw, "wiki.settings");
+    }
+    async list(projectKey) {
+        const settings = await this.settings(projectKey);
+        const ids = taxonomyIds(settings.taxonomy);
+        const articles = await mapWithConcurrency(ids, WIKI_LIST_CONCURRENCY, (id) => this.get(id, projectKey));
+        return this.client.safeParse(WikiArticleDataArraySchema, articles, "wiki.list");
+    }
+    async get(articleIdOrName, projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/wiki/${encodeURIComponent(articleIdOrName)}`);
+        return this.client.safeParse(WikiArticleDataSchema, raw, "wiki.get");
+    }
+    async create(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const raw = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/wiki/`, {
+            projectKey: pk,
+            name: opts.name,
+            parent: opts.parent ?? null,
+        });
+        const created = this.client.safeParse(WikiArticleDataSchema, raw, "wiki.create");
+        if (opts.content === undefined)
+            return created;
+        return this.update(created.article.id, { content: opts.content, projectKey: pk, });
+    }
+    async update(articleIdOrName, opts) {
+        const current = await this.get(articleIdOrName, opts.projectKey);
+        const patch = opts.data ?? {};
+        const next = deepMerge(current, patch);
+        if (opts.name !== undefined)
+            next.article = { ...next.article, name: opts.name, };
+        if (opts.content !== undefined)
+            next.payload = opts.content;
+        const raw = await this.client.put(`/public/api/projects/${this.enc(opts.projectKey)}/wiki/${encodeURIComponent(current.article.id)}`, next);
+        return this.client.safeParse(WikiArticleDataSchema, raw, "wiki.update");
+    }
+    async delete(articleIdOrName, projectKey) {
+        const current = await this.get(articleIdOrName, projectKey);
+        await this.client.del(`/public/api/projects/${this.enc(projectKey)}/wiki/${encodeURIComponent(current.article.id)}`);
+    }
+}

package/dist/src/schemas.d.ts

@@ -3,5 +3,5 @@
  * The types package (packages/types/) owns the TypeBox schema definitions.
  * SDK consumers get everything through this re-export.
  */
-export { BuildModeSchema, CodeEnvDetailsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, ConnectionSummarySchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, ScenarioWaitResultSchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "../packages/types/src/index.js";
-export type { BuildMode, CodeEnvDetails, CodeEnvSummary, ConnectionSummary, DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary, FlowMapOptions, FolderDetails, FolderItem, FolderSummary, JobSummary, JobWaitResult, JupyterCell, JupyterNotebookContent, JupyterNotebookSummary, NotebookSession, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectVariables, RecipeCreateOptions, RecipeCreateResult, RecipeDetails, RecipeSummary, SafeParseResult, ScenarioDetails, ScenarioStatus, ScenarioSummary, ScenarioWaitResult, SqlNotebookCell, SqlNotebookContent, SqlNotebookSummary, SqlQueryResponse, SqlQueryResult, SqlQuerySchema, } from "../packages/types/src/index.js";
+export { BuildModeSchema, CodeEnvActionResultSchema, CodeEnvCreateOptionsSchema, CodeEnvDetailsSchema, CodeEnvPackageListSchema, CodeEnvSetPackagesOptionsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, CodeEnvUpdatePackagesOptionsSchema, CodeEnvUsageArraySchema, CodeEnvWaitOptionsSchema, ConnectionSummarySchema, DashboardDetailsSchema, DashboardSummaryArraySchema, DashboardSummarySchema, DataQualityComputeResultSchema, DataQualityProjectStatusSchema, DataQualityRuleArraySchema, DataQualityRuleResultArraySchema, DataQualityRuleResultSchema, DataQualityRuleSchema, DataQualityRulesSchema, DataQualityStatusByPartitionSchema, DataQualityStatusSchema, DataQualityTimelineEntrySchema, DataQualityTimelineSchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FlowZoneArraySchema, FlowZoneCreateOptionsSchema, FlowZoneItemSchema, FlowZoneObjectTypeSchema, FlowZoneSchema, FlowZoneUpdateOptionsSchema, FolderCreateOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, FutureStateSchema, FutureWaitResultSchema, InsightDetailsSchema, InsightSummaryArraySchema, InsightSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, ScenarioWaitResultSchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, WikiArticleDataArraySchema, WikiArticleDataSchema, WikiArticleMetadataSchema, WikiSettingsSchema, WikiTaxonomyNodeSchema, } from "../packages/types/src/index.js";
+export type { BuildMode, CodeEnvActionResult, CodeEnvCreateOptions, CodeEnvDetails, CodeEnvPackageList, CodeEnvSetPackagesOptions, CodeEnvSummary, CodeEnvUpdatePackagesOptions, CodeEnvUsage, CodeEnvWaitOptions, ConnectionSummary, DashboardDetails, DashboardSummary, DataQualityComputeResult, DataQualityProjectStatus, DataQualityRule, DataQualityRuleResult, DataQualityRules, DataQualityStatus, DataQualityStatusByPartition, DataQualityTimeline, DataQualityTimelineEntry, DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary, FlowMapOptions, FlowZone, FlowZoneCreateOptions, FlowZoneItem, FlowZoneObjectType, FlowZoneUpdateOptions, FolderCreateOptions, FolderDetails, FolderItem, FolderSummary, FutureState, FutureWaitResult, InsightDetails, InsightSummary, JobSummary, JobWaitResult, JupyterCell, JupyterNotebookContent, JupyterNotebookSummary, NotebookSession, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectVariables, RecipeCreateOptions, RecipeCreateResult, RecipeDetails, RecipeSummary, SafeParseResult, ScenarioDetails, ScenarioStatus, ScenarioSummary, ScenarioWaitResult, SqlNotebookCell, SqlNotebookContent, SqlNotebookSummary, SqlQueryResponse, SqlQueryResult, SqlQuerySchema, WikiArticleData, WikiArticleMetadata, WikiSettings, WikiTaxonomyNode, } from "../packages/types/src/index.js";

package/dist/src/schemas.js

@@ -3,4 +3,4 @@
  * The types package (packages/types/) owns the TypeBox schema definitions.
  * SDK consumers get everything through this re-export.
  */
-export { BuildModeSchema, CodeEnvDetailsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, ConnectionSummarySchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, ScenarioWaitResultSchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "../packages/types/src/index.js";
+export { BuildModeSchema, CodeEnvActionResultSchema, CodeEnvCreateOptionsSchema, CodeEnvDetailsSchema, CodeEnvPackageListSchema, CodeEnvSetPackagesOptionsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, CodeEnvUpdatePackagesOptionsSchema, CodeEnvUsageArraySchema, CodeEnvWaitOptionsSchema, ConnectionSummarySchema, DashboardDetailsSchema, DashboardSummaryArraySchema, DashboardSummarySchema, DataQualityComputeResultSchema, DataQualityProjectStatusSchema, DataQualityRuleArraySchema, DataQualityRuleResultArraySchema, DataQualityRuleResultSchema, DataQualityRuleSchema, DataQualityRulesSchema, DataQualityStatusByPartitionSchema, DataQualityStatusSchema, DataQualityTimelineEntrySchema, DataQualityTimelineSchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FlowZoneArraySchema, FlowZoneCreateOptionsSchema, FlowZoneItemSchema, FlowZoneObjectTypeSchema, FlowZoneSchema, FlowZoneUpdateOptionsSchema, FolderCreateOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, FutureStateSchema, FutureWaitResultSchema, InsightDetailsSchema, InsightSummaryArraySchema, InsightSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, ScenarioWaitResultSchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, WikiArticleDataArraySchema, WikiArticleDataSchema, WikiArticleMetadataSchema, WikiSettingsSchema, WikiTaxonomyNodeSchema, } from "../packages/types/src/index.js";

package/dist/src/utils/cleanup-ledger.d.ts

@@ -0,0 +1,15 @@
+export type CleanupLedgerAction = "create" | "upload" | "delete" | "update" | "set" | "run" | string;
+export interface CleanupLedgerEntry {
+    ts: string;
+    action: CleanupLedgerAction;
+    resource: string;
+    id?: string;
+    name?: string;
+    path?: string;
+    projectKey?: string;
+    cleanup: {
+        argv: string[];
+    };
+}
+export declare function appendCleanupLedgerEntry(filePath: string, entry: CleanupLedgerEntry): Promise<void>;
+export declare function readCleanupLedger(filePath: string): Promise<CleanupLedgerEntry[]>;

package/dist/src/utils/cleanup-ledger.js

@@ -0,0 +1,15 @@
+import { appendFile, mkdir, readFile, } from "node:fs/promises";
+import { dirname, resolve, } from "node:path";
+export async function appendCleanupLedgerEntry(filePath, entry) {
+    const resolved = resolve(filePath);
+    await mkdir(dirname(resolved), { recursive: true, });
+    await appendFile(resolved, `${JSON.stringify(entry)}\n`, "utf-8");
+}
+export async function readCleanupLedger(filePath) {
+    const content = await readFile(resolve(filePath), "utf-8");
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map((line) => JSON.parse(line));
+}

package/node_modules/@sinclair/typebox/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.48",
+  "version": "0.34.49",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -12,7 +12,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/sinclairzx81/typebox-legacy"
+    "url": "https://github.com/sinclairzx81/sinclair-typebox"
   },
   "scripts": {
     "test": "echo test"

package/node_modules/@sinclair/typebox/readme.md

@@ -1,10 +1,10 @@
 <div align='center'>
 
-<h1>TypeBox 0.34.x</h1>
+<h1>Sinclair TypeBox</h1>
 
 <p>Json Schema Type Builder with Static Type Resolution for TypeScript</p>
 
-<img src="https://raw.githubusercontent.com/sinclairzx81/typebox-legacy/refs/heads/main/typebox.png" />
+<img src="https://raw.githubusercontent.com/sinclairzx81/sinclair-typebox/refs/heads/main/typebox.png" />
 
 <br />
 <br />
@@ -16,14 +16,17 @@
 
 </div>
 
+
 <a name="Install"></a>
 
 ## Install
 
+For the latest version use [TypeBox 1.x](https://github.com/sinclairzx81/typebox) 
+
 ```bash
-$ npm install @sinclair/typebox                     # TypeBox-Legacy | 0.34.x
+$ npm install @sinclair/typebox                     # TypeBox 0.x - Long Term Support
 
-$ npm install typebox                               # TypeBox        | 1.0.x
+$ npm install typebox                               # TypeBox 1.x - Latest
 ```
 
 ## Example
@@ -48,13 +51,10 @@ type T = Static<typeof T>                            // type T = {
                                                      // }
 ```
 
-
 <a name="Overview"></a>
 
 ## Overview
 
-> ⚠️ TypeBox versions (pre-1.0) will continue active maintenance through 2026 and beyond. This repository services as the OIDC publishing environment for the `@sinclair/typebox` package scope on NPM. For TypeBox versions 1.0 and above, refer to https://github.com/sinclairzx81/typebox
-
 TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The schematics produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
 
 This library is designed to allow Json Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "0.4.0",
+	"version": "0.5.1",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [
@@ -27,16 +27,20 @@
 		"lint:fix": "oxlint --fix src/",
 		"format": "dprint fmt",
 		"format:check": "dprint check",
-		"test": "bun test"
+		"test": "bun test",
+		"test:integration": "RUN_DATAIKU_INTEGRATION=1 bun test tests/integration-playground.test.ts",
+		"test:integration:mutating": "RUN_DATAIKU_INTEGRATION=1 RUN_DATAIKU_INTEGRATION_MUTATING=1 bun test tests/integration-playground.test.ts",
+		"test:integration:rigorous": "RUN_DATAIKU_INTEGRATION=1 bun test tests/integration-rigorous.test.ts",
+		"test:integration:rigorous:mutating": "RUN_DATAIKU_INTEGRATION=1 RUN_DATAIKU_INTEGRATION_MUTATING=1 bun test tests/integration-rigorous.test.ts"
 	},
 	"devDependencies": {
-		"@types/bun": "^1.2.14",
-		"dprint": "^0.53.0",
-		"oxlint": "^1.55.0",
-		"typescript": "^5.8.0"
+		"@types/bun": "^1.3.13",
+		"dprint": "^0.53.2",
+		"oxlint": "^1.62.0",
+		"typescript": "^5.9.3"
 	},
 	"dependencies": {
-		"@sinclair/typebox": "^0.34.48"
+		"@sinclair/typebox": "^0.34.49"
 	},
 	"bundledDependencies": [
 		"@sinclair/typebox"