@keboola/api-client 3.0.1 → 5.0.0

package/dist/index.js

@@ -1,36 +1,40 @@
+import { delay, createStorageSdk } from './chunk-KQ2QNGRX.js';
+export { PollException, createStorageSdk, delay, poll } from './chunk-KQ2QNGRX.js';
 import { createProject } from './chunk-UABYNGBZ.js';
+import { createStorageTable } from './chunk-ZOREOLGE.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-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 { createSyncActionsClient } from './chunk-6DPZQRNC.js';
+import { createTelemetryClient } from './chunk-S7HIK7XY.js';
+import { createVaultClient } from './chunk-YH52X52J.js';
+export { UserError } from './chunk-YH52X52J.js';
+import { createManagementClient } from './chunk-MUQ7TAWH.js';
+export { ManagementClientAuthError, isManagementClientAuthError } from './chunk-MUQ7TAWH.js';
+import { createVerifyClient } from './chunk-7PPUK4HS.js';
+import { createMetastoreClient } from './chunk-7JOV7PXU.js';
+import { createOauthClient } from './chunk-Y3RILILK.js';
+import { createQueryServiceClient } from './chunk-UT3GUUCO.js';
+import { createQueueClient } from './chunk-JKXQFEY7.js';
+import { createStatusClient } from './chunk-2NLVV2MF.js';
 import './chunk-7J2R6XHB.js';
-import { createStorageTokenMiddleware, createStorageClient } from './chunk-T66CY2YX.js';
-export { series } from './chunk-T66CY2YX.js';
+import { createStorageClient } from './chunk-4NUA46VD.js';
+export { series } from './chunk-4NUA46VD.js';
 export { concurrent } from './chunk-EBCZUGUX.js';
-import { createSyncActionsClient } from './chunk-M4PFR3OS.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-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 { createStreamClient } from './chunk-OJJ3QLZP.js';
+import { createAiClient } from './chunk-4IBEYSSA.js';
+import { createAssetsClient } from './chunk-XRHAE4SD.js';
+import { createChatClient } from './chunk-2CTHLPTU.js';
+import './chunk-4RC5E3SL.js';
+import { createDataScienceClient } from './chunk-4FU45NEU.js';
+export { parseLogLines } from './chunk-4FU45NEU.js';
+import { createEditorClient } from './chunk-EDDRN2CO.js';
+import { createEncryptionClient } from './chunk-65YXOZDQ.js';
+import { createImportClient } from './chunk-5XADEX3R.js';
+import { isApiError, ApiError, createOpenapiFetchClient, createGenericFetchClient } from './chunk-XI6R76X3.js';
+export { ApiError, HttpContentType, HttpHeader, createGenericFetchClient, isAbortError, isApiError, isFetchClientError } from './chunk-XI6R76X3.js';
+import { KeboolaHttpHeader, HttpStatus, ProjectFeatures } from './chunk-FL54VJ35.js';
+export { KeboolaHttpHeader } from './chunk-FL54VJ35.js';
 import { z } from 'zod';
 
 // src/errors/ServiceUnavailableError.ts
