@commercelayer/sdk 7.0.0-beta.1 → 7.0.0-beta.10

package/lib/common.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var api = require('./api');
+
+const isResourceId = (resource) => {
+  return resource?.type && resource.id && api.resourceList.includes(resource.type);
+};
+const isResourceType = (resource) => {
+  return resource && typeof resource.type !== "undefined" && resource.type && api.resourceList.includes(resource.type);
+};
+const DBG = {
+  verbose: false
+};
+
+exports.DBG = DBG;
+exports.isResourceId = isResourceId;
+exports.isResourceType = isResourceType;

package/lib/common.d.cts

@@ -0,0 +1,13 @@
+import { p as ResourceId, R as ResourceType } from './api-BYcswOJ0.cjs';
+import './client.cjs';
+import './interceptor-5MISI1yn.cjs';
+import './types.cjs';
+
+declare const isResourceId: (resource: any) => resource is ResourceId;
+declare const isResourceType: (resource: any) => resource is ResourceType;
+
+declare const DBG: {
+    verbose: boolean;
+};
+
+export { DBG, isResourceId, isResourceType };

package/lib/common.d.ts

@@ -0,0 +1,13 @@
+import { p as ResourceId, R as ResourceType } from './api-Cknm0QL_.js';
+import './client.js';
+import './interceptor-5MISI1yn.js';
+import './types.js';
+
+declare const isResourceId: (resource: any) => resource is ResourceId;
+declare const isResourceType: (resource: any) => resource is ResourceType;
+
+declare const DBG: {
+    verbose: boolean;
+};
+
+export { DBG, isResourceId, isResourceType };

package/lib/common.js

@@ -0,0 +1,13 @@
+import { resourceList } from './api';
+
+const isResourceId = (resource) => {
+  return resource?.type && resource.id && resourceList.includes(resource.type);
+};
+const isResourceType = (resource) => {
+  return resource && typeof resource.type !== "undefined" && resource.type && resourceList.includes(resource.type);
+};
+const DBG = {
+  verbose: false
+};
+
+export { DBG, isResourceId, isResourceType };

package/lib/config.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const config = {
+  default: {
+    domain: "commercelayer.io",
+    pageNumber: 1,
+    pageSize: 10
+  },
+  client: {
+    timeout: 15e3,
+    requiredAttributes: ["organization", "accessToken"]
+  },
+  jsonapi: {
+    maxResourceIncluded: 2
+  }
+};
+var config_default = config;
+
+module.exports = config_default;
+
+module.exports = exports.default;

package/lib/config.d.cts

@@ -0,0 +1,19 @@
+import { ApiClientInitConfig } from './client.cjs';
+import './interceptor-5MISI1yn.cjs';
+
+declare const config: {
+    readonly default: {
+        readonly domain: "commercelayer.io";
+        readonly pageNumber: 1;
+        readonly pageSize: 10;
+    };
+    readonly client: {
+        readonly timeout: 15000;
+        readonly requiredAttributes: Array<keyof ApiClientInitConfig>;
+    };
+    readonly jsonapi: {
+        readonly maxResourceIncluded: 2;
+    };
+};
+
+export = config;

package/lib/config.d.ts

@@ -0,0 +1,19 @@
+import { ApiClientInitConfig } from './client.js';
+import './interceptor-5MISI1yn.js';
+
+declare const config: {
+    readonly default: {
+        readonly domain: "commercelayer.io";
+        readonly pageNumber: 1;
+        readonly pageSize: 10;
+    };
+    readonly client: {
+        readonly timeout: 15000;
+        readonly requiredAttributes: Array<keyof ApiClientInitConfig>;
+    };
+    readonly jsonapi: {
+        readonly maxResourceIncluded: 2;
+    };
+};
+
+export { config as default };

package/lib/config.js

@@ -0,0 +1,17 @@
+const config = {
+  default: {
+    domain: "commercelayer.io",
+    pageNumber: 1,
+    pageSize: 10
+  },
+  client: {
+    timeout: 15e3,
+    requiredAttributes: ["organization", "accessToken"]
+  },
+  jsonapi: {
+    maxResourceIncluded: 2
+  }
+};
+var config_default = config;
+
+export { config_default as default };

