@alphasquad/saleor-template-advance 0.1.0

package/src/graphql/client.ts

@@ -0,0 +1,288 @@
+'use client';
+
+import { ApolloClient, InMemoryCache, createHttpLink, from } from "@apollo/client";
+import { setContext } from "@apollo/client/link/context";
+import { onError } from "@apollo/client/link/error";
+import { Observable } from "@apollo/client/utilities";
+import type { GraphQLFormattedError } from "graphql";
+
+declare global {
+  interface Window {
+    __APOLLO_CLIENT__?: ApolloClient<unknown>;
+  }
+}
+
+interface GraphQLErrorExtensions {
+  code?: string;
+  exception?: {
+    code?: string;
+    stacktrace?: string[];
+  };
+  [key: string]: unknown;
+}
+
+interface TypedGraphQLError {
+  message: string;
+  extensions?: GraphQLErrorExtensions;
+  path?: readonly (string | number)[];
+}
+
+function normalizeGraphqlUrl(raw?: string) {
+  if (!raw) return undefined;
+  let url = raw.trim();
+  // If the user passed the Saleor base URL, append /graphql/
+  const lower = url.toLowerCase();
+  const hasGraphql = lower.endsWith('/graphql') || lower.endsWith('/graphql/');
+  if (!hasGraphql) {
+    url = url.replace(/\/+$/, '') + '/graphql/';
+    if (typeof window !== 'undefined') {
+      console.warn('[Apollo] NEXT_PUBLIC_API_URL did not include /graphql. Using:', url);
+    }
+  }
+  return url;
+}
+
+const httpLink = createHttpLink({
+  uri: normalizeGraphqlUrl(process.env.NEXT_PUBLIC_API_URL), // Set in .env.local
+});
+
+// Attach JWT from localStorage for client-side requests
+const authLink = setContext((_, { headers }) => {
+  if (typeof window === "undefined") {
+    return { headers };
+  }
+  const token = localStorage.getItem("token");
+  return {
+    headers: {
+      ...headers,
+      Authorization: token ? `Bearer ${token}` : "",
+    },
+  };
+});
+
+// --- Token Refresh Logic ---
+let isRefreshing = false;
+let pendingRequests: Array<(token: string | null) => void> = [];
+
+const resolvePendingRequests = (newToken: string | null) => {
+  pendingRequests.forEach((cb) => cb(newToken));
+  pendingRequests = [];
+};
+
+async function performTokenRefresh(endpoint: string): Promise<{ token: string | null; refreshToken: string | null }> {
+  const refreshToken = typeof window !== 'undefined' ? localStorage.getItem('refreshToken') : null;
+  if (!refreshToken) {
+    throw new Error('No refresh token');
+  }
+
+  try {
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        query: `mutation TokenRefresh($refreshToken: String!) { 
+          tokenRefresh(refreshToken: $refreshToken) { 
+            token 
+            refreshToken 
+            errors { 
+              field
+              message 
+              code
+            } 
+          } 
+        }`,
+        variables: { refreshToken },
+      }),
+    });
+    
+    if (!res.ok) {
+      throw new Error(`tokenRefresh failed: ${res.status}`);
+    }
+    
+    const json = await res.json();
+    
+    const payload = json?.data?.tokenRefresh;
+    const errors = json.errors || payload?.errors || [];
+    
+    if (errors.length) {
+      throw new Error(errors[0]?.message || 'Token refresh failed');
+    }
+    
+    if (!payload?.token) {
+      throw new Error('No token in refresh response');
+    }
+    
+    return { 
+      token: payload.token, 
+      refreshToken: payload.refreshToken || null 
+    };
+  } catch (error) {
+    throw error;
+  }
+}
+
+// Helper function to handle logout and redirect
+async function forceLogout() {
+  if (typeof window === "undefined") return;
+
+  try {
+    // Clear localStorage
+    localStorage.removeItem("token");
+    localStorage.removeItem("refreshToken");
+
+    // Call server to clear cookies
+    await fetch("/api/auth/clear", {
+      method: "POST",
+      credentials: "include",
+    });
+
+    // Clear Apollo cache
+    if (window.__APOLLO_CLIENT__) {
+      await window.__APOLLO_CLIENT__.clearStore().catch((e) =>
+        console.error("Error clearing Apollo cache:", e)
+      );
+    }
+
+    // Redirect to login
+    const currentPath = window.location.pathname;
+    const loginUrl = new URL("/account/login", window.location.origin);
+
+    if (currentPath !== "/account/login") {
+      loginUrl.searchParams.set("next", currentPath);
+    }
+
+    loginUrl.searchParams.set("sessionExpired", "true");
+    window.location.assign(loginUrl.toString());
+  } catch (error) {
+    console.error("Error in forceLogout:", error);
+    window.location.href = "/account/login?sessionExpired=true";
+  }
+}
+
+
+const errorLink = onError(({ graphQLErrors, operation, forward }) => {
+  // If we don't have graphQLErrors or we're on the server, do nothing
+  if (!graphQLErrors || typeof window === 'undefined') {
+    return;
+  }
+
+  // Type assertion for graphQLErrors
+  const errors: TypedGraphQLError[] = graphQLErrors.map((e: GraphQLFormattedError) => ({
+    message: e.message,
+    extensions: e.extensions as GraphQLErrorExtensions | undefined,
+    path: e.path
+  }));
+
+  const authError = errors.find((e) => {
+    const extensions = e.extensions;
+    const errorCode = extensions?.exception?.code || extensions?.code;
+    const isUnauthenticated = errorCode === 'UNAUTHENTICATED' || errorCode === 'ExpiredSignatureError';
+    const isTokenExpired = e.message?.includes('signature has expired') || 
+                          e.message?.includes('Token is invalid or expired');
+    return isUnauthenticated || isTokenExpired;
+  });
+
+  // If not an auth error or running on server, do nothing
+  if (!authError || typeof window === 'undefined') {
+    return;
+  }
+
+  const endpoint = normalizeGraphqlUrl(process.env.NEXT_PUBLIC_API_URL) as string;
+
+  // If we're not already refreshing, start the refresh process
+  if (!isRefreshing) {
+    isRefreshing = true;
+    performTokenRefresh(endpoint)
+      .then(({ token, refreshToken }) => {
+        if (token && refreshToken) {
+          // Save new tokens
+          localStorage.setItem('token', token);
+          localStorage.setItem('refreshToken', refreshToken);
+          resolvePendingRequests(token);
+        } else {
+          // If no new tokens, log out
+          forceLogout();
+        }
+      })
+      .catch((error) => {
+        console.error('Token refresh failed:', error);
+        forceLogout();
+      })
+      .finally(() => {
+        isRefreshing = false;
+      });
+  }
+
+  // Return observable to handle the operation after token refresh
+  return new Observable((observer) => {
+    pendingRequests.push((newToken) => {
+      if (!newToken) {
+        // If no new token, the refresh failed
+        forceLogout();
+        observer.error(authError);
+        return;
+      }
+
+      // Retry the operation with the new token
+      const oldHeaders = operation.getContext().headers || {};
+      operation.setContext({
+        headers: {
+          ...oldHeaders,
+          Authorization: `Bearer ${newToken}`,
+        },
+      });
+
+      const subscriber = {
+        next: observer.next.bind(observer),
+        error: (err: Error) => {
+          // If we get another auth error after refresh, force logout
+          if (err.message?.includes('signature has expired') || 
+              ('graphQLErrors' in err && Array.isArray((err as { graphQLErrors?: GraphQLFormattedError[] }).graphQLErrors) && 
+               (err as { graphQLErrors: GraphQLFormattedError[] }).graphQLErrors.some((e: GraphQLFormattedError) => 
+                 e.extensions?.code === 'UNAUTHENTICATED'))) {
+            forceLogout();
+          }
+          observer.error(err);
+        },
+        complete: observer.complete.bind(observer),
+      };
+
+      const subscriberHandle = forward(operation).subscribe(subscriber);
+      
+      return () => {
+        subscriberHandle.unsubscribe();
+      };
+    });
+    
+    return () => {
+      // Clean up pending requests if the observable is unsubscribed
+      pendingRequests = [];
+    };
+  });
+});
+
+// Create the Apollo client instance
+const client = new ApolloClient({
+  link: from([errorLink, authLink, httpLink]),
+  cache: new InMemoryCache(),
+  defaultOptions: {
+    watchQuery: {
+      fetchPolicy: 'cache-first',
+      errorPolicy: 'all',
+    },
+    query: {
+      fetchPolicy: 'network-only',
+      errorPolicy: 'all',
+    },
+    mutate: {
+      errorPolicy: 'all',
+    },
+  },
+});
+
+// Store the client on the window for debugging and forceLogout access
+if (typeof window !== 'undefined') {
+  window.__APOLLO_CLIENT__ = client;
+}
+
+export default client;

