@keboola/api-client 3.0.1 → 5.0.0

package/dist/{chunk-ROBQ2CV7.cjs → chunk-T7UDL2KI.cjs}

@@ -1,7 +1,8 @@
 'use strict';
 
 var chunkCVV4HROS_cjs = require('./chunk-CVV4HROS.cjs');
-var chunkMTFRH3R5_cjs = require('./chunk-MTFRH3R5.cjs');
+var chunk3CIPWA33_cjs = require('./chunk-3CIPWA33.cjs');
+var chunk4I6TJWBG_cjs = require('./chunk-4I6TJWBG.cjs');
 
 // src/clients/storage/configurationVersions/configurationVersions.ts
 var createConfigurationVersions = (client) => {
@@ -79,6 +80,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",
@@ -96,6 +103,7 @@ var createMergeRequests = (client) => {
     requestReview,
     approveMergeRequest,
     requestChangesMergeRequest,
+    mergeMergeRequest,
     getMergeRequestConflicts
   };
 };
@@ -203,10 +211,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;
@@ -229,7 +237,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 }
     );
@@ -264,7 +272,7 @@ var createBuckets = (client) => {
       );
       return toBucketListing(data, bucketId);
     } catch (error) {
-      if (chunkMTFRH3R5_cjs.isApiError(error) && error.response.status === 404) return null;
+      if (chunk3CIPWA33_cjs.isApiError(error) && error.response.status === 404) return null;
       throw error;
     }
   };
@@ -317,6 +325,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,
@@ -330,7 +432,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
   };
 };
 
@@ -374,6 +541,18 @@ var createComponentsAndConfigurations = (client) => {
     );
     return data;
   };
+  const rebaseConfiguration = async ({
+    branchId,
+    componentId,
+    configId,
+    ...body
+  }) => {
+    const { data } = await client.post("/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/rebase", {
+      path: { branchId, componentId, configId },
+      body
+    });
+    return data;
+  };
   const getConfigurationRowDiff = async ({ componentId, configId, rowId, branchId }, signal) => {
     const { data } = await client.get(
       "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}/rows/{rowId}/diff",
@@ -393,6 +572,24 @@ var createComponentsAndConfigurations = (client) => {
     });
     return data;
   };
+  const updateConfiguration = async ({
+    branchId = "default",
+    componentId,
+    configId,
+    configuration,
+    ...rest
+  }, signal) => {
+    const body = {
+      ...rest,
+      ...configuration !== void 0 && { configuration: JSON.stringify(configuration) }
+    };
+    const { data } = await client.put(
+      "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}",
+      { path: { branchId, componentId, configId }, body },
+      { signal }
+    );
+    return data;
+  };
   const deleteConfiguration = async (path) => {
     await client.delete(
       "/v2/storage/branch/{branchId}/components/{componentId}/configs/{configId}",
@@ -527,9 +724,11 @@ var createComponentsAndConfigurations = (client) => {
     searchComponentConfigurations,
     // configurations
     createConfiguration,
+    updateConfiguration,
     getConfiguration,
     getConfigurationDiff,
     getConfigurationRowDiff,
+    rebaseConfiguration,
     deleteConfiguration,
     deleteConfigurations,
     getConfigurations,
@@ -688,12 +887,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(chunk4I6TJWBG_cjs.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;
@@ -747,6 +996,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",
@@ -755,6 +1008,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,
@@ -764,7 +1094,19 @@ var createTables = (client) => {
     deleteTableRows,
     exportAsync,
     createTableAsync,
-    importAsync
+    createTableDefinitionAsync,
+    importAsync,
+    updateTableDefinition,
+    updateTable,
+    pullTable,
+    createAliasTable,
+    setAliasTableFilter,
+    removeAliasTableFilter,
+    createSnapshot,
+    deleteSnapshot,
+    loadTableSnapshots,
+    saveTableMetadata,
+    deleteTableMetadata
   };
 };
 
@@ -786,9 +1128,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
   };
 };
 
@@ -891,6 +1317,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,
@@ -902,19 +1340,32 @@ var createWorkspaces = (client, openApiClient) => {
     getWorkspaceSaml2Login,
     getWorkspaceObjects,
     deleteWorkspaceObjectsAsync,
-    unloadWorkspace
+    unloadWorkspace,
+    inputMappingLoadPreview
   };
 };
 
 // src/clients/storage/storageClient.ts
-var createStorageClient = ({ baseUrl, middlewares = [] }) => {
-  const client = chunkMTFRH3R5_cjs.createGenericFetchClient({
+var createStorageClient = ({
+  baseUrl,
+  token,
+  middlewares = [],
+  onRefreshToken
+}) => {
+  const allMiddlewares = onRefreshToken ? [
+    ...middlewares,
+    createRefreshTokenMiddlware({ accessToken: token, onRefresh: onRefreshToken })
+  ] : middlewares;
+  const headers = { [chunk4I6TJWBG_cjs.KeboolaHttpHeader.STORAGE_API_TOKEN]: token };
+  const client = chunk3CIPWA33_cjs.createGenericFetchClient({
     baseUrl,
-    middlewares
+    middlewares: allMiddlewares,
+    headers
   });
-  const openApiClient = chunkMTFRH3R5_cjs.createOpenapiFetchClient({
+  const openApiClient = chunk3CIPWA33_cjs.createOpenapiFetchClient({
     baseUrl,
-    middlewares
+    middlewares: allMiddlewares,
+    headers
   });
   const getStackInfo = async (query, signal) => {
     const { data } = await client.get(
@@ -929,6 +1380,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),
@@ -936,35 +1388,14 @@ 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(chunkMTFRH3R5_cjs.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;
-  };
-};
-
 exports.createStorageClient = createStorageClient;
-exports.createStorageTokenMiddleware = createStorageTokenMiddleware;
 exports.series = series;
-//# sourceMappingURL=chunk-ROBQ2CV7.cjs.map
-//# sourceMappingURL=chunk-ROBQ2CV7.cjs.map
+//# sourceMappingURL=chunk-T7UDL2KI.cjs.map
+//# sourceMappingURL=chunk-T7UDL2KI.cjs.map