@keboola/api-client 3.0.0 → 4.0.0

package/dist/index.js

@@ -1,35 +1,36 @@
 import { createProject } from './chunk-UABYNGBZ.js';
+import { createVaultSdk } from './chunk-7ETZQGY7.js';
 import { generateUUID, createTagSdk } from './chunk-JURD5MC3.js';
 export { generateUUID, keboolaUID } from './chunk-JURD5MC3.js';
-import { delay, createStorageSdk } from './chunk-R7PD3BRA.js';
-export { PollException, createStorageSdk, delay, poll } from './chunk-R7PD3BRA.js';
-import { createTelemetryClient } from './chunk-TXFQ4YIK.js';
-import { createVaultClient } from './chunk-SAEG42HW.js';
-export { UserError } from './chunk-SAEG42HW.js';
-import { createManagementClient } from './chunk-ZEMKE6DI.js';
-export { ManagementClientAuthError, isManagementClientAuthError } from './chunk-ZEMKE6DI.js';
-import { createVerifyClient } from './chunk-GNPQB3MT.js';
-import { createMetastoreClient } from './chunk-GO6SOMGL.js';
-import { createOauthClient } from './chunk-7FY6COWG.js';
-import { createQueryServiceClient } from './chunk-LV3ZWNDC.js';
-import { createQueueClient } from './chunk-3Y6NK7TC.js';
-import { createStatusClient } from './chunk-VAOCYA6B.js';
+import { delay, createStorageSdk } from './chunk-2ZMZ4KWJ.js';
+export { PollException, createStorageSdk, delay, poll } from './chunk-2ZMZ4KWJ.js';
+import { createTelemetryClient } from './chunk-HLGMFFDF.js';
+import { createVaultClient } from './chunk-CQFZ7PGZ.js';
+export { UserError } from './chunk-CQFZ7PGZ.js';
+import { createManagementClient } from './chunk-RBW5ABSQ.js';
+export { ManagementClientAuthError, isManagementClientAuthError } from './chunk-RBW5ABSQ.js';
+import { createVerifyClient } from './chunk-OAKTIIG4.js';
+import { createMetastoreClient } from './chunk-GLQZHLLN.js';
+import { createOauthClient } from './chunk-ZQPET6GI.js';
+import { createQueryServiceClient } from './chunk-PM2FAMWT.js';
+import { createQueueClient } from './chunk-5PUNJJAR.js';
+import { createStatusClient } from './chunk-LBVYZLWL.js';
 import './chunk-7J2R6XHB.js';
-import { createStorageTokenMiddleware, createStorageClient } from './chunk-TNJWOHPM.js';
-export { series } from './chunk-TNJWOHPM.js';
+import { createStorageTokenMiddleware, createStorageClient } from './chunk-7NX56CKZ.js';
+export { series } from './chunk-7NX56CKZ.js';
 export { concurrent } from './chunk-EBCZUGUX.js';
-import { createSyncActionsClient } from './chunk-3B7L6MCG.js';
-import { createAiClient } from './chunk-VS5PM7KL.js';
-import { createAssetsClient } from './chunk-WQ7EZWBF.js';
-import { createChatClient } from './chunk-PV4HIVW2.js';
+import { createSyncActionsClient } from './chunk-X73I4PLK.js';
+import { createAiClient } from './chunk-3DW7RIEB.js';
+import { createAssetsClient } from './chunk-6TUGEXVX.js';
+import { createChatClient } from './chunk-Q6T6GRDR.js';
 import { suggestionsApiResponseSchema } from './chunk-4RC5E3SL.js';
