@websolutespa/bom-mixer-models 2.0.2 → 3.0.1

package/src/page/page.service.ts

@@ -1,10 +1,10 @@
-import { ICategorized, ICategory, IComponent, IEquatable, ILayout, IPage, IRoute, IRouteLink, PageProps, QueryParams, SchemaType, asCategoryId, asServerProps, defaultLocale, defaultMarket } from '@websolutespa/bom-core';
-import { getStore } from '@websolutespa/bom-mixer-store';
+import { asCategoryId, asServerProps, defaultLocale, defaultMarket, ICategorized, ICategory, IComponent, IEquatable, ILayout, IPage, IRoute, IRouteLink, PageProps, QueryParams, SchemaType } from '@websolutespa/bom-core';
+import { getStore } from '@websolutespa/bom-mixer-store/server';
 import { Redirect } from 'next';
 import { getSegments } from '../category/category.service';
 import { resolveLabel } from '../label/label.service';
 import { getLayout } from '../layout/layout.service';
-import { getDecoratedComponents } from '../lazy/lazy';
+import { getDecoratedComponents } from '../lazy/lazy.service';
 import { getBreadcrumbFromSegments, getRoutes } from '../route/route.service';
 import { IModelStore } from '../store/store';
 
@@ -77,6 +77,43 @@ export async function getPage<T extends ICategorized = ICategorized>(schema: str
   }
 }
 
