@nymphjs/server 1.0.0-beta.1 → 1.0.0-beta.100

package/src/index.test.ts

@@ -1,27 +1,35 @@
 import express from 'express';
 import SQLite3Driver from '@nymphjs/driver-sqlite3';
 import { Nymph as NymphServer } from '@nymphjs/nymph';
-import { Nymph } from '@nymphjs/client-node';
-import { Entity } from '@nymphjs/client';
+import { Nymph, Entity, HttpError } from '@nymphjs/client';
 
-import createServer from './index';
-import { EmployeeModel, Employee } from './testArtifacts';
+import createServer from './index.js';
+import {
+  EmployeeModel as EmployeeModelClass,
+  Employee as EmployeeClass,
+  RestrictedModel as RestrictedModelClass,
+  Restricted as RestrictedClass,
+  EmployeeData,
+} from './testArtifacts.js';
 
 const sqliteConfig = {
   filename: ':memory:',
 };
 
 const nymphServer = new NymphServer({}, new SQLite3Driver(sqliteConfig));
-nymphServer.addEntityClass(EmployeeModel);
+const EmployeeModel = nymphServer.addEntityClass(EmployeeModelClass);
+const RestrictedModel = nymphServer.addEntityClass(RestrictedModelClass);
 
 const app = express();
 app.use('/test', createServer(nymphServer));
 const server = app.listen(5080);
 
+const REST_URL = 'http://localhost:5080/test/';
 const nymph = new Nymph({
-  restUrl: 'http://localhost:5080/test/',
+  restUrl: REST_URL,
 });
-nymph.addEntityClass(Employee);
+const Employee = nymph.addEntityClass(EmployeeClass);
+const Restricted = nymph.addEntityClass(RestrictedClass);
 
 describe('Nymph REST Server and Client', () => {
   async function createJane() {
@@ -126,7 +134,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         ref: ['subordinates', jane],
-      }
+      },
     );
 
     expect(checkSteve?.guid).toEqual(steve.guid);
@@ -139,7 +147,7 @@ describe('Nymph REST Server and Client', () => {
           'subordinates',
           [{ class: Employee }, { type: '&', guid: jane.guid }],
         ],
-      }
+      },
     );
 
     expect(checkSteveQref?.guid).toEqual(steve.guid);
@@ -153,7 +161,7 @@ describe('Nymph REST Server and Client', () => {
     expect(entity.$hasTag('test', 'test2')).toEqual(true);
     entity.$addTag('test', 'test3', 'test4', 'test5', 'test6');
     expect(entity.$hasTag('test', 'test3', 'test4', 'test5', 'test6')).toEqual(
-      true
+      true,
     );
     entity.$removeTag('test2');
     expect(!entity.$hasTag('test2')).toEqual(true);
@@ -175,10 +183,10 @@ describe('Nymph REST Server and Client', () => {
       'nymph_entity_reference',
       jane.guid,
       'Employee',
-    ]);
-    await entity.$ready();
+    ]) as EmployeeClass & EmployeeData;
+    await entity.$wake();
 
-    expect(jane?.name).toEqual('Jane Doe');
+    expect(entity?.name).toEqual('Jane Doe');
   });
 
   it('change an entity', async () => {
@@ -229,13 +237,51 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         equal: ['name', 'Jane Doe'],
-      }
+      },
     );
 
     expect(jane).not.toBeNull();
     expect(jane?.guid).not.toBeNull();
   });
 
