@nymphjs/pubsub 1.0.0-beta.11 → 1.0.0-beta.111

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([]);
@@ -105,6 +106,167 @@ describe('Nymph REST Server and Client', () => {
             });
         });
     });
+    it('notified of new match only after transaction committed', async () => {
+        let guid;
+        let committed = false;
+        await new Promise((resolve) => {
+            let updated = false;
+            const subscription = pubsub.subscribeEntities({ class: Employee }, {
+                type: '&',
+                equal: ['name', 'Steve Transaction'],
+            })(async (update) => {
+                if (updated) {
+                    if (committed) {
+                        expect('added' in update && update.added).toEqual(guid);
+                        expect('data' in update && update.data.guid).toEqual(guid);
+                    }
+                    else {
+                        throw new Error('Update arrived before transaction committed.');
+                    }
+                    subscription.unsubscribe();
+                    resolve();
+                }
+                else {
+                    expect(update).toEqual([]);
+                    updated = true;
+                    const tnymph = await nymphServer.startTransaction('steve');
+                    const Employee = tnymph.getEntityClass(EmployeeModel);
+                    const steve = await Employee.factory();
+                    steve.name = 'Steve Transaction';
+                    steve.current = true;
+                    steve.salary = 8000000;
+                    steve.startDate = Date.now();
+                    steve.subordinates = [];
+                    steve.title = 'Seniorer Person';
+                    try {
+                        await steve.$save();
+                        guid = steve.guid;
+                        await new Promise((res) => setTimeout(res, 1000));
+                        committed = true;
+                        await tnymph.commit('steve');
+                    }
+                    catch (e) {
+                        console.error('Error creating entity: ', e);
+                        throw e;
+                    }
+                }
+            });
+        });
+    });
+    it('not notified of new match when transaction rolled back', async () => {
+        let guid;
+        await new Promise((resolve) => {
+            let updated = false;
+            const subscription = pubsub.subscribeEntities({ class: Employee }, {
+                type: '&',
+                equal: ['name', 'Steve Rollback'],
+            })(async (update) => {
+                if (updated) {
+                    if ('added' in update && update.added === guid) {
+                        throw new Error('Update arrived after transaction rolled back.');
+                    }
+                    throw new Error('Update arrived unrelated to transaction.');
+                }
+                else {
+                    expect(update).toEqual([]);
+                    updated = true;
+                    const tnymph = await nymphServer.startTransaction('steve');
+                    const Employee = tnymph.getEntityClass(EmployeeModel);
+                    const steve = await Employee.factory();
+                    steve.name = 'Steve Rollback';
+                    steve.current = true;
+                    steve.salary = 8000000;
+                    steve.startDate = Date.now();
+                    steve.subordinates = [];
+                    steve.title = 'Seniorer Person';
+                    try {
+                        await steve.$save();
+                        guid = steve.guid;
+                        await new Promise((res) => setTimeout(res, 600));
+                        await tnymph.rollback('steve');
+                        await new Promise((res) => setTimeout(res, 600));
+                        subscription.unsubscribe();
+                        resolve();
+                    }
+                    catch (e) {
+                        console.error('Error creating entity: ', e);
+                        throw e;
+                    }
+                }
+            });
+        });
+    });
+    it('notified of new match after complex transactions committed', async () => {
+        let guid;
+        let committed = false;
+        await new Promise((resolve) => {
+            let updated = false;
+            const subscription = pubsub.subscribeEntities({ class: Employee }, {
+                type: '&',
+                equal: ['name', 'Steve Complex'],
+            })(async (update) => {
+                if (updated) {
+                    if (committed) {
+                        expect('added' in update && update.added).toEqual(guid);
+                        expect('data' in update && update.data.guid).toEqual(guid);
+                    }
+                    else {
+                        throw new Error('Update arrived before transaction committed.');
+                    }
+                    subscription.unsubscribe();
+                    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);
+                    const badSteve = await EmployeeB.factory();
+                    badSteve.name = 'Steve Complex';
+                    badSteve.current = true;
+                    badSteve.salary = 8000000;
+                    badSteve.startDate = Date.now();
+                    badSteve.subordinates = [];
+                    badSteve.title = 'Seniorer Person';
+                    try {
+                        await badSteve.$save();
+                        await new Promise((res) => setTimeout(res, 200));
+                        await tnymphB.rollback('steve-b');
+                        await new Promise((res) => setTimeout(res, 200));
+                    }
+                    catch (e) {
+                        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);
+                    const goodSteve = await EmployeeA.factory();
+                    goodSteve.name = 'Steve Complex';
+                    goodSteve.current = true;
+                    goodSteve.salary = 8000000;
+                    goodSteve.startDate = Date.now();
+                    goodSteve.subordinates = [];
+                    goodSteve.title = 'Seniorer Person';
+                    try {
+                        await goodSteve.$save();
+                        guid = goodSteve.guid;
+                        await new Promise((res) => setTimeout(res, 200));
+                        await tnymphA.commit('steve-a');
+                        await new Promise((res) => setTimeout(res, 400));
+                        committed = true;
+                        await tnymphTop.commit('steve-top');
+                    }
+                    catch (e) {
+                        console.error('Error creating entity: ', e);
+                        throw e;
+                    }
+                }
+            });
+        });
+    });
     it('notified of entity update', async () => {
         let jane = await createJane();
         let entities = [];
@@ -120,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;
@@ -151,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;
@@ -167,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.');
             }
@@ -186,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 = [];
@@ -211,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();
                 }
@@ -225,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.');
@@ -238,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();
                 }
@@ -252,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;
@@ -302,7 +564,7 @@ describe('Nymph REST Server and Client', () => {
                     }
                     if (receivedAdd && receivedRemove) {
                         subscription.unsubscribe();
-                        resolve(true);
+                        resolve();
                     }
                 }
                 else if (Array.isArray(update)) {
@@ -319,9 +581,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) {
@@ -330,18 +593,72 @@ 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';
+                            if (!(await entity.$save())) {
+                                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);
             });
@@ -362,7 +679,7 @@ describe('Nymph REST Server and Client', () => {
                 lastUpdate = value;
                 if (value == 100) {
                     subscription.unsubscribe();
-                    resolve(true);
+                    resolve();
                 }
             }, (err) => {
                 expect(err.status).toEqual(404);
@@ -379,7 +696,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);
             });
@@ -394,9 +711,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;
                 }
@@ -413,7 +730,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);
             });
@@ -429,28 +746,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