package/src/graphql/mutations/accountAddressCreate.ts

@@ -0,0 +1,56 @@
+"use client";
+
+import { gql } from "@apollo/client";
+
+export const ACCOUNT_ADDRESS_CREATE = gql`
+  mutation AddAddress($input: AddressInput!) {
+    accountAddressCreate(input: $input) {
+      user { id }
+      address {
+        id
+        firstName
+        lastName
+        streetAddress1
+        city
+        postalCode
+        country { code country }
+        phone
+      }
+      errors { field message code }
+    }
+  }
+`;
+
+export interface AddressInput {
+  firstName: string;
+  lastName: string;
+  phone?: string | null;
+  companyName?: string | null;
+  streetAddress1: string;
+  streetAddress2?: string | null;
+  city: string;
+  postalCode: string;
+  country: string; // ISO code
+  countryArea?: string | null;
+}
+
+export interface AccountAddressCreateData {
+  accountAddressCreate: {
+    user: { id: string } | null;
+    address: {
+      id: string;
+      firstName: string;
+      lastName: string;
+      streetAddress1: string;
+      city: string;
+      postalCode: string;
+      country: { code: string; country: string };
+      phone?: string | null;
+    } | null;
+    errors: { field: string | null; message: string; code?: string | null }[];
+  };
+}
+
+export interface AccountAddressCreateVars {
+  input: AddressInput;
+}

