@akinon/next 1.107.0 → 1.108.0-rc.87

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');
-  }
-}
+const findBaseDir = require('../utils/find-base-dir');
 
 const baseDir = findBaseDir();
 

package/__tests__/redirect.test.ts

@@ -0,0 +1,319 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+jest.mock(
+  'countries',
+  () => ({
+    countries: [
+      { value: 'ae', localizable: true },
+      { value: 'qa', localizable: true },
+      { value: 'sa', localizable: true }
+    ],
+    countryCurrencyMap: { ae: 'aed', qa: 'qar', sa: 'sar' },
+    countryShortCodeMap: { ae: 'uae', qa: 'qtr', sa: 'ksa' }
+  }),
+  { virtual: true }
+);
+
+jest.mock(
+  '@theme/routes',
+  () => ({
+    ROUTES: {
+      AUTH: '/auth',
+      BASKET: '/basket',
+      ACCOUNT_ORDERS: '/account/orders'
+    }
+  }),
+  { virtual: true }
+);
+
+type Locale = {
+  value: string;
+  label?: string;
+  localePath?: string;
+  apiValue?: string;
+  rtl?: boolean;
+};
+
+type Settings = {
+  localization: {
+    defaultLocaleValue: string;
+    localeUrlStrategy: string;
+    locales: Locale[];
+  };
+};
+
+function resolveSettingsPath(): string | null {
+  const insideNodeModules = __dirname.includes('node_modules');
+
+  const candidates: string[] = [];
+
+  if (insideNodeModules) {
+    const projectRoot = path.resolve(__dirname, '../../../../');
+    candidates.push(path.join(projectRoot, 'src/settings.js'));
+    candidates.push(
+      path.join(projectRoot, 'apps', 'projectzeronext', 'src', 'settings.js')
+    );
+  } else {
+    const repoRoot = path.resolve(__dirname, '../../..');
+    candidates.push(
+      path.join(repoRoot, 'apps', 'projectzeronext', 'src', 'settings.js')
+    );
+    candidates.push(path.join(repoRoot, 'src', 'settings.js'));
+  }
+
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+
+  return null;
+}
+
+function loadProjectSettings(): Settings {
+  const settingsPath = resolveSettingsPath();
+  if (settingsPath) {
+    const settings: any = require(settingsPath);
+    return settings as Settings;
+  }
+
+  return {
+    localization: {
+      defaultLocaleValue: 'en',
+      localeUrlStrategy: 'hide-default-locale',
+      locales: [
+        { value: 'en', label: 'EN' },
+        { value: 'tr', label: 'TR' }
+      ]
+    }
+  };
+}
+
+function getUrlPathWithLocaleLocal(
+  pathname: string,
+  currentLocale: string | undefined,
+  settings: Settings
+): string {
+  const { defaultLocaleValue, localeUrlStrategy } = settings.localization;
+  const effectiveLocale = currentLocale ?? defaultLocaleValue;
+
+  if (
+    localeUrlStrategy === 'subdomain' ||
+    localeUrlStrategy === 'hide-all-locales'
+  ) {
+    return pathname;
+  }
+
+  if (localeUrlStrategy === 'hide-default-locale') {
+    if (effectiveLocale === defaultLocaleValue) {
+      return pathname;
+    }
+    return `/${effectiveLocale}${pathname}`;
+  }
+
+  return `/${effectiveLocale}${pathname}`;
+}
+
+function computeUrlLocaleMatcherRegex(settings: Settings): RegExp {
+  const { locales, localeUrlStrategy, defaultLocaleValue } =
+    settings.localization;
+
+  const filtered =
+    localeUrlStrategy === 'show-all-locales' ||
+    localeUrlStrategy === 'subdomain'
+      ? locales
+      : locales.filter((l: any) => l.value !== defaultLocaleValue);
+
+  return new RegExp(
+    `^/(${filtered.map((l: any) => l.value).join('|')})(?=/|$)`
+  );
+}
+
+function redirectMinimal(
+  destPath: string,
+  pageUrlInput: string,
+  settings: Settings
+): string {
+  const regex = computeUrlLocaleMatcherRegex(settings);
+  const pageUrl = new URL(pageUrlInput);
+  let currentLocaleValue = settings.localization.defaultLocaleValue;
+
+  const match = pageUrl.pathname.match(regex);
+  if (match && match[0]) {
+    currentLocaleValue = match[0].replace('/', '');
+  }
+
+  const redirectUrlWithLocale = getUrlPathWithLocaleLocal(
+    destPath,
+    currentLocaleValue,
+    settings
+  );
+  
+  const callbackPath = pageUrl.pathname.replace(regex, '');
+
+  return `${redirectUrlWithLocale}?callbackUrl=${callbackPath}`;
+}
+
+describe('Redirect utility functional tests', () => {
+  const settings = loadProjectSettings();
+
+  function buildPageUrl(pathAfter: string, locale: string): string {
+    const { defaultLocaleValue, localeUrlStrategy } = settings.localization;
+    const isDefault = locale === defaultLocaleValue;
+    let prefix = '';
+    if (isDefault) {
+      prefix = localeUrlStrategy === 'show-all-locales' ? `/${locale}` : '';
+    } else {
+      prefix = `/${locale}`;
+    }
+    return `https://example.com${prefix}${pathAfter}`;
+  }
+
+  describe('getUrlPathWithLocale functional tests', () => {
+    it('should respect project localeUrlStrategy dynamically', () => {
+      const { defaultLocaleValue, locales, localeUrlStrategy } =
+        settings.localization;
+
+      const nonDefault = locales.find((l) => l.value !== defaultLocaleValue);
+
+      const resultDefault = getUrlPathWithLocaleLocal(
+        '/login',
+        defaultLocaleValue,
+        settings
+      );
+      const resultNonDefault = nonDefault
+        ? getUrlPathWithLocaleLocal('/login', nonDefault.value, settings)
+        : null;
+      const resultUndefined = getUrlPathWithLocaleLocal(
+        '/login',
+        undefined,
+        settings
+      );
+
+      if (localeUrlStrategy === 'hide-default-locale') {
+        expect(resultDefault).toBe('/login');
+        if (resultNonDefault && nonDefault) {
+          expect(resultNonDefault).toBe(`/${nonDefault.value}/login`);
+        }
+        expect(resultUndefined).toBe('/login');
+      } else if (localeUrlStrategy === 'show-all-locales') {
+        expect(resultDefault).toBe(`/${defaultLocaleValue}/login`);
+        if (resultNonDefault && nonDefault) {
+          expect(resultNonDefault).toBe(`/${nonDefault.value}/login`);
+        }
+        expect(resultUndefined).toBe(`/${defaultLocaleValue}/login`);
+      } else if (localeUrlStrategy === 'hide-all-locales') {
+        expect(resultDefault).toBe('/login');
+        if (resultNonDefault) {
+          expect(resultNonDefault).toBe('/login');
+        }
+        expect(resultUndefined).toBe('/login');
+      } else if (localeUrlStrategy === 'subdomain') {
+        expect(resultDefault).toBe('/login');
+        if (resultNonDefault) {
+          expect(resultNonDefault).toBe('/login');
+        }
+        expect(resultUndefined).toBe('/login');
+      }
+    });
+  });
+
+  describe('redirect function behavior (simulated)', () => {
+    it('should redirect with correct URL for default locale (no query preserved)', () => {
+      const { defaultLocaleValue } = settings.localization;
+      const regex = computeUrlLocaleMatcherRegex(settings);
+      const url = buildPageUrl(
+        '/profile?tab=settings&view=list#frag',
+        defaultLocaleValue
+      );
+      const matched = new URL(url).pathname.match(regex)?.[0]?.replace('/', '');
+      const expectedPath = getUrlPathWithLocaleLocal(
+        '/login',
+        matched,
+        settings
+      );
+      const out = redirectMinimal('/login', url, settings);
+      expect(out).toBe(`${expectedPath}?callbackUrl=/profile`);
+    });
+
+    it('should handle non-default locale from path', () => {
+      const nonDefault = settings.localization.locales.find(
+        (l) => l.value !== settings.localization.defaultLocaleValue
+      );
+      if (!nonDefault) return;
+      const url = buildPageUrl('/products/123', nonDefault.value);
+      const regex = computeUrlLocaleMatcherRegex(settings);
+      const matched = new URL(url).pathname.match(regex)?.[0]?.replace('/', '');
+      const expectedPath = getUrlPathWithLocaleLocal(
+        '/auth',
+        matched,
+        settings
+      );
+      const out = redirectMinimal('/auth', url, settings);
+      expect(out).toBe(`${expectedPath}?callbackUrl=/products/123`);
+    });
+
+    it('should use env fallback when header missing (no query preserved)', () => {
+      const { defaultLocaleValue } = settings.localization;
+      const url = buildPageUrl('/some/path?x=1#y', defaultLocaleValue).replace(
+        'https://example.com',
+        'https://fallback.com'
+      );
+      const regex = computeUrlLocaleMatcherRegex(settings);
+      const matched = new URL(url).pathname.match(regex)?.[0]?.replace('/', '');
+      const expectedPath = getUrlPathWithLocaleLocal(
+        '/login',
+        matched,
+        settings
+      );
+      const out = redirectMinimal('/login', url, settings);
+      expect(out).toBe(`${expectedPath}?callbackUrl=/some/path`);
+    });
+
+    it('should throw with invalid URL', () => {
+      expect(() => new URL('')).toThrow();
+    });
+
+    it('should mention RedirectType usage in implementation', () => {
+      const redirectFilePath = path.resolve(__dirname, '../utils/redirect.ts');
+      const content = fs.readFileSync(redirectFilePath, 'utf8');
+      expect(content.includes('RedirectType')).toBe(true);
+      expect(content.includes('nextRedirect(redirectUrl, type)')).toBe(true);
+      expect(content.includes('nextRedirect(redirectUrl)')).toBe(true);
+    });
+  });
+
+  describe('URL locale matcher regex behavior (simulated)', () => {
+    it('should match prefixes based on project strategy', () => {
+      const { defaultLocaleValue, locales, localeUrlStrategy } =
+        settings.localization;
+      const urlLocaleMatcherRegex = computeUrlLocaleMatcherRegex(settings);
+
+      const nonDefault = locales.find((l) => l.value !== defaultLocaleValue);
+
+      if (localeUrlStrategy === 'show-all-locales') {
+        expect(
+          urlLocaleMatcherRegex.test(`/${defaultLocaleValue}/profile`)
+        ).toBe(true);
+      } else {
+        expect(
+          urlLocaleMatcherRegex.test(`/${defaultLocaleValue}/profile`)
+        ).toBe(false);
+      }
+
+      if (nonDefault) {
+        expect(urlLocaleMatcherRegex.test(`/${nonDefault.value}/profile`)).toBe(
+          true
+        );
+      }
+      expect(urlLocaleMatcherRegex.test('/profile')).toBe(false);
+    });
+  });
+
+  it('should verify redirect utility file exists and has expected structure', () => {
+    const redirectFilePath = path.resolve(__dirname, '../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/api/image-proxy.ts

@@ -0,0 +1,75 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+async function proxyImage(imageUrl: string) {
+  if (!imageUrl) {
+    return NextResponse.json(
+      { success: false, error: 'Missing url parameter' },
+      { status: 400 }
+    );
+  }
+
+  const imageResponse = await fetch(imageUrl);
+
+  if (!imageResponse.ok) {
+    return NextResponse.json(
+      { success: false, error: 'Failed to fetch image from URL' },
+      { status: 400 }
+    );
+  }
+
+  const imageBuffer = await imageResponse.arrayBuffer();
+  const base64Image = Buffer.from(imageBuffer).toString('base64');
+  const contentType = imageResponse.headers.get('content-type') || 'image/jpeg';
+
+  return { base64Image, contentType, imageBuffer };
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const imageUrl = searchParams.get('url');
+
+    const result = await proxyImage(imageUrl!);
+    if (result instanceof NextResponse) {
+      return result;
+    }
+
+    return new NextResponse(result.imageBuffer, {
+      status: 200,
+      headers: {
+        'Content-Type': result.contentType,
+        'Access-Control-Allow-Origin': '*',
+        'Cache-Control': 'public, max-age=3600'
+      }
+    });
+  } catch (error) {
+    console.error('Image proxy error:', error);
+    return NextResponse.json(
+      { success: false, error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const imageUrl = body.imageUrl;
+
+    const result = await proxyImage(imageUrl);
+    if (result instanceof NextResponse) {
+      return result;
+    }
+
+    return NextResponse.json({
+      success: true,
+      base64Image: `data:${result.contentType};base64,${result.base64Image}`
+    });
+  } catch (error) {
+    console.error('Image proxy POST error:', error);
+    return NextResponse.json(
+      { success: false, error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}

package/api/similar-product-list.ts

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { cookies } from 'next/headers';
+import Settings from 'settings';
+import { ServerVariables } from '../utils/server-variables';
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const dynamicFilter = request.headers.get('x-search-dynamic-filter');
+    const dynamicExclude = request.headers.get('x-search-dynamic-exclude');
+
+    const nextCookies = cookies();
+    const currency =
+      nextCookies.get('pz-currency')?.value || ServerVariables.currency;
+    const locale =
+      nextCookies.get('pz-locale')?.value || ServerVariables.locale;
+
+    if (!dynamicFilter && !dynamicExclude) {
+      return NextResponse.json(
+        {
+          error:
+            'Missing x-search-dynamic-filter or x-search-dynamic-exclude header'
+        },
+        { status: 400 }
+      );
+    }
+
+    if (Settings.commerceUrl === 'default') {
+      return NextResponse.json(
+        { error: 'Commerce URL is not configured' },
+        { status: 500 }
+      );
+    }
+
+    const queryString = searchParams.toString();
+    const apiUrl = `${Settings.commerceUrl}/list${
+      queryString ? `?${queryString}` : ''
+    }`;
+
+    const headers: Record<string, string> = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    };
+
+    if (dynamicFilter) {
+      headers['x-search-dynamic-filter'] = dynamicFilter;
+    } else if (dynamicExclude) {
+      headers['x-search-dynamic-exclude'] = dynamicExclude;
+    }
+
+    if (currency) {
+      headers['x-currency'] = currency;
+    }
+
+    if (locale) {
+      const currentLocale = Settings.localization.locales.find(
+        (l) => l.value === locale
+      );
+      if (currentLocale) {
+        headers['Accept-Language'] = currentLocale.apiValue;
+      }
+    }
+
+    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/api/similar-products.ts

@@ -0,0 +1,120 @@
+import { NextResponse } from 'next/server';
+import Settings from 'settings';
+
+const IMAGE_SEARCH_API_URL = Settings.commerceUrl + '/image-search/';
+
+const errorResponse = (message: string, status: number) => {
+  return NextResponse.json({ error: message }, { status });
+};
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const limit = searchParams.get('limit') || '20';
+  const url = searchParams.get('url');
+  const excludedProductIds = searchParams.get('excluded_product_ids');
+  const text = searchParams.get('text');
+
+  if (!url) {
+    return errorResponse('URL parameter is required', 400);
+  }
+
+  if (Settings.commerceUrl === 'default') {
+    return errorResponse('Commerce URL is not configured', 500);
+  }
+
+  const apiParams = new URLSearchParams();
+  apiParams.append('limit', limit);
+  apiParams.append('url', url);
+
+  if (excludedProductIds) {
+    apiParams.append('excluded_product_ids', excludedProductIds);
+  }
+
+  if (text) {
+    apiParams.append('text', text);
+  }
+
+  const apiUrl = `${IMAGE_SEARCH_API_URL}?${apiParams.toString()}`;
+
+  try {
+    const response = await fetch(apiUrl, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json'
+      }
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return errorResponse(
+        errorText || `API request failed with status: ${response.status}`,
+        response.status
+      );
+    }
+
+    const responseText = await response.text();
+
+    return NextResponse.json(JSON.parse(responseText));
+  } catch (error) {
+    return errorResponse((error as Error).message, 500);
+  }
+}
+
+export async function POST(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const limit = searchParams.get('limit') || '20';
+
+  if (Settings.commerceUrl === 'default') {
+    return errorResponse('Commerce URL is not configured', 500);
+  }
+
+  let requestBody;
+  try {
+    requestBody = await request.json();
+  } catch (error) {
+    return errorResponse('Invalid JSON in request body', 400);
+  }
+
+  if (!requestBody.image) {
+    return errorResponse('Image data is required in request body', 400);
+  }
+
+  const apiParams = new URLSearchParams();
+  apiParams.append('limit', limit);
+
+  const apiUrl = `${IMAGE_SEARCH_API_URL}?${apiParams.toString()}`;
+
+  const bodyData: any = { image: requestBody.image };
+
+  if (requestBody.excluded_product_ids) {
+    bodyData.excluded_product_ids = requestBody.excluded_product_ids;
+  }
+
+  if (requestBody.text) {
+    bodyData.text = requestBody.text;
+  }
+
+  try {
+    const response = await fetch(apiUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      body: JSON.stringify(bodyData)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return errorResponse(
+        errorText || `API request failed with status: ${response.status}`,
+        response.status
+      );
+    }
+
+    const responseData = await response.json();
+    return NextResponse.json(responseData);
+  } catch (error) {
+    return errorResponse((error as Error).message, 500);
+  }
+}

package/bin/pz-prebuild.js

@@ -2,6 +2,7 @@
 
 const runScript = require('./run-script');
 
+runScript('pz-run-tests.js');
 runScript('pz-install-theme.js');
 runScript('pz-pre-check-dist.js');
 runScript('pz-generate-translations.js');

package/components/input.tsx

@@ -1,6 +1,8 @@
 import clsx from 'clsx';
 import { forwardRef, FocusEvent, useState, Ref } from 'react';
 import { Controller } from 'react-hook-form';
+
+// @ts-ignore
 import { PatternFormat, PatternFormatProps } from 'react-number-format';
 import { InputProps } from '../types';
 import { twMerge } from 'tailwind-merge';

package/components/link.tsx

@@ -10,7 +10,9 @@ type LinkProps = Omit<
   React.AnchorHTMLAttributes<HTMLAnchorElement>,
   keyof NextLinkProps
 > &
-  NextLinkProps;
+  NextLinkProps & {
+    href: string;
+  };
 
 export const Link = ({ children, href, ...rest }: LinkProps) => {
   const { locale, defaultLocaleValue, localeUrlStrategy } = useLocalization();
@@ -26,19 +28,21 @@ export const Link = ({ children, href, ...rest }: LinkProps) => {
       return href;
     }
 
-    const pathnameWithoutLocale = href.replace(urlLocaleMatcherRegex, '');
-    const hrefWithLocale = `/${locale}${pathnameWithoutLocale}`;
-
-    if (localeUrlStrategy === LocaleUrlStrategy.ShowAllLocales) {
-      return hrefWithLocale;
-    } else if (
-      localeUrlStrategy === LocaleUrlStrategy.HideDefaultLocale &&
-      locale !== defaultLocaleValue
-    ) {
-      return hrefWithLocale;
+    if (typeof href === 'string' && !href.startsWith('http')) {
+      const pathnameWithoutLocale = href.replace(urlLocaleMatcherRegex, '');
+      const hrefWithLocale = `/${locale}${pathnameWithoutLocale}`;
+
+      if (localeUrlStrategy === LocaleUrlStrategy.ShowAllLocales) {
+        return hrefWithLocale;
+      } else if (
+        localeUrlStrategy === LocaleUrlStrategy.HideDefaultLocale &&
+        locale !== defaultLocaleValue
+      ) {
+        return hrefWithLocale;
+      }
     }
 
-    return href || '#';
+    return href;
   }, [href, defaultLocaleValue, locale, localeUrlStrategy]);
 
   return (

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;