@keboola/api-client 25.0.0 → 29.0.0

package/dist/import-KLH1uRtx.cjs

@@ -0,0 +1,121 @@
+const require_createOpenapiFetchClient = require("./createOpenapiFetchClient-Cr90VXY4.cjs");
+const require_auth = require("./auth-5HCvCsZO.cjs");
+//#region src/fetchClient/xhrFetch.ts
+const parseResponseHeaders = (raw) => {
+	const headers = new Headers();
+	for (const line of raw.trim().split(/[\r\n]+/)) {
+		const separator = line.indexOf(":");
+		if (separator < 0) continue;
+		headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+	}
+	return headers;
+};
+const createAbortError = () => new DOMException("The operation was aborted.", "AbortError");
+const BODILESS_STATUSES = [204, 205];
+const BODILESS_METHODS = ["GET", "HEAD"];
+/**
+* A `fetch` implementation backed by XHR, for the `fetchFn` escape hatch: `fetch` cannot observe
+* request-body upload progress outside Chromium, `xhr.upload.onprogress` can.
+*/
+const xhrFetch = (onProgress) => {
+	return async (input, init) => {
+		if (typeof XMLHttpRequest === "undefined") return fetch(input, init);
+		const request = new Request(input, init);
+		const body = BODILESS_METHODS.includes(request.method) ? null : await request.blob();
+		if (request.signal.aborted) throw createAbortError();
+		const { promise, resolve, reject } = Promise.withResolvers();
+		const xhr = new XMLHttpRequest();
+		const handleProgress = (event) => {
+			if (!event.lengthComputable) return;
+			onProgress({
+				loaded: event.loaded,
+				total: event.total,
+				percent: event.loaded / event.total * 100
+			});
+		};
+		const handleLoad = () => {
+			resolve(new Response(BODILESS_STATUSES.includes(xhr.status) ? null : xhr.response, {
+				status: xhr.status,
+				statusText: xhr.statusText,
+				headers: parseResponseHeaders(xhr.getAllResponseHeaders())
+			}));
+		};
+		const handleError = () => reject(/* @__PURE__ */ new TypeError("Failed to fetch"));
+		const handleAbort = () => reject(createAbortError());
+		xhr.open(request.method, request.url, true);
+		xhr.responseType = "blob";
+		xhr.withCredentials = request.credentials === "include";
+		request.headers.forEach((value, name) => xhr.setRequestHeader(name, value));
+		xhr.upload.addEventListener("progress", handleProgress);
+		xhr.addEventListener("load", handleLoad);
+		xhr.addEventListener("error", handleError);
+		xhr.addEventListener("abort", handleAbort);
+		request.signal.addEventListener("abort", () => xhr.abort(), { once: true });
+		xhr.send(body);
+		return promise;
+	};
+};
+//#endregion
+//#region src/clients/import/utils.ts
+/**
+* Every field the importer takes is a form part, named exactly as the spec names it: flags go as
+* `1` when on and are left out when off (so the service applies its own default), and arrays repeat
+* under the `[]`-suffixed name. The payload rides along as the `data` part — `file` is the public
+* API's word for it, not the wire's.
+*/
+const createFormData = (fields) => {
+	const formData = new FormData();
+	for (const [name, value] of Object.entries(fields)) {
+		if (!value) continue;
+		if (Array.isArray(value)) for (const item of value) formData.append(`${name}[]`, item);
+		else formData.append(name, value === true ? "1" : value);
+	}
+	return formData;
+};
+//#endregion
+//#region src/clients/import/importClient.ts
+const createImportClient = ({ baseUrl, middlewares, auth }) => {
+	const client = require_createOpenapiFetchClient.createOpenapiFetchClient({
+		baseUrl,
+		middlewares,
+		headers: require_auth.createAuthHeaders(auth)
+	});
+	const uploadFile = async ({ file, ...fields }, { signal, onProgress } = {}) => {
+		const { data } = await client.post("/upload-file", { body: createFormData({
+			data: file,
+			...fields
+		}) }, {
+			signal,
+			fetchFn: onProgress ? xhrFetch(onProgress) : void 0
+		});
+		return data;
+	};
+	const writeTable = async ({ file, ...fields }, { signal, onProgress } = {}) => {
+		const { data } = await client.post("/write-table", { body: createFormData({
+			data: file,
+			...fields
+		}) }, {
+			signal,
+			fetchFn: onProgress ? xhrFetch(onProgress) : void 0
+		});
+		return data;
+	};
+	const healthCheck = async (signal) => {
+		const { data } = await client.get("/health-check", {}, { signal });
+		return data;
+	};
+	return {
+		healthCheck,
+		uploadFile,
+		writeTable
+	};
+};
+//#endregion
+Object.defineProperty(exports, "createImportClient", {
+	enumerable: true,
+	get: function() {
+		return createImportClient;
+	}
+});
+
+//# sourceMappingURL=import-KLH1uRtx.cjs.map

