@shopware/api-client 0.5.0 → 1.0.0

package/api-types/storeApiTypes.overrides.ts

@@ -0,0 +1,182 @@
+import { components as mainComponents } from "./storeApiTypes";
+
+export type components = mainComponents;
+//   & {
+//   schemas: schemas;
+// };
+
+export type Schemas = {
+  ProductListingResult: components["schemas"]["EntitySearchResult"] & {
+    /** @enum {string} */
+    apiAlias: "product_listing";
+    /** Contains the available sorting. These can be used to show a sorting select-box in the product listing. */
+    availableSortings: {
+      /** @enum {string} */
+      apiAlias: "product_sorting";
+      key: string;
+      label: string;
+      priority: number;
+      translated: {
+        apiAlias?: string;
+        key?: string;
+        label: string;
+      };
+    }[];
+    /** Contains the state of the filters. These can be used to create listing filters. */
+    currentFilters: {
+      manufacturer: string[];
+      navigationId: string;
+      price: {
+        /** @default 0 */
+        max: number;
+        /** @default 0 */
+        min: number;
+      };
+      properties: string[];
+      rating?: number; // TODO: [OpenAPI][ProductListingResult] - rating should be defined the same as in body of the request
+      search: string; // TODO: [OpenAPI][ProductListingResult] - search should be required as is required in body of the request, otherwise everywhere optional
+      /** @default false */
+      "shipping-free": boolean;
+    };
+    elements: components["schemas"]["Product"][];
+    /** @enum {string} */
+    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 = {
+  "register post /account/register": {
+    contentType?: "application/json";
+    accept?: "application/json";
+    body: {
+      /** Flag indicating accepted data protection */
+      acceptedDataProtection: boolean;
+      /**
+       * Account type of the customer which can be either `private` or `business`.
+       * @default private
+       */
+      accountType?: string;
+      /** Field can be used to store an affiliate tracking code */
+      affiliateCode?: string;
+      billingAddress: Omit<
+        components["schemas"]["CustomerAddress"],
+        "createdAt" | "id" | "customerId" | "firstName" | "lastName"
+      >; // TODO: [OpenAPI][register] - omit id, createdAt, customerId, firstName, lastName while creating address (or better to reverse and pick required fields)
+      /** Birthday day */
+      birthdayDay?: number;
+      /** Birthday month */
+      birthdayMonth?: number;
+      /** Birthday year */
+      birthdayYear?: number;
+      /** Field can be used to store a campaign tracking code */
+      campaignCode?: string;
+      /** Email of the customer. Has to be unique, unless `guest` is `true` */
+      email: string;
+      /** Customer first name. Value will be reused for shipping and billing address if not provided explicitly. */
+      firstName: string;
+      /**
+       * If set, will create a guest customer. Guest customers can re-use an email address and don't need a password.
+       * @default false
+       */
+      guest?: boolean;
+      /** Customer last name. Value will be reused for shipping and billing address if not provided explicitly. */
+      lastName: string;
+      /** Password for the customer. Required, unless `guest` is `true` */
+      password: string;
+      /** Id of the salutation for the customer account. Fetch options using `salutation` endpoint. */
+      salutationId: string;
+      shippingAddress?: components["schemas"]["CustomerAddress"];
+      /** URL of the storefront for that registration. Used in confirmation emails. Has to be one of the configured domains of the sales channel. */
+      storefrontUrl: string;
+      /** (Academic) title of the customer */
+      title?: string;
+    };
+    response: components["schemas"]["Customer"];
+    responseCode: 200;
+  };
+  "addLineItem post /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][addLineItem] - add proper request body type with required fields
+      items: Array<{
+        id?: string; // TODO: [OpenAPI][addLineItem] - check if this is used at all?
+        referencedId: string;
+        quantity?: number;
+        type: "product" | "promotion" | "custom" | "credit"; // TODO: [OpenAPI][addLineItem] - add proper type -> see also #456
+      }>;
+    };
+    response: components["schemas"]["Cart"];
+    responseCode: 200;
+  };
+  "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;
+  };
+};

package/dist/index.cjs

@@ -1,6 +1,47 @@
 'use strict';
 
 const ofetch = require('ofetch');
