@keboola/api-client 1.0.0 → 2.0.0

package/dist/storageSdk-BZ7ZW6_h.d.cts

@@ -0,0 +1,143 @@
+import { CreateTableAsyncBody, TableCreateJob, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, BucketListing, CreateBucketListingInput, UpdateBucketListingInput } from './storage/types.cjs';
+import { c as createStorageClient } from './storageClient-CmK1LPHr.cjs';
+
+type Options = {
+    interval?: number;
+    maxAttempts?: number;
+    abortSignal?: AbortSignal;
+};
+type StorageSdkOptions = {
+    storageClient: ReturnType<typeof createStorageClient>;
+};
+declare const createStorageSdk: ({ storageClient }: StorageSdkOptions) => {
+    createTable: (bucketId: string, body: CreateTableAsyncBody, options?: Options) => Promise<TableCreateJob>;
+    importFromFile: (tableId: string, body: TableImportAsyncBody, options?: Options) => Promise<TableImportJob>;
+    exportToFile: (tableId: string, body?: TableExportAsyncBody, options?: Options) => Promise<TableExportJob>;
+    getBucketListing: (bucketId: string, signal?: AbortSignal) => Promise<BucketListing | null>;
+    listBucketListings: (signal?: AbortSignal) => Promise<BucketListing[]>;
+    createBucketListing: (bucketId: string, input: CreateBucketListingInput, options?: Options) => Promise<{
+        id: number;
+        tableId: string | null;
+        runId: string;
+        url: string;
+        createdTime: string;
+        creatorToken: {
+            id: string;
+            description: string;
+        };
+        endTime: string | null;
+        startTime: string | null;
+        operationName: "bucketListingCreate";
+        operationParams: {
+            queue: string;
+        } & {
+            bucketId: string;
+        };
+        metrics: {
+            inCompressed: boolean;
+            inBytes: number;
+            inBytesUncompressed: number;
+            outCompressed: boolean;
+            outBytes: number;
+            outBytesUncompressed: number;
+        };
+    } & ({
+        status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+        results: null;
+    } | {
+        status: "error";
+        results: null;
+        error: {
+            code: string;
+            message: string;
+            exceptionId?: string;
+        };
+    } | {
+        status: "success";
+        results: null;
+    })>;
+    updateBucketListing: (bucketId: string, input: UpdateBucketListingInput, options?: Options) => Promise<{
+        id: number;
+        tableId: string | null;
+        runId: string;
+        url: string;
+        createdTime: string;
+        creatorToken: {
+            id: string;
+            description: string;
+        };
+        endTime: string | null;
+        startTime: string | null;
+        operationName: "bucketListingUpdate";
+        operationParams: {
+            queue: string;
+        } & {
+            bucketId: string;
+        };
+        metrics: {
+            inCompressed: boolean;
+            inBytes: number;
+            inBytesUncompressed: number;
+            outCompressed: boolean;
+            outBytes: number;
+            outBytesUncompressed: number;
+        };
+    } & ({
+        status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+        results: null;
+    } | {
+        status: "error";
+        results: null;
+        error: {
+            code: string;
+            message: string;
+            exceptionId?: string;
+        };
+    } | {
+        status: "success";
+        results: null;
+    })>;
+    deleteBucketListing: (bucketId: string, options?: Options) => Promise<{
+        id: number;
+        tableId: string | null;
+        runId: string;
+        url: string;
+        createdTime: string;
+        creatorToken: {
+            id: string;
+            description: string;
+        };
+        endTime: string | null;
+        startTime: string | null;
+        operationName: "bucketListingDelete";
+        operationParams: {
+            queue: string;
+        } & {
+            bucketId: string;
+        };
+        metrics: {
+            inCompressed: boolean;
+            inBytes: number;
+            inBytesUncompressed: number;
+            outCompressed: boolean;
+            outBytes: number;
+            outBytesUncompressed: number;
+        };
+    } & ({
+        status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+        results: null;
+    } | {
+        status: "error";
+        results: null;
+        error: {
+            code: string;
+            message: string;
+            exceptionId?: string;
+        };
+    } | {
+        status: "success";
+        results: null;
+    })>;
+};
+
+export { createStorageSdk as c };

package/dist/storageSdk-DCcD68FQ.d.ts

