arky-sdk 0.7.95 → 0.7.102

package/dist/storefront.js

@@ -392,7 +392,7 @@ var createStorefrontApi = (apiConfig) => {
         const items = paramItems || groupCartToItems(cart);
         return apiConfig.httpClient.post(
           `${base(target_store_id)}/bookings/checkout`,
-          { market: "booking", ...payload, items },
+          { market: apiConfig.market, ...payload, items },
           options
         );
       },
@@ -415,7 +415,7 @@ var createStorefrontApi = (apiConfig) => {
         const target_store_id = store_id || apiConfig.storeId;
         return apiConfig.httpClient.post(
           `${base(target_store_id)}/bookings/quote`,
-          { market: "booking", ...payload },
+          { market: apiConfig.market, ...payload },
           options
         );
       },
@@ -494,61 +494,46 @@ var createStorefrontApi = (apiConfig) => {
     },
     crm: {
       customer: {
-        async session(params, options) {
-          const store_id = params?.store_id || apiConfig.storeId;
-          const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/customers/session`,
-            { store_id, market: params?.market || apiConfig.market || null },
-            options
-          );
-          if (result?.token?.access_token) {
-            apiConfig.setToken(result.token);
-          }
-          return result;
-        },
-        async connect(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+        async identify(params, options) {
+          const store_id = apiConfig.storeId;
           const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/customers/connect`,
-            { email: params.email, store_id },
+            `${base(store_id)}/customers/identify`,
+            {
+              store_id,
+              market: params?.market || apiConfig.market || null,
+              email: params?.email,
+              verify: params?.verify ?? false
+            },
             options
           );
-          if (result?.access_token) {
-            apiConfig.setToken(result);
+          if (result?.token?.token) {
+            apiConfig.setToken({ access_token: result.token.token });
           }
           return result;
         },
-        requestCode(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          return apiConfig.httpClient.post(
-            `${base(store_id)}/customers/auth/code`,
-            { email: params.email, store_id },
-            options
-          );
-        },
         async verify(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
+          const store_id = apiConfig.storeId;
           const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/customers/auth/verify`,
-            { email: params.email, code: params.code, store_id },
+            `${base(store_id)}/customers/verify`,
+            { store_id, code: params.code },
             options
           );
-          if (result?.access_token) {
-            apiConfig.setToken(result);
+          if (result?.token) {
+            apiConfig.setToken({ access_token: result.token });
           }
           return result;
         },
-        async refreshToken(params, options) {
-          const store_id = params.store_id || apiConfig.storeId;
-          const result = await apiConfig.httpClient.post(
-            `${base(store_id)}/customers/auth/refresh`,
-            { refresh_token: params.refresh_token },
-            options
-          );
-          if (result?.access_token) {
-            apiConfig.setToken(result);
+        async logout(options) {
+          const store_id = apiConfig.storeId;
+          try {
+            await apiConfig.httpClient.post(
+              `${base(store_id)}/customers/logout`,
+              {},
+              options
+            );
+          } finally {
+            apiConfig.setToken({ access_token: "" });
           }
-          return result;
         },
         getMe(options) {
           return apiConfig.httpClient.get(`${base()}/customers/me`, options);
@@ -709,36 +694,31 @@ function buildQueryString(params) {
 }
 
 // src/services/createHttpClient.ts
-var STORAGE_KEYS = {
-  access_token: "arky_token",
-  refresh_token: "arky_refresh",
-  access_expires_at: "arky_expires_at"
-};
+var TOKEN_KEY = "arky_token";
+var LEGACY_KEYS = ["arky_refresh", "arky_expires_at"];
 function defaultGetToken() {
   if (typeof window === "undefined") return { access_token: "" };
   return {
-    access_token: localStorage.getItem(STORAGE_KEYS.access_token) || "",
-    refresh_token: localStorage.getItem(STORAGE_KEYS.refresh_token) || "",
-    access_expires_at: parseInt(localStorage.getItem(STORAGE_KEYS.access_expires_at) || "0", 10)
+    access_token: localStorage.getItem(TOKEN_KEY) || ""
   };
 }
 function defaultSetToken(tokens) {
   if (typeof window === "undefined") return;
   if (tokens.access_token) {
-    localStorage.setItem(STORAGE_KEYS.access_token, tokens.access_token);
-    localStorage.setItem(STORAGE_KEYS.refresh_token, tokens.refresh_token || "");
-    localStorage.setItem(STORAGE_KEYS.access_expires_at, (tokens.access_expires_at || 0).toString());
+    localStorage.setItem(TOKEN_KEY, tokens.access_token);
   } else {
-    Object.values(STORAGE_KEYS).forEach((key) => localStorage.removeItem(key));
+    localStorage.removeItem(TOKEN_KEY);
   }
+  LEGACY_KEYS.forEach((key) => localStorage.removeItem(key));
 }
 function defaultLogout() {
   if (typeof window === "undefined") return;
-  Object.values(STORAGE_KEYS).forEach((key) => localStorage.removeItem(key));
+  localStorage.removeItem(TOKEN_KEY);
+  LEGACY_KEYS.forEach((key) => localStorage.removeItem(key));
 }
 function defaultIsAuthenticated() {
   if (typeof window === "undefined") return false;
-  const token = localStorage.getItem(STORAGE_KEYS.access_token) || "";
+  const token = localStorage.getItem(TOKEN_KEY) || "";
   return token.startsWith("customer_") || token.startsWith("account_");
 }
 function createHttpClient(cfg) {
@@ -1206,13 +1186,11 @@ function createStorefront(config) {
   const setToken = config.setToken || defaultSetToken;
   const logout = config.logout || defaultLogout;
   const isAuthenticated = config.isAuthenticated || defaultIsAuthenticated;
-  let refresh_store_id = config.storeId;
   const httpClient = createHttpClient({
     ...config,
     getToken,
     setToken,
-    logout,
-    refreshPath: () => `/v1/storefront/${refresh_store_id}/customers/auth/refresh`
+    logout
   });
   const apiConfig = {
     httpClient,
@@ -1228,9 +1206,9 @@ function createStorefront(config) {
   let currentSession = null;
   const sessionListeners = /* @__PURE__ */ new Set();
   const customerApi = storefrontApi.crm.customer;
-  function emitSessionChange(session2) {
+  function emitSessionChange(session) {
     for (const listener of sessionListeners) {
-      Promise.resolve().then(() => listener(session2)).catch(() => {
+      Promise.resolve().then(() => listener(session)).catch(() => {
       });
     }
   }
@@ -1254,22 +1232,26 @@ function createStorefront(config) {
     clearSession();
     return result;
   }
-  function session(market2) {
-    if (market2 !== void 0) apiConfig.market = market2;
-    if (sessionPromise) return sessionPromise;
-    sessionPromise = (async () => {
+  function identify(params) {
+    if (params?.market !== void 0) apiConfig.market = params.market;
+    const isBareCall = !params?.email && !params?.verify;
+    if (isBareCall && sessionPromise) return sessionPromise;
+    const promise = (async () => {
       try {
-        const result = await customerApi.session({
-          market: apiConfig.market
+        const result = await customerApi.identify({
+          market: apiConfig.market,
+          email: params?.email,
+          verify: params?.verify
         });
         return setCurrentSessionFromResult(result);
       } catch (err) {
-        const status = err?.statusCode || err?.status || err?.response?.status;
-        if (status === 401) {
+        const e = err;
+        const status = e?.statusCode || e?.status || e?.response?.status;
+        if (isBareCall && status === 401) {
           currentSession = null;
           emitSessionChange(null);
-          await setToken({ access_token: "", refresh_token: "", access_expires_at: 0 });
-          const result = await customerApi.session({
+          await setToken({ access_token: "" });
+          const result = await customerApi.identify({
             market: apiConfig.market
           });
           return setCurrentSessionFromResult(result);
@@ -1277,10 +1259,11 @@ function createStorefront(config) {
         throw err;
       }
     })().catch((err) => {
-      sessionPromise = null;
+      if (isBareCall) sessionPromise = null;
       throw err;
     });
-    return sessionPromise;
+    if (isBareCall) sessionPromise = promise;
+    return promise;
   }
   function setMarket(key) {
     apiConfig.market = key;
@@ -1299,10 +1282,6 @@ function createStorefront(config) {
   function getSession() {
     return currentSession;
   }
-  function logoutAndClearSession() {
-    clearSession();
-    return logout();
-  }
   function setTokenAndClearSession(tokens) {
     setToken(tokens);
     clearSession();
@@ -1311,17 +1290,33 @@ function createStorefront(config) {
     ...storefrontApi.crm,
     customer: {
       ...customerApi,
-      async session(params, options) {
-        const result = await customerApi.session(params, options);
+      async identify(params, options) {
+        const result = await customerApi.identify(params, options);
         setCurrentSessionFromResult(result);
         return result;
       },
-      connect: (params, options) => invalidateAfterAuth(customerApi.connect(params, options)),
       verify: (params, options) => invalidateAfterAuth(customerApi.verify(params, options))
     }
   };
+  async function verify(params) {
+    const result = await invalidateAfterAuth(customerApi.verify(params));
+    return result;
+  }
+  async function me() {
+    return customerApi.getMe();
+  }
+  async function logoutCustomer() {
+    try {
+      await customerApi.logout();
+    } finally {
+      clearSession();
+    }
+  }
   return {
-    session,
+    identify,
+    verify,
+    me,
+    logout: logoutCustomer,
     getSession,
     onSessionChange,
     store: storefrontApi.store,
@@ -1332,7 +1327,6 @@ function createStorefront(config) {
     activity: storefrontApi.activity,
     automation: storefrontApi.automation,
     setStoreId: (storeId) => {
-      refresh_store_id = storeId;
       apiConfig.storeId = storeId;
       clearSession();
     },
@@ -1344,7 +1338,6 @@ function createStorefront(config) {
     },
     getLocale: () => apiConfig.locale,
     isAuthenticated,
-    logout: logoutAndClearSession,
     setToken: setTokenAndClearSession,
     extractBlockValues,
     utils: createUtilitySurface(apiConfig)