package/lib/debug.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+const debuggerFunction = (_pattern, ..._args) => {
+};
+let debuggerFactory = (_namespace) => debuggerFunction;
+try {
+  const debugModule = require("debug");
+  if (debugModule && typeof debugModule === "function") debuggerFactory = debugModule;
+} catch (error) {
+}
+const debugPrefix = "clsdk";
+const debug = (namespace) => {
+  return debuggerFactory(`${debugPrefix}:${namespace}`);
+};
+var debug_default = debug;
+
+module.exports = debug_default;
+
+module.exports = exports.default;

package/lib/debug.d.cts

@@ -0,0 +1,4 @@
+type Debugger = (pattern: string, ...args: any[]) => void;
+declare const debug: (namespace: string) => Debugger;
+
+export = debug;

package/lib/debug.d.ts

@@ -0,0 +1,4 @@
+type Debugger = (pattern: string, ...args: any[]) => void;
+declare const debug: (namespace: string) => Debugger;
+
+export { debug as default };

package/lib/debug.js

@@ -0,0 +1,15 @@
+const debuggerFunction = (_pattern, ..._args) => {
+};
+let debuggerFactory = (_namespace) => debuggerFunction;
+try {
+  const debugModule = require("debug");
+  if (debugModule && typeof debugModule === "function") debuggerFactory = debugModule;
+} catch (error) {
+}
+const debugPrefix = "clsdk";
+const debug = (namespace) => {
+  return debuggerFactory(`${debugPrefix}:${namespace}`);
+};
+var debug_default = debug;
+
+export { debug_default as default };

package/lib/error.cjs

@@ -0,0 +1,97 @@
+'use strict';
+
+var fetch = require('./fetch');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["CLIENT"] = "client";
+  ErrorType2["REQUEST"] = "request";
+  ErrorType2["RESPONSE"] = "response";
+  ErrorType2["CANCEL"] = "cancel";
+  ErrorType2["PARSE"] = "parse";
+  ErrorType2["TIMEOUT"] = "timeout";
+  ErrorType2["TOKEN_REFRESH"] = "token-refresh";
+  return ErrorType2;
+})(ErrorType || {});
+const _SdkError = class _SdkError extends Error {
+  constructor(error) {
+    super(error.message);
+    __publicField(this, "type");
+    __publicField(this, "code");
+    __publicField(this, "source");
+    this.name = _SdkError.NAME;
+    this.type = error.type || "client" /* CLIENT */;
+  }
+  static isSdkError(error) {
+    return error && [_SdkError.NAME, ApiError.NAME].includes(error.name) && Object.values(ErrorType).includes(error.type);
+  }
+};
+__publicField(_SdkError, "NAME", "SdkError");
+let SdkError = _SdkError;
+const _ApiError = class _ApiError extends SdkError {
+  // constructor(error: SdkError)
+  constructor(error) {
+    super({ ...error, type: "response" /* RESPONSE */ });
+    __publicField(this, "errors", []);
+    __publicField(this, "status");
+    __publicField(this, "statusText");
+    this.name = _ApiError.NAME;
+  }
+  static isApiError(error) {
+    return SdkError.isSdkError(error) && error.name === _ApiError.NAME && error.type === "response" /* RESPONSE */;
+  }
+  first() {
+    return this.errors?.length > 0 ? this.errors[0] : void 0;
+  }
+};
+__publicField(_ApiError, "NAME", "ApiError");
+let ApiError = _ApiError;
+const isRequestError = (error) => {
+  return error instanceof TypeError && error.message !== "fetch failed";
+};
+const isCancelError = (error) => {
+  return error instanceof DOMException && error.name === "AbortError";
+};
+const isTimeoutError = (error) => {
+  return error instanceof DOMException && error.name === "TimeoutError";
+};
+const isExpiredTokenError = (error) => {
+  const invalidTokenCodes = [
+    "INVALID_TOKEN"
+    /*, 'UNAUTHORIZED' */
+  ];
+  return ApiError.isApiError(error) && error.status === 401 && (invalidTokenCodes.includes(error.code || "") || error.errors && error.errors.length > 0 && invalidTokenCodes.includes(error.errors[0].code));
+};
+const handleError = (error) => {
+  console.log(error);
+  if (SdkError.isSdkError(error) || ApiError.isApiError(error)) throw error;
+  let sdkError = new SdkError({ message: error.message });
+  if (fetch.FetchError.isFetchError(error)) {
+    const apiError = new ApiError(sdkError);
+    apiError.type = "response" /* RESPONSE */;
+    apiError.status = error.status;
+    apiError.statusText = error.statusText;
+    apiError.code = String(apiError.status);
+    apiError.errors = error.errors || [];
+    if (!apiError.message && apiError.statusText) apiError.message = apiError.statusText;
+    sdkError = apiError;
+  } else if (isRequestError(error)) {
+    sdkError.type = "request" /* REQUEST */;
+  } else if (isCancelError(error)) {
+    sdkError.type = "cancel" /* CANCEL */;
+  } else if (isTimeoutError(error)) {
+    sdkError.type = "timeout" /* TIMEOUT */;
+  } else {
+    sdkError.type = "client" /* CLIENT */;
+    sdkError.source = error;
+  }
+  throw sdkError;
+};
+
+exports.ApiError = ApiError;
+exports.ErrorType = ErrorType;
+exports.SdkError = SdkError;
+exports.handleError = handleError;
+exports.isExpiredTokenError = isExpiredTokenError;