package/dist/import-KLH1uRtx.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-KLH1uRtx.cjs","names":["createOpenapiFetchClient","createAuthHeaders"],"sources":["../src/fetchClient/xhrFetch.ts","../src/clients/import/utils.ts","../src/clients/import/importClient.ts"],"sourcesContent":["import type { FetchFn } from './createFetchClient';\n\nexport type UploadProgress = {\n  loaded: number;\n  total: number;\n  percent: number;\n};\n\nconst parseResponseHeaders = (raw: string) => {\n  const headers = new Headers();\n\n  for (const line of raw.trim().split(/[\\r\\n]+/)) {\n    const separator = line.indexOf(':');\n    if (separator < 0) continue;\n\n    headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());\n  }\n\n  return headers;\n};\n\nconst createAbortError = () => new DOMException('The operation was aborted.', 'AbortError');\n\n// `new Response(body)` throws for these statuses even when the body is empty.\nconst BODILESS_STATUSES = [204, 205];\n\nconst BODILESS_METHODS = ['GET', 'HEAD'];\n\n/**\n * A `fetch` implementation backed by XHR, for the `fetchFn` escape hatch: `fetch` cannot observe\n * request-body upload progress outside Chromium, `xhr.upload.onprogress` can.\n */\nexport const xhrFetch = (onProgress: (progress: UploadProgress) => void): FetchFn => {\n  return async (input, init) => {\n    // Node has no XHR, and asking for progress is not worth failing an upload over — the caller\n    // simply gets no progress events there.\n    if (typeof XMLHttpRequest === 'undefined') return fetch(input, init);\n\n    const request = new Request(input, init);\n    const body = BODILESS_METHODS.includes(request.method) ? null : await request.blob();\n\n    if (request.signal.aborted) throw createAbortError();\n\n    const { promise, resolve, reject } = Promise.withResolvers<Response>();\n    const xhr = new XMLHttpRequest();\n\n    const handleProgress = (event: ProgressEvent) => {\n      if (!event.lengthComputable) return;\n\n      onProgress({\n        loaded: event.loaded,\n        total: event.total,\n        percent: (event.loaded / event.total) * 100,\n      });\n    };\n\n    const handleLoad = () => {\n      resolve(\n        new Response(BODILESS_STATUSES.includes(xhr.status) ? null : xhr.response, {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: parseResponseHeaders(xhr.getAllResponseHeaders()),\n        }),\n      );\n    };\n\n    // `TypeError` for parity with `fetch` — `isFetchClientError` keys off it.\n    const handleError = () => reject(new TypeError('Failed to fetch'));\n    const handleAbort = () => reject(createAbortError());\n\n    xhr.open(request.method, request.url, true);\n    xhr.responseType = 'blob';\n    xhr.withCredentials = request.credentials === 'include';\n\n    // The body we send is the one this `Request` serialized, so its `content-type` — multipart\n    // boundary included — describes those exact bytes and can be forwarded as-is.\n    request.headers.forEach((value, name) => xhr.setRequestHeader(name, value));\n\n    xhr.upload.addEventListener('progress', handleProgress);\n    xhr.addEventListener('load', handleLoad);\n    xhr.addEventListener('error', handleError);\n    xhr.addEventListener('abort', handleAbort);\n    request.signal.addEventListener('abort', () => xhr.abort(), { once: true });\n\n    xhr.send(body);\n\n    return promise;\n  };\n};\n","/**\n * Every field the importer takes is a form part, named exactly as the spec names it: flags go as\n * `1` when on and are left out when off (so the service applies its own default), and arrays repeat\n * under the `[]`-suffixed name. The payload rides along as the `data` part — `file` is the public\n * API's word for it, not the wire's.\n */\nexport const createFormData = (\n  fields: Record<string, string | boolean | string[] | File | null | undefined>,\n) => {\n  const formData = new FormData();\n\n  for (const [name, value] of Object.entries(fields)) {\n    if (!value) {\n      continue;\n    }\n\n    if (Array.isArray(value)) {\n      for (const item of value) {\n        formData.append(`${name}[]`, item);\n      }\n    } else {\n      formData.append(name, value === true ? '1' : value);\n    }\n  }\n\n  return formData;\n};\n","import type { UploadProgress } from '../../fetchClient';\nimport { createOpenapiFetchClient, xhrFetch } from '../../fetchClient';\nimport { createAuthHeaders } from '../auth';\nimport type { ClientInitOptions } from '../types';\n\nimport type { paths } from './__generated__/schema';\nimport type { UploadFileInput, WriteTableInput } from './types';\nimport { createFormData } from './utils';\n\ntype Options = {\n  signal?: AbortSignal;\n  onProgress?: (progress: UploadProgress) => void;\n};\n\nexport const createImportClient = ({ baseUrl, middlewares, auth }: ClientInitOptions) => {\n  const client = createOpenapiFetchClient<paths>({\n    baseUrl,\n    middlewares,\n    headers: createAuthHeaders(auth),\n  });\n\n  const uploadFile = async (\n    { file, ...fields }: UploadFileInput,\n    { signal, onProgress }: Options = {},\n  ) => {\n    const { data } = await client.post(\n      '/upload-file',\n      { body: createFormData({ data: file, ...fields }) },\n      { signal, fetchFn: onProgress ? xhrFetch(onProgress) : undefined },\n    );\n\n    return data;\n  };\n\n  const writeTable = async (\n    { file, ...fields }: WriteTableInput,\n    { signal, onProgress }: Options = {},\n  ) => {\n    const { data } = await client.post(\n      '/write-table',\n      { body: createFormData({ data: file, ...fields }) },\n      { signal, fetchFn: onProgress ? xhrFetch(onProgress) : undefined },\n    );\n\n    return data;\n  };\n\n  const healthCheck = async (signal?: AbortSignal) => {\n    const { data } = await client.get('/health-check', {}, { signal });\n\n    return data;\n  };\n\n  return {\n    healthCheck,\n    uploadFile,\n    writeTable,\n  };\n};\n"],"mappings":"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"}

