@nymphjs/server 1.0.0-alpha.2 → 1.0.0-alpha.23

package/src/index.ts

@@ -10,24 +10,47 @@ import {
   EntityPatch,
   EntityReference,
   InvalidParametersError,
+  TilmeldAccessLevels,
 } from '@nymphjs/nymph';
 import { EntityInvalidDataError } from '@nymphjs/nymph';
 
+type NymphResponse = Response<any, { nymph: Nymph }>;
+
+const NOT_FOUND_ERROR = 'Entity is not found.';
+
+/**
+ * A REST server middleware creator for Nymph.
+ *
+ * Written by Hunter Perrin for SciActive.
+ *
+ * @author Hunter Perrin <hperrin@gmail.com>
+ * @copyright SciActive Inc
+ * @see http://nymph.io/
+ */
 export default function createServer(nymph: Nymph) {
   const rest = express();
   rest.use(cookieParser());
   rest.use(express.json());
 
+  function instantiateNymph(
+    _request: Request,
+    response: NymphResponse,
+    next: NextFunction
+  ) {
+    response.locals.nymph = nymph.clone();
+    next();
+  }
+
   function authenticateTilmeld(
     request: Request,
-    response: Response,
+    response: NymphResponse,
     next: NextFunction
   ) {
-    if (nymph.tilmeld) {
-      nymph.tilmeld.request = request;
-      nymph.tilmeld.response = response;
+    if (response.locals.nymph.tilmeld) {
+      response.locals.nymph.tilmeld.request = request;
+      response.locals.nymph.tilmeld.response = response;
       try {
-        nymph.tilmeld.authenticate();
+        response.locals.nymph.tilmeld.authenticate();
       } catch (e: any) {
         httpError(response, 500, 'Internal Server Error', e);
         return;
@@ -38,14 +61,14 @@ export default function createServer(nymph: Nymph) {
 
   function unauthenticateTilmeld(
     _request: Request,
-    response: Response,
+    response: NymphResponse,
     next: NextFunction
   ) {
-    if (nymph.tilmeld) {
-      nymph.tilmeld.request = null;
-      nymph.tilmeld.response = null;
+    if (response.locals.nymph.tilmeld) {
+      response.locals.nymph.tilmeld.request = null;
+      response.locals.nymph.tilmeld.response = null;
       try {
-        nymph.tilmeld.clearSession();
+        response.locals.nymph.tilmeld.clearSession();
       } catch (e: any) {
         httpError(response, 500, 'Internal Server Error', e);
         return;
@@ -77,10 +100,13 @@ export default function createServer(nymph: Nymph) {
     }
   }
 
+  // Create a new instance of Nymph for the request/response.
+  rest.use(instantiateNymph);
+
   // Authenticate before the request.
   rest.use(authenticateTilmeld);
 
-  rest.get('/', async (request, response) => {
+  rest.get('/', async (request, response: NymphResponse) => {
     try {
       const { action, data } = getActionData(request);
       if (['entity', 'entities', 'uid'].indexOf(action) === -1) {
@@ -103,7 +129,7 @@ export default function createServer(nymph: Nymph) {
         }
         let EntityClass;
         try {
-          EntityClass = nymph.getEntityClass(data[0].class);
+          EntityClass = response.locals.nymph.getEntityClass(data[0].class);
         } catch (e: any) {
           httpError(response, 400, 'Bad Request', e);
           return;
@@ -119,16 +145,22 @@ export default function createServer(nymph: Nymph) {
           | null;
         try {
           if (action === 'entity') {
-            result = await nymph.getEntity(data[0], ...data.slice(1));
+            result = await response.locals.nymph.getEntity(
+              data[0],
+              ...data.slice(1)
+            );
           } else {
-            result = await nymph.getEntities(...data);
+            result = await response.locals.nymph.getEntities(...data);
           }
         } catch (e: any) {
           httpError(response, 500, 'Internal Server Error', e);
           return;
         }
         if (result === [] || result == null) {
-          if (action === 'entity' || nymph.config.emptyListError) {
+          if (
+            action === 'entity' ||
+            response.locals.nymph.config.emptyListError
+          ) {
             httpError(response, 404, 'Not Found');
             return;
           }
@@ -136,9 +168,24 @@ export default function createServer(nymph: Nymph) {
         response.setHeader('Content-Type', 'application/json');
         response.send(JSON.stringify(result));
       } else {
+        if (typeof data !== 'string') {
+          httpError(response, 400, 'Bad Request');
+          return;
+        }
+        if (response.locals.nymph.tilmeld) {
+          if (
+            !response.locals.nymph.tilmeld.checkClientUIDPermissions(
+              data,
+              TilmeldAccessLevels.READ_ACCESS
+            )
+          ) {
+            httpError(response, 403, 'Forbidden');
+            return;
+          }
+        }
         let result: number | null;
         try {
-          result = await nymph.getUID(`${data}`);
+          result = await response.locals.nymph.getUID(data);
         } catch (e: any) {
           httpError(response, 500, 'Internal Server Error', e);
           return;
@@ -159,7 +206,7 @@ export default function createServer(nymph: Nymph) {
     }
   });
 
-  rest.post('/', async (request, response) => {
+  rest.post('/', async (request, response: NymphResponse) => {
     try {
       const { action, data: dataConst } = getActionData(request);
       let data = dataConst;
@@ -175,6 +222,7 @@ export default function createServer(nymph: Nymph) {
         let hadSuccess = false;
         let invalidRequest = false;
         let conflict = false;
+        let notfound = false;
         let lastException = null;
         for (let entData of data) {
           if (entData.guid) {
@@ -184,10 +232,12 @@ export default function createServer(nymph: Nymph) {
           }
           let entity: EntityInterface;
           try {
-            entity = await loadEntity(entData);
+            entity = await loadEntity(entData, response.locals.nymph);
           } catch (e: any) {
             if (e instanceof EntityConflictError) {
               conflict = true;
+            } else if (e.message === NOT_FOUND_ERROR) {
+              notfound = true;
             } else if (e instanceof InvalidParametersError) {
               invalidRequest = true;
               lastException = e;
@@ -225,6 +275,9 @@ export default function createServer(nymph: Nymph) {
           } else if (conflict) {
             httpError(response, 409, 'Conflict');
             return;
+          } else if (notfound) {
+            httpError(response, 404, 'Not Found');
+            return;
           } else {
             httpError(response, 500, 'Internal Server Error', lastException);
             return;
@@ -242,11 +295,14 @@ export default function createServer(nymph: Nymph) {
           httpError(response, 400, 'Bad Request');
           return;
         }
-        const params = referencesToEntities([...data.params]);
+        const params = referencesToEntities(
+          [...data.params],
+          response.locals.nymph
+        );
         if (data.static) {
           let EntityClass: EntityConstructor;
           try {
-            EntityClass = nymph.getEntityClass(data.class);
+            EntityClass = response.locals.nymph.getEntityClass(data.class);
           } catch (e: any) {
             httpError(response, 400, 'Bad Request');
             return;
@@ -283,10 +339,12 @@ export default function createServer(nymph: Nymph) {
         } else {
           let entity: EntityInterface;
           try {
-            entity = await loadEntity(data.entity);
+            entity = await loadEntity(data.entity, response.locals.nymph);
           } catch (e: any) {
             if (e instanceof EntityConflictError) {
               httpError(response, 409, 'Conflict');
+            } else if (e.message === NOT_FOUND_ERROR) {
+              httpError(response, 404, 'Not Found', e);
             } else if (e instanceof InvalidParametersError) {
               httpError(response, 400, 'Bad Request', e);
             } else {
@@ -328,9 +386,24 @@ export default function createServer(nymph: Nymph) {
           }
         }
       } else {
+        if (typeof data !== 'string') {
+          httpError(response, 400, 'Bad Request');
+          return;
+        }
+        if (response.locals.nymph.tilmeld) {
+          if (
+            !response.locals.nymph.tilmeld.checkClientUIDPermissions(
+              data,
+              TilmeldAccessLevels.WRITE_ACCESS
+            )
+          ) {
+            httpError(response, 403, 'Forbidden');
+            return;
+          }
+        }
         let result: number | null;
         try {
-          result = await nymph.newUID(`${data}`);
+          result = await response.locals.nymph.newUID(data);
         } catch (e: any) {
           httpError(response, 500, 'Internal Server Error', e);
           return;
@@ -349,7 +422,7 @@ export default function createServer(nymph: Nymph) {
     }
   });
 
-  rest.put('/', async (request, response) => {
+  rest.put('/', async (request, response: NymphResponse) => {
     try {
       const { action, data } = getActionData(request);
       if (['entity', 'entities', 'uid'].indexOf(action) === -1) {
@@ -363,7 +436,7 @@ export default function createServer(nymph: Nymph) {
     }
   });
 
-  rest.patch('/', async (request, response) => {
+  rest.patch('/', async (request, response: NymphResponse) => {
     try {
       const { action, data } = getActionData(request);
       if (['entity', 'entities'].indexOf(action) === -1) {
@@ -378,7 +451,7 @@ export default function createServer(nymph: Nymph) {
   });
 
   async function doPutOrPatch(
-    response: Response,
+    response: NymphResponse,
     action: string,
     data: any,
     patch: boolean
@@ -388,9 +461,20 @@ export default function createServer(nymph: Nymph) {
         httpError(response, 400, 'Bad Request');
         return;
       }
+      if (response.locals.nymph.tilmeld) {
+        if (
+          !response.locals.nymph.tilmeld.checkClientUIDPermissions(
+            data.name,
+            TilmeldAccessLevels.FULL_ACCESS
+          )
+        ) {
+          httpError(response, 403, 'Forbidden');
+          return;
+        }
+      }
       let result: boolean;
       try {
-        result = await nymph.setUID(data.name, data.value);
+        result = await response.locals.nymph.setUID(data.name, data.value);
       } catch (e: any) {
         httpError(response, 500, 'Internal Server Error', e);
         return;
@@ -420,14 +504,17 @@ export default function createServer(nymph: Nymph) {
         }
         let entity: EntityInterface;
         try {
-          entity = await loadEntity(entData, patch);
+          entity = await loadEntity(entData, response.locals.nymph, patch);
         } catch (e: any) {
           if (e instanceof EntityConflictError) {
             conflict = true;
-          }
-          if (e instanceof InvalidParametersError) {
+          } else if (e.message === NOT_FOUND_ERROR) {
+            notfound = true;
+          } else if (e instanceof InvalidParametersError) {
             invalidRequest = true;
             lastException = e;
+          } else {
+            lastException = e;
           }
           saved.push(null);
           continue;
@@ -475,7 +562,7 @@ export default function createServer(nymph: Nymph) {
     }
   }
 
-  rest.delete('/', async (request, response) => {
+  rest.delete('/', async (request, response: NymphResponse) => {
     try {
       const { action, data: dataConst } = getActionData(request);
       let data = dataConst;
@@ -489,28 +576,56 @@ export default function createServer(nymph: Nymph) {
         }
         const deleted = [];
         let failures = false;
+        let hadSuccess = false;
         let invalidRequest = false;
+        let notfound = false;
         let lastException = null;
-        for (let delEnt of data) {
+        for (let entData of data) {
+          if (entData.guid && entData.guid.length != 24) {
+            invalidRequest = true;
+            continue;
+          }
+          let EntityClass: EntityConstructor;
           try {
-            const guid = delEnt.guid;
-            if (!delEnt.guid) {
-              invalidRequest = true;
-              continue;
-            }
-            if (await nymph.deleteEntityByID(guid, delEnt.class)) {
-              deleted.push(guid);
+            EntityClass = response.locals.nymph.getEntityClass(entData.class);
+          } catch (e: any) {
+            invalidRequest = true;
+            failures = true;
+            continue;
+          }
+          let entity: EntityInterface | null;
+          try {
+            entity = await response.locals.nymph.getEntity(
+              { class: EntityClass },
+              { type: '&', guid: entData.guid }
+            );
+          } catch (e: any) {
+            lastException = e;
+            failures = true;
+            continue;
+          }
+          if (!entity) {
+            notfound = true;
+            failures = true;
+            continue;
+          }
+          try {
+            if (await entity.$delete()) {
+              deleted.push(entData.guid);
+              hadSuccess = true;
             } else {
               failures = true;
             }
           } catch (e: any) {
-            failures = true;
             lastException = e;
+            failures = true;
           }
         }
         if (deleted.length === 0) {
           if (invalidRequest || !failures) {
-            httpError(response, 400, 'Bad Request');
+            httpError(response, 400, 'Bad Request', lastException);
+          } else if (notfound) {
+            httpError(response, 404, 'Not Found');
           } else {
             httpError(response, 500, 'Internal Server Error', lastException);
           }
@@ -528,9 +643,20 @@ export default function createServer(nymph: Nymph) {
           httpError(response, 400, 'Bad Request');
           return;
         }
+        if (response.locals.nymph.tilmeld) {
+          if (
+            !response.locals.nymph.tilmeld.checkClientUIDPermissions(
+              data,
+              TilmeldAccessLevels.FULL_ACCESS
+            )
+          ) {
+            httpError(response, 403, 'Forbidden');
+            return;
+          }
+        }
         let result: boolean;
         try {
-          result = await nymph.deleteUID(data);
+          result = await response.locals.nymph.deleteUID(data);
         } catch (e: any) {
           httpError(response, 500, 'Internal Server Error', e);
           return;
@@ -554,6 +680,7 @@ export default function createServer(nymph: Nymph) {
 
   async function loadEntity(
     entityData: EntityJson | EntityPatch,
+    nymph: Nymph,
     patch = false,
     allowConflict = false
   ): Promise<EntityInterface> {
@@ -574,7 +701,7 @@ export default function createServer(nymph: Nymph) {
         }
       );
       if (entity === null) {
-        throw new Error('Entity is not found.');
+        throw new Error(NOT_FOUND_ERROR);
       }
     } else {
       entity = await EntityClass.factory();
@@ -595,7 +722,7 @@ export default function createServer(nymph: Nymph) {
    * @param item The item to check.
    * @returns The item, converted.
    */
-  function referencesToEntities(item: any): any {
+  function referencesToEntities(item: any, nymph: Nymph): any {
     if (Array.isArray(item)) {
       if (item.length === 3 && item[0] === 'nymph_entity_reference') {
         try {
@@ -605,12 +732,12 @@ export default function createServer(nymph: Nymph) {
           return item;
         }
       }
-      return item.map((entry) => referencesToEntities(entry));
+      return item.map((entry) => referencesToEntities(entry, nymph));
     } else if (typeof item === 'object' && !(item instanceof Entity)) {
       // Only do this for non-entity objects.
       const newItem: { [k: string]: any } = {};
       for (let curProperty in item) {
-        newItem[curProperty] = referencesToEntities(item[curProperty]);
+        newItem[curProperty] = referencesToEntities(item[curProperty], nymph);
       }
       return newItem;
     }
@@ -625,7 +752,7 @@ export default function createServer(nymph: Nymph) {
    * @param error An optional exception object to report.
    */
   function httpError(
-    res: Response,
+    res: NymphResponse,
     errorCode: number,
     message: string,
     error?: Error

package/src/testArtifacts.ts

@@ -1,8 +1,4 @@
-import nymphServer, {
-  Entity as EntityServer,
-  EntityInvalidDataError,
-} from '@nymphjs/nymph';
-import { Nymph } from '@nymphjs/client-node';
+import { Entity as EntityServer, EntityInvalidDataError } from '@nymphjs/nymph';
 import { Entity } from '@nymphjs/client';
 
 export type EmployeeBaseData<T> = {
@@ -98,7 +94,7 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     }
     // Generate employee ID.
     if (this.$data.id == null) {
-      this.$data.id = (await nymphServer.newUID('employee')) ?? undefined;
+      this.$data.id = (await this.$nymph.newUID('employee')) ?? undefined;
     }
     return await super.$save();
   }
@@ -130,8 +126,6 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
   }
 }
 
-nymphServer.setEntityClass(EmployeeModel.class, EmployeeModel);
-
 export class BadFunctionCallError extends Error {
   constructor(message: string) {
     super(message);
@@ -188,5 +182,4 @@ export class Employee extends Entity<EmployeeData> {
   }
 }
 
-Nymph.setEntityClass(Employee.class, Employee);
 export default Employee;