package/lib/error.d.cts

@@ -0,0 +1,35 @@
+declare enum ErrorType {
+    CLIENT = "client",// Generic Client error
+    REQUEST = "request",// Error preparing API request
+    RESPONSE = "response",// Error response from API
+    CANCEL = "cancel",// Forced request abort using interceptor
+    PARSE = "parse",// Error parsing API resource
+    TIMEOUT = "timeout",// Timeout error
+    TOKEN_REFRESH = "token-refresh"
+}
+declare class SdkError extends Error {
+    static NAME: string;
+    static isSdkError(error: any): error is SdkError;
+    type: ErrorType;
+    code?: string;
+    source?: Error;
+    constructor(error: {
+        message: string;
+        type?: ErrorType;
+    });
+}
+declare class ApiError extends SdkError {
+    static NAME: string;
+    static isApiError(error: any): error is ApiError;
+    errors: any[];
+    status?: number;
+    statusText?: string;
+    constructor(error: {
+        message: string;
+    });
+    first(): any;
+}
+declare const isExpiredTokenError: (error: any) => boolean;
+declare const handleError: (error: Error) => never;
+
+export { ApiError, ErrorType, SdkError, handleError, isExpiredTokenError };

package/lib/error.d.ts

@@ -0,0 +1,35 @@
+declare enum ErrorType {
+    CLIENT = "client",// Generic Client error
+    REQUEST = "request",// Error preparing API request
+    RESPONSE = "response",// Error response from API
+    CANCEL = "cancel",// Forced request abort using interceptor
+    PARSE = "parse",// Error parsing API resource
+    TIMEOUT = "timeout",// Timeout error
+    TOKEN_REFRESH = "token-refresh"
+}
+declare class SdkError extends Error {
+    static NAME: string;
+    static isSdkError(error: any): error is SdkError;
+    type: ErrorType;
+    code?: string;
+    source?: Error;
+    constructor(error: {
+        message: string;
+        type?: ErrorType;
+    });
+}
+declare class ApiError extends SdkError {
+    static NAME: string;
+    static isApiError(error: any): error is ApiError;
+    errors: any[];
+    status?: number;
+    statusText?: string;
+    constructor(error: {
+        message: string;
+    });
+    first(): any;
+}
+declare const isExpiredTokenError: (error: any) => boolean;
+declare const handleError: (error: Error) => never;
+
+export { ApiError, ErrorType, SdkError, handleError, isExpiredTokenError };

package/lib/error.js