-import { createDataScienceClient } from './chunk-UXF53ZOV.js';
-export { parseLogLines } from './chunk-UXF53ZOV.js';
-import { createEditorClient } from './chunk-OKVYLO6C.js';
-import { createEncryptionClient } from './chunk-IJMQCOBC.js';
-import { createImportClient } from './chunk-FBQHHAL5.js';
-import { KeboolaHttpHeader, HttpStatus, ApiError, createCallbackMiddleware, normalizeBaseUrl, createOpenapiFetchClient, createGenericFetchClient } from './chunk-PD3LJYS2.js';
-export { ApiError, HttpContentType, HttpHeader, KeboolaHttpHeader, createGenericFetchClient, isAbortError, isApiError, isFetchClientError, normalizeBaseUrl } from './chunk-PD3LJYS2.js';
+import { createDataScienceClient } from './chunk-RBGTWJ7G.js';
+export { parseLogLines } from './chunk-RBGTWJ7G.js';
+import { createEditorClient } from './chunk-76Q2CTFV.js';
+import { createEncryptionClient } from './chunk-V35JLM5Q.js';
+import { createImportClient } from './chunk-T23NVI3Q.js';
+import { KeboolaHttpHeader, HttpStatus, isApiError, ApiError, createOpenapiFetchClient, createGenericFetchClient } from './chunk-QXWPUKK2.js';
+export { ApiError, HttpContentType, HttpHeader, KeboolaHttpHeader, createGenericFetchClient, isAbortError, isApiError, isFetchClientError } from './chunk-QXWPUKK2.js';
 import { z } from 'zod';
 
 // src/errors/ServiceUnavailableError.ts