package/src/graphql/mutations/accountAddressDelete.ts

@@ -0,0 +1,23 @@
+"use client";
+
+import { gql } from "@apollo/client";
+
+export const ACCOUNT_ADDRESS_DELETE = gql`
+  mutation DeleteAddress($id: ID!) {
+    accountAddressDelete(id: $id) {
+      user { id }
+      errors { field message code }
+    }
+  }
+`;
+
+export interface AccountAddressDeleteData {
+  accountAddressDelete: {
+    user: { id: string } | null;
+    errors: { field: string | null; message: string; code?: string | null }[];
+  };
+}
+
+export interface AccountAddressDeleteVars {
+  id: string;
+}

package/src/graphql/mutations/accountAddressUpdate.ts

@@ -0,0 +1,55 @@
+"use client";
+
+import { gql } from "@apollo/client";
+
+export const ACCOUNT_ADDRESS_UPDATE = gql`
+  mutation UpdateAddress($id: ID!, $input: AddressInput!) {
+    accountAddressUpdate(id: $id, input: $input) {
+      address {
+        id
+        firstName
+        lastName
+        streetAddress1
+        city
+        postalCode
+        country { code country }
+        phone
+      }
+      errors { field message code }
+    }
+  }
+`;
+
+export interface AddressUpdateInput {
+  firstName: string;
+  lastName: string;
+  phone?: string | null;
+  companyName?: string | null;
+  streetAddress1: string;
+  streetAddress2?: string | null;
+  city: string;
+  postalCode: string;
+  country: string; // ISO code
+  countryArea?: string | null;
+}
+
+export interface AccountAddressUpdateData {
+  accountAddressUpdate: {
+    address: {
+      id: string;
+      firstName: string;
+      lastName: string;
+      streetAddress1: string;
+      city: string;
+      postalCode: string;
+      country: { code: string; country: string };
+      phone?: string | null;
+    } | null;
+    errors: { field: string | null; message: string; code?: string | null }[];
+  };
+}
+
+export interface AccountAddressUpdateVars {
+  id: string;
+  input: AddressUpdateInput;
+}

package/src/graphql/mutations/accountSetDefaultAddress.ts

@@ -0,0 +1,32 @@
+"use client";
+
+import { gql } from "@apollo/client";
+
+export const ACCOUNT_SET_DEFAULT_ADDRESS = gql`
+  mutation SetDefaultAddress($id: ID!, $type: AddressTypeEnum!) {
+    accountSetDefaultAddress(id: $id, type: $type) {
+      user {
+        id
+        defaultShippingAddress { id }
+        defaultBillingAddress { id }
+      }
+      errors { field message code }
+    }
+  }
+`;
+
+export interface AccountSetDefaultAddressData {
+  accountSetDefaultAddress: {
+    user: {
+      id: string;
+      defaultShippingAddress: { id: string } | null;
+      defaultBillingAddress: { id: string } | null;
+    } | null;
+    errors: { field: string | null; message: string; code?: string | null }[];
+  };
+}
+
+export interface AccountSetDefaultAddressVars {
+  id: string;
+  type: "SHIPPING" | "BILLING";
+}

package/src/graphql/mutations/accountUpdate.ts

@@ -0,0 +1,34 @@
+export const ACCOUNT_UPDATE = `
+  mutation AccountUpdate($input: AccountInput!) {
+    accountUpdate(input: $input) {
+      user {
+        id
+        metadata {
+          key
+          value
+        }
+      }
+      errors {
+        field
+        message
+      }
+    }
+  }
+`;
+
+export const ACCOUNT_METADATA_UPDATE = `
+  mutation UpdateMetadata($id: ID!, $input: [MetadataInput!]!) {
+    updateMetadata(id: $id, input: $input) {
+      item {
+        metadata {
+          key
+          value
+        }
+      }
+      errors {
+        field
+        message
+      }
+    }
+  }
+`;

package/src/graphql/mutations/changePassword.ts