@@ -0,0 +1,91 @@
+import { FetchError } from './fetch';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["CLIENT"] = "client";
+  ErrorType2["REQUEST"] = "request";
+  ErrorType2["RESPONSE"] = "response";
+  ErrorType2["CANCEL"] = "cancel";
+  ErrorType2["PARSE"] = "parse";
+  ErrorType2["TIMEOUT"] = "timeout";
+  ErrorType2["TOKEN_REFRESH"] = "token-refresh";
+  return ErrorType2;
+})(ErrorType || {});
+const _SdkError = class _SdkError extends Error {
+  constructor(error) {
+    super(error.message);
+    __publicField(this, "type");
+    __publicField(this, "code");
+    __publicField(this, "source");
+    this.name = _SdkError.NAME;
+    this.type = error.type || "client" /* CLIENT */;
+  }
+  static isSdkError(error) {
+    return error && [_SdkError.NAME, ApiError.NAME].includes(error.name) && Object.values(ErrorType).includes(error.type);
+  }
+};
+__publicField(_SdkError, "NAME", "SdkError");
+let SdkError = _SdkError;
+const _ApiError = class _ApiError extends SdkError {
+  // constructor(error: SdkError)
+  constructor(error) {
+    super({ ...error, type: "response" /* RESPONSE */ });
+    __publicField(this, "errors", []);
+    __publicField(this, "status");
+    __publicField(this, "statusText");
+    this.name = _ApiError.NAME;
+  }
+  static isApiError(error) {
+    return SdkError.isSdkError(error) && error.name === _ApiError.NAME && error.type === "response" /* RESPONSE */;
+  }
+  first() {
+    return this.errors?.length > 0 ? this.errors[0] : void 0;
+  }
+};
+__publicField(_ApiError, "NAME", "ApiError");
+let ApiError = _ApiError;
+const isRequestError = (error) => {
+  return error instanceof TypeError && error.message !== "fetch failed";
+};
+const isCancelError = (error) => {
+  return error instanceof DOMException && error.name === "AbortError";
+};
+const isTimeoutError = (error) => {
+  return error instanceof DOMException && error.name === "TimeoutError";
+};
+const isExpiredTokenError = (error) => {
+  const invalidTokenCodes = [
+    "INVALID_TOKEN"
+    /*, 'UNAUTHORIZED' */
+  ];
+  return ApiError.isApiError(error) && error.status === 401 && (invalidTokenCodes.includes(error.code || "") || error.errors && error.errors.length > 0 && invalidTokenCodes.includes(error.errors[0].code));
+};
+const handleError = (error) => {
+  console.log(error);
+  if (SdkError.isSdkError(error) || ApiError.isApiError(error)) throw error;
+  let sdkError = new SdkError({ message: error.message });
+  if (FetchError.isFetchError(error)) {
+    const apiError = new ApiError(sdkError);
+    apiError.type = "response" /* RESPONSE */;
+    apiError.status = error.status;
+    apiError.statusText = error.statusText;
+    apiError.code = String(apiError.status);
+    apiError.errors = error.errors || [];
+    if (!apiError.message && apiError.statusText) apiError.message = apiError.statusText;
+    sdkError = apiError;
+  } else if (isRequestError(error)) {
+    sdkError.type = "request" /* REQUEST */;
+  } else if (isCancelError(error)) {
+    sdkError.type = "cancel" /* CANCEL */;
+  } else if (isTimeoutError(error)) {
+    sdkError.type = "timeout" /* TIMEOUT */;
+  } else {
+    sdkError.type = "client" /* CLIENT */;
+    sdkError.source = error;
+  }
+  throw sdkError;
+};
+
+export { ApiError, ErrorType, SdkError, handleError, isExpiredTokenError };

package/lib/fetch.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var error = require('./error');
+var Debug = require('./debug');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Debug__default = /*#__PURE__*/_interopDefault(Debug);
+
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _errors, _status, _statusText, _request;
+const debug = Debug__default.default("fetch");
+const _FetchError = class _FetchError extends Error {
+  constructor(status, statusText, body, request) {
+    super(statusText);
+    __privateAdd(this, _errors);
+    __privateAdd(this, _status);
+    __privateAdd(this, _statusText);
+    __privateAdd(this, _request);
+    __privateSet(this, _status, status);
+    __privateSet(this, _statusText, statusText);
+    if (body) __privateSet(this, _errors, body.errors);
+    if (request) __privateSet(this, _request, request);
+  }
+  get errors() {
+    return __privateGet(this, _errors);
+  }
+  get status() {
+    return __privateGet(this, _status);
+  }
+  get statusText() {
+    return __privateGet(this, _statusText);
+  }
+  get request() {
+    return __privateGet(this, _request);
+  }
+};
+_errors = new WeakMap();
+_status = new WeakMap();
+_statusText = new WeakMap();
+_request = new WeakMap();
+__publicField(_FetchError, "isFetchError", (error) => {
+  return error instanceof _FetchError;
+});
+let FetchError = _FetchError;
+const fetchURL = async (url, requestOptions, clientOptions) => {
+  debug("fetch: %s, %O, native[%s]", url, requestOptions || {}, clientOptions?.fetch ? "no" : "yes");
+  const interceptors = clientOptions?.interceptors;
+  if (interceptors?.request?.onSuccess) ({ url, options: requestOptions } = await interceptors.request.onSuccess({ url, options: requestOptions }));
+  const fetchClient = clientOptions?.fetch || fetch;
+  let response = await fetchClient(url, requestOptions);
+  if (response.ok) {
+    if (interceptors?.rawReader?.onSuccess) await interceptors.rawReader.onSuccess(response);
+    if (interceptors?.response?.onSuccess) response = await interceptors.response.onSuccess(response);
+  } else {
+    if (interceptors?.rawReader?.onFailure) await interceptors.rawReader.onFailure(response);
+  }
+  const responseBody = response.body && response.status !== 204 ? await response.json().then((json) => {
+    debug("response: %O", json);
+    return json;
+  }).catch((err) => {
+    debug("error: %s", err.message);
+    if (response.ok) throw new error.SdkError({ message: "Error parsing API response body", type: error.ErrorType.PARSE });
+  }) : void 0;
+  if (!response.ok) {
+    let error = new FetchError(response.status, response.statusText, responseBody, requestOptions);
+    if (interceptors?.response?.onFailure) error = await interceptors.response.onFailure(error);
+    if (error) throw error;
+  }
+  return responseBody;
+};
+
+exports.FetchError = FetchError;
+exports.fetchURL = fetchURL;