+  it('try to get a non-existent entity', async () => {
+    let error = { status: 200 };
+    try {
+      await nymph.getEntity(
+        {
+          class: Employee,
+        },
+        {
+          type: '&',
+          equal: ['name', 'Non Existent'],
+        },
+      );
+    } catch (e: any) {
+      error = e;
+    }
+    expect(error.status).toEqual(404);
+  });
+
+  it('try to get a non-existent entity without error', async () => {
+    const nymph = new Nymph({
+      restUrl: REST_URL,
+      returnNullOnNotFound: true,
+    });
+    const Employee = nymph.addEntityClass(EmployeeClass);
+
+    const nonexistent = await nymph.getEntity(
+      {
+        class: Employee,
+      },
+      {
+        type: '&',
+        equal: ['name', 'Non Existent'],
+      },
+    );
+
+    expect(nonexistent).toBeNull();
+  });
+
   it('get entities', async () => {
     for (let i = 0; i < 4; i++) {
       await createJane();
@@ -249,7 +295,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         tag: ['employee'],
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -275,13 +321,13 @@ describe('Nymph REST Server and Client', () => {
 
     const resultSelectors = await nymph.getEntities(
       { class: Employee },
-      { type: '&', equal: ['name', 'Jane Doe'] }
+      { type: '&', equal: ['name', 'Jane Doe'] },
     );
 
     // Testing count return with selectors...
     const resultSelectorsCount = await nymph.getEntities(
       { class: Employee, return: 'count' },
-      { type: '&', equal: ['name', 'Jane Doe'] }
+      { type: '&', equal: ['name', 'Jane Doe'] },
     );
     expect(resultSelectorsCount).toBeGreaterThanOrEqual(1);
     expect(resultSelectorsCount).toEqual(resultSelectors.length);
@@ -304,7 +350,7 @@ describe('Nymph REST Server and Client', () => {
     // Testing empty count...
     const resultSelectorsEmpty = await nymph.getEntities(
       { class: Employee, return: 'count' },
-      { type: '&', tag: 'pickle' }
+      { type: '&', tag: 'pickle' },
     );
     expect(resultSelectorsEmpty).toEqual(0);
   });
@@ -323,7 +369,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         tag: 'employee',
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -349,7 +395,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         like: ['name', '%Jane%'],
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -375,7 +421,7 @@ describe('Nymph REST Server and Client', () => {
           type: '|',
           like: ['name', '%Jane%'],
         },
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -410,7 +456,7 @@ describe('Nymph REST Server and Client', () => {
             },
           ],
         },
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -435,7 +481,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         guid,
-      }
+      },
     );
 
     expect(check.length).toEqual(0);
@@ -458,7 +504,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '|',
         guid: guids,
-      }
+      },
     );
 
     expect(check.length).toEqual(0);
@@ -475,7 +521,7 @@ describe('Nymph REST Server and Client', () => {
       error = e;
     }
     expect(error.message).toEqual(
-      "Can't use Entity class directly from the front end."
+      "Can't use Entity class directly from the front end.",
     );
   });
 
@@ -490,32 +536,103 @@ describe('Nymph REST Server and Client', () => {
   });
 
   it('handle server side static error', async () => {
-    let error = { error: { name: '' } };
+    let error = { status: 0, error: { name: '' } };
     try {
       await Employee.throwErrorStatic();
     } catch (e: any) {
       error = e;
     }
+    expect(error.status).toEqual(500);
+    expect(error.error.name).toEqual('BadFunctionCallError');
+  });
+
+  it('handle server side static iterator error', async () => {
+    let error: any = { status: 0, error: { name: '' } };
+    const data = await Employee.throwErrorStaticIterable();
+
+    let count = 0;
+    for await (let value of data) {
+      count++;
+      if (value instanceof Error) {
+        error = value;
+      } else {
+        expect(value).toEqual(count);
+      }
+    }
+
+    expect(count).toEqual(2);
+    expect(error.status).toEqual(500);
     expect(error.error.name).toEqual('BadFunctionCallError');
   });
 
   it('handle server side error', async () => {
     const jane = await createJane();
 
-    let error = { error: { name: '' } };
+    let error = { status: 0, error: { name: '' } };
     try {
       await jane.$throwError();
     } catch (e: any) {
       error = e;
     }
+    expect(error.status).toEqual(500);
     expect(error.error.name).toEqual('BadFunctionCallError');
   });
 
