@keboola/api-client 0.1.0 → 1.0.1

package/dist/index.cjs

@@ -71,6 +71,25 @@ var ServiceUnavailableError = class _ServiceUnavailableError extends Error {
     Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
   }
 };
+
+// src/constants.ts
+var KeboolaHttpHeader = {
+  STORAGE_API_TOKEN: "X-StorageApi-Token",
+  MANAGEMENT_API_TOKEN: "X-Kbc-Manageapitoken",
+  STORAGE_API_URL: "x-storageapi-url"
+};
+var HttpStatus = {
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+var ENCRYPTED_VALUE_PREFIX = "KBC::";
+
+// src/fetchClient/createFetchClient/utils.ts
 var HttpHeader = {
   CONTENT_TYPE: "content-type",
   CONTENT_DISPOSITION: "content-disposition"
@@ -90,7 +109,7 @@ function removeUndefined(obj) {
   return objCopy;
 }
 var parseData = async (response) => {
-  if (response.status === 204) return null;
+  if (response.status === HttpStatus.NO_CONTENT) return null;
   const contentType = response.headers.get(HttpHeader.CONTENT_TYPE);
   if (contentType && contentType == HttpContentType.JSON) {
     return response.json();
@@ -310,14 +329,6 @@ var createAssetsClient = ({ baseUrl, middlewares }) => {
     getPublishedChangelogPosts
   };
 };
-
-// src/constants.ts
-var KeboolaHttpHeader = {
-  STORAGE_API_TOKEN: "X-StorageApi-Token",
-  MANAGEMENT_API_TOKEN: "X-Kbc-Manageapitoken",
-  STORAGE_API_URL: "x-storageapi-url"
-};
-var ENCRYPTED_VALUE_PREFIX = "KBC::";
 var SUGGESTION_CATEGORIES = ["error", "maintenance", "documentation"];
 var suggestionCategorySchema = z5.z.enum(SUGGESTION_CATEGORIES);
 var suggestionSchema = z5.z.object({
@@ -718,7 +729,7 @@ var createDataScienceClient = ({ baseUrl, middlewares }) => {
         nextLogTimestamp
       };
     } catch (error) {
-      if (isApiError(error) && error.response.status === 400 && TailError.safeParse(error.data).data?.context?.code === "apps.appNotRunning") {
+      if (isApiError(error) && error.response.status === HttpStatus.BAD_REQUEST && TailError.safeParse(error.data).data?.context?.code === "apps.appNotRunning") {
         return { entries: [], nextLogTimestamp: null };
       }
       throw error;
@@ -861,14 +872,6 @@ var createEditorClient = ({ baseUrl, middlewares }) => {
     });
     return data;
   };
-  const getWorkspacePassword = async (id, signal) => {
-    const { data } = await client.get(
-      `/sql/sessions/{id}/workspace-password`,
-      { path: { id } },
-      { signal }
-    );
-    return data;
-  };
   const resetWorkspacePassword = async (id) => {
     const { data } = await client.post(`/sql/sessions/{id}/reset-password`, {
       path: { id }
@@ -893,7 +896,6 @@ var createEditorClient = ({ baseUrl, middlewares }) => {
     tableDefinition,
     load,
     unload,
-    getWorkspacePassword,
     resetWorkspacePassword,
     getSessionCredentials
   };
@@ -985,6 +987,24 @@ var toolInfoSchema2 = z5.z.object({
 var toolsListResponseSchema2 = z5.z.object({
   tools: z5.z.array(toolInfoSchema2)
 });
+var sandboxFileEntrySchema = z5.z.object({
+  name: z5.z.string(),
+  path: z5.z.string(),
+  type: z5.z.enum(["file", "dir"]),
+  size: z5.z.number().int().nonnegative().optional()
+});
+var sandboxFileListingSchema = z5.z.object({
+  entries: z5.z.array(sandboxFileEntrySchema)
+});
+var sandboxFileContentSchema = z5.z.object({
+  content: z5.z.string(),
+  encoding: z5.z.enum(["utf-8", "binary"]),
+  truncated: z5.z.boolean(),
+  size: z5.z.number().int().nonnegative()
+});
+var sandboxGitBranchSchema = z5.z.object({
+  branch: z5.z.string().nullable()
+});
 var createKaiAgentClient = ({ baseUrl, middlewares }) => {
   const clientOptions = { baseUrl, middlewares };
   const client = createOpenapiFetchClient(clientOptions);
@@ -1022,6 +1042,10 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
   const submitToolOutput = async (chatId, body) => {
     await client.post("/api/chat/{id}/ui-tool-result", { path: { id: chatId }, body });
   };
+  const stopChat = async (chatId) => {
+    const { data } = await client.post("/api/chat/{id}/stop", { path: { id: chatId } });
+    return data;
+  };
   const getSuggestions = async (request, signal) => {
     const { data } = await genericClient.post(
       "/api/suggestions",
@@ -1090,6 +1114,42 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
     }
     return result.data;
   };
+  const listSandboxFiles = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
+      { query: path ? { path } : void 0 },
+      { signal }
+    );
+    const result = sandboxFileListingSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox files response format");
+    }
+    return result.data;
+  };
+  const readSandboxFile = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/file`,
+      { query: { path } },
+      { signal }
+    );
+    const result = sandboxFileContentSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox file response format");
+    }
+    return result.data;
+  };
+  const getSandboxGitBranch = async (chatId, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`,
+      {},
+      { signal }
+    );
+    const result = sandboxGitBranchSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox git-branch response format");
+    }
+    return result.data;
+  };
   const chatStreamUrl = baseUrl + "/api/chat";
   return {
     getHistory,
@@ -1101,12 +1161,16 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
     getUsage,
     approveToolCall,
     submitToolOutput,
+    stopChat,
     getSuggestions,
     getAgentSettings,
     updateAgentSettings,
     getUserAgentSettings,
     updateUserAgentSettings,
     getToolsList,
+    listSandboxFiles,
+    readSandboxFile,
+    getSandboxGitBranch,
     chatStreamUrl
   };
 };
@@ -1134,6 +1198,7 @@ var createVerifyClient = () => {
 };
 
 // src/clients/management/authMiddleware.ts
+var TOKEN_CACHE_TTL_MS = 6e4;
 var isManagementClientAuthError = (error) => error instanceof ManagementClientAuthError;
 var createAuth = (baseUrl) => {
   const fetchClient = createGenericFetchClient({ baseUrl });
@@ -1179,18 +1244,34 @@ var createAuthMiddleware = ({
   const auth = createAuth(baseUrl);
   const verify = createVerifyClient();
   let token = accessToken;
+  let tokenValidUntil = 0;
+  let inflightAuth = null;
   const isDevelopment = process.env.NODE_ENV === "development";
-  return (next) => async (request) => {
-    if (!!token) {
+  const ensureValidToken = async () => {
+    if (token && Date.now() < tokenValidUntil) return token;
+    if (token) {
       const tokenInfo = await verify.managementApiToken(baseUrl, token);
       const isTokenValid = !tokenInfo.isDisabled && !tokenInfo.isExpired;
-      if (!isTokenValid) {
-        token = isDevelopment ? await auth.createCurrentUserSessionToken(token) : await auth.createAdminAccountSessionToken();
+      if (isTokenValid) {
+        tokenValidUntil = Date.now() + TOKEN_CACHE_TTL_MS;
+        return token;
       }
-    } else {
-      token = await auth.createAdminAccountSessionToken();
+      token = isDevelopment ? await auth.createCurrentUserSessionToken(token) : await auth.createAdminAccountSessionToken();
+      tokenValidUntil = Date.now() + TOKEN_CACHE_TTL_MS;
+      return token;
+    }
+    token = await auth.createAdminAccountSessionToken();
+    tokenValidUntil = Date.now() + TOKEN_CACHE_TTL_MS;
+    return token;
+  };
+  return (next) => async (request) => {
+    if (!inflightAuth) {
+      inflightAuth = ensureValidToken().finally(() => {
+        inflightAuth = null;
+      });
     }
-    request.request.headers.set(KeboolaHttpHeader.MANAGEMENT_API_TOKEN, token);
+    const validToken = await inflightAuth;
+    request.request.headers.set(KeboolaHttpHeader.MANAGEMENT_API_TOKEN, validToken);
     return next(request);
   };
 };
@@ -1394,14 +1475,6 @@ var createMaintainers = (client) => {
       path: { id: maintainerId, invitationId }
     });
   };
-  const getMaintainerOrganizations = async (maintainerId, signal) => {
-    const { data } = await client.get(
-      "/manage/maintainers/{id}/organizations",
-      { path: { id: maintainerId } },
-      { signal }
-    );
-    return data;
-  };
   const createMaintainerOrganization = async ({
     maintainerId,
     ...body
@@ -1451,7 +1524,6 @@ var createMaintainers = (client) => {
     getMaintainerInvitation,
     createMaintainerInvitation,
     deleteMaintainerInvitation,
-    getMaintainerOrganizations,
     createMaintainerOrganization,
     getMaintainerMetadata,
     setMaintainerMetadata,
@@ -1773,13 +1845,18 @@ var createManagementClient = ({
     baseUrl,
     middlewares
   });
+  const verifyToken = async (signal) => {
+    const { data } = await openApiClient.get("/manage/tokens/verify", {}, { signal });
+    return data;
+  };
   return {
     currentUser: createCurrentUser(openApiClient),
     features: createFeatures(client),
     maintainers: createMaintainers(openApiClient),
     organizations: createOrganizations(openApiClient),
     projects: createProjects(client),
-    users: createUsers(client)
+    users: createUsers(client),
+    verifyToken
   };
 };
 
@@ -1959,6 +2036,72 @@ var createMetastoreClient = ({ baseUrl, middlewares }) => {
   };
 };
 
+// src/clients/oauth/oauthClient.ts
+var createOauthClient = ({ baseUrl, middlewares }) => {
+  const client = createGenericFetchClient({ baseUrl, middlewares });
+  const getCredentials = async (query, signal) => {
+    const { data } = await client.get(
+      "/credentials",
+      { query },
+      { signal }
+    );
+    return data;
+  };
+  const getCredential = async (componentId, id, signal) => {
+    const { data } = await client.get(
+      "/credentials/{componentId}/{id}",
+      { path: { componentId, id } },
+      { signal }
+    );
+    return data;
+  };
+  const _createCredentials = async (componentId, body, signal) => {
+    const { data } = await client.post(
+      "/credentials/{componentId}",
+      { path: { componentId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const _createLegacyCredentials = async (componentId, { data: credentialsData, ...rest }, signal) => {
+    const { data } = await client.post(
+      "/credentials/{componentId}",
+      {
+        path: { componentId },
+        body: {
+          ...rest,
+          "#data": JSON.stringify(credentialsData)
+        }
+      },
+      { signal }
+    );
+    return data;
+  };
+  const createCredential = async (componentId, body, signal) => {
+    try {
+      return await _createCredentials(componentId, body, signal);
+    } catch (error) {
+      if (isApiError(error) && error.response.status === HttpStatus.UNPROCESSABLE_ENTITY) {
+        return _createLegacyCredentials(componentId, body, signal);
+      }
+      throw error;
+    }
+  };
+  const deleteCredential = async (componentId, id, signal) => {
+    await client.delete(
+      "/credentials/{componentId}/{id}",
+      { path: { componentId, id } },
+      { signal }
+    );
+  };
+  return {
+    getCredentials,
+    getCredential,
+    createCredential,
+    deleteCredential
+  };
+};
+
 // src/clients/queryService/queryServiceClient.ts
 var createQueryServiceClient = ({ baseUrl, middlewares }) => {
   const client = createOpenapiFetchClient({
@@ -2114,7 +2257,6 @@ var createMergeRequests = (client) => {
   const getMergeRequestWithActivityLog = async (id, signal) => {
     const { data } = await client.get(
       "/v2/storage/merge-request/{id}",
-      // @ts-expect-error backend accepts `?include=activityLog`; OpenAPI schema regen pending (connection#7250).
       { path: { id }, query: { include: "activityLog" } },
       { signal }
     );
@@ -2146,11 +2288,18 @@ var createMergeRequests = (client) => {
   const requestChangesMergeRequest = async (id, reason) => {
     const { data } = await client.put("/v2/storage/merge-request/{id}/request-changes", {
       path: { id },
-      // @ts-expect-error backend accepts optional `{ reason }` body; OpenAPI schema regen pending (connection#7250).
       body: reason ? { reason } : void 0
     });
     return data;
   };
+  const getMergeRequestConflicts = async (id, signal) => {
+    const { data } = await client.get(
+      "/v2/storage/merge-request/{id}/conflicts",
+      { path: { id } },
+      { signal }
+    );
+    return data;
+  };
   return {
     getMergeRequests,
     getMergeRequest,
@@ -2159,7 +2308,8 @@ var createMergeRequests = (client) => {
     updateMergeRequest,
     requestReview,
     approveMergeRequest,
-    requestChangesMergeRequest
+    requestChangesMergeRequest,
+    getMergeRequestConflicts
   };
 };
 
@@ -2240,6 +2390,30 @@ var createBranches = (client) => {
   };
 };
 
+// src/clients/storage/buckets/listingConversion.ts
+var toBackendSubscribers = (subscribers) => subscribers.map((s) => `${s.type}:${s.email}`);
+var fromBackendSubscribers = (raw) => {
+  const result = [];
+  for (const entry of raw) {
+    const colon = entry.indexOf(":");
+    if (colon === -1) continue;
+    const prefix = entry.slice(0, colon);
+    const email2 = entry.slice(colon + 1);
+    if (prefix !== "user" && prefix !== "group") continue;
+    if (email2.length === 0) continue;
+    result.push({ type: prefix, email: email2 });
+  }
+  return result;
+};
+var toBucketListing = (raw, bucketId) => ({
+  bucketId,
+  name: raw.name,
+  description: raw.description ?? null,
+  listingId: raw.bigquery.listingId,
+  subscribers: fromBackendSubscribers(raw.bigquery.subscribers),
+  createdAt: raw.createdAt
+});
+
 // src/clients/storage/buckets/buckets.ts
 var createBuckets = (client) => {
   const getBuckets = async (query = {}, signal) => {
@@ -2291,6 +2465,64 @@ var createBuckets = (client) => {
       path: { taskId }
     });
   };
+  const getListing = async (bucketId, signal) => {
+    try {
+      const { data } = await client.get(
+        `/buckets/{bucketId}/listing`,
+        { path: { bucketId } },
+        { signal }
+      );
+      return toBucketListing(data, bucketId);
+    } catch (error) {
+      if (isApiError(error) && error.response.status === 404) return null;
+      throw error;
+    }
+  };
+  const createListing = async (bucketId, input, signal) => {
+    const { data } = await client.post(
+      `/buckets/{bucketId}/listing`,
+      {
+        path: { bucketId },
+        body: {
+          listingName: input.name,
+          listingDescription: input.description?.trim() || null,
+          bigquery: {
+            listingId: input.listingId,
+            subscribers: toBackendSubscribers(input.subscribers)
+          }
+        }
+      },
+      { signal }
+    );
+    return data;
+  };
+  const updateListing = async (bucketId, input, signal) => {
+    const body = {};
+    if (input.name !== void 0) body.exposureName = input.name;
+    if (input.description !== void 0) {
+      body.exposureDescription = input.description?.trim() || null;
+    }
+    if (input.subscribers !== void 0) {
+      body.bigquery = { subscribers: toBackendSubscribers(input.subscribers) };
+    }
+    if (Object.keys(body).length === 0) {
+      throw new Error("updateListing requires at least one field");
+    }
+    const { data } = await client.patch(`/buckets/{bucketId}/listing`, { path: { bucketId }, body }, { signal });
+    return data;
+  };
+  const deleteListing = async (bucketId, signal) => {
+    const { data } = await client.delete(
+      `/buckets/{bucketId}/listing`,
+      { path: { bucketId } },
+      { signal }
+    );
+    return data;
+  };
+  const listListings = async (signal) => {
+    const { data } = await client.get(`/listings`, {}, { signal });
+    return data.map((row) => toBucketListing(row, row.bucketId));
+  };
   return {
     getBuckets,
     getBucket,
@@ -2299,7 +2531,12 @@ var createBuckets = (client) => {
     deleteBucket,
     deleteBucketAsync,
     createScheduledRefresh,
-    deleteScheduledTask
+    deleteScheduledTask,
+    getListing,
+    createListing,
+    updateListing,
+    deleteListing,
+    listListings
   };
 };
 
@@ -3366,10 +3603,29 @@ var createStorageSdk = ({ storageClient }) => {
     const job = await storageClient.tables.exportAsync(tableId, body, options?.abortSignal);
     return waitForJob(job, options);
   };
+  const getBucketListing = async (bucketId, signal) => storageClient.buckets.getListing(bucketId, signal);
+  const listBucketListings = async (signal) => storageClient.buckets.listListings(signal);
+  const createBucketListing = async (bucketId, input, options) => {
+    const job = await storageClient.buckets.createListing(bucketId, input, options?.abortSignal);
+    return waitForJob(job, options);
+  };
+  const updateBucketListing = async (bucketId, input, options) => {
+    const job = await storageClient.buckets.updateListing(bucketId, input, options?.abortSignal);
+    return waitForJob(job, options);
+  };
+  const deleteBucketListing = async (bucketId, options) => {
+    const job = await storageClient.buckets.deleteListing(bucketId, options?.abortSignal);
+    return waitForJob(job, options);
+  };
   return {
     createTable,
     importFromFile,
-    exportToFile
+    exportToFile,
+    getBucketListing,
+    listBucketListings,
+    createBucketListing,
+    updateBucketListing,
+    deleteBucketListing
   };
 };
 
@@ -3674,6 +3930,11 @@ var createClients = async ({
           baseUrl: serviceBaseUrl,
           middlewares: commonMiddlewares
         })
+      },
+      {
+        serviceId: "oauth",
+        clientName: "oauth",
+        clientFn: (serviceBaseUrl) => createOauthClient({ baseUrl: serviceBaseUrl, middlewares: commonMiddlewares })
       }
     ]
   });
@@ -3843,7 +4104,12 @@ var createLoggingMiddleware = (options = {}) => {
 
 // src/middlewares/retryMiddleware.ts
 var DEFAULT_MAX_RETRIES = 5;
-var DEFAULT_RETRYABLE_STATUSES = [500, 502, 503, 504];
+var DEFAULT_RETRYABLE_STATUSES = [
+  HttpStatus.INTERNAL_SERVER_ERROR,
+  HttpStatus.BAD_GATEWAY,
+  HttpStatus.SERVICE_UNAVAILABLE,
+  HttpStatus.GATEWAY_TIMEOUT
+];
 var DEFAULT_BACKOFF_FACTOR = 0.3;
 var defaultShouldRetry = (error) => error instanceof ApiError && DEFAULT_RETRYABLE_STATUSES.includes(error.response.status);
 var createRetryMiddleware = (options) => {