@@ -66,6 +70,19 @@ var toolInfoSchema = z.object({
 var toolsListResponseSchema = z.object({
   tools: z.array(toolInfoSchema)
 });
+var skillInfoSchema = z.object({
+  name: z.string(),
+  description: z.string().nullable(),
+  source: z.enum(["first-party", "vendored", "project"])
+});
+var builtInCommandSchema = z.object({
+  name: z.string(),
+  description: z.string()
+});
+var skillsListResponseSchema = z.object({
+  skills: z.array(skillInfoSchema),
+  commands: z.array(builtInCommandSchema)
+});
 var sandboxFileEntrySchema = z.object({
   name: z.string(),
   path: z.string(),
@@ -84,8 +101,12 @@ var sandboxFileContentSchema = z.object({
 var sandboxGitBranchSchema = z.object({
   branch: z.string().nullable()
 });
-var createKaiAgentClient = ({ baseUrl, middlewares }) => {
-  const clientOptions = { baseUrl, middlewares };
+var createKaiAgentClient = ({ baseUrl, middlewares, token }) => {
+  const clientOptions = {
+    baseUrl,
+    middlewares,
+    headers: { [KeboolaHttpHeader.STORAGE_API_TOKEN]: token }
+  };
   const client = createOpenapiFetchClient(clientOptions);
   const genericClient = createGenericFetchClient(clientOptions);
   const getHistory = async (params) => {
@@ -126,16 +147,8 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
     return data;
   };
   const getSuggestions = async (request, signal) => {
-    const { data } = await genericClient.post(
-      "/api/suggestions",
-      { body: request },
-      { signal }
-    );
-    const result = suggestionsApiResponseSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid suggestions response format");
-    }
-    return result.data;
+    const { data } = await client.post("/api/suggestions", { body: request }, { signal });
+    return data;
   };
   const getAgentSettings = async (signal) => {
     const { data } = await genericClient.get("/api/settings", {}, { signal });
@@ -193,6 +206,14 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
     }
     return result.data;
   };
+  const getSkillsList = async (signal) => {
+    const { data } = await genericClient.get("/api/skills", {}, { signal });
+    const result = skillsListResponseSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid skills list response format");
+    }
+    return result.data;
+  };
   const listSandboxFiles = async (chatId, path, signal) => {
     const { data } = await genericClient.get(
       `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
@@ -247,6 +268,7 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
     getUserAgentSettings,
     updateUserAgentSettings,
     getToolsList,
+    getSkillsList,
     listSandboxFiles,
     readSandboxFile,
     getSandboxGitBranch,
@@ -262,29 +284,26 @@ function assert(value, message) {
 }
 
 // src/utils/coalesce.ts
-var coalesce = (task, onError) => {
+var coalesce = (task) => {
   let running = false;
-  let pending = false;
-  return () => {
-    if (running) {
-      pending = true;
-      return;
-    }
+  const waiters = [];
+  const drain = async () => {
     running = true;
-    void (async () => {
-      try {
-        do {
-          pending = false;
-          try {
-            await task();
-          } catch (error) {
-            onError?.(error);
-          }
-        } while (pending);
-      } finally {
-        running = false;
-      }
-    })();
+    const batch = waiters.splice(0);
+    try {
+      const result = await task();
+      batch.forEach((waiter) => waiter.resolve(result));
+    } catch (error) {
+      batch.forEach((waiter) => waiter.reject(error));
+    }
+    if (waiters.length > 0) return drain();
+    running = false;
+  };
+  return () => {
+    const waiter = Promise.withResolvers();
+    waiters.push(waiter);
+    if (!running) void drain();
+    return waiter.promise;
   };
 };
 
@@ -307,6 +326,52 @@ var createStore = (initial) => {
     }
   };
 };
+var isPlainObjectOrArray = (value) => {
+  if (Array.isArray(value)) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var shallowEqual = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+  if (!isPlainObjectOrArray(a) || !isPlainObjectOrArray(b)) return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  return aKeys.length === bKeys.length && aKeys.every((key) => Object.is(a[key], b[key]));
+};
+var createDerivedStore = ({
+  source,
+  dependsOn,
+  build,
+  keyEquals = shallowEqual
+}) => {
+  let key = dependsOn(source.get());
+  const store = createStore(build(key));
+  source.subscribe((state) => {
+    const next = dependsOn(state);
+    if (keyEquals(key, next)) return;
+    key = next;
+    store.set(build(next));
+  });
+  return { get: store.get, subscribe: store.subscribe };
+};
+
+// src/domain/defaultBranch.ts
+var createDefaultBranch = ({ devBranches }) => {
+  const defaultBranch = devBranches.find((branch) => branch.isDefault);
+  assert(defaultBranch, "No default branch found for the project.");
+  const getType = (branchId) => {
+    if (branchId == null || branchId === "default") return "default";
+    return Number(branchId) === defaultBranch.id ? "default" : "dev";
+  };
+  return {
+    id: defaultBranch.id,
+    name: defaultBranch.name,
+    getType,
+    isDev: (branchId) => getType(branchId) === "dev",
+    isDefault: (branchId) => getType(branchId) === "default"
+  };
+};
 
 // src/domain/stack.ts
 var SERVICE_URL_OVERRIDES = {
@@ -381,10 +446,8 @@ var createDummyClient = ({
 // src/serviceClientRegistry/createServiceClientRegistry.ts
 var createServiceClientRegistry = () => ({
   getServiceBaseUrl,
-  onUnavailable,
-  meta
+  onUnavailable
 }) => {
-  let metaValue = meta ?? {};
   const dummy = (serviceId, clientName) => createDummyClient({
     onCall: (path, args) => {
       onUnavailable?.({
@@ -402,16 +465,15 @@ var createServiceClientRegistry = () => ({
     clientName
   }) => {
     const serviceBaseUrl = getServiceBaseUrl(serviceId);
-    return serviceBaseUrl ? clientFn(serviceBaseUrl, metaValue) : dummy(serviceId, clientName);
+    return serviceBaseUrl ? clientFn(serviceBaseUrl) : dummy(serviceId, clientName);
   };
-  let clientMap = null;
   const registry = {
     add: (config) => {
       configs.push(config);
       return registry;
     },
     build: () => {
-      clientMap = {};
+      const clientMap = {};
       const clientMeta = [];
       configs.forEach((config) => {
         clientMap[config.clientName] = resolveClient(config);
@@ -425,21 +487,49 @@ var createServiceClientRegistry = () => ({
         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 createAttachTokenMiddleware = (getToken) => (next) => (request) => {
+  request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, getToken());
+  return next(request);
+};
+var STORAGE_TOKEN_MUTATING_PATTERNS = [
+  // Bucket lifecycle (create / delete / register) — changes token.bucketPermissions.
+  // At most one trailing segment, so sub-resources (tables, listing, metadata, refresh)
+  // under /buckets/{id}/... don't trigger a re-verify.
+  /\/buckets(\/[^/]+)?$/,
+  // Project feature toggles — changes token.owner.features. Anchored to
+  // /projects/{id}/features so /manage/features and /users/{id}/features don't match.
+  /\/projects\/[^/]+\/features(\/[^/]+)?$/
+];
+var isStorageTokenMutatingRequest = (request) => {
+  if (request.method === "GET") return false;
+  const { pathname } = new URL(request.url);
+  return STORAGE_TOKEN_MUTATING_PATTERNS.some((pattern) => pattern.test(pathname));
+};
+var createProjectRefreshMiddleware = (shouldRefresh, requestRefresh) => (next) => async (request) => {
+  const response = await next(request);
+  if (shouldRefresh(request.request)) await requestRefresh();
+  return response;
+};
+var createLiveProject = ({
+  initialToken,
+  verify
+}) => {
+  const store = createStore(createProject({ sapiToken: initialToken }));
+  const refresh = coalesce(async () => store.set(createProject({ sapiToken: await verify() })));
+  const middleware = createProjectRefreshMiddleware(isStorageTokenMutatingRequest, refresh);
+  return { store, getProject: () => store.get(), subscribe: store.subscribe, middleware };
+};
+var createLiveToken = ({ initialToken }) => {
+  const store = createStore(initialToken);
+  const attachTokenMiddleware = createAttachTokenMiddleware(() => store.get());
+  return { attachTokenMiddleware, set: store.set };
+};
 var createClients = async ({
   baseUrl,
   token,
@@ -449,27 +539,45 @@ var createClients = async ({
   clientServiceUrls,
   middlewares
 }) => {
-  const storageTokenMiddleware = createStorageTokenMiddleware(token.storageApi);
-  const commonMiddlewares = [storageTokenMiddleware];
   const middlewareFor = createMiddlewareFor(middlewares);
+  const liveToken = createLiveToken({ initialToken: token.storageApi });
+  const _storage = createStorageClient({
+    baseUrl,
+    token: token.storageApi,
+    middlewares: [liveToken.attachTokenMiddleware]
+  });
+  const [stackInfo, sapiToken, devBranches] = await Promise.all([
+    _storage.getStackInfo({ exclude: "componentDetails" }),
+    _storage.tokens.verify(),
+    _storage.branches.getDevBranches()
+  ]);
+  const stack = createStack({ stackInfo, clientServiceUrls });
+  const defaultBranch = createDefaultBranch({ devBranches });
+  const liveProject = createLiveProject({
+    initialToken: sapiToken,
+    verify: () => _storage.tokens.verify()
+  });
+  const storageTableStore = createDerivedStore({
+    source: liveProject.store,
+    build: createStorageTable,
+    dependsOn: (project) => ({
+      useLegacyBucketPrefix: !project.hasFeature(ProjectFeatures.DISABLE_LEGACY_BUCKET_PREFIX),
+      hasProtectedDefaultBranch: project.hasFeature(ProjectFeatures.SOX_PROTECTED_DEFAULT_BRANCH),
+      hasStorageBranches: project.hasFeature(ProjectFeatures.STORAGE_BRANCHES)
+    })
+  });
   const storage = createStorageClient({
     baseUrl,
-    middlewares: middlewareFor("storage", commonMiddlewares)
+    token: token.storageApi,
+    middlewares: middlewareFor("storage", [liveProject.middleware]),
+    onRefreshToken: liveToken.set
   });
   const management = createManagementClient({
     baseUrl,
     token: token.managementApi,
-    middlewares: middlewareFor("management", [])
+    middlewares: middlewareFor("management", [liveProject.middleware])
   });
-  const [stackInfo, sapiToken] = await Promise.all([
-    storage.getStackInfo({
-      exclude: "componentDetails"
-    }),
-    storage.tokens.verify()
-  ]);
-  const stack = createStack({ stackInfo, clientServiceUrls });
-  const project = createProject({ sapiToken });
-  const registry = createServiceClientRegistry()({
+  const { client, meta } = createServiceClientRegistry()({
     getServiceBaseUrl: (serviceId) => stack.getServiceUrl(serviceId),
     onUnavailable: ({ serviceId, path, clientName }) => {
       throw new ServiceUnavailableError(serviceId, path, clientName);
@@ -479,14 +587,16 @@ var createClients = async ({
     clientName: "vault",
     clientFn: (serviceBaseUrl) => createVaultClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("vault", commonMiddlewares)
+      middlewares: middlewareFor("vault", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "data-science",
     clientName: "dataScience",
     clientFn: (serviceBaseUrl) => createDataScienceClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("dataScience", commonMiddlewares)
+      middlewares: middlewareFor("dataScience", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "encryption",
@@ -500,35 +610,40 @@ var createClients = async ({
     clientName: "editor",
     clientFn: (serviceBaseUrl) => createEditorClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("editor", commonMiddlewares)
+      middlewares: middlewareFor("editor", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "sync-actions",
     clientName: "syncActions",
     clientFn: (serviceBaseUrl) => createSyncActionsClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("syncActions", commonMiddlewares)
+      middlewares: middlewareFor("syncActions", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "telemetry",
     clientName: "telemetry",
     clientFn: (serviceBaseUrl) => createTelemetryClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("telemetry", commonMiddlewares)
+      middlewares: middlewareFor("telemetry", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "query",
     clientName: "queryService",
     clientFn: (serviceBaseUrl) => createQueryServiceClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("queryService", commonMiddlewares)
+      middlewares: middlewareFor("queryService", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "queue",
     clientName: "queue",
     clientFn: (serviceBaseUrl) => createQueueClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("queue", commonMiddlewares)
+      middlewares: middlewareFor("queue", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "kai-assistant",
@@ -536,41 +651,54 @@ var createClients = async ({
     clientFn: (serviceBaseUrl) => createChatClient({
       storageApiUrl: baseUrl,
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("chat", commonMiddlewares)
+      middlewares: middlewareFor("chat", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "ai",
     clientName: "ai",
     clientFn: (serviceBaseUrl) => createAiClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("ai", commonMiddlewares)
+      middlewares: middlewareFor("ai", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "import",
     clientName: "import",
     clientFn: (serviceBaseUrl) => createImportClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("import", commonMiddlewares)
+      middlewares: middlewareFor("import", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "kai-agent",
     clientName: "kaiAgent",
     clientFn: (serviceBaseUrl) => createKaiAgentClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("kaiAgent", commonMiddlewares)
+      middlewares: middlewareFor("kaiAgent", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
   }).add({
     serviceId: "oauth",
     clientName: "oauth",
     clientFn: (serviceBaseUrl) => createOauthClient({
       baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("oauth", commonMiddlewares)
+      middlewares: middlewareFor("oauth", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
     })
-  });
-  const { client, meta } = registry.build();
+  }).add({
+    serviceId: "stream",
+    clientName: "stream",
+    clientFn: (serviceBaseUrl) => createStreamClient({
+      baseUrl: serviceBaseUrl,
+      middlewares: middlewareFor("stream", [liveToken.attachTokenMiddleware]),
+      token: token.storageApi
+    })
+  }).build();
   const metastore = createMetastoreClient({
     baseUrl: metastoreBaseUrl,
-    middlewares: middlewareFor("metastore", commonMiddlewares)
+    middlewares: middlewareFor("metastore", [liveToken.attachTokenMiddleware]),
+    token: token.storageApi
   });
   const assets = createAssetsClient({
     baseUrl: assetsBaseUrl,
@@ -590,11 +718,19 @@ var createClients = async ({
     vaultClient: client.vault,
     encryptionClient: client.encryption
   });
-  return {
-    // info
+  const context = {
     stack,
-    project,
-    serviceMeta: meta,
+    defaultBranch,
+    get project() {
+      return liveProject.getProject();
+    },
+    get st() {
+      return storageTableStore.get();
+    },
+    serviceMeta: meta
+  };
+  return {
+    context,
     // clients
     storage,
     assets,
@@ -805,6 +941,6 @@ var createDevApiClient = () => ({
   verify: createVerifyClient()
 });
 
-export { ServiceUnavailableError, assert, coalesce, createApiClient, createDevApiClient, createLoggingMiddleware, createRetryMiddleware, createStore };
+export { ServiceUnavailableError, assert, coalesce, createApiClient, createDerivedStore, createDevApiClient, createLiveProject, createLoggingMiddleware, createRetryMiddleware, createStore, isStorageTokenMutatingRequest, shallowEqual };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map