@akinon/next 1.108.0-rc.87 → 1.108.0-rc.9

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/data/server/basket.ts

@@ -1,72 +0,0 @@
-import { Cache, CacheKey } from '../../lib/cache';
-import { basket } from '../../data/urls';
-import { Basket } from '../../types';
-import appFetch from '../../utils/app-fetch';
-import { ServerVariables } from '../../utils/server-variables';
-import logger from '../../utils/log';
-
-type GetBasketParams = {
-  locale?: string;
-  currency?: string;
-  namespace?: string;
-};
-
-const getBasketDataHandler = ({
-  locale,
-  currency,
-  namespace
-}: GetBasketParams) => {
-  return async function () {
-    try {
-      const url = namespace
-        ? basket.getBasketDetail(namespace)
-        : basket.getBasket;
-
-      const basketData = await appFetch<{ basket: Basket }>({
-        url,
-        locale,
-        currency,
-        init: {
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json'
-          }
-        }
-      });
-
-      if (!basketData?.basket) {
-        logger.warn('Basket data is undefined', {
-          handler: 'getBasketDataHandler',
-          namespace
-        });
-      }
-
-      return basketData;
-    } catch (error) {
-      logger.error('Error fetching basket data', {
-        handler: 'getBasketDataHandler',
-        error,
-        namespace
-      });
-      throw error;
-    }
-  };
-};
-
-export const getBasketData = async ({
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency,
-  namespace
-}: GetBasketParams = {}) => {
-  return Cache.wrap(
-    CacheKey.Basket(namespace),
-    locale,
-    getBasketDataHandler({ locale, currency, namespace }),
-    {
-      expire: 0,
-      cache: false
-    }
-  );
-};
-
-