dataiku-sdk 0.1.0

package/dist/src/utils/flow-map.js

@@ -0,0 +1,296 @@
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asStringArray(value, warnings, context) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value)) {
+        warnings.push(`Skipped non-array "${context}" field.`);
+        return [];
+    }
+    const out = [];
+    for (const item of value) {
+        if (typeof item === "string" && item.length > 0)
+            out.push(item);
+        else
+            warnings.push(`Skipped non-string item in "${context}".`);
+    }
+    return out;
+}
+function inferKind(type) {
+    if (!type)
+        return "other";
+    const upper = type.toUpperCase();
+    if (upper.includes("RECIPE"))
+        return "recipe";
+    if (upper.includes("DATASET"))
+        return "dataset";
+    if (upper.includes("FOLDER"))
+        return "folder";
+    return "other";
+}
+function inferSubtypeFromType(type) {
+    if (!type)
+        return undefined;
+    const upper = type.toUpperCase();
+    if (upper.includes("IMPLICIT_RECIPE"))
+        return "implicit";
+    return undefined;
+}
+function relationRank(relation) {
+    switch (relation) {
+        case "reads":
+        case "writes":
+            return 3;
+        case "depends_on":
+            return 2;
+        default:
+            return 1;
+    }
+}
+function inferRelation(fromKind, toKind) {
+    if ((fromKind === "dataset" || fromKind === "folder") && toKind === "recipe") {
+        return "reads";
+    }
+    if (fromKind === "recipe" && (toKind === "dataset" || toKind === "folder")) {
+        return "writes";
+    }
+    if (fromKind === "other" || toKind === "other")
+        return "unknown";
+    return "depends_on";
+}
+function preferredKind(current, incoming) {
+    if (current === incoming)
+        return current;
+    if (current === "other")
+        return incoming;
+    return current;
+}
+function getConnection(record) {
+    const direct = asString(record.connection);
+    if (direct)
+        return direct;
+    const params = asRecord(record.params);
+    return asString(params?.connection);
+}
+function mergeUnique(...lists) {
+    const out = new Set();
+    for (const list of lists) {
+        if (!list)
+            continue;
+        for (const item of list) {
+            if (item)
+                out.add(item);
+        }
+    }
+    return [...out,];
+}
+export function normalizeFlowGraph(raw, projectKey, options = {}) {
+    const warnings = [];
+    const root = asRecord(raw);
+    if (!root) {
+        return {
+            projectKey,
+            nodes: [],
+            edges: [],
+            stats: {
+                nodeCount: 0,
+                edgeCount: 0,
+                datasets: 0,
+                recipes: 0,
+                roots: 0,
+                leaves: 0,
+            },
+            roots: [],
+            leaves: [],
+            warnings: ["Flow graph response was not an object.",],
+        };
+    }
+    const nodeMap = new Map();
+    const aliasMap = new Map();
+    function upsertNode(node) {
+        const existing = nodeMap.get(node.id);
+        if (!existing) {
+            nodeMap.set(node.id, {
+                ...node,
+                predecessors: [],
+                successors: [],
+            });
+            return;
+        }
+        existing.kind = preferredKind(existing.kind, node.kind);
+        if (!existing.name && node.name)
+            existing.name = node.name;
+        if (!existing.subtype && node.subtype)
+            existing.subtype = node.subtype;
+        if (!existing.connection && node.connection)
+            existing.connection = node.connection;
+    }
+    function ensureNode(id) {
+        const existing = nodeMap.get(id);
+        if (existing)
+            return existing;
+        const placeholder = {
+            id,
+            kind: "other",
+            name: id,
+            predecessors: [],
+            successors: [],
+        };
+        nodeMap.set(id, placeholder);
+        warnings.push(`Added placeholder node for "${id}" referenced by an edge.`);
+        return placeholder;
+    }
+    function addAlias(alias, id) {
+        if (!alias)
+            return;
+        aliasMap.set(alias, id);
+    }
+    const rawNodes = root.nodes;
+    if (rawNodes !== undefined && !asRecord(rawNodes)) {
+        warnings.push('Skipped "nodes" because it was not an object.');
+    }
+    for (const [nodeKey, nodeValue,] of Object.entries(asRecord(rawNodes) ?? {})) {
+        const nodeObj = asRecord(nodeValue);
+        if (!nodeObj) {
+            warnings.push(`Skipped node "${nodeKey}" because it was not an object.`);
+            continue;
+        }
+        const ref = asString(nodeObj.ref);
+        const id = ref ?? nodeKey;
+        const kind = inferKind(asString(nodeObj.type));
+        const subtype = asString(nodeObj.subType)
+            ?? asString(nodeObj.subtype)
+            ?? inferSubtypeFromType(asString(nodeObj.type));
+        const fallbackName = asString(nodeObj.name) ?? asString(nodeObj.label) ?? ref ?? nodeKey;
+        const folderName = kind === "folder" ? asString(options.folderNamesById?.[id]) : undefined;
+        const name = folderName ?? fallbackName;
+        const connection = getConnection(nodeObj);
+        upsertNode({
+            id,
+            kind,
+            name,
+            subtype,
+            connection,
+        });
+        addAlias(nodeKey, id);
+        addAlias(ref, id);
+        addAlias(asString(nodeObj.id), id);
+        const node = ensureNode(id);
+        node.predecessors = asStringArray(nodeObj.predecessors, warnings, `nodes.${nodeKey}.predecessors`);
+        node.successors = asStringArray(nodeObj.successors, warnings, `nodes.${nodeKey}.successors`);
+    }
+    const datasets = mergeUnique(asStringArray(root.datasets, warnings, "datasets"), options.allDatasetNames);
+    for (const dataset of datasets) {
+        upsertNode({ id: dataset, kind: "dataset", name: dataset, });
+        addAlias(dataset, dataset);
+    }
+    const recipes = mergeUnique(asStringArray(root.recipes, warnings, "recipes"), options.allRecipeNames);
+    for (const recipe of recipes) {
+        upsertNode({ id: recipe, kind: "recipe", name: recipe, });
+        addAlias(recipe, recipe);
+    }
+    const folders = mergeUnique(asStringArray(root.folders, warnings, "folders"), options.allFolderIds);
+    for (const folder of folders) {
+        upsertNode({
+            id: folder,
+            kind: "folder",
+            name: asString(options.folderNamesById?.[folder]) ?? folder,
+        });
+        addAlias(folder, folder);
+    }
+    // Best-effort rename of folder nodes using managed folder metadata lookup.
+    for (const [id, node,] of nodeMap.entries()) {
+        if (node.kind !== "folder")
+            continue;
+        const friendlyName = asString(options.folderNamesById?.[id]);
+        if (!friendlyName)
+            continue;
+        if (!node.name || node.name === id)
+            node.name = friendlyName;
+    }
+    function resolveAlias(ref) {
+        return aliasMap.get(ref) ?? ref;
+    }
+    const edgeMap = new Map();
+    function addEdge(fromRef, toRef) {
+        const from = resolveAlias(fromRef);
+        const to = resolveAlias(toRef);
+        const fromNode = ensureNode(from);
+        const toNode = ensureNode(to);
+        const relation = inferRelation(fromNode.kind, toNode.kind);
+        const key = `${from}::${to}`;
+        const existing = edgeMap.get(key);
+        if (!existing || relationRank(relation) > relationRank(existing.relation)) {
+            edgeMap.set(key, { from, to, relation, });
+        }
+    }
+    for (const node of nodeMap.values()) {
+        for (const predecessor of node.predecessors) {
+            addEdge(predecessor, node.id);
+        }
+        for (const successor of node.successors) {
+            addEdge(node.id, successor);
+        }
+    }
+    const nodes = [...nodeMap.values(),]
+        .map((node) => ({
+        id: node.id,
+        kind: node.kind,
+        name: node.name,
+        subtype: node.subtype,
+        connection: node.connection,
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const edges = [...edgeMap.values(),].sort((a, b) => {
+        const byFrom = a.from.localeCompare(b.from);
+        if (byFrom !== 0)
+            return byFrom;
+        const byTo = a.to.localeCompare(b.to);
+        if (byTo !== 0)
+            return byTo;
+        return a.relation.localeCompare(b.relation);
+    });
+    const inDegree = new Map();
+    const outDegree = new Map();
+    for (const node of nodes) {
+        inDegree.set(node.id, 0);
+        outDegree.set(node.id, 0);
+    }
+    for (const edge of edges) {
+        inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+        outDegree.set(edge.from, (outDegree.get(edge.from) ?? 0) + 1);
+    }
+    const roots = nodes
+        .filter((node) => (inDegree.get(node.id) ?? 0) === 0)
+        .map((node) => node.id)
+        .sort((a, b) => a.localeCompare(b));
+    const leaves = nodes
+        .filter((node) => (outDegree.get(node.id) ?? 0) === 0)
+        .map((node) => node.id)
+        .sort((a, b) => a.localeCompare(b));
+    const datasetsCount = nodes.filter((node) => node.kind === "dataset").length;
+    const recipesCount = nodes.filter((node) => node.kind === "recipe").length;
+    return {
+        projectKey,
+        nodes,
+        edges,
+        stats: {
+            nodeCount: nodes.length,
+            edgeCount: edges.length,
+            datasets: datasetsCount,
+            recipes: recipesCount,
+            roots: roots.length,
+            leaves: leaves.length,
+        },
+        roots,
+        leaves,
+        warnings,
+    };
+}

package/dist/src/utils/pagination.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizeQuery(query: string | undefined): string | undefined;
+export declare function filterByQuery<T>(items: T[], query: string | undefined, pickValues: (item: T) => Array<string | undefined>): T[];
+export declare function paginateItems<T>(items: T[], limit: number | undefined, offset: number | undefined, defaultLimit?: number): {
+    items: T[];
+    offset: number;
+    limit: number;
+    hasMore: boolean;
+};

package/dist/src/utils/pagination.js

@@ -0,0 +1,23 @@
+export function normalizeQuery(query) {
+    const normalized = query?.trim().toLowerCase();
+    return normalized && normalized.length > 0 ? normalized : undefined;
+}
+export function filterByQuery(items, query, pickValues) {
+    const normalized = normalizeQuery(query);
+    if (!normalized)
+        return items;
+    return items.filter((item) => pickValues(item).some((value) => (value ?? "").toLowerCase().includes(normalized)));
+}
+const DEFAULT_PAGE_LIMIT = 100;
+export function paginateItems(items, limit, offset, defaultLimit = DEFAULT_PAGE_LIMIT) {
+    const pageOffset = Math.max(0, offset ?? 0);
+    const effectiveLimit = Math.max(1, limit ?? defaultLimit);
+    const pagedItems = items.slice(pageOffset, pageOffset + effectiveLimit);
+    const hasMore = pageOffset + pagedItems.length < items.length;
+    return {
+        items: pagedItems,
+        offset: pageOffset,
+        limit: effectiveLimit,
+        hasMore,
+    };
+}

package/dist/src/utils/sanitize.d.ts

@@ -0,0 +1,2 @@
+/** Sanitize a string for use as a local filename. */
+export declare function sanitizeFileName(name: string, fallback: string): string;

package/dist/src/utils/sanitize.js

@@ -0,0 +1,16 @@
+const WINDOWS_RESERVED_FILE_NAMES = /^(con|prn|aux|nul|com[1-9¹²³]|lpt[1-9¹²³])$/i;
+/** Sanitize a string for use as a local filename. */
+export function sanitizeFileName(name, fallback) {
+    const sanitized = name
+        .replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_")
+        .replace(/[. ]+$/g, "")
+        .trim();
+    if (!sanitized)
+        return fallback;
+    const dotIndex = sanitized.indexOf(".");
+    const baseName = dotIndex === -1 ? sanitized : sanitized.slice(0, dotIndex);
+    const extension = dotIndex === -1 ? "" : sanitized.slice(dotIndex);
+    if (WINDOWS_RESERVED_FILE_NAMES.test(baseName))
+        return `${baseName}_${extension}`;
+    return sanitized;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "dataiku-sdk",
+	"version": "0.1.0",
+	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
+	"type": "module",
+	"workspaces": ["packages/*"],
+	"main": "dist/src/index.js",
+	"types": "dist/src/index.d.ts",
+	"bin": {
+		"dss": "bin/dss.js"
+	},
+	"files": [
+		"dist/",
+		"bin/dss.js",
+		"packages/types/dist/"
+	],
+	"engines": {
+		"bun": ">=1.0"
+	},
+	"scripts": {
+		"build": "tsc && cd packages/types && npx tsc",
+		"prepublishOnly": "bun run build",
+		"check": "tsc --noEmit",
+		"lint": "oxlint src/",
+		"lint:fix": "oxlint --fix src/",
+		"format": "dprint fmt",
+		"format:check": "dprint check",
+		"test": "bun test"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.2.14",
+		"dprint": "^0.53.0",
+		"oxlint": "^1.55.0",
+		"typescript": "^5.8.0"
+	},
+	"dependencies": {
+		"@sinclair/typebox": "^0.34.48"
+	},
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/clssck/dataiku-sdk.git"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}