@shopware/api-client 1.2.0 → 1.3.0

package/api-types/storeApiTypes.overrides.ts

@@ -43,72 +43,6 @@ export type Schemas = {
     entity?: "product";
     sorting?: string;
   };
-  SwagPaypalVaultToken: {
-    // TODO: [OpenAPI][SwagPaypalVaultToken] - add SwagPaypalVaultToken definition to schema
-    /** Format: date-time */
-    createdAt: string;
-    customer?: components["schemas"]["Customer"];
-    customerId: string;
-    id?: string;
-    identifier: string;
-    mainMapping?: components["schemas"]["SwagPaypalVaultTokenMapping"];
-    paymentMethod?: components["schemas"]["PaymentMethod"];
-    paymentMethodId: string;
-    /** Format: date-time */
-    updatedAt?: string;
-  };
 };
 
-export type operations = {
-  "updateLineItem patch /checkout/cart/line-item": {
-    contentType?: "application/json";
-    accept?: "application/json";
-    headers?: {
-      /** Instructs Shopware to return the response in the given language. */
-      "sw-language-id"?: string;
-    };
-    body: {
-      // TODO: [OpenAPI][updateLineItem] - add proper request body type with required fields
-      items: Array<{
-        id: string;
-        quantity: number;
-      }>;
-    };
-    response: components["schemas"]["Cart"];
-    responseCode: 200;
-  };
-  "readProduct post /product": {
-    contentType?: "application/json";
-    accept?: "application/json";
-    headers?: {
-      /** Instructs Shopware to return the response in the given language. */
-      "sw-language-id"?: string;
-    };
-    body?: components["schemas"]["Criteria"];
-    response: {
-      elements: components["schemas"]["Product"][]; // TODO: [OpenAPI][readProduct]: add elements property as required
-    } & components["schemas"]["EntitySearchResult"];
-    responseCode: 200;
-  };
-  "readShippingMethod post /shipping-method": {
-    contentType?: "application/json";
-    accept?: "application/json";
-    headers?: {
-      /** Instructs Shopware to return the response in the given language. */
-      "sw-language-id"?: string;
-    };
-    query?: {
-      /** List only available shipping methods. This filters shipping methods methods which can not be used in the actual context because of their availability rule. */
-      onlyAvailable?: boolean;
-    };
-    body?: components["schemas"]["Criteria"];
-    response: {
-      /** aggregation result */
-      aggregations?: Record<string, never>;
-      elements: components["schemas"]["ShippingMethod"][]; // TODO: [OpenAPI][readShippingMethod]: response should be `EntitySearchResult` and elements should be required
-      /** Total amount */
-      total?: number;
-    };
-    responseCode: 200;
-  };
-};
+// export type operations = {};

package/dist/index.cjs

@@ -50,10 +50,7 @@ function createHeaders(init, hookCallback) {
 
 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;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 class ApiClientError extends Error {
   constructor(response) {
     let message = "Failed request";
@@ -116,7 +113,7 @@ function errorInterceptor(response) {
 function createPathWithParams(requestPath, pathParams) {
   return Object.keys(pathParams || {}).reduce((acc, paramName) => {
     return acc.replace(`{${paramName}}`, pathParams[paramName]);
-  }, requestPath);
+  }, requestPath || "");
 }
 
 function createAPIClient(params) {
@@ -135,25 +132,31 @@ function createAPIClient(params) {
       }
     }
   );
-  const apiFetch = ofetch.ofetch.create({
-    baseURL: params.baseURL,
-    ...params.fetchOptions,
-    // async onRequest({ request, options }) {},
-    // async onRequestError({ request, options, error }) {},
-    async onResponse(context) {
-      apiClientHooks.callHook("onSuccessResponse", context.response);
-      if (context.response.headers.has("sw-context-token") && 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;
+  let currentBaseURL = params.baseURL;
+  let currentAccessToken = params.accessToken;
+  function createFetchClient(baseURL) {
+    return ofetch.ofetch.create({
+      baseURL,
+      ...params.fetchOptions,
+      async onRequest(context) {
+        apiClientHooks.callHook("onRequest", context);
+      },
+      async onResponse(context) {
+        apiClientHooks.callHook("onSuccessResponse", context.response);
+        if (context.response.headers.has("sw-context-token") && 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;
+        }
+      },
+      async onResponseError({ response }) {
+        apiClientHooks.callHook("onResponseError", response);
+        errorInterceptor(response);
       }
-    },
-    async onResponseError({ response }) {
-      apiClientHooks.callHook("onResponseError", response);
-      errorInterceptor(response);
-    }
-  });
+    });
+  }
+  let apiFetch = createFetchClient(currentBaseURL);
   async function invoke(pathParam, ...params2) {
     const [, method, requestPath] = pathParam.split(" ");
     const currentParams = params2[0] || {};
@@ -164,9 +167,10 @@ function createAPIClient(params) {
     const fetchOptions = {
       ...currentParams.fetchOptions || {}
     };
-    const mergedHeaders = defu__default(currentParams.headers, defaultHeaders);
+    let mergedHeaders = defu__default(currentParams.headers, defaultHeaders);
     if (mergedHeaders?.["Content-Type"]?.includes("multipart/form-data") && typeof window !== "undefined") {
-      mergedHeaders["Content-Type"] = void 0;
+      const { "Content-Type": _, ...headersWithoutContentType } = mergedHeaders;
+      mergedHeaders = headersWithoutContentType;
     }
     const resp = await apiFetch.raw(requestPathWithParams, {
       ...fetchOptions,
@@ -186,15 +190,37 @@ function createAPIClient(params) {
      * Default headers used in every client request (if not overriden in specific request).
      */
     defaultHeaders,
-    hook: apiClientHooks.hook
+    hook: apiClientHooks.hook,
+    /**
+     * Update the base configuration for API client
+     */
+    updateBaseConfig: (config) => {
+      let shouldRecreateClient = false;
+      if (config.baseURL !== void 0 && config.baseURL !== currentBaseURL) {
+        currentBaseURL = config.baseURL;
+        shouldRecreateClient = true;
+      }
+      if (config.accessToken !== void 0 && config.accessToken !== currentAccessToken) {
+        currentAccessToken = config.accessToken;
+        defaultHeaders["sw-access-key"] = config.accessToken;
+      }
+      if (shouldRecreateClient) {
+        apiFetch = createFetchClient(currentBaseURL);
+      }
+    },
+    /**
+     * Get the current base configuration
+     */
+    getBaseConfig: () => ({
+      baseURL: currentBaseURL,
+      accessToken: currentAccessToken
+    })
   };
 }
 
 function createAuthorizationHeader(token) {
-  if (!token)
-    return "";
-  if (token.startsWith("Bearer "))
-    return token;
+  if (!token) return "";
+  if (token.startsWith("Bearer ")) return token;
   return `Bearer ${token}`;
 }
 function createAdminAPIClient(params) {
@@ -261,8 +287,7 @@ function createAdminAPIClient(params) {
             errorInterceptor(response);
           },
           onResponse(context) {
-            if (!context.response._data)
-              return;
+            if (!context.response._data) return;
             updateSessionData(context.response._data);
             options.headers.set(
               "Authorization",