dataiku-sdk 0.1.0

package/dist/src/client.d.ts

@@ -0,0 +1,89 @@
+import { type Static, type TSchema } from "@sinclair/typebox";
+import { CodeEnvsResource } from "./resources/code-envs.js";
+import { ConnectionsResource } from "./resources/connections.js";
+import { DatasetsResource } from "./resources/datasets.js";
+import { FoldersResource } from "./resources/folders.js";
+import { JobsResource } from "./resources/jobs.js";
+import { NotebooksResource } from "./resources/notebooks.js";
+import { ProjectsResource } from "./resources/projects.js";
+import { RecipesResource } from "./resources/recipes.js";
+import { ScenariosResource } from "./resources/scenarios.js";
+import { SqlResource } from "./resources/sql.js";
+import { VariablesResource } from "./resources/variables.js";
+export interface DataikuClientConfig {
+    /** DSS base URL (e.g. https://dss.example.com) */
+    url: string;
+    /** API key for authentication */
+    apiKey: string;
+    /** Default project key — used when a resource method omits projectKey */
+    projectKey?: string;
+    /** Per-request timeout in milliseconds (default 30 000) */
+    requestTimeoutMs?: number;
+    /** Max retry attempts for idempotent requests (default 4, capped at 10) */
+    retryMaxAttempts?: number;
+    /**
+     * Called when an API response fails schema validation but data is still usable.
+     * Default: logs to console.warn. Set to a throwing function for strict mode.
+     * @param method - resource method that triggered the warning (e.g. "datasets.list")
+     * @param errors - human-readable validation error strings
+     */
+    onValidationWarning?: (method: string, errors: string[]) => void;
+}
+export declare class DataikuClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly defaultProjectKey;
+    private readonly requestTimeoutMs;
+    private readonly retryMaxAttempts;
+    private readonly onValidationWarning;
+    private _projects?;
+    private _datasets?;
+    private _recipes?;
+    private _jobs?;
+    private _scenarios?;
+    private _folders?;
+    private _variables?;
+    private _connections?;
+    private _codeEnvs?;
+    private _sql?;
+    private _notebooks?;
+    get projects(): ProjectsResource;
+    get datasets(): DatasetsResource;
+    get recipes(): RecipesResource;
+    get jobs(): JobsResource;
+    get scenarios(): ScenariosResource;
+    get folders(): FoldersResource;
+    get variables(): VariablesResource;
+    get connections(): ConnectionsResource;
+    get codeEnvs(): CodeEnvsResource;
+    get sql(): SqlResource;
+    get notebooks(): NotebooksResource;
+    constructor(config: DataikuClientConfig);
+    resolveProjectKey(paramValue?: string): string;
+    get<T = unknown>(path: string): Promise<T>;
+    getText(path: string): Promise<string>;
+    post<T = unknown>(path: string, body?: unknown): Promise<T>;
+    put<T = unknown>(path: string, body: unknown): Promise<T>;
+    del(path: string): Promise<void>;
+    putVoid(path: string, body: unknown): Promise<void>;
+    upload(path: string, filePath: string): Promise<void>;
+    stream(path: string): Promise<Response>;
+    private getHeaders;
+    private getAnyHeaders;
+    /**
+     * Validate raw data against a TypeBox schema, throwing on structural mismatch.
+     * Resources call this instead of bare `as T` casts for validated responses.
+     * Extra DSS fields (additionalProperties) are preserved in the returned data.
+     */
+    parse<S extends TSchema>(schema: S, data: unknown): Static<S>;
+    /**
+     * Validate raw data against a TypeBox schema without throwing.
+     * Always returns the data. On mismatch, fires onValidationWarning callback
+     * with the method name and error details.
+     */
+    safeParse<S extends TSchema>(schema: S, data: unknown, method: string): Static<S>;
+    /** Emit a validation warning via the configured callback. */
+    warn(method: string, errors: string[]): void;
+    private parseJsonResponse;
+    private fetchWithRetry;
+}

package/dist/src/client.js

