dataiku-sdk 0.11.0 → 0.12.0

package/dist/src/resources/model-evaluation-stores.d.ts

@@ -0,0 +1,41 @@
+import { BaseResource } from "./base.js";
+export interface ModelEvaluationStoreListItem extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    mesFlavor?: string;
+}
+export interface ModelEvaluationStore extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    mesFlavor?: string;
+}
+export interface ModelEvaluationStoreCreateOptions {
+    name: string;
+    projectKey?: string;
+}
+export interface ModelEvaluationStoreCreateResult extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+}
+export interface ModelEvaluationListItem extends Record<string, unknown> {
+    id?: string;
+    evaluationId?: string;
+    createdOn?: number;
+    label?: string;
+}
+export declare class ModelEvaluationStoresResource extends BaseResource {
+    /** List model evaluation stores in a project. */
+    list(projectKey?: string): Promise<ModelEvaluationStoreListItem[]>;
+    /** Get model evaluation store settings and metadata. */
+    get(modelEvaluationStoreId: string, projectKey?: string): Promise<ModelEvaluationStore>;
+    /** Create a tabular model evaluation store. */
+    create(opts: ModelEvaluationStoreCreateOptions): Promise<ModelEvaluationStoreCreateResult>;
+    /** List evaluations in a model evaluation store. */
+    listEvaluations(modelEvaluationStoreId: string, projectKey?: string): Promise<ModelEvaluationListItem[]>;
+    /** Delete a model evaluation store and its evaluations. */
+    delete(modelEvaluationStoreId: string, projectKey?: string): Promise<void>;
+    private storePath;
+}

package/dist/src/resources/model-evaluation-stores.js

@@ -0,0 +1,36 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+export class ModelEvaluationStoresResource extends BaseResource {
+    /** List model evaluation stores in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/evaluationstores/`);
+    }
+    /** Get model evaluation store settings and metadata. */
+    async get(modelEvaluationStoreId, projectKey) {
+        return this.client.get(this.storePath(modelEvaluationStoreId, projectKey));
+    }
+    /** Create a tabular model evaluation store. */
+    async create(opts) {
+        const name = requireNonEmpty(opts.name, "name");
+        const projectKey = this.resolveProjectKey(opts.projectKey);
+        return this.client.post(`/public/api/projects/${encodeURIComponent(projectKey)}/evaluationstores/?flavor=TABULAR`, { projectKey, name, });
+    }
+    /** List evaluations in a model evaluation store. */
+    async listEvaluations(modelEvaluationStoreId, projectKey) {
+        return this.client.get(`${this.storePath(modelEvaluationStoreId, projectKey)}/evaluations/`);
+    }
+    /** Delete a model evaluation store and its evaluations. */
+    async delete(modelEvaluationStoreId, projectKey) {
+        await this.client.del(this.storePath(modelEvaluationStoreId, projectKey));
+    }
+    storePath(modelEvaluationStoreId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(modelEvaluationStoreId, "modelEvaluationStoreId"));
+        return `/public/api/projects/${this.enc(projectKey)}/evaluationstores/${id}`;
+    }
+}

package/dist/src/resources/recipes.js

@@ -22,6 +22,67 @@ function asRecord(value) {
         return undefined;
     return value;
 }