+export async function getSchemaRoutes(schema: string, market: string, locale: string): Promise<IRoute[]> {
+  const routes: IRoute[] = await getRoutes({
+    where: {
+      market: {
+        equals: market,
+      },
+      locale: {
+        equals: locale,
+      },
+      schema: {
+        equals: schema,
+      },
+    },
+  });
+  return routes;
+}
+
+export async function getNotFoundRoute(market: string, locale: string): Promise<IRoute | undefined> {
+  const routes: IRoute[] = await getRoutes({
+    where: {
+      market: {
+        equals: market,
+      },
+      locale: {
+        equals: locale,
+      },
+      schema: {
+        equals: 'notfound',
+      },
+    },
+  });
+  if (routes.length > 0) {
+    return routes[0];
+  }
+  return;
+}
+
 export async function NotFound(market: string, locale: string): Promise<{ redirect: Redirect } | void> {
   const routes: IRoute[] = await getRoutes({
     where: {
@@ -94,7 +131,7 @@ export async function NotFound(market: string, locale: string): Promise<{ redire
   if (routes.length > 0) {
     return {
       redirect: {
-        destination: routes[0].id,
+        destination: routes[0]!.id,
         permanent: false,
       },
     };
@@ -106,7 +143,7 @@ export async function getPageRoutes(schema: string, id: IEquatable): Promise<IRo
   const store = await getStore<IModelStore>();
   let routes: IRoute[] = [];
   try {
-    routes = await store.route.findMany({
+    routes = await store.route!.findMany({
       where: {
         page: {
           equals: id,
@@ -137,7 +174,7 @@ export async function getPageCategory<T extends ICategorized>(schema: string, pa
   const category = pages.length ? pages[0] : null;
   // console.log(page, market, locale, category);
   if (category) {
-    const routes = await store.route.findMany({
+    const routes = await store.route!.findMany({
       where: {
         schema: {
           equals: schema,
@@ -206,7 +243,10 @@ export async function getErrorPageLayout(): Promise<{ layout: ILayout, page: IPa
 
 export type PartialPageProps<T extends ICategorized, B> = Omit<PageProps<T>, 'page'> & Partial<Pick<PageProps<T>, 'page'>> & B;
 
-export async function getPageProps<T extends ICategorized, B = any>(props: PartialPageProps<T, B>, extraComponents?: IComponent[]) {
+export async function getPageProps<T extends ICategorized, B = any>(
+  props: PartialPageProps<T, B>,
+  extraComponents?: IComponent[]
+) {
   if (props.page) {
     await getDecoratedComponents(props as PageProps<T> & B, extraComponents);
   }

package/src/page/page.ts

@@ -0,0 +1,9 @@
+
+export function getPublicUrl() {
+  const publicUrl = process.env && process.env.NEXT_PUBLIC_URL ? process.env.NEXT_PUBLIC_URL : '';
+  return publicUrl;
+}
+
+export function resolveHref(href: string = '') {
+  return href.startsWith('http') ? href : `${getPublicUrl()}${href}`;
+}

package/src/province/province.service.ts

@@ -1,21 +1,21 @@
 import { IEquatable, INamedEntity, IPaginationResult, QueryParams } from '@websolutespa/bom-core';
-import { getStore } from '@websolutespa/bom-mixer-store';
+import { getStore } from '@websolutespa/bom-mixer-store/server';
 import { IModelStore } from '../store/store';
 
 export async function getProvinces(locale?: string): Promise<INamedEntity[]> {
   const store = await getStore<IModelStore>();
-  const items = await store.i18n_province.findMany({ locale });
+  const items = await store.i18n_province!.findMany({ locale });
   return items;
 }
 
 export async function getProvince(id: IEquatable, params: QueryParams = {}): Promise<INamedEntity | undefined> {
   const store = await getStore<IModelStore>();
-  const item = await store.i18n_province.findOne(id, params);
+  const item = await store.i18n_province!.findOne(id, params);
   return item;
 }
 
 export async function getProvincesPagination(params: QueryParams = {}): Promise<IPaginationResult<INamedEntity>> {
   const store = await getStore<IModelStore>();
-  const pagination = await store.i18n_province.findPaged<INamedEntity>(params);
+  const pagination = await store.i18n_province!.findPaged<INamedEntity>(params);
   return pagination;
 }

package/src/redirect/redirect.service.ts

@@ -1,22 +1,22 @@
 import { IEquatable, ILayout, IPaginationResult, IRedirect, QueryParams } from '@websolutespa/bom-core';
-import { getStore } from '@websolutespa/bom-mixer-store';
+import { getStore } from '@websolutespa/bom-mixer-store/server';
 import { IModelStore } from '../store/store';
 
 export async function getRedirects(locale?: string): Promise<IRedirect[]> {
   const store = await getStore<IModelStore>();
-  const items = await store.redirect.findMany({ locale });
+  const items = await store.redirect!.findMany({ locale });
   return items;
 }
 
 export async function getRedirect(id: IEquatable, params: QueryParams = {}): Promise<IRedirect | undefined> {
   const store = await getStore<IModelStore>();
-  const item = await store.redirect.findOne(id, params);
+  const item = await store.redirect!.findOne(id, params);
   return item;
 }
 
 export async function getRedirectsPagination(params: QueryParams = {}): Promise<IPaginationResult<IRedirect>> {
   const store = await getStore<IModelStore>();
-  const pagination = await store.redirect.findPaged<IRedirect>(params);
+  const pagination = await store.redirect!.findPaged<IRedirect>(params);
   return pagination;
 }
 

package/src/region/region.service.ts

@@ -1,21 +1,21 @@
 import { IEquatable, INamedEntity, IPaginationResult, QueryParams } from '@websolutespa/bom-core';
-import { getStore } from '@websolutespa/bom-mixer-store';
+import { getStore } from '@websolutespa/bom-mixer-store/server';
 import { IModelStore } from '../store/store';
 
 export async function getRegions(locale?: string): Promise<INamedEntity[]> {
   const store = await getStore<IModelStore>();
-  const items = await store.i18n_region.findMany({ locale });
+  const items = await store.i18n_region!.findMany({ locale });
   return items;
 }
 
 export async function getRegion(id: IEquatable, params: QueryParams = {}): Promise<INamedEntity | undefined> {
   const store = await getStore<IModelStore>();
-  const item = await store.i18n_region.findOne(id, params);
+  const item = await store.i18n_region!.findOne(id, params);
   return item;
 }
 
 export async function getRegionsPagination(params: QueryParams = {}): Promise<IPaginationResult<INamedEntity>> {
   const store = await getStore<IModelStore>();
-  const pagination = await store.i18n_region.findPaged<INamedEntity>(params);
+  const pagination = await store.i18n_region!.findPaged<INamedEntity>(params);
   return pagination;
 }

package/src/route/route-revalidate.handler.ts

@@ -1,43 +1,54 @@
-
-import { apiHandler } from '@websolutespa/bom-mixer-store';
-import { NextApiRequest, NextApiResponse } from 'next';
-import { getRoutes, resolveRoute } from './route.service';
-
-export function routeRevalidateHandler() {
-  return apiHandler({
-    post: async (request: NextApiRequest, response: NextApiResponse) => {
-      // console.log(request.headers);
-      const authorization = request.headers.authorization;
-      const bearer = authorization && authorization.replace('Bearer ', '');
-      // Check for secret to confirm this is a valid request
-      if (bearer !== process.env.HOOKS_SECRET) {
-        return response.status(401).json({ message: 'Invalid token' });
-      }
-      try {
-        /* { "id": 1, "schema": "product", "href": "/product/xxxx" } */
-        const { href } = request.body;
-        const routes = await getRoutes({
-          where: {
-            id: { equals: href },
-          },
-        });
-        if (routes.length === 0) {
-          // console.log('route.notfound', href);
-          return response.status(404).send(`routeRevalidateHandler.notFound ${href}`);
-        }
-        // console.log('routes', routes);
-        for (const route of routes) {
-          // console.log('route.found', route);
-          const resolvedRoute = resolveRoute(route);
-          console.log('route.revalidating', resolvedRoute);
-          await response.revalidate(resolvedRoute);
-        }
-        return response.json({ revalidated: true });
-      } catch (error) {
-        // If there was an error, Next.js will continue
-        // to show the last successfully generated page
-        return response.status(500).send('Error revalidating');
-      }
-    },
-  });
-}
+
+import { Where } from '@websolutespa/bom-core';
+import { apiHandler } from '@websolutespa/bom-mixer-store/server';
+import { NextApiRequest, NextApiResponse } from 'next';
+import { resolveRoute } from './route';
+import { getRoutes } from './route.service';
+
+export function routeRevalidateHandler() {
+  return apiHandler({
+    post: async (request: NextApiRequest, response: NextApiResponse) => {
+      // console.log(request.headers);
+      const authorization = request.headers.authorization;
+      const bearer = authorization && authorization.replace('Bearer ', '');
+      // Check for secret to confirm this is a valid request
+      if (bearer !== process.env.MIXER_SECRET) {
+        return response.status(401).json({ message: 'Invalid token' });
+      }
+      try {
+        /* { "id": 1, "schema": "product", "href": "/product/xxxx" } */
+        const { href, schema, page } = request.body || {};
+
+        let where: Where;
+        if (href) {
+          where = { id: { equals: href } };
+        } else if (schema && page) {
+          where = { schema: { equals: schema }, page: { equals: page } };
+        } else {
+          return response.status(400).send('Missing href or schema and page');
+        }
+
+        const routes = await getRoutes({ where });
+        if (routes.length === 0) {
+          // console.log('route.notfound', href);
+          const notFoundTarget = href || `${schema}:${page}`;
+          return response.status(404).send(`routeRevalidateHandler.notFound ${notFoundTarget}`);
+        }
+        // console.log('routes', routes);
+        for (const route of routes) {
+          // console.log('route.found', route);
+          const resolvedRoute = resolveRoute(route);
+          // console.log('route.revalidating', resolvedRoute);
+          await response.revalidate(resolvedRoute);
+
+          // @TODO: CDN cache purge
+        }
+        return response.json({ revalidated: true });
+      } catch (error) {
+        // If there was an error, Next.js will continue
+        // to show the last successfully generated page
+        return response.status(500).send('Error revalidating');
+      }
+    },
+  });
+}

package/src/route/route.interceptor.ts

@@ -1,8 +1,8 @@
 import { IMarket, IRoute, asEquatable, defaultLocale, defaultMarket, getHost, isDevelopment } from '@websolutespa/bom-core';
 import { StoreStrategy, localApiGet, localApiPost, storeApiGet, storeApiPost, storeStrategy } from '@websolutespa/bom-mixer-store';
 import { NextFetchEvent, NextRequest, NextResponse } from 'next/server';
-import { getPublicUrl, resolveHref } from '../page/page.service';
-import { resolveRoute } from './route.service';
+import { getPublicUrl, resolveHref } from '../page/page';
+import { resolveRoute } from './route';
 
 export async function detectLocale(request: NextRequest, defaultLocale?: string) {
   const acceptLanguage = request.headers.get('accept-language')?.split(',')[0];
@@ -11,7 +11,10 @@ export async function detectLocale(request: NextRequest, defaultLocale?: string)
 }
 
 export async function detectCountry(request: NextRequest, defaultMarket?: string) {
-  const ip = request.ip || request.headers.get('X-Forwarded-For') || request.headers.get('x-real-ip');
+  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 {
@@ -67,13 +70,18 @@ export async function routeAutoDetection(request: NextRequest, next: NextFetchEv
     }
     // console.log('routeInterceptor.routeAutoDetection', url.pathname);
     const rootRoutes = await getRootRoutes();
+    // console.log('routeInterceptor.routeAutoDetection.rootRoutes', rootRoutes);
     const defaultRoute = rootRoutes.find(x => x.id === '/');
+    // console.log('routeInterceptor.routeAutoDetection.defaultRoute', defaultRoute);
     if (defaultRoute) {
       return;
     }
     const markets = await getMarkets();
+    // 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);
@@ -81,14 +89,18 @@ export async function routeAutoDetection(request: NextRequest, next: NextFetchEv
       }) ||
       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 ?
@@ -98,6 +110,7 @@ export async function routeAutoDetection(request: NextRequest, next: NextFetchEv
           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);
       route = detectedRoute.id;
@@ -111,8 +124,10 @@ export async function routeInterceptor(request: NextRequest, next: NextFetchEven
   let route: IRoute | undefined;
   let url = request.nextUrl;
   const hrefBeforeRedirect = getHrefBeforeRedirect(request);
+  // console.log('routeInterceptor._live', request.nextUrl.searchParams.get('_live'));
   try {
     const redirectUrl = await routeAutoDetection(request, next);
+    // console.log('routeInterceptor.routeAutoDetection', redirectUrl);
     if (redirectUrl) {
       const response = NextResponse.redirect(resolveHref(redirectUrl), isDevelopment ? 307 : 301);
       response.cookies.set({

package/src/route/route.service.ts

@@ -1,25 +1,27 @@
-import { asCategoryId, defaultLocale, defaultMarket, findRouteOfCategory, getRootCategory, ICategory, IRoute, IRouteLink, localize, QueryParams } from '@websolutespa/bom-core';
-import { buildStrategy, BuildStrategy, getStore, StoreStrategy, storeStrategy } from '@websolutespa/bom-mixer-store';
+import { asCategoryId, defaultLocale, defaultMarket, findRouteOfCategory, getRootCategory, ICategory, IRoute, IRouteLink, QueryParams } from '@websolutespa/bom-core';
+import { buildStrategy, BuildStrategy, StoreStrategy, storeStrategy } from '@websolutespa/bom-mixer-store';
+import { getStore } from '@websolutespa/bom-mixer-store/server';
 import { IModelStore } from '../store/store';
+import { newRouteLink, routeToRouteLink } from './route';
 
 export type StaticPath = { params: { [key: string]: string } };
 
 export async function getRoutes(params: QueryParams = {}): Promise<IRoute[]> {
   const store = await getStore<IModelStore>();
-  const routes = await store.route.findMany(params);
+  const routes = await store.route!.findMany(params);
   return routes;
 }
 
 export async function getRoute(id: string): Promise<IRoute | undefined> {
   const store = await getStore<IModelStore>();
-  const route = await store.route.findOne(id);
+  const route = await store.route!.findOne(id);
   // console.log('RouteService.getRoute', id, '->', route);
   return route;
 }
 
 export async function getRoutesForSchemas(schemas: string[], market?: string, locale?: string): Promise<{ [key: string]: string; }> {
   const store = await getStore<IModelStore>();
-  const routes = await store.route.findMany({
+  const routes = await store.route!.findMany({
     where: {
       schema: {
         in: schemas,
@@ -43,7 +45,7 @@ export async function getRoutesForSchemas(schemas: string[], market?: string, lo
 
 export async function getRoutesForTemplates(templates: string[], market?: string, locale?: string): Promise<{ [key: string]: string; }> {
   const store = await getStore<IModelStore>();
-  const routes = await store.route.findMany({
+  const routes = await store.route!.findMany({
     where: {
       template: {
         in: templates,
@@ -75,7 +77,7 @@ export async function getStaticPathsForSchema(
     return [];
   }
   const store = await getStore<IModelStore>();
-  const routes = await store.route.findMany({
+  const routes = await store.route!.findMany({
     where: template ? ({
       and: [{
         template: {
@@ -151,7 +153,7 @@ export async function getBreadcrumbFromSegments(segments: ICategory[], route: IR
 export async function getRouteLinkTree(market: string, locale: string): Promise<IRouteLink | undefined> {
   const store = await getStore<IModelStore>();
   // console.log('getRouteLinkTree.store', store);
-  const routes = await store.route.findMany({
+  const routes = await store.route!.findMany({
     where: {
       market: {
         equals: market,
@@ -162,7 +164,7 @@ export async function getRouteLinkTree(market: string, locale: string): Promise<
     },
   });
   // console.log('getRouteLinkTree.routes', routes.map(x => x.id));
-  const categories = await store.category.findMany({ market, locale });
+  const categories = await store.category!.findMany({ market, locale });
   // console.log('getRouteLinkTree.categories', categories.map(x => x.id));
   const rootCategory = getRootCategory(categories);
   // console.log('getRouteLinkTree.rootCategory', rootCategory?.id);
@@ -205,43 +207,3 @@ export function getRouteLinkCategory(
   routeLink.items = items;
   return routeLink;
 }
-
-export function newRouteLink(category: ICategory, route: IRoute | undefined, locale: string): IRouteLink {
-  const href = (route && route.id) ? route.id.toString() : '/';
-  const id = route?.page || category.id;
-  const media = category.media || route?.media;
-  const schema = route?.template || route?.schema || category?.schema || 'unknown';
-  const title = localize(category.title || route?.title || 'untitled', locale);
-  const routeLink = {
-    category: category.id,
-    href,
-    id,
-    items: [],
-    media,
-    schema,
-    title,
-  };
-  return routeLink;
-}
-
-export function routeToRouteLink(route: IRoute): IRouteLink {
-  const routeLink: IRouteLink = {
-    category: asCategoryId(route.category),
-    href: route.id,
-    id: route.page,
-    items: [],
-    media: route.media,
-    schema: route.schema,
-    title: route.title,
-  };
-  return routeLink;
-}
-
-export function resolveRoute(route: IRoute & { splat?: string }) {
-  // console.log('resolveRoute', route);
-  const routepath: string = route.template || route.schema;
-  // convert route to next.js pages folder schema
-  const resolvedPathname = `/${route.market}/${route.locale}/${routepath}/${route.page}${route.splat || ''}`;
-  // console.log('resolveRoute', route.schema, resolvedPathname);
-  return resolvedPathname;
-}

package/src/route/route.ts

@@ -0,0 +1,64 @@
+import { asCategoryId, findRouteOfCategory, getRootCategory, ICategory, IRoute, IRouteLink, localize } from '@websolutespa/bom-core';
+
+export type StaticPath = { params: { [key: string]: string } };
+
+export function categoryToRouteLink(routes: IRoute[], categories: ICategory[], category: ICategory, locale: string): IRouteLink | undefined {
+  const route = findRouteOfCategory(routes, category.id);
+  if (!route) {
+    return undefined;
+  }
+  const rootCategory = getRootCategory(categories);
+  const childCategories = categories.filter(x => {
+    const parentId = asCategoryId(x.category);
+    return rootCategory && rootCategory.id === category.id ?
+      (x.id !== rootCategory.id && (parentId === category.id || !parentId)) :
+      parentId === category.id;
+  });
+  // console.log('childCategories', category.id, childCategories);
+  const routeLink = newRouteLink(category, route, locale);
+  // console.log('categoryToRouteLink', href, category.id, route);
+  routeLink.items = childCategories
+    .map(x => categoryToRouteLink(routes, categories, x, locale))
+    .filter(x => x !== undefined) as IRouteLink[];
+  return routeLink;
+}
+
+export function newRouteLink(category: ICategory, route: IRoute | undefined, locale: string): IRouteLink {
+  const href = (route && route.id) ? route.id.toString() : '/';
+  const id = route?.page || category.id;
+  const media = category.media || route?.media;
+  const schema = route?.template || route?.schema || category?.schema || 'unknown';
+  const title = localize(category.title || route?.title || 'untitled', locale);
+  const routeLink = {
+    category: category.id,
+    href,
+    id,
+    items: [],
+    media,
+    schema,
+    title,
+  };
+  return routeLink;
+}
+
+export function routeToRouteLink(route: IRoute): IRouteLink {
+  const routeLink: IRouteLink = {
+    category: asCategoryId(route.category),
+    href: route.id,
+    id: route.page,
+    items: [],
+    media: route.media,
+    schema: route.schema,
+    title: route.title,
+  };
+  return routeLink;
+}
+
+export function resolveRoute(route: IRoute & { splat?: string }) {
+  // console.log('resolveRoute', route);
+  const routepath: string = route.template || route.schema;
+  // convert route to next.js pages folder schema
+  const resolvedPathname = `/${route.market}/${route.locale}/${routepath}/${route.page}${route.splat || ''}`;
+  // console.log('resolveRoute', route.schema, resolvedPathname);
+  return resolvedPathname;
+}

package/src/session/session.service.ts

@@ -4,21 +4,29 @@ import { getIronSession, IronSession, SessionOptions } from 'iron-session';
 import { NextApiRequest, NextApiResponse } from 'next';
 import { NextRequest, NextResponse } from 'next/server';
 
+function getSessionSecret() {
+  const secret = process.env.MIXER_SECRET || '';
+  if (!secret) {
+    throw 'getSessionSecret MIXER_SECRET not defined';
+  }
+  return secret;
+}
+
 export async function getSession<T extends object = Record<string, any>>(
   request: NextRequest | NextApiRequest | IncomingMessage & {
     cookies: Partial<{ [key: string]: string }>;
   },
   response: NextResponse | NextApiResponse | ServerResponse<IncomingMessage>
 ): Promise<IronSession<T>> {
-  const COOKIE_NAME = 'websolutespa-next-js';
-  const COOKIE_PASSWORD = process.env.SECRET_COOKIE_PASSWORD as string || 'SECRET_COOKIE_PASSWORD_32_CHARS_LONG';
+  const cookieName = 'websolutespa-next-js';
+  const password = getSessionSecret();
   const sessionOptions: SessionOptions = {
-    cookieName: COOKIE_NAME,
+    cookieName,
+    password,
     // secure: true should be used in production (HTTPS) but can't be used in development (HTTP)
     cookieOptions: {
       secure: !isDevelopment,
     },
-    password: COOKIE_PASSWORD,
   };
   const session = await getIronSession<T>(request, response, sessionOptions);
   return session;

package/src/sitemap/sitemap.service.ts

@@ -24,7 +24,7 @@ export async function getSiteMapIndex(origin: string): Promise<string> {
     // console.log(sitemapRoutes.shift(), sitemapRoutes.pop());
     sitemaps.push({
       id: `/${market.id}/${locale.id}/sitemap.xml`,
-      updatedAt: sitemapRoutes.length > 0 ? sitemapRoutes[sitemapRoutes.length - 1].updatedAt : undefined,
+      updatedAt: sitemapRoutes.length > 0 ? sitemapRoutes[sitemapRoutes.length - 1]!.updatedAt : undefined,
     });
   });
   return `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${origin}/sitemap.xsl"?>
@@ -122,8 +122,8 @@ export async function getSiteMapXML(origin: string, marketId?: string, localeId?
   let locales: ILocale[] = await getLocales();
   markets = markets.filter(x => x.isActive !== false);
   locales = locales.filter(x => x.isActive !== false);
-  const defaultMarket = markets.find(x => marketId ? x.id === marketId : x.isDefault) || markets[0];
-  const defaultLocale = locales.find(x => localeId ? x.id === localeId : x.isDefault) || locales[0];
+  const defaultMarket = markets.find(x => marketId ? x.id === marketId : x.isDefault) || markets[0]!;
+  const defaultLocale = locales.find(x => localeId ? x.id === localeId : x.isDefault) || locales[0]!;
   const defaultMarketLocale = defaultMarket && defaultMarket.defaultLanguage ? defaultMarket.defaultLanguage : defaultLocale.id;
   const routes: IRoute[] = await getRoutes();
   const isCanonicalRoute: (route: IRoute) => boolean = (marketId && localeId) ? (route) => {
@@ -155,7 +155,7 @@ ${getSiteMapXMLUrls(origin, canonicalRoutes)}
 export async function getSiteMapXSL(localeId?: string): Promise<string> {
   let locales: ILocale[] = await getLocales();
   locales = locales.filter(x => x.isActive !== false);
-  const defaultLocale = locales.find(x => localeId ? x.id === localeId : x.isDefault) || locales[0];
+  const locale = locales.find(x => localeId ? x.id === localeId : x.isDefault) || locales[0]!;
   return /* html */`<?xml version="1.0" encoding="UTF-8"?>
 	<xsl:stylesheet version="2.0"
 		xmlns:html="http://www.w3.org/TR/REC-html40"
@@ -164,7 +164,7 @@ export async function getSiteMapXSL(localeId?: string): Promise<string> {
 		xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 	<xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
 	<xsl:template match="/">
-		<html lang="${defaultLocale.id}" xmlns="http://www.w3.org/1999/xhtml">
+		<html lang="${locale.id}" xmlns="http://www.w3.org/1999/xhtml">
 		<head>
 			<title>XML Sitemap</title>
 			<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />