@shopware/api-client 0.5.0 → 1.0.0

package/dist/index.mjs

@@ -1,4 +1,41 @@
 import { ofetch } from 'ofetch';
+import { createHooks } from 'hookable';
+import defu from '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;
@@ -9,14 +46,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.
@@ -43,9 +89,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;
@@ -53,188 +97,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 = createHooks();
   const apiFetch = 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(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 = 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.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("/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(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
   };
 }
 

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@shopware/api-client",
-  "version": "0.5.0",
+  "version": "1.0.0",
   "description": "Shopware client for API connection.",
   "author": "Shopware",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shopware/frontends.git"
@@ -35,31 +36,36 @@
         "types": "./dist/index.d.mts",
         "default": "./dist/index.mjs"
       }
-    }
+    },
+    "./api-types": "./api-types/storeApiTypes.d.ts",
+    "./store-api-types": "./api-types/storeApiTypes.d.ts",
+    "./admin-api-types": "./api-types/adminApiTypes.d.ts"
   },
   "devDependencies": {
-    "@types/prettier": "^3.0.0",
-    "@vitest/coverage-c8": "^0.33.0",
-    "prettier": "^3.0.3",
-    "unbuild": "^2.0.0",
-    "vitest": "^0.34.6",
-    "@shopware/api-gen": "0.1.0",
-    "eslint-config-shopware": "0.0.7",
+    "@codspeed/vitest-plugin": "3.1.0",
+    "@types/prettier": "3.0.0",
+    "@vitest/coverage-v8": "1.6.0",
+    "prettier": "3.3.2",
+    "unbuild": "2.0.0",
+    "vitest": "1.6.0",
+    "eslint-config-shopware": "0.0.9",
     "tsconfig": "0.0.0"
   },
   "dependencies": {
-    "ofetch": "^1.3.3"
+    "defu": "6.1.4",
+    "hookable": "5.5.3",
+    "ofetch": "1.3.4"
   },
   "scripts": {
     "build": "export NODE_ENV=production && unbuild && pnpm build:types",
     "build:types": "tsc ./src/*.ts --declaration --allowJs --emitDeclarationOnly --outDir ./temp --skipLibCheck",
     "dev": "export NODE_ENV=development && unbuild --stub",
-    "generate": "esno ../api-gen/src/cli.ts generate",
     "lint": "eslint src/**/*.ts* --fix --max-warnings=0 && pnpm run typecheck",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run && pnpm run test:types",
-    "test:types": "vitest typecheck --run",
+    "test": "vitest run --typecheck",
     "test:bench": "vitest bench",
-    "test:watch": "vitest"
+    "test:watch": "vitest --typecheck",
+    "generate-types": "esno ../api-gen/src/cli.ts generate --apiType=store",
+    "generate-admin-types": "esno ../api-gen/src/cli.ts generate --apiType=admin"
   }
 }