@commercelayer/sdk 8.0.0-beta.8 → 8.0.0

package/lib/chunk-7OQXO6O6.cjs

@@ -0,0 +1,843 @@
+'use strict';
+
+var chunkNVCWUEL2_cjs = require('./chunk-NVCWUEL2.cjs');
+
+// ../sdk-runtime/src/debug.ts
+var PREFIX = "clsdk";
+var debugEnv = () => {
+  try {
+    return typeof process !== "undefined" ? process.env?.DEBUG ?? "" : "";
+  } catch {
+    return "";
+  }
+};
+var toMatcher = (pattern) => new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+var isEnabled = (namespace) => {
+  const env = debugEnv();
+  if (!env) return false;
+  return env.split(",").map((p) => p.trim()).filter(Boolean).some((p) => toMatcher(p).test(namespace));
+};
+var interpolate = (pattern, args) => {
+  let i = 0;
+  const out = pattern.replace(/%[oOjsdi%]/g, (token) => {
+    if (token === "%%") return "%";
+    if (i >= args.length) return token;
+    const arg = args[i++];
+    switch (token) {
+      case "%s":
+        return String(arg);
+      case "%d":
+      case "%i":
+        return String(Number(arg));
+      default:
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+    }
+  });
+  const rest = args.slice(i);
+  return rest.length > 0 ? `${out} ${rest.map((a) => safeStringify(a)).join(" ")}` : out;
+};
+var safeStringify = (value) => {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var debug = (namespace) => {
+  const full = `${PREFIX}:${namespace}`;
+  return (pattern, ...args) => {
+    if (!isEnabled(full)) return;
+    console.error(`${full} ${interpolate(pattern, args)}`);
+  };
+};
+var debug_default = debug;
+
+// ../sdk-runtime/src/fetch.ts
+var debug2 = debug_default("fetch");
+var FetchError = class _FetchError extends Error {
+  static NAME = "FetchError";
+  static isFetchError = (error) => {
+    return error instanceof _FetchError;
+  };
+  #errors;
+  #status;
+  #statusText;
+  #request;
+  constructor(status, statusText, body, request) {
+    super(statusText);
+    this.#status = status;
+    this.#statusText = statusText;
+    if (body) this.#errors = body.errors;
+    if (request) this.#request = request;
+    this.name = _FetchError.NAME;
+  }
+  get errors() {
+    return this.#errors;
+  }
+  get status() {
+    return this.#status;
+  }
+  get statusText() {
+    return this.#statusText;
+  }
+  get request() {
+    return this.#request;
+  }
+};
+var fetchURL = async (url, requestOptions, clientOptions) => {
+  debug2("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) => {
+    debug2("response: %O", json);
+    return json;
+  }).catch((err) => {
+    debug2("error: %s", err.message);
+    if (response.ok) throw new SdkError({ message: "Error parsing API response body", type: "parse" /* 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;
+};
+
+// ../sdk-runtime/src/error.ts
+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 || {});
+var SdkError = class _SdkError extends Error {
+  static NAME = "SdkError";
+  static isSdkError(error) {
+    return error && [_SdkError.NAME, ApiError.NAME].includes(error.name) && Object.values(ErrorType).includes(error.type);
+  }
+  type;
+  code;
+  source;
+  constructor(error) {
+    super(error.message);
+    this.name = _SdkError.NAME;
+    this.type = error.type || "client" /* CLIENT */;
+  }
+};
+var ApiError = class _ApiError extends SdkError {
+  static NAME = "ApiError";
+  static isApiError(error) {
+    return SdkError.isSdkError(error) && error.name === _ApiError.NAME && error.type === "response" /* RESPONSE */;
+  }
+  errors = [];
+  status;
+  statusText;
+  // constructor(error: SdkError)
+  constructor(error) {
+    super({ ...error, type: "response" /* RESPONSE */ });
+    this.name = _ApiError.NAME;
+  }
+  first() {
+    return this.errors?.length > 0 ? this.errors[0] : void 0;
+  }
+};
+var isRequestError = (error) => {
+  return error instanceof TypeError && error.message !== "fetch failed";
+};
+var isCancelError = (error) => {
+  return error instanceof DOMException && error.name === "AbortError";
+};
+var isTimeoutError = (error) => {
+  return error instanceof DOMException && error.name === "TimeoutError";
+};
+var 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));
+};
+var handleError = (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;
+};
+function isSdkError(error) {
+  return SdkError.isSdkError(error);
+}
+function isApiError(error) {
+  return ApiError.isApiError(error);
+}
+
+// ../sdk-runtime/src/util.ts
+var decodeJwtSegment = (segment) => atob(segment.replace(/-/g, "+").replace(/_/g, "/"));
+var COMMERCE_LAYER_DOMAINS = ["commercelayer.io", "commercelayer.co", "commercelayer.dev"];
+var domainFromIssuer = (iss) => {
+  if (typeof iss !== "string") return void 0;
+  let host;
+  try {
+    const url = new URL(iss);
+    if (url.protocol !== "https:") return void 0;
+    host = url.hostname;
+  } catch {
+    return void 0;
+  }
+  if (!host.startsWith("auth.")) return void 0;
+  const domain = host.slice("auth.".length);
+  const trusted = COMMERCE_LAYER_DOMAINS.some((d) => domain === d || domain.endsWith(`.${d}`));
+  return trusted ? domain : void 0;
+};
+var extractTokenData = (token) => {
+  try {
+    const data = JSON.parse(decodeJwtSegment(token.split(".")[1]));
+    return {
+      organization: data.organization?.slug,
+      domain: domainFromIssuer(data.iss),
+      expiration: data.exp
+    };
+  } catch (_err) {
+    return void 0;
+  }
+};
+var isTokenExpired = (token) => {
+  try {
+    const tokenData = extractTokenData(token);
+    return tokenData?.expiration ? tokenData.expiration * 1e3 - Date.now() < 0 : false;
+  } catch (_err) {
+    return false;
+  }
+};
+
+// ../sdk-runtime/src/config.ts
+var config = {
+  default: {
+    domain: "commercelayer.io",
+    pageNumber: 1,
+    pageSize: 10
+  },
+  client: {
+    timeout: 15e3,
+    requiredAttributes: ["organization", "accessToken"]
+  },
+  jsonapi: {
+    maxResourceIncluded: 2
+  }
+};
+var config_default = config;
+
+// ../sdk-runtime/src/client.ts
+var CLIENT_HEADER_NAME = "X-CL-SDK";
+var debug3 = debug_default("client");
+var baseURL = (organization, domain, apiVersion) => {
+  const versionSegment = apiVersion ? `/${apiVersion}` : "";
+  const subdomain = chunkNVCWUEL2_cjs.binding.subdomain ?? organization.toLowerCase();
+  return `https://${subdomain}.${domain || config_default.default.domain}/api${versionSegment}`;
+};
+var ApiClient = class _ApiClient {
+  static create(options) {
+    if ((!options.organization || !options.domain) && options.accessToken) {
+      const tokenData = extractTokenData(options.accessToken);
+      if (!options.organization && tokenData?.organization) options.organization = tokenData.organization;
+      if (!options.domain && tokenData?.domain) options.domain = tokenData.domain;
+    }
+    const required = chunkNVCWUEL2_cjs.binding.subdomain ? config_default.client.requiredAttributes.filter((a) => a !== "organization") : config_default.client.requiredAttributes;
+    for (const attr of required) if (!options[attr]) throw new SdkError({ message: `Undefined '${attr}' parameter` });
+    return new _ApiClient(options);
+  }
+  #baseUrl;
+  #accessToken;
+  #organization;
+  #domain;
+  #apiVersion;
+  #clientConfig;
+  #interceptors;
+  constructor(options) {
+    debug3("new client instance %O", options);
+    this.#apiVersion = options.apiVersion;
+    this.#baseUrl = baseURL(options.organization ?? "", options.domain, this.#apiVersion);
+    this.#accessToken = options.accessToken;
+    this.#organization = options.organization ?? "";
+    this.#domain = options.domain;
+    const fetchConfig = {
+      timeout: options.timeout || config_default.client.timeout,
+      fetch: options.fetch,
+      refreshToken: options.refreshToken
+    };
+    const customHeaders = this.customHeaders(options.headers);
+    const headers = {
+      ...customHeaders,
+      Accept: "application/vnd.api+json",
+      "Content-Type": "application/vnd.api+json",
+      Authorization: "Bearer " + this.#accessToken
+    };
+    if (options.telemetry !== false) headers[CLIENT_HEADER_NAME] = `js/${chunkNVCWUEL2_cjs.binding.name}-v${chunkNVCWUEL2_cjs.binding.sdkVersion}`;
+    if (options.userAgent) headers["User-Agent"] = options.userAgent;
+    fetchConfig.headers = headers;
+    this.#clientConfig = fetchConfig;
+    debug3("fetch config: %O", fetchConfig);
+    this.#interceptors = {};
+  }
+  get interceptors() {
+    return this.#interceptors;
+  }
+  get requestHeaders() {
+    if (!this.#clientConfig.headers) this.#clientConfig.headers = {};
+    return this.#clientConfig.headers;
+  }
+  /*
+  set requestHeaders(headers: RequestHeaders) {
+  	this.#clientConfig.headers = { ...this.#clientConfig.headers, ...headers }
+  }
+  */
+  config(config2) {
+    debug3("config %o", config2);
+    const def = this.#clientConfig;
+    if (!def.headers) def.headers = {};
+    if (config2.timeout) def.timeout = config2.timeout;
+    if (config2.userAgent) this.userAgent(config2.userAgent);
+    if (config2.fetch) this.#clientConfig.fetch = config2.fetch;
+    if (config2.refreshToken) this.#clientConfig.refreshToken = config2.refreshToken;
+    if (config2.apiVersion !== void 0) this.#apiVersion = config2.apiVersion;
+    if (config2.organization || config2.domain || config2.apiVersion !== void 0)
+      this.#baseUrl = baseURL(
+        config2.organization || this.#organization,
+        config2.domain || this.#domain,
+        this.#apiVersion
+      );
+    if (config2.organization) this.#organization = config2.organization;
+    if (config2.domain) this.#domain = config2.domain;
+    if (config2.accessToken) {
+      this.#accessToken = config2.accessToken;
+      def.headers.Authorization = "Bearer " + this.#accessToken;
+    }
+    if (config2.headers) def.headers = { ...def.headers, ...this.customHeaders(config2.headers) };
+    return this;
+  }
+  userAgent(userAgent) {
+    if (userAgent) this.requestHeaders["User-Agent"] = userAgent;
+    return this;
+  }
+  async request(method, path, body, options) {
+    debug3("request %s %s, %O, %O", method, path, body || {}, options || {});
+    if (options?.userAgent) debug3("User-Agent header ignored in request config");
+    const baseUrl = options?.organization || options?.apiVersion !== void 0 ? baseURL(
+      options.organization || this.#organization,
+      options.domain || this.#domain,
+      options.apiVersion ?? this.#apiVersion
+    ) : this.#baseUrl;
+    const url = new URL(`${baseUrl}/${path}`);
+    const bodyData = body ? JSON.stringify({ data: body }) : void 0;
+    const headers = { ...this.requestHeaders, ...this.customHeaders(options?.headers) };
+    const accessToken = options?.accessToken || this.#accessToken;
+    if (accessToken) headers.Authorization = "Bearer " + accessToken;
+    const refreshToken = options?.refreshToken || this.#clientConfig.refreshToken;
+    const fetchFunction = options?.fetch || this.#clientConfig.fetch;
+    const requestOptions = { method, body: bodyData, headers };
+    const timeout = options?.timeout || this.#clientConfig.timeout;
+    if (timeout) {
+      if (AbortSignal?.timeout) requestOptions.signal = AbortSignal.timeout(timeout);
+      else debug3("Timeout not set. Undefined function: %s", "AbortSignal.timeout");
+    }
+    if (options?.params)
+      Object.entries(options?.params).forEach(([name, value]) => {
+        url.searchParams.append(name, String(value));
+      });
+    const clientOptions = {
+      interceptors: this.interceptors,
+      fetch: fetchFunction
+    };
+    try {
+      return await fetchURL(url, requestOptions, clientOptions).catch((error) => handleError(error));
+    } catch (err) {
+      if (isExpiredTokenError(err) && refreshToken && isTokenExpired(accessToken)) {
+        debug3("Access token has expired");
+        const newAccessToken = await refreshToken(this.#accessToken).catch((e) => {
+          debug3("Refresh token error: %s", e.message);
+          const tokenError = new SdkError({ message: "Error refreshing access token", type: "token-refresh" /* TOKEN_REFRESH */ });
+          tokenError.source = e;
+          throw tokenError;
+        });
+        if (newAccessToken) {
+          debug3("Access token refreshed");
+          this.config({ accessToken: newAccessToken });
+          this.#accessToken = newAccessToken;
+          if (requestOptions.headers)
+            requestOptions.headers.Authorization = `Bearer ${newAccessToken}`;
+          const response = await fetchURL(url, requestOptions, clientOptions).catch(
+            (error) => handleError(error)
+          );
+          return response;
+        }
+      } else throw err;
+    }
+  }
+  customHeaders(headers) {
+    const customHeaders = {};
+    if (headers) {
+      for (const [name, value] of Object.entries(headers))
+        if (!["accept", "content-type", "authorization", "user-agent", CLIENT_HEADER_NAME.toLowerCase()].includes(
+          name.toLowerCase()
+        ))
+          customHeaders[name] = value;
+    }
+    return customHeaders;
+  }
+  get currentAccessToken() {
+    return this.#accessToken;
+  }
+  get currentOrganization() {
+    return this.#organization;
+  }
+  /** The API version pinned via `apiVersion`, or `undefined` when requests are unversioned. */
+  get currentApiVersion() {
+    return this.#apiVersion;
+  }
+};
+var client_default = ApiClient;
+
+// ../sdk-runtime/src/jsonapi.ts
+var debug4 = debug_default("jsonapi");
+var denormalize = (response) => {
+  if (!response) return response;
+  let denormalizedResponse;
+  if (response.links) delete response.links;
+  const data = response.data;
+  const included = response.included;
+  if (!data) denormalizedResponse = data;
+  else {
+    if (Array.isArray(data)) denormalizedResponse = data.map((res) => denormalizeResource(res, included));
+    else denormalizedResponse = denormalizeResource(data, included);
+  }
+  return denormalizedResponse;
+};
+var findIncluded = (rel, included = []) => {
+  const inc = included.find((inc2) => {
+    return rel.id === inc2.id && rel.type === inc2.type;
+  });
+  return inc || rel;
+};
+var denormalizeResource = (res, included, chain = []) => {
+  debug4("denormalize resource: %O, %o", res, included || {});
+  if (!res) return res;
+  const resource = {
+    id: res.id,
+    type: res.type,
+    ...res.attributes
+  };
+  if (res.meta) resource.meta = res.meta;
+  if (res.relationships)
+    Object.keys(res.relationships).forEach((key) => {
+      const rel = res.relationships[key].data;
+      if (rel) {
+        if (chain.filter((r) => r.id === rel.id && r.type === rel.type).length >= config_default.jsonapi.maxResourceIncluded)
+          resource[key] = rel;
+        else {
+          if (Array.isArray(rel))
+            resource[key] = rel.map(
+              (r) => denormalizeResource(findIncluded(r, included), included, [...chain, r])
+            );
+          else resource[key] = denormalizeResource(findIncluded(rel, included), included, [...chain, rel]);
+        }
+      } else if (rel === null) resource[key] = null;
+    });
+  debug4("denormalized resource: %O", resource);
+  return resource;
+};
+var normalize = (resource) => {
+  debug4("normalize resource: %O", resource);
+  const attributes = {};
+  const relationships = {};
+  for (const field in resource) {
+    if (["type", "id", "meta"].includes(field)) continue;
+    const value = resource[field];
+    if (Array.isArray(value) && value.length === 1 && isResourceType(value[0]) && value[0].id === null) {
+      relationships[field] = { data: [] };
+    } else if (value && isResourceType(value) && value.id === null) {
+      relationships[field] = { data: null };
+    } else if (value && (isResourceId(value) || Array.isArray(value) && isResourceId(value[0]))) {
+      relationships[field] = { data: value };
+    } else attributes[field] = value;
+  }
+  const normalized = {
+    type: resource.type,
+    attributes,
+    relationships
+  };
+  if (isResourceId(resource)) normalized.id = resource.id;
+  debug4("normalized resource: %O", normalized);
+  return normalized;
+};
+
+// ../sdk-runtime/src/query.ts
+var debug5 = debug_default("query");
+var arrayFilters = ["_any", "_all", "_in", "_not_in_or_null"];
+var isArrayFilter = (filter) => {
+  return arrayFilters.some((f) => filter.endsWith(f));
+};
+var objectFilters = ["_jcont"];
+var isObjectFilter = (filter) => {
+  return objectFilters.some((f) => filter.endsWith(f));
+};
+var isParamsList = (params) => {
+  return params && (params.filters || params.pageNumber || params.pageSize || params.sort || params.pageAfter || params.pageBefore);
+};
+var generateQueryStringParams = (params, res) => {
+  debug5("generate query string params: %O, %O", params, res);
+  const qp = {};
+  if (!params) return qp;
+  if (params.include) qp.include = params.include.join(",");
+  if (params.fields) {
+    if (Array.isArray(params.fields)) params.fields = { [res.type || res]: params.fields };
+    Object.entries(params.fields).forEach(([p, v]) => {
+      qp[`fields[${p}]`] = v.join(",");
+    });
+  }
+  if (isParamsList(params)) {
+    if (params.sort) {
+      if (Array.isArray(params.sort)) qp.sort = params.sort.join(",");
+      else
+        qp.sort = Object.entries(params.sort).map(([k, v]) => `${v === "desc" ? "-" : ""}${k}`).join(",");
+    }
+    if (params.pageNumber) qp["page[number]"] = String(params.pageNumber);
+    if (params.pageSize) qp["page[size]"] = String(params.pageSize);
+    if (params.pageAfter) qp["page[after]"] = String(params.pageAfter);
+    if (params.pageBefore) qp["page[before]"] = String(params.pageBefore);
+    if (params.filters) {
+      Object.entries(params.filters).forEach(([p, v]) => {
+        let val;
+        if (Array.isArray(v)) {
+          if (!isArrayFilter(p))
+            throw new SdkError({
+              message: `Incorrect filter [${p}]: Array value is supported only for the following filters: ${arrayFilters.join(", ")}`,
+              type: "request" /* REQUEST */
+            });
+          val = v.join(",");
+        } else if (typeof v === "object") {
+          if (!isObjectFilter(p))
+            throw new SdkError({
+              message: `Incorrect filter [${p}]: Object value is supported only for the following filters: ${objectFilters.join(", ")}`,
+              type: "request" /* REQUEST */
+            });
+          val = JSON.stringify(v);
+        } else val = String(v);
+        qp[`filter[q][${p}]`] = val;
+      });
+    }
+  }
+  debug5("query string params: %O", qp);
+  return qp;
+};
+
+// ../sdk-runtime/src/resource.ts
+var debug6 = debug_default("resource");
+var ListResponse = class extends Array {
+  meta;
+  constructor(meta, data) {
+    super(...data || []);
+    this.meta = meta;
+  }
+  first() {
+    return this.length ? this[0] : void 0;
+  }
+  last() {
+    return this.length ? this[this.length - 1] : void 0;
+  }
+  get(index) {
+    return this.length && index >= 0 ? this[index] : void 0;
+  }
+  hasNextPage() {
+    return this.meta.currentPage < this.meta.pageCount;
+  }
+  hasPrevPage() {
+    return this.meta.currentPage > 1;
+  }
+  getRecordCount() {
+    return this.meta.recordCount;
+  }
+  getRecordCountEstimated() {
+    return this.meta.recordCountEstimated;
+  }
+  getPageCount() {
+    return this.meta.pageCount;
+  }
+  get recordCount() {
+    return this.meta.recordCount;
+  }
+  get pageCount() {
+    return this.meta.pageCount;
+  }
+};
+var parseCursorLink = (url) => {
+  if (!url) return void 0;
+  let params;
+  try {
+    params = new URL(url).searchParams;
+  } catch {
+    return void 0;
+  }
+  const after = params.get("page[after]") ?? void 0;
+  const before = params.get("page[before]") ?? void 0;
+  return after != null || before != null ? { before, after } : void 0;
+};
+var buildListMeta = (res, links, params) => {
+  const recordsPerPage = params?.pageSize || config_default.default.pageSize;
+  if (res.meta?.page_count == null) {
+    return {
+      // Offset fields aren't applicable to cursor pagination; kept as NaN so the
+      // shared `meta.*` interface still resolves (see ListMeta).
+      pageCount: NaN,
+      recordCount: NaN,
+      recordCountEstimated: false,
+      currentPage: NaN,
+      recordsPerPage,
+      cursor: {
+        prev: parseCursorLink(links?.prev),
+        next: parseCursorLink(links?.next)
+      }
+    };
+  }
+  return {
+    pageCount: Number(res.meta?.page_count),
+    recordCount: Number(res.meta?.record_count),
+    recordCountEstimated: Boolean(res.meta?.record_count_estimated),
+    currentPage: params?.pageNumber || config_default.default.pageNumber,
+    recordsPerPage
+  };
+};
+var ApiResourceAdapter = class _ApiResourceAdapter {
+  static adapter;
+  constructor() {
+  }
+  static init(config2) {
+    _ApiResourceAdapter.adapter = new ResourceAdapter(config2);
+    debug6("resource adapter initialized");
+    return _ApiResourceAdapter.get();
+  }
+  static get(config2) {
+    if (config2) return _ApiResourceAdapter.init(config2);
+    else {
+      if (_ApiResourceAdapter.adapter) return _ApiResourceAdapter.adapter;
+      else throw new SdkError({ message: "Commerce Layer not initialized" });
+    }
+  }
+  static config(config2) {
+    _ApiResourceAdapter.get().config(config2);
+  }
+};
+var ResourceAdapter = class {
+  #client;
+  #config = {};
+  constructor(config2) {
+    this.#client = client_default.create(config2);
+    this.localConfig(config2);
+  }
+  localConfig(config2) {
+    Object.assign(this.#config, config2);
+  }
+  config(config2) {
+    debug6("config %o", config2);
+    this.localConfig(config2);
+    this.#client.config(config2);
+    return this;
+  }
+  get client() {
+    return this.#client;
+  }
+  async singleton(resource, params, options, path) {
+    debug6("singleton: %o, %O, %O", resource, params || {}, options || {});
+    const queryParams = generateQueryStringParams(params, resource);
+    if (options?.params) Object.assign(queryParams, options?.params);
+    const res = await this.#client.request("GET", `${path || resource.type}`, void 0, {
+      ...options,
+      params: queryParams
+    });
+    const r = denormalize(res);
+    return r;
+  }
+  async retrieve(resource, params, options) {
+    debug6("retrieve: %o, %O, %O", resource, params || {}, options || {});
+    const queryParams = generateQueryStringParams(params, resource);
+    if (options?.params) Object.assign(queryParams, options?.params);
+    const res = await this.#client.request("GET", `${resource.type}/${resource.id}`, void 0, {
+      ...options,
+      params: queryParams
+    });
+    const r = denormalize(res);
+    return r;
+  }
+  async list(resource, params, options) {
+    debug6("list: %o, %O, %O", resource, params || {}, options || {});
+    const queryParams = generateQueryStringParams(params, resource);
+    if (options?.params) Object.assign(queryParams, options?.params);
+    const usesCursor = queryParams["page[after]"] != null || queryParams["page[before]"] != null;
+    if (!usesCursor && !queryParams["page[number]"]) queryParams["page[number]"] = "1";
+    const res = await this.#client.request("GET", `${resource.type}`, void 0, { ...options, params: queryParams });
+    const links = res.links;
+    const r = denormalize(res);
+    return new ListResponse(buildListMeta(res, links, params), r);
+  }
+  async create(resource, params, options) {
+    debug6("create: %o, %O, %O", resource, params || {}, options || {});
+    const queryParams = generateQueryStringParams(params, resource);
+    if (options?.params) Object.assign(queryParams, options?.params);
+    const data = normalize(resource);
+    const res = await this.#client.request("POST", resource.type, data, { ...options, params: queryParams });
+    const r = denormalize(res);
+    return r;
+  }
+  async update(resource, params, options, path) {
+    debug6("update: %o, %O, %O", resource, params || {}, options || {});
+    const queryParams = generateQueryStringParams(params, resource);
+    if (options?.params) Object.assign(queryParams, options?.params);
+    const data = normalize(resource);
+    const res = await this.#client.request("PATCH", path || `${resource.type}/${resource.id}`, data, {
+      ...options,
+      params: queryParams
+    });
+    const r = denormalize(res);
+    return r;
+  }
+  async delete(resource, options) {
+    debug6("delete: %o, %O", resource, options || {});
+    await this.#client.request("DELETE", `${resource.type}/${resource.id}`, void 0, options);
+  }
+  /**
+   * Calls a non-CRUD endpoint hosted at a sub-path of a resource, e.g.
+   * `POST memberships/:id/resend`. These endpoints are not described by the
+   * public resources schema, so they are declared in a target config and
+   * emitted from it.
+   */
+  async action(cmd, path, payload, options) {
+    debug6("action: %o %o, %O", cmd, path, options || {});
+    const queryParams = {};
+    if (options?.params) Object.assign(queryParams, options.params);
+    const data = payload && isResourceId(payload) ? normalize(payload) : payload;
+    await this.#client.request(cmd, path, data, { ...options, params: queryParams });
+  }
+  async fetch(resource, path, params, options) {
+    debug6("fetch: %o, %O, %O", path, params || {}, options || {});
+    const queryParams = generateQueryStringParams(params, resource);
+    if (options?.params) Object.assign(queryParams, options?.params);
+    const res = await this.#client.request("GET", path, void 0, { ...options, params: queryParams });
+    const links = res.links;
+    const r = denormalize(res);
+    if (Array.isArray(r)) {
+      const p = params;
+      return new ListResponse(buildListMeta(res, links, p), r);
+    } else return r;
+  }
+};
+var ApiResourceBase = class {
+  static TYPE;
+  #resources;
+  constructor(adapter) {
+    debug6("new resource instance: %s", this.type());
+    if (adapter) this.#resources = adapter;
+  }
+  get resources() {
+    return this.#resources || ApiResourceAdapter.get();
+  }
+  /**
+   * Returns a copy of this resource instance bound to a specific
+   * `ResourceAdapter`. Used by the bundle client so each client instance
+   * routes requests through its own adapter (its own access token) instead
+   * of the process-global static adapter. Resource classes are type-only
+   * exports, so we clone via `this.constructor` rather than referencing the
+   * class directly.
+   */
+  withAdapter(adapter) {
+    return new this.constructor(adapter);
+  }
+  relationshipOneToOne(id) {
+    return id === null || typeof id === "string" ? { id, type: this.type() } : { id: id.id, type: this.type() };
+  }
+  relationshipOneToMany(...ids) {
+    return ids === null || ids.length === 0 || ids[0] === null ? [{ id: null, type: this.type() }] : ids.map((id) => {
+      return { id, type: this.type() };
+    });
+  }
+  path() {
+    return this.type();
+  }
+  // reference, reference_origin and metadata attributes are always updatable
+  async update(resource, params, options) {
+    return this.resources.update({ ...resource, type: this.type() }, params, options);
+  }
+};
+var ApiResource = class extends ApiResourceBase {
+  async retrieve(id, params, options) {
+    const resId = typeof id === "string" ? { type: this.type(), id } : id;
+    if (!resId.id) throw new SdkError({ message: "Resource id cannot be blank" });
+    return this.resources.retrieve(resId, params, options);
+  }
+  async list(params, options) {
+    return this.resources.list({ type: this.type() }, params, options);
+  }
+  async count(filter, options) {
+    const params = {
+      filters: isParamsList(filter) ? filter.filters : filter,
+      pageNumber: 1,
+      pageSize: 1
+    };
+    const response = await this.list(params, options);
+    return Promise.resolve(response.meta.recordCount);
+  }
+};
+var ApiSingleton = class extends ApiResourceBase {
+  async retrieve(params, options) {
+    return this.resources.singleton({ type: this.type() }, params, options, this.path());
+  }
+};
+var isResourceId = (resource) => {
+  return resource?.type && resource.id && chunkNVCWUEL2_cjs.binding.resourceList.includes(resource.type);
+};
+var isResourceType = (resource) => {
+  return resource?.type && chunkNVCWUEL2_cjs.binding.resourceList.includes(resource.type);
+};
+
+exports.ApiResource = ApiResource;
+exports.ApiResourceAdapter = ApiResourceAdapter;
+exports.ApiSingleton = ApiSingleton;
+exports.debug_default = debug_default;
+exports.isApiError = isApiError;
+exports.isSdkError = isSdkError;
+exports.isTokenExpired = isTokenExpired;
+//# sourceMappingURL=chunk-7OQXO6O6.cjs.map
+//# sourceMappingURL=chunk-7OQXO6O6.cjs.map