@nymphjs/server 1.0.0-beta.12 → 1.0.0-beta.120

package/src/index.test.ts

@@ -1,14 +1,16 @@
 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 createServer from './index.js';
 import {
   EmployeeModel as EmployeeModelClass,
   Employee as EmployeeClass,
-} from './testArtifacts';
+  RestrictedModel as RestrictedModelClass,
+  Restricted as RestrictedClass,
+  EmployeeData,
+} from './testArtifacts.js';
 
 const sqliteConfig = {
   filename: ':memory:',
@@ -16,15 +18,18 @@ const sqliteConfig = {
 
 const nymphServer = new NymphServer({}, new SQLite3Driver(sqliteConfig));
 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,
 });
 const Employee = nymph.addEntityClass(EmployeeClass);
+const Restricted = nymph.addEntityClass(RestrictedClass);
 
 describe('Nymph REST Server and Client', () => {
   async function createJane() {
@@ -129,7 +134,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         ref: ['subordinates', jane],
-      }
+      },
     );
 
     expect(checkSteve?.guid).toEqual(steve.guid);
@@ -142,7 +147,7 @@ describe('Nymph REST Server and Client', () => {
           'subordinates',
           [{ class: Employee }, { type: '&', guid: jane.guid }],
         ],
-      }
+      },
     );
 
     expect(checkSteveQref?.guid).toEqual(steve.guid);
@@ -156,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);
@@ -178,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 () => {
@@ -232,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();
@@ -252,7 +295,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         tag: ['employee'],
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -278,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);
@@ -307,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);
   });
@@ -326,7 +369,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         tag: 'employee',
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -352,7 +395,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         like: ['name', '%Jane%'],
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -378,7 +421,7 @@ describe('Nymph REST Server and Client', () => {
           type: '|',
           like: ['name', '%Jane%'],
         },
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -413,7 +456,7 @@ describe('Nymph REST Server and Client', () => {
             },
           ],
         },
-      }
+      },
     );
 
     expect(entities.length).toEqual(4);
@@ -438,7 +481,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         guid,
-      }
+      },
     );
 
     expect(check.length).toEqual(0);
@@ -461,7 +504,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '|',
         guid: guids,
-      }
+      },
     );
 
     expect(check.length).toEqual(0);
@@ -478,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.",
     );
   });
 
