dataiku-sdk 3.6.1 → 3.8.0

package/dist/src/errors.js

@@ -74,9 +74,15 @@ export const UNEXPECTED_RESPONSE_MARKER = "Unexpected DSS response";
 export function unexpectedResponseError(detail, status = 200) {
     return new DataikuError(status, "Unexpected Response", `${UNEXPECTED_RESPONSE_MARKER}: ${detail}`);
 }
+/** Hint for a DSS answer that definitively failed the request (e.g. the database rejected the SQL). */
+const DEFINITE_FAILURE_HINT = "DSS reported that the request failed (for SQL: syntax error, missing object, or missing privileges of the connection's role). Fix the request or grants; do not retry unchanged.";
 /** Prefix for a SQL query failure reported by DSS on a 2xx finish-streaming response. */
 export const SQL_QUERY_FAILED_MARKER = "SQL query failed in DSS";
-const TLS_CERTIFICATE_HINT = "TLS certificate verification failed. Trust the DSS/corporate CA with --ca-cert PATH or NODE_EXTRA_CA_CERTS; use --insecure only for temporary troubleshooting.";
+const TLS_CERTIFICATE_HINT = "TLS certificate verification failed. Trust the DSS/corporate CA with --ca-cert PATH or NODE_EXTRA_CA_CERTS, or save it for every process and directory with `dss auth login --ca-cert PATH` (a project .env applies only when dss runs in that directory); use --insecure only for temporary troubleshooting.";
+/** Generic permission hint; the CLI names the project when the request was project-scoped. */
+export 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 const NOT_FOUND_HINT = "Verify projectKey and object identifiers (dataset/recipe/scenario/folder IDs).";
 const BUSINESS_APPS_API_UNAVAILABLE_HINT = "Business Apps API is not available on this DSS instance. Use classic app commands or check DSS version/feature availability.";
 const MAX_ERROR_SUMMARY_LENGTH = 200;
 function isHtmlResponseBody(body) {
@@ -136,6 +142,8 @@ function isCertificateTrustFailure(lowerBody) {
         || lowerBody.includes("unable to get local issuer certificate")
         || lowerBody.includes("unable to verify leaf signature")
         || lowerBody.includes("self-signed certificate")
+        || lowerBody.includes("self signed certificate")
+        || lowerBody.includes("depth_zero_self_signed_cert")
         || lowerBody.includes("certificate has expired")
         || lowerBody.includes("cert_has_expired")
         || lowerBody.includes("self_signed_cert_in_chain")
@@ -170,6 +178,15 @@ export function classifyDataikuError(status, body) {
                 retryHint: TLS_CERTIFICATE_HINT,
             };
         }
+        // The same URL fails the same way on every attempt: nothing listens on
+        // the port, the host name does not resolve, or the URL is malformed.
+        if (/\b(?:connectionrefused|econnrefused|enotfound|err_invalid_url|bad port)\b/.test(lowerBody)) {
+            return {
+                category: "validation",
+                retryable: false,
+                retryHint: "DSS is not reachable at this URL. Check --url / DATAIKU_URL (scheme, host, port) and that DSS is running; do not retry unchanged.",
+            };
+        }
         return {
             category: "transient",
             retryable: true,
@@ -295,11 +312,7 @@ export function classifyDataikuError(status, body) {
             || (lowerBody.includes("permission")
                 && (lowerBody.includes("cannot use") || lowerBody.includes("not allowed"))));
     if (isServerPermissionLike) {
-        return {
-            category: "forbidden",
-            retryable: false,
-            retryHint: "Check API key validity and project permissions for the requested action.",
-        };
+        return { category: "forbidden", retryable: false, retryHint: FORBIDDEN_HINT, };
     }
     if (status === 404) {
         if (isBusinessAppsApiRootNotFound(lowerBody)) {
@@ -315,15 +328,11 @@ export function classifyDataikuError(status, body) {
             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).",
+                : NOT_FOUND_HINT,
         };
     }
     if (status === 401 || status === 403) {
-        return {
-            category: "forbidden",
-            retryable: false,
-            retryHint: "Check API key validity and project permissions for the requested action.",
-        };
+        return { category: "forbidden", retryable: false, retryHint: FORBIDDEN_HINT, };
     }
     if (status === 400 || status === 409 || status === 422) {
         return {
@@ -367,31 +376,40 @@ export class DataikuError extends Error {
     trustedTarget;
     trustedElapsedMs;
     bodyTruncated;
+    /** DSS definitively failed the whole operation; see `DataikuErrorTrustedMetadata.definiteFailure`. */
+    definiteFailure;
+    /** Client-side outcome context (e.g. rollback of partial mutations), surfaced in CLI `details`. */
+    details;
     constructor(status, statusText, body, retry, requestId, trustedMetadata) {
-        const details = DataikuError.buildDetails(status, body, retry);
+        const details = DataikuError.buildDetails(status, body);
         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;
+        const definite = trustedMetadata?.definiteFailure === true;
+        // A definite DSS refusal is not a transport/server fault: replaying it
+        // unchanged cannot succeed. Keep a more specific forbidden/not_found class.
+        const reclassify = definite
+            && (details.category === "transient" || details.category === "unknown"
+                || details.category === "unexpected_response");
+        this.category = reclassify ? "validation" : details.category;
+        this.retryable = reclassify ? false : details.retryable;
+        this.retryHint = reclassify ? DEFINITE_FAILURE_HINT : details.retryHint;
         this.retry = retry;
         this.requestId = requestId;
         this.trustedTarget = trustedMetadata?.target;
         this.trustedElapsedMs = trustedMetadata?.elapsedMs;
         this.bodyTruncated = trustedMetadata?.bodyTruncated === true ? true : undefined;
+        this.definiteFailure = definite ? true : undefined;
     }
+    /** Status line only: never echoes response body text. */
     get safeMessage() {
-        const retrySummary = DataikuError.formatRetryMetadata(this.retry);
-        return [
-            `${this.status} ${canonicalStatusText(this.status)}`,
-            `Error type: ${this.category}`,
-            `Retryable: ${this.retryable ? "yes" : "no"}`,
-            `Hint: ${this.retryHint}`,
-            ...(retrySummary ? [retrySummary,] : []),
-        ].join("\n");
+        return `${this.status} ${canonicalStatusText(this.status)}`;
+    }
+    /** The DSS message part of `message` (HTML summarized, server paths stripped, bounded). */
+    get summary() {
+        return this.message.slice(this.safeMessage.length + 2);
     }
     static extractSummary(_status, body) {
         try {
@@ -406,33 +424,14 @@ export class DataikuError extends Error {
             return "(empty response body)";
         return summarizeErrorText(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, body, retry) {
-        const summary = DataikuError.extractSummary(status, body);
-        const taxonomy = classifyDataikuError(status, body);
-        const retrySummary = DataikuError.formatRetryMetadata(retry);
+    /**
+     * One line: status plus the DSS message. Category, retryability, hint, and
+     * retry metadata are structured fields on the error, not message prose.
+     */
+    static buildDetails(status, body) {
         return {
-            ...taxonomy,
-            message: [
-                `${status} ${canonicalStatusText(status)}: ${summary}`,
-                `Error type: ${taxonomy.category}`,
-                `Retryable: ${taxonomy.retryable ? "yes" : "no"}`,
-                `Hint: ${taxonomy.retryHint}`,
-                ...(retrySummary ? [retrySummary,] : []),
-            ].join("\n"),
+            ...classifyDataikuError(status, body),
+            message: `${status} ${canonicalStatusText(status)}: ${DataikuError.extractSummary(status, body).replace(/\s+/g, " ").trim()}`,
         };
     }
 }