@akinon/next 1.100.0-rc.72 → 1.100.0

package/types/index.ts

@@ -83,12 +83,6 @@ export interface Settings {
   };
   usePrettyUrlRoute?: boolean;
   commerceUrl: string;
-  /**
-   * This option allows you to track Sentry events on the client side, in addition to server and edge environments.
-   *
-   * It overrides process.env.NEXT_PUBLIC_SENTRY_DSN and process.env.SENTRY_DSN.
-   */
-  sentryDsn?: string;
   redis: {
     defaultExpirationTime: number;
   };
@@ -298,13 +292,7 @@ export interface ButtonProps
   target?: '_blank' | '_self' | '_parent' | '_top';
 }
 
-export interface FileInputProps extends React.HTMLProps<HTMLInputElement> {
-  fileClassName?: string;
-  fileNameWrapperClassName?: string;
-  fileInputClassName?: string;
-  onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
-  buttonClassName?: string;
-}
+export type FileInputProps = React.HTMLProps<HTMLInputElement>;
 
 export interface PriceProps {
   currencyCode?: string;
@@ -325,19 +313,15 @@ export interface InputProps extends React.HTMLProps<HTMLInputElement> {
 
 export interface AccordionProps {
   isCollapse?: boolean;
-  collapseClassName?: string;
   title?: string;
   subTitle?: string;
   icons?: string[];
   iconSize?: number;
   iconColor?: string;
   children?: ReactNode;
-  headerClassName?: string;
   className?: string;
   titleClassName?: string;
-  subTitleClassName?: string;
   dataTestId?: string;
-  contentClassName?: string;
 }
 
 export interface PluginModuleComponentProps {
@@ -362,20 +346,3 @@ export interface PaginationProps {
   direction?: 'next' | 'prev';
   isLoading?: boolean;
 }
-
-export interface ModalProps {
-  portalId: string;
-  children?: React.ReactNode;
-  open?: boolean;
-  setOpen?: (open: boolean) => void;
-  title?: React.ReactNode;
-  showCloseButton?: React.ReactNode;
-  className?: string;
-  overlayClassName?: string;
-  headerWrapperClassName?: string;
-  titleClassName?: string;
-  closeButtonClassName?: string;
-  iconName?: string;
-  iconSize?: number;
-  iconClassName?: string;
-}

package/utils/app-fetch.ts

@@ -43,12 +43,12 @@ const appFetch = async <T>({
     const requestURL = `${decodeURIComponent(commerceUrl)}${url}`;
 
     init.headers = {
-      cookie: nextCookies.toString(),
       ...(init.headers ?? {}),
       ...(ServerVariables.globalHeaders ?? {}),
       'Accept-Language': currentLocale.apiValue,
       'x-currency': currency,
-      'x-forwarded-for': ip
+      'x-forwarded-for': ip,
+      cookie: nextCookies.toString()
     };
 
     init.next = {
@@ -60,11 +60,6 @@ const appFetch = async <T>({
     status = req.status;
     logger.debug(`FETCH END ${url}`, { status: req.status, ip });
 
-    if (!req.ok) {
-      const errorMessage = `HTTP ${req.status}: ${req.statusText}`;
-      throw new Error(errorMessage);
-    }
-
     if (responseType === FetchResponseType.JSON) {
       response = (await req.json()) as T;
     } else {

package/utils/override-middleware.ts

@@ -10,6 +10,7 @@ export enum MiddlewareNames {
   DataSourceShippingOptionMiddleware = 'dataSourceShippingOptionMiddleware',
   AttributeBasedShippingOptionMiddleware = 'attributeBasedShippingOptionMiddleware',
   PaymentOptionMiddleware = 'paymentOptionMiddleware',
+  PaymentOptionResetMiddleware = 'paymentOptionResetMiddleware',
   InstallmentOptionMiddleware = 'installmentOptionMiddleware',
   ShippingStepMiddleware = 'shippingStepMiddleware'
 }

package/utils/redirect.ts

@@ -1,39 +1,20 @@
 import { redirect as nextRedirect, RedirectType } from 'next/navigation';
 import Settings from 'settings';
-import { headers, cookies } from 'next/headers';
+import { headers } from 'next/headers';
+import { ServerVariables } from '@akinon/next/utils/server-variables';
 import { getUrlPathWithLocale } from '@akinon/next/utils/localization';
 import { urlLocaleMatcherRegex } from '@akinon/next/utils';
 
 export const redirect = (path: string, type?: RedirectType) => {
   const nextHeaders = headers();
-  const nextCookies = cookies();
   const pageUrl = new URL(
     nextHeaders.get('pz-url') ?? process.env.NEXT_PUBLIC_URL ?? ''
   );
 
-  let currentLocaleValue = Settings.localization.defaultLocaleValue;
-  const urlLocaleMatch = pageUrl.pathname.match(urlLocaleMatcherRegex);
-
-  if (urlLocaleMatch && urlLocaleMatch[0]) {
-    currentLocaleValue = urlLocaleMatch[0].replace('/', '');
-  } else {
-    const cookieLocale = nextCookies.get('pz-locale')?.value;
-    if (
-      cookieLocale &&
-      Settings.localization.locales.find((l) => l.value === cookieLocale)
-    ) {
-      currentLocaleValue = cookieLocale;
-    }
-  }
-
   const currentLocale = Settings.localization.locales.find(
-    (locale) => locale.value === currentLocaleValue
+    (locale) => locale.value === ServerVariables.locale
   );
 
-  if (!currentLocale) {
-    currentLocaleValue = Settings.localization.defaultLocaleValue;
-  }
-
   const searchParams = new URLSearchParams(pageUrl.search);
 
   const callbackUrl =

package/with-pz-config.js

@@ -16,8 +16,12 @@ const defaultConfig = {
     remotePatterns: [
       {
         protocol: 'https',
-        hostname: '**'
+        hostname: '**.akinoncloud.com'
       },
+      {
+        protocol: 'https',
+        hostname: '**.akinoncdn.com'
+      }
     ]
   },
   modularizeImports: {

package/__tests__/redirect.test.ts

@@ -1,319 +0,0 @@
-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/form.ts

@@ -1,84 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { getFormData } from '@akinon/next/data/server';
-
-interface FormRouteParams {
-  params: {
-    id: string[];
-  };
-}
-
-interface FormConfig {
-  pk: number;
-  is_active: boolean;
-}
-
-type SubmissionData = Record<string, string | File>;
-
-export async function POST(request: NextRequest, { params }: FormRouteParams) {
-  try {
-    const formId = params.id?.[0];
-
-    if (!formId || isNaN(Number(formId))) {
-      return NextResponse.json(
-        { error: 'Valid form ID is required' },
-        { status: 400 }
-      );
-    }
-
-    const formConfig: FormConfig | null = await getFormData({
-      pk: Number(formId)
-    });
-
-    if (!formConfig || !formConfig.is_active) {
-      return NextResponse.json(
-        { error: 'Form not found or inactive' },
-        { status: 404 }
-      );
-    }
-
-    const formData = await request.formData();
-    const submissionData: SubmissionData = Object.fromEntries(
-      formData.entries()
-    );
-
-    return await processFormSubmission(formConfig, submissionData);
-  } catch (error) {
-    console.error('Form submission error:', error);
-
-    return NextResponse.json(
-      { error: 'Internal server error' },
-      { status: 500 }
-    );
-  }
-}
-
-async function processFormSubmission(
-  formConfig: FormConfig,
-  data: SubmissionData
-) {
-  const backendUrl = process.env.SERVICE_BACKEND_URL;
-  if (!backendUrl) {
-    throw new Error('SERVICE_BACKEND_URL is not defined');
-  }
-
-  const url = `${backendUrl}/forms/${formConfig.pk}/generate`;
-
-  const submissionPayload = {
-    ...data
-  };
-
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(submissionPayload)
-  });
-
-  const body = await response.text();
-
-  return new NextResponse(body, {
-    status: response.status,
-    headers: {
-      'Content-Type': response.headers.get('content-type') ?? 'application/json'
-    }
-  });
-}

package/api/image-proxy.ts

@@ -1,75 +0,0 @@
-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 }
-    );
-  }
-}