package/lib/fetch.d.cts

@@ -0,0 +1 @@
+export { F as Fetch, i as FetchClientOptions, j as FetchError, h as FetchRequestOptions, g as FetchResponse, k as fetchURL } from './interceptor-5MISI1yn.cjs';

package/lib/fetch.d.ts

@@ -0,0 +1 @@
+export { F as Fetch, i as FetchClientOptions, j as FetchError, h as FetchRequestOptions, g as FetchResponse, k as fetchURL } from './interceptor-5MISI1yn.js';

package/lib/fetch.js

@@ -0,0 +1,76 @@
+import { SdkError, ErrorType } from './error';
+import Debug from './debug';
+
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _errors, _status, _statusText, _request;
+const debug = Debug("fetch");
+const _FetchError = class _FetchError extends Error {
+  constructor(status, statusText, body, request) {
+    super(statusText);
+    __privateAdd(this, _errors);
+    __privateAdd(this, _status);
+    __privateAdd(this, _statusText);
+    __privateAdd(this, _request);
+    __privateSet(this, _status, status);
+    __privateSet(this, _statusText, statusText);
+    if (body) __privateSet(this, _errors, body.errors);
+    if (request) __privateSet(this, _request, request);
+  }
+  get errors() {
+    return __privateGet(this, _errors);
+  }
+  get status() {
+    return __privateGet(this, _status);
+  }
+  get statusText() {
+    return __privateGet(this, _statusText);
+  }
+  get request() {
+    return __privateGet(this, _request);
+  }
+};
+_errors = new WeakMap();
+_status = new WeakMap();
+_statusText = new WeakMap();
+_request = new WeakMap();
+__publicField(_FetchError, "isFetchError", (error) => {
+  return error instanceof _FetchError;
+});
+let FetchError = _FetchError;
+const fetchURL = async (url, requestOptions, clientOptions) => {
+  debug("fetch: %s, %O, native[%s]", url, requestOptions || {}, clientOptions?.fetch ? "no" : "yes");
+  const interceptors = clientOptions?.interceptors;
+  if (interceptors?.request?.onSuccess) ({ url, options: requestOptions } = await interceptors.request.onSuccess({ url, options: requestOptions }));
+  const fetchClient = clientOptions?.fetch || fetch;
+  let response = await fetchClient(url, requestOptions);
+  if (response.ok) {
+    if (interceptors?.rawReader?.onSuccess) await interceptors.rawReader.onSuccess(response);
+    if (interceptors?.response?.onSuccess) response = await interceptors.response.onSuccess(response);
+  } else {
+    if (interceptors?.rawReader?.onFailure) await interceptors.rawReader.onFailure(response);
+  }
+  const responseBody = response.body && response.status !== 204 ? await response.json().then((json) => {
+    debug("response: %O", json);
+    return json;
+  }).catch((err) => {
+    debug("error: %s", err.message);
+    if (response.ok) throw new SdkError({ message: "Error parsing API response body", type: ErrorType.PARSE });
+  }) : void 0;
+  if (!response.ok) {
+    let error = new FetchError(response.status, response.statusText, responseBody, requestOptions);
+    if (interceptors?.response?.onFailure) error = await interceptors.response.onFailure(error);
+    if (error) throw error;
+  }
+  return responseBody;
+};
+
+export { FetchError, fetchURL };