@@ -0,0 +1,143 @@
+import { CreateTableAsyncBody, TableCreateJob, TableImportAsyncBody, TableImportJob, TableExportAsyncBody, TableExportJob, BucketListing, CreateBucketListingInput, UpdateBucketListingInput } from './storage/types.js';
+import { c as createStorageClient } from './storageClient-BicsbzZy.js';
+
+type Options = {
+    interval?: number;
+    maxAttempts?: number;
+    abortSignal?: AbortSignal;
+};
+type StorageSdkOptions = {
+    storageClient: ReturnType<typeof createStorageClient>;
+};
+declare const createStorageSdk: ({ storageClient }: StorageSdkOptions) => {
+    createTable: (bucketId: string, body: CreateTableAsyncBody, options?: Options) => Promise<TableCreateJob>;
+    importFromFile: (tableId: string, body: TableImportAsyncBody, options?: Options) => Promise<TableImportJob>;
+    exportToFile: (tableId: string, body?: TableExportAsyncBody, options?: Options) => Promise<TableExportJob>;
+    getBucketListing: (bucketId: string, signal?: AbortSignal) => Promise<BucketListing | null>;
+    listBucketListings: (signal?: AbortSignal) => Promise<BucketListing[]>;
+    createBucketListing: (bucketId: string, input: CreateBucketListingInput, options?: Options) => Promise<{
+        id: number;
+        tableId: string | null;
+        runId: string;
+        url: string;
+        createdTime: string;
+        creatorToken: {
+            id: string;
+            description: string;
+        };
+        endTime: string | null;
+        startTime: string | null;
+        operationName: "bucketListingCreate";
+        operationParams: {
+            queue: string;
+        } & {
+            bucketId: string;
+        };
+        metrics: {
+            inCompressed: boolean;
+            inBytes: number;
+            inBytesUncompressed: number;
+            outCompressed: boolean;
+            outBytes: number;
+            outBytesUncompressed: number;
+        };
+    } & ({
+        status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+        results: null;
+    } | {
+        status: "error";
+        results: null;
+        error: {
+            code: string;
+            message: string;
+            exceptionId?: string;
+        };
+    } | {
+        status: "success";
+        results: null;
+    })>;
+    updateBucketListing: (bucketId: string, input: UpdateBucketListingInput, options?: Options) => Promise<{
+        id: number;
+        tableId: string | null;
+        runId: string;
+        url: string;
+        createdTime: string;
+        creatorToken: {
+            id: string;
+            description: string;
+        };
+        endTime: string | null;
+        startTime: string | null;
+        operationName: "bucketListingUpdate";
+        operationParams: {
+            queue: string;
+        } & {
+            bucketId: string;
+        };
+        metrics: {
+            inCompressed: boolean;
+            inBytes: number;
+            inBytesUncompressed: number;
+            outCompressed: boolean;
+            outBytes: number;
+            outBytesUncompressed: number;
+        };
+    } & ({
+        status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+        results: null;
+    } | {
+        status: "error";
+        results: null;
+        error: {
+            code: string;
+            message: string;
+            exceptionId?: string;
+        };
+    } | {
+        status: "success";
+        results: null;
+    })>;
+    deleteBucketListing: (bucketId: string, options?: Options) => Promise<{
+        id: number;
+        tableId: string | null;
+        runId: string;
+        url: string;
+        createdTime: string;
+        creatorToken: {
+            id: string;
+            description: string;
+        };
+        endTime: string | null;
+        startTime: string | null;
+        operationName: "bucketListingDelete";
+        operationParams: {
+            queue: string;
+        } & {
+            bucketId: string;
+        };
+        metrics: {
+            inCompressed: boolean;
+            inBytes: number;
+            inBytesUncompressed: number;
+            outCompressed: boolean;
+            outBytes: number;
+            outBytesUncompressed: number;
+        };
+    } & ({
+        status: Exclude<"error" | "success" | "warning" | "created" | "waiting" | "processing" | "terminating" | "terminated" | "cancelled", "success" | "error">;
+        results: null;
+    } | {
+        status: "error";
+        results: null;
+        error: {
+            code: string;
+            message: string;
+            exceptionId?: string;
+        };
+    } | {
+        status: "success";
+        results: null;
+    })>;
+};
+
+export { createStorageSdk as c };

package/dist/syncActions/index.cjs

@@ -1,372 +1,13 @@
 'use strict';
 
