@fjell/express-router 4.4.1 → 4.4.3

package/src/ItemRouter.ts

@@ -11,25 +11,11 @@ import {
 } from "@fjell/core";
 import { NotFoundError, Operations } from "@fjell/lib";
 import deepmerge from "deepmerge";
-import { Request, RequestHandler, Response, Router } from "express";
+import { Request, Response, Router } from "express";
 import LibLogger from "./logger";
 
 export type ItemRouterOptions = Record<string, never>;
 
-// TODO: body is in the request, it's not needed in the parameters
-export type ActionMethod = <
-  S extends string,
-  L1 extends string = never,
-  L2 extends string = never,
-  L3 extends string = never,
-  L4 extends string = never,
-  L5 extends string = never
->(req: Request, res: Response, item: Item<S, L1, L2, L3, L4, L5>, params: any, body: any) =>
-  Promise<Item<S, L1, L2, L3, L4, L5>>;
-
-// TODO: body is in the request, it's not needed in the parameters
-export type AllActionMethods = Array<RequestHandler>;
-
 export class ItemRouter<
   S extends string,
   L1 extends string = never,
@@ -44,7 +30,6 @@ export class ItemRouter<
   protected options: ItemRouterOptions;
   private childRouters: Record<string, Router> = {};
   private logger;
