@akinon/next 2.0.0-beta.16 → 2.0.0-beta.17

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @akinon/next
 
+## 2.0.0-beta.17
+
+### Minor Changes
+
+- 8218dafa: ZERO-4160: Refactor oauth-login middleware to use fetch for login and callback responses
+- 2a8ddcf6: ZERO-4111: Add total balance field to store credit localization and update related components
+- 8a7fd0f4: ZERO-4065: Add '[segment]' to skipSegments in route generation
+- 36143125: ZERO-3987: Add barcode scanner functionality with modal and button
+- f7e0f646: ZERO-4032: Add bfcache-headers middleware, integrate it into the default chain, and introduce a new environment variable for control.
+- 94a86fcc: ZERO-4065: Expand skipSegments array to include additional segments for route generation
+- bcaad120: ZERO-4158: Add logging for OAuth login and callback redirects
+
 ## 2.0.0-beta.16
 
 ### Minor Changes

package/api/barcode-search.ts

@@ -0,0 +1,59 @@
+import { NextRequest, NextResponse } from 'next/server';
+import Settings from 'settings';
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const barcode = searchParams.get('search_text');
+
+    if (!barcode) {
+      return NextResponse.json(
+        { error: 'Missing search_text parameter (barcode)' },
+        { status: 400 }
+      );
+    }
+
+    if (Settings.commerceUrl === 'default') {
+      return NextResponse.json(
+        { error: 'Commerce URL is not configured' },
+        { status: 500 }
+      );
+    }
+
+    const queryParams = new URLSearchParams();
+    queryParams.append('search_text', barcode);
+
+    searchParams.forEach((value, key) => {
+      if (key !== 'search_text') {
+        queryParams.append(key, value);
+      }
+    });
+
+    const apiUrl = `${Settings.commerceUrl}/list/?${queryParams.toString()}`;
+
+    const headers: Record<string, string> = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    };
+
+    const response = await fetch(apiUrl, {
+      method: 'GET',
+      headers
+    });
+
+    if (!response.ok) {
+      return NextResponse.json(
+        { error: `API request failed with status: ${response.status}` },
+        { status: response.status }
+      );
+    }
+
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    return NextResponse.json(
+      { error: (error as Error).message },
+      { status: 500 }
+    );
+  }
+}

package/bin/pz-generate-routes.js

