@websolutespa/bom-next 3.0.0

package/src/mock.ts

@@ -0,0 +1,264 @@
+import type { TypedLocale } from 'payload';
+
+type Simplify<T> = { [Key in keyof T]: T[Key] } & {};
+
+type RequiredKeys<T> = {
+  [Key in keyof T]-?: Pick<T, Key> extends Required<Pick<T, Key>> ? Key : never;
+}[keyof T];
+
+type PayloadSchema = {
+  collections: object;
+  globals?: object;
+};
+
+type MockLocale = Extract<TypedLocale, string>;
+
+type SystemField =
+  | 'apiKeyIndex'
+  | 'createdAt'
+  | 'hash'
+  | 'lockUntil'
+  | 'loginAttempts'
+  | 'resetPasswordExpiration'
+  | 'resetPasswordToken'
+  | 'salt'
+  | 'sessions'
+  | 'updatedAt'
+  | '_status';
+
+type LocalizedField =
+  | 'abstract'
+  | 'alt'
+  | 'description'
+  | 'extra'
+  | 'keywords'
+  | 'name'
+  | 'robots'
+  | 'slug'
+  | 'text'
+  | 'title';
+
+type LexicalState = {
+  root: {
+    children: unknown[];
+    type: string;
+  };
+};
+
+type MockValue<T, Locale extends string, AdditionalLocalizedFields extends PropertyKey> =
+  T extends readonly (infer Item)[]
+  ? MockValue<Item, Locale, AdditionalLocalizedFields>[]
+  : T extends LexicalState
+  ? T | string
+  : T extends object
+  ? MockObject<T, Locale, AdditionalLocalizedFields>
+  : T;
+
+type LocalizedMockValue<T, Locale extends string, AdditionalLocalizedFields extends PropertyKey> =
+  MockValue<T, Locale, AdditionalLocalizedFields>
+  | Partial<Record<Locale, MockValue<T, Locale, AdditionalLocalizedFields>>>;
+
+type MockProperty<
+  Key extends PropertyKey,
+  Value,
+  Locale extends string,
+  AdditionalLocalizedFields extends PropertyKey,
+> = Key extends LocalizedField | AdditionalLocalizedFields
+  ? LocalizedMockValue<Value, Locale, AdditionalLocalizedFields>
+  : Key extends 'media'
+  ? IMockMedia<Locale> | MockValue<Value, Locale, AdditionalLocalizedFields>
+  : MockValue<Value, Locale, AdditionalLocalizedFields>;
+
+type MockObject<T extends object, Locale extends string, AdditionalLocalizedFields extends PropertyKey> = Simplify<
+  {
+    [Key in Exclude<keyof T, RequiredKeys<T> | SystemField>]?: MockProperty<
+      Key,
+      T[Key],
+      Locale,
+      AdditionalLocalizedFields
+    >;
+  } & {
+    [Key in Exclude<RequiredKeys<T>, SystemField>]?: MockProperty<
+      Key,
+      T[Key],
+      Locale,
+      AdditionalLocalizedFields
+    >;
+  }
+>;
+
+/** A locale map accepted by localized Payload fields during seeding. */
+export type IMockLocalized<T = string, Locale extends string = MockLocale> = Partial<Record<Locale, T>>;
+
+/** Compact upload input accepted by the seed plugin before it creates a Media document. */
+export type IMockMedia<Locale extends string = MockLocale> = {
+  alt?: string | IMockLocalized<string, Locale>;
+  id?: string | number;
+  src: string;
+  type?: string;
+};
+
+/**
+ * Seed input derived from a Payload document type.
+ *
+ * Database-managed fields are omitted, document fields are optional to support
+ * `$inherit`, and conventional localized field names also accept locale maps.
+ */
+export type IMockDocument<
+  Document extends object = Record<string, unknown>,
+  Locale extends string = MockLocale,
+  AdditionalLocalizedFields extends PropertyKey = never,
+> = Simplify<
+  MockObject<Document, Locale, AdditionalLocalizedFields> & {
+    $inherit?: boolean | readonly (Extract<keyof Document, string>)[];
+    id?: string | number;
+  }
+>;
+
+/** Seed input for an arbitrary Payload collection. */
+export type IMockCollection<
+  Document extends object = Record<string, unknown>,
+  Locale extends string = MockLocale,
+  AdditionalLocalizedFields extends PropertyKey = never,
+> = IMockDocument<Document, Locale, AdditionalLocalizedFields>;
+
+/** Seed input for a Payload global. */
+export type IMockGlobal<
+  Global extends object = Record<string, unknown>,
+  Locale extends string = MockLocale,
+  AdditionalLocalizedFields extends PropertyKey = never,
+> = IMockDocument<Global, Locale, AdditionalLocalizedFields>;
+
+/**
+ * Seed input for a page collection. It has the same generic seed semantics as
+ * a collection document; page-specific fields remain inferred from the
+ * project's generated Payload type.
+ */
+export type IMockPage<
+  Document extends object = Record<string, unknown>,
+  Locale extends string = MockLocale,
+  AdditionalLocalizedFields extends PropertyKey = never,
+> = IMockDocument<Document, Locale, AdditionalLocalizedFields>;
+
+type DefaultMenuItem = {
+  abstract?: string;
+  category?: string;
+  customClass?: string;
+  customTitle?: string;
+  extra?: string;
+  href?: string;
+  items?: DefaultMenuItem[];
+  markets?: string[];
+  maxDepth?: number;
+  page?: { relationTo: string; value: string | number };
+  strategy?: string;
+  target?: string;
+  title?: string;
+  type?: 'page' | 'category' | 'link' | 'group';
+};
+
+type DefaultMenuDocument = {
+  id?: string | number;
+  items?: DefaultMenuItem[] | null;
+  markets?: string[];
+};
+
+type MenuDocument = {
+  items?: readonly object[] | null;
+};
+
+type MenuItem<Document extends MenuDocument> = NonNullable<NonNullable<Document['items']>[number]>;
+
+type MockMenuField<
+  Item extends object,
+  Key extends keyof Item,
+  Locale extends string,
+  AdditionalLocalizedFields extends PropertyKey,
+> = MockProperty<Key, Item[Key], Locale, AdditionalLocalizedFields>;
+
+type MockMenuItemBase<
+  Item extends object,
+  Locale extends string,
+  AdditionalLocalizedFields extends PropertyKey,
+> = Omit<MockObject<Item, Locale, AdditionalLocalizedFields>, 'blockName' | 'blockType' | 'category' | 'href' | 'items' | 'page' | 'title' | 'type'>;
+
+/** A recursive author-facing menu item; seed setup adds Payload block metadata. */
+export type IMockMenuItem<
+  Document extends MenuDocument = DefaultMenuDocument,
+  Locale extends string = MockLocale,
+  AdditionalLocalizedFields extends PropertyKey = never,
+  Item extends object = MenuItem<Document>,
+> =
+  | (MockMenuItemBase<Item, Locale, AdditionalLocalizedFields> & {
+    category: NonNullable<MockMenuField<Item, Extract<'category', keyof Item>, Locale, AdditionalLocalizedFields>>;
+    type: 'category';
+  })
+  | (MockMenuItemBase<Item, Locale, AdditionalLocalizedFields> & {
+    page: NonNullable<MockMenuField<Item, Extract<'page', keyof Item>, Locale, AdditionalLocalizedFields>>;
+    type: 'page';
+  })
+  | (MockMenuItemBase<Item, Locale, AdditionalLocalizedFields> & {
+    href: NonNullable<MockMenuField<Item, Extract<'href', keyof Item>, Locale, AdditionalLocalizedFields>>;
+    title: NonNullable<MockMenuField<Item, Extract<'title', keyof Item>, Locale, AdditionalLocalizedFields>>;
+    type: 'link';
+  })
+  | (MockMenuItemBase<Item, Locale, AdditionalLocalizedFields> & {
+    items: IMockMenuItem<Document, Locale, AdditionalLocalizedFields>[];
+    title?: MockMenuField<Item, Extract<'title', keyof Item>, Locale, AdditionalLocalizedFields>;
+    type: 'group';
+  });
+
+/**
+ * Seed input for a recursive Payload menu collection.
+ *
+ * Its items intentionally omit generated `Level N` block metadata because
+ * seed registration assigns it from the nesting level before persistence.
+ */
+export type IMockMenu<
+  Document extends MenuDocument = DefaultMenuDocument,
+  Locale extends string = MockLocale,
+  AdditionalLocalizedFields extends PropertyKey = never,
+> = Simplify<
+  Omit<IMockDocument<Document, Locale, AdditionalLocalizedFields>, 'items'> & {
+    items: IMockMenuItem<Document, Locale, AdditionalLocalizedFields>[];
+  }
+>;
+
+/** Legacy locale seed record for projects that manage locales outside generated Payload collections. */
+export type IMockLocale<Locale extends string = MockLocale> = {
+  id: Locale;
+  isDefault?: boolean;
+  isHidden?: boolean;
+  title: string | IMockLocalized<string, Locale>;
+};
+
+type CollectionSlug<Schema extends PayloadSchema> = Extract<keyof Schema['collections'], string>;
+type CollectionDocument<Schema extends PayloadSchema, Slug extends CollectionSlug<Schema>> = Schema['collections'][Slug] extends object
+  ? Schema['collections'][Slug]
+  : never;
+
+type MockCollections<
+  Schema extends PayloadSchema,
+  PageSlug extends CollectionSlug<Schema>,
+  Locale extends string,
+  AdditionalCollections extends Record<string, object>,
+> = {
+  [Slug in Exclude<CollectionSlug<Schema>, PageSlug>]?: IMockCollection<CollectionDocument<Schema, Slug>, Locale>[];
+} & {
+    [Slug in keyof AdditionalCollections]?: IMockCollection<AdditionalCollections[Slug], Locale>[];
+  };
+
+type MockPages<Schema extends PayloadSchema, PageSlug extends CollectionSlug<Schema>, Locale extends string> = {
+  [Slug in PageSlug]?: IMockPage<CollectionDocument<Schema, Slug>, Locale>[];
+};
+
+/** A typed collection/page store for the memory-store and Payload seed inputs. */
+export type IMockStore<
+  Schema extends PayloadSchema = { collections: Record<string, Record<string, unknown>> },
+  PageSlug extends CollectionSlug<Schema> = never,
+  AdditionalCollections extends Record<string, object> = Record<never, never>,
+  Locale extends string = MockLocale,
+> = {
+  collections: MockCollections<Schema, PageSlug, Locale, AdditionalCollections>;
+  pages: MockPages<Schema, PageSlug, Locale>;
+};