@@ -503,6 +546,25 @@ describe('Nymph REST Server and Client', () => {
     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();
 
@@ -549,6 +611,28 @@ describe('Nymph REST Server and Client', () => {
     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();
 
@@ -577,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.');
@@ -603,7 +687,7 @@ describe('Nymph REST Server and Client', () => {
       {
         class: Employee,
       },
-      first.guid
+      first.guid,
     );
 
     if (second == null || second.guid == null) {
@@ -635,7 +719,7 @@ describe('Nymph REST Server and Client', () => {
       {
         class: Employee,
       },
-      first.guid
+      first.guid,
     );
 
     if (second == null || second.guid == null) {
@@ -658,7 +742,7 @@ describe('Nymph REST Server and Client', () => {
       {
         type: '&',
         '!guid': first.guid,
-      }
+      },
     );
 
     if (third == null || third.guid == null) {
@@ -668,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');

package/src/index.ts

@@ -1,7 +1,6 @@
-import { createServer } from './createServer';
+import { createServer } from './createServer.js';
 
-export * from './HttpError';
-export * from './statusDescriptions';
-export * from './createServer';
+export * from './statusDescriptions.js';
+export * from './createServer.js';
 
 export default createServer;

package/src/testArtifacts.ts

@@ -1,8 +1,10 @@
-import { Entity as EntityServer, EntityInvalidDataError } from '@nymphjs/nymph';
+import {
+  Entity as EntityServer,
+  EntityInvalidDataError,
+  HttpError,
+} from '@nymphjs/nymph';
 import { Entity } from '@nymphjs/client';
 
-import { HttpError } from './HttpError';
-
 export type EmployeeBaseData<T> = {
   name?: string;
   id?: number;
@@ -39,7 +41,13 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     '$throwHttpError',
     '$throwHttpErrorWithDescription',
   ];
-  public static clientEnabledStaticMethods = ['testStatic', 'throwErrorStatic'];
+  public static clientEnabledStaticMethods = [
+    'testStatic',
+    'testStaticIterable',
+    'testStaticIterableAbort',
+    'throwErrorStatic',
+    'throwErrorStaticIterable',
+  ];
   protected $protectedTags = ['employee'];
   protected $allowlistTags? = ['boss', 'bigcheese'];
   protected $allowlistData? = [
@@ -57,37 +65,25 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     'building',
   ];
 
-  static async factory(
-    guid?: string
-  ): Promise<EmployeeModel & EmployeeModelData> {
-    return (await super.factory(guid)) as EmployeeModel & EmployeeModelData;
-  }
-
-  static factorySync(guid?: string): EmployeeModel & EmployeeModelData {
-    return super.factorySync(guid) as EmployeeModel & EmployeeModelData;
-  }
-
-  constructor(guid?: string) {
-    super(guid);
+  constructor() {
+    super();
 
-    if (this.guid == null) {
-      this.$addTag('employee');
-      this.$data.current = true;
-      this.$data.startDate = Date.now();
-      this.$data.subordinates = [];
-      if (!IS_MANAGER) {
-        this.$privateData.push('salary');
-      }
+    this.$addTag('employee');
+    this.$data.current = true;
+    this.$data.startDate = Date.now();
+    this.$data.subordinates = [];
+    if (!IS_MANAGER) {
+      this.$privateData.push('salary');
     }
   }
 
   public async $save() {
     // Validate employee data.
     const error = new EntityInvalidDataError('Invalid entity data.');
-    if (this.$data.name == null || this.$data.name == '') {
+    if (this.$data.name == null || this.$data.name === '') {
       error.addField('name');
     }
-    if (this.$data.title == null || this.$data.title == '') {
+    if (this.$data.title == null || this.$data.title === '') {
       error.addField('title');
     }
     if (this.$data.startDate == null) {
@@ -117,10 +113,33 @@ export class EmployeeModel extends EntityServer<EmployeeModelData> {
     return value * 2;
   }
 
+  public static *testStaticIterable(value: number) {
+    yield value + 1;
+    yield value + 2;
+    yield value + 3;
+  }
+
+  public static *testStaticIterableAbort(): Iterator<number, void, boolean> {
+    let aborted = yield 1;
+
+    if (!aborted) {
+      throw new Error(
+        "testStaticIterableAbort wasn't aborted after the first iteration.",
+      );
+    }
+  }
+
   public static throwErrorStatic() {
     throw new BadFunctionCallError('This function only throws errors.');
   }
 
+  public static *throwErrorStaticIterable() {
+    yield 1;
+    throw new BadFunctionCallError(
+      'This function throws errors after the first iteration.',
+    );
+  }
+
   public $throwError() {
     throw new BadFunctionCallError('This function only throws errors.');
   }
@@ -151,22 +170,12 @@ export class Employee extends Entity<EmployeeData> {
   // The name of the server class
   public static class = 'Employee';
 
-  constructor(guid?: string) {
-    super(guid);
-
-    if (guid == null) {
-      this.$addTag('employee');
-      this.$data.current = true;
-      this.$data.subordinates = [];
-    }
-  }
-
-  static async factory(guid?: string): Promise<Employee & EmployeeData> {
-    return (await super.factory(guid)) as Employee & EmployeeData;
-  }
+  constructor() {
+    super();
 
-  static factorySync(guid?: string): Employee & EmployeeData {
-    return super.factorySync(guid) as Employee & EmployeeData;
+    this.$addTag('employee');
+    this.$data.current = true;
+    this.$data.subordinates = [];
   }
 
   $testMethod(value: number) {
@@ -193,13 +202,133 @@ export class Employee extends Entity<EmployeeData> {
     return this.serverCallStatic('testStatic', [value]);
   }
 
+  static testStaticIterable(value: number) {
+    return this.serverCallStaticIterator('testStaticIterable', [value]);
+  }
+
+  static testStaticIterableAbort() {
+    return this.serverCallStaticIterator('testStaticIterableAbort', []);
+  }
+
   static throwErrorStatic() {
     return this.serverCallStatic('throwErrorStatic', []);
   }
 
+  static throwErrorStaticIterable() {
+    return this.serverCallStaticIterator('throwErrorStaticIterable', []);
+  }
+
   static inaccessibleMethod() {
     return this.serverCallStatic('inaccessibleMethod', []);
   }
 }
 
-export default Employee;
+export type RestrictedModelData = {
+  name: string;
+};
+
+/**
+ * This class is a test class that extends the Entity class.
+ */
+export class RestrictedModel extends EntityServer<RestrictedModelData> {
+  static ETYPE = 'restricted';
+  static class = 'Restricted';
+
+  public static restEnabled = false;
+
+  constructor() {
+    super();
+
+    this.$data.name = '';
+  }
+
+  public async $save() {
+    // Validate entity data.
+    const error = new EntityInvalidDataError('Invalid entity data.');
+    if (this.$data.name == null || this.$data.name === '') {
+      error.addField('name');
+    }
+    if (error.getFields().length) {
+      throw error;
+    }
+    return await super.$save();
+  }
+
+  $testMethod(value: string) {
+    return value;
+  }
+
+  public static testStatic(value: number) {
+    return value;
+  }
+}
+
+export type RestrictedData = {
+  name: string;
+};
+
+export class Restricted extends Entity<RestrictedData> {
+  // The name of the server class
+  public static class = 'Restricted';
+
+  constructor() {
+    super();
+
+    this.$data.name = '';
+  }
+
+  $testMethod(value: number) {
+    return this.$serverCall('$testMethod', [value]);
+  }
+
+  static testStatic(value: number) {
+    return this.serverCallStatic('testStatic', [value]);
+  }
+}
+
+export type PubSubDisabledModelData = {
+  name: string;
+};
+
+/**
+ * This class is a test class that extends the Entity class.
+ */
+export class PubSubDisabledModel extends EntityServer<PubSubDisabledModelData> {
+  static ETYPE = 'pubsub_disabled';
+  static class = 'PubSubDisabled';
+
+  public static pubSubEnabled = false;
+
+  constructor() {
+    super();
+
+    this.$data.name = '';
+  }
+
+  public async $save() {
+    // Validate entity data.
+    const error = new EntityInvalidDataError('Invalid entity data.');
+    if (this.$data.name == null || this.$data.name === '') {
+      error.addField('name');
+    }
+    if (error.getFields().length) {
+      throw error;
+    }
+    return await super.$save();
+  }
+}
+
+export type PubSubDisabledData = {
+  name: string;
+};
+
+export class PubSubDisabled extends Entity<PubSubDisabledData> {
+  // The name of the server class
+  public static class = 'PubSubDisabled';
+
+  constructor() {
+    super();
+
+    this.$data.name = '';
+  }
+}

package/tsconfig.json

@@ -2,10 +2,13 @@
   "extends": "@tsconfig/recommended/tsconfig.json",
 
   "compilerOptions": {
-    "lib": ["ES2021"],
-    "target": "ES2021",
+    "types": ["node", "jest"],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "lib": ["es2023"],
+    "target": "es2023",
     "noImplicitAny": true,
-    "removeComments": true,
+    "removeComments": false,
     "sourceMap": true,
     "outDir": "dist",
     "resolveJsonModule": true,

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.ts"]
+}

package/dist/HttpError.d.ts

@@ -1,5 +0,0 @@
-export declare class HttpError extends Error {
-    status?: number;
-    statusText?: string;
-    constructor(message: string, status?: number, statusText?: string);
-}

package/dist/HttpError.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpError = void 0;
-class HttpError extends Error {
-    constructor(message, status, statusText) {
-        super(message);
-        this.name = 'HttpError';
-        this.status = status;
-        this.statusText = statusText;
-    }
-}
-exports.HttpError = HttpError;
-//# sourceMappingURL=HttpError.js.map