@websolutespa/bom-mixer-store 0.3.1 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @websolutespa/bom-mixer-store
 
+## 0.4.0
+
+### Minor Changes
+
+- Modified routes, added redirects.
+
+## 0.3.2
+
+### Patch Changes
+
+- Modified: MockMenuService.
+
 ## 0.3.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -50,7 +50,7 @@ declare function isRelation(item: unknown): item is IPageRelation;
 
 declare function getMockStoreServer<T extends IStore>(): Promise<T>;
 declare function getMockStore<T extends IStore>(getJson: () => Promise<string>): Promise<T>;
-declare function getMockStoreFromData<T extends IStore>(data: IMemoryStore): T;
+declare function getMockStoreFromData<T extends IStore>(data?: IMemoryStore): T;
 
 type IField = {
     name: string;
@@ -89,7 +89,12 @@ declare enum StoreStrategy {
 }
 declare const storeStrategy: StoreStrategy;
 
-declare function storeHandler<T extends IStore>(storePromise?: () => Promise<T>): any;
+declare function storeHandler<T extends IStore>(storePromise?: () => Promise<T>): any;
+declare function collectionGet<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+declare function collectionPost<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+declare function collectionPatch<T extends IStore>(storePromise: () => Promise<T>): (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+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 const MOCK_COLLECTIONS: string[];
 declare const STATIC_COLLECTIONS: string[];
@@ -122,4 +127,4 @@ declare function getApiStore<T extends IStore>(collections: string[]): Promise<T
 declare function getApiRuntimeStore<T extends IStore>(collections: string[]): Promise<T>;
 declare function getApiBuildStore<T extends IStore>(): Promise<T>;
 
-export { ApiRequestOptions, COLLECTIONS, IApiHandler, ICrudMethod, IField, IHandler, KNOWN_COLLECTIONS, MOCK_COLLECTIONS, MapTo, MockService, STATIC_COLLECTIONS, StaticService, StaticServiceConfig, StaticServiceSrc, StoreApiService, StoreStrategy, apiDelete, apiFetch, apiGet, apiHandler, apiPatch, apiPost, apiPut, errorHandler, getApiBuildStore, getApiRuntimeStore, getApiStore, getApiUrl, getMockStore, getMockStoreFromData, getMockStoreServer, getStore, isApiRequest, isNextRequest, isObject, isRelation, isStaticRequest, mockHandler, staticCollections, storeApiDelete, storeApiFetch, storeApiGet, storeApiPatch, storeApiPost, storeApiPut, storeHandler, storeStrategy };
+export { ApiRequestOptions, COLLECTIONS, IApiHandler, ICrudMethod, IField, IHandler, KNOWN_COLLECTIONS, MOCK_COLLECTIONS, MapTo, MockService, STATIC_COLLECTIONS, StaticService, StaticServiceConfig, StaticServiceSrc, StoreApiService, StoreStrategy, apiDelete, apiFetch, apiGet, apiHandler, apiPatch, apiPost, apiPut, collectionDelete, collectionGet, collectionPatch, collectionPost, errorHandler, getApiBuildStore, getApiRuntimeStore, getApiStore, getApiUrl, getMockStore, getMockStoreFromData, getMockStoreServer, getStore, isApiRequest, isNextRequest, isObject, isRelation, isStaticRequest, mockHandler, routePost, staticCollections, storeApiDelete, storeApiFetch, storeApiGet, storeApiPatch, storeApiPost, storeApiPut, storeHandler, storeStrategy };

package/dist/index.js

@@ -35,6 +35,10 @@ __export(src_exports, {
   apiPatch: () => apiPatch,
   apiPost: () => apiPost,
   apiPut: () => apiPut,
+  collectionDelete: () => collectionDelete,
+  collectionGet: () => collectionGet,
+  collectionPatch: () => collectionPatch,
+  collectionPost: () => collectionPost,
   errorHandler: () => errorHandler,
   getApiBuildStore: () => getApiBuildStore,
   getApiRuntimeStore: () => getApiRuntimeStore,
@@ -50,6 +54,7 @@ __export(src_exports, {
   isRelation: () => isRelation,
   isStaticRequest: () => isStaticRequest,
   mockHandler: () => mockHandler,
+  routePost: () => routePost,
   staticCollections: () => staticCollections,
   storeApiDelete: () => storeApiDelete,
   storeApiFetch: () => storeApiFetch,
@@ -159,10 +164,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) {
@@ -171,11 +176,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;
   }
 }
 
@@ -573,6 +578,26 @@ var MockMenuService = class extends MockService {
     }
   }
 };
+async function collectPages(store, items) {
+  if (!items) {
+    return;
+  }
+  for (const item of items) {
+    if (item.type === "page" && typeof item.page.value === "number" && store[item.page.relationTo] !== void 0) {
+      const value = await store[item.page.relationTo].findOne(item.page.value);
+      if (value) {
+        item.page.value = value;
+      }
+    }
+    switch (item.type) {
+      case "group":
+      case "link":
+      case "page":
+        await collectPages(store, item.items);
+        break;
+    }
+  }
+}
 async function decorateMenu(store, item, market = "ww", locale = "en") {
   const items = item.items || [];
   const decoratedItem = {
@@ -590,27 +615,7 @@ async function decorateMenu(store, item, market = "ww", locale = "en") {
       }
     }
   });
-  async function collectPages(items2) {
-    if (!items2) {
-      return;
-    }
-    for (const item2 of items2) {
-      if (item2.type === "page" && typeof item2.page.value === "number" && store[item2.page.relationTo] !== void 0) {
-        const value = await store[item2.page.relationTo].findOne(item2.page.value);
-        if (value) {
-          item2.page.value = value;
-        }
-      }
-      switch (item2.type) {
-        case "group":
-        case "link":
-        case "page":
-          await collectPages(item2.items);
-          break;
-      }
-    }
-  }
-  await collectPages(items);
+  await collectPages(store, items);
   decoratedItem.items = items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market));
   return decoratedItem;
 }
