dataiku-sdk 3.3.0 → 3.4.0

package/dist/src/client.d.ts

@@ -73,6 +73,15 @@ export interface DataikuGetOptions {
      * budget may shorten those limits but never extends them.
      */
     timeoutMs?: number;
+    /**
+     * Issue exactly one transport attempt (no retries). Independent of
+     * `timeoutMs`: when both are supplied the total budget above still applies
+     * and aborts the attempt; when no budget is supplied the attempt is capped
+     * by the client-level `requestTimeoutMs`. Wait loops use this for the one
+     * observation whose wait budget is already spent, so it still reaches the
+     * server once instead of failing before any transport attempt.
+     */
+    noRetry?: boolean;
 }
 export interface DataikuClientTraceEvent {
     type: "trace";
@@ -298,7 +307,7 @@ export declare class DataikuClient {
     /** Send raw file contents through the shared authenticated transport. */
     postRawBody(path: string, body: string | Uint8Array): Promise<void>;
     /** Git endpoints require Basic API-key authentication, unlike the bearer API. */
-    requestGit(method: string, path: string, body?: unknown, deadlineAt?: number): Promise<Response>;
+    requestGit(method: string, path: string, body?: unknown, deadlineAt?: number, noRetry?: boolean): Promise<Response>;
     postStream(path: string, body?: unknown): Promise<Response>;
     put<T = unknown>(path: string, body: unknown): Promise<T>;
     del(path: string): Promise<void>;

package/dist/src/client.js

@@ -78,6 +78,19 @@ 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));
 }
+/** Server-directed waits never bypass the existing automatic backoff cap. */
+function retryAfterDelayMs(value) {
+    if (value === null)
+        return 0;
+    const text = value.trim();
+    if (/^\d+$/.test(text))
+        return Number(text) * 1_000;
+    // Accept HTTP dates, not Date.parse's permissive numeric date shorthand.
+    if (!/^[A-Za-z]{3,9},? /.test(text))
+        return 0;
+    const date = Date.parse(text);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 0;
+}
 function isTransientError(status, body) {
     return classifyDataikuError(status, body).category === "transient";
 }
@@ -455,7 +468,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(), }, undefined, deadlineAt);
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, { method: "GET", headers: this.getHeaders(), }, options?.noRetry === true ? 1 : undefined, deadlineAt);
         return this.parseJsonResponse(res, deadlineAt);
     }
     /**
@@ -563,7 +576,7 @@ export class DataikuClient {
         await response.text();
     }
     /** Git endpoints require Basic API-key authentication, unlike the bearer API. */
-    async requestGit(method, path, body, deadlineAt) {
+    async requestGit(method, path, body, deadlineAt, noRetry = false) {
         return this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method,
             headers: {
@@ -572,7 +585,7 @@ export class DataikuClient {
                 "Content-Type": "application/json",
             },
             body: body === undefined ? undefined : JSON.stringify(body),
-        }, undefined, deadlineAt);
+        }, noRetry ? 1 : undefined, deadlineAt);
     }
     async postStream(path, body) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
@@ -1018,8 +1031,10 @@ export class DataikuClient {
                 if (!res.ok) {
                     const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes, startedAt + attemptTimeoutMs);
                     const canRetry = retryEnabled && attempt < maxAttempts && isTransientError(res.status, text);
-                    if (canRetry) {
-                        const delayMs = computeBackoffDelayMs(attempt);
+                    const serverDelayMs = canRetry ? retryAfterDelayMs(res.headers.get("retry-after")) : 0;
+                    // A longer server wait declines automatic retry; never clamp it into an early request.
+                    if (canRetry && serverDelayMs <= MAX_BACKOFF_DELAY_MS) {
+                        const delayMs = Math.max(computeBackoffDelayMs(attempt), serverDelayMs);
                         // Do not start a retry whose backoff cannot fit in the budget.
                         if (deadlineAt === undefined || Date.now() + delayMs <= deadlineAt) {
                             delaysMs.push(delayMs);

package/dist/src/errors.js

@@ -92,10 +92,12 @@ function firstHtmlTextLine(body) {
         .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
         .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
         .replace(/<[^>]+>/g, "\n"));
-    return text
-        .split(/\r?\n/g)
-        .map((line) => line.trim())
-        .find((line) => line.length > 0);
+    for (const match of text.matchAll(/[^\n]+/g)) {
+        const line = match[0].trim();
+        if (line.length > 0)
+            return line;
+    }
+    return undefined;
 }
 function conciseErrorSummary(text) {
     const sanitized = stripServerFilesystemPaths(text);