+  it('handle server side HTTP error', async () => {
+    const jane = await createJane();
+
+    let error = { status: 0, statusText: '', message: '' };
+    try {
+      await jane.$throwHttpError();
+    } catch (e: any) {
+      error = e;
+    }
+    expect(error.status).toEqual(501);
+    expect(error.statusText).toEqual('Not Implemented');
+    expect(error.message).toEqual('A 501 HTTP error.');
+  });
+
+  it('handle server side custom HTTP error', async () => {
+    const jane = await createJane();
+
+    let error = { status: 0, statusText: '', message: '' };
+    try {
+      await jane.$throwHttpErrorWithDescription();
+    } catch (e: any) {
+      error = e;
+    }
+    expect(error.status).toEqual(512);
+    expect(error.statusText).toEqual('Some Error');
+    expect(error.message).toEqual('A 512 HTTP error.');
+  });
+
   it('call a server side static method', async () => {
     const data = await Employee.testStatic(5);
     expect(data).toEqual(10);
   });
 
+  it('call a server side static iterator method', async () => {
+    const data = await Employee.testStaticIterable(5);
+
+    let count = 0;
+    for await (let value of data) {
+      count++;
+      expect(value).toEqual(5 + count);
+    }
+
+    expect(count).toEqual(3);
+  });
+
+  it('aborts a server side static iterator method', async () => {
+    const data = await Employee.testStaticIterableAbort();
+    data.abortController.abort();
+
+    // Wait 1 second to ensure server receives abort signal.
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    expect(true).toBeTruthy();
+  });
+
   it('call a stateless server side method', async () => {
     const jane = await createJane();
 
@@ -544,7 +661,7 @@ describe('Nymph REST Server and Client', () => {
       {
         class: Employee,
       },
-      jane1.guid
+      jane1.guid,
     );
     if (jane1 == null || jane2 == null) {
       throw new Error('Entity is null.');
@@ -570,7 +687,7 @@ describe('Nymph REST Server and Client', () => {
       {
         class: Employee,
       },
-      first.guid
+      first.guid,
     );
 
     if (second == null || second.guid == null) {
@@ -602,7 +719,7 @@ describe('Nymph REST Server and Client', () => {
       {
         class: Employee,
       },
-      first.guid
+      first.guid,
     );
 
     if (second == null || second.guid == null) {
@@ -625,7 +742,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         '!guid': first.guid,
-      }
+      },
     );
 
     if (third == null || third.guid == null) {
@@ -635,6 +752,66 @@ describe('Nymph REST Server and Client', () => {
     expect(first.$is(third)).toEqual(false);
   });
 
+  it("doesn't allow creation of a restricted entity class", async () => {
+    const attempt = await Restricted.factory();
+    attempt.name = 'Jane Doe';
+
+    let error = null;
+
+    try {
+      await attempt.$save();
+    } catch (e: any) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(HttpError);
+    expect(error.status).toEqual(403);
+  });
+
+  it("doesn't allow search of a restricted entity class", async () => {
+    let error = null;
+
+    try {
+      await nymph.getEntity({
+        class: Restricted,
+      });
+    } catch (e: any) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(HttpError);
+    expect(error.status).toEqual(403);
+  });
+
+  it("doesn't allow methods of a restricted entity class", async () => {
+    const attempt = await Restricted.factory();
+    attempt.name = 'Jane Doe';
+
+    let error = null;
+
+    try {
+      await attempt.$testMethod(1);
+    } catch (e: any) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(HttpError);
+    expect(error.status).toEqual(403);
+  });
+
+  it("doesn't allow static methods of a restricted entity class", async () => {
+    let error = null;
+
+    try {
+      await Restricted.testStatic(1);
+    } catch (e: any) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(HttpError);
+    expect(error.status).toEqual(403);
+  });
+
   it('get a new UID', async () => {
     const uidValue = await nymph.newUID('employee');
     expect(typeof uidValue).toEqual('number');