@@ -619,12 +624,14 @@ async function decorateMenus(store, items, market = "ww", locale = "en") {
 }
 function decorateMenuCategory(item, categories, routes, market, depth = 0) {
   const decoratedItem = {
-    id: item.id || "",
-    type: item.type,
-    title: "",
+    abstract: item.abstract,
     category: "",
+    customClass: item.customClass,
     href: "",
-    items: []
+    id: item.id || "",
+    items: [],
+    title: "",
+    type: item.type
   };
   const category = typeof item.category === "string" ? categories.find((x) => x.id === item.category) : item.category;
   if (category) {
@@ -680,9 +687,11 @@ function decorateMenuRoute(item) {
 function decorateMenuGroup(item, categories, routes, market) {
   const items = item.items || [];
   const decoratedItem = {
+    abstract: item.abstract,
+    customClass: item.customClass,
     id: item.id || "",
-    type: item.type,
     title: item.title,
+    type: item.type,
     items: items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market))
   };
   return decoratedItem;
@@ -690,11 +699,13 @@ function decorateMenuGroup(item, categories, routes, market) {
 function decorateMenuLink(item, categories, routes, market) {
   const items = item.items || [];
   const decoratedItem = {
-    id: item.id || "",
-    type: item.type,
-    title: item.title,
+    abstract: item.abstract,
+    customClass: item.customClass,
     href: item.href,
+    id: item.id || "",
     target: item.target || "",
+    title: item.title,
+    type: item.type,
     items: items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market))
   };
   return decoratedItem;
@@ -706,6 +717,8 @@ function decorateMenuPage(item, categories, routes, market) {
     id: item.id || "",
     type: item.type,
     title: item.title || item.page.value.title || "",
+    abstract: item.abstract || item.page.value.abstract || "",
+    customClass: item.customClass,
     href: route?.id || "",
     media: item.page.value.media,
     page: route?.page || "",
@@ -836,28 +849,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);
@@ -1107,6 +1124,7 @@ var KNOWN_COLLECTIONS = [
   "menu",
   "template",
   "page",
+  "redirect",
   "route",
   ...STATIC_COLLECTIONS
 ];
@@ -1127,157 +1145,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 = (0, import_bom_core9.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((0, import_bom_core9.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 = (0, import_bom_core9.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((0, import_bom_core9.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
@@ -1301,6 +1378,10 @@ function mockHandler(getJson) {
   apiPatch,
   apiPost,
   apiPut,
+  collectionDelete,
+  collectionGet,
+  collectionPatch,
+  collectionPost,
   errorHandler,
   getApiBuildStore,
   getApiRuntimeStore,
@@ -1316,6 +1397,7 @@ function mockHandler(getJson) {
   isRelation,
   isStaticRequest,
   mockHandler,
+  routePost,
   staticCollections,
   storeApiDelete,
   storeApiFetch,