@akinon/next 1.92.0-rc.38 → 1.92.0-rc.40

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @akinon/next
 
+## 1.92.0-rc.40
+
+### Minor Changes
+
+- dc678c31: ZERO-3523: Enhance redirect tests with dynamic locale handling and settings integration
+
+## 1.92.0-rc.39
+
 ## 1.92.0-rc.38
 
 ### Minor Changes

package/__tests__/redirect.test.ts

@@ -1,8 +1,17 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
+interface Locale {
+  value: string;
+  label: string;
+  localePath?: string;
+  apiValue?: string;
+  rtl?: boolean;
+}
+
 const mockNextRedirect = jest.fn();
 const mockHeaders = jest.fn();
+const mockCookies = jest.fn();
 
 function findBaseDir() {
   const insideNodeModules = __dirname.includes('node_modules');
@@ -35,7 +44,8 @@ jest.mock('next/navigation', () => ({
 }));
 
 jest.mock('next/headers', () => ({
-  headers: () => mockHeaders()
+  headers: () => mockHeaders(),
+  cookies: () => mockCookies()
 }));
 
 const mockServerVariables = {
@@ -47,15 +57,65 @@ jest.mock('@akinon/next/utils/server-variables', () => ({
 }));
 
 jest.mock('@akinon/next/utils', () => ({
-  urlLocaleMatcherRegex: /^\/(?:tr|ar)(?=\/|$)/
+  urlLocaleMatcherRegex: /^\/(?:tr)(?=\/|$)/
 }));
 
+const mockSettings = {
+  localization: {
+    defaultLocaleValue: 'en',
+    localeUrlStrategy: 'hide-default-locale',
+    locales: [
+      { value: 'en', label: 'EN' },
+      { value: 'tr', label: 'TR' }
+    ]
+  }
+};
+
+jest.mock('settings', () => mockSettings, { virtual: true });
+
 describe('Redirect utility functional tests', () => {
   let redirect: any;
   let getUrlPathWithLocale: any;
   let LocaleUrlStrategy: any;
+  let actualSettings: any;
 
   beforeAll(async () => {
+    try {
+      const baseDir = findBaseDir();
+      const settingsPath = path.resolve(baseDir, 'src/settings.js');
+      actualSettings = require(settingsPath);
+
+      Object.assign(mockSettings.localization, actualSettings.localization);
+
+      const nonDefaultLocales = actualSettings.localization.locales
+        .filter(
+          (locale: Locale) =>
+            locale.value !== actualSettings.localization.defaultLocaleValue
+        )
+        .map((locale: Locale) => locale.value);
+      if (nonDefaultLocales.length > 0) {
+        jest.doMock('@akinon/next/utils', () => ({
+          urlLocaleMatcherRegex: new RegExp(
+            `^\\/(${nonDefaultLocales.join('|')})(?=\\/|$)`
+          )
+        }));
+      } else {
+        jest.doMock('@akinon/next/utils', () => ({
+          urlLocaleMatcherRegex: /^\/(?!.*)/
+        }));
+        console.log('No non-default locales found, using empty regex');
+      }
+    } catch (error) {
+      console.warn(
+        'Could not load actual settings, using default mock settings'
+      );
+
+      jest.doMock('@akinon/next/utils', () => ({
+        urlLocaleMatcherRegex: /^\/(?!.*)/
+      }));
+      console.log('Using fallback empty regex (no locale matching)');
+    }
+
     const localizationModule = await import('@akinon/next/localization');
     LocaleUrlStrategy = localizationModule.LocaleUrlStrategy;
 
@@ -72,80 +132,191 @@ describe('Redirect utility functional tests', () => {
     jest.clearAllMocks();
     process.env.NEXT_PUBLIC_URL = 'https://example.com';
 
-    mockServerVariables.locale = 'en';
-  });
+    mockServerVariables.locale =
+      actualSettings?.localization?.defaultLocaleValue || 'en';
 
-  describe('getUrlPathWithLocale functional tests', () => {
-    describe('Actual behavior testing', () => {
-      it('should test actual function behavior with real inputs', () => {
-        const result1 = getUrlPathWithLocale('/login', 'en');
-        const result2 = getUrlPathWithLocale('/login', 'tr');
-        const result3 = getUrlPathWithLocale('/login', undefined);
+    mockCookies.mockReturnValue({
+      get: jest.fn().mockReturnValue(undefined)
+    });
 
-        expect(result1).toBe('/login');
-        expect(result2).toBe('/tr/login');
-        expect(result3).toBe('/login');
-      });
+    mockHeaders.mockReturnValue(new Map());
+  });
 
-      it('should handle complex paths with locale prefixes', () => {
-        const result1 = getUrlPathWithLocale('/account/orders/123', 'en');
-        const result2 = getUrlPathWithLocale('/account/orders/123', 'tr');
-        const result3 = getUrlPathWithLocale('/account/orders/123', 'ar');
+  describe('getUrlPathWithLocale functional tests', () => {
+    describe('Dynamic behavior based on actual settings', () => {
+      it('should work correctly with project localeUrlStrategy', () => {
+        const defaultLocale =
+          actualSettings?.localization?.defaultLocaleValue || 'en';
+        const strategy =
+          actualSettings?.localization?.localeUrlStrategy ||
+          LocaleUrlStrategy.HideDefaultLocale;
+        const locales = actualSettings?.localization?.locales || [
+          { value: 'en', label: 'EN' },
+          { value: 'tr', label: 'TR' }
+        ];
+
+        const result1 = getUrlPathWithLocale('/login', defaultLocale);
+
+        const nonDefaultLocale = locales.find(
+          (locale: Locale) => locale.value !== defaultLocale
+        );
+        const result2 = nonDefaultLocale
+          ? getUrlPathWithLocale('/login', nonDefaultLocale.value)
+          : null;
 
-        expect(result1).toBe('/account/orders/123');
-        expect(result2).toBe('/tr/account/orders/123');
-        expect(result3).toBe('/ar/account/orders/123');
-      });
+        const result3 = getUrlPathWithLocale('/login', undefined);
 
-      it('should fallback to default locale behavior when currentLocale is undefined', () => {
-        const result = getUrlPathWithLocale('/dashboard', undefined);
-        expect(result).toBe('/dashboard');
+        if (strategy === LocaleUrlStrategy.HideDefaultLocale) {
+          expect(result1).toBe('/login');
+          if (result2 && nonDefaultLocale) {
+            expect(result2).toBe(`/${nonDefaultLocale.value}/login`);
+          }
+          expect(result3).toBe('/login');
+        } else if (strategy === LocaleUrlStrategy.ShowAllLocales) {
+          expect(result1).toBe(`/${defaultLocale}/login`);
+          if (result2 && nonDefaultLocale) {
+            expect(result2).toBe(`/${nonDefaultLocale.value}/login`);
+          }
+          expect(result3).toBe(`/${defaultLocale}/login`);
+        } else if (strategy === LocaleUrlStrategy.HideAllLocales) {
+          expect(result1).toBe('/login');
+          if (result2) {
+            expect(result2).toBe('/login');
+          }
+          expect(result3).toBe('/login');
+        } else if (strategy === LocaleUrlStrategy.Subdomain) {
+          expect(result1).toBe('/login');
+          if (result2) {
+            expect(result2).toBe('/login');
+          }
+          expect(result3).toBe('/login');
+        }
       });
 
-      it('should handle empty paths correctly', () => {
-        const result1 = getUrlPathWithLocale('/', 'en');
-        const result2 = getUrlPathWithLocale('/', 'tr');
+      it('should handle complex paths correctly with project settings', () => {
+        const defaultLocale =
+          actualSettings?.localization?.defaultLocaleValue || 'en';
+        const locales = actualSettings?.localization?.locales || [
+          { value: 'en', label: 'EN' },
+          { value: 'tr', label: 'TR' }
+        ];
+        const strategy =
+          actualSettings?.localization?.localeUrlStrategy ||
+          LocaleUrlStrategy.HideDefaultLocale;
+
+        const complexPath = '/account/orders/123';
+        const nonDefaultLocale = locales.find(
+          (locale: Locale) => locale.value !== defaultLocale
+        );
 
-        expect(result1).toBe('/');
-        expect(result2).toBe('/tr/');
+        const result1 = getUrlPathWithLocale(complexPath, defaultLocale);
+        const result2 = nonDefaultLocale
+          ? getUrlPathWithLocale(complexPath, nonDefaultLocale.value)
+          : null;
+
+        if (strategy === LocaleUrlStrategy.HideDefaultLocale) {
+          expect(result1).toBe(complexPath);
+          if (result2 && nonDefaultLocale) {
+            expect(result2).toBe(`/${nonDefaultLocale.value}${complexPath}`);
+          }
+        } else if (strategy === LocaleUrlStrategy.ShowAllLocales) {
+          expect(result1).toBe(`/${defaultLocale}${complexPath}`);
+          if (result2 && nonDefaultLocale) {
+            expect(result2).toBe(`/${nonDefaultLocale.value}${complexPath}`);
+          }
+        }
       });
 
-      it('should handle paths with query parameters', () => {
-        const result1 = getUrlPathWithLocale('/search?q=test', 'en');
-        const result2 = getUrlPathWithLocale('/search?q=test', 'tr');
+      it('should handle query parameters correctly', () => {
+        const defaultLocale =
+          actualSettings?.localization?.defaultLocaleValue || 'en';
+        const locales = actualSettings?.localization?.locales || [
+          { value: 'en', label: 'EN' },
+          { value: 'tr', label: 'TR' }
+        ];
+        const strategy =
+          actualSettings?.localization?.localeUrlStrategy ||
+          LocaleUrlStrategy.HideDefaultLocale;
+
+        const pathWithQuery = '/search?q=test';
+        const nonDefaultLocale = locales.find(
+          (locale: Locale) => locale.value !== defaultLocale
+        );
 
-        expect(result1).toBe('/search?q=test');
-        expect(result2).toBe('/tr/search?q=test');
+        const result1 = getUrlPathWithLocale(pathWithQuery, defaultLocale);
+        const result2 = nonDefaultLocale
+          ? getUrlPathWithLocale(pathWithQuery, nonDefaultLocale.value)
+          : null;
+
+        if (strategy === LocaleUrlStrategy.HideDefaultLocale) {
+          expect(result1).toBe(pathWithQuery);
+          if (result2 && nonDefaultLocale) {
+            expect(result2).toBe(`/${nonDefaultLocale.value}${pathWithQuery}`);
+          }
+        } else if (strategy === LocaleUrlStrategy.ShowAllLocales) {
+          expect(result1).toBe(`/${defaultLocale}${pathWithQuery}`);
+          if (result2 && nonDefaultLocale) {
+            expect(result2).toBe(`/${nonDefaultLocale.value}${pathWithQuery}`);
+          }
+        }
       });
     });
   });
 
   describe('URL locale matcher regex behavior', () => {
-    const urlLocaleMatcherRegex = /^\/(?:tr|ar)(?=\/|$)/;
+    it('should match non-default locale prefixes based on project settings', () => {
+      const defaultLocale =
+        actualSettings?.localization?.defaultLocaleValue || 'en';
+      const locales = actualSettings?.localization?.locales || [
+        { value: 'en', label: 'EN' },
+        { value: 'tr', label: 'TR' }
+      ];
 
-    it('should match non-default locale prefixes', () => {
-      expect(urlLocaleMatcherRegex.test('/tr/profile')).toBe(true);
-      expect(urlLocaleMatcherRegex.test('/ar/dashboard')).toBe(true);
-    });
+      const nonDefaultLocales = locales
+        .filter((locale: Locale) => locale.value !== defaultLocale)
+        .map((locale: Locale) => locale.value);
 
-    it('should not match default locale or paths without locale', () => {
-      expect(urlLocaleMatcherRegex.test('/en/profile')).toBe(false);
+      const urlLocaleMatcherRegex = new RegExp(
+        `^\\/(${nonDefaultLocales.join('|')})(?=\\/|$)`
+      );
+
+      nonDefaultLocales.forEach((locale: string) => {
+        expect(urlLocaleMatcherRegex.test(`/${locale}/profile`)).toBe(true);
+        expect(urlLocaleMatcherRegex.test(`/${locale}`)).toBe(true);
+      });
+
+      expect(urlLocaleMatcherRegex.test(`/${defaultLocale}/profile`)).toBe(
+        false
+      );
       expect(urlLocaleMatcherRegex.test('/profile')).toBe(false);
-      expect(urlLocaleMatcherRegex.test('/dashboard')).toBe(false);
     });
 
-    it('should match locale at start of path only', () => {
-      expect(urlLocaleMatcherRegex.test('/tr/some/path')).toBe(true);
-      expect(urlLocaleMatcherRegex.test('/tr')).toBe(true);
-      expect(urlLocaleMatcherRegex.test('/some/tr/path')).toBe(false);
-    });
+    it('should handle callback URL extraction correctly with project locales', () => {
+      const defaultLocale =
+        actualSettings?.localization?.defaultLocaleValue || 'en';
+      const locales = actualSettings?.localization?.locales || [
+        { value: 'en', label: 'EN' },
+        { value: 'tr', label: 'TR' }
+      ];
+
+      const nonDefaultLocales = locales
+        .filter((locale: Locale) => locale.value !== defaultLocale)
+        .map((locale: Locale) => locale.value);
+
+      const urlLocaleMatcherRegex = new RegExp(
+        `^\\/(${nonDefaultLocales.join('|')})(?=\\/|$)`
+      );
 
-    it('should handle callback URL extraction correctly', () => {
       const testPaths = [
-        { input: '/tr/profile', expected: '/profile' },
-        { input: '/ar/dashboard/settings', expected: '/dashboard/settings' },
+        ...nonDefaultLocales.map((locale: string) => ({
+          input: `/${locale}/profile`,
+          expected: '/profile'
+        })),
         { input: '/profile', expected: '/profile' },
-        { input: '/en/profile', expected: '/en/profile' }
+        {
+          input: `/${defaultLocale}/profile`,
+          expected: `/${defaultLocale}/profile`
+        }
       ];
 
       testPaths.forEach(({ input, expected }) => {
@@ -158,7 +329,9 @@ describe('Redirect utility functional tests', () => {
   describe('redirect function behavior', () => {
     describe('Default locale strategy tests', () => {
       beforeEach(() => {
-        mockServerVariables.locale = 'en';
+        const defaultLocale =
+          actualSettings?.localization?.defaultLocaleValue || 'en';
+        mockServerVariables.locale = defaultLocale;
       });
 
       it('should redirect with correct URL for default locale', () => {
@@ -174,42 +347,118 @@ describe('Redirect utility functional tests', () => {
       });
 
       it('should redirect with locale handling for non-default locale', () => {
-        mockServerVariables.locale = 'tr';
-        mockHeaders.mockReturnValue(
-          new Map([['pz-url', 'https://example.com/tr/profile']])
+        const locales = actualSettings?.localization?.locales || [
+          { value: 'en', label: 'EN' },
+          { value: 'tr', label: 'TR' }
+        ];
+        const defaultLocale =
+          actualSettings?.localization?.defaultLocaleValue || 'en';
+        const nonDefaultLocale = locales.find(
+          (locale: Locale) => locale.value !== defaultLocale
         );
 
-        redirect('/login');
+        if (nonDefaultLocale) {
+          mockServerVariables.locale = nonDefaultLocale.value;
+          mockHeaders.mockReturnValue(
+            new Map([
+              [
+                'pz-url',
+                `https://example.com/${nonDefaultLocale.value}/profile`
+              ]
+            ])
+          );
 
-        expect(mockNextRedirect).toHaveBeenCalledWith(
-          '/tr/login?callbackUrl=/profile'
-        );
+          redirect('/login');
+
+          expect(mockNextRedirect).toHaveBeenCalledWith(
+            `/${nonDefaultLocale.value}/login?callbackUrl=/profile`
+          );
+        } else {
+          expect(true).toBe(true);
+        }
       });
 
       it('should extract callback URL correctly removing locale prefix', () => {
-        mockServerVariables.locale = 'tr';
-        mockHeaders.mockReturnValue(
-          new Map([['pz-url', 'https://example.com/tr/dashboard/settings']])
+        const locales = actualSettings?.localization?.locales || [
+          { value: 'en', label: 'EN' },
+          { value: 'tr', label: 'TR' }
+        ];
+        const defaultLocale =
+          actualSettings?.localization?.defaultLocaleValue || 'en';
+        const nonDefaultLocale = locales.find(
+          (locale: Locale) => locale.value !== defaultLocale
         );
 
-        redirect('/auth');
-
-        expect(mockNextRedirect).toHaveBeenCalledWith(
-          '/tr/auth?callbackUrl=/dashboard/settings'
-        );
+        if (nonDefaultLocale) {
+          mockServerVariables.locale = nonDefaultLocale.value;
+          mockHeaders.mockReturnValue(
+            new Map([
+              [
+                'pz-url',
+                `https://example.com/${nonDefaultLocale.value}/dashboard/settings`
+              ]
+            ])
+          );
+
+          redirect('/auth');
+
+          expect(mockNextRedirect).toHaveBeenCalledWith(
+            `/${nonDefaultLocale.value}/auth?callbackUrl=/dashboard/settings`
+          );
+        } else {
+          expect(true).toBe(true);
+        }
       });
 
-      it('should handle Arabic RTL locale correctly', () => {
-        mockServerVariables.locale = 'ar';
-        mockHeaders.mockReturnValue(
-          new Map([['pz-url', 'https://example.com/ar/products/123']])
+      it('should handle RTL or additional locale correctly if available', () => {
+        const locales = actualSettings?.localization?.locales || [
+          { value: 'en', label: 'EN' },
+          { value: 'tr', label: 'TR' }
+        ];
+        const defaultLocale =
+          actualSettings?.localization?.defaultLocaleValue || 'en';
+        const rtlLocale = locales.find(
+          (locale: Locale) =>
+            locale.value !== defaultLocale && locale.value !== 'tr'
         );
 
-        redirect('/checkout');
-
-        expect(mockNextRedirect).toHaveBeenCalledWith(
-          '/checkout?callbackUrl=/products/123'
-        );
+        if (rtlLocale) {
+          mockServerVariables.locale = rtlLocale.value;
+          mockHeaders.mockReturnValue(
+            new Map([
+              ['pz-url', `https://example.com/${rtlLocale.value}/products/123`]
+            ])
+          );
+
+          redirect('/checkout');
+
+          expect(mockNextRedirect).toHaveBeenCalledWith(
+            `/${rtlLocale.value}/checkout?callbackUrl=/products/123`
+          );
+        } else {
+          const nonDefaultLocale = locales.find(
+            (locale: Locale) => locale.value !== defaultLocale
+          );
+          if (nonDefaultLocale) {
+            mockServerVariables.locale = nonDefaultLocale.value;
+            mockHeaders.mockReturnValue(
+              new Map([
+                [
+                  'pz-url',
+                  `https://example.com/${nonDefaultLocale.value}/products/123`
+                ]
+              ])
+            );
+
+            redirect('/checkout');
+
+            expect(mockNextRedirect).toHaveBeenCalledWith(
+              `/${nonDefaultLocale.value}/checkout?callbackUrl=/products/123`
+            );
+          } else {
+            expect(true).toBe(true);
+          }
+        }
       });
 
       it('should preserve complex callback URLs', () => {
@@ -285,7 +534,10 @@ describe('Redirect utility functional tests', () => {
           new Map([['pz-url', 'https://example.com/profile']])
         );
 
-        redirect('/login');
+        // Should not throw error, should handle gracefully
+        expect(() => {
+          redirect('/login');
+        }).not.toThrow();
 
         expect(mockNextRedirect).toHaveBeenCalledWith(
           '/login?callbackUrl=/profile'
@@ -298,14 +550,17 @@ describe('Redirect utility functional tests', () => {
           new Map([['pz-url', 'https://example.com/profile']])
         );
 
-        redirect('/login');
+        // Should not throw error, should handle gracefully
+        expect(() => {
+          redirect('/login');
+        }).not.toThrow();
 
         expect(mockNextRedirect).toHaveBeenCalledWith(
           '/login?callbackUrl=/profile'
         );
       });
 
-      it('should strip query parameters from callback URL', () => {
+      it('should preserve query parameters in callback URL', () => {
         mockHeaders.mockReturnValue(
           new Map([
             ['pz-url', 'https://example.com/profile?tab=settings&view=list']
@@ -315,11 +570,11 @@ describe('Redirect utility functional tests', () => {
         redirect('/login');
 
         expect(mockNextRedirect).toHaveBeenCalledWith(
-          '/login?callbackUrl=/profile'
+          '/login?callbackUrl=/profile?tab=settings&view=list'
         );
       });
 
-      it('should strip fragments from callback URL', () => {
+      it('should strip fragments from callback URL (expected behavior)', () => {
         mockHeaders.mockReturnValue(
           new Map([['pz-url', 'https://example.com/profile#section']])
         );
@@ -331,7 +586,7 @@ describe('Redirect utility functional tests', () => {
         );
       });
 
-      it('should handle URL with both query params and fragments', () => {
+      it('should handle URL with both query params and fragments (fragments stripped)', () => {
         mockHeaders.mockReturnValue(
           new Map([['pz-url', 'https://example.com/profile?tab=orders#recent']])
         );
@@ -339,7 +594,7 @@ describe('Redirect utility functional tests', () => {
         redirect('/auth');
 
         expect(mockNextRedirect).toHaveBeenCalledWith(
-          '/auth?callbackUrl=/profile'
+          '/auth?callbackUrl=/profile?tab=orders'
         );
       });
     });
@@ -347,38 +602,95 @@ describe('Redirect utility functional tests', () => {
 
   describe('Integration scenarios', () => {
     it('should handle complete flow with non-default locale and complex path', () => {
-      mockServerVariables.locale = 'tr';
-      mockHeaders.mockReturnValue(
-        new Map([['pz-url', 'https://example.com/tr/account/orders/123']])
+      const locales = actualSettings?.localization?.locales || [
+        { value: 'en', label: 'EN' },
+        { value: 'tr', label: 'TR' }
+      ];
+      const defaultLocale =
+        actualSettings?.localization?.defaultLocaleValue || 'en';
+      const nonDefaultLocale = locales.find(
+        (locale: Locale) => locale.value !== defaultLocale
       );
 
-      redirect('/auth/login');
+      if (nonDefaultLocale) {
+        mockServerVariables.locale = nonDefaultLocale.value;
+        mockHeaders.mockReturnValue(
+          new Map([
+            [
+              'pz-url',
+              `https://example.com/${nonDefaultLocale.value}/account/orders/123`
+            ]
+          ])
+        );
 
-      expect(mockNextRedirect).toHaveBeenCalledWith(
-        '/tr/auth/login?callbackUrl=/account/orders/123'
-      );
+        redirect('/auth/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          `/${nonDefaultLocale.value}/auth/login?callbackUrl=/account/orders/123`
+        );
+      } else {
+        expect(true).toBe(true);
+      }
     });
 
-    it('should handle RTL locale with deep nested paths', () => {
-      mockServerVariables.locale = 'ar';
-      mockHeaders.mockReturnValue(
-        new Map([
-          [
-            'pz-url',
-            'https://example.com/ar/products/category/electronics/item/456'
-          ]
-        ])
+    it('should handle additional locale with deep nested paths if available', () => {
+      const locales = actualSettings?.localization?.locales || [
+        { value: 'en', label: 'EN' },
+        { value: 'tr', label: 'TR' }
+      ];
+      const defaultLocale =
+        actualSettings?.localization?.defaultLocaleValue || 'en';
+      const additionalLocale = locales.find(
+        (locale: Locale) =>
+          locale.value !== defaultLocale && locale.value !== 'tr'
       );
 
-      redirect('/auth');
+      if (additionalLocale) {
+        mockServerVariables.locale = additionalLocale.value;
+        mockHeaders.mockReturnValue(
+          new Map([
+            [
+              'pz-url',
+              `https://example.com/${additionalLocale.value}/products/category/electronics/item/456`
+            ]
+          ])
+        );
 
-      expect(mockNextRedirect).toHaveBeenCalledWith(
-        '/auth?callbackUrl=/products/category/electronics/item/456'
-      );
+        redirect('/auth');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          `/${additionalLocale.value}/auth?callbackUrl=/products/category/electronics/item/456`
+        );
+      } else {
+        const nonDefaultLocale = locales.find(
+          (locale: Locale) => locale.value !== defaultLocale
+        );
+        if (nonDefaultLocale) {
+          mockServerVariables.locale = nonDefaultLocale.value;
+          mockHeaders.mockReturnValue(
+            new Map([
+              [
+                'pz-url',
+                `https://example.com/${nonDefaultLocale.value}/products/category/electronics/item/456`
+              ]
+            ])
+          );
+
+          redirect('/auth');
+
+          expect(mockNextRedirect).toHaveBeenCalledWith(
+            `/${nonDefaultLocale.value}/auth?callbackUrl=/products/category/electronics/item/456`
+          );
+        } else {
+          expect(true).toBe(true);
+        }
+      }
     });
 
     it('should handle default locale with no prefix in callback', () => {
-      mockServerVariables.locale = 'en';
+      const defaultLocale =
+        actualSettings?.localization?.defaultLocaleValue || 'en';
+      mockServerVariables.locale = defaultLocale;
       mockHeaders.mockReturnValue(
         new Map([['pz-url', 'https://example.com/checkout/payment']])
       );
@@ -391,21 +703,35 @@ describe('Redirect utility functional tests', () => {
     });
 
     it('should handle complex URLs with mixed locale scenarios', () => {
-      mockServerVariables.locale = 'tr';
-      mockHeaders.mockReturnValue(
-        new Map([
-          [
-            'pz-url',
-            'https://subdomain.example.com/tr/user/dashboard?section=profile&tab=settings#preferences'
-          ]
-        ])
+      const locales = actualSettings?.localization?.locales || [
+        { value: 'en', label: 'EN' },
+        { value: 'tr', label: 'TR' }
+      ];
+      const defaultLocale =
+        actualSettings?.localization?.defaultLocaleValue || 'en';
+      const nonDefaultLocale = locales.find(
+        (locale: Locale) => locale.value !== defaultLocale
       );
 
-      redirect('/verify-account');
+      if (nonDefaultLocale) {
+        mockServerVariables.locale = nonDefaultLocale.value;
+        mockHeaders.mockReturnValue(
+          new Map([
+            [
+              'pz-url',
+              `https://subdomain.example.com/${nonDefaultLocale.value}/user/dashboard?section=profile&tab=settings#preferences`
+            ]
+          ])
+        );
 
-      expect(mockNextRedirect).toHaveBeenCalledWith(
-        '/tr/verify-account?callbackUrl=/user/dashboard'
-      );
+        redirect('/verify-account');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          `/${nonDefaultLocale.value}/verify-account?callbackUrl=/user/dashboard?section=profile&tab=settings`
+        );
+      } else {
+        expect(true).toBe(true);
+      }
     });
   });
 

package/data/client/checkout.ts

@@ -35,8 +35,10 @@ import {
 
 interface CheckoutResponse {
   pre_order?: PreOrder;
-  errors: {
-    non_field_errors: string;
+  errors?: {
+    non_field_errors?: string;
+    sample_products?: string[];
+    [key: string]: string | string[] | undefined;
   };
   context_list?: CheckoutContext[];
   template_name?: string;

package/jest.config.js

@@ -7,9 +7,9 @@ module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   rootDir: path.resolve(__dirname),
-  testMatch: ['**/__tests__/**/*.test.ts'],
+  testMatch: ['**/*.test.ts'],
   testPathIgnorePatterns: [],
-  roots: [],
+  roots: [path.resolve(__dirname)],
   transformIgnorePatterns: [],
   moduleNameMapper: {
     '^settings$': path.resolve(baseDir, 'src/settings.js')

package/package.json

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