@keboola/api-client 0.1.0

package/dist/storage/index.js

@@ -0,0 +1,1014 @@
+import qs from 'qs';
+
+// src/errors/ApiError.ts
+var ApiError = class extends Error {
+  response;
+  request;
+  data;
+  constructor({ response, request, data }) {
+    super(response.statusText);
+    this.response = response;
+    this.request = request;
+    this.data = data;
+  }
+};
+var HttpHeader = {
+  CONTENT_TYPE: "content-type"};
+var HttpContentType = {
+  JSON: "application/json"};
+var defaultValidateStatus = ({ response }) => response.status >= 200 && response.status <= 299;
+function removeUndefined(obj) {
+  const objCopy = { ...obj };
+  for (const [key, value] of Object.entries(objCopy)) {
+    if (value == null) delete objCopy[key];
+  }
+  return objCopy;
+}
+var parseData = async (response) => {
+  if (response.status === 204) return null;
+  const contentType = response.headers.get(HttpHeader.CONTENT_TYPE);
+  if (contentType && contentType == HttpContentType.JSON) {
+    return response.json();
+  }
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var cleanHeadersInit = (headersInit) => {
+  if (Array.isArray(headersInit)) return headersInit;
+  if (headersInit instanceof Headers) return headersInit;
+  if (headersInit == null) return headersInit;
+  return removeUndefined(headersInit);
+};
+var createHeaders = (headersInitA, headersInitB) => {
+  const headersA = new Headers(cleanHeadersInit(headersInitA));
+  const headersB = new Headers(cleanHeadersInit(headersInitB));
+  headersB.forEach((value, key) => {
+    headersA.set(key, value);
+  });
+  return headersA;
+};
+var createPath = (path, pathParam = {}) => path.replace(/\{([^}]+)}/g, (_, key) => {
+  if (!(key in pathParam))
+    throw new Error(`Path parameter "${key}" is missing in the path "${path}"`);
+  return encodeURIComponent(pathParam[key]);
+});
+var createSearch = (query, options = {}) => {
+  return qs.stringify(query, {
+    encodeValuesOnly: true,
+    skipNulls: true,
+    ...options
+  });
+};
+var createBody = (body, headers) => {
+  if (body == null) return null;
+  if (body instanceof FormData) return body;
+  if (typeof body === "string") return body;
+  const stringifyBody = JSON.stringify(body);
+  const stringBody = stringifyBody === "{}" ? null : stringifyBody;
+  if (stringBody) headers.set(HttpHeader.CONTENT_TYPE, HttpContentType.JSON);
+  return stringBody;
+};
+var createFetchRequest = ({
+  url,
+  method,
+  params,
+  options = {},
+  defaultOptions
+}) => {
+  const {
+    baseUrl,
+    validateStatus: defValidateStatus = defaultValidateStatus,
+    headers: defaultHeaders,
+    ...restDefaultOptions
+  } = defaultOptions;
+  const { validateStatus, queryArrayFormat, headers: endpointHeaders, ...restOptions } = options;
+  const headers = createHeaders(defaultHeaders, endpointHeaders);
+  const path = createPath(url, params.path);
+  const search = createSearch(params.query ?? {}, { arrayFormat: queryArrayFormat });
+  const body = createBody(params.body, headers);
+  const urlInstance = new URL(baseUrl + path);
+  urlInstance.search = search;
+  const request = new Request(urlInstance, {
+    ...restDefaultOptions,
+    ...restOptions,
+    headers,
+    method: method.toUpperCase(),
+    body
+  });
+  return { request, validateStatus: validateStatus ?? defValidateStatus };
+};
+
+// src/fetchClient/createFetchClient/createFetchClient.ts
+var isApiError = (error) => error instanceof ApiError;
+var createCoreFetch = (fetchFn) => async ({ request, validateStatus }) => {
+  const response = await fetchFn(request);
+  const data = await parseData(response);
+  const apiResponse = {
+    request,
+    response,
+    data
+  };
+  const boolOrError = validateStatus(apiResponse);
+  if (isApiError(boolOrError)) throw boolOrError;
+  if (!boolOrError) throw new ApiError(apiResponse);
+  return apiResponse;
+};
+var createFetchClient = ({
+  middlewares = [],
+  ...defaultOptions
+}) => {
+  const coreFetch = createCoreFetch(defaultOptions.fetchFn ?? fetch);
+  const fetchWithMiddlewares = middlewares.reduceRight(
+    (next, middleware) => middleware(next),
+    coreFetch
+  );
+  const createFetchMethod = (method) => async (url, params, options = {}) => {
+    const request = createFetchRequest({
+      url,
+      method,
+      params,
+      defaultOptions,
+      options
+    });
+    const methodMiddlewares = options?.middlewares ?? [];
+    return methodMiddlewares.reduceRight(
+      (next, middleware) => middleware(next),
+      fetchWithMiddlewares
+    )(request);
+  };
+  return {
+    get: createFetchMethod("get"),
+    post: createFetchMethod("post"),
+    put: createFetchMethod("put"),
+    patch: createFetchMethod("patch"),
+    delete: createFetchMethod("delete")
+  };
+};
+
+// src/fetchClient/createGenericFetchClient.ts
+var createGenericFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
+
+// src/fetchClient/createOpenapiFetchClient.ts
+var createOpenapiFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
+
+// src/clients/storage/configurationVersions/configurationVersions.ts
+var createConfigurationVersions = (client) => {
+  const listConfigurationVersions = async ({ branchId, componentId, configId }, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/components/{componentId}/configs/{configId}/versions",
+      { path: { branchId, componentId, configId } },
+      { signal }
+    );
+    return data;
+  };
+  const getConfigurationVersion = async ({ branchId, componentId, configId, versionId }, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/components/{componentId}/configs/{configId}/versions/{versionId}",
+      { path: { branchId, componentId, configId, versionId } },
+      { signal }
+    );
+    return data;
+  };
+  return {
+    listConfigurationVersions,
+    getConfigurationVersion
+  };
+};
+
+// src/clients/storage/mergeRequests/mergeRequests.ts
+var createMergeRequests = (client) => {
+  const getMergeRequests = async (signal) => {
+    const { data } = await client.get("/v2/storage/merge-request", {}, { signal });
+    return data;
+  };
+  const getMergeRequest = async (id, signal) => {
+    const { data } = await client.get(
+      "/v2/storage/merge-request/{id}",
+      { path: { id } },
+      { signal }
+    );
+    return data;
+  };
+  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 }
+    );
+    return data;
+  };
+  const createMergeRequest = async (params) => {
+    const { data } = await client.post("/v2/storage/merge-request", { body: params });
+    return data;
+  };
+  const updateMergeRequest = async (id, params) => {
+    const { data } = await client.put("/v2/storage/merge-request/{id}", {
+      path: { id },
+      body: params
+    });
+    return data;
+  };
+  const requestReview = async (id) => {
+    const { data } = await client.put("/v2/storage/merge-request/{id}/request-review", {
+      path: { id }
+    });
+    return data;
+  };
+  const approveMergeRequest = async (id) => {
+    const { data } = await client.put("/v2/storage/merge-request/{id}/approve", {
+      path: { id }
+    });
+    return data;
+  };
+  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;
+  };
+  return {
+    getMergeRequests,
+    getMergeRequest,
+    getMergeRequestWithActivityLog,
+    createMergeRequest,
+    updateMergeRequest,
+    requestReview,
+    approveMergeRequest,
+    requestChangesMergeRequest
+  };
+};
+
+// src/clients/storage/branches/mappers.ts
+var mapBranchMetadata = (data) => ({
+  ...data,
+  timestamp: new Date(data.timestamp)
+});
+
+// src/clients/storage/branches/branches.ts
+var createBranches = (client) => {
+  const getDevBranches = async (signal) => {
+    const { data } = await client.get("/dev-branches", {}, { signal });
+    return data;
+  };
+  const createDevBranchJob = async (body) => {
+    const { data } = await client.post(
+      "/dev-branches",
+      {
+        body
+      }
+    );
+    return data;
+  };
+  const updateDevBranch = async ({
+    id,
+    name,
+    description
+  }) => {
+    const { data } = await client.put(
+      "/dev-branches/{id}",
+      {
+        path: { id },
+        body: {
+          name,
+          description
+        }
+      }
+    );
+    return data;
+  };
+  const deleteDevBranchJob = async (id) => {
+    const { data } = await client.delete(
+      "/dev-branches/{id}",
+      {
+        path: { id }
+      }
+    );
+    return data;
+  };
+  const getDevBranchMetadata = async (id, signal) => {
+    const { data } = await client.get(
+      "/branch/{id}/metadata",
+      { path: { id } },
+      { signal }
+    );
+    return data.map(mapBranchMetadata);
+  };
+  const saveDevBranchMetadata = async (id, metadata, signal) => {
+    const { data } = await client.post("/branch/{id}/metadata", { path: { id }, body: { metadata } }, { signal });
+    return data.map(mapBranchMetadata);
+  };
+  const deleteDevBranchMetadata = async (id, metadataId, signal) => {
+    await client.delete(
+      "/branch/{id}/metadata/{metadataId}",
+      { path: { id, metadataId } },
+      { signal }
+    );
+  };
+  return {
+    getDevBranches,
+    createDevBranchJob,
+    updateDevBranch,
+    deleteDevBranchJob,
+    getDevBranchMetadata,
+    saveDevBranchMetadata,
+    deleteDevBranchMetadata
+  };
+};
+
+// src/clients/storage/buckets/buckets.ts
+var createBuckets = (client) => {
+  const getBuckets = async (query = {}, signal) => {
+    const { data } = await client.get(
+      `/buckets`,
+      { query },
+      { signal, queryArrayFormat: "comma" }
+    );
+    return data;
+  };
+  const getBucket = async (id, signal) => {
+    const { data } = await client.get(
+      `/buckets/{id}`,
+      { path: { id } },
+      { signal }
+    );
+    return data;
+  };
+  const createBucket = async (body) => {
+    const { data } = await client.post(`/buckets`, {
+      body
+    });
+    return data;
+  };
+  const updateBucket = async (id, body) => {
+    const { data } = await client.patch(
+      `/buckets/{id}`,
+      { path: { id }, body }
+    );
+    return data;
+  };
+  const deleteBucket = async (id) => {
+    await client.delete(`/buckets/{id}`, { path: { id } });
+  };
+  const deleteBucketAsync = async (id, options = {}) => {
+    const { data } = await client.delete(`/buckets/{id}`, { path: { id }, query: { async: true, ...options } });
+    return data;
+  };
+  const createScheduledRefresh = async (input) => {
+    const { branchId, bucketId, cronExpression } = input;
+    const { data } = await client.post(`/branch/{branchId}/buckets/{bucketId}/scheduled-tasks/refresh`, {
+      path: { branchId, bucketId },
+      body: { cronExpression }
+    });
+    return data;
+  };
+  const deleteScheduledTask = async (taskId) => {
+    await client.delete(`/scheduled-tasks/{taskId}`, {
+      path: { taskId }
+    });
+  };
+  return {
+    getBuckets,
+    getBucket,
+    createBucket,
+    updateBucket,
+    deleteBucket,
+    deleteBucketAsync,
+    createScheduledRefresh,
+    deleteScheduledTask
+  };
+};
+
+// src/utils/concurrent.ts
+var concurrent = async ({
+  items,
+  process,
+  concurrency = 2,
+  middlewares = []
+}) => {
+  if (concurrency < 1) throw new Error("Concurrency must be greater than 0");
+  if (items.length === 0) return [];
+  if (concurrency === Infinity)
+    return Promise.all(items.map((item, index) => process(item, index, items.length)));
+  const n = items.length;
+  const results = new Array(n);
+  const processWithMiddlewares = middlewares.reduceRight(
+    (next, middleware) => middleware(next),
+    process
+  );
+  const queue = items.map((item, index) => async () => {
+    results[index] = await processWithMiddlewares(item, index, items.length);
+  });
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    async function processQueue() {
+      while (queue.length) {
+        await queue.shift()?.();
+      }
+    }
+  );
+  await Promise.all(workers);
+  return results;
+};
+
+// src/utils/series.ts
+var series = async (options) => concurrent({
+  ...options,
+  concurrency: 1
+});
+
+// src/clients/storage/componentsAndConfigurations/componentsAndConfigurations.ts
+var createComponentsAndConfigurations = (client) => {
+  const getComponent = async ({ componentId, branchId = "default" }, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/components/{componentId}",
+      { path: { componentId, branchId } },
+      { signal }
+    );
+    return data;
+  };
+  const getComponents = async ({ branchId = "default", ...query } = {}, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/components",
+      { path: { branchId }, query },
+      { signal, queryArrayFormat: "comma" }
+    );
+    return data;
+  };
+  const getConfiguration = async ({ componentId, configId, branchId = "default" }, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/components/{componentId}/configs/{configId}",
+      { path: { componentId, configId, branchId } },
+      { signal }
+    );
+    return data;
+  };
+  const createConfiguration = async ({
+    branchId = "default",
+    componentId,
+    ...body
+  }) => {
+    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs", {
+      path: { branchId, componentId },
+      body
+    });
+    return data;
+  };
+  const deleteConfiguration = async (path) => {
+    await client.delete(
+      "/branch/{branchId}/components/{componentId}/configs/{configId}",
+      { path }
+    );
+  };
+  const deleteConfigurations = async ({
+    configIds,
+    ...rest
+  }) => {
+    await concurrent({
+      items: configIds,
+      process: async (configId) => deleteConfiguration({ ...rest, configId })
+    });
+  };
+  const getConfigurations = async ({ componentId, branchId = "default" }, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/components/{componentId}/configs",
+      { path: { componentId, branchId } },
+      { signal }
+    );
+    return data;
+  };
+  const getConfigurationWorkspaces = async ({
+    componentId,
+    branchId,
+    configId
+  }) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces",
+      {
+        path: { componentId, branchId, configId }
+      }
+    );
+    return data;
+  };
+  const createConfigurationWorkspace = async ({
+    componentId,
+    branchId,
+    configId,
+    ...body
+  }) => {
+    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces", {
+      path: { componentId, branchId, configId },
+      body
+    });
+    return data;
+  };
+  const createConfigurationWorkspaceJob = async ({
+    componentId,
+    branchId,
+    configId,
+    ...body
+  }) => {
+    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs/{configId}/workspaces", {
+      path: { componentId, branchId, configId },
+      body,
+      query: { async: true }
+    });
+    return data;
+  };
+  const createConfigurationRow = async ({
+    branchId = "default",
+    componentId,
+    configId,
+    ...body
+  }) => {
+    const { data } = await client.post("/branch/{branchId}/components/{componentId}/configs/{configId}/rows", {
+      path: { branchId, componentId, configId },
+      body
+    });
+    return data;
+  };
+  const createConfigurationRows = async ({
+    branchId = "default",
+    componentId,
+    configId,
+    data
+  }, options) => {
+    return series({
+      items: data,
+      process: (rowBody) => {
+        return createConfigurationRow({
+          branchId,
+          componentId,
+          configId,
+          ...rowBody
+        });
+      },
+      middlewares: options?.middlewares
+    });
+  };
+  const deleteConfigurationRow = async ({
+    changeDescription,
+    ...path
+  }) => {
+    await client.delete(
+      "/branch/{branchId}/components/{componentId}/configs/{configId}/rows/{rowId}",
+      {
+        path,
+        body: { changeDescription }
+      }
+    );
+  };
+  const deleteConfigurationRows = async ({ rowIds, changeDescription, ...input }, options) => {
+    await concurrent({
+      items: rowIds,
+      process: (rowId) => {
+        const resolvedDescription = typeof changeDescription === "string" ? changeDescription : changeDescription?.(rowId);
+        return deleteConfigurationRow({
+          rowId,
+          changeDescription: resolvedDescription,
+          ...input
+        });
+      },
+      concurrency: 5,
+      middlewares: options?.middlewares
+    });
+  };
+  const searchComponentConfigurations = async ({ branchId = "default" } = {}, query, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/search/component-configurations",
+      { path: { branchId }, query },
+      { signal, queryArrayFormat: "comma" }
+    );
+    return data;
+  };
+  return {
+    // components
+    getComponent,
+    getComponents,
+    searchComponentConfigurations,
+    // configurations
+    createConfiguration,
+    getConfiguration,
+    deleteConfiguration,
+    deleteConfigurations,
+    getConfigurations,
+    // configuration's rows
+    createConfigurationRow,
+    createConfigurationRows,
+    deleteConfigurationRow,
+    deleteConfigurationRows,
+    // configuration's workspaces
+    createConfigurationWorkspace,
+    createConfigurationWorkspaceJob,
+    getConfigurationWorkspaces
+  };
+};
+
+// src/clients/storage/events/events.ts
+var createEvents = (client) => {
+  const getEvents = async (query, signal) => {
+    const { data } = await client.get(
+      "/events",
+      { query },
+      { signal }
+    );
+    return data;
+  };
+  const getEvent = async (eventId, signal) => {
+    const { data } = await client.get(
+      "/events/{eventId}",
+      {
+        path: { eventId }
+      },
+      { signal }
+    );
+    return data;
+  };
+  const createEvent = async (body, signal) => {
+    const { data } = await client.post(
+      "/events",
+      {
+        body
+      },
+      { signal }
+    );
+    return data;
+  };
+  return {
+    getEvents,
+    getEvent,
+    createEvent
+  };
+};
+
+// src/clients/storage/files/files.ts
+var createFiles = (client) => {
+  const getFile = async (fileId, signal) => {
+    const { data } = await client.get(
+      `/files/{fileId}`,
+      {
+        path: { fileId }
+      },
+      { signal }
+    );
+    return data;
+  };
+  const getFiles = async (query, signal) => {
+    const { data } = await client.get(
+      "/files",
+      { query },
+      { signal, queryArrayFormat: "brackets" }
+    );
+    return data;
+  };
+  const deleteFile = async (fileId) => {
+    const { data } = await client.delete(`/files/{fileId}`, {
+      path: { fileId }
+    });
+    return data;
+  };
+  const addFileTag = async (fileId, tag) => {
+    const { data } = await client.post(
+      `/files/{fileId}/tags`,
+      {
+        path: { fileId },
+        body: { tag }
+      }
+    );
+    return data;
+  };
+  const getFileContent = async (fileId, signal) => {
+    const { data } = await client.get(
+      `/files/{fileId}/content`,
+      {
+        path: { fileId }
+      },
+      { signal }
+    );
+    return typeof data === "string" ? data : JSON.stringify(data, null, 2);
+  };
+  const deleteFileTag = async (fileId, tag) => {
+    const { data } = await client.delete(
+      "/files/{fileId}/tags/{tag}",
+      {
+        path: { fileId, tag }
+      }
+    );
+    return data;
+  };
+  const prepareFile = async (body, signal) => {
+    const { data } = await client.post(
+      "/files/prepare",
+      { body },
+      { signal }
+    );
+    return data;
+  };
+  return {
+    getFile,
+    getFileContent,
+    getFiles,
+    deleteFile,
+    addFileTag,
+    deleteFileTag,
+    prepareFile
+  };
+};
+
+// src/clients/storage/jobs/jobs.ts
+var createJobs = (client) => {
+  const getJob = async (id, signal) => {
+    const { data } = await client.get(
+      `/jobs/{id}`,
+      {
+        path: { id }
+      },
+      { signal }
+    );
+    return data;
+  };
+  const getJobs = async (query, signal) => {
+    const { data } = await client.get(
+      "/jobs",
+      { query },
+      { signal, queryArrayFormat: "brackets" }
+    );
+    return data;
+  };
+  return { getJob, getJobs };
+};
+
+// src/clients/storage/tables/tables.ts
+var createTables = (client) => {
+  const getTables = async (query = { include: [] }, signal) => {
+    const { data } = await client.get(
+      `/tables`,
+      { query },
+      { signal, queryArrayFormat: "comma" }
+    );
+    return data;
+  };
+  const getTable = async (id, signal) => {
+    const { data } = await client.get(
+      `/tables/{id}`,
+      { path: { id } },
+      { signal }
+    );
+    return data;
+  };
+  const deleteTable = async (id, signal) => {
+    await client.delete(`/tables/{id}`, { path: { id } }, { signal });
+  };
+  const deleteTables = async (ids) => {
+    await concurrent({
+      items: ids,
+      process: (id) => deleteTable(id)
+    });
+  };
+  const deleteTableRows = async (id, query, signal) => {
+    const { data } = await client.delete(
+      `/tables/{id}/rows`,
+      { path: { id }, query },
+      { signal }
+    );
+    return data;
+  };
+  const getDataPreview = async (id, query, signal) => {
+    const { data } = await client.get(
+      `/tables/{id}/data-preview`,
+      { path: { id }, query: { format: "json", ...query } },
+      { signal }
+    );
+    return data;
+  };
+  const exportAsync = async (tableId, body, signal) => {
+    const { data } = await client.post(
+      "/tables/{id}/export-async",
+      { path: { id: tableId }, body },
+      { signal }
+    );
+    return data;
+  };
+  const createTableAsync = async (bucketId, body, signal) => {
+    const { data } = await client.post("/buckets/{bucketId}/tables-async", { path: { bucketId }, body }, { signal });
+    return data;
+  };
+  const importAsync = async (tableId, body, signal) => {
+    const { data } = await client.post(
+      "/tables/{id}/import-async",
+      { path: { id: tableId }, body },
+      { signal }
+    );
+    return data;
+  };
+  return {
+    getTables,
+    getTable,
+    getDataPreview,
+    deleteTable,
+    deleteTables,
+    deleteTableRows,
+    exportAsync,
+    createTableAsync,
+    importAsync
+  };
+};
+
+// src/clients/storage/tokens/tokens.ts
+var createTokens = (client) => {
+  const verify = async (signal) => {
+    const { data } = await client.get(
+      "/tokens/verify",
+      {},
+      { signal }
+    );
+    return data;
+  };
+  const refresh = async (id, signal) => {
+    const { data } = await client.post(
+      `/tokens/${id}/refresh`,
+      {},
+      { signal }
+    );
+    return data;
+  };
+  return {
+    verify,
+    refresh
+  };
+};
+
+// src/clients/storage/workspaces/workspaces.ts
+var createWorkspaces = (client) => {
+  const getWorkspaces = async (branchId, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/workspaces",
+      { path: { branchId } },
+      { signal }
+    );
+    return data;
+  };
+  const getWorkspace = async (path, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/workspaces/{workspaceId}",
+      { path },
+      { signal }
+    );
+    return data;
+  };
+  const deleteWorkspace = async (path) => {
+    await client.delete(
+      "/branch/{branchId}/workspaces/{workspaceId}",
+      { path }
+    );
+  };
+  const deleteWorkspaces = async ({
+    workspaceIds,
+    branchId
+  }) => {
+    await concurrent({
+      items: workspaceIds,
+      process: async (workspaceId) => deleteWorkspace({ branchId, workspaceId }),
+      concurrency: 5
+    });
+  };
+  const deleteWorkspaceJob = async (path) => {
+    const { data } = await client.delete(
+      "/branch/{branchId}/workspaces/{workspaceId}",
+      { path, query: { async: true } },
+      {}
+    );
+    return data;
+  };
+  const resetWorkspacePassword = async ({ branchId, workspaceId }) => {
+    const { data } = await client.post(
+      "/branch/{branchId}/workspaces/{workspaceId}/password",
+      {
+        path: { branchId, workspaceId }
+      }
+    );
+    return data;
+  };
+  const getWorkspaceSaml2Login = async (path, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/workspaces/{workspaceId}/saml2-login",
+      { path },
+      { signal }
+    );
+    return data;
+  };
+  const setWorkspacePublicKey = async ({
+    branchId,
+    workspaceId,
+    publicKey
+  }) => {
+    const { data } = await client.post("/branch/{branchId}/workspaces/{workspaceId}/public-key", {
+      path: { branchId, workspaceId },
+      body: { publicKey }
+    });
+    return data;
+  };
+  const getWorkspaceObjects = async (path, signal) => {
+    const { data } = await client.get(
+      "/branch/{branchId}/workspaces/{workspaceId}/objects",
+      { path },
+      { signal }
+    );
+    return data;
+  };
+  const deleteWorkspaceObjectsAsync = async ({
+    branchId,
+    workspaceId,
+    ...body
+  }) => {
+    const { data } = await client.post("/branch/{branchId}/workspaces/{workspaceId}/objects/batch-delete", {
+      path: { branchId, workspaceId },
+      body
+    });
+    return data;
+  };
+  return {
+    getWorkspace,
+    getWorkspaces,
+    deleteWorkspace,
+    resetWorkspacePassword,
+    deleteWorkspaces,
+    deleteWorkspaceJob,
+    setWorkspacePublicKey,
+    getWorkspaceSaml2Login,
+    getWorkspaceObjects,
+    deleteWorkspaceObjectsAsync
+  };
+};
+
+// src/clients/storage/storageClient.ts
+var createStorageClient = ({ baseUrl, middlewares = [] }) => {
+  const storageBaseUrl = `${baseUrl}/v2/storage`;
+  const client = createGenericFetchClient({
+    baseUrl: storageBaseUrl,
+    middlewares
+  });
+  const openApiClient = createOpenapiFetchClient({
+    baseUrl,
+    middlewares
+  });
+  const getStackInfo = async (query, signal) => {
+    const { data } = await client.get(
+      "",
+      { query },
+      { signal }
+    );
+    return data;
+  };
+  return {
+    buckets: createBuckets(client),
+    events: createEvents(client),
+    files: createFiles(client),
+    tables: createTables(client),
+    branches: createBranches(client),
+    workspaces: createWorkspaces(client),
+    mergeRequests: createMergeRequests(openApiClient),
+    jobs: createJobs(client),
+    componentsAndConfigurations: createComponentsAndConfigurations(client),
+    configurationVersions: createConfigurationVersions(client),
+    tokens: createTokens(client),
+    getStackInfo
+  };
+};
+
+// src/constants.ts
+var KeboolaHttpHeader = {
+  STORAGE_API_TOKEN: "X-StorageApi-Token"};
+
+// 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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map