@websolutespa/bom-mixer-store 1.7.0 → 1.7.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @websolutespa/bom-mixer-store
 
+## 1.7.1
+
+### Patch Changes
+
+- Fixing: findRoute redirects
+
 ## 1.7.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -231,7 +231,7 @@ declare function collectionPatch<T extends IStore>(storePromise: () => Promise<T
 declare function collectionDelete<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
 declare function routePost(store: IStore, request: NextApiRequest, response: NextApiResponse): Promise<void>;
 declare function storeIndexHandler(): any;
-declare function findRoute(store: IStore, pathname: string, href: string): Promise<IRoute | undefined>;
+declare function findRoute(store: IStore, pathname: string, href: string, hrefBeforeRedirect: string | null): Promise<IRoute | undefined>;
 
 declare function getStore<T extends IStore>(): Promise<T>;
 

package/dist/index.js

@@ -649,18 +649,18 @@ async function localApiDelete(url, options = {}, serviceOptions) {
 var mime = __toESM(require("mime"));
 var API_BASE2 = process.env.NEXT_PUBLIC_API || "/api";
 function isStaticRequest(request) {
-  const url = request.nextUrl;
-  const isStatic = mime.getType(url.pathname) !== null;
+  const { pathname } = request.nextUrl;
+  const isStatic = mime.getType(pathname) !== null;
   return isStatic;
 }
 function isNextRequest(request) {
-  const url = request.nextUrl;
-  const isNext = url.pathname.indexOf("/_next/") === 0;
+  const { pathname } = request.nextUrl;
+  const isNext = pathname.startsWith("/_next");
   return isNext;
 }
 function isApiRequest(request) {
-  const url = request.nextUrl;
-  const isApi = url.pathname.indexOf(API_BASE2) === 0;
+  const { pathname } = request.nextUrl;
+  const isApi = pathname.startsWith(API_BASE2);
   return isApi;
 }
 
@@ -1730,30 +1730,31 @@ function collectionDelete(storePromise) {
   };
 }
 async function routePost(store, request, response) {
-  if (request.body.pathname && request.body.href) {
-    try {
-      const { pathname, href } = request.body;
-      const route = await findRoute(store, pathname, href);
+  try {
+    const { pathname, href, hrefBeforeRedirect } = request.body;
+    console.log("routePost", pathname, href, hrefBeforeRedirect);
+    if (pathname && href) {
+      const route = await findRoute(store, pathname, href, hrefBeforeRedirect);
       return response.status(200).json(route);
-    } catch (error) {
-      if (error.status < 500) {
-        if (error.status < 400) {
-          return response.status(error.status).send({
-            redirectUrl: error.redirectUrl
-          });
-        }
-        if (error.status === 404) {
-          return response.status(404).send("not found");
-        } else {
-          return response.status(error.status).send("gone");
-        }
+    } else {
+      return response.status(400).send("bad request");
+    }
+  } catch (error) {
+    if (error.status < 500) {
+      if (error.status < 400) {
+        return response.status(error.status).send({
+          redirectUrl: error.redirectUrl
+        });
+      }
+      if (error.status === 404) {
+        return response.status(404).send("not found");
       } else {
-        console.error("storeHandler.error.500", error);
-        throw error;
+        return response.status(error.status).send("gone");
       }
+    } else {
+      console.error("storeHandler.error.500", error);
+      throw error;
     }
-  } else {
-    return response.status(400).send("bad request");
   }
 }
 function storeIndexHandler() {
@@ -1887,7 +1888,38 @@ function storeIndexHandler() {
     }
   });
 }
-async function findRoute(store, pathname, href) {
+var trimTerminalSlash = (path) => {
+  return path.replace(/\/+$/, "");
+};
+var sanitizeHref = (url, urlBeforeRedirect) => {
+  if (urlBeforeRedirect) {
+    const sanitizedUrl = new URL(urlBeforeRedirect);
+    sanitizedUrl.protocol = url.protocol;
+    return trimTerminalSlash(sanitizedUrl.href);
+  } else {
+    return trimTerminalSlash(url.href);
+  }
+};
+var sanitizeRedirectFrom = (path, url, urlBeforeRedirect) => {
+  path = trimTerminalSlash(path);
+  if (urlBeforeRedirect) {
+    return path.replace(/^(\^?)((https?:\/\/)+)/, `$1${url.protocol}//`);
+  } else {
+    return path.replace(/^(\^?)((https?:\/\/)+(\w|\.|:)+)/, `$1${url.origin}`);
+  }
+};
+var sanitizeRedirectTo = (path) => {
+  return path ? trimTerminalSlash(path) : void 0;
+};
+var sanitizeRedirectUrl = (path, url) => {
+  if (path != null) {
+    path = trimTerminalSlash(path);
+    return path.match(/^((https?:\/\/)+)/) ? path : `${url.origin}${path}`;
+  } else {
+    return path;
+  }
+};
+async function findRoute(store, pathname, href, hrefBeforeRedirect) {
   const routes = await store.route.findMany({
     where: {
       id: {
@@ -1916,23 +1948,31 @@ async function findRoute(store, pathname, href) {
     if (splatRoute) {
       return splatRoute;
     }
-    const redirects = await store.redirect.findMany({
+    const url = new URL(href);
+    const urlBeforeRedirect = hrefBeforeRedirect ? new URL(hrefBeforeRedirect) : null;
+    const sanitizedHref = sanitizeHref(url, urlBeforeRedirect);
+    let redirects = await store.redirect.findMany({
       where: {
         isActive: {
           equals: true
         }
       }
     });
+    redirects = redirects.map((x) => ({
+      ...x,
+      from: sanitizeRedirectFrom(x.from, url, urlBeforeRedirect),
+      to: sanitizeRedirectTo(x.to)
+    }));
     const exactMatchResolver = (redirect) => {
       const status = parseInt(redirect.status) || 307;
       if (status < 400) {
-        const redirectUrl = redirect.to;
+        const redirectUrl = sanitizeRedirectUrl(redirect.to, url);
         throw { status, redirectUrl };
       } else {
         throw { status };
       }
     };
-    const exactMatchRedirect = redirects.find((x) => x.from === href);
+    const exactMatchRedirect = redirects.find((x) => x.from === sanitizedHref);
     if (exactMatchRedirect !== void 0) {
       return exactMatchResolver(exactMatchRedirect);
     }
@@ -1944,7 +1984,8 @@ async function findRoute(store, pathname, href) {
         let redirectUrl = redirect.to.replace(/\*/g, (...rest) => {
           return `$${++i}`;
         });
-        redirectUrl = href.replace(regexp, redirectUrl);
+        redirectUrl = sanitizedHref.replace(regexp, redirectUrl);
+        redirectUrl = sanitizeRedirectUrl(redirectUrl, url);
         throw { status, redirectUrl };
       } else {
         throw { status };
@@ -1956,7 +1997,7 @@ async function findRoute(store, pathname, href) {
       expression = `^${expression.replace(/(^\^)|(\$$)/g, "")}$`;
       x.from = expression;
     });
-    const firstMatch = redirects.find((x) => href.match(x.from));
+    const firstMatch = redirects.find((x) => sanitizedHref.match(x.from));
     if (firstMatch) {
       return patternMatchResolver(firstMatch);
     }

package/dist/index.mjs

@@ -541,18 +541,18 @@ async function localApiDelete(url, options = {}, serviceOptions) {
 import * as mime from "mime";
 var API_BASE2 = process.env.NEXT_PUBLIC_API || "/api";
 function isStaticRequest(request) {
-  const url = request.nextUrl;
-  const isStatic = mime.getType(url.pathname) !== null;
+  const { pathname } = request.nextUrl;
+  const isStatic = mime.getType(pathname) !== null;
   return isStatic;
 }
 function isNextRequest(request) {
-  const url = request.nextUrl;
-  const isNext = url.pathname.indexOf("/_next/") === 0;
+  const { pathname } = request.nextUrl;
+  const isNext = pathname.startsWith("/_next");
   return isNext;
 }
 function isApiRequest(request) {
-  const url = request.nextUrl;
-  const isApi = url.pathname.indexOf(API_BASE2) === 0;
+  const { pathname } = request.nextUrl;
+  const isApi = pathname.startsWith(API_BASE2);
   return isApi;
 }
 
@@ -1622,30 +1622,31 @@ function collectionDelete(storePromise) {
   };
 }
 async function routePost(store, request, response) {
-  if (request.body.pathname && request.body.href) {
-    try {
-      const { pathname, href } = request.body;
-      const route = await findRoute(store, pathname, href);
+  try {
+    const { pathname, href, hrefBeforeRedirect } = request.body;
+    console.log("routePost", pathname, href, hrefBeforeRedirect);
+    if (pathname && href) {
+      const route = await findRoute(store, pathname, href, hrefBeforeRedirect);
       return response.status(200).json(route);
-    } catch (error) {
-      if (error.status < 500) {
-        if (error.status < 400) {
-          return response.status(error.status).send({
-            redirectUrl: error.redirectUrl
-          });
-        }
-        if (error.status === 404) {
-          return response.status(404).send("not found");
-        } else {
-          return response.status(error.status).send("gone");
-        }
+    } else {
+      return response.status(400).send("bad request");
+    }
+  } catch (error) {
+    if (error.status < 500) {
+      if (error.status < 400) {
+        return response.status(error.status).send({
+          redirectUrl: error.redirectUrl
+        });
+      }
+      if (error.status === 404) {
+        return response.status(404).send("not found");
       } else {
-        console.error("storeHandler.error.500", error);
-        throw error;
+        return response.status(error.status).send("gone");
       }
+    } else {
+      console.error("storeHandler.error.500", error);
+      throw error;
     }
-  } else {
-    return response.status(400).send("bad request");
   }
 }
 function storeIndexHandler() {
@@ -1779,7 +1780,38 @@ function storeIndexHandler() {
     }
   });
 }
-async function findRoute(store, pathname, href) {
+var trimTerminalSlash = (path) => {
+  return path.replace(/\/+$/, "");
+};
+var sanitizeHref = (url, urlBeforeRedirect) => {
+  if (urlBeforeRedirect) {
+    const sanitizedUrl = new URL(urlBeforeRedirect);
+    sanitizedUrl.protocol = url.protocol;
+    return trimTerminalSlash(sanitizedUrl.href);
+  } else {
+    return trimTerminalSlash(url.href);
+  }
+};
+var sanitizeRedirectFrom = (path, url, urlBeforeRedirect) => {
+  path = trimTerminalSlash(path);
+  if (urlBeforeRedirect) {
+    return path.replace(/^(\^?)((https?:\/\/)+)/, `$1${url.protocol}//`);
+  } else {
+    return path.replace(/^(\^?)((https?:\/\/)+(\w|\.|:)+)/, `$1${url.origin}`);
+  }
+};
+var sanitizeRedirectTo = (path) => {
+  return path ? trimTerminalSlash(path) : void 0;
+};
+var sanitizeRedirectUrl = (path, url) => {
+  if (path != null) {
+    path = trimTerminalSlash(path);
+    return path.match(/^((https?:\/\/)+)/) ? path : `${url.origin}${path}`;
+  } else {
+    return path;
+  }
+};
+async function findRoute(store, pathname, href, hrefBeforeRedirect) {
   const routes = await store.route.findMany({
     where: {
       id: {
@@ -1808,23 +1840,31 @@ async function findRoute(store, pathname, href) {
     if (splatRoute) {
       return splatRoute;
     }
-    const redirects = await store.redirect.findMany({
+    const url = new URL(href);
+    const urlBeforeRedirect = hrefBeforeRedirect ? new URL(hrefBeforeRedirect) : null;
+    const sanitizedHref = sanitizeHref(url, urlBeforeRedirect);
+    let redirects = await store.redirect.findMany({
       where: {
         isActive: {
           equals: true
         }
       }
     });
+    redirects = redirects.map((x) => ({
+      ...x,
+      from: sanitizeRedirectFrom(x.from, url, urlBeforeRedirect),
+      to: sanitizeRedirectTo(x.to)
+    }));
     const exactMatchResolver = (redirect) => {
       const status = parseInt(redirect.status) || 307;
       if (status < 400) {
-        const redirectUrl = redirect.to;
+        const redirectUrl = sanitizeRedirectUrl(redirect.to, url);
         throw { status, redirectUrl };
       } else {
         throw { status };
       }
     };
-    const exactMatchRedirect = redirects.find((x) => x.from === href);
+    const exactMatchRedirect = redirects.find((x) => x.from === sanitizedHref);
     if (exactMatchRedirect !== void 0) {
       return exactMatchResolver(exactMatchRedirect);
     }
@@ -1836,7 +1876,8 @@ async function findRoute(store, pathname, href) {
         let redirectUrl = redirect.to.replace(/\*/g, (...rest) => {
           return `$${++i}`;
         });
-        redirectUrl = href.replace(regexp, redirectUrl);
+        redirectUrl = sanitizedHref.replace(regexp, redirectUrl);
+        redirectUrl = sanitizeRedirectUrl(redirectUrl, url);
         throw { status, redirectUrl };
       } else {
         throw { status };
@@ -1848,7 +1889,7 @@ async function findRoute(store, pathname, href) {
       expression = `^${expression.replace(/(^\^)|(\$$)/g, "")}$`;
       x.from = expression;
     });
-    const firstMatch = redirects.find((x) => href.match(x.from));
+    const firstMatch = redirects.find((x) => sanitizedHref.match(x.from));
     if (firstMatch) {
       return patternMatchResolver(firstMatch);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@websolutespa/bom-mixer-store",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Mixer Store module of the BOM Repository",
   "keywords": [
     "bom",

package/src/middleware/middleware.service.ts

@@ -4,20 +4,19 @@ import { NextRequest } from 'next/server';
 const API_BASE = process.env.NEXT_PUBLIC_API || '/api';
 
 export function isStaticRequest(request: NextRequest) {
-  const url = request.nextUrl;
-  const isStatic = mime.getType(url.pathname) !== null;
-  // const isStatic = url.pathname.indexOf('.') !== -1;
+  const { pathname } = request.nextUrl;
+  const isStatic = mime.getType(pathname) !== null;
   return isStatic;
 }
 
 export function isNextRequest(request: NextRequest) {
-  const url = request.nextUrl;
-  const isNext = url.pathname.indexOf('/_next/') === 0;
+  const { pathname } = request.nextUrl;
+  const isNext = pathname.startsWith('/_next');
   return isNext;
 }
 
 export function isApiRequest(request: NextRequest) {
-  const url = request.nextUrl;
-  const isApi = url.pathname.indexOf(API_BASE) === 0;
+  const { pathname } = request.nextUrl;
+  const isApi = pathname.startsWith(API_BASE);
   return isApi;
 }

package/src/store/store.handler.ts

@@ -152,30 +152,31 @@ export function collectionDelete<T extends IStore>(storePromise: () => Promise<T
 // route post resolver
 // !!! todo, should be moved to models -> route service
 export async function routePost(store: IStore, request: NextApiRequest, response: NextApiResponse) {
-  if (request.body.pathname && request.body.href) {
-    try {
-      const { pathname, href } = request.body;
-      const route = await findRoute(store, pathname, href);
+  try {
+    const { pathname, href, hrefBeforeRedirect } = request.body;
+    console.log('routePost', pathname, href, hrefBeforeRedirect);
+    if (pathname && href) {
+      const route = await findRoute(store, pathname, href, hrefBeforeRedirect);
       return response.status(200).json(route);
-    } catch (error: any) {
-      if (error.status < 500) {
-        if (error.status < 400) {
-          return response.status(error.status).send({
-            redirectUrl: error.redirectUrl,
-          });
-        }
-        if (error.status === 404) {
-          return response.status(404).send('not found');
-        } else {
-          return response.status(error.status).send('gone');
-        }
+    } else {
+      return response.status(400).send('bad request');
+    }
+  } catch (error: any) {
+    if (error.status < 500) {
+      if (error.status < 400) {
+        return response.status(error.status).send({
+          redirectUrl: error.redirectUrl,
+        });
+      }
+      if (error.status === 404) {
+        return response.status(404).send('not found');
       } else {
-        console.error('storeHandler.error.500', error);
-        throw error;
+        return response.status(error.status).send('gone');
       }
+    } else {
+      console.error('storeHandler.error.500', error);
+      throw error;
     }
-  } else {
-    return response.status(400).send('bad request');
   }
 }
 
@@ -314,7 +315,43 @@ export function storeIndexHandler() {
   });
 }
 
-export async function findRoute(store: IStore, pathname: string, href: string): Promise<IRoute | undefined> {
+const trimTerminalSlash = (path: string) => {
+  return path.replace(/\/+$/, '');
+};
+
+const sanitizeHref = (url: URL, urlBeforeRedirect: URL | null) => {
+  if (urlBeforeRedirect) {
+    const sanitizedUrl = new URL(urlBeforeRedirect);
+    sanitizedUrl.protocol = url.protocol;
+    return trimTerminalSlash(sanitizedUrl.href);
+  } else {
+    return trimTerminalSlash(url.href);
+  }
+};
+
+const sanitizeRedirectFrom = (path: string, url: URL, urlBeforeRedirect: URL | null) => {
+  path = trimTerminalSlash(path);
+  if (urlBeforeRedirect) {
+    return path.replace(/^(\^?)((https?:\/\/)+)/, `$1${url.protocol}//`);
+  } else {
+    return path.replace(/^(\^?)((https?:\/\/)+(\w|\.|:)+)/, `$1${url.origin}`);
+  }
+};
+
+const sanitizeRedirectTo = (path?: string) => {
+  return path ? trimTerminalSlash(path) : undefined;
+};
+
+const sanitizeRedirectUrl = (path: string | undefined, url: URL) => {
+  if (path != null) {
+    path = trimTerminalSlash(path);
+    return path.match(/^((https?:\/\/)+)/) ? path : `${url.origin}${path}`;
+  } else {
+    return path;
+  }
+};
+
+export async function findRoute(store: IStore, pathname: string, href: string, hrefBeforeRedirect: string | null): Promise<IRoute | undefined> {
   // here we use findMany because route id would break api url
   const routes = await store.route.findMany<IRoute>({
     where: {
@@ -323,6 +360,7 @@ export async function findRoute(store: IStore, pathname: string, href: string):
       },
     },
   });
+  // console.log('routes', routes);
   // console.log('pathname', pathname);
   if (routes.length > 0) {
     return routes[0];
@@ -336,7 +374,6 @@ export async function findRoute(store: IStore, pathname: string, href: string):
         },
       },
     });
-    // console.log('splatRoutes', splatRoutes);
     // find best match splat route
     const splatRoute = splatRoutes.reduce((p: (IRoute & { splat: string }) | undefined, c: IRoute) => {
       const match = pathname.indexOf(c.id) === 0;
@@ -349,27 +386,42 @@ export async function findRoute(store: IStore, pathname: string, href: string):
     if (splatRoute) {
       return splatRoute;
     }
+    const url = new URL(href);
+    const urlBeforeRedirect = hrefBeforeRedirect ? new URL(hrefBeforeRedirect) : null;
+    const sanitizedHref = sanitizeHref(url, urlBeforeRedirect);
+    /*
+    console.log('href', url.href);
+    console.log('hrefBeforeRedirect', urlBeforeRedirect?.href);
+    console.log('sanitizedHref', sanitizedHref);
+    */
     // collect redirects
-    const redirects = await store.redirect.findMany<IRedirect>({
+    let redirects = await store.redirect.findMany<IRedirect>({
       where: {
         isActive: {
           equals: true,
         },
       },
     });
+    redirects = redirects.map(x => ({
+      ...x,
+      from: sanitizeRedirectFrom(x.from, url, urlBeforeRedirect),
+      to: sanitizeRedirectTo(x.to),
+    }));
     // redirects.sort((a, b) => a.order - b.order);
+    // console.log('findRoute redirects', redirects);
     // exact match redirect resolver
     const exactMatchResolver = (redirect: IRedirect) => {
       const status: number = parseInt(redirect.status) || 307;
       if (status < 400) {
-        const redirectUrl = redirect.to;
+        const redirectUrl = sanitizeRedirectUrl(redirect.to, url);
+        // console.log('>>>>>>>>>> findRoute exactMatchResolver', status, redirectUrl, redirect.to);
         throw { status, redirectUrl };
       } else {
         throw { status };
       }
     };
     // check exact match redirects
-    const exactMatchRedirect = redirects.find(x => x.from === href);
+    const exactMatchRedirect = redirects.find(x => x.from === sanitizedHref);
     if (exactMatchRedirect !== undefined) {
       return exactMatchResolver(exactMatchRedirect);
     }
@@ -382,7 +434,9 @@ export async function findRoute(store: IStore, pathname: string, href: string):
         let redirectUrl = (redirect.to as string).replace(/\*/g, (...rest) => {
           return `$${++i}`;
         });
-        redirectUrl = href.replace(regexp, redirectUrl);
+        redirectUrl = sanitizedHref.replace(regexp, redirectUrl);
+        redirectUrl = sanitizeRedirectUrl(redirectUrl, url) as string;
+        // console.log('>>>>>>>>>> findRoute patternMatchResolver', status, redirectUrl, redirect.to);
         throw { status, redirectUrl };
       } else {
         throw { status };
@@ -398,7 +452,8 @@ export async function findRoute(store: IStore, pathname: string, href: string):
       x.from = expression;
     });
     // check if a regex pattern redirect does match
-    const firstMatch = redirects.find(x => href.match(x.from));
+    const firstMatch = redirects.find(x => sanitizedHref.match(x.from));
+    // console.log('>>>>>>>>>> findRoute firstMatch', firstMatch);
     if (firstMatch) {
       return patternMatchResolver(firstMatch);
     }