dataiku-sdk 3.6.0 → 3.7.0

package/dist/src/client.js

@@ -1,52 +1,8 @@
 import { readFileSync, } from "node:fs";
 import { basename, } from "node:path";
-import { getCACertificates, } from "node:tls";
 import { Value, } from "@sinclair/typebox/value";
 import { safeParseSchema, } from "./schemas.js";
 import { classifyDataikuError, ClientValidationError, DataikuError, nonJsonResponseBody, } from "./errors.js";
-import { AnalysesResource, } from "./resources/analyses.js";
-import { ApiDeployerResource, } from "./resources/api-deployer.js";
-import { ApiServicesResource, } from "./resources/api-services.js";
-import { ApplicationsResource, } from "./resources/applications.js";
-import { BundlesResource, ProjectDeployerResource, } from "./resources/bundles.js";
-import { CodeEnvsResource, } from "./resources/code-envs.js";
-import { ConnectionsResource, } from "./resources/connections.js";
-import { ContinuousActivitiesResource, } from "./resources/continuous-activities.js";
-import { DashboardsResource, } from "./resources/dashboards.js";
-import { DataCollectionsResource, } from "./resources/data-collections.js";
-import { DataQualityResource, } from "./resources/data-quality.js";
-import { DatasetsResource, } from "./resources/datasets.js";
-import { DiscussionsResource, } from "./resources/discussions.js";
-import { FlowZonesResource, } from "./resources/flow-zones.js";
-import { FoldersResource, } from "./resources/folders.js";
-import { FuturesResource, } from "./resources/futures.js";
-import { GroupsResource, } from "./resources/groups.js";
-import { InsightsResource, } from "./resources/insights.js";
-import { JobsResource, } from "./resources/jobs.js";
-import { KnowledgeBanksResource, } from "./resources/knowledge-banks.js";
-import { LlmsResource, } from "./resources/llms.js";
-import { MacrosResource, } from "./resources/macros.js";
-import { MeaningsResource, } from "./resources/meanings.js";
-import { MetricsResource, } from "./resources/metrics.js";
-import { MlTasksResource, } from "./resources/ml-tasks.js";
-import { ModelEvaluationStoresResource, } from "./resources/model-evaluation-stores.js";
-import { NotebooksResource, } from "./resources/notebooks.js";
-import { PluginsResource, } from "./resources/plugins.js";
-import { ProjectFoldersResource, } from "./resources/project-folders.js";
-import { ProjectGitResource, } from "./resources/project-git.js";
-import { ProjectLibraryResource, } from "./resources/project-library.js";
-import { ProjectsResource, } from "./resources/projects.js";
-import { RecipesResource, } from "./resources/recipes.js";
-import { SavedModelsResource, } from "./resources/saved-models.js";
-import { ScenariosResource, } from "./resources/scenarios.js";
-import { SqlResource, } from "./resources/sql.js";
-import { StatisticsResource, } from "./resources/statistics.js";
-import { StreamingEndpointsResource, } from "./resources/streaming-endpoints.js";
-import { UsersResource, } from "./resources/users.js";
-import { VariablesResource, } from "./resources/variables.js";
-import { WebappsResource, } from "./resources/webapps.js";
-import { WikiResource, } from "./resources/wiki.js";
-import { WorkspacesResource, } from "./resources/workspaces.js";
 /* ------------------------------------------------------------------ */
 /*  Constants                                                          */
 /* ------------------------------------------------------------------ */