@@ -0,0 +1,301 @@
+import { Value, } from "@sinclair/typebox/value";
+import { safeParseSchema, } from "./schemas.js";
+import { classifyDataikuError, DataikuError, } from "./errors.js";
+import { CodeEnvsResource, } from "./resources/code-envs.js";
+import { ConnectionsResource, } from "./resources/connections.js";
+import { DatasetsResource, } from "./resources/datasets.js";
+import { FoldersResource, } from "./resources/folders.js";
+import { JobsResource, } from "./resources/jobs.js";
+import { NotebooksResource, } from "./resources/notebooks.js";
+import { ProjectsResource, } from "./resources/projects.js";
+import { RecipesResource, } from "./resources/recipes.js";
+import { ScenariosResource, } from "./resources/scenarios.js";
+import { SqlResource, } from "./resources/sql.js";
+import { VariablesResource, } from "./resources/variables.js";
+/* ------------------------------------------------------------------ */
+/*  Constants                                                          */
+/* ------------------------------------------------------------------ */
+const DEFAULT_RETRY_MAX_ATTEMPTS = 4;
+const MAX_RETRY_ATTEMPTS_CAP = 10;
+const BASE_DELAY_MS = 2_000;
+const MAX_BACKOFF_DELAY_MS = 30_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+function defaultValidationWarning(method, errors) {
+    console.warn(`[dataiku-sdk] Schema validation warning in ${method}:\n  ${errors.join("\n  ")}`);
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function computeBackoffDelayMs(retryNumber) {
+    const cap = Math.min(MAX_BACKOFF_DELAY_MS, BASE_DELAY_MS * 2 ** Math.max(0, retryNumber - 1));
+    return Math.floor(Math.random() * (cap + 1));
+}
+function isTransientError(status, body) {
+    return classifyDataikuError(status, body).category === "transient";
+}
+function shouldRetryMethod(method) {
+    return method.toUpperCase() === "GET";
+}
+function buildRetryMetadata(method, enabled, maxAttempts, attempts, delaysMs, timedOut) {
+    return {
+        method,
+        enabled,
+        maxAttempts,
+        attempts,
+        retries: Math.max(0, attempts - 1),
+        delaysMs,
+        timedOut,
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Client                                                             */
+/* ------------------------------------------------------------------ */
+export class DataikuClient {
+    baseUrl;
+    apiKey;
+    defaultProjectKey;
+    requestTimeoutMs;
+    retryMaxAttempts;
+    onValidationWarning;
+    /* Resource namespaces — lazily initialized to break circular imports */
+    _projects;
+    _datasets;
+    _recipes;
+    _jobs;
+    _scenarios;
+    _folders;
+    _variables;
+    _connections;
+    _codeEnvs;
+    _sql;
+    _notebooks;
+    get projects() {
+        return (this._projects ??= new ProjectsResource(this));
+    }
+    get datasets() {
+        return (this._datasets ??= new DatasetsResource(this));
+    }
+    get recipes() {
+        return (this._recipes ??= new RecipesResource(this));
+    }
+    get jobs() {
+        return (this._jobs ??= new JobsResource(this));
+    }
+    get scenarios() {
+        return (this._scenarios ??= new ScenariosResource(this));
+    }
+    get folders() {
+        return (this._folders ??= new FoldersResource(this));
+    }
+    get variables() {
+        return (this._variables ??= new VariablesResource(this));
+    }
+    get connections() {
+        return (this._connections ??= new ConnectionsResource(this));
+    }
+    get codeEnvs() {
+        return (this._codeEnvs ??= new CodeEnvsResource(this));
+    }
+    get sql() {
+        return (this._sql ??= new SqlResource(this));
+    }
+    get notebooks() {
+        return (this._notebooks ??= new NotebooksResource(this));
+    }
+    constructor(config) {
+        const url = config.url?.trim();
+        if (!url)
+            throw new Error("DataikuClientConfig.url is required and must not be empty");
+        const apiKey = config.apiKey?.trim();
+        if (!apiKey)
+            throw new Error("DataikuClientConfig.apiKey is required and must not be empty");
+        this.baseUrl = url.replace(/\/+$/, "");
+        this.apiKey = apiKey;
+        this.defaultProjectKey = config.projectKey?.trim() || undefined;
+        this.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        const rawMax = config.retryMaxAttempts ?? DEFAULT_RETRY_MAX_ATTEMPTS;
+        this.retryMaxAttempts = Math.min(Math.max(1, rawMax), MAX_RETRY_ATTEMPTS_CAP);
+        this.onValidationWarning = config.onValidationWarning ?? defaultValidationWarning;
+    }
+    /* ---- public: project key resolution ---- */
+    resolveProjectKey(paramValue) {
+        const pk = paramValue?.trim();
+        if (pk)
+            return pk;
+        if (this.defaultProjectKey)
+            return this.defaultProjectKey;
+        throw new Error("projectKey is required — pass it as a parameter or set projectKey in DataikuClientConfig");
+    }
+    /* ---- public: HTTP verbs ---- */
+    async get(path) {
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "GET",
+            headers: this.getHeaders(),
+        });
+        return this.parseJsonResponse(res);
+    }
+    async getText(path) {
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "GET",
+            headers: this.getAnyHeaders(),
+        });
+        return res.text();
+    }
+    async post(path, body) {
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: this.getHeaders(),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        return this.parseJsonResponse(res);
+    }
+    async put(path, body) {
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "PUT",
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+        return this.parseJsonResponse(res);
+    }
+    async del(path) {
+        await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "DELETE",
+            headers: this.getHeaders(),
+        });
+    }
+    async putVoid(path, body) {
+        await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "PUT",
+            headers: this.getHeaders(),
+            body: JSON.stringify(body),
+        });
+    }
+    async upload(path, filePath) {
+        const { openAsBlob, } = await import("node:fs");
+        const { basename, } = await import("node:path");
+        const fileBlob = await openAsBlob(filePath);
+        const fileName = basename(filePath);
+        const formData = new FormData();
+        formData.append("file", fileBlob, fileName);
+        await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${this.apiKey}`, },
+            body: formData,
+        });
+    }
+    async stream(path) {
+        return this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "GET",
+            headers: this.getAnyHeaders(),
+        });
+    }
+    /* ---- private: headers ---- */
+    getHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+    }
+    getAnyHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: "*/*",
+        };
+    }
+    /* ---- public: schema-validated parsing ---- */
+    /**
+     * Validate raw data against a TypeBox schema, throwing on structural mismatch.
+     * Resources call this instead of bare `as T` casts for validated responses.
+     * Extra DSS fields (additionalProperties) are preserved in the returned data.
+     */
+    parse(schema, data) {
+        Value.Assert(schema, data);
+        return data;
+    }
+    /**
+     * Validate raw data against a TypeBox schema without throwing.
+     * Always returns the data. On mismatch, fires onValidationWarning callback
+     * with the method name and error details.
+     */
+    safeParse(schema, data, method) {
+        const result = safeParseSchema(schema, data);
+        if (!result.success) {
+            this.onValidationWarning(method, result.errors);
+        }
+        return result.data;
+    }
+    /** Emit a validation warning via the configured callback. */
+    warn(method, errors) {
+        this.onValidationWarning(method, errors);
+    }
+    /* ---- private: JSON parsing ---- */
+    async parseJsonResponse(res) {
+        const text = await res.text();
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const summary = text.length > 300 ? `${text.slice(0, 300)}…` : text;
+            throw new DataikuError(res.status, res.statusText || "Invalid JSON response", `Expected JSON response body but got non-JSON content: ${summary}`);
+        }
+    }
+    /* ---- private: retry loop ---- */
+    async fetchWithRetry(url, init) {
+        const method = (init.method ?? "GET").toUpperCase();
+        const retryEnabled = shouldRetryMethod(method);
+        const maxAttempts = retryEnabled ? this.retryMaxAttempts : 1;
+        const delaysMs = [];
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            let timedOut = false;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+            }, this.requestTimeoutMs);
+            try {
+                const res = await fetch(url, { ...init, method, signal: controller.signal, });
+                if (!res.ok) {
+                    const text = await res.text();
+                    const canRetry = retryEnabled && attempt < maxAttempts && isTransientError(res.status, text);
+                    if (canRetry) {
+                        const delayMs = computeBackoffDelayMs(attempt);
+                        delaysMs.push(delayMs);
+                        await sleep(delayMs);
+                        continue;
+                    }
+                    throw new DataikuError(res.status, res.statusText, text, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, false));
+                }
+                return res;
+            }
+            catch (error) {
+                if (error instanceof DataikuError)
+                    throw error;
+                const canRetry = retryEnabled && attempt < maxAttempts;
+                if (canRetry) {
+                    const delayMs = computeBackoffDelayMs(attempt);
+                    delaysMs.push(delayMs);
+                    await sleep(delayMs);
+                    continue;
+                }
+                const detail = timedOut
+                    ? `Request timed out after ${this.requestTimeoutMs}ms`
+                    : error instanceof Error
+                        ? error.message
+                        : "Unknown transport error";
+                const statusText = timedOut ? "Request Timeout" : "Network Error";
+                throw new DataikuError(0, statusText, detail, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, timedOut));
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        // Unreachable in practice — the loop always throws or returns.
+        throw new DataikuError(0, "Network Error", "Request failed before receiving a response.", buildRetryMetadata(method, false, 1, 1, [], false));
+    }
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,29 @@
+export type DataikuErrorCategory = "not_found" | "forbidden" | "validation" | "transient" | "unknown";
+export interface DataikuErrorTaxonomy {
+    category: DataikuErrorCategory;
+    retryable: boolean;
+    retryHint: string;
+}
+export interface DataikuRetryMetadata {
+    method: string;
+    enabled: boolean;
+    maxAttempts: number;
+    attempts: number;
+    retries: number;
+    delaysMs: number[];
+    timedOut: boolean;
+}
+export declare function classifyDataikuError(status: number, body: string): DataikuErrorTaxonomy;
+export declare class DataikuError extends Error {
+    status: number;
+    statusText: string;
+    body: string;
+    category: DataikuErrorCategory;
+    retryable: boolean;
+    retryHint: string;
+    retry?: DataikuRetryMetadata;
+    constructor(status: number, statusText: string, body: string, retry?: DataikuRetryMetadata);
+    private static extractSummary;
+    private static formatRetryMetadata;
+    private static buildDetails;
+}

package/dist/src/errors.js

@@ -0,0 +1,141 @@
+export function classifyDataikuError(status, body) {
+    if (status === 0) {
+        return {
+            category: "transient",
+            retryable: true,
+            retryHint: "Network/transport failure. Retry with backoff and verify DSS URL reachability.",
+        };
+    }
+    const lowerBody = body.toLowerCase();
+    const isMissingDatasetRootPath = status === 500
+        && lowerBody.includes("root path of the dataset")
+        && lowerBody.includes("does not exist");
+    if (isMissingDatasetRootPath) {
+        return {
+            category: "validation",
+            retryable: false,
+            retryHint: "Dataset files are missing on storage. Build/materialize the dataset or upstream recipes before preview/download.",
+        };
+    }
+    const isServerNotFoundLike = status >= 500
+        && (lowerBody.includes("not found") || lowerBody.includes("does not exist"))
+        && ["dataset", "recipe", "scenario", "project", "folder",].some((token) => lowerBody.includes(token));
+    if (isServerNotFoundLike) {
+        return {
+            category: "not_found",
+            retryable: false,
+            retryHint: "Requested object was not found. Verify projectKey and object identifiers before retrying.",
+        };
+    }
+    const isServerValidationLike = status >= 500
+        && (lowerBody.includes("invalid")
+            || lowerBody.includes("validation")
+            || lowerBody.includes("bad request")
+            || lowerBody.includes("illegal argument"));
+    if (isServerValidationLike) {
+        return {
+            category: "validation",
+            retryable: false,
+            retryHint: "Request appears invalid for this endpoint. Fix parameters/payload before retrying.",
+        };
+    }
+    if (status === 404) {
+        const isHtmlGatewayResponse = lowerBody.includes("<!doctype html>");
+        return {
+            category: "not_found",
+            retryable: false,
+            retryHint: isHtmlGatewayResponse
+                ? "Resource was not found (gateway returned HTML). Verify DSS URL, projectKey, and object identifiers."
+                : "Verify projectKey and object identifiers (dataset/recipe/scenario/folder IDs).",
+        };
+    }
+    if (status === 401 || status === 403) {
+        return {
+            category: "forbidden",
+            retryable: false,
+            retryHint: "Check API key validity and project permissions for the requested action.",
+        };
+    }
+    if (status === 400 || status === 409 || status === 422) {
+        return {
+            category: "validation",
+            retryable: false,
+            retryHint: "Fix request parameters/payload and try again (same request will likely fail).",
+        };
+    }
+    if (status === 408 || status === 425 || status === 429 || (status >= 500 && status <= 599)) {
+        return {
+            category: "transient",
+            retryable: true,
+            retryHint: "Retry with exponential backoff. If it persists, check DSS availability and upstream proxies.",
+        };
+    }
+    return {
+        category: "unknown",
+        retryable: false,
+        retryHint: "Inspect the response details and DSS logs to determine whether retry is appropriate.",
+    };
+}
+export class DataikuError extends Error {
+    status;
+    statusText;
+    body;
+    category;
+    retryable;
+    retryHint;
+    retry;
+    constructor(status, statusText, body, retry) {
+        const details = DataikuError.buildDetails(status, statusText, body, retry);
+        super(details.message);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = "DataikuError";
+        this.category = details.category;
+        this.retryable = details.retryable;
+        this.retryHint = details.retryHint;
+        this.retry = retry;
+    }
+    static extractSummary(_status, _statusText, body) {
+        try {
+            const parsed = JSON.parse(body);
+            if (parsed.message)
+                return String(parsed.message);
+        }
+        catch {
+            // not JSON — use raw body
+        }
+        if (!body)
+            return "(empty response body)";
+        return body.length > 200 ? `${body.slice(0, 200)}…` : body;
+    }
+    static formatRetryMetadata(retry) {
+        if (!retry)
+            return undefined;
+        const shownDelays = retry.delaysMs.slice(0, 10);
+        const delaysSuffix = retry.delaysMs.length > shownDelays.length ? ", …" : "";
+        const delaysPart = shownDelays.length > 0 ? `[${shownDelays.join(", ")}${delaysSuffix}]` : "[]";
+        return [
+            `Retry attempts: ${retry.attempts}/${retry.maxAttempts}`,
+            `Retry policy: ${retry.enabled ? "enabled" : "disabled"} for ${retry.method}`,
+            `Retries performed: ${retry.retries}`,
+            `Backoff delays (ms): ${delaysPart}`,
+            `Timed out: ${retry.timedOut ? "yes" : "no"}`,
+        ].join(" | ");
+    }
+    static buildDetails(status, statusText, body, retry) {
+        const summary = DataikuError.extractSummary(status, statusText, body);
+        const taxonomy = classifyDataikuError(status, body);
+        const retrySummary = DataikuError.formatRetryMetadata(retry);
+        return {
+            ...taxonomy,
+            message: [
+                `${status} ${statusText}: ${summary}`,
+                `Error type: ${taxonomy.category}`,
+                `Retryable: ${taxonomy.retryable ? "yes" : "no"}`,
+                `Hint: ${taxonomy.retryHint}`,
+                ...(retrySummary ? [retrySummary,] : []),
+            ].join("\n"),
+        };
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+export { DataikuClient, type DataikuClientConfig, } from "./client.js";
+export { DataikuError, type DataikuErrorCategory, type DataikuErrorTaxonomy, type DataikuRetryMetadata, } from "./errors.js";
+export { CodeEnvsResource, } from "./resources/code-envs.js";
+export { ConnectionsResource, } from "./resources/connections.js";
+export { DatasetsResource, } from "./resources/datasets.js";
+export { FoldersResource, } from "./resources/folders.js";
+export { computeNextPollDelayMs, JobsResource, } from "./resources/jobs.js";
+export { NotebooksResource, } from "./resources/notebooks.js";
+export { type FlowMapResult, ProjectsResource, } from "./resources/projects.js";
+export { RecipesResource, } from "./resources/recipes.js";
+export { ScenariosResource, } from "./resources/scenarios.js";
+export { SqlResource, } from "./resources/sql.js";
+export { VariablesResource, } from "./resources/variables.js";
+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, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "./schemas.js";
+export type { SafeParseResult, } from "./schemas.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, ScenarioDetails, ScenarioStatus, ScenarioSummary, SqlNotebookCell, SqlNotebookContent, SqlNotebookSummary, SqlQueryResponse, SqlQueryResult, SqlQuerySchema, } from "./schemas.js";
+export { deepMerge, } from "./utils/deep-merge.js";
+export { type NormalizedFlowEdge, type NormalizedFlowMap, type NormalizedFlowNode, normalizeFlowGraph, } from "./utils/flow-map.js";
+export { sanitizeFileName, } from "./utils/sanitize.js";
+export { validateStreamColumns, } from "./resources/datasets.js";

package/dist/src/index.js

@@ -0,0 +1,24 @@
+// Client
+export { DataikuClient, } from "./client.js";
+// Errors
+export { DataikuError, } from "./errors.js";
+// Resources (for advanced use / extension)
+export { CodeEnvsResource, } from "./resources/code-envs.js";
+export { ConnectionsResource, } from "./resources/connections.js";
+export { DatasetsResource, } from "./resources/datasets.js";
+export { FoldersResource, } from "./resources/folders.js";
+export { computeNextPollDelayMs, JobsResource, } from "./resources/jobs.js";
+export { NotebooksResource, } from "./resources/notebooks.js";
+export { ProjectsResource, } from "./resources/projects.js";
+export { RecipesResource, } from "./resources/recipes.js";
+export { ScenariosResource, } from "./resources/scenarios.js";
+export { SqlResource, } from "./resources/sql.js";
+export { VariablesResource, } from "./resources/variables.js";
+// Schemas (TypeBox schema objects for runtime validation)
+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, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "./schemas.js";
+// Utilities
+export { deepMerge, } from "./utils/deep-merge.js";
+export { normalizeFlowGraph, } from "./utils/flow-map.js";
+export { sanitizeFileName, } from "./utils/sanitize.js";
+// Stream validation
+export { validateStreamColumns, } from "./resources/datasets.js";

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

@@ -0,0 +1,7 @@
+import type { DataikuClient } from "../client.js";
+export declare abstract class BaseResource {
+    protected readonly client: DataikuClient;
+    constructor(client: DataikuClient);
+    protected resolveProjectKey(pk?: string): string;
+    protected enc(pk?: string): string;
+}

package/dist/src/resources/base.js

@@ -0,0 +1,12 @@
+export class BaseResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    resolveProjectKey(pk) {
+        return this.client.resolveProjectKey(pk);
+    }
+    enc(pk) {
+        return encodeURIComponent(this.resolveProjectKey(pk));
+    }
+}

package/dist/src/resources/code-envs.d.ts

@@ -0,0 +1,8 @@
+import type { CodeEnvDetails, CodeEnvSummary } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export declare class CodeEnvsResource extends BaseResource {
+    list(opts?: {
+        envLang?: "PYTHON" | "R";
+    }): Promise<CodeEnvSummary[]>;
+    get(envLang: string, envName: string): Promise<CodeEnvDetails>;
+}

package/dist/src/resources/code-envs.js

@@ -0,0 +1,36 @@
+import { CodeEnvSummaryArraySchema, } from "../schemas.js";
+import { BaseResource, } from "./base.js";
+export class CodeEnvsResource extends BaseResource {
+    async list(opts) {
+        const raw = await this.client.get("/public/api/admin/code-envs/");
+        const envs = this.client.safeParse(CodeEnvSummaryArraySchema, raw, "codeEnvs.list");
+        if (opts?.envLang) {
+            return envs.filter((e) => e.envLang === opts.envLang);
+        }
+        return envs;
+    }
+    async get(envLang, envName) {
+        const langEnc = encodeURIComponent(envLang);
+        const nameEnc = encodeURIComponent(envName);
+        const raw = await this.client.get(`/public/api/admin/code-envs/${langEnc}/${nameEnc}/`);
+        const desc = (raw.desc ?? {});
+        const requestedPackages = splitPackageList(raw.specPackageList);
+        requestedPackages.sort();
+        const installedPackages = splitPackageList(raw.actualPackageList);
+        return {
+            envName: raw.envName ?? envName,
+            envLang: raw.envLang ?? envLang,
+            pythonInterpreter: desc.pythonInterpreter,
+            requestedPackages,
+            installedPackages,
+        };
+    }
+}
+function splitPackageList(raw) {
+    if (!raw)
+        return [];
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}