+function parseRecipePayload(payload) {
+    if (!payload)
+        return {};
+    const parsed = JSON.parse(payload);
+    return asRecord(parsed) ?? {};
+}
+function parseJoinKeyPairs(values, optionName = "joinOn") {
+    const pairs = [];
+    for (const raw of values) {
+        const token = raw.trim();
+        if (!token)
+            continue;
+        const eq = token.indexOf("=");
+        if (eq === -1) {
+            pairs.push({ left: token, right: token, });
+            continue;
+        }
+        const left = token.slice(0, eq).trim();
+        const right = token.slice(eq + 1).trim();
+        if (!left || !right)
+            throw new Error(`${optionName} values must use COL or LEFT=RIGHT.`);
+        pairs.push({ left, right, });
+    }
+    return pairs;
+}
+function normalizeFuzzyDistance(value) {
+    const normalized = typeof value === "string" && value.trim().length > 0
+        ? value.trim().toUpperCase()
+        : "DAMERAU_LEVENSHTEIN";
+    if (normalized === "DAMERAU_LEVENSHTEIN")
+        return "LEVENSHTEIN";
+    if (normalized === "HAMMING" || normalized === "JACCARD" || normalized === "COSINE"
+        || normalized === "EUCLIDEAN") {
+        return normalized;
+    }
+    throw new Error("fuzzyDistance must be one of DAMERAU_LEVENSHTEIN, HAMMING, JACCARD, COSINE, or EUCLIDEAN.");
+}
+function normalizeJoinType(value) {
+    const normalized = typeof value === "string" && value.trim().length > 0
+        ? value.trim().toUpperCase()
+        : "LEFT";
+    if (normalized === "LEFT" || normalized === "INNER" || normalized === "RIGHT"
+        || normalized === "FULL") {
+        return normalized;
+    }
+    throw new Error("joinType must be one of LEFT, INNER, RIGHT, or FULL.");
+}
+function recipeVirtualInputs(payload, inputCount) {
+    const current = Array.isArray(payload.virtualInputs) ? payload.virtualInputs : [];
+    const virtualInputs = [];
+    for (let i = 0; i < inputCount; i++) {
+        virtualInputs.push({
+            preFilter: {},
+            outputColumnsSelectionMode: "AUTO_NON_CONFLICTING",
+            computedColumns: [],
+            ...asRecord(current[i]),
+            index: i,
+        });
+    }
+    return virtualInputs;
+}
 const RECIPE_DEFINITION_FIELDS = new Set(["params", "inputs", "outputs", "scriptSettings",]);
 function rootRecipeDefinitionFields(data) {
     return Object.keys(data).filter((key) => RECIPE_DEFINITION_FIELDS.has(key));
@@ -467,17 +528,37 @@ export class RecipesResource extends BaseResource {
         if (!type || !name || !inputs || !outputs) {
             throw new Error("type and (inputDatasets + outputDataset/outputFolder) or (name + inputs + outputs) are required for create.");
         }
+        const joinCols = typeof opts.joinOn === "string" ? [opts.joinOn,] : asStringArray(opts.joinOn);
+        const joinKeys = type === "join" && joinCols?.length
+            ? parseJoinKeyPairs(joinCols)
+            : undefined;
+        const fuzzyOn = opts.fuzzyOn ?? (type === "fuzzyjoin" ? opts.joinOn : undefined);
+        const fuzzyCols = typeof fuzzyOn === "string" ? [fuzzyOn,] : asStringArray(fuzzyOn);
+        const fuzzyKeys = type === "fuzzyjoin" && fuzzyCols?.length
+            ? parseJoinKeyPairs(fuzzyCols, "fuzzyOn")
+            : undefined;
+        const normalizedJoinType = joinKeys?.length || fuzzyKeys?.length
+            ? normalizeJoinType(rawJoinType)
+            : undefined;
+        const fuzzyDistance = fuzzyKeys?.length ? normalizeFuzzyDistance(opts.fuzzyDistance) : undefined;
+        const fuzzyThreshold = opts.fuzzyThreshold ?? 1;
+        if (!Number.isFinite(fuzzyThreshold)) {
+            throw new Error("fuzzyThreshold must be a finite number.");
+        }
         const recipePrototype = {
             type,
             name,
             projectKey: pk,
-            inputs,
+            ...(type === "fuzzyjoin" ? {} : { inputs, }),
             outputs,
         };
         const creationSettings = {};
         if (payload !== undefined) {
             creationSettings.script = payload;
         }
+        if (type === "fuzzyjoin") {
+            creationSettings.virtualInputs = recipeInputItems({ inputs, }).map((item) => item.ref);
+        }
         const createRecipe = () => this.client.post(`/public/api/projects/${enc}/recipes/`, {
             recipePrototype,
             creationSettings,
@@ -597,37 +678,29 @@ export class RecipesResource extends BaseResource {
         }
         // For join recipes: configure join conditions after creation
         let joinConfigured = false;
-        const joinCols = typeof opts.joinOn === "string" ? [opts.joinOn,] : asStringArray(opts.joinOn);
-        const joinType = asString(rawJoinType) ?? "LEFT";
-        if (type === "join" && joinCols?.length) {
+        if (type === "join" && joinKeys?.length) {
             const rnEnc = encodeURIComponent(name);
             const full = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}`);
-            // DSS returns empty payload for fresh join recipes — construct from scratch
-            const inputCount = inputDatasets?.length
-                ?? inputs?.main?.items?.length
-                ?? 2;
-            const virtualInputs = [{ index: 0, preFilter: {}, },];
-            for (let i = 1; i < inputCount; i++) {
-                virtualInputs.push({
-                    index: i,
-                    on: joinCols.map((col) => ({
-                        column: col,
-                        type: "string",
-                        related: col,
-                        relatedType: "string",
-                        maxMatches: 1,
+            const joinPayload = parseRecipePayload(full.payload);
+            const inputCount = recipeInputItems({ inputs, }).length || inputDatasets?.length || 2;
+            const joinType = normalizedJoinType ?? "LEFT";
+            joinPayload.virtualInputs = recipeVirtualInputs(joinPayload, inputCount);
+            joinPayload.joins = Array.from({ length: Math.max(0, inputCount - 1), }, (_, index) => {
+                const table2 = index + 1;
+                return {
+                    table1: 0,
+                    table2,
+                    conditionsMode: "AND",
+                    type: joinType,
+                    outerJoinOnTheLeft: joinType === "LEFT",
+                    on: joinKeys.map((key) => ({
+                        column1: { name: key.left, table: 0, },
+                        column2: { name: key.right, table: table2, },
+                        type: "EQ",
                     })),
-                    joinType,
-                    preFilter: {},
-                });
-            }
-            const joinPayload = {
-                virtualInputs,
-                computedColumns: [],
-                postFilter: {},
-            };
-            // Ensure inputs/outputs are set — DSS may not persist them from the POST for join recipes
-            const updatedFull = {
+                };
+            });
+            await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, {
                 ...full,
                 recipe: {
                     ...full.recipe,
@@ -635,8 +708,52 @@ export class RecipesResource extends BaseResource {
                     outputs,
                 },
                 payload: JSON.stringify(joinPayload),
-            };
-            await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, updatedFull);
+            });
+            joinConfigured = true;
+        }
+        if (type === "fuzzyjoin" && fuzzyKeys?.length) {
+            const rnEnc = encodeURIComponent(name);
+            const full = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}`);
+            const fuzzyPayload = parseRecipePayload(full.payload);
+            const inputCount = recipeInputItems({ inputs, }).length || inputDatasets?.length || 2;
+            const joinType = normalizedJoinType ?? "LEFT";
+            fuzzyPayload.virtualInputs = recipeVirtualInputs(fuzzyPayload, inputCount);
+            fuzzyPayload.joins = Array.from({ length: Math.max(0, inputCount - 1), }, (_, index) => {
+                const table2 = index + 1;
+                return {
+                    table1: 0,
+                    table2,
+                    conditionsMode: "AND",
+                    type: joinType,
+                    on: fuzzyKeys.map((key) => ({
+                        column1: { name: key.left, table: 0, },
+                        column2: { name: key.right, table: table2, },
+                        type: "EQ",
+                        fuzzyMatchDesc: {
+                            distanceType: fuzzyDistance ?? "LEVENSHTEIN",
+                            threshold: fuzzyThreshold,
+                        },
+                        ...(opts.fuzzyNormalize === true
+                            ? {
+                                normaliseDesc: {
+                                    caseInsensitive: true,
+                                    normaliseText: true,
+                                    unicodeCasting: true,
+                                },
+                            }
+                            : {}),
+                    })),
+                };
+            });
+            await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, {
+                ...full,
+                recipe: {
+                    ...full.recipe,
+                    inputs,
+                    outputs,
+                },
+                payload: JSON.stringify(fuzzyPayload),
+            });
             joinConfigured = true;
         }
         let temporaryOutputDatasetDeleted;

package/dist/src/resources/saved-models.d.ts

@@ -0,0 +1,41 @@
+import { BaseResource } from "./base.js";
+export interface SavedModelListItem extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    activeVersion?: string;
+}
+export interface SavedModel extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    activeVersion?: string;
+}
+export interface SavedModelVersionListItem extends Record<string, unknown> {
+    id?: string;
+    active?: boolean;
+    createdOn?: number;
+}
+export interface SavedModelVersionDetails extends Record<string, unknown> {
+    id?: string;
+    algorithm?: string;
+    predictionType?: string;
+}
+export interface SavedModelActionResult extends Record<string, unknown> {
+    message?: string;
+}
+export declare class SavedModelsResource extends BaseResource {
+    /** List saved models in a project. */
+    list(projectKey?: string): Promise<SavedModelListItem[]>;
+    /** Get saved-model settings and metadata. */
+    get(savedModelId: string, projectKey?: string): Promise<SavedModel>;
+    /** List all versions of a saved model. */
+    listVersions(savedModelId: string, projectKey?: string): Promise<SavedModelVersionListItem[]>;
+    /** Get full details for one saved-model version. */
+    versionDetails(savedModelId: string, versionId: string, projectKey?: string): Promise<SavedModelVersionDetails>;
+    /** Make one saved-model version active. */
+    setActiveVersion(savedModelId: string, versionId: string, projectKey?: string): Promise<SavedModelActionResult | undefined>;
+    /** Delete a saved model and all of its versions. */
+    delete(savedModelId: string, projectKey?: string): Promise<void>;
+    private savedModelPath;
+}

