@akinon/next 1.92.0-rc.25 → 1.92.0-rc.26

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @akinon/next
 
+## 1.92.0-rc.26
+
+### Minor Changes
+
+- 16aff54: ZERO-3431: Add test script for redirect utility in package.json
+
 ## 1.92.0-rc.25
 
 ### Minor Changes

package/__tests__/next-config.test.ts

@@ -1,15 +1,6 @@
 import { resolve } from 'path';
 import type { NextConfig } from 'next';
-
-function findBaseDir() {
-  const insideNodeModules = __dirname.includes('node_modules');
-
-  if (insideNodeModules) {
-    return resolve(__dirname, '../../../../');
-  } else {
-    return resolve(__dirname, '../../../apps/projectzeronext');
-  }
-}
+import findBaseDir from '../utils/find-base-dir';
 
 const baseDir = findBaseDir();
 

package/__tests__/redirect.test.ts

@@ -0,0 +1,432 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+const mockNextRedirect = jest.fn();
+const mockHeaders = jest.fn();
+
+function findBaseDir() {
+  const insideNodeModules = __dirname.includes('node_modules');
+
+  if (insideNodeModules) {
+    return path.resolve(__dirname, '../../../../');
+  } else {
+    return path.resolve(__dirname, '../../../apps/projectzeronext');
+  }
+}
+
+jest.mock(
+  '@theme/routes',
+  () => ({
+    ROUTES: {
+      AUTH: '/auth',
+      BASKET: '/basket',
+      ACCOUNT_ORDERS: '/account/orders'
+    }
+  }),
+  { virtual: true }
+);
+
+jest.mock('next/navigation', () => ({
+  redirect: mockNextRedirect,
+  RedirectType: {
+    replace: 'replace',
+    push: 'push'
+  }
+}));
+
+jest.mock('next/headers', () => ({
+  headers: () => mockHeaders()
+}));
+
+const mockServerVariables = {
+  locale: 'en' as string | undefined
+};
+
+jest.mock('@akinon/next/utils/server-variables', () => ({
+  ServerVariables: mockServerVariables
+}));
+
+jest.mock('@akinon/next/utils', () => ({
+  urlLocaleMatcherRegex: /^\/(?:tr|ar)(?=\/|$)/
+}));
+
+describe('Redirect utility functional tests', () => {
+  let redirect: any;
+  let getUrlPathWithLocale: any;
+  let LocaleUrlStrategy: any;
+
+  beforeAll(async () => {
+    const localizationModule = await import('@akinon/next/localization');
+    LocaleUrlStrategy = localizationModule.LocaleUrlStrategy;
+
+    const redirectModule = await import('@akinon/next/utils/redirect');
+    redirect = redirectModule.redirect;
+
+    const localizationUtilsModule = await import(
+      '@akinon/next/utils/localization'
+    );
+    getUrlPathWithLocale = localizationUtilsModule.getUrlPathWithLocale;
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env.NEXT_PUBLIC_URL = 'https://example.com';
+
+    mockServerVariables.locale = '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);
+
+        expect(result1).toBe('/login');
+        expect(result2).toBe('/tr/login');
+        expect(result3).toBe('/login');
+      });
+
+      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');
+
+        expect(result1).toBe('/account/orders/123');
+        expect(result2).toBe('/tr/account/orders/123');
+        expect(result3).toBe('/ar/account/orders/123');
+      });
+
+      it('should fallback to default locale behavior when currentLocale is undefined', () => {
+        const result = getUrlPathWithLocale('/dashboard', undefined);
+        expect(result).toBe('/dashboard');
+      });
+
+      it('should handle empty paths correctly', () => {
+        const result1 = getUrlPathWithLocale('/', 'en');
+        const result2 = getUrlPathWithLocale('/', 'tr');
+
+        expect(result1).toBe('/');
+        expect(result2).toBe('/tr/');
+      });
+
+      it('should handle paths with query parameters', () => {
+        const result1 = getUrlPathWithLocale('/search?q=test', 'en');
+        const result2 = getUrlPathWithLocale('/search?q=test', 'tr');
+
+        expect(result1).toBe('/search?q=test');
+        expect(result2).toBe('/tr/search?q=test');
+      });
+    });
+  });
+
+  describe('URL locale matcher regex behavior', () => {
+    const urlLocaleMatcherRegex = /^\/(?:tr|ar)(?=\/|$)/;
+
+    it('should match non-default locale prefixes', () => {
+      expect(urlLocaleMatcherRegex.test('/tr/profile')).toBe(true);
+      expect(urlLocaleMatcherRegex.test('/ar/dashboard')).toBe(true);
+    });
+
+    it('should not match default locale or paths without locale', () => {
+      expect(urlLocaleMatcherRegex.test('/en/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', () => {
+      const testPaths = [
+        { input: '/tr/profile', expected: '/profile' },
+        { input: '/ar/dashboard/settings', expected: '/dashboard/settings' },
+        { input: '/profile', expected: '/profile' },
+        { input: '/en/profile', expected: '/en/profile' }
+      ];
+
+      testPaths.forEach(({ input, expected }) => {
+        const result = input.replace(urlLocaleMatcherRegex, '');
+        expect(result).toBe(expected);
+      });
+    });
+  });
+
+  describe('redirect function behavior', () => {
+    describe('Default locale strategy tests', () => {
+      beforeEach(() => {
+        mockServerVariables.locale = 'en';
+      });
+
+      it('should redirect with correct URL for default locale', () => {
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/profile']])
+        );
+
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/login?callbackUrl=/profile'
+        );
+      });
+
+      it('should redirect with locale handling for non-default locale', () => {
+        mockServerVariables.locale = 'tr';
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/tr/profile']])
+        );
+
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/tr/login?callbackUrl=/profile'
+        );
+      });
+
+      it('should extract callback URL correctly removing locale prefix', () => {
+        mockServerVariables.locale = 'tr';
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/tr/dashboard/settings']])
+        );
+
+        redirect('/auth');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/tr/auth?callbackUrl=/dashboard/settings'
+        );
+      });
+
+      it('should handle Arabic RTL locale correctly', () => {
+        mockServerVariables.locale = 'ar';
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/ar/products/123']])
+        );
+
+        redirect('/checkout');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/checkout?callbackUrl=/products/123'
+        );
+      });
+
+      it('should preserve complex callback URLs', () => {
+        mockServerVariables.locale = 'tr';
+        mockHeaders.mockReturnValue(
+          new Map([
+            ['pz-url', 'https://example.com/tr/account/orders/123/details']
+          ])
+        );
+
+        redirect('/auth/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/tr/auth/login?callbackUrl=/account/orders/123/details'
+        );
+      });
+    });
+
+    describe('Redirect type handling', () => {
+      beforeEach(() => {
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/profile']])
+        );
+      });
+
+      it('should pass RedirectType when provided', () => {
+        const { RedirectType } = require('next/navigation');
+
+        redirect('/login', RedirectType.replace);
+
+        expect(mockNextRedirect).toHaveBeenCalledTimes(1);
+        const [redirectUrl, type] = mockNextRedirect.mock.calls[0];
+        expect(redirectUrl).toContain('/login');
+        expect(type).toBe(RedirectType.replace);
+      });
+
+      it('should call redirect without type when not provided', () => {
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledTimes(1);
+        const args = mockNextRedirect.mock.calls[0];
+        expect(args.length).toBe(1);
+      });
+    });
+
+    describe('Error handling and edge cases', () => {
+      it('should handle missing pz-url header with env fallback', () => {
+        mockHeaders.mockReturnValue(new Map());
+        process.env.NEXT_PUBLIC_URL = 'https://fallback.com/some/path';
+
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/login?callbackUrl=/some/path'
+        );
+      });
+
+      it('should handle completely missing URL sources gracefully', () => {
+        mockHeaders.mockReturnValue(new Map());
+        const originalEnv = process.env.NEXT_PUBLIC_URL;
+        delete process.env.NEXT_PUBLIC_URL;
+
+        expect(() => {
+          redirect('/login');
+        }).toThrow('Invalid URL');
+
+        process.env.NEXT_PUBLIC_URL = originalEnv;
+      });
+
+      it('should handle undefined locale gracefully', () => {
+        mockServerVariables.locale = undefined;
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/profile']])
+        );
+
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/login?callbackUrl=/profile'
+        );
+      });
+
+      it('should handle invalid locale gracefully', () => {
+        mockServerVariables.locale = 'invalid-locale';
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/profile']])
+        );
+
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/login?callbackUrl=/profile'
+        );
+      });
+
+      it('should strip query parameters from callback URL', () => {
+        mockHeaders.mockReturnValue(
+          new Map([
+            ['pz-url', 'https://example.com/profile?tab=settings&view=list']
+          ])
+        );
+
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/login?callbackUrl=/profile'
+        );
+      });
+
+      it('should strip fragments from callback URL', () => {
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/profile#section']])
+        );
+
+        redirect('/login');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/login?callbackUrl=/profile'
+        );
+      });
+
+      it('should handle URL with both query params and fragments', () => {
+        mockHeaders.mockReturnValue(
+          new Map([['pz-url', 'https://example.com/profile?tab=orders#recent']])
+        );
+
+        redirect('/auth');
+
+        expect(mockNextRedirect).toHaveBeenCalledWith(
+          '/auth?callbackUrl=/profile'
+        );
+      });
+    });
+  });
+
+  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']])
+      );
+
+      redirect('/auth/login');
+
+      expect(mockNextRedirect).toHaveBeenCalledWith(
+        '/tr/auth/login?callbackUrl=/account/orders/123'
+      );
+    });
+
+    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'
+          ]
+        ])
+      );
+
+      redirect('/auth');
+
+      expect(mockNextRedirect).toHaveBeenCalledWith(
+        '/auth?callbackUrl=/products/category/electronics/item/456'
+      );
+    });
+
+    it('should handle default locale with no prefix in callback', () => {
+      mockServerVariables.locale = 'en';
+      mockHeaders.mockReturnValue(
+        new Map([['pz-url', 'https://example.com/checkout/payment']])
+      );
+
+      redirect('/auth/login');
+
+      expect(mockNextRedirect).toHaveBeenCalledWith(
+        '/auth/login?callbackUrl=/checkout/payment'
+      );
+    });
+
+    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'
+          ]
+        ])
+      );
+
+      redirect('/verify-account');
+
+      expect(mockNextRedirect).toHaveBeenCalledWith(
+        '/tr/verify-account?callbackUrl=/user/dashboard'
+      );
+    });
+  });
+
+  it('should verify redirect utility file exists and has expected structure', () => {
+    const baseDir = findBaseDir();
+    const insideNodeModules = __dirname.includes('node_modules');
+
+    let redirectFilePath;
+    if (insideNodeModules) {
+      redirectFilePath = path.resolve(__dirname, '../utils/redirect.ts');
+    } else {
+      redirectFilePath = path.resolve(
+        baseDir,
+        '../../packages/akinon-next/utils/redirect.ts'
+      );
+    }
+
+    const redirectFileContent = fs.readFileSync(redirectFilePath, 'utf8');
+
+    expect(redirectFileContent.includes('export const redirect')).toBe(true);
+    expect(redirectFileContent.includes('getUrlPathWithLocale')).toBe(true);
+    expect(redirectFileContent.includes('callbackUrl')).toBe(true);
+  });
+});

package/jest.config.js

@@ -1,13 +1,19 @@
 const path = require('path');
+const findBaseDir = require('./utils/find-base-dir');
+
+const baseDir = findBaseDir();
 
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   rootDir: path.resolve(__dirname),
-  roots: [],
-  testMatch: ['**/*.test.ts'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
   testPathIgnorePatterns: [],
+  roots: [],
   transformIgnorePatterns: [],
+  moduleNameMapper: {
+    '^settings$': path.resolve(baseDir, 'src/settings.js')
+  },
   transform: {
     '^.+\\.(tsx?|jsx?|mjs?)$': [
       'ts-jest',

package/package.json

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