@@ -94,6 +50,24 @@ function retryAfterDelayMs(value) {
 function isTransientError(status, body) {
     return classifyDataikuError(status, body).category === "transient";
 }
+/**
+ * Transport failure text that keeps the system error code: Bun puts it on the
+ * error (`ConnectionRefused`, `ENOTFOUND`), Node's fetch on `cause`.
+ */
+function transportErrorDetail(error) {
+    if (!(error instanceof Error))
+        return "Unknown transport error";
+    const cause = error.cause instanceof Error ? error.cause : undefined;
+    let code;
+    for (const candidate of [error, cause,]) {
+        if (candidate && "code" in candidate && typeof candidate.code === "string") {
+            code = candidate.code;
+            break;
+        }
+    }
+    const message = cause?.message ?? error.message;
+    return code && !message.includes(code) ? `${code}: ${message}` : message;
+}
 function shouldRetryMethod(method) {
     return method.toUpperCase() === "GET";
 }
@@ -183,6 +157,8 @@ function buildFetchTlsOptions(config) {
         tls.rejectUnauthorized = rejectUnauthorized;
     if (caCertPath) {
         try {
+            // node:tls costs ~12 ms to load; only a custom CA bundle needs it.
+            const { getCACertificates, } = require("node:tls");
             tls.ca = [...getCACertificates("default"), readFileSync(caCertPath, "utf-8"),];
         }
         catch (error) {
@@ -249,6 +225,8 @@ export class DataikuClient {
     scenariosResource;
     foldersResource;
     flowZonesResource;
+    flowResource;
+    mlflowExtensionResource;
     variablesResource;
     connectionsResource;
     codeEnvsResource;
@@ -283,137 +261,329 @@ export class DataikuClient {
     pluginsResource;
     usersResource;
     groupsResource;
+    // Resource modules load on first access (like commands/index.ts): a command
+    // that touches one resource does not parse the other forty-odd.
     get projects() {
-        return (this.projectsResource ??= new ProjectsResource(this));
+        if (!this.projectsResource) {
+            const { ProjectsResource: Resource, } = require("./resources/projects.js");
+            this.projectsResource = new Resource(this);
+        }
+        return this.projectsResource;
     }
     get datasets() {
-        return (this.datasetsResource ??= new DatasetsResource(this));
+        if (!this.datasetsResource) {
+            const { DatasetsResource: Resource, } = require("./resources/datasets.js");
+            this.datasetsResource = new Resource(this);
+        }
+        return this.datasetsResource;
     }
     get dashboards() {
-        return (this.dashboardsResource ??= new DashboardsResource(this));
+        if (!this.dashboardsResource) {
+            const { DashboardsResource: Resource, } = require("./resources/dashboards.js");
+            this.dashboardsResource = new Resource(this);
+        }
+        return this.dashboardsResource;
     }
     get dataQuality() {
-        return (this.dataQualityResource ??= new DataQualityResource(this));
+        if (!this.dataQualityResource) {
+            const { DataQualityResource: Resource, } = require("./resources/data-quality.js");
+            this.dataQualityResource = new Resource(this);
+        }
+        return this.dataQualityResource;
     }
     get recipes() {
-        return (this.recipesResource ??= new RecipesResource(this));
+        if (!this.recipesResource) {
+            const { RecipesResource: Resource, } = require("./resources/recipes.js");
+            this.recipesResource = new Resource(this);
+        }
+        return this.recipesResource;
     }
     get jobs() {
-        return (this.jobsResource ??= new JobsResource(this));
+        if (!this.jobsResource) {
+            const { JobsResource: Resource, } = require("./resources/jobs.js");
+            this.jobsResource = new Resource(this);
+        }
+        return this.jobsResource;
     }
     get futures() {
-        return (this.futuresResource ??= new FuturesResource(this));
+        if (!this.futuresResource) {
+            const { FuturesResource: Resource, } = require("./resources/futures.js");
+            this.futuresResource = new Resource(this);
+        }
+        return this.futuresResource;
     }
     get scenarios() {
-        return (this.scenariosResource ??= new ScenariosResource(this));
+        if (!this.scenariosResource) {
+            const { ScenariosResource: Resource, } = require("./resources/scenarios.js");
+            this.scenariosResource = new Resource(this);
+        }
+        return this.scenariosResource;
     }
     get folders() {
-        return (this.foldersResource ??= new FoldersResource(this));
+        if (!this.foldersResource) {
+            const { FoldersResource: Resource, } = require("./resources/folders.js");
+            this.foldersResource = new Resource(this);
+        }
+        return this.foldersResource;
     }
     get flowZones() {
-        return (this.flowZonesResource ??= new FlowZonesResource(this));
+        if (!this.flowZonesResource) {
+            const { FlowZonesResource: Resource, } = require("./resources/flow-zones.js");
+            this.flowZonesResource = new Resource(this);
+        }
+        return this.flowZonesResource;
+    }
+    get flow() {
+        if (!this.flowResource) {
+            const { FlowResource: Resource, } = require("./resources/flow.js");
+            this.flowResource = new Resource(this);
+        }
+        return this.flowResource;
+    }
+    get mlflowExtension() {
+        if (!this.mlflowExtensionResource) {
+            const { MlflowExtensionResource: Resource, } = require("./resources/mlflow-extension.js");
+            this.mlflowExtensionResource = new Resource(this);
+        }
+        return this.mlflowExtensionResource;
     }
     get variables() {
-        return (this.variablesResource ??= new VariablesResource(this));
+        if (!this.variablesResource) {
+            const { VariablesResource: Resource, } = require("./resources/variables.js");
+            this.variablesResource = new Resource(this);
+        }
+        return this.variablesResource;
     }
     get connections() {
-        return (this.connectionsResource ??= new ConnectionsResource(this));
+        if (!this.connectionsResource) {
+            const { ConnectionsResource: Resource, } = require("./resources/connections.js");
+            this.connectionsResource = new Resource(this);
+        }
+        return this.connectionsResource;
     }
     get codeEnvs() {
-        return (this.codeEnvsResource ??= new CodeEnvsResource(this));
+        if (!this.codeEnvsResource) {
+            const { CodeEnvsResource: Resource, } = require("./resources/code-envs.js");
+            this.codeEnvsResource = new Resource(this);
+        }
+        return this.codeEnvsResource;
     }
     get insights() {
-        return (this.insightsResource ??= new InsightsResource(this));
+        if (!this.insightsResource) {
+            const { InsightsResource: Resource, } = require("./resources/insights.js");
+            this.insightsResource = new Resource(this);
+        }
+        return this.insightsResource;
     }
     get sql() {
-        return (this.sqlResource ??= new SqlResource(this));
+        if (!this.sqlResource) {
+            const { SqlResource: Resource, } = require("./resources/sql.js");
+            this.sqlResource = new Resource(this);
+        }
+        return this.sqlResource;
     }
     get notebooks() {
-        return (this.notebooksResource ??= new NotebooksResource(this));
+        if (!this.notebooksResource) {
+            const { NotebooksResource: Resource, } = require("./resources/notebooks.js");
+            this.notebooksResource = new Resource(this);
+        }
+        return this.notebooksResource;
     }
     get wiki() {
-        return (this.wikiResource ??= new WikiResource(this));
+        if (!this.wikiResource) {
+            const { WikiResource: Resource, } = require("./resources/wiki.js");
+            this.wikiResource = new Resource(this);
+        }
+        return this.wikiResource;
     }
     get applications() {
-        return (this.applicationsResource ??= new ApplicationsResource(this));
+        if (!this.applicationsResource) {
+            const { ApplicationsResource: Resource, } = require("./resources/applications.js");
+            this.applicationsResource = new Resource(this);
+        }
+        return this.applicationsResource;
     }
     get webapps() {
-        return (this.webappsResource ??= new WebappsResource(this));
+        if (!this.webappsResource) {
+            const { WebappsResource: Resource, } = require("./resources/webapps.js");
+            this.webappsResource = new Resource(this);
+        }
+        return this.webappsResource;
     }
     get apiServices() {
-        return (this.apiServicesResource ??= new ApiServicesResource(this));
+        if (!this.apiServicesResource) {
+            const { ApiServicesResource: Resource, } = require("./resources/api-services.js");
+            this.apiServicesResource = new Resource(this);
+        }
+        return this.apiServicesResource;
     }
     get apiDeployer() {
-        return (this.apiDeployerResource ??= new ApiDeployerResource(this));
+        if (!this.apiDeployerResource) {
+            const { ApiDeployerResource: Resource, } = require("./resources/api-deployer.js");
+            this.apiDeployerResource = new Resource(this);
+        }
+        return this.apiDeployerResource;
     }
     get bundles() {
-        return (this.bundlesResource ??= new BundlesResource(this));
+        if (!this.bundlesResource) {
+            const { BundlesResource: Resource, } = require("./resources/bundles.js");
+            this.bundlesResource = new Resource(this);
+        }
+        return this.bundlesResource;
     }
     get projectDeployer() {
-        return (this.projectDeployerResource ??= new ProjectDeployerResource(this));
+        if (!this.projectDeployerResource) {
+            const { ProjectDeployerResource: Resource, } = require("./resources/bundles.js");
+            this.projectDeployerResource = new Resource(this);
+        }
+        return this.projectDeployerResource;
     }
     get projectLibrary() {
-        return (this.projectLibraryResource ??= new ProjectLibraryResource(this));
+        if (!this.projectLibraryResource) {
+            const { ProjectLibraryResource: Resource, } = require("./resources/project-library.js");
+            this.projectLibraryResource = new Resource(this);
+        }
+        return this.projectLibraryResource;
     }
     get projectGit() {
-        return (this.projectGitResource ??= new ProjectGitResource(this));
+        if (!this.projectGitResource) {
+            const { ProjectGitResource: Resource, } = require("./resources/project-git.js");
+            this.projectGitResource = new Resource(this);
+        }
+        return this.projectGitResource;
     }
     get streamingEndpoints() {
-        return (this.streamingEndpointsResource ??= new StreamingEndpointsResource(this));
+        if (!this.streamingEndpointsResource) {
+            const { StreamingEndpointsResource: Resource, } = require("./resources/streaming-endpoints.js");
+            this.streamingEndpointsResource = new Resource(this);
+        }
+        return this.streamingEndpointsResource;
     }
     get continuousActivities() {
-        return (this.continuousActivitiesResource ??= new ContinuousActivitiesResource(this));
+        if (!this.continuousActivitiesResource) {
+            const { ContinuousActivitiesResource: Resource, } = require("./resources/continuous-activities.js");
+            this.continuousActivitiesResource = new Resource(this);
+        }
+        return this.continuousActivitiesResource;
     }
     get statistics() {
-        return (this.statisticsResource ??= new StatisticsResource(this));
+        if (!this.statisticsResource) {
+            const { StatisticsResource: Resource, } = require("./resources/statistics.js");
+            this.statisticsResource = new Resource(this);
+        }
+        return this.statisticsResource;
     }
     get discussions() {
-        return (this.discussionsResource ??= new DiscussionsResource(this));
+        if (!this.discussionsResource) {
+            const { DiscussionsResource: Resource, } = require("./resources/discussions.js");
+            this.discussionsResource = new Resource(this);
+        }
+        return this.discussionsResource;
     }
     get workspaces() {
-        return (this.workspacesResource ??= new WorkspacesResource(this));
+        if (!this.workspacesResource) {
+            const { WorkspacesResource: Resource, } = require("./resources/workspaces.js");
+            this.workspacesResource = new Resource(this);
+        }
+        return this.workspacesResource;
     }
     get metrics() {
-        return (this.metricsResource ??= new MetricsResource(this));
+        if (!this.metricsResource) {
+            const { MetricsResource: Resource, } = require("./resources/metrics.js");
+            this.metricsResource = new Resource(this);
+        }
+        return this.metricsResource;
     }
     get meanings() {
-        return (this.meaningsResource ??= new MeaningsResource(this));
+        if (!this.meaningsResource) {
+            const { MeaningsResource: Resource, } = require("./resources/meanings.js");
+            this.meaningsResource = new Resource(this);
+        }
+        return this.meaningsResource;
     }
     get analyses() {
-        return (this.analysesResource ??= new AnalysesResource(this));
+        if (!this.analysesResource) {
+            const { AnalysesResource: Resource, } = require("./resources/analyses.js");
+            this.analysesResource = new Resource(this);
+        }
+        return this.analysesResource;
     }
     get mlTasks() {
-        return (this.mlTasksResource ??= new MlTasksResource(this));
+        if (!this.mlTasksResource) {
+            const { MlTasksResource: Resource, } = require("./resources/ml-tasks.js");
+            this.mlTasksResource = new Resource(this);
+        }
+        return this.mlTasksResource;
     }
     get savedModels() {
-        return (this.savedModelsResource ??= new SavedModelsResource(this));
+        if (!this.savedModelsResource) {
+            const { SavedModelsResource: Resource, } = require("./resources/saved-models.js");
+            this.savedModelsResource = new Resource(this);
+        }
+        return this.savedModelsResource;
     }
     get modelEvaluationStores() {
-        return (this.modelEvaluationStoresResource ??= new ModelEvaluationStoresResource(this));
+        if (!this.modelEvaluationStoresResource) {
+            const { ModelEvaluationStoresResource: Resource, } = require("./resources/model-evaluation-stores.js");
+            this.modelEvaluationStoresResource = new Resource(this);
+        }
+        return this.modelEvaluationStoresResource;
     }
     get projectFolders() {
-        return (this.projectFoldersResource ??= new ProjectFoldersResource(this));
+        if (!this.projectFoldersResource) {
+            const { ProjectFoldersResource: Resource, } = require("./resources/project-folders.js");
+            this.projectFoldersResource = new Resource(this);
+        }
+        return this.projectFoldersResource;
     }
     get dataCollections() {
-        return (this.dataCollectionsResource ??= new DataCollectionsResource(this));
+        if (!this.dataCollectionsResource) {
+            const { DataCollectionsResource: Resource, } = require("./resources/data-collections.js");
+            this.dataCollectionsResource = new Resource(this);
+        }
+        return this.dataCollectionsResource;
     }
     get llms() {
-        return (this.llmsResource ??= new LlmsResource(this));
+        if (!this.llmsResource) {
+            const { LlmsResource: Resource, } = require("./resources/llms.js");
+            this.llmsResource = new Resource(this);
+        }
+        return this.llmsResource;
     }
     get knowledgeBanks() {
-        return (this.knowledgeBanksResource ??= new KnowledgeBanksResource(this));
+        if (!this.knowledgeBanksResource) {
+            const { KnowledgeBanksResource: Resource, } = require("./resources/knowledge-banks.js");
+            this.knowledgeBanksResource = new Resource(this);
+        }
+        return this.knowledgeBanksResource;
     }
     get macros() {
-        return (this.macrosResource ??= new MacrosResource(this));
+        if (!this.macrosResource) {
+            const { MacrosResource: Resource, } = require("./resources/macros.js");
+            this.macrosResource = new Resource(this);
+        }
+        return this.macrosResource;
     }
     get plugins() {
-        return (this.pluginsResource ??= new PluginsResource(this));
+        if (!this.pluginsResource) {
+            const { PluginsResource: Resource, } = require("./resources/plugins.js");
+            this.pluginsResource = new Resource(this);
+        }
+        return this.pluginsResource;
     }
     get users() {
-        return (this.usersResource ??= new UsersResource(this));
+        if (!this.usersResource) {
+            const { UsersResource: Resource, } = require("./resources/users.js");
+            this.usersResource = new Resource(this);
+        }
+        return this.usersResource;
     }
     get groups() {
-        return (this.groupsResource ??= new GroupsResource(this));
+        if (!this.groupsResource) {
+            const { GroupsResource: Resource, } = require("./resources/groups.js");
+            this.groupsResource = new Resource(this);
+        }
+        return this.groupsResource;
     }
     constructor(config) {
         /* oxlint-disable dss/no-direct-process-env -- SDK constructor defaults (DATAIKU_URL/DATAIKU_API_KEY) for library callers */
@@ -470,7 +640,7 @@ export class DataikuClient {
     /* ---- public: HTTP verbs ---- */
     async get(path, options) {
         const deadlineAt = resolveGetDeadlineAt(options);
-        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, { method: "GET", headers: this.getHeaders(false), }, options?.noRetry === true ? 1 : undefined, deadlineAt);
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, { method: "GET", headers: { ...this.getHeaders(false), ...options?.headers, }, }, options?.noRetry === true ? 1 : undefined, deadlineAt);
         return this.parseJsonResponse(res, deadlineAt);
     }
     /**
@@ -543,7 +713,7 @@ export class DataikuClient {
         }
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "POST",
-            headers: this.getHeaders(body !== undefined),
+            headers: { ...this.getHeaders(body !== undefined), ...options?.headers, },
             body: body !== undefined ? JSON.stringify(body) : undefined,
         }, retryMaxAttempts);
         return this.parseJsonResponse(res);
@@ -1072,7 +1242,13 @@ export class DataikuClient {
                     }
                     timedOut = true;
                 }
-                const canRetry = retryEnabled && attempt < maxAttempts;
+                const detail = timedOut
+                    ? `Request timed out after ${attemptTimeoutMs}ms`
+                    : transportErrorDetail(error);
+                // The classifier that labels the final error also decides the retry:
+                // a refused connection, unknown host, bad URL, or untrusted certificate
+                // fails the same way on every attempt.
+                const canRetry = retryEnabled && attempt < maxAttempts && isTransientError(0, detail);
                 if (canRetry) {
                     const delayMs = computeBackoffDelayMs(attempt);
                     if (deadlineAt === undefined || Date.now() + delayMs <= deadlineAt) {
@@ -1083,11 +1259,6 @@ export class DataikuClient {
                     await sleep(Math.max(0, deadlineAt - Date.now()));
                     throw new DataikuError(0, "Request Timeout", `Request deadline exceeded before backoff retry ${attempt + 1}.`, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, true));
                 }
-                const detail = timedOut
-                    ? `Request timed out after ${attemptTimeoutMs}ms`
-                    : error instanceof Error
-                        ? error.message
-                        : "Unknown transport error";
                 this.logTrace({
                     phase: "error",
                     method,

package/dist/src/errors.d.ts

@@ -45,6 +45,10 @@ export declare const UNEXPECTED_RESPONSE_MARKER = "Unexpected DSS response";
 export declare function unexpectedResponseError(detail: string, status?: number): DataikuError;
 /** Prefix for a SQL query failure reported by DSS on a 2xx finish-streaming response. */
 export declare const SQL_QUERY_FAILED_MARKER = "SQL query failed in DSS";
+/** Generic permission hint; the CLI names the project when the request was project-scoped. */
+export declare const FORBIDDEN_HINT = "Check API key validity and project permissions for the requested action.";
+/** Generic 404 hint; the CLI names the resource and project when it knows them. */
+export declare const NOT_FOUND_HINT = "Verify projectKey and object identifiers (dataset/recipe/scenario/folder IDs).";
 export declare function classifyDataikuError(status: number, body: string): DataikuErrorTaxonomy;
 export declare class DataikuError extends Error {
     status: number;
@@ -59,8 +63,14 @@ export declare class DataikuError extends Error {
     readonly trustedElapsedMs?: number;
     readonly bodyTruncated?: boolean;
     constructor(status: number, statusText: string, body: string, retry?: DataikuRetryMetadata, requestId?: string, trustedMetadata?: DataikuErrorTrustedMetadata);
+    /** Status line only: never echoes response body text. */
     get safeMessage(): string;
+    /** The DSS message part of `message` (HTML summarized, server paths stripped, bounded). */
+    get summary(): string;
     private static extractSummary;
-    private static formatRetryMetadata;
+    /**
+     * One line: status plus the DSS message. Category, retryability, hint, and
+     * retry metadata are structured fields on the error, not message prose.
+     */
     private static buildDetails;
 }