package/dist/index-8pN6Emos.d.ts

@@ -0,0 +1,218 @@
+import * as z$1 from "zod";
+import { IStringifyOptions } from "qs";
+//#region src/errors/ApiError.d.ts
+declare class ApiError extends Error {
+  response: Response;
+  request: Request;
+  data: unknown;
+  constructor({ response, request, data }: ApiResponse);
+}
+//#endregion
+//#region src/fetchClient/createFetchClient/types.d.ts
+type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options';
+type PathParam = Record<string, string | number>;
+type QueryParam = Record<string, unknown>;
+type BodyParam = Record<string, unknown> | FormData | string | undefined | null | Record<string, unknown>[];
+type ValidateStatusFn = (options: ApiResponse) => boolean | ApiError;
+type CustomRequestInit = Omit<RequestInit, 'method' | 'body'>;
+type FetchFn = typeof fetch;
+type CreateFetchClientOptions = {
+  baseUrl: string;
+  validateStatus?: ValidateStatusFn;
+  middlewares?: MiddlewareFn[];
+  fetchFn?: FetchFn;
+} & CustomRequestInit;
+type FetchClientOptions = {
+  validateStatus?: ValidateStatusFn;
+  queryArrayFormat?: IStringifyOptions['arrayFormat'];
+  middlewares?: MiddlewareFn[];
+  fetchFn?: FetchFn;
+} & CustomRequestInit;
+type ApiResponse<Data = unknown> = {
+  data: Data;
+  response: Response;
+  request: Request;
+};
+type FetchRequest = {
+  request: Request;
+  validateStatus: ValidateStatusFn;
+  fetchFn?: FetchFn;
+};
+type CoreFetchFn = (request: FetchRequest) => Promise<ApiResponse>;
+type MiddlewareFn = (next: CoreFetchFn) => CoreFetchFn;
+//#endregion
+//#region src/errors/ManagementClientAuthError.d.ts
+declare class ManagementClientAuthError extends ApiError {
+  title: string;
+  message: string;
+  constructor(title: string, message: string, res: ApiResponse);
+}
+//#endregion
+//#region src/errors/ValidationError.d.ts
+/**
+ * A payload the SDK refused to accept — an input a caller assembled wrongly, or a response that did
+ * not match the shape the endpoint is documented to return.
+ *
+ * It exists so a `ZodError` never leaves the package. `ZodError.message` is `JSON.stringify` of its
+ * issue list — over a kilobyte for two problems — and a consumer that renders a caught error's
+ * message puts that blob in front of a user. `message` here is a single line built for exactly that
+ * rendering, while `issues` keeps the structured detail for anyone inspecting the failure rather
+ * than displaying it.
+ */
+declare class ValidationError extends Error {
+  issues: z$1.core.$ZodIssue[];
+  constructor(message: string, issues?: z$1.core.$ZodIssue[]);
+}
+declare const isValidationError: (error: unknown) => error is ValidationError;
+/**
+ * Parses with `schema`, converting a `ZodError` into a {@link ValidationError}. Use it instead of a
+ * bare `schema.parse()` anywhere the value crosses the package boundary — every client input and
+ * every response body.
+ */
+declare const parseOrThrow: <T extends z$1.ZodType>(schema: T, value: unknown) => z$1.output<T>;
+//#endregion
+//#region src/fetchClient/createFetchClient/createFetchClient.d.ts
+type FetchClientError = TypeError | ApiError | SyntaxError | DOMException;
+declare const isApiError: (error: unknown) => error is ApiError;
+declare const isAbortError: (error: unknown) => error is DOMException;
+declare const isFetchClientError: (error: unknown) => error is FetchClientError;
+//#endregion
+//#region src/fetchClient/createFetchClient/utils.d.ts
+declare const HttpHeader: {
+  CONTENT_TYPE: string;
+  CONTENT_DISPOSITION: string;
+  AUTHORIZATION: string;
+  IDEMPOTENCY_KEY: string;
+  IF_MATCH: string;
+};
+declare const HttpContentType: {
+  JSON: string;
+  TEXT_PLAIN: string;
+  FORM_DATA: string;
+  TEXT_HTML: string;
+};
+//#endregion
+//#region src/fetchClient/createGenericFetchClient.d.ts
+type FetchParams<Path = PathParam, Query = QueryParam, Body = BodyParam> = {
+  path?: Path;
+  query?: Query;
+  body?: Body;
+};
+type FetchMethod$1 = <Data, Path = PathParam, Query = QueryParam, Body = BodyParam>(url: string, params: FetchParams<Path, Query, Body>, options?: FetchClientOptions) => Promise<ApiResponse<Data>>;
+type FetchClient$1 = {
+  get: FetchMethod$1;
+  post: FetchMethod$1;
+  put: FetchMethod$1;
+  patch: FetchMethod$1;
+  delete: FetchMethod$1;
+};
+declare const createGenericFetchClient: (defaultOptions: CreateFetchClientOptions) => FetchClient$1;
+//#endregion
+//#region src/fetchClient/xhrFetch.d.ts
+type UploadProgress = {
+  loaded: number;
+  total: number;
+  percent: number;
+};
+//#endregion
+//#region src/fetchClient/types.d.ts
+type OpenapiQueryType<Operation> = Operation extends {
+  parameters?: {
+    query?: infer Query;
+  };
+} ? Query : never;
+type OpenapiPathType<Operation> = Operation extends {
+  parameters?: {
+    path?: infer Path;
+  };
+} ? Path : never;
+type HasRequestBody<Operation> = Operation extends {
+  requestBody?: never;
+} ? false : true;
+type HasOptionalBody<Operation> = Operation extends {
+  requestBody: unknown;
+} ? false : true;
+type OpenapiBodyType<Operation> = HasRequestBody<Operation> extends true ? Operation extends {
+  requestBody?: {
+    content: {
+      'application/json': infer RequestBody;
+    };
+  };
+} ? RequestBody : Operation extends {
+  requestBody: {
+    content: {
+      'application/json': infer RequestBody;
+    };
+  };
+} ? RequestBody : Operation extends {
+  requestBody: {
+    content: {
+      'application/vnd.api+json': infer RequestBody;
+    };
+  };
+} ? RequestBody : Operation extends {
+  requestBody?: {
+    content: {
+      'multipart/form-data': unknown;
+    };
+  };
+} ? FormData : Operation extends {
+  requestBody: {
+    content: {
+      'application/x-www-form-urlencoded': infer RequestBody;
+    };
+  };
+} ? RequestBody : never : never;
+/**
+ * The per-field shape of a `multipart/form-data` body — the complement of `OpenapiBodyType`, which
+ * resolves such an operation to the `FormData` that goes on the wire and so cannot report the
+ * fields inside it. Clients derive their input types from this rather than restating the field list.
+ */
+type OpenapiFormDataType<Operation> = Operation extends {
+  requestBody?: {
+    content: {
+      'multipart/form-data': infer Fields;
+    };
+  };
+} ? { [Key in keyof Fields as Key extends `${infer Name}[]` ? Name : Key]: Fields[Key]; } : never;
+type OpenapiBodyParam<Operation> = OpenapiBodyType<Operation> extends never ? {
+  body?: never;
+} : HasOptionalBody<Operation> extends true ? {
+  body?: OpenapiBodyType<Operation>;
+} : {
+  body: OpenapiBodyType<Operation>;
+};
+type InferOpenapiParametersType<Operation> = Operation extends {
+  parameters?: infer P;
+} ? P : never;
+type OpenapiParametersType<Operation> = Omit<InferOpenapiParametersType<Operation>, 'cookie' | 'header'> & OpenapiBodyParam<Operation>;
+type OpenapiResponseTypes<OP> = OP extends {
+  responses: infer R;
+} ? { [S in keyof R]: R[S] extends {
+  content: {
+    'text/plain': infer S;
+  };
+} ? S : R[S] extends {
+  content: {
+    'application/json': infer C;
+  };
+} ? C : S extends 'default' ? R[S] : never; } : never;
+type OpenapiSuccessType<T> = 200 extends keyof T ? T[200] : 201 extends keyof T ? T[201] : 202 extends keyof T ? T[202] : 204 extends keyof T ? T[204] : 'default' extends keyof T ? T['default'] : unknown;
+type OpenapiReturnType<OP> = OpenapiSuccessType<OpenapiResponseTypes<OP>>;
+type ArrayElement<T> = T extends (infer U)[] ? U : never;
+//#endregion
+//#region src/fetchClient/createOpenapiFetchClient.d.ts
+type OpenapiPaths<Paths> = { [P in keyof Paths]: { [M in HttpMethod]?: unknown; }; };
+type PathsWithMethod<Paths extends OpenapiPaths<Paths>, PathnameMethod extends HttpMethod> = { [Pathname in keyof Paths]: Paths[Pathname] extends { [K in PathnameMethod]: any; } ? Pathname : never; }[keyof Paths];
+type FetchMethod<Paths extends OpenapiPaths<Paths>, Method extends HttpMethod> = <Path extends PathsWithMethod<Paths, Method>>(url: Path, params: OpenapiParametersType<Paths[Path][Method]>, options?: FetchClientOptions) => Promise<ApiResponse<OpenapiReturnType<Paths[Path][Method]>>>;
+type FetchClient<Paths extends OpenapiPaths<Paths>> = {
+  get: FetchMethod<Paths, 'get'>;
+  post: FetchMethod<Paths, 'post'>;
+  put: FetchMethod<Paths, 'put'>;
+  patch: FetchMethod<Paths, 'patch'>;
+  delete: FetchMethod<Paths, 'delete'>;
+};
+declare const createOpenapiFetchClient: <Paths extends OpenapiPaths<Paths>>(defaultOptions: CreateFetchClientOptions) => FetchClient<Paths>;
+//#endregion
+export { MiddlewareFn as C, HttpMethod as S, ApiError as T, ValidationError as _, OpenapiParametersType as a, ManagementClientAuthError as b, OpenapiReturnType as c, HttpContentType as d, HttpHeader as f, isFetchClientError as g, isApiError as h, OpenapiFormDataType as i, UploadProgress as l, isAbortError as m, ArrayElement as n, OpenapiPathType as o, FetchClientError as p, OpenapiBodyType as r, OpenapiQueryType as s, createOpenapiFetchClient as t, createGenericFetchClient as u, isValidationError as v, ValidateStatusFn as w, ApiResponse as x, parseOrThrow as y };
+//# sourceMappingURL=index-8pN6Emos.d.ts.map