package/dist/src/resources/saved-models.js

@@ -0,0 +1,40 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+export class SavedModelsResource extends BaseResource {
+    /** List saved models in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/savedmodels/`);
+    }
+    /** Get saved-model settings and metadata. */
+    async get(savedModelId, projectKey) {
+        return this.client.get(this.savedModelPath(savedModelId, projectKey));
+    }
+    /** List all versions of a saved model. */
+    async listVersions(savedModelId, projectKey) {
+        return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions`);
+    }
+    /** Get full details for one saved-model version. */
+    async versionDetails(savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/details`);
+    }
+    /** Make one saved-model version active. */
+    async setActiveVersion(savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        return this.client.post(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/actions/setActive`, {});
+    }
+    /** Delete a saved model and all of its versions. */
+    async delete(savedModelId, projectKey) {
+        await this.client.del(this.savedModelPath(savedModelId, projectKey));
+    }
+    savedModelPath(savedModelId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(savedModelId, "savedModelId"));
+        return `/public/api/projects/${this.enc(projectKey)}/savedmodels/${id}`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "0.11.0",
+	"version": "0.12.0",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [

package/packages/types/dist/index.d.ts

@@ -147,6 +147,10 @@ export declare const RecipeCreateOptionsSchema: import("@sinclair/typebox").TObj
     outputConnection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     joinOn: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
     joinType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    fuzzyOn: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    fuzzyDistance: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    fuzzyThreshold: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    fuzzyNormalize: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     projectKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     outputFolder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;

package/packages/types/dist/index.js

@@ -195,6 +195,10 @@ export const RecipeCreateOptionsSchema = Type.Object({
     outputConnection: Type.Optional(Type.String()),
     joinOn: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String()),])),
     joinType: Type.Optional(Type.String()),
+    fuzzyOn: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String()),])),
+    fuzzyDistance: Type.Optional(Type.String()),
+    fuzzyThreshold: Type.Optional(Type.Number()),
+    fuzzyNormalize: Type.Optional(Type.Boolean()),
     projectKey: Type.Optional(Type.String()),
     outputFolder: Type.Optional(Type.String()),
 });