@@ -25,7 +25,17 @@ const generateRoutes = () => {
   const routes = [];
   const excludedDirs = ['api', 'pz-not-found'];
 
-  const skipSegments = ['[pz]', '[commerce]', '[locale]', '[currency]'];
+  const skipSegments = [
+    '[pz]',
+    '[commerce]',
+    '[locale]',
+    '[currency]',
+    '[session]',
+    '[segment]',
+    '[url]',
+    '[theme]',
+    '[member_type]'
+  ];
   const skipCatchAllRoutes = ['[...prettyurl]', '[...not_found]'];
 
   const walkDirectory = (dir, basePath = '') => {

package/components/plugin-module.tsx

@@ -55,6 +55,7 @@ export enum Component {
   SavedCard = 'SavedCardOption',
   VirtualTryOnPlugin = 'VirtualTryOnPlugin',
   BasketVirtualTryOn = 'BasketVirtualTryOn',
+  BarcodeScannerPlugin = 'BarcodeScannerPlugin',
   IyzicoSavedCard = 'IyzicoSavedCardOption',
   Hepsipay = 'Hepsipay',
   FlowPayment = 'FlowPayment',
@@ -117,7 +118,7 @@ const PluginComponents = new Map([
   [Plugin.FlowPayment, [Component.FlowPayment]],
   [
     Plugin.VirtualTryOn,
-    [Component.VirtualTryOnPlugin, Component.BasketVirtualTryOn]
+    [Component.VirtualTryOnPlugin, Component.BasketVirtualTryOn, Component.BarcodeScannerPlugin]
   ],
   [Plugin.Hepsipay, [Component.Hepsipay]],
   [Plugin.MasterpassRest, [Component.MasterpassRest]],

package/data/client/account.ts

@@ -7,6 +7,7 @@ import {
   AccountOrderCancellation,
   AccountOrderCancellationReason,
   ContactFormType,
+  LoyaltyBalanceItem,
   Order,
   Quotations
 } from '../../types';
@@ -220,7 +221,10 @@ const accountApi = api.injectEndpoints({
         method: 'PATCH'
       })
     }),
-    getLoyaltyBalance: builder.query<{ balance: number }, void>({
+    getLoyaltyBalance: builder.query<
+      { balance: number; balances?: LoyaltyBalanceItem[] },
+      void
+    >({
       query: () => buildClientRequestUrl(account.loyaltyBalance)
     }),
     getLoyaltyTransactions: builder.query<LoyaltyTransactions, void>({

package/data/client/checkout.ts

@@ -10,6 +10,7 @@ import {
 } from '../../redux/reducers/checkout';
 import {
   CheckoutContext,
+  AccountUsage,
   ExtraField,
   GuestLoginFormParams,
   Order,
@@ -776,16 +777,28 @@ export const checkoutApi = api.injectEndpoints({
         url: buildCheckoutRequestUrl(checkout.loyaltyMoneyUsage)
       })
     }),
-    payWithLoyaltyBalance: build.mutation<any, string>({
-      query: (amount) => ({
-        url: buildCheckoutRequestUrl(checkout.loyaltyMoneyUsage, {
-          useFormData: true
-        }),
-        method: 'POST',
-        body: {
-          loyalty_amount_to_use: amount
-        }
-      }),
+    payWithLoyaltyBalance: build.mutation<
+      any,
+      string | { account_usages: AccountUsage[] }
+    >({
+      query: (params) => {
+        const isAccountUsages =
+          typeof params === 'object' && 'account_usages' in params;
+
+        return {
+          url: buildCheckoutRequestUrl(checkout.loyaltyMoneyUsage, {
+            useFormData: true
+          }),
+          method: 'POST',
+          body: isAccountUsages
+            ? {
+                account_usages: JSON.stringify(params.account_usages)
+              }
+            : {
+                loyalty_amount_to_use: params
+              }
+        };
+      },
       async onQueryStarted(arg, { dispatch, queryFulfilled }) {
         dispatch(setPaymentStepBusy(true));
         dispatch(setPaymentOptions([]));

package/middlewares/bfcache-headers.ts

@@ -0,0 +1,18 @@
+import { NextMiddleware } from 'next/server';
+
+const withBfcacheHeaders = (middleware: NextMiddleware): NextMiddleware => {
+  return async (req, event) => {
+    const response = await middleware(req, event);
+
+    if (process.env.BF_CACHE === 'true' && response) {
+      response.headers.set(
+        'Cache-Control',
+        'private, no-cache, max-age=0, must-revalidate'
+      );
+    }
+
+    return response;
+  };
+};
+
+export default withBfcacheHeaders;

package/middlewares/default.ts

@@ -14,7 +14,8 @@ import {
   withUrlRedirection,
   withCompleteWallet,
   withWalletCompleteRedirection,
-  withMasterpassRestCallback
+  withMasterpassRestCallback,
+  withBfcacheHeaders
 } from '.';
 import { urlLocaleMatcherRegex } from '../utils';
 import { getPzSegmentsConfig, encodePzValue, isLegacyMode } from '../utils/pz-segments';
@@ -256,10 +257,11 @@ const withPzDefault =
                           withCompleteWallet(
                             withWalletCompleteRedirection(
                               withMasterpassRestCallback(
-                                async (
-                                  req: PzNextRequest,
-                                  event: NextFetchEvent
-                                ) => {
+                                withBfcacheHeaders(
+                                  async (
+                                    req: PzNextRequest,
+                                    event: NextFetchEvent
+                                  ) => {
                                   let middlewareResult: NextResponse | void =
                                     NextResponse.next();
 
@@ -563,7 +565,7 @@ const withPzDefault =
                                   }
 
                                   return middlewareResult;
-                                }
+                                })
                               )
                             )
                           )

package/middlewares/index.ts

@@ -12,6 +12,7 @@ import withSavedCardRedirection from './saved-card-redirection';
 import withCompleteWallet from './complete-wallet';
 import withWalletCompleteRedirection from './wallet-complete-redirection';
 import withMasterpassRestCallback from './masterpass-rest-callback';
+import withBfcacheHeaders from './bfcache-headers';
 import { NextRequest } from 'next/server';
 
 export {
@@ -28,7 +29,8 @@ export {
   withSavedCardRedirection,
   withCompleteWallet,
   withWalletCompleteRedirection,
-  withMasterpassRestCallback
+  withMasterpassRestCallback,
+  withBfcacheHeaders
 };
 
 export interface PzNextRequest extends NextRequest {

package/middlewares/oauth-login.ts

@@ -6,78 +6,221 @@ import {
 } from 'next/server';
 import Settings from 'settings';
 import { getUrlPathWithLocale } from '../utils/localization';
+import logger from '../utils/log';
 
-const withOauthLogin =
-  (middleware: NextMiddleware) =>
-  async (req: NextRequest, event: NextFetchEvent) => {
-    const url = req.nextUrl.clone();
-    const loginUrlMatcherRegex = new RegExp(/^\/(\w+)\/login\/?$/);
-    const loginCallbackUrlMatcherRegex = new RegExp(
-      /^\/(\w+)\/login\/callback\/?$/
-    );
-    const ip = req.headers.get('x-forwarded-for') ?? '';
-
-    const headers = {
-      'x-forwarded-host':
-        req.headers.get('x-forwarded-host') || req.headers.get('host') || '',
-      'x-currency': req.cookies.get('pz-currency')?.value ?? '',
-      'x-forwarded-for': ip
+const LOGIN_URL_REGEX = /^\/(\w+)\/login\/?$/;
+const CALLBACK_URL_REGEX = /^\/(\w+)\/login\/callback\/?$/;
+
+function buildCommerceHeaders(req: NextRequest): Record<string, string> {
+  return {
+    'x-forwarded-host':
+      req.headers.get('x-forwarded-host') || req.headers.get('host') || '',
+    'x-forwarded-for': req.headers.get('x-forwarded-for') ?? '',
+    'x-forwarded-proto': req.headers.get('x-forwarded-proto') || 'https',
+    'x-currency': req.cookies.get('pz-currency')?.value ?? '',
+    cookie: req.headers.get('cookie') ?? ''
+  };
+}
+
+async function getRequestBody(
+  req: NextRequest
+): Promise<{ content: string; contentType: string } | undefined> {
+  if (req.method !== 'POST') return undefined;
+
+  const content = await req.text();
+  if (!content.length) return undefined;
+
+  return {
+    content,
+    contentType:
+      req.headers.get('content-type') ?? 'application/x-www-form-urlencoded'
+  };
+}
+
+function fetchCommerce(
+  url: string,
+  req: NextRequest,
+  body?: { content: string; contentType: string }
+): Promise<Response> {
+  const headers = buildCommerceHeaders(req);
+
+  if (body) {
+    headers['content-type'] = body.contentType;
+  }
+
+  return fetch(url, {
+    method: body ? 'POST' : 'GET',
+    headers,
+    body: body?.content,
+    redirect: 'manual'
+  });
+}
+
+function forwardCookies(from: Response, to: NextResponse): void {
+  from.headers.getSetCookie().forEach((cookie) => {
+    to.headers.append('set-cookie', cookie);
+  });
+}
+
+function buildRedirectResponse(
+  commerceResponse: Response,
+  location: string,
+  origin: string
+): NextResponse {
+  const response = NextResponse.redirect(new URL(location, origin));
+  forwardCookies(commerceResponse, response);
+  return response;
+}
+
+function commercePassthrough(commerceResponse: Response): NextResponse {
+  return new NextResponse(commerceResponse.body, {
+    status: commerceResponse.status,
+    headers: commerceResponse.headers
+  });
+}
+
+function buildOAuthCallbackCookie(referer: string): string {
+  return `pz-oauth-callback-url=${encodeURIComponent(referer)}; Path=/`;
+}
+
+async function handleLogin(
+  req: NextRequest,
+  provider: string
+): Promise<{ response: NextResponse; redirected: boolean }> {
+  const commerceResponse = await fetchCommerce(
+    `${Settings.commerceUrl}/${provider}/login/`,
+    req
+  );
+
+  const location = commerceResponse.headers.get('location');
+  if (!location) {
+    return {
+      response: commercePassthrough(commerceResponse),
+      redirected: false
     };
+  }
 
-    if (loginUrlMatcherRegex.test(url.pathname)) {
-      const provider = url.pathname.match(loginUrlMatcherRegex)[1];
-      const response = NextResponse.rewrite(
-        `${Settings.commerceUrl}/${provider}/login/`,
-        {
-          headers
-        }
-      );
+  const response = buildRedirectResponse(
+    commerceResponse,
+    location,
+    req.nextUrl.origin
+  );
 
-      if (req.headers.get('referer')) {
-        response.cookies.set(
-          'pz-oauth-callback-url',
-          req.headers.get('referer')
-        );
-      }
+  response.headers.append(
+    'set-cookie',
+    buildOAuthCallbackCookie(req.headers.get('referer') || '')
+  );
 
-      return response;
-    }
+  return { response, redirected: true };
+}
 
-    if (loginCallbackUrlMatcherRegex.test(url.pathname)) {
-      const provider = url.pathname.match(loginCallbackUrlMatcherRegex)[1];
+async function handleCallback(
+  req: NextRequest,
+  provider: string,
+  search: string
+): Promise<{ response: NextResponse; redirected: boolean }> {
+  const body = await getRequestBody(req);
+  const commerceResponse = await fetchCommerce(
+    `${Settings.commerceUrl}/${provider}/login/callback/${search}`,
+    req,
+    body
+  );
 
-      return NextResponse.rewrite(
-        `${Settings.commerceUrl}/${provider}/login/callback/${url.search}`,
-        {
-          headers
-        }
-      );
-    }
+  const location = commerceResponse.headers.get('location');
+  if (!location) {
+    return {
+      response: commercePassthrough(commerceResponse),
+      redirected: false
+    };
+  }
+
+  return {
+    response: buildRedirectResponse(
+      commerceResponse,
+      location,
+      req.nextUrl.origin
+    ),
+    redirected: true
+  };
+}
+
+function handleBasketRedirect(req: NextRequest): NextResponse | null {
+  const hasSession = req.cookies.get('osessionid');
+  const messages = req.cookies.get('messages')?.value;
+
+  if (!messages) return null;
+  if (!messages.includes('Successfully signed in') && !hasSession) return null;
+
+  let redirectUrl = `${req.nextUrl.origin}${getUrlPathWithLocale(
+    '/auth/oauth-login',
+    req.cookies.get('pz-locale')?.value
+  )}`;
+
+  const callbackUrl = req.cookies.get('pz-oauth-callback-url')?.value ?? '';
+  if (callbackUrl.length) {
+    redirectUrl += `?next=${encodeURIComponent(callbackUrl)}`;
+  }
+
+  const response = NextResponse.redirect(redirectUrl);
+  response.cookies.delete('messages');
+  response.cookies.delete('pz-oauth-callback-url');
+  return response;
+}
 
-    if (!url.pathname.startsWith('/baskets/basket')) {
+const withOauthLogin =
+  (middleware: NextMiddleware) =>
+  async (req: NextRequest, event: NextFetchEvent) => {
+    const { pathname, search } = req.nextUrl;
+
+    if (!pathname.includes('/login') && !pathname.startsWith('/baskets/basket')) {
       return middleware(req, event);
     }
 
-    const currentSessionId = req.cookies.get('osessionid');
+    logger.info('OAuth login redirect', {
+      host: req.headers.get('host'),
+      'x-forwarded-host': req.headers.get('x-forwarded-host'),
+      'x-forwarded-for': req.headers.get('x-forwarded-for')
+    });
 
-    if (
-      req.cookies.get('messages')?.value.includes('Successfully signed in') ||
-      (currentSessionId && req.cookies.get('messages'))
-    ) {
-      let redirectUrlWithLocale = `${url.origin}${getUrlPathWithLocale(
-        '/auth/oauth-login',
-        req.cookies.get('pz-locale')?.value
-      )}`;
-      let callbackUrl = req.cookies.get('pz-oauth-callback-url')?.value ?? '';
+    const loginMatch = LOGIN_URL_REGEX.exec(pathname);
+    if (loginMatch) {
+      try {
+        const { response, redirected } = await handleLogin(req, loginMatch[1]);
+        if (!redirected) {
+          logger.warn('OAuth login: no redirect from commerce', {
+            provider: loginMatch[1]
+          });
+        }
+        return response;
+      } catch (error) {
+        logger.error('OAuth login fetch failed', { error });
+        return middleware(req, event);
+      }
+    }
 
-      if (callbackUrl.length) {
-        redirectUrlWithLocale += `?next=${encodeURIComponent(callbackUrl)}`;
+    const callbackMatch = CALLBACK_URL_REGEX.exec(pathname);
+    if (callbackMatch) {
+      try {
+        const { response, redirected } = await handleCallback(
+          req,
+          callbackMatch[1],
+          search
+        );
+        if (!redirected) {
+          logger.warn('OAuth callback: no redirect from commerce', {
+            provider: callbackMatch[1]
+          });
+        }
+        return response;
+      } catch (error) {
+        logger.error('OAuth callback fetch failed', { error });
+        return middleware(req, event);
       }
+    }
 
-      const response = NextResponse.redirect(redirectUrlWithLocale);
-      response.cookies.delete('messages');
-      response.cookies.delete('pz-oauth-callback-url');
-      return response;
+    if (pathname.startsWith('/baskets/basket')) {
+      const response = handleBasketRedirect(req);
+      if (response) return response;
     }
 
     return middleware(req, event);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "2.0.0-beta.16",
+  "version": "2.0.0-beta.17",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -35,7 +35,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "2.0.0-beta.16",
+    "@akinon/eslint-plugin-projectzero": "2.0.0-beta.17",
     "@babel/core": "7.26.10",
     "@babel/preset-env": "7.26.9",
     "@babel/preset-typescript": "7.27.0",

package/redux/middlewares/checkout.ts

@@ -14,6 +14,7 @@ import {
   setHasGiftBox,
   setInstallmentOptions,
   setLoyaltyBalance,
+  setLoyaltyBalances,
   setPaymentChoices,
   setPaymentOptions,
   setRetailStores,
@@ -224,6 +225,14 @@ export const contextListMiddleware: Middleware = ({
           dispatch(setLoyaltyBalance(context.page_context.balance));
         }
 
+        if (context.page_context.balances) {
+          dispatch(setLoyaltyBalances(context.page_context.balances));
+        }
+
+        if (context.page_context.accounts) {
+          dispatch(setLoyaltyBalances(context.page_context.accounts));
+        }
+
         if (context.page_context.retail_stores) {
           dispatch(setRetailStores(context.page_context.retail_stores));
         }

package/redux/reducers/checkout.ts

@@ -9,6 +9,7 @@ import {
   CreditCardType,
   DeliveryOption,
   InstallmentOption,
+  LoyaltyBalanceItem,
   PaymentChoice,
   PaymentOption,
   CheckoutCreditPaymentOption,
@@ -49,6 +50,7 @@ export interface CheckoutState {
   bankAccounts: BankAccount[];
   selectedBankAccountPk: number;
   loyaltyBalance?: string;
+  loyaltyBalances?: LoyaltyBalanceItem[];
   retailStores: RetailStore[];
   attributeBasedShippingOptions: AttributeBasedShippingOption[];
   selectedShippingOptions: Record<string, number>;
@@ -188,6 +190,9 @@ const checkoutSlice = createSlice({
     setLoyaltyBalance(state, { payload }) {
       state.loyaltyBalance = payload;
     },
+    setLoyaltyBalances(state, { payload }) {
+      state.loyaltyBalances = payload;
+    },
     setRetailStores(state, { payload }) {
       state.retailStores = payload;
     },
@@ -234,6 +239,7 @@ export const {
   setBankAccounts,
   setSelectedBankAccountPk,
   setLoyaltyBalance,
+  setLoyaltyBalances,
   setRetailStores,
   setAttributeBasedShippingOptions,
   setSelectedShippingOptions,

package/types/commerce/checkout.ts

@@ -68,6 +68,18 @@ export interface CheckoutPaymentOption {
   viewProps?: any;
 }
 
+export interface LoyaltyBalanceItem {
+  label_id: number | null;
+  label: string | null;
+  balance: string;
+  currency?: string;
+}
+
+export interface AccountUsage {
+  label_id: number | null;
+  amount: number;
+}
+
 export interface GiftBox {
   note: string;
   gift_video: boolean;
@@ -91,6 +103,7 @@ export interface PreOrder {
   notes?: string;
   user_phone_number?: string;
   loyalty_money?: string;
+  loyalty_account_usages?: AccountUsage[];
   currency_type_label?: string;
   is_guest?: boolean;
   is_post_order?: boolean;
@@ -151,6 +164,8 @@ export interface CheckoutContext {
     redirect_url?: string;
     context_data?: any;
     balance?: string;
+    balances?: LoyaltyBalanceItem[];
+    accounts?: LoyaltyBalanceItem[];
     attribute_based_shipping_options?: AttributeBasedShippingOption[];
     paymentData?: any;
     paymentMethod?: string;