@nymphjs/pubsub 1.0.0-beta.13 → 1.0.0-beta.130

package/dist/PubSub.test.js

@@ -1,39 +1,40 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = __importDefault(require("express"));
-const driver_sqlite3_1 = __importDefault(require("@nymphjs/driver-sqlite3"));
-const nymph_1 = require("@nymphjs/nymph");
-const client_node_1 = require("@nymphjs/client-node");
-const server_1 = __importDefault(require("@nymphjs/server"));
-const testArtifacts_js_1 = require("@nymphjs/server/dist/testArtifacts.js");
-const index_1 = __importDefault(require("./index"));
-const PubSub_1 = __importDefault(require("./PubSub"));
+import express from 'express';
+import ws from 'websocket';
+import SQLite3Driver from '@nymphjs/driver-sqlite3';
+import { Nymph as NymphServer } from '@nymphjs/nymph';
+import { Nymph, PubSub } from '@nymphjs/client';
+import createRestServer from '@nymphjs/server';
+import { EmployeeModel as EmployeeModelClass, Employee as EmployeeClass, RestrictedModel as RestrictedModelClass, Restricted as RestrictedClass, PubSubDisabledModel as PubSubDisabledModelClass, PubSubDisabled as PubSubDisabledClass, } from '@nymphjs/server/dist/testArtifacts.js';
+import createServer from './index.js';
+import PubSubServer from './PubSub.js';
 const sqliteConfig = {
     filename: ':memory:',
 };
 const pubSubConfig = {
     originIsAllowed: () => true,
-    entries: ['ws://localhost:5081/'],
+    entries: ['ws://localhost:5083/'],
     logger: () => { },
 };
-const nymphServer = new nymph_1.Nymph({}, new driver_sqlite3_1.default(sqliteConfig));
-const EmployeeModel = nymphServer.addEntityClass(testArtifacts_js_1.EmployeeModel);
-PubSub_1.default.initPublisher(pubSubConfig, nymphServer);
-const app = (0, express_1.default)();
-app.use((0, server_1.default)(nymphServer));
-const server = app.listen(5080);
-const pubsubServer = (0, index_1.default)(5081, pubSubConfig, nymphServer);
+const nymphServer = new NymphServer({}, new SQLite3Driver(sqliteConfig));
+const EmployeeModel = nymphServer.addEntityClass(EmployeeModelClass);
+const RestrictedModel = nymphServer.addEntityClass(RestrictedModelClass);
+const PubSubDisabledModel = nymphServer.addEntityClass(PubSubDisabledModelClass);
+const removePublisher = PubSubServer.initPublisher(pubSubConfig, nymphServer);
+const app = express();
+app.use(createRestServer(nymphServer));
+const server = app.listen(5082);
+const pubsubServer = createServer(5083, pubSubConfig, nymphServer);
 const nymphOptions = {
-    restUrl: 'http://localhost:5080/',
-    pubsubUrl: 'ws://localhost:5081/',
+    restUrl: 'http://localhost:5082/',
+    pubsubUrl: 'ws://localhost:5083/',
     noConsole: true,
+    WebSocket: ws.w3cwebsocket,
 };
