@fjell/express-router 4.4.3 → 4.4.5

package/src/ItemRouter.ts

@@ -3,13 +3,12 @@ import {
   cPK,
   Item,
   ItemEvent,
-  ItemProperties,
   LocKey,
   LocKeyArray,
   PriKey,
   validatePK
 } from "@fjell/core";
-import { NotFoundError, Operations } from "@fjell/lib";
+import { Instance, NotFoundError } from "@fjell/lib";
 import deepmerge from "deepmerge";
 import { Request, Response, Router } from "express";
 import LibLogger from "./logger";
@@ -25,14 +24,14 @@ export class ItemRouter<
   L5 extends string = never
 > {
 
-  protected lib: Operations<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>;
+  protected lib: Instance<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>;
   private keyType: S;
   protected options: ItemRouterOptions;
   private childRouters: Record<string, Router> = {};
-  private logger;
+  protected logger;
 
   constructor(
-    lib: Operations<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>,
+    lib: Instance<Item<S, L1, L2, L3, L4, L5>, S, L1, L2, L3, L4, L5>,
     keyType: S,
     options: ItemRouterOptions = {}
   ) {
@@ -75,23 +74,74 @@ export class ItemRouter<
     throw new Error('Method not implemented in an abstract router');
   }
 
+  protected postAllAction = async (req: Request, res: Response) => {
+    const libOptions = this.lib.definition.options;
+    const libOperations = this.lib.operations;
+    this.logger.debug('Posting All Action', { query: req?.query, params: req?.params, locals: res?.locals });
+    const allActionKey = req.path.substring(req.path.lastIndexOf('/') + 1);
+    if (!libOptions.allActions) {
+      this.logger.error('Item Actions are not configured');
+      res.status(500).json({ error: 'Item Actions are not configured' });
+      return;
+    }
+    const allAction = libOptions.allActions[allActionKey];
+    if (!allAction) {
+      this.logger.error('All Action is not configured', { allActionKey });
+      res.status(500).json({ error: 'Item Action is not configured' });
+      return;
+    }
+    try {
+      res.json(await libOperations.allAction(allActionKey, req.body));
+    } catch (err: any) {
+      this.logger.error('Error in All Action', { message: err?.message, stack: err?.stack });
+      res.status(500).json(err);
+    }
+  }
+
+  protected getAllFacet = async (req: Request, res: Response) => {
+    const libOptions = this.lib.definition.options;
+    const libOperations = this.lib.operations;
+    this.logger.debug('Getting All Facet', { query: req?.query, params: req?.params, locals: res?.locals });
+    const facetKey = req.path.substring(req.path.lastIndexOf('/') + 1);
+    if (!libOptions.allFacets) {
+      this.logger.error('Item Facets are not configured');
+      res.status(500).json({ error: 'Item Facets are not configured' });
+      return;
+    }
+    const facet = libOptions.allFacets[facetKey];
+    if (!facet) {
+      this.logger.error('Item Facet is not configured', { facetKey });
+      res.status(500).json({ error: 'Item Facet is not configured' });
+      return;
+    }
+    try {
+      const combinedQueryParams = { ...req.query, ...req.params } as Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>;
+      res.json(await libOperations.allFacet(facetKey, combinedQueryParams));
+    } catch (err: any) {
+      this.logger.error('Error in All Facet', { message: err?.message, stack: err?.stack });
+      res.status(500).json(err);
+    }
+  }
+
   protected postItemAction = async (req: Request, res: Response) => {
-    this.logger.default('Getting Item', { query: req?.query, params: req?.params, locals: res?.locals });
+    const libOptions = this.lib.definition.options;
+    const libOperations = this.lib.operations;
+    this.logger.debug('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.lib.actions) {
+    if (!libOptions.actions) {
       this.logger.error('Item Actions are not configured');
       res.status(500).json({ error: 'Item Actions are not configured' });
       return;
     }
-    const action = this.lib.actions[actionKey];
+    const action = libOptions.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 {
-      res.json(await this.lib.action(ik, actionKey, req.body));
+      res.json(await libOperations.action(ik, actionKey, req.body));
     } catch (err: any) {
       this.logger.error('Error in Item Action', { message: err?.message, stack: err?.stack });
       res.status(500).json(err);
@@ -99,22 +149,25 @@ export class ItemRouter<
   }
 
   protected getItemFacet = async (req: Request, res: Response) => {
-    this.logger.default('Getting Item', { query: req?.query, params: req?.params, locals: res?.locals });
+    const libOptions = this.lib.definition.options;
+    const libOperations = this.lib.operations;
+    this.logger.debug('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) {
+    if (!libOptions.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];
+    const facet = libOptions.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));
+      const combinedQueryParams = { ...req.query, ...req.params } as Record<string, string | number | boolean | Date | Array<string | number | boolean | Date>>;
+      res.json(await libOperations.facet(ik, facetKey, combinedQueryParams));
     } catch (err: any) {
       this.logger.error('Error in Item Facet', { message: err?.message, stack: err?.stack });
       res.status(500).json(err);
@@ -122,44 +175,53 @@ export class ItemRouter<
   }
 
   private configure = (router: Router) => {
-    this.logger.default('Configuring Router', { pkType: this.getPkType() });
+    const libOptions = this.lib.definition.options;
+    this.logger.debug('Configuring Router', { pkType: this.getPkType() });
     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]);
-    //   });
-    // }
+    this.logger.default('All Actions supplied to Router', { allActions: libOptions.allActions });
+    if (libOptions.allActions) {
+      Object.keys(libOptions.allActions).forEach((actionKey) => {
+        this.logger.debug('Configuring All Action %s', actionKey);
+        // TODO: Ok, this is a bit of a hack, but we need to customize the types of the request handlers
+        router.post(`/${actionKey}`, this.postAllAction);
+      });
+    }
+
+    this.logger.default('All Facets supplied to Router', { allFacets: libOptions.allFacets });
+    if (libOptions.allFacets) {
+      Object.keys(libOptions.allFacets).forEach((facetKey) => {
+        this.logger.debug('Configuring All Facet %s', facetKey);
+        // TODO: Ok, this is a bit of a hack, but we need to customize the types of the request handlers
+        router.get(`/${facetKey}`, this.getAllFacet);
+      });
+    }
 
     const itemRouter = Router();
     itemRouter.get('/', this.getItem);
     itemRouter.put('/', this.updateItem);
     itemRouter.delete('/', this.deleteItem);
 
-    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 });
+    this.logger.default('Item Actions supplied to Router', { itemActions: libOptions.actions });
+    if (libOptions.actions) {
+      Object.keys(libOptions.actions).forEach((actionKey) => {
+        this.logger.debug('Configuring Item Action %s', 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 });
+    this.logger.default('Item Facets supplied to Router', { itemFacets: libOptions.facets });
+    if (libOptions.facets) {
+      Object.keys(libOptions.facets).forEach((facetKey) => {
+        this.logger.debug('Configuring Item Facet %s', 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() });
+    this.logger.debug('Configuring Item Operations under PK Param %s', this.getPkParam());
     router.use(`/:${this.getPkParam()}`, this.validatePrimaryKeyValue, itemRouter);
 
     if (this.childRouters) {
@@ -174,14 +236,14 @@ export class ItemRouter<
       res.locals[this.getPkParam()] = pkParamValue;
       next();
     } else {
-      this.logger.error('Invalid Primary Key', { pkParamValue, path: req?.path });
-      res.status(500).json({ error: 'Invalid Primary Key', path: req?.path });
+      this.logger.error('Invalid Primary Key', { pkParamValue, path: req?.originalUrl });
+      res.status(500).json({ error: 'Invalid Primary Key', path: req?.originalUrl });
     }
   }
 
   private configureChildRouters = (router: Router, childRouters: Record<string, Router>) => {
     for (const path in childRouters) {
-      this.logger.default('Configuring Child Router at Path', { path });
+      this.logger.debug('Configuring Child Router at Path %s', path);
 
       router.use(`/${path}`, childRouters[path]);
     }
@@ -208,14 +270,16 @@ export class ItemRouter<
   // TODO: Probably a better way to do this, but this postCreate hook only needs the item.
   /* istanbul ignore next */
   public postCreateItem = async (item: Item<S, L1, L2, L3, L4, L5>): Promise<Item<S, L1, L2, L3, L4, L5>> => {
-    this.logger.default('Post Create Item', { item });
+    this.logger.debug('Post Create Item', { item });
     return item;
   };
 
   protected deleteItem = async (req: Request, res: Response): Promise<void> => {
-    this.logger.default('Deleting Item', { query: req.query, params: req.params, locals: res.locals });
+    const libOperations = this.lib.operations;
+
+    this.logger.debug('Deleting Item', { query: req.query, params: req.params, locals: res.locals });
     const ik = this.getIk(res);
-    const removedItem = await this.lib.remove(ik);
+    const removedItem = await libOperations.remove(ik);
     const item = validatePK(removedItem, this.getPkType());
     res.json(item);
   };
@@ -228,11 +292,12 @@ export class ItemRouter<
   /* eslint-enable */
 
   protected getItem = async (req: Request, res: Response) => {
-    this.logger.default('Getting Item', { query: req.query, params: req.params, locals: res.locals });
+    const libOperations = this.lib.operations;
+    this.logger.debug('Getting Item', { query: req.query, params: req.params, locals: res.locals });
     const ik = this.getIk(res);
     try {
       // TODO: What error does validate PK throw, when can that fail?
-      const item = validatePK(await this.lib.get(ik), this.getPkType());
+      const item = validatePK(await libOperations.get(ik), this.getPkType());
       res.json(item);
     } catch (err: any) {
       if (err instanceof NotFoundError) {
@@ -252,18 +317,18 @@ export class ItemRouter<
   }
 
   protected updateItem = async (req: Request, res: Response) => {
-    this.logger.default('Updating Item',
+    const libOperations = this.lib.operations;
+    this.logger.debug('Updating Item',
       { body: req?.body, query: req?.query, params: req?.params, locals: res?.locals });
     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());
+    const itemToUpdate = this.convertDates(req.body as Partial<Item<S, L1, L2, L3, L4, L5>>);
+    const retItem = validatePK(await libOperations.update(ik, itemToUpdate), this.getPkType());
     res.json(retItem);
   };
 
-  public convertDates = (item: Item<S, L1, L2, L3, L4, L5> | ItemProperties<S, L1, L2, L3, L4, L5>):
-    Item<S, L1, L2, L3, L4, L5> | ItemProperties<S, L1, L2, L3, L4, L5> => {
+  public convertDates = (item: Partial<Item<S, L1, L2, L3, L4, L5>>): Partial<Item<S, L1, L2, L3, L4, L5>> => {
     const events = item.events as Record<string, ItemEvent>;
-    this.logger.default('Converting Dates', { item });
+    this.logger.debug('Converting Dates', { item });
     if (events) {
       Object.keys(events).forEach((key: string) => {
         Object.assign(events, {

package/src/PItemRouter.ts

@@ -2,9 +2,6 @@ import { Item, ItemQuery, paramsToQuery, PriKey, QueryParams, validatePK } from
 import { Primary } from "@fjell/lib";
 import { ItemRouter, ItemRouterOptions } from "@/ItemRouter";
 import { Request, Response } from "express";
-import LibLogger from "@/logger";
-
-const logger = LibLogger.get('PItemRouter');
 
 interface ParsedQuery {
   [key: string]: undefined | string | string[] | ParsedQuery | ParsedQuery[];
@@ -12,7 +9,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 = {}) {
+  constructor(lib: Primary.Instance<T, S>, keyType: S, options: ItemRouterOptions = {}) {
     super(lib as any, keyType, options);
   }
 
@@ -22,16 +19,18 @@ export class PItemRouter<T extends Item<S>, S extends string> extends ItemRouter
   }
 
   public createItem = async (req: Request, res: Response) => {
-    logger.default('Creating Item 2', { body: req.body, query: req.query, params: req.params, locals: res.locals });
+    const libOperations = this.lib.operations;
+    this.logger.default('Creating Item', { body: req.body, query: req.query, params: req.params, locals: res.locals });
     const itemToCreate = this.convertDates(req.body as Item<S>);
-    let item =
-      validatePK(await this.lib.create(itemToCreate), this.getPkType()) as Item<S>;
+    let item = validatePK(await libOperations.create(itemToCreate), this.getPkType()) as Item<S>;
     item = await this.postCreateItem(item);
+    this.logger.default('Created Item %j', item);
     res.json(item);
   };
 
   protected findItems = async (req: Request, res: Response) => {
-    logger.default('Finding Items', { query: req.query, params: req.params, locals: res.locals });
+    const libOperations = this.lib.operations;
+    this.logger.default('Finding Items', { query: req.query, params: req.params, locals: res.locals });
 
     let items: Item<S>[] = [];
 
@@ -42,19 +41,19 @@ export class PItemRouter<T extends Item<S>, S extends string> extends ItemRouter
 
     if (finder) {
       // If finder is defined?  Call a finder.
-      logger.default('Finding Items with a finder', { finder, finderParams, one });
+      this.logger.default('Finding Items with Finder %s %j one:%s', 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));
+        items = await libOperations.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
       const itemQuery: ItemQuery = paramsToQuery(req.query as QueryParams);
-      items = await this.lib.all(itemQuery);
+      this.logger.default('Finding Items with a query %j', itemQuery);
+      items = await libOperations.all(itemQuery);
     }
 
     res.json(items.map((item: Item<S>) => validatePK(item, this.getPkType())));

package/src/util/general.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-undefined */
+export const clean = (obj: any) => {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([_, v]) => v !== undefined)
+  );
+}
+
+//Recursive implementation of jSON.stringify;
+export const stringifyJSON = function (obj: any, visited: Set<any> = new Set()): string {
+  const arrOfKeyVals: string[] = [];
+  const arrVals: string[] = [];
+  let objKeys: string[] = [];
+
+  /*********CHECK FOR PRIMITIVE TYPES**********/
+  if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null)
+    return '' + obj;
+  else if (typeof obj === 'string')
+    return '"' + obj + '"';
+
+  /*********DETECT CIRCULAR REFERENCES**********/
+  if (obj instanceof Object && visited.has(obj)) {
+    return '"(circular)"';
+  }
+
+  /*********CHECK FOR ARRAY**********/
+  else if (Array.isArray(obj)) {
+    //check for empty array
+    if (obj[0] === undefined)
+      return '[]';
+    else {
+      // Add array to visited before processing its elements
+      visited.add(obj);
+      obj.forEach(function (el) {
+        arrVals.push(stringifyJSON(el, visited));
+      });
+      return '[' + arrVals + ']';
+    }
+  }
+  /*********CHECK FOR OBJECT**********/
+  else if (obj instanceof Object) {
+    // Add object to visited before processing its properties
+    visited.add(obj);
+    //get object keys
+    objKeys = Object.keys(obj);
+    //set key output;
+    objKeys.forEach(function (key) {
+      const keyOut = '"' + key + '":';
+      const keyValOut = obj[key];
+      //skip functions and undefined properties
+      if (keyValOut instanceof Function || keyValOut === undefined)
+        return; // Skip this entry entirely instead of pushing an empty string
+      else if (typeof keyValOut === 'string')
+        arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
+      else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null)
+        arrOfKeyVals.push(keyOut + keyValOut);
+      //check for nested objects, call recursively until no more objects
+      else if (keyValOut instanceof Object) {
+        arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));
+      }
+    });
+    return '{' + arrOfKeyVals + '}';
+  }
+  return '';
+};