-var qs = require('qs');
-var z = require('zod');
+var chunkXUDMML5C_cjs = require('../chunk-XUDMML5C.cjs');
+require('../chunk-HPVTVQBJ.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
 
-var qs__default = /*#__PURE__*/_interopDefault(qs);
-var z__namespace = /*#__PURE__*/_interopNamespace(z);
-
-// 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;
-  }
-};
-
-// src/constants.ts
-var HttpStatus = {
-  NO_CONTENT: 204};
-
-// src/fetchClient/createFetchClient/utils.ts
-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 === HttpStatus.NO_CONTENT) 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__default.default.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/createOpenapiFetchClient.ts
-var createOpenapiFetchClient = (defaultOptions) => createFetchClient(defaultOptions);
-
-// src/clients/syncActions/constants.ts
-var SyncAction = {
-  DATA_APP_GIT_REPOSITORY: "git-repository",
-  GIT_REPOSITORY: "gitRepository",
-  ENROLL_MFA: "enrollMFA"
-};
-var Component = {
-  DATA_APP: "keboola.data-apps"
-};
-var Author = z__namespace.object({
-  name: z__namespace.string(),
-  email: z__namespace.email()
+Object.defineProperty(exports, "createSyncActionsClient", {
+  enumerable: true,
+  get: function () { return chunkXUDMML5C_cjs.createSyncActionsClient; }
 });
-var RepositoryBranch = z__namespace.object({
-  sha: z__namespace.string(),
-  date: z__namespace.string(),
-  comment: z__namespace.string(),
-  branch: z__namespace.string(),
-  author: Author
-});
-var Repository = z__namespace.object({
-  repository: z__namespace.object({
-    url: z__namespace.string()
-  }),
-  branches: z__namespace.array(RepositoryBranch)
-});
-
-// src/clients/syncActions/gitRepository/utils.ts
-var GitRepoConfigDataBuilder = class {
-  repositoryUrl;
-  config = {};
-  constructor(repositoryUrl) {
-    this.repositoryUrl = repositoryUrl;
-  }
-  withCredentials(username, password) {
-    this.config.username = username;
-    delete this.config["#sshKey"];
-    this.config["#password"] = password;
-    return this;
-  }
-  withSshKey(username, sshKey) {
-    this.config.username = username;
-    delete this.config["#password"];
-    this.config["#sshKey"] = sshKey;
-    return this;
-  }
-  build() {
-    return {
-      parameters: {
-        git: {
-          repo: this.repositoryUrl,
-          ...this.config
-        }
-      }
-    };
-  }
-  buildForDataApp() {
-    return {
-      parameters: {
-        dataApp: {
-          git: {
-            repository: this.repositoryUrl,
-            ...this.config
-          }
-        }
-      }
-    };
-  }
-};
-var createGitRepoConfigDataBuilder = (repositoryUrl) => new GitRepoConfigDataBuilder(repositoryUrl);
-
-// src/clients/syncActions/gitRepository/gitRepository.ts
-var createGitRepository = (sendSyncAction) => {
-  const getDataAppPublicGitRepository = async ({ repositoryUrl, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.DATA_APP_GIT_REPOSITORY,
-        componentId: Component.DATA_APP,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).buildForDataApp()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getDataAppPasswordPrivateGitRepository = async ({ repositoryUrl, username, password, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.DATA_APP_GIT_REPOSITORY,
-        componentId: Component.DATA_APP,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).withCredentials(username, password).buildForDataApp()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getDataAppSSHKeyPrivateGitRepository = async ({ repositoryUrl, username, sshKey, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.DATA_APP_GIT_REPOSITORY,
-        componentId: Component.DATA_APP,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).withSshKey(username, sshKey).buildForDataApp()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getPublicGitRepository = async ({ repositoryUrl, componentId, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.GIT_REPOSITORY,
-        componentId,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).build()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  const getPrivateGitRepository = async ({ repositoryUrl, username, password, componentId, ...other }, signal) => {
-    const data = await sendSyncAction(
-      {
-        ...other,
-        action: SyncAction.GIT_REPOSITORY,
-        componentId,
-        configData: createGitRepoConfigDataBuilder(repositoryUrl).withCredentials(username, password).build()
-      },
-      signal
-    );
-    return Repository.parse(data);
-  };
-  return {
-    getDataAppPublicGitRepository,
-    getDataAppPasswordPrivateGitRepository,
-    getDataAppSSHKeyPrivateGitRepository,
-    getPublicGitRepository,
-    getPrivateGitRepository
-  };
-};
-
-// src/clients/syncActions/syncActionsClient.ts
-var createSendSyncAction = (client) => {
-  return async (body, signal) => {
-    const { data } = await client.post(
-      "/actions",
-      {
-        body
-      },
-      { signal }
-    );
-    return data;
-  };
-};
-var createSyncActionsClient = ({ baseUrl, middlewares }) => {
-  const client = createOpenapiFetchClient({
-    baseUrl,
-    middlewares
-  });
-  const sendSyncAction = createSendSyncAction(client);
-  const enrollMFA = ({ email: email2, ...rest }, signal) => {
-    return sendSyncAction(
-      {
-        ...rest,
-        action: SyncAction.ENROLL_MFA,
-        configData: {
-          parameters: {
-            user: {
-              email: email2
-            }
-          }
-        }
-      },
-      signal
-    );
-  };
-  return {
-    enrollMFA,
-    gitRepository: createGitRepository(sendSyncAction)
-  };
-};
-
-exports.createSyncActionsClient = createSyncActionsClient;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map