@keboola/api-client 4.0.0 → 6.0.0

package/dist/{chunk-7NX56CKZ.js → chunk-QEQAZPWM.js}

@@ -1,5 +1,6 @@
 import { concurrent } from './chunk-EBCZUGUX.js';
-import { createGenericFetchClient, createOpenapiFetchClient, KeboolaHttpHeader, isApiError } from './chunk-QXWPUKK2.js';
+import { createGenericFetchClient, createOpenapiFetchClient, isApiError } from './chunk-D2SWTZFS.js';
+import { KeboolaHttpHeader } from './chunk-SI5TFV5M.js';
 
 // src/clients/storage/configurationVersions/configurationVersions.ts
 var createConfigurationVersions = (client) => {
@@ -77,6 +78,12 @@ var createMergeRequests = (client) => {
     });
     return data;
   };
+  const mergeMergeRequest = async (id) => {
+    const { data } = await client.put("/v2/storage/merge-request/{id}/merge", {
+      path: { id }
+    });
+    return data;
+  };
   const getMergeRequestConflicts = async (id, signal) => {
     const { data } = await client.get(
       "/v2/storage/merge-request/{id}/conflicts",
@@ -94,6 +101,7 @@ var createMergeRequests = (client) => {
     requestReview,
     approveMergeRequest,
     requestChangesMergeRequest,
+    mergeMergeRequest,
     getMergeRequestConflicts
   };
 };
@@ -201,10 +209,10 @@ var toBucketListing = (raw, bucketId) => ({
 
 // src/clients/storage/buckets/buckets.ts
 var createBuckets = (client) => {
-  const getBuckets = async (query = {}, signal) => {
+  const getBuckets = async (branchId, query = {}, signal) => {
     const { data } = await client.get(
-      `/v2/storage/buckets`,
-      { query },
+      `/v2/storage/branch/{branchId}/buckets`,
+      { path: { branchId }, query },
       { signal, queryArrayFormat: "comma" }
     );
     return data;
@@ -227,7 +235,7 @@ var createBuckets = (client) => {
     return data;
   };
   const updateBucket = async (id, body) => {
-    const { data } = await client.patch(
+    const { data } = await client.put(
       `/v2/storage/buckets/{id}`,
       { path: { id }, body }
     );
@@ -315,6 +323,100 @@ var createBuckets = (client) => {
     );
     return data.map((row) => toBucketListing(row, row.bucketId));
   };
+  const shareBucketToOrganization = async (bucketId, signal) => {
+    const { data } = await client.post(
+      `/v2/storage/buckets/{bucketId}/share-organization`,
+      { path: { bucketId }, query: { async: true } },
+      { signal }
+    );
+    return data;
+  };
+  const shareBucketToOrganizationProject = async (bucketId, signal) => {
+    const { data } = await client.post(
+      `/v2/storage/buckets/{bucketId}/share-organization-project`,
+      { path: { bucketId }, query: { async: true } },
+      { signal }
+    );
+    return data;
+  };
+  const shareBucketToProjects = async (bucketId, body, signal) => {
+    const { data } = await client.post(
+      `/v2/storage/buckets/{bucketId}/share-to-projects`,
+      { path: { bucketId }, query: { async: true }, body },
+      { signal }
+    );
+    return data;
+  };
+  const shareBucketToUsers = async (bucketId, body, signal) => {
+    const { data } = await client.post(
+      `/v2/storage/buckets/{bucketId}/share-to-users`,
+      { path: { bucketId }, query: { async: true }, body },
+      { signal }
+    );
+    return data;
+  };
+  const unshareBucket = async (bucketId, signal) => {
+    const { data } = await client.delete(
+      `/v2/storage/buckets/{bucketId}/share`,
+      { path: { bucketId }, query: { async: true } },
+      { signal }
+    );
+    return data;
+  };
+  const forceUnlinkBucket = async (bucketId, linkedProjectId, signal) => {
+    const { data } = await client.delete(
+      `/v2/storage/buckets/{bucketId}/links/{linkedProjectId}`,
+      { path: { bucketId, linkedProjectId }, query: { async: true } },
+      { signal }
+    );
+    return data;
+  };
+  const getBucketOwner = async (bucketId, signal) => {
+    const { data } = await client.get(
+      `/v2/storage/buckets/{bucketId}/owner`,
+      { path: { bucketId } },
+      { signal }
+    );
+    return data;
+  };
+  const updateBucketOwner = async (bucketId, body, signal) => {
+    await client.post(
+      `/v2/storage/buckets/{bucketId}/owner`,
+      { path: { bucketId }, body },
+      { signal }
+    );
+  };
+  const refreshExternalBucket = async (bucketId, query = {}, signal) => {
+    const { data } = await client.put(`/v2/storage/buckets/{bucketId}/refresh`, { path: { bucketId }, query }, { signal });
+    return data;
+  };
+  const registerBucket = async (body, signal) => {
+    const { data } = await client.post(`/v2/storage/buckets/register`, { query: { async: true }, body }, { signal });
+    return data;
+  };
+  const getBucketRegistrationGuide = async (query, signal) => {
+    const { data } = await client.get(
+      `/v2/storage/buckets/register-guide`,
+      { query },
+      { signal }
+    );
+    return data;
+  };
+  const sharedBuckets = async (signal) => {
+    const { data } = await client.get(`/v2/storage/shared-buckets`, {}, { signal });
+    return data;
+  };
+  const saveBucketMetadata = async (bucketId, body, signal) => {
+    const { data } = await client.post(`/v2/storage/buckets/{bucketId}/metadata`, { path: { bucketId }, body }, { signal });
+    return data;
+  };
+  const deleteBucketMetadata = async (bucketId, metadataId, signal) => {
+    await client.delete(
+      `/v2/storage/buckets/{bucketId}/metadata/{metadataId}`,
+      { path: { bucketId, metadataId } },
+      { signal }
+    );
+  };
   return {
     getBuckets,
     getBucket,
@@ -328,7 +430,72 @@ var createBuckets = (client) => {
     createListing,
     updateListing,
     deleteListing,
-    listListings
+    listListings,
+    shareBucketToOrganization,
+    shareBucketToOrganizationProject,
+    shareBucketToProjects,
+    shareBucketToUsers,
+    unshareBucket,
+    forceUnlinkBucket,
+    getBucketOwner,
+    updateBucketOwner,
+    refreshExternalBucket,
+    registerBucket,
+    getBucketRegistrationGuide,
+    sharedBuckets,
+    saveBucketMetadata,
+    deleteBucketMetadata
+  };
+};
+
+// src/clients/storage/columns/columns.ts
+var createColumns = (client) => {
+  const addTableColumn = async (tableId, body, signal) => {
+    const { data } = await client.post("/v2/storage/tables/{id}/columns", { path: { id: tableId }, body }, { signal });
+    return data;
+  };
+  const deleteTableColumn = async (tableId, columnName, query, signal) => {
+    const { data } = await client.delete(
+      "/v2/storage/tables/{id}/columns/{column}",
+      { path: { id: tableId, column: columnName }, query },
+      { signal }
+    );
+    return data;
+  };
+  const createTablePrimaryKey = async (tableId, body, signal) => {
+    const { data } = await client.post("/v2/storage/tables/{id}/primary-key", { path: { id: tableId }, body }, { signal });
+    return data;
+  };
+  const removeTablePrimaryKey = async (tableId, signal) => {
+    const { data } = await client.delete(
+      "/v2/storage/tables/{id}/primary-key",
+      { path: { id: tableId } },
+      { signal }
+    );
+    return data;
+  };
+  const saveColumnMetadata = async (columnId, body, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/columns/{id}/metadata",
+      { path: { id: columnId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const deleteColumnMetadata = async (columnId, metadataId, signal) => {
+    await client.delete(
+      "/v2/storage/columns/{id}/metadata/{metadataId}",
+      { path: { id: columnId, metadataId } },
+      { signal }
+    );
+  };
+  return {
+    addTableColumn,
+    deleteTableColumn,
+    createTablePrimaryKey,
+    removeTablePrimaryKey,
+    saveColumnMetadata,
+    deleteColumnMetadata
   };
 };
 
@@ -718,12 +885,62 @@ var createJobs = (client) => {
   return { getJob, getJobs };
 };
 
+// src/clients/storage/refreshTokenMiddleware.ts
+var isTokenRefreshEndpoint = (request) => {
+  const url = new URL(request.url);
+  return request.method === "POST" && /\/tokens\/[^/]+\/refresh$/.test(url.pathname);
+};
+var tryParseNewToken = (data) => {
+  if (data === null || typeof data !== "object") return null;
+  const token = data.token;
+  return typeof token === "string" ? token : null;
+};
+var createRefreshTokenMiddlware = ({ accessToken, onRefresh }) => {
+  let current = accessToken;
+  return (next) => async (request) => {
+    request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, current);
+    if (!isTokenRefreshEndpoint(request.request)) return next(request);
+    const response = await next(request);
+    const newToken = tryParseNewToken(response.data);
+    if (newToken === null) return response;
+    current = newToken;
+    onRefresh?.(current);
+    return response;
+  };
+};
+
+// src/clients/storage/search/search.ts
+var createSearch = (client) => {
+  const globalSearch = async (query, signal) => {
+    const { data } = await client.get(
+      "/v2/storage/global-search",
+      { query },
+      { signal }
+    );
+    return data;
+  };
+  return { globalSearch };
+};
+
+// src/clients/storage/stats/stats.ts
+var createStats = (client) => {
+  const getRunIdStats = async (runId, signal) => {
+    const { data } = await client.get(
+      "/v2/storage/stats",
+      { query: { runId } },
+      { signal }
+    );
+    return data;
+  };
+  return { getRunIdStats };
+};
+
 // src/clients/storage/tables/tables.ts
 var createTables = (client) => {
-  const getTables = async (query = { include: [] }, signal) => {
+  const getTables = async (branchId, query = { include: [] }, signal) => {
     const { data } = await client.get(
-      `/v2/storage/tables`,
-      { query },
+      `/v2/storage/branch/{branchId}/tables`,
+      { path: { branchId }, query },
       { signal, queryArrayFormat: "comma" }
     );
     return data;
@@ -777,6 +994,10 @@ var createTables = (client) => {
     const { data } = await client.post("/v2/storage/buckets/{bucketId}/tables-async", { path: { bucketId }, body }, { signal });
     return data;
   };
+  const createTableDefinitionAsync = async (bucketId, body, signal) => {
+    const { data } = await client.post("/v2/storage/buckets/{bucketId}/tables-definition", { path: { bucketId }, body }, { signal });
+    return data;
+  };
   const importAsync = async (tableId, body, signal) => {
     const { data } = await client.post(
       "/v2/storage/tables/{id}/import-async",
@@ -785,6 +1006,83 @@ var createTables = (client) => {
     );
     return data;
   };
+  const updateTableDefinition = async ({ branchId = "default", tableId, ...body }, signal) => {
+    const { data } = await client.put(
+      "/v2/storage/branch/{branchId}/tables/{tableId}/definition",
+      { path: { branchId, tableId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const updateTable = async (tableId, body, signal) => {
+    const { data } = await client.put(
+      "/v2/storage/tables/{id}",
+      { path: { id: tableId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const pullTable = async (tableId, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/tables/{id}/pull",
+      { path: { id: tableId } },
+      { signal }
+    );
+    return data;
+  };
+  const createAliasTable = async (bucketId, body, signal) => {
+    const { data } = await client.post("/v2/storage/buckets/{bucketId}/table-aliases", { path: { bucketId }, body }, { signal });
+    return data;
+  };
+  const setAliasTableFilter = async (tableId, body, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/tables/{id}/alias-filter",
+      { path: { id: tableId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const removeAliasTableFilter = async (tableId, signal) => {
+    await client.delete(
+      "/v2/storage/tables/{id}/alias-filter",
+      { path: { id: tableId } },
+      { signal }
+    );
+  };
+  const createSnapshot = async (tableId, body, signal) => {
+    const { data } = await client.post("/v2/storage/tables/{id}/snapshots", { path: { id: tableId }, body }, { signal });
+    return data;
+  };
+  const deleteSnapshot = async (snapshotId, signal) => {
+    await client.delete(
+      "/v2/storage/snapshots/{snapshotId}",
+      { path: { snapshotId } },
+      { signal }
+    );
+  };
+  const loadTableSnapshots = async (tableId, signal) => {
+    const { data } = await client.get(
+      "/v2/storage/tables/{id}/snapshots",
+      { path: { id: tableId } },
+      { signal }
+    );
+    return data;
+  };
+  const saveTableMetadata = async (tableId, body, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/tables/{id}/metadata",
+      { path: { id: tableId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const deleteTableMetadata = async (tableId, metadataId, signal) => {
+    await client.delete(
+      "/v2/storage/tables/{id}/metadata/{metadataId}",
+      { path: { id: tableId, metadataId } },
+      { signal }
+    );
+  };
   return {
     getTables,
     getTable,
@@ -794,7 +1092,19 @@ var createTables = (client) => {
     deleteTableRows,
     exportAsync,
     createTableAsync,
-    importAsync
+    createTableDefinitionAsync,
+    importAsync,
+    updateTableDefinition,
+    updateTable,
+    pullTable,
+    createAliasTable,
+    setAliasTableFilter,
+    removeAliasTableFilter,
+    createSnapshot,
+    deleteSnapshot,
+    loadTableSnapshots,
+    saveTableMetadata,
+    deleteTableMetadata
   };
 };
 
@@ -816,9 +1126,93 @@ var createTokens = (client) => {
     );
     return data;
   };
+  const getTokens = async (signal) => {
+    const { data } = await client.get(
+      "/v2/storage/tokens",
+      {},
+      { signal }
+    );
+    return data;
+  };
+  const createToken = async (body, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/tokens",
+      { body },
+      { signal }
+    );
+    return data;
+  };
+  const updateToken = async (id, body, signal) => {
+    const { data } = await client.put(
+      "/v2/storage/tokens/{id}",
+      { path: { id }, body },
+      { signal }
+    );
+    return data;
+  };
+  const deleteToken = async (id, signal) => {
+    await client.delete(
+      "/v2/storage/tokens/{id}",
+      { path: { id } },
+      { signal }
+    );
+  };
+  const shareToken = async (id, body, signal) => {
+    await client.post(
+      "/v2/storage/tokens/{id}/share",
+      { path: { id }, body },
+      { signal }
+    );
+  };
   return {
     verify,
-    refresh
+    refresh,
+    getTokens,
+    createToken,
+    updateToken,
+    deleteToken,
+    shareToken
+  };
+};
+
+// src/clients/storage/triggers/triggers.ts
+var createTriggers = (client) => {
+  const listTriggers = async (query, signal) => {
+    const { data } = await client.get(
+      "/v2/storage/triggers",
+      { query },
+      { signal }
+    );
+    return data;
+  };
+  const createTrigger = async (body, signal) => {
+    const { data } = await client.post(
+      "/v2/storage/triggers",
+      { body },
+      { signal }
+    );
+    return data;
+  };
+  const updateTrigger = async (triggerId, body, signal) => {
+    const { data } = await client.put(
+      "/v2/storage/triggers/{triggerId}",
+      { path: { triggerId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const deleteTrigger = async (triggerId, signal) => {
+    await client.delete(
+      "/v2/storage/triggers/{triggerId}",
+      { path: { triggerId } },
+      { signal }
+    );
+  };
+  return {
+    listTriggers,
+    createTrigger,
+    updateTrigger,
+    deleteTrigger
   };
 };
 
@@ -921,6 +1315,18 @@ var createWorkspaces = (client, openApiClient) => {
     );
     return data;
   };
+  const inputMappingLoadPreview = async ({ branchId, body, backend }, signal) => {
+    const { data } = await openApiClient.post(
+      "/v2/storage/branch/{branchId}/input-mapping-load/preview",
+      {
+        path: { branchId: String(branchId) },
+        query: backend ? { backend } : void 0,
+        body
+      },
+      { signal }
+    );
+    return data;
+  };
   return {
     getWorkspace,
     getWorkspaces,
@@ -932,19 +1338,32 @@ var createWorkspaces = (client, openApiClient) => {
     getWorkspaceSaml2Login,
     getWorkspaceObjects,
     deleteWorkspaceObjectsAsync,
-    unloadWorkspace
+    unloadWorkspace,
+    inputMappingLoadPreview
   };
 };
 
 // src/clients/storage/storageClient.ts
-var createStorageClient = ({ baseUrl, middlewares = [] }) => {
+var createStorageClient = ({
+  baseUrl,
+  token,
+  middlewares = [],
+  onRefreshToken
+}) => {
+  const allMiddlewares = onRefreshToken ? [
+    ...middlewares,
+    createRefreshTokenMiddlware({ accessToken: token, onRefresh: onRefreshToken })
+  ] : middlewares;
+  const headers = { [KeboolaHttpHeader.STORAGE_API_TOKEN]: token };
   const client = createGenericFetchClient({
     baseUrl,
-    middlewares
+    middlewares: allMiddlewares,
+    headers
   });
   const openApiClient = createOpenapiFetchClient({
     baseUrl,
-    middlewares
+    middlewares: allMiddlewares,
+    headers
   });
   const getStackInfo = async (query, signal) => {
     const { data } = await client.get(
@@ -959,6 +1378,7 @@ var createStorageClient = ({ baseUrl, middlewares = [] }) => {
     events: createEvents(client),
     files: createFiles(client),
     tables: createTables(client),
+    columns: createColumns(client),
     branches: createBranches(client),
     workspaces: createWorkspaces(client, openApiClient),
     mergeRequests: createMergeRequests(openApiClient),
@@ -966,33 +1386,13 @@ var createStorageClient = ({ baseUrl, middlewares = [] }) => {
     componentsAndConfigurations: createComponentsAndConfigurations(client),
     configurationVersions: createConfigurationVersions(client),
     tokens: createTokens(client),
+    triggers: createTriggers(client),
+    search: createSearch(client),
+    stats: createStats(client),
     getStackInfo
   };
 };
 
-// src/clients/storage/storageTokenMiddleware.ts
-var isTokenRefreshEndpoint = (request) => {
-  const url = new URL(request.url);
-  return request.method === "POST" && /\/tokens\/[^/]+\/refresh$/.test(url.pathname);
-};
-var tryParseNewToken = (data) => {
-  if (data === null || typeof data !== "object") return null;
-  const token = data.token;
-  return typeof token === "string" ? token : null;
-};
-var createStorageTokenMiddleware = (initialToken) => {
-  let current = initialToken;
-  return (next) => async (request) => {
-    request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, current);
-    const response = await next(request);
-    if (isTokenRefreshEndpoint(request.request)) {
-      const newToken = tryParseNewToken(response.data);
-      if (newToken !== null) current = newToken;
-    }
-    return response;
-  };
-};
-
-export { createStorageClient, createStorageTokenMiddleware, series };
-//# sourceMappingURL=chunk-7NX56CKZ.js.map
-//# sourceMappingURL=chunk-7NX56CKZ.js.map
+export { createStorageClient, series };
+//# sourceMappingURL=chunk-QEQAZPWM.js.map
+//# sourceMappingURL=chunk-QEQAZPWM.js.map