-  private itemActions: Record<string, ActionMethod> | undefined;
 
   constructor(
     lib: Operations<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>,
@@ -94,17 +79,45 @@ export class ItemRouter<
     this.logger.default('Getting Item', { query: req?.query, params: req?.params, locals: res?.locals });
     const ik = this.getIk(res);
     const actionKey = req.path.substring(req.path.lastIndexOf('/') + 1);
-    if (!this.itemActions) {
+    if (!this.lib.actions) {
       this.logger.error('Item Actions are not configured');
-      return res.status(500).json({ error: 'Item Actions are not configured' });
+      res.status(500).json({ error: 'Item Actions are not configured' });
+      return;
+    }
+    const action = this.lib.actions[actionKey];
+    if (!action) {
+      this.logger.error('Item Action is not configured', { actionKey });
+      res.status(500).json({ error: 'Item Action is not configured' });
+      return;
     }
     try {
-      const item =
-        validatePK(await this.lib.get(ik), this.getPkType()) as Item<S, L1, L2, L3, L4, L5>;
-      return res.json(await this.itemActions[actionKey](req, res, item, req.params, req.body));
+      res.json(await this.lib.action(ik, actionKey, req.body));
     } catch (err: any) {
       this.logger.error('Error in Item Action', { message: err?.message, stack: err?.stack });
-      return res.status(500).json(err);
+      res.status(500).json(err);
+    }
+  }
+
+  protected getItemFacet = async (req: Request, res: Response) => {
+    this.logger.default('Getting Item', { query: req?.query, params: req?.params, locals: res?.locals });
+    const ik = this.getIk(res);
+    const facetKey = req.path.substring(req.path.lastIndexOf('/') + 1);
+    if (!this.lib.facets) {
+      this.logger.error('Item Facets are not configured');
+      res.status(500).json({ error: 'Item Facets are not configured' });
+      return;
+    }
+    const facet = this.lib.facets[facetKey];
+    if (!facet) {
+      this.logger.error('Item Facet is not configured', { facetKey });
+      res.status(500).json({ error: 'Item Facet is not configured' });
+      return;
+    }
+    try {
+      res.json(await this.lib.facet(ik, facetKey, req.params));
+    } catch (err: any) {
+      this.logger.error('Error in Item Facet', { message: err?.message, stack: err?.stack });
+      res.status(500).json(err);
     }
   }
 
@@ -113,31 +126,39 @@ export class ItemRouter<
     router.get('/', this.findItems);
     router.post('/', this.createItem);
 
-    const allActions = this.configureAllActions();
-    this.logger.debug('All Actions supplied to Router', { allActions });
-    if (allActions) {
-      Object.keys(allActions).forEach((actionKey) => {
-        this.logger.default('Configuring All Action', { actionKey });
-        // TODO: Ok, this is a bit of a hack, but we need to customize the types of the request handlers
-        router.post(`/${actionKey}`, ...allActions[actionKey]);
-      });
-    }
+    // const allActions = this.configureAllActions();
+    // this.logger.debug('All Actions supplied to Router', { allActions });
+    // if (allActions) {
+    //   Object.keys(allActions).forEach((actionKey) => {
+    //     this.logger.default('Configuring All Action', { actionKey });
+    //     // TODO: Ok, this is a bit of a hack, but we need to customize the types of the request handlers
+    //     router.post(`/${actionKey}`, ...allActions[actionKey]);
+    //   });
+    // }
 
     const itemRouter = Router();
     itemRouter.get('/', this.getItem);
     itemRouter.put('/', this.updateItem);
     itemRouter.delete('/', this.deleteItem);
 
-    this.itemActions = this.configureItemActions();
-    this.logger.debug('Item Actions supplied to Router', { itemActions: this.itemActions });
-    if (this.itemActions) {
-      Object.keys(this.itemActions).forEach((actionKey) => {
+    this.logger.debug('Item Actions supplied to Router', { itemActions: this.lib.actions });
+    if (this.lib.actions) {
+      Object.keys(this.lib.actions).forEach((actionKey) => {
         this.logger.default('Configuring Item Action', { actionKey });
         // TODO: Ok, this is a bit of a hack, but we need to customize the types of the request handlers
         itemRouter.post(`/${actionKey}`, this.postItemAction)
       });
     }
 
+    this.logger.debug('Item Facets supplied to Router', { itemFacets: this.lib.facets });
+    if (this.lib.facets) {
+      Object.keys(this.lib.facets).forEach((facetKey) => {
+        this.logger.default('Configuring Item Facet', { facetKey });
+        // TODO: Ok, this is a bit of a hack, but we need to customize the types of the request handlers
+        itemRouter.get(`/${facetKey}`, this.getItemFacet)
+      });
+    }
+
     this.logger.default('Configuring Item Operations under PK Param', { pkParam: this.getPkParam() });
     router.use(`/:${this.getPkParam()}`, this.validatePrimaryKeyValue, itemRouter);
 
@@ -171,18 +192,6 @@ export class ItemRouter<
     this.childRouters[path] = router;
   }
 
-  /* istanbul ignore next */
-  protected configureItemActions(): Record<string, ActionMethod> {
-    this.logger.debug('ARouter - No Item Actions Configured');
-    return {};
-  }
-
-  /* istanbul ignore next */
-  protected configureAllActions(): Record<string, AllActionMethods> {
-    this.logger.debug('ARouter - No All Actions Configured');
-    return {};
-  }
-
   /* istanbul ignore next */
   public getRouter(): Router {
     const router = Router();
@@ -192,7 +201,7 @@ export class ItemRouter<
 
   /* istanbul ignore next */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected createItem = async (req: Request, res: Response): Promise<Response<any, Record<string, any>>> => {
+  protected createItem = async (req: Request, res: Response): Promise<void> => {
     throw new Error('Method not implemented in an abstract router');
   };
 
@@ -203,17 +212,17 @@ export class ItemRouter<
     return item;
   };
 
-  protected deleteItem = async (req: Request, res: Response): Promise<Response<any, Record<string, any>>> => {
+  protected deleteItem = async (req: Request, res: Response): Promise<void> => {
     this.logger.default('Deleting Item', { query: req.query, params: req.params, locals: res.locals });
     const ik = this.getIk(res);
     const removedItem = await this.lib.remove(ik);
     const item = validatePK(removedItem, this.getPkType());
-    return res.json(item);
+    res.json(item);
   };
 
   /* eslint-disable */
   /* istanbul ignore next */
-  protected findItems = async (req: Request, res: Response): Promise<Response<any, Record<string, any>>> => {
+  protected findItems = async (req: Request, res: Response): Promise<void> => {
     throw new Error('Method not implemented in an abstract router');
   };
   /* eslint-enable */
@@ -224,17 +233,17 @@ export class ItemRouter<
     try {
       // TODO: What error does validate PK throw, when can that fail?
       const item = validatePK(await this.lib.get(ik), this.getPkType());
-      return res.json(item);
+      res.json(item);
     } catch (err: any) {
       if (err instanceof NotFoundError) {
         this.logger.error('Item Not Found', { ik, message: err?.message, stack: err?.stack });
-        return res.status(404).json({
+        res.status(404).json({
           ik,
           message: "Item Not Found",
         });
       } else {
         this.logger.error('General Error', { ik, message: err?.message, stack: err?.stack });
-        return res.status(500).json({
+        res.status(500).json({
           ik,
           message: "General Error",
         });
@@ -248,7 +257,7 @@ export class ItemRouter<
     const ik = this.getIk(res);
     const itemToUpdate = this.convertDates(req.body as ItemProperties<S, L1, L2, L3, L4, L5>);
     const retItem = validatePK(await this.lib.update(ik, itemToUpdate), this.getPkType());
-    return res.json(retItem);
+    res.json(retItem);
   };
 
   public convertDates = (item: Item<S, L1, L2, L3, L4, L5> | ItemProperties<S, L1, L2, L3, L4, L5>):

package/src/PItemRouter.ts

@@ -13,7 +13,7 @@ interface ParsedQuery {
 export class PItemRouter<T extends Item<S>, S extends string> extends ItemRouter<S> {
 
   constructor(lib: Primary.Operations<T, S>, keyType: S, options: ItemRouterOptions = {}) {
-    super(lib, keyType, options);
+    super(lib as any, keyType, options);
   }
 
   public getIk(res: Response): PriKey<S> {
@@ -27,10 +27,9 @@ export class PItemRouter<T extends Item<S>, S extends string> extends ItemRouter
     let item =
       validatePK(await this.lib.create(itemToCreate), this.getPkType()) as Item<S>;
     item = await this.postCreateItem(item);
-    return res.json(item);
+    res.json(item);
   };
 
-  /* eslint-disable */
   protected findItems = async (req: Request, res: Response) => {
     logger.default('Finding Items', { query: req.query, params: req.params, locals: res.locals });
 
@@ -39,11 +38,18 @@ export class PItemRouter<T extends Item<S>, S extends string> extends ItemRouter
     const query: ParsedQuery = req.query as unknown as ParsedQuery;
     const finder = query['finder'] as string;
     const finderParams = query['finderParams'] as string;
+    const one = query['one'] as string;
 
-    if( finder ) { 
+    if (finder) {
       // If finder is defined?  Call a finder.
-      logger.default('Finding Items with a finder', { finder, finderParams });
-      items = await this.lib.find(finder, JSON.parse(finderParams));
+      logger.default('Finding Items with a finder', { finder, finderParams, one });
+
+      if (one === 'true') {
+        const item = await (this.lib as any).findOne(finder, JSON.parse(finderParams));
+        items = item ? [item] : [];
+      } else {
+        items = await this.lib.find(finder, JSON.parse(finderParams));
+      }
     } else {
       logger.default('Finding Items with a query', { query: req.query });
       // TODO: This is once of the more important places to perform some validaation and feedback
@@ -51,7 +57,7 @@ export class PItemRouter<T extends Item<S>, S extends string> extends ItemRouter
       items = await this.lib.all(itemQuery);
     }
 
-    return res.json(items.map((item: Item<S>) => validatePK(item, this.getPkType())));
+    res.json(items.map((item: Item<S>) => validatePK(item, this.getPkType())));
   };
-  /* eslint-enable */
+
 }