@shopware/api-client 0.3.0 → 0.5.0

package/admin-api-types/index.d.ts

@@ -0,0 +1 @@
+export * from "./apiTypes-6.5.3.0";

package/dist/index.cjs

@@ -0,0 +1,245 @@
+'use strict';
+
+const ofetch = require('ofetch');
+
+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);
+  return value;
+};
+class ApiClientError extends Error {
+  constructor(response) {
+    let message = "Failed request";
+    message += response._data?.errors.reduce((message2, error) => {
+      let pointer = "";
+      if (error.source?.pointer) {
+        pointer = `[${error.source.pointer}]`;
+      }
+      return `${message2}
+ - [${error.title}]${pointer} ${error.detail ?? ""}`;
+    }, "");
+    super(message);
+    /**
+     * Flag to indicate if the request was successful.
+     */
+    __publicField(this, "ok");
+    /**
+     * HTTP status code of the response.
+     */
+    __publicField(this, "status");
+    /**
+     * HTTP status text of the response.
+     */
+    __publicField(this, "statusText");
+    /**
+     * URL of the request.
+     */
+    __publicField(this, "url");
+    /**
+     * Details of the error.
+     */
+    __publicField(this, "details");
+    /**
+     * Headers of the response.
+     */
+    __publicField(this, "headers");
+    this.name = "ApiClientError";
+    this.details = response._data || {
+      errors: [{ title: "Unknown error", detail: "" }]
+    };
+    this.ok = response.ok;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.url = response.url;
+    this.headers = response.headers;
+  }
+}
+function errorInterceptor(response) {
+  throw new ApiClientError(response);
+}
+
+function transformPathToQuery(path, params) {
+  const [, method, pathDefinition, headerParams] = path.split(" ");
+  const [requestPath, queryParams] = pathDefinition.split("?");
+  const pathParams = requestPath.match(/{[^}]+}/g)?.map((param) => param.substring(1, param.length - 1)) || [];
+  const requestPathWithParams = pathParams.reduce((acc, paramName) => {
+    return acc.replace(`{${paramName}}`, params[paramName]);
+  }, requestPath);
+  const queryParamNames = queryParams?.split(",") || [];
+  const headerParamnames = headerParams?.split(",") || [];
+  const headers = {};
+  headerParamnames.forEach((paramName) => {
+    headers[paramName] = params[paramName];
+  });
+  const query = {};
+  queryParamNames.forEach((paramName) => {
+    let queryParamName = paramName;
+    if (Array.isArray(params[paramName]) && !queryParamName.includes("[]")) {
+      queryParamName += "[]";
+    }
+    query[queryParamName] = params[paramName];
+  });
+  const returnOptions = {
+    method: method.toUpperCase(),
+    headers,
+    query
+  };
+  if (!params) {
+    return [requestPathWithParams, returnOptions];
+  }
+  Object.keys(params).forEach((key) => {
+    if (!pathParams.includes(key) && !queryParamNames.includes(key) && !headerParamnames.includes(key)) {
+      returnOptions.body ?? (returnOptions.body = {});
+      Reflect.set(returnOptions.body, key, params[key]);
+    }
+  });
+  return [requestPathWithParams, returnOptions];
+}
+
+function createAPIClient(params) {
+  const defaultHeaders = {
+    "sw-access-key": params.accessToken
+  };
+  if (params.contextToken) {
+    defaultHeaders["sw-context-token"] = params.contextToken;
+  }
+  const apiFetch = ofetch.ofetch.create({
+    baseURL: params.baseURL,
+    // async onRequest({ request, options }) {},
+    // async onRequestError({ request, options, error }) {},
+    async onResponse(context) {
+      if (defaultHeaders["sw-context-token"] !== context.response.headers.get("sw-context-token")) {
+        const newContextToken = context.response.headers.get("sw-context-token") || "";
+        defaultHeaders["sw-context-token"] = newContextToken;
+        params.onContextChanged?.(newContextToken);
+      }
+    },
+    async onResponseError({ request, response, options }) {
+      errorInterceptor(response);
+    }
+  });
+  async function invoke(pathParam, ...params2) {
+    const [requestPath, options] = transformPathToQuery(
+      pathParam,
+      params2?.[0]
+    );
+    return apiFetch(
+      requestPath,
+      {
+        ...options,
+        headers: {
+          ...defaultHeaders,
+          ...options.headers
+        }
+      }
+    );
+  }
+  return {
+    invoke
+  };
+}
+function createAuthorizationHeader(token) {
+  if (!token)
+    return null;
+  if (token.startsWith("Bearer "))
+    return token;
+  return `Bearer ${token}`;
+}
+function createAdminAPIClient(params) {
+  const sessionData = {
+    accessToken: params.sessionData?.accessToken || "",
+    refreshToken: params.sessionData?.refreshToken || "",
+    expirationTime: Number(params.sessionData?.expirationTime || 0)
+  };
+  function updateSessionData(responseData) {
+    if (responseData?.access_token) {
+      defaultHeaders.Authorization = createAuthorizationHeader(
+        responseData.access_token
+      );
+      sessionData.accessToken = responseData.access_token;
+      sessionData.refreshToken = responseData.refresh_token;
+      sessionData.expirationTime = Date.now() + responseData.expires_in * 1e3;
+      params.onAuthChange?.({
+        ...sessionData
+      });
+    }
+  }
+  function setSessionData(data) {
+    sessionData.accessToken = data.accessToken;
+    sessionData.refreshToken = data.refreshToken;
+    sessionData.expirationTime = data.expirationTime;
+    return getSessionData();
+  }
+  function getSessionData() {
+    return { ...sessionData };
+  }
+  const defaultHeaders = {
+    Authorization: createAuthorizationHeader(sessionData.accessToken)
+  };
+  const apiFetch = ofetch.ofetch.create({
+    baseURL: params.baseURL,
+    async onRequest({ request, options }) {
+      const isExpired = sessionData.expirationTime <= Date.now();
+      if (isExpired && !request.toString().includes("/oauth/token")) {
+        await ofetch.ofetch("/oauth/token", {
+          baseURL: params.baseURL,
+          method: "POST",
+          body: {
+            grant_type: "refresh_token",
+            client_id: "administration",
+            refresh_token: sessionData.refreshToken || ""
+          },
+          headers: defaultHeaders,
+          onResponseError({ response }) {
+            errorInterceptor(response);
+          },
+          onResponse(context) {
+            updateSessionData(context.response._data);
+          }
+        });
+      }
+    },
+    async onResponse(context) {
+      updateSessionData(context.response._data);
+    },
+    async onResponseError({ request, response, options }) {
+      errorInterceptor(response);
+    }
+  });
+  async function invoke(pathParam, params2) {
+    const [requestPath, options] = transformPathToQuery(
+      pathParam,
+      params2
+    );
+    return apiFetch(
+      requestPath,
+      {
+        ...options,
+        headers: {
+          ...defaultHeaders,
+          ...options.headers
+        }
+      }
+    );
+  }
+  return {
+    /**
+     * Invoke API request based on provided path definition.
+     */
+    invoke,
+    /**
+     * Enables to change session data in runtime. Useful for testing purposes.
+     * Setting session data with this methis will **not** fire `onAuthChange` hook.
+     */
+    setSessionData,
+    /**
+     * Returns current session data. Useful for testing purposes, as in most cases you'll want to use `onAuthChange` hook for that.
+     */
+    getSessionData
+  };
+}
+
+exports.ApiClientError = ApiClientError;
+exports.createAPIClient = createAPIClient;
+exports.createAdminAPIClient = createAdminAPIClient;