@websolutespa/bom-mixer-store 0.3.2 → 1.0.0

package/dist/index.mjs

@@ -103,10 +103,10 @@ var fs = __require("fs");
 async function fsRead(pathname, encoding = "utf8") {
   try {
     const data = await fs.promises.readFile(pathname, encoding);
-    return data || null;
+    return data || void 0;
   } catch (error) {
     console.log("fsRead", error, pathname);
-    return null;
+    return;
   }
 }
 async function fsReadJson(pathname) {
@@ -115,11 +115,11 @@ async function fsReadJson(pathname) {
     if (data) {
       return JSON.parse(data);
     } else {
-      return null;
+      return;
     }
   } catch (error) {
     console.log("fsReadJson", error, pathname);
-    return null;
+    return;
   }
 }
 
@@ -796,28 +796,32 @@ async function getMockStore(getJson) {
 }
 function getMockStoreFromData(data) {
   const store = {};
-  for (const key in data) {
-    if (!PAGES.includes(key)) {
-      const service = new MockService(data[key], store);
-      store[key] = service;
+  if (data) {
+    for (const key in data) {
+      if (!PAGES.includes(key)) {
+        const service = new MockService(data[key], store);
+        store[key] = service;
+      }
     }
-  }
-  const category = store.category;
-  const route = store.route;
-  const menu = data.menu;
-  if (category && route && menu) {
-    store.menu = new MockMenuService(menu, store);
-  }
-  for (const key in data) {
-    if (PAGES.includes(key)) {
-      let service;
-      if (route) {
-        service = new MockPageService(data[key], store);
-      } else {
-        service = new MockService(data[key], store);
+    const category = store.category;
+    const route = store.route;
+    const menu = data.menu;
+    if (category && route && menu) {
+      store.menu = new MockMenuService(menu, store);
+    }
+    for (const key in data) {
+      if (PAGES.includes(key)) {
+        let service;
+        if (route) {
+          service = new MockPageService(data[key], store);
+        } else {
+          service = new MockService(data[key], store);
+        }
+        store[key] = service;
       }
-      store[key] = service;
     }
+  } else {
+    console.log("mock store not found");
   }
   staticCollections.forEach((config) => {
     store[config.slug] = new StaticService(config, store);
@@ -1067,6 +1071,7 @@ var KNOWN_COLLECTIONS = [
   "menu",
   "template",
   "page",
+  "redirect",
   "route",
   ...STATIC_COLLECTIONS
 ];
@@ -1087,157 +1092,216 @@ async function getStore() {
 // src/store/store.handler.ts
 function storeHandler(storePromise = async () => await getStore()) {
   return apiHandler({
-    // find a specific document by id or
-    // find paginated documents
-    get: async (request, response) => {
-      try {
-        const { collections, ...query } = request.query;
-        if (!Array.isArray(collections) || collections?.length === 0) {
-          console.error("method not allowed", collections);
-          return response.status(405).send("method not allowed");
-        }
-        const collection = collections[0];
-        const id = collections[1];
-        const qs = Object.entries(query).map((kv) => kv.join("=")).join("&");
-        const params = qsDeserialize(qs);
-        if (!COLLECTIONS.includes(collection)) {
-          console.error("method not allowed", collection);
-          return response.status(405).send("method not allowed");
-        }
-        const store = await storePromise();
-        const service = store[collection];
-        if (!service) {
-          console.error("method not allowed", collection);
-          return response.status(405).send("method not allowed");
-        }
-        if (id) {
-          const item = await service.findOne(asEquatable(id), params);
-          if (item) {
-            return response.status(200).json(item);
-          } else {
-            return response.status(404).send("not found");
-          }
-        } else if (String(params.pagination) === "true") {
-          const pagination = await service.findPaged(params);
-          return response.status(200).json(pagination);
+    get: collectionGet(storePromise),
+    post: collectionPost(storePromise),
+    patch: collectionPatch(storePromise),
+    delete: collectionDelete(storePromise)
+  });
+}
+function collectionGet(storePromise) {
+  return async (request, response) => {
+    try {
+      const { collections, ...query } = request.query;
+      if (!Array.isArray(collections) || collections?.length === 0) {
+        console.error("storeHandler.collectionGet", "method not allowed", collections);
+        return response.status(405).send("method not allowed");
+      }
+      const collection = collections[0];
+      const id = collections[1];
+      const qs = Object.entries(query).map((kv) => kv.join("=")).join("&");
+      const params = qsDeserialize(qs);
+      if (!COLLECTIONS.includes(collection)) {
+        console.error("storeHandler.collectionGet", "method not allowed", collection);
+        return response.status(405).send("method not allowed");
+      }
+      const store = await storePromise();
+      const service = store[collection];
+      if (!service) {
+        console.error("storeHandler.collectionGet", "method not allowed", collection);
+        return response.status(405).send("method not allowed");
+      }
+      if (id) {
+        const item = await service.findOne(asEquatable(id), params);
+        if (item) {
+          return response.status(200).json(item);
         } else {
-          const items = await service.findMany(params);
-          return response.status(200).json(items);
+          return response.status(404).send("not found");
         }
-      } catch (error) {
-        console.error("storeHandler.error.500", error);
-        throw error;
+      } else if (String(params.pagination) === "true") {
+        const pagination = await service.findPaged(params);
+        return response.status(200).json(pagination);
+      } else {
+        const items = await service.findMany(params);
+        return response.status(200).json(items);
       }
-    },
-    // create a new document
-    post: async (request, response) => {
-      try {
-        const { collections, ...query } = request.query;
-        if (!Array.isArray(collections) || collections.length !== 1) {
-          console.error("method not allowed", collections);
-          return response.status(405).send("method not allowed");
-        }
-        const collection = collections[0];
-        const store = await storePromise();
-        const service = store[collection];
-        if (!service) {
-          console.error("method not allowed", collection);
-          return response.status(405).send("method not allowed");
+    } catch (error) {
+      console.error("storeHandler.collectionGet.error", "500", error);
+      throw error;
+    }
+  };
+}
+function collectionPost(storePromise) {
+  return async (request, response) => {
+    try {
+      const { collections, ...query } = request.query;
+      if (!Array.isArray(collections) || collections.length !== 1) {
+        console.error("method not allowed", collections);
+        return response.status(405).send("method not allowed");
+      }
+      const collection = collections[0];
+      const store = await storePromise();
+      const service = store[collection];
+      if (!service) {
+        console.error("method not allowed", collection);
+        return response.status(405).send("method not allowed");
+      }
+      if (collection === "route") {
+        return routePost(store, request, response);
+      }
+    } catch (error) {
+      console.error("storeHandler.error.500", error);
+      throw error;
+    }
+  };
+}
+function collectionPatch(storePromise) {
+  return async (request, response) => {
+    try {
+      const params = request.query;
+      const { collections, ...query } = params;
+      if (!Array.isArray(collections) || collections.length !== 2) {
+        console.error("method not allowed", collections);
+        return response.status(405).send("method not allowed");
+      }
+      const collection = collections[0];
+      const id = collections[1];
+      const store = await storePromise();
+      const service = store[collection];
+      if (!service) {
+        console.error("method not allowed", collection);
+        return response.status(405).send("method not allowed");
+      }
+    } catch (error) {
+      console.error("storeHandler.error.500", error);
+      throw error;
+    }
+  };
+}
+function collectionDelete(storePromise) {
+  return async (request, response) => {
+    try {
+      const params = request.query;
+      const { collections, ...query } = params;
+      if (!Array.isArray(collections) || collections.length !== 2) {
+        console.error("method not allowed", collections);
+        return response.status(405).send("method not allowed");
+      }
+      const collection = collections[0];
+      const id = collections[1];
+      const store = await storePromise();
+      const service = store[collection];
+      if (!service) {
+        console.error("method not allowed", collection);
+        return response.status(405).send("method not allowed");
+      }
+    } catch (error) {
+      console.error("storeHandler.error.500", error);
+      throw error;
+    }
+  };
+}
+async function routePost(store, request, response) {
+  if (request.body.pathname && request.body.href) {
+    try {
+      const { pathname, href } = request.body;
+      const routes = await store.route.findMany({
+        where: {
+          id: {
+            equals: pathname
+          }
         }
-        if (collection === "route" && request.body.pathname) {
-          try {
-            const { pathname } = request.body;
-            const routes = await store.route.findMany({
-              where: {
-                id: {
-                  equals: pathname
-                }
-              }
-            });
-            if (routes.length === 0) {
-              const splatRoutes = await store.route.findMany({
-                where: {
-                  useSplat: {
-                    equals: true
-                  }
-                }
-              });
-              const route = splatRoutes.reduce((p, c) => {
-                const match = pathname.indexOf(c.id) === 0;
-                if (match && (!p || p.id.length < c.id.length)) {
-                  return { ...c, splat: pathname.substring(c.id.length, pathname.length) };
-                } else {
-                  return p;
-                }
-              }, void 0);
-              if (route) {
-                return response.status(200).json(route);
-              }
-            }
-            if (routes.length > 0) {
-              return response.status(200).json(routes[0]);
-            } else {
-              return response.status(404).send("not found");
-            }
-          } catch (error) {
-            if (error.status === 404) {
-              return response.status(404).send("not found");
-            } else {
-              console.error("storeHandler.error.500", error);
-              throw error;
+      });
+      if (routes.length > 0) {
+        return response.status(200).json(routes[0]);
+      } else {
+        const splatRoutes = await store.route.findMany({
+          where: {
+            useSplat: {
+              equals: true
             }
           }
+        });
+        const splatRoute = splatRoutes.reduce((p, c) => {
+          const match = pathname.indexOf(c.id) === 0;
+          if (match && (!p || p.id.length < c.id.length)) {
+            return { ...c, splat: pathname.substring(c.id.length, pathname.length) };
+          } else {
+            return p;
+          }
+        }, void 0);
+        if (splatRoute) {
+          return response.status(200).json(splatRoute);
         }
-      } catch (error) {
-        console.error("storeHandler.error.500", error);
-        throw error;
-      }
-    },
-    // update a document by id
-    patch: async (request, response) => {
-      try {
-        const params = request.query;
-        const { collections, ...query } = params;
-        if (!Array.isArray(collections) || collections.length !== 2) {
-          console.error("method not allowed", collections);
-          return response.status(405).send("method not allowed");
+        const redirects = await store.redirect.findMany({
+          where: {
+            isActive: {
+              equals: true
+            }
+          }
+        });
+        const exactMatchResolver = (redirect) => {
+          const status = parseInt(redirect.status) || 307;
+          if (status < 400) {
+            const redirectUrl = redirect.to;
+            return response.status(status).send({
+              redirectUrl
+            });
+          } else {
+            return response.status(status).send("gone");
+          }
+        };
+        const exactMatchRedirect = redirects.find((x) => x.from === href);
+        if (exactMatchRedirect !== void 0) {
+          return exactMatchResolver(exactMatchRedirect);
         }
-        const collection = collections[0];
-        const id = collections[1];
-        const store = await storePromise();
-        const service = store[collection];
-        if (!service) {
-          console.error("method not allowed", collection);
-          return response.status(405).send("method not allowed");
+        const patternMatchResolver = (redirect) => {
+          const status = parseInt(redirect.status) || 307;
+          if (status < 400) {
+            const regexp = new RegExp(redirect.from);
+            let i = 0;
+            let redirectUrl = redirect.to.replace(/\*/g, (...rest) => {
+              return `$${++i}`;
+            });
+            redirectUrl = href.replace(regexp, redirectUrl);
+            return response.status(status).send({
+              redirectUrl
+            });
+          } else {
+            return response.status(status).send("gone");
+          }
+        };
+        redirects.forEach((x) => {
+          x.from = x.from.replace(/\*/g, (...rest) => {
+            return "(.*)";
+          });
+        });
+        const firstMatch = redirects.find((x) => href.match(x.from));
+        if (firstMatch) {
+          return patternMatchResolver(firstMatch);
         }
-      } catch (error) {
-        console.error("storeHandler.error.500", error);
-        throw error;
+        return response.status(404).send("not found");
       }
-    },
-    // delete an existing document by id
-    delete: async (request, response) => {
-      try {
-        const params = request.query;
-        const { collections, ...query } = params;
-        if (!Array.isArray(collections) || collections.length !== 2) {
-          console.error("method not allowed", collections);
-          return response.status(405).send("method not allowed");
-        }
-        const collection = collections[0];
-        const id = collections[1];
-        const store = await storePromise();
-        const service = store[collection];
-        if (!service) {
-          console.error("method not allowed", collection);
-          return response.status(405).send("method not allowed");
-        }
-      } catch (error) {
+    } catch (error) {
+      if (error.status === 404) {
+        return response.status(404).send("not found");
+      } else {
         console.error("storeHandler.error.500", error);
         throw error;
       }
     }
-  });
+  } else {
+    return response.status(400).send("bad request");
+  }
 }
 
 // src/mock/mock.handler.ts
@@ -1260,6 +1324,10 @@ export {
   apiPatch,
   apiPost,
   apiPut,
+  collectionDelete,
+  collectionGet,
+  collectionPatch,
+  collectionPost,
   errorHandler,
   getApiBuildStore,
   getApiRuntimeStore,
@@ -1275,6 +1343,7 @@ export {
   isRelation,
   isStaticRequest,
   mockHandler,
+  routePost,
   staticCollections,
   storeApiDelete,
   storeApiFetch,

package/package.json

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

package/src/api/api.service.ts

@@ -16,6 +16,16 @@ export function getApiUrl(pathname: string): string {
     process.env.NEXT_PUBLIC_URL;
   const apiBase = process.env.NEXT_PUBLIC_API || '/api';
   const url = `${localUrl}${apiBase}${pathname}`;
+  /*
+  console.log(
+    'getApiUrl',
+    'NEXT_PUBLIC_URL', process.env.NEXT_PUBLIC_URL,
+    'NEXT_PUBLIC_MOCK_FALLBACK_URL', process.env.NEXT_PUBLIC_MOCK_FALLBACK_URL,
+    'localUrl', localUrl,
+    'apiBase', apiBase,
+    'url', url,
+  );
+  */
   return url;
 }
 

package/src/fs/fs.service.ts

@@ -11,28 +11,28 @@ export async function fsExists(pathname: string): Promise<boolean> {
   }
 }
 
-export async function fsRead(pathname: string, encoding = 'utf8'): Promise<any> {
+export async function fsRead(pathname: string, encoding = 'utf8'): Promise<string | undefined> {
   try {
     const data = await fs.promises.readFile(pathname, encoding);
-    return data || null;
+    return data || undefined;
   } catch (error) {
     console.log('fsRead', error, pathname);
-    return null;
+    return;
   }
 }
 
-export async function fsReadJson(pathname: string): Promise<any> {
+export async function fsReadJson<T = {}>(pathname: string): Promise<T | undefined> {
   try {
     const data = await fsRead(pathname);
     if (data) {
-      return JSON.parse(data);
+      return JSON.parse(data) as T;
     } else {
-      return null;
+      return;
     }
   } catch (error) {
     console.log('fsReadJson', error, pathname);
     // throw (error);
-    return null;
+    return;
   }
 }
 

package/src/mock/mock.store.ts

@@ -21,7 +21,7 @@ export async function getMockStoreServer<T extends IStore>(): Promise<T> {
   }
   const pathname = path.join(process.cwd(), '.mixer', 'store.json');
   // console.log('getMockStore.pathname', pathname);
-  const data: IMemoryStore = await fsReadJson(pathname);
+  const data = await fsReadJson<IMemoryStore>(pathname);
   const store = getMockStoreFromData(data);
   if (!isDevelopment) {
     STORE_ = store;
@@ -44,33 +44,37 @@ export async function getMockStore<T extends IStore>(getJson: () => Promise<stri
   return store as T;
 }
 
-export function getMockStoreFromData<T extends IStore>(data: IMemoryStore): T {
+export function getMockStoreFromData<T extends IStore>(data?: IMemoryStore): T {
   const store: IStore = {};
-  for (const key in data) {
-    if (!PAGES.includes(key)) {
-      // new collection
-      const service = new MockService(data[key], store);
-      store[key] = service;
+  if (data) {
+    for (const key in data) {
+      if (!PAGES.includes(key)) {
+        // new collection
+        const service = new MockService(data[key], store);
+        store[key] = service;
+      }
     }
-  }
-  const category = store.category;
-  const route = store.route;
-  const menu = data.menu;
-  if (category && route && menu) {
-    store.menu = new MockMenuService(menu, store);
-  }
-  for (const key in data) {
-    if (PAGES.includes(key)) {
-      let service;
-      if (route) {
-        // new page
-        service = new MockPageService(data[key], store);
-      } else {
-        // !!! new collection should throw
-        service = new MockService(data[key], store);
+    const category = store.category;
+    const route = store.route;
+    const menu = data.menu;
+    if (category && route && menu) {
+      store.menu = new MockMenuService(menu, store);
+    }
+    for (const key in data) {
+      if (PAGES.includes(key)) {
+        let service;
+        if (route) {
+          // new page
+          service = new MockPageService(data[key], store);
+        } else {
+          // !!! new collection should throw
+          service = new MockService(data[key], store);
+        }
+        store[key] = service;
       }
-      store[key] = service;
     }
+  } else {
+    console.log('mock store not found');
   }
   staticCollections.forEach(config => {
     store[config.slug] = new StaticService(config, store);