-const nymph = new client_node_1.Nymph(nymphOptions);
-const pubsub = new client_node_1.PubSub(nymphOptions, nymph);
-const Employee = nymph.addEntityClass(testArtifacts_js_1.Employee);
+const nymph = new Nymph(nymphOptions);
+const pubsub = new PubSub(nymphOptions, nymph);
+const Employee = nymph.addEntityClass(EmployeeClass);
+const Restricted = nymph.addEntityClass(RestrictedClass);
+const PubSubDisabled = nymph.addEntityClass(PubSubDisabledClass);
 describe('Nymph REST Server and Client', () => {
     async function createJane() {
         const jane = await Employee.factory();
@@ -95,7 +96,7 @@ describe('Nymph REST Server and Client', () => {
                     expect('added' in update && update.added).toEqual((await jane).guid);
                     expect('data' in update && update.data.guid).toEqual((await jane).guid);
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else {
                     expect(update).toEqual([]);
@@ -123,13 +124,13 @@ describe('Nymph REST Server and Client', () => {
                         throw new Error('Update arrived before transaction committed.');
                     }
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else {
                     expect(update).toEqual([]);
                     updated = true;
                     const tnymph = await nymphServer.startTransaction('steve');
-                    const Employee = tnymph.getEntityClass(EmployeeModel.class);
+                    const Employee = tnymph.getEntityClass(EmployeeModel);
                     const steve = await Employee.factory();
                     steve.name = 'Steve Transaction';
                     steve.current = true;
@@ -170,7 +171,7 @@ describe('Nymph REST Server and Client', () => {
                     expect(update).toEqual([]);
                     updated = true;
                     const tnymph = await nymphServer.startTransaction('steve');
-                    const Employee = tnymph.getEntityClass(EmployeeModel.class);
+                    const Employee = tnymph.getEntityClass(EmployeeModel);
                     const steve = await Employee.factory();
                     steve.name = 'Steve Rollback';
                     steve.current = true;
@@ -185,7 +186,7 @@ describe('Nymph REST Server and Client', () => {
                         await tnymph.rollback('steve');
                         await new Promise((res) => setTimeout(res, 600));
                         subscription.unsubscribe();
-                        resolve(true);
+                        resolve();
                     }
                     catch (e) {
                         console.error('Error creating entity: ', e);
@@ -213,14 +214,15 @@ describe('Nymph REST Server and Client', () => {
                         throw new Error('Update arrived before transaction committed.');
                     }
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else {
                     expect(update).toEqual([]);
                     updated = true;
                     const tnymphTop = await nymphServer.startTransaction('steve-top');
+                    // Start a transaction that ultimately gets rolled back.
                     const tnymphB = await tnymphTop.startTransaction('steve-b');
-                    const EmployeeB = tnymphB.getEntityClass(EmployeeModel.class);
+                    const EmployeeB = tnymphB.getEntityClass(EmployeeModel);
                     const badSteve = await EmployeeB.factory();
                     badSteve.name = 'Steve Complex';
                     badSteve.current = true;
@@ -238,8 +240,9 @@ describe('Nymph REST Server and Client', () => {
                         console.error('Error creating entity: ', e);
                         throw e;
                     }
+                    // Start a transaction that ultimately gets committed.
                     const tnymphA = await tnymphTop.startTransaction('steve-a');
-                    const EmployeeA = tnymphA.getEntityClass(EmployeeModel.class);
+                    const EmployeeA = tnymphA.getEntityClass(EmployeeModel);
                     const goodSteve = await EmployeeA.factory();
                     goodSteve.name = 'Steve Complex';
                     goodSteve.current = true;
@@ -279,11 +282,12 @@ describe('Nymph REST Server and Client', () => {
                 pubsub.updateArray(entities, update);
                 if (mdate > 0 && (entities[0]?.mdate ?? -1) === mdate) {
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else if (Array.isArray(update)) {
                     expect(update.length).toEqual(1);
                     expect(entities[0].salary).toEqual(8000000);
+                    // Time for a raise!
                     jane.salary = (jane.salary ?? 0) + 1000000;
                     await jane.$save();
                     mdate = jane.mdate ?? 0;
@@ -310,11 +314,12 @@ describe('Nymph REST Server and Client', () => {
                 pubsub.updateArray(entities, update);
                 if (mdate > 0 && (entities[0]?.mdate ?? -1) === mdate) {
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else if (Array.isArray(update)) {
                     expect(update.length).toEqual(1);
                     expect(entities[0].salary).toEqual(8000000);
+                    // Time for a raise!
                     jane.salary = (jane.salary ?? 0) + 1000000;
                     await jane.$save();
                     mdate = jane.mdate ?? 0;
@@ -326,7 +331,14 @@ describe('Nymph REST Server and Client', () => {
     it('notified of new match for qref query', async () => {
         let [jane, john] = await createBossJane();
         let entities = [];
-        await new Promise((resolve) => {
+        // Create employees that matches qref to test when multiple things match.
+        let oldEmployee = await createJane();
+        oldEmployee.current = false;
+        await oldEmployee.$save();
+        let oldEmployee2 = await createJane();
+        oldEmployee2.current = false;
+        await oldEmployee2.$save();
+        expect(await new Promise((resolve) => {
             if (jane.guid == null || john.guid == null) {
                 throw new Error('Entity is null.');
             }
@@ -345,13 +357,100 @@ describe('Nymph REST Server and Client', () => {
                 }
                 else if (Array.isArray(update)) {
                     expect(update.length).toEqual(0);
+                    // John gets fired.
                     john.current = false;
                     await john.$save();
                 }
             });
-        });
+        })).toEqual(true);
         expect(entities.length).toEqual(1);
     });
+    it('notified of new match for qref query in transaction', async () => {
+        let entities = [];
+        const john = await EmployeeModel.factory();
+        john.name = 'John Der';
+        john.current = true;
+        john.salary = 8000000;
+        john.startDate = Date.now();
+        john.subordinates = [];
+        john.title = 'Junior Person';
+        try {
+            await john.$save();
+        }
+        catch (e) {
+            console.error('Error creating entity: ', e);
+            throw e;
+        }
+        const jane = await EmployeeModel.factory();
+        jane.name = 'Jane Doe';
+        jane.current = true;
+        jane.salary = 8000000;
+        jane.startDate = Date.now();
+        jane.subordinates = [john];
+        jane.title = 'Seniorer Person';
+        try {
+            await jane.$save();
+        }
+        catch (e) {
+            console.error('Error creating entity: ', e);
+            throw e;
+        }
+        async function createNewBoss() {
+            // Create employee that matches qref.
+            const tnymph = await nymphServer.startTransaction('qref-test');
+            const tnymphDeep = await tnymph.startTransaction('qref-deep-test');
+            const TEmployeeModel = tnymph.getEntityClass(EmployeeModel);
+            const newBoss = await TEmployeeModel.factory();
+            newBoss.name = 'Jill Doe';
+            newBoss.current = false;
+            newBoss.salary = 8000000;
+            newBoss.startDate = Date.now();
+            newBoss.subordinates = [john];
+            newBoss.title = 'Seniorer Person';
+            try {
+                await newBoss.$save();
+            }
+            catch (e) {
+                console.error('Error creating entity: ', e);
+                throw e;
+            }
+            newBoss.current = true;
+            try {
+                await newBoss.$save();
+            }
+            catch (e) {
+                console.error('Error creating entity: ', e);
+                throw e;
+            }
+            await tnymphDeep.commit('qref-deep-test');
+            await tnymph.commit('qref-test');
+        }
+        expect(await new Promise((resolve) => {
+            if (jane.guid == null || john.guid == null) {
+                throw new Error('Entity is null.');
+            }
+            const subscription = pubsub.subscribeEntities({ class: Employee }, {
+                type: '&',
+                truthy: 'current',
+                qref: [
+                    'subordinates',
+                    [{ class: Employee }, { type: '&', guid: john.guid }],
+                ],
+            })(async (update) => {
+                pubsub.updateArray(entities, update);
+                if (Array.isArray(update)) {
+                    expect(entities.length).toEqual(1);
+                    await createNewBoss();
+                }
+                else {
+                    expect(entities.length).toEqual(2);
+                    subscription.unsubscribe();
+                    resolve(true);
+                }
+            });
+        })).toEqual(true);
+        expect(entities.length).toEqual(2);
+    });
     it('notified of removed match for qref query', async () => {
         let [jane, john] = await createBossJane();
         let entities = [];
@@ -370,10 +469,11 @@ describe('Nymph REST Server and Client', () => {
                 pubsub.updateArray(entities, update);
                 if (!entities.length) {
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else if (Array.isArray(update)) {
                     expect(update.length).toEqual(1);
+                    // John gets fired.
                     john.current = false;
                     await john.$save();
                 }
@@ -384,8 +484,10 @@ describe('Nymph REST Server and Client', () => {
     it('receives correct number of updates', async () => {
         let jane = await createJane();
         let entities = [];
-        await new Promise((resolve) => setTimeout(() => resolve(true), 10));
+        // Wait for change to propagate. (Only needed since we're not going across network.)
+        await new Promise((resolve) => setTimeout(() => resolve(), 10));
         await new Promise((resolve) => {
+            // Should only receive 1 update, since we waited.
             let updated = false;
             if (jane.guid == null) {
                 throw new Error('Entity is null.');
@@ -397,12 +499,13 @@ describe('Nymph REST Server and Client', () => {
                 pubsub.updateArray(entities, update);
                 if (updated) {
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else if (Array.isArray(update)) {
                     expect(update.length).toEqual(1);
                     expect(entities[0].salary).toEqual(8000000);
                     updated = true;
+                    // Time for a raise!
                     jane.salary = (jane.salary ?? 0) + 1000000;
                     await jane.$save();
                 }
@@ -411,39 +514,39 @@ describe('Nymph REST Server and Client', () => {
         expect(entities[0].salary).toEqual(9000000);
     });
     it('notified of entity delete', async () => {
-        let jane = await createJane();
+        let jane;
         let entities = [];
-        await new Promise((resolve) => setTimeout(() => resolve(true), 10));
-        let length = -1;
+        let removed = false;
         await new Promise((resolve) => {
-            let updated = false;
-            if (jane.guid == null) {
-                throw new Error('Entity is null.');
-            }
             const subscription = pubsub.subscribeEntities({ class: Employee }, {
                 type: '&',
                 equal: ['name', 'Jane Doe'],
             })(async (update) => {
                 pubsub.updateArray(entities, update);
-                if (updated) {
-                    subscription.unsubscribe();
-                    resolve(true);
+                if (Array.isArray(update)) {
+                    jane = await createJane();
+                    if (jane.guid == null) {
+                        throw new Error('Entity is null.');
+                    }
                 }
-                else if (Array.isArray(update)) {
-                    expect(update.length).toBeGreaterThan(0);
-                    updated = true;
-                    length = update.length;
-                    await jane.$delete();
+                else if ('added' in update) {
+                    await entities.find((e) => e.guid === update.added)?.$delete();
+                }
+                else if ('removed' in update && update.removed === jane.guid) {
+                    subscription.unsubscribe();
+                    removed = true;
+                    resolve();
                 }
             });
         });
-        expect(entities.length).toEqual(length - 1);
+        expect(removed).toBeTruthy();
     });
     it('entire match is updated', async () => {
         let jane;
         let entities = [];
         await createJane();
-        await new Promise((resolve) => setTimeout(() => resolve(true), 10));
+        // Wait for change to propagate. (Only needed since we're not going across network.)
+        await new Promise((resolve) => setTimeout(() => resolve(), 10));
         await new Promise((resolve) => {
             let receivedRemove = false;
             let receivedAdd = false;
@@ -453,15 +556,20 @@ describe('Nymph REST Server and Client', () => {
             })(async (update) => {
                 pubsub.updateArray(entities, update);
                 if (jane) {
-                    if ('removed' in update) {
-                        receivedRemove = true;
-                    }
-                    if ('added' in update) {
-                        receivedAdd = true;
-                    }
-                    if (receivedAdd && receivedRemove) {
-                        subscription.unsubscribe();
-                        resolve(true);
+                    const updates = 'multiple' in update && update.multiple
+                        ? update.messages
+                        : [update];
+                    for (let curUpdate of updates) {
+                        if ('removed' in curUpdate) {
+                            receivedRemove = true;
+                        }
+                        if ('added' in curUpdate) {
+                            receivedAdd = true;
+                        }
+                        if (receivedAdd && receivedRemove) {
+                            subscription.unsubscribe();
+                            resolve();
+                        }
                     }
                 }
                 else if (Array.isArray(update)) {
@@ -478,9 +586,10 @@ describe('Nymph REST Server and Client', () => {
         await new Promise(async (resolve) => {
             let mdate = 0;
             const subscription = pubsub.subscribeWith(jane, async () => {
+                expect(jane.guid).not.toBeNull();
                 if (mdate > 0 && (jane.mdate ?? -1) === mdate) {
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
             });
             if (jane.guid == null) {
@@ -489,18 +598,75 @@ describe('Nymph REST Server and Client', () => {
             expect(jane.salary).toEqual(8000000);
             const janeDupe = await Employee.factory(jane.guid);
             expect(janeDupe.salary).toEqual(8000000);
+            // Time for a raise!
             janeDupe.salary = (janeDupe.salary ?? 0) + 1000000;
             await janeDupe.$save();
             mdate = janeDupe.mdate ?? 0;
         });
         expect(jane.salary).toEqual(9000000);
     });
+    it("doesn't allow subscription of a restricted entity class", async () => {
+        let receivedBadUpdate = false;
+        let error = null;
+        await new Promise((resolve) => {
+            pubsub.subscribeEntities({ class: Restricted }, {
+                type: '&',
+                equal: ['name', 'Jane Doe'],
+            })(async () => {
+                receivedBadUpdate = true;
+                resolve();
+            }, (e) => {
+                error = e;
+                resolve();
+            });
+        });
+        expect(receivedBadUpdate).toEqual(false);
+        expect(error).toEqual('Not accessible.');
+    });
+    it("doesn't notify of new pubsub disabled entity class", async () => {
+        let receivedBadUpdate = false;
+        await new Promise(async (resolve) => {
+            const subscription = await new Promise(async (resolve) => {
+                let updated = false;
+                const subscription = pubsub.subscribeEntities({
+                    class: PubSubDisabled,
+                })(async (update) => {
+                    if (updated) {
+                        receivedBadUpdate = true;
+                    }
+                    else {
+                        expect(update).toEqual([]);
+                        updated = true;
+                        try {
+                            const entity = await PubSubDisabled.factory();
+                            entity.name = 'Someone';
+                            try {
+                                await entity.$save();
+                            }
+                            catch (e) {
+                                throw new Error("Couldn't save.");
+                            }
+                            resolve(subscription);
+                        }
+                        catch (e) {
+                            console.error('Error creating entity: ', e);
+                            throw e;
+                        }
+                    }
+                });
+            });
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            subscription.unsubscribe();
+            resolve();
+        });
+        expect(receivedBadUpdate).toEqual(false);
+    });
     it('new uid', async () => {
         await new Promise(async (resolve) => {
             const subscription = pubsub.subscribeUID('testNewUID')(async (value) => {
                 expect(value).toEqual(directValue);
                 subscription.unsubscribe();
-                resolve(true);
+                resolve();
             }, (err) => {
                 expect(err.status).toEqual(404);
             });
@@ -508,20 +674,24 @@ describe('Nymph REST Server and Client', () => {
         });
     });
     it('increasing uids', async () => {
-        await new Promise(async (resolve) => {
+        await new Promise(async (finalResolve) => {
             let receivedFirst = false;
             let lastUpdate = 0;
+            // Don't go too fast.
+            let { promise, resolve } = Promise.withResolvers();
             const subscription = pubsub.subscribeUID('testIncUID')(async (value) => {
                 if (!receivedFirst) {
                     receivedFirst = true;
                     expect(value).toBeNull();
+                    resolve();
                     return;
                 }
                 expect(value).toEqual(lastUpdate + 1);
                 lastUpdate = value;
+                resolve();
                 if (value == 100) {
                     subscription.unsubscribe();
-                    resolve(true);
+                    finalResolve();
                 }
             }, (err) => {
                 expect(err.status).toEqual(404);
@@ -529,6 +699,8 @@ describe('Nymph REST Server and Client', () => {
             await nymph.deleteUID('testIncUID');
             let directValue = -1;
             while (directValue < 100) {
+                await promise;
+                ({ promise, resolve } = Promise.withResolvers());
                 directValue = await nymph.newUID('testIncUID');
             }
         });
@@ -538,7 +710,7 @@ describe('Nymph REST Server and Client', () => {
             const subscription = pubsub.subscribeUID('testSetUID')(async (value) => {
                 expect(value).toEqual(123);
                 subscription.unsubscribe();
-                resolve(true);
+                resolve();
             }, (err) => {
                 expect(err.status).toEqual(404);
             });
@@ -553,9 +725,9 @@ describe('Nymph REST Server and Client', () => {
                     expect(event).toEqual('renameUID');
                     expect(value).toEqual(null);
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
-                else {
+                else if (event === 'setUID') {
                     expect(value).toEqual(456);
                     updated = true;
                 }
@@ -572,7 +744,7 @@ describe('Nymph REST Server and Client', () => {
                 expect(event).toEqual('setUID');
                 expect(value).toEqual(456);
                 subscription.unsubscribe();
-                resolve(true);
+                resolve();
             }, (err) => {
                 expect(err.status).toEqual(404);
             });
@@ -588,28 +760,40 @@ describe('Nymph REST Server and Client', () => {
                 if (updated && event === 'deleteUID') {
                     expect(value).toEqual(null);
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
                 else {
                     expect(value).toEqual(789);
                     updated = true;
+                    await nymph.deleteUID('testDeleteUID');
                 }
             }, (err) => {
                 expect(err.status).toEqual(404);
             });
-            await nymph.deleteUID('testDeleteUID');
         });
     });
+    beforeEach(async () => {
+        pubsub.connect();
+        while (!pubsub.isConnectionOpen()) {
+            await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+    });
     afterAll(async () => {
+        // Don't publish anything after the tests.
+        removePublisher();
+        // Avoid jest open handle errors.
         const closed = new Promise((resolve) => {
             pubsub.on('disconnect', () => {
-                resolve(true);
+                resolve();
             });
         });
-        pubsub.close();
+        pubsub.close(); // close PubSub client.
         await closed;
-        pubsubServer.close();
-        server.close();
+        pubsubServer.close(); // close PubSub server.
+        server.close(); // close REST server.
+        // Wait for the next event loop to prevent websocket importing something
+        // after jest teardown.
+        await new Promise((resolve) => setImmediate(resolve));
     });
 });
 //# sourceMappingURL=PubSub.test.js.map