@@ -0,0 +1,25 @@
+import { gql } from '@apollo/client';
+
+export const CHANGE_PASSWORD = gql`
+  mutation ChangePassword($oldPassword: String!, $newPassword: String!) {
+    passwordChange(oldPassword: $oldPassword, newPassword: $newPassword) {
+      user {
+        id
+        email
+      }
+      errors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export type ChangePasswordVars = { oldPassword: string; newPassword: string };
+export type ChangePasswordData = {
+  passwordChange: {
+    user: { id: string; email: string } | null;
+    errors: Array<{ field: string | null; message: string | null; code: string }>;
+  } | null;
+};

package/src/graphql/mutations/checkout.ts

@@ -0,0 +1,117 @@
+export const CHECKOUT_SHIPPING_ADDRESS_UPDATE = `
+  mutation CheckoutShippingAddressUpdate($id: ID!, $shippingAddress: AddressInput!) {
+    checkoutShippingAddressUpdate(id: $id, shippingAddress: $shippingAddress) {
+      checkout { id }
+      errors { field message }
+    }
+  }
+`;
+
+export const CHECKOUT_BILLING_ADDRESS_UPDATE = `
+  mutation CheckoutBillingAddressUpdate($id: ID!, $billingAddress: AddressInput!) {
+    checkoutBillingAddressUpdate(id: $id, billingAddress: $billingAddress) {
+      checkout { id }
+      errors { field message }
+    }
+  }
+`;
+
+export const CHECKOUT_DELIVERY_METHOD_UPDATE = `
+  mutation CheckoutDeliveryMethodUpdate($id: ID!, $deliveryMethodId: ID!) {
+    checkoutDeliveryMethodUpdate(id: $id, deliveryMethodId: $deliveryMethodId) {
+      checkout { 
+        id
+        totalPrice {
+          gross {
+            amount
+            currency
+          }
+          net {
+            amount
+            currency
+          }
+          tax {
+            amount
+            currency
+          }
+        }
+        shippingPrice {
+          gross {
+            amount
+            currency
+          }
+          net {
+            amount
+            currency
+          }
+          tax {
+            amount
+            currency
+          }
+        }
+        subtotalPrice {
+          gross {
+            amount
+            currency
+          }
+          net {
+            amount
+            currency
+          }
+          tax {
+            amount
+            currency
+          }
+        }
+      }
+      errors { field message }
+    }
+  }
+`;
+
+export const ACCOUNT_ADDRESS_CREATE = `
+  mutation AddAddress($input: AddressInput!) {
+    accountAddressCreate(input: $input) {
+      address { id }
+      errors { field message }
+    }
+  }
+`;
+
+export const ACCOUNT_SET_DEFAULT_ADDRESS = `
+  mutation SetDefaultAddress($id: ID!, $type: AddressTypeEnum!) {
+    accountSetDefaultAddress(id: $id, type: $type) {
+      user { id }
+      errors { field message }
+    }
+  }
+`;
+
+export const CHECKOUT_PAYMENT_CREATE = `
+  mutation CheckoutPaymentCreate($checkoutId: ID!, $gateway: String!, $token: String!) {
+    checkoutPaymentCreate(
+      checkoutId: $checkoutId
+      input: { gateway: $gateway, token: $token }
+    ) {
+      payment { 
+        id 
+        chargeStatus
+        gateway
+        isActive
+        created
+        capturedAmount { amount currency }
+        total { amount currency }
+      }
+      errors { field message code }
+    }
+  }
+`;
+
+export const CHECKOUT_COMPLETE = `
+  mutation CheckoutComplete($checkoutId: ID!) {
+    checkoutComplete(checkoutId: $checkoutId) {
+      order { id userEmail isPaid chargeStatus paymentStatus }
+      errors { field message }
+    }
+  }
+`;

package/src/graphql/mutations/checkoutAddVoucher.ts

@@ -0,0 +1,63 @@
+export const ADD_VOUCHER_TO_CHECKOUT = `
+  mutation AddVoucherToCheckout($checkoutId: ID!, $promoCode: String!) {
+    checkoutAddPromoCode(checkoutId: $checkoutId, promoCode: $promoCode) {
+      checkout {
+        id
+        voucherCode
+        discount {
+          amount
+          currency
+        }
+        totalPrice {
+          gross {
+            amount
+            currency
+          }
+        }
+        subtotalPrice {
+          gross {
+            amount
+            currency
+          }
+        }
+      }
+      errors {
+        field
+        code
+        message
+      }
+    }
+  }
+`;
+
+export const REMOVE_VOUCHER_FROM_CHECKOUT = `
+  mutation RemoveVoucherFromCheckout($checkoutId: ID!, $promoCode: String!) {
+    checkoutRemovePromoCode(checkoutId: $checkoutId, promoCode: $promoCode) {
+      checkout {
+        id
+        voucherCode
+        discount {
+          amount
+          currency
+        }
+        totalPrice {
+          gross {
+            amount
+            currency
+          }
+        }
+        subtotalPrice {
+          gross {
+            amount
+            currency
+          }
+        }
+      }
+      errors {
+        field
+        code
+        message
+      }
+    }
+  }
+`;