@@ -84,7 +85,7 @@ var sandboxGitBranchSchema = z.object({
   branch: z.string().nullable()
 });
 var createKaiAgentClient = ({ baseUrl, middlewares }) => {
-  const clientOptions = { baseUrl: normalizeBaseUrl(baseUrl), middlewares };
+  const clientOptions = { baseUrl, middlewares };
   const client = createOpenapiFetchClient(clientOptions);
   const genericClient = createGenericFetchClient(clientOptions);
   const getHistory = async (params) => {
@@ -260,6 +261,53 @@ function assert(value, message) {
   }
 }
 
+// src/utils/coalesce.ts
+var coalesce = (task, onError) => {
+  let running = false;
+  let pending = false;
+  return () => {
+    if (running) {
+      pending = true;
+      return;
+    }
+    running = true;
+    void (async () => {
+      try {
+        do {
+          pending = false;
+          try {
+            await task();
+          } catch (error) {
+            onError?.(error);
+          }
+        } while (pending);
+      } finally {
+        running = false;
+      }
+    })();
+  };
+};
+
+// src/utils/createStore.ts
+var createStore = (initial) => {
+  let value = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get: () => value,
+    set: (next) => {
+      if (Object.is(next, value)) return;
+      value = next;
+      listeners.forEach((listener) => listener(value));
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
 // src/domain/stack.ts
 var SERVICE_URL_OVERRIDES = {
   // The service URL for the Kai Assistant is incomplete; we need to add the `/api` suffix to get the full URL for the API.
@@ -302,6 +350,16 @@ var createStack = ({ stackInfo, clientServiceUrls }) => {
   };
 };
 
+// src/createMiddlewareFor.ts
+var createMiddlewareFor = (middlewares) => {
+  return (target, baseline = []) => {
+    if (Array.isArray(middlewares)) return [...baseline, ...middlewares];
+    const all = middlewares?.all ?? [];
+    const targeted = middlewares?.[target] ?? [];
+    return [...baseline, ...all, ...targeted];
+  };
+};
+
 // src/serviceClientRegistry/utils.ts
 var isBuiltInProperty = (property) => typeof property === "symbol" || property === "then" || property === "constructor" || property === "toString" || property === "valueOf";
 var createDummyClient = ({
@@ -324,8 +382,9 @@ var createDummyClient = ({
 var createServiceClientRegistry = () => ({
   getServiceBaseUrl,
   onUnavailable,
-  clients
+  meta
 }) => {
+  let metaValue = meta ?? {};
   const dummy = (serviceId, clientName) => createDummyClient({
     onCall: (path, args) => {
       onUnavailable?.({
@@ -336,42 +395,71 @@ var createServiceClientRegistry = () => ({
       });
     }
   });
-  const clientMap = {};
-  const meta = [];
-  clients.forEach(({ serviceId, clientFn, clientName }) => {
+  const configs = [];
+  const resolveClient = ({
+    serviceId,
+    clientFn,
+    clientName
+  }) => {
     const serviceBaseUrl = getServiceBaseUrl(serviceId);
-    clientMap[clientName] = serviceBaseUrl ? clientFn(serviceBaseUrl) : dummy(serviceId, clientName);
-    meta.push({ clientName, serviceId, isAvailable: !!serviceBaseUrl });
-  });
-  const client = clientMap;
-  return {
-    client,
-    meta
+    return serviceBaseUrl ? clientFn(serviceBaseUrl, metaValue) : dummy(serviceId, clientName);
   };
+  let clientMap = null;
+  const registry = {
+    add: (config) => {
+      configs.push(config);
+      return registry;
+    },
+    build: () => {
+      clientMap = {};
+      const clientMeta = [];
+      configs.forEach((config) => {
+        clientMap[config.clientName] = resolveClient(config);
+        clientMeta.push({
+          clientName: config.clientName,
+          serviceId: config.serviceId,
+          isAvailable: !!getServiceBaseUrl(config.serviceId)
+        });
+      });
+      return {
+        client: clientMap,
+        meta: clientMeta
+      };
+    },
+    rebuild: (nextMeta) => {
+      if (!clientMap) {
+        throw new Error("Registry must be built before rebuild() is called.");
+      }
+      metaValue = nextMeta;
+      configs.forEach((config) => {
+        clientMap[config.clientName] = resolveClient(config);
+      });
+    }
+  };
+  return registry;
 };
 
 // src/client.ts
 var createClients = async ({
   baseUrl,
   token,
-  callbacks,
   assetsBaseUrl,
   statusBaseUrl,
   metastoreBaseUrl,
   clientServiceUrls,
-  storageMiddlewares
+  middlewares
 }) => {
-  const callbackMiddleware = createCallbackMiddleware(callbacks);
   const storageTokenMiddleware = createStorageTokenMiddleware(token.storageApi);
-  const commonMiddlewares = [callbackMiddleware, storageTokenMiddleware];
+  const commonMiddlewares = [storageTokenMiddleware];
+  const middlewareFor = createMiddlewareFor(middlewares);
   const storage = createStorageClient({
     baseUrl,
-    middlewares: [...commonMiddlewares, ...storageMiddlewares || []]
+    middlewares: middlewareFor("storage", commonMiddlewares)
   });
   const management = createManagementClient({
     baseUrl,
     token: token.managementApi,
-    callbacks
+    middlewares: middlewareFor("management", [])
   });
   const [stackInfo, sapiToken] = await Promise.all([
     storage.getStackInfo({
@@ -381,97 +469,116 @@ var createClients = async ({
   ]);
   const stack = createStack({ stackInfo, clientServiceUrls });
   const project = createProject({ sapiToken });
-  const { client, meta } = createServiceClientRegistry()({
+  const registry = createServiceClientRegistry()({
     getServiceBaseUrl: (serviceId) => stack.getServiceUrl(serviceId),
     onUnavailable: ({ serviceId, path, clientName }) => {
       throw new ServiceUnavailableError(serviceId, path, clientName);
-    },
-    clients: [
-      {
-        serviceId: "vault",
-        clientName: "vault",
-        clientFn: (serviceBaseUrl) => createVaultClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "data-science",
-        clientName: "dataScience",
-        clientFn: (serviceBaseUrl) => createDataScienceClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "encryption",
-        clientName: "encryption",
-        clientFn: (serviceBaseUrl) => createEncryptionClient({ baseUrl: serviceBaseUrl, middlewares: [callbackMiddleware] })
-      },
-      {
-        serviceId: "editor",
-        clientName: "editor",
-        clientFn: (serviceBaseUrl) => createEditorClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "sync-actions",
-        clientName: "syncActions",
-        clientFn: (serviceBaseUrl) => createSyncActionsClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "telemetry",
-        clientName: "telemetry",
-        clientFn: (serviceBaseUrl) => createTelemetryClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "query",
-        clientName: "queryService",
-        clientFn: (serviceBaseUrl) => createQueryServiceClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "queue",
-        clientName: "queue",
-        clientFn: (serviceBaseUrl) => createQueueClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "kai-assistant",
-        clientName: "chat",
-        clientFn: (serviceBaseUrl) => createChatClient({
-          storageApiUrl: baseUrl,
-          baseUrl: serviceBaseUrl,
-          middlewares: commonMiddlewares
-        })
-      },
-      {
-        serviceId: "ai",
-        clientName: "ai",
-        clientFn: (serviceBaseUrl) => createAiClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "import",
-        clientName: "import",
-        clientFn: (serviceBaseUrl) => createImportClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      },
-      {
-        serviceId: "kai-agent",
-        clientName: "kaiAgent",
-        clientFn: (serviceBaseUrl) => createKaiAgentClient({
-          baseUrl: serviceBaseUrl,
-          middlewares: commonMiddlewares
-        })
-      },
-      {
-        serviceId: "oauth",
-        clientName: "oauth",
-        clientFn: (serviceBaseUrl) => createOauthClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
-      }
-    ]
+    }
+  }).add({
+    serviceId: "vault",
+    clientName: "vault",
+    clientFn: (serviceBaseUrl) => createVaultClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("vault", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "data-science",
+    clientName: "dataScience",
+    clientFn: (serviceBaseUrl) => createDataScienceClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("dataScience", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "encryption",
+    clientName: "encryption",
+    clientFn: (serviceBaseUrl) => createEncryptionClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("encryption")
+    })
+  }).add({
+    serviceId: "editor",
+    clientName: "editor",
+    clientFn: (serviceBaseUrl) => createEditorClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("editor", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "sync-actions",
+    clientName: "syncActions",
+    clientFn: (serviceBaseUrl) => createSyncActionsClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("syncActions", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "telemetry",
+    clientName: "telemetry",
+    clientFn: (serviceBaseUrl) => createTelemetryClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("telemetry", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "query",
+    clientName: "queryService",
+    clientFn: (serviceBaseUrl) => createQueryServiceClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("queryService", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "queue",
+    clientName: "queue",
+    clientFn: (serviceBaseUrl) => createQueueClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("queue", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "kai-assistant",
+    clientName: "chat",
+    clientFn: (serviceBaseUrl) => createChatClient({
+      storageApiUrl: baseUrl,
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("chat", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "ai",
+    clientName: "ai",
+    clientFn: (serviceBaseUrl) => createAiClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("ai", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "import",
+    clientName: "import",
+    clientFn: (serviceBaseUrl) => createImportClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("import", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "kai-agent",
+    clientName: "kaiAgent",
+    clientFn: (serviceBaseUrl) => createKaiAgentClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("kaiAgent", commonMiddlewares)
+    })
+  }).add({
+    serviceId: "oauth",
+    clientName: "oauth",
+    clientFn: (serviceBaseUrl) => createOauthClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("oauth", commonMiddlewares)
+    })
   });
+  const { client, meta } = registry.build();
   const metastore = createMetastoreClient({
     baseUrl: metastoreBaseUrl,
-    middlewares: commonMiddlewares
+    middlewares: middlewareFor("metastore", commonMiddlewares)
   });
   const assets = createAssetsClient({
     baseUrl: assetsBaseUrl,
-    middlewares: [callbackMiddleware]
+    middlewares: middlewareFor("assets")
   });
   const status = createStatusClient({
     baseUrl: statusBaseUrl,
-    middlewares: [callbackMiddleware]
+    middlewares: middlewareFor("status")
   });
   const tag = createTagSdk({
     metastoreClient: metastore
@@ -479,6 +586,10 @@ var createClients = async ({
   const storageSdk = createStorageSdk({
     storageClient: storage
   });
+  const vault = createVaultSdk({
+    vaultClient: client.vault,
+    encryptionClient: client.encryption
+  });
   return {
     // info
     stack,
@@ -492,7 +603,8 @@ var createClients = async ({
     ...client,
     sdk: {
       tag,
-      storage: storageSdk
+      storage: storageSdk,
+      vault
     }
   };
 };
@@ -518,7 +630,10 @@ var createApiClient = () => {
 var CORRELATION_ID_HEADER = "X-Correlation-ID";
 var ALWAYS_REDACTED_HEADERS = [
   KeboolaHttpHeader.MANAGEMENT_API_TOKEN,
-  KeboolaHttpHeader.STORAGE_API_TOKEN
+  KeboolaHttpHeader.STORAGE_API_TOKEN,
+  "authorization",
+  "cookie",
+  "set-cookie"
 ];
 var ALWAYS_REDACTED_QUERY_PARAMS = /* @__PURE__ */ new Set([
   "token",
@@ -572,33 +687,51 @@ var getResponseLog = (response, redactedHeaders) => ({
   statusText: response.statusText,
   headers: getRedactedHeaders(response.headers, redactedHeaders)
 });
+var redactApiError = (error, redactedHeaders) => new ApiError({
+  request: new Request(getRedactedUrl(error.request.url), {
+    method: error.request.method,
+    headers: getRedactedHeaders(error.request.headers, redactedHeaders)
+  }),
+  response: new Response(null, {
+    status: error.response.status,
+    statusText: error.response.statusText,
+    headers: getRedactedHeaders(error.response.headers, redactedHeaders)
+  }),
+  data: error.data
+});
 var formatLog = (level, log) => {
   const parts = [`[${level.toUpperCase()}]`, `${Math.round(log.durationMs)}ms`, log.method];
   parts.push(log.request.url);
-  if (log.response) parts.push(String(log.response.status));
+  if ("response" in log) parts.push(String(log.response.status));
   return parts.join(" ");
 };
-var consoleLogger = {
-  info: (log) => console.info(formatLog("info", log)),
-  error: (log) => console.error(formatLog("error", log))
-};
-var wrapSafe = (logger, level) => ({
-  info: (log) => {
-    if (level !== "all") return;
-    try {
-      logger.info(log);
-    } catch {
-    }
-  },
-  error: (log) => {
-    try {
-      logger.error(log);
-    } catch {
+var createSafeLogger = (logger, level = "error-only") => {
+  return {
+    info: (log) => {
+      if (level !== "all") return;
+      try {
+        if (logger?.info) {
+          logger.info(log);
+          return;
+        }
+        console.info(formatLog("info", log));
+      } catch {
+      }
+    },
+    error: (log) => {
+      try {
+        if (logger?.error) {
+          logger.error(log);
+          return;
+        }
+        console.error(formatLog("error", log));
+      } catch {
+      }
     }
-  }
-});
+  };
+};
 var createLoggingMiddleware = (options = {}) => {
-  const safeLogger = wrapSafe(options.logger ?? consoleLogger, options.level ?? "error-only");
+  const safeLogger = createSafeLogger(options.logger, options.level);
   const redactHeaders = options.redactHeaders ?? [];
   return (next) => async (fetchRequest) => {
     const correlationId = ensureCorrelationId(fetchRequest.request);
@@ -616,10 +749,14 @@ var createLoggingMiddleware = (options = {}) => {
       });
       return result;
     } catch (error) {
-      const durationMs = performance.now() - start;
-      if (error instanceof Error) {
-        safeLogger.error({ correlationId, method, durationMs, request: requestLog, error });
-      }
+      if (error instanceof Error)
+        safeLogger.error({
+          correlationId,
+          method,
+          durationMs: performance.now() - start,
+          request: requestLog,
+          error: isApiError(error) ? redactApiError(error, redactHeaders) : error
+        });
       throw error;
     }
   };
@@ -668,6 +805,6 @@ var createDevApiClient = () => ({
   verify: createVerifyClient()
 });
 
-export { ServiceUnavailableError, assert, consoleLogger, createApiClient, createDevApiClient, createLoggingMiddleware, createRetryMiddleware };
+export { ServiceUnavailableError, assert, coalesce, createApiClient, createDevApiClient, createLoggingMiddleware, createRetryMiddleware, createStore };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map