+const hookable = require('hookable');
+const defu = require('defu');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const defu__default = /*#__PURE__*/_interopDefaultCompat(defu);
+
+function createHeaders(init) {
+  const _headers = {
+    "Content-Type": "application/json"
+  };
+  const handler = {
+    get: (target, prop) => {
+      if (prop === "apply") {
+        return apply;
+      }
+      return Reflect.get(target, prop);
+    },
+    set: (target, prop, value) => {
+      if (prop === "apply") {
+        throw new Error("Cannot override apply method");
+      }
+      return Reflect.set(target, prop, value);
+    }
+  };
+  const headersProxy = new Proxy(
+    _headers,
+    handler
+  );
+  function apply(headers) {
+    for (const [key, value] of Object.entries(headers)) {
+      if (value) {
+        headersProxy[key] = value;
+      } else {
+        delete headersProxy[key];
+      }
+    }
+  }
+  headersProxy.apply({ ...init });
+  return headersProxy;
+}
 
 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;
@@ -11,14 +52,23 @@ var __publicField = (obj, key, value) => {
 class ApiClientError extends Error {
   constructor(response) {
     let message = "Failed request";
-    message += response._data?.errors.reduce((message2, error) => {
+    const errorDetails = response._data || {
+      errors: [
+        {
+          title: "Unknown error",
+          detail: "API did not return errors, but request failed. Please check the network tab."
+        }
+      ]
+    };
+    message += errorDetails.errors?.reduce((message2, error) => {
       let pointer = "";
       if (error.source?.pointer) {
         pointer = `[${error.source.pointer}]`;
       }
+      const details = error.detail ?? "No error details provided.";
       return `${message2}
- - [${error.title}]${pointer} ${error.detail ?? ""}`;
-    }, "");
+ - [${error.title}]${pointer} ${details}`;
+    }, "") ?? "";
     super(message);
     /**
      * Flag to indicate if the request was successful.
@@ -45,9 +95,7 @@ class ApiClientError extends Error {
      */
     __publicField(this, "headers");
     this.name = "ApiClientError";
-    this.details = response._data || {
-      errors: [{ title: "Unknown error", detail: "" }]
-    };
+    this.details = errorDetails;
     this.ok = response.ok;
     this.status = response.status;
     this.statusText = response.statusText;
@@ -55,188 +103,203 @@ class ApiClientError extends Error {
     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]);
+function createPathWithParams(requestPath, pathParams) {
+  return Object.keys(pathParams || {}).reduce((acc, paramName) => {
+    return acc.replace(`{${paramName}}`, pathParams[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 defaultHeaders = createHeaders({
+    "sw-access-key": params.accessToken,
+    Accept: "application/json",
+    "sw-context-token": params.contextToken,
+    ...params.defaultHeaders
+  });
+  const apiClientHooks = hookable.createHooks();
   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") || "";
+      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;
-        params.onContextChanged?.(newContextToken);
+        apiClientHooks.callHook("onContextChanged", newContextToken);
       }
     },
-    async onResponseError({ request, response, options }) {
+    async onResponseError({ response }) {
+      apiClientHooks.callHook("onResponseError", response);
       errorInterceptor(response);
     }
   });
   async function invoke(pathParam, ...params2) {
-    const [requestPath, options] = transformPathToQuery(
-      pathParam,
-      params2?.[0]
-    );
-    return apiFetch(
+    const [, method, requestPath] = pathParam.split(" ");
+    const currentParams = params2[0] || {};
+    const requestPathWithParams = createPathWithParams(
       requestPath,
-      {
-        ...options,
-        headers: {
-          ...defaultHeaders,
-          ...options.headers
-        }
-      }
+      currentParams.pathParams
     );
+    const fetchOptions = {
+      ...currentParams.fetchOptions || {}
+    };
+    const resp = await apiFetch.raw(requestPathWithParams, {
+      ...fetchOptions,
+      method,
+      body: currentParams.body,
+      headers: defu__default(defaultHeaders, currentParams.headers),
+      query: currentParams.query
+    });
+    return {
+      data: resp._data,
+      status: resp.status
+    };
   }
   return {
-    invoke
+    invoke,
+    /**
+     * Default headers used in every client request (if not overriden in specific request).
+     */
+    defaultHeaders,
+    hook: apiClientHooks.hook
   };
 }
+
 function createAuthorizationHeader(token) {
   if (!token)
-    return null;
+    return "";
   if (token.startsWith("Bearer "))
     return token;
   return `Bearer ${token}`;
 }
 function createAdminAPIClient(params) {
+  const isTokenBasedAuth = params.credentials?.grant_type === "client_credentials";
   const sessionData = {
     accessToken: params.sessionData?.accessToken || "",
     refreshToken: params.sessionData?.refreshToken || "",
     expirationTime: Number(params.sessionData?.expirationTime || 0)
   };
+  const defaultHeaders = createHeaders({
+    Authorization: createAuthorizationHeader(sessionData.accessToken),
+    Accept: "application/json"
+  });
+  const apiClientHooks = hookable.createHooks();
+  function getSessionData() {
+    return { ...sessionData };
+  }
+  function setSessionData(data) {
+    sessionData.accessToken = data.accessToken;
+    sessionData.refreshToken = data.refreshToken || "";
+    sessionData.expirationTime = data.expirationTime;
+    return getSessionData();
+  }
   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
+      const dataCopy = setSessionData({
+        accessToken: responseData.access_token,
+        refreshToken: responseData.refresh_token,
+        expirationTime: Date.now() + responseData.expires_in * 1e3
       });
+      apiClientHooks.callHook("onAuthChange", dataCopy);
     }
   }
-  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")) {
+        if (!params.credentials && !isTokenBasedAuth && !sessionData.refreshToken) {
+          console.warn(
+            "[ApiClientWarning] No `credentials` or `sessionData` provided. Provide at least one of them to ensure authentication."
+          );
+        }
+        const body = params.credentials && !sessionData.refreshToken ? params.credentials : {
+          grant_type: "refresh_token",
+          client_id: "administration",
+          refresh_token: sessionData.refreshToken
+        };
         await ofetch.ofetch("/oauth/token", {
           baseURL: params.baseURL,
           method: "POST",
-          body: {
-            grant_type: "refresh_token",
-            client_id: "administration",
-            refresh_token: sessionData.refreshToken || ""
-          },
+          body,
           headers: defaultHeaders,
           onResponseError({ response }) {
             errorInterceptor(response);
           },
           onResponse(context) {
+            if (!context.response._data)
+              return;
             updateSessionData(context.response._data);
+            options.headers = {
+              ...options.headers,
+              Authorization: createAuthorizationHeader(
+                context.response._data.access_token
+              )
+            };
           }
         });
       }
     },
     async onResponse(context) {
+      apiClientHooks.callHook("onSuccessResponse", context.response);
       updateSessionData(context.response._data);
     },
-    async onResponseError({ request, response, options }) {
+    async onResponseError({ response }) {
+      apiClientHooks.callHook("onResponseError", response);
       errorInterceptor(response);
     }
   });
-  async function invoke(pathParam, params2) {
-    const [requestPath, options] = transformPathToQuery(
-      pathParam,
-      params2
-    );
-    return apiFetch(
+  async function invoke(pathParam, ...params2) {
+    const [, method, requestPath] = pathParam.split(" ");
+    const requestPathWithParams = createPathWithParams(
       requestPath,
-      {
-        ...options,
-        headers: {
-          ...defaultHeaders,
-          ...options.headers
-        }
-      }
+      params2[0]?.pathParams
     );
+    const fetchOptions = {
+      ...params2[0]?.fetchOptions || {}
+    };
+    const resp = await apiFetch.raw(requestPathWithParams, {
+      ...fetchOptions,
+      method,
+      body: params2[0]?.body,
+      headers: defu__default(defaultHeaders, params2[0]?.headers),
+      query: params2[0]?.query
+    });
+    return {
+      data: resp._data,
+      status: resp.status
+    };
   }
   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.
+     * Setting session data with this method 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
+    getSessionData,
+    /**
+     * Default headers used in every client request (if not overriden in specific request).
+     */
+    defaultHeaders,
+    /**
+     * Available hooks for the client.
+     */
+    hook: apiClientHooks.hook
   };
 }