package/src/proxy/protected-route.test.ts

@@ -0,0 +1,75 @@
+// @vitest-environment node
+
+import { IRoute } from '@websolutespa/bom-core';
+import { NextRequest } from 'next/server';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { describe, expect, test, vi } from 'vitest';
+import { localApiGet } from '../lib/http';
+import { protectedRouteProxy } from './protected-route';
+
+vi.mock('../lib/http', () => ({
+  localApiGet: vi.fn(),
+}));
+
+describe('protectedRouteProxy Edge boundary', () => {
+  test('does not import or initialize Payload in middleware', () => {
+    for (const fileName of ['protected-route.ts', 'proxy.ts', 'route-proxy.ts']) {
+      const source = readFileSync(path.join(import.meta.dirname, fileName), 'utf8');
+
+      expect(source).not.toContain('from \'../server/mixer\'');
+      expect(source).not.toContain('getPayload(');
+      expect(source).not.toContain('from \'next/headers\'');
+      expect(source).not.toMatch(/^import\s+\{[^}]+\}\s+from\s+['"]payload['"]/m);
+    }
+  });
+});
+
+describe('protectedRouteProxy', () => {
+  test('redirects unauthenticated protected requests to a safe public fallback', async () => {
+    const request = new NextRequest('https://app.example.test/members');
+    const route: IRoute = {
+      category: 'members',
+      id: '/members',
+      isProtected: true,
+      locale: 'en',
+      market: 'ww',
+      page: 'members',
+      publicRedirect: '/sign-in',
+      resolvedCategory: 'members',
+      schema: 'page',
+      title: 'Members',
+    };
+
+    const response = await protectedRouteProxy({ request, next: {} as never, route });
+
+    expect(response?.status).toBe(307);
+    expect(response?.headers.get('location')).toBe('https://app.example.test/sign-in');
+  });
+  test('falls back to the login resolver for an unsafe public fallback', async () => {
+    const request = new NextRequest('https://app.example.test/members');
+    const route: IRoute = {
+      category: 'members',
+      id: '/members',
+      isProtected: true,
+      locale: 'en',
+      market: 'ww',
+      page: 'members',
+      publicRedirect: '//untrusted.example.test/sign-in',
+      resolvedCategory: 'members',
+      schema: 'page',
+      title: 'Members',
+    };
+
+    vi.mocked(localApiGet).mockResolvedValueOnce(undefined);
+    const response = await protectedRouteProxy({ request, next: {} as never, route });
+
+    expect(response).toBeUndefined();
+    expect(localApiGet).toHaveBeenCalledWith(
+      '/-route?schema=login&market=ww&locale=en',
+      {},
+      undefined,
+      'https://app.example.test'
+    );
+  });
+});

package/src/proxy/protected-route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from 'next/server';
+import { localApiGet } from '../lib/http';
+import { getNextUrl } from '../server/utils';
+import { getRequestOrigin } from './proxy';
+import type { RouteMiddleware, RouteMiddlewareOptions, RouteResolverResponse } from './route-proxy';
+
+function getPublicRedirectUrl(request: RouteMiddlewareOptions['request'], href: string): URL | undefined {
+  if (!href.startsWith('/') || href.startsWith('//')) {
+    return undefined;
+  }
+  const url = new URL(href, getRequestOrigin(request));
+  return url.pathname === request.nextUrl.pathname ? undefined : url;
+}
+
+export const protectedRouteProxy: RouteMiddleware = async ({ request, route }: RouteMiddlewareOptions) => {
+  // console.log('protectedRouteProxy', 'token', token);
+  if (route.isProtected) {
+    const token = request.cookies.get('payload-token');
+    const isAuthenticated = token; // await hasValidSession();
+    console.log('protectedRouteProxy.isAuthenticated', isAuthenticated);
+    if (!isAuthenticated) {
+      if (route.publicRedirect) {
+        const redirectUrl = getPublicRedirectUrl(request, route.publicRedirect);
+        if (redirectUrl) {
+          return NextResponse.redirect(redirectUrl);
+        }
+      }
+      const url = request.nextUrl;
+      const { pathname } = url;
+      const reqHeaders = new Headers(request.headers);
+      reqHeaders.set('x-pathname', pathname);
+      const resolution = await localApiGet<RouteResolverResponse>(
+        `/-route?schema=login&market=${encodeURIComponent(route.market)}&locale=${encodeURIComponent(route.locale)}`,
+        {},
+        undefined,
+        getRequestOrigin(request)
+      );
+      const nextRoute = resolution?.route;
+      if (nextRoute) {
+        const nextUrl = getNextUrl(request, nextRoute);
+        reqHeaders.set('x-market', nextRoute.market);
+        reqHeaders.set('x-locale', nextRoute.locale);
+        reqHeaders.set('x-schema', nextRoute.schema);
+        reqHeaders.set('x-id', String(nextRoute.page));
+        reqHeaders.set('x-forwarded-pathname', nextUrl.pathname);
+        console.log('protectedRouteProxy.Protected', pathname, '>', nextUrl.pathname);
+        const response = NextResponse
+          .rewrite(nextUrl, {
+            request: {
+              headers: reqHeaders,
+            },
+          });
+        return response;
+      }
+    }
+  }
+};

package/src/proxy/proxy.test.ts

@@ -0,0 +1,48 @@
+// @vitest-environment node
+
+import { NextRequest } from 'next/server';
+import { describe, expect, test } from 'vitest';
+import { getRequestOrigin } from './proxy';
+
+describe('getRequestOrigin', () => {
+    test('uses Vercel forwarded host and protocol', () => {
+        const request = new NextRequest('https://bom-next-79lpg3gby-luca-zampettis-projects.vercel.app/', {
+            headers: {
+                'x-forwarded-host': 'bom-next-tau.vercel.app',
+                'x-forwarded-port': '443',
+                'x-forwarded-proto': 'https',
+            },
+        });
+
+        expect(getRequestOrigin(request)).toBe('https://bom-next-tau.vercel.app');
+    });
+
+    test('uses a non-default port supplied by a reverse proxy', () => {
+        const request = new NextRequest('http://internal-app:3000/', {
+            headers: {
+                'x-forwarded-host': 'app.example.com',
+                'x-forwarded-port': '8443',
+                'x-forwarded-proto': 'https',
+            },
+        });
+
+        expect(getRequestOrigin(request)).toBe('https://app.example.com:8443');
+    });
+
+    test('uses the direct request origin without forwarded headers', () => {
+        const request = new NextRequest('http://localhost:3000/');
+
+        expect(getRequestOrigin(request)).toBe('http://localhost:3000');
+    });
+
+    test('falls back to the direct request origin when forwarded protocol is invalid', () => {
+        const request = new NextRequest('https://app.example.com/', {
+            headers: {
+                'x-forwarded-host': 'untrusted.example.com',
+                'x-forwarded-proto': 'ftp',
+            },
+        });
+
+        expect(getRequestOrigin(request)).toBe('https://app.example.com');
+    });
+});

package/src/proxy/proxy.ts

@@ -0,0 +1,64 @@
+import { NextMiddlewareResult } from 'next/dist/server/web/types';
+import { NextFetchEvent, NextRequest, NextResponse } from 'next/server';
+
+// export type Middleware = (request: NextRequest, next: NextFetchEvent) => Promise<NextMiddlewareResult>;
+
+export type MiddlewareOptions = {
+  request: NextRequest,
+  next: NextFetchEvent,
+  disabled?: boolean,
+};
+export type Middleware = (props: MiddlewareOptions) => NextMiddlewareResult | Promise<NextMiddlewareResult>;
+
+/**
+ * Returns the externally visible origin for an internal middleware request.
+ *
+ * Deployments commonly terminate TLS or change ports before forwarding to
+ * Next.js. Honoring valid forwarded headers keeps resolver requests on the
+ * public host and prevents an avoidable proxy redirect; direct-origin fallback
+ * keeps local development and untrusted/invalid header values deterministic.
+ */
+export function getRequestOrigin(request: NextRequest): string {
+  const forwardedHost = request.headers.get('x-forwarded-host')?.split(',')[0]?.trim();
+  const forwardedProtocol = request.headers.get('x-forwarded-proto')?.split(',')[0]?.trim();
+  const forwardedPort = request.headers.get('x-forwarded-port')?.split(',')[0]?.trim();
+
+  if (!forwardedHost || !['http', 'https'].includes(forwardedProtocol || '')) {
+    return request.nextUrl.origin;
+  }
+
+  const protocol = forwardedProtocol!;
+  const defaultPort = protocol === 'https' ? '443' : '80';
+  const includesPort = forwardedHost.startsWith('[') ? forwardedHost.includes(']:') : forwardedHost.includes(':');
+  const authority = forwardedPort && forwardedPort !== defaultPort && !includesPort ? `${forwardedHost}:${forwardedPort}` : forwardedHost;
+
+  return `${protocol}://${authority}`;
+}
+
+/**
+ * Composes middleware into an ordered, short-circuiting proxy pipeline.
+ *
+ * A disabled proxy returns immediately, avoiding all downstream request work.
+ * Otherwise each middleware can claim the response; stopping at its first
+ * result prevents duplicate rewrites, redirects, and expensive policy checks.
+ */
+export function createProxy(...proxies: Middleware[]): Middleware {
+  return async function ({ request, next, disabled }: MiddlewareOptions) {
+    if (disabled) {
+      return NextResponse.next();
+    }
+    let proxyResponse, i = 0;
+    while (i < proxies.length && !proxyResponse) {
+      const proxy = proxies[i] as Middleware;
+      // console.log('createProxy.proxies', proxies.length, typeof proxy === 'function');
+      if (typeof proxy === 'function') {
+        proxyResponse = await proxy({ request, next });
+        if (proxyResponse) {
+          return proxyResponse;
+        }
+      }
+      i++;
+    }
+    return NextResponse.next();
+  };
+}

package/src/proxy/route-auto-detection.ts

@@ -0,0 +1,126 @@
+'use server';
+
+import { asEquatable, defaultLocale, defaultMarket, IMarket, IRoute } from '@websolutespa/bom-core';
+import { NextRequest, NextResponse } from 'next/server';
+import { localApiGet } from '../lib/http';
+import { getRequestOrigin, Middleware, MiddlewareOptions } from './proxy';
+
+export async function detectLocale(request: NextRequest, defaultLocale?: string) {
+  const acceptLanguage = request.headers.get('accept-language')?.split(',')[0];
+  const detectedLocale = request.cookies.get('NEXT_LOCALE')?.value || acceptLanguage || defaultLocale || process.env.DEFAULT_LOCALE;
+  return detectedLocale as string;
+}
+
+export async function detectCountry(request: NextRequest, defaultMarket?: string) {
+  let ip = request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip');
+  if (ip) {
+    ip = ip.split(',')[0];
+  }
+  const isValidIp = ip?.match(/^(\d+?)\.(\d+?)\.(\d+?)\.(\d+?)$/);
+  let detectedCountry = '';
+  try {
+    const token = process.env.IPINFO_TOKEN;
+    if (token) {
+      const url = isValidIp ?
+        `https://api.ipinfo.io/lite/${ip}/country_code?token=${token}` :
+        `https://api.ipinfo.io/lite/me/country_code?token=${token}`;
+      const response = await fetch(url);
+      if (response.ok) {
+        const data = await response.text();
+        detectedCountry = data.toLowerCase();
+      }
+    } else {
+      const url = `https://geoip.websolute.it/Ip2Location/get_info.aspx?ipaddress=${isValidIp ? ip : ''}`;
+      const response = await fetch(url);
+      if (response.ok) {
+        const xml = await response.text();
+        detectedCountry = (
+          ((xml.split('<CountryCode><![CDATA[')[1] || '').split(']]></CountryCode>')[0] || '')
+        ).replace('-', '').toLowerCase();
+        // console.log('detectedCountry', detectedCountry);
+      }
+    }
+    // console.log('routeInterceptor.detectCountry', detectedCountry);
+    return detectedCountry || defaultMarket || process.env.DEFAULT_MARKET;
+  } catch (error) {
+    console.log('routeInterceptor.detectCountry.error', error);
+  }
+  return (defaultMarket || process.env.DEFAULT_MARKET) as string;
+}
+
+export const routeAutoDetection: Middleware = async ({ request }: MiddlewareOptions) => {
+  let redirectUrl: string | undefined = undefined;
+  const url = request.nextUrl;
+  const origin = getRequestOrigin(request);
+  if (url.pathname === '/') {
+    const cookie = request.cookies.get('detectedRoute');
+    if (cookie?.value) {
+      redirectUrl = cookie.value;
+    }
+    // console.log('routeInterceptor.routeAutoDetection', url.pathname);
+    const rootRoutes: IRoute[] = await localApiGet('/-route?where[isRoot][equals]=true', {}, undefined, origin);
+    // console.log('routeInterceptor.routeAutoDetection.rootRoutes', rootRoutes);
+    const defaultRoute = rootRoutes.find(x => x.id === '/');
+    // console.log('routeInterceptor.routeAutoDetection.defaultRoute', defaultRoute);
+    if (defaultRoute) {
+      return;
+    }
+    const markets: IMarket[] = await localApiGet('/market?pagination=false', {}, undefined, origin);
+    // console.log('routeInterceptor.routeAutoDetection.markets', markets);
+    const market = markets.find(x => x.isDefault) || markets.find(x => x.id === defaultMarket) || markets[0];
+    // console.log('routeInterceptor.routeAutoDetection.market', market);
+    const detectedCountry = await detectCountry(request, market.id);
+    // console.log('routeInterceptor.routeAutoDetection.detectedCountry', detectedCountry);
+    const detectedMarket = detectedCountry ? (
+      markets.filter(x => Array.isArray(x.countries)).find(x => {
+        const countries: string[] = (x.countries || []).map(x => typeof x === 'string' ? x : x.id as string);
+        return countries.includes(detectedCountry);
+      }) ||
+      markets.find(x => !Array.isArray(x.countries))
+    ) : undefined;
+    // console.log('routeInterceptor.routeAutoDetection.detectedMarket', detectedMarket);
+    let detectedMarketRoutes = rootRoutes.filter(x => x.market === detectedMarket?.id);
+    if (detectedMarketRoutes.length === 0) {
+      detectedMarketRoutes = rootRoutes.filter(x => x.market === market.id);
+    }
+    // console.log('routeInterceptor.routeAutoDetection.detectedMarketRoutes', detectedMarketRoutes);
+    const defaultMarketLocale = market.defaultLanguage ? (
+      typeof market.defaultLanguage === 'string' ? market.defaultLanguage : market.defaultLanguage.id
+    ) as string : defaultLocale;
+    // console.log('routeInterceptor.routeAutoDetection.defaultMarketLocale', defaultMarketLocale);
+    const detectedLocale = await detectLocale(request, defaultMarketLocale);
+    // console.log('routeInterceptor.routeAutoDetection.detectedLocale', detectedLocale);
+    const detectedLocaleRoutes = detectedMarketRoutes.filter(x => x.locale === detectedLocale);
+    const detectedRoute =
+      detectedLocaleRoutes.length > 0 ?
+        detectedLocaleRoutes[0]! :
+        detectedMarketRoutes.find(x => {
+          const market = markets.find(m => m.id === x.market)!;
+          const marketLocale = (market.defaultLanguage ? asEquatable(market.defaultLanguage as string) : defaultMarketLocale);
+          return x.locale === marketLocale;
+        })!;
+    // console.log('routeInterceptor.routeAutoDetection.detectedRoute', detectedRoute);
+    if (detectedRoute && detectedRoute.id !== url.pathname) {
+      console.log('routeInterceptor.routeAutoDetection', detectedLocale, detectedCountry, detectedRoute.id);
+      redirectUrl = detectedRoute.id;
+    }
+    // console.log('routeInterceptor.routeAutoDetection', locale, detectedCountry, rootRoutes);
+  }
+  if (redirectUrl) {
+    // console.log('routeInterceptor', 'redirectUrl', redirectUrl);
+    const resolvedUrl = new URL(redirectUrl, origin).href;
+    // console.log('routeInterceptor', 'resolvedUrl', resolvedUrl);
+    const search = request.nextUrl.search;
+    const response = NextResponse.redirect(resolvedUrl + search, { status: 307 });
+    response.cookies.set({
+      expires: new Date(Date.now() + 1 * 24 * 60 * 60 * 1000),
+      httpOnly: true,
+      name: 'detectedRoute',
+      path: '/',
+      sameSite: 'lax',
+      secure: true,
+      value: redirectUrl,
+    });
+    return response;
+  }
+};