jinaga-server 2.6.2 → 3.0.0

package/integration-test/jinaga-test/jinaga.test.js

@@ -1,11 +1,217 @@
 const { encode } = require("@stablelib/base64");
-const { ensure, Jinaga } = require("jinaga");
+const { buildModel, Device, User, UserName } = require("jinaga");
 const { JinagaServer } = require("./jinaga-server");
 
 const host = "db";
 // const host = "localhost";
 const connectionString = `postgresql://dev:devpw@${host}:5432/integrationtest`;
 
+class Root {
+    static Type = "IntegrationTest.Root";
+    type = Root.Type;
+
+    constructor(identifier) {
+        this.identifier = identifier;
+    }
+}
+
+class Successor {
+    static Type = "IntegrationTest.Successor";
+    type = Successor.Type;
+
+    constructor(identifier, predecessor) {
+        this.identifier = identifier;
+        this.predecessor = predecessor;
+    }
+}
+
+class UnknownType {
+    static Type = "IntegrationTest.UnknownType";
+    type = UnknownType.Type;
+
+    constructor(predecessor) {
+        this.predecessor = predecessor;
+    }
+}
+
+class Configuration {
+    static Type = "Configuration";
+    type = Configuration.Type;
+
+    constructor(from) {
+        this.from = from;
+    }
+}
+
+class Tenant {
+    static Type = "MyApplication.Tenant";
+    type = Tenant.Type;
+
+    constructor(identifier, creator) {
+        this.identifier = identifier;
+        this.creator = creator;
+    }
+}
+
+class DefaultTenant {
+    static Type = "MyApplication.DefaultTenant";
+    type = DefaultTenant.Type;
+
+    constructor(tenant, device, prior) {
+        this.tenant = tenant;
+        this.device = device;
+        this.prior = prior;
+    }
+}
+
+class Membership {
+    static Type = "MyApplication.Membership";
+    type = Membership.Type;
+
+    constructor(tenant, creator) {
+        this.tenant = tenant;
+        this.creator = creator;
+    }
+}
+
+class MembershipDeleted {
+    static Type = "MyApplication.Membership.Deleted";
+    type = MembershipDeleted.Type;
+
+    constructor(membership) {
+        this.membership = membership;
+    }
+}
+
+class MembershipRestored {
+    static Type = "MyApplication.Membership.Restored";
+    type = MembershipRestored.Type;
+
+    constructor(deleted) {
+        this.deleted = deleted;
+    }
+}
+
+const model = buildModel(b => b
+    .type(Root)
+    .type(Successor, m => m
+        .predecessor("predecessor", Root)
+    )
+    .type(UnknownType, m => m
+        .predecessor("predecessor", Root)
+    )
+    .type(User)
+    .type(UserName, m => m
+        .predecessor("user", User)
+        .predecessor("prior", UserName)
+    )
+    .type(Device)
+    .type(Configuration, m => m
+        .predecessor("from", Device)
+    )
+    .type(Tenant, m => m
+        .predecessor("creator", User)
+    )
+    .type(DefaultTenant, m => m
+        .predecessor("tenant", Tenant)
+        .predecessor("device", Device)
+        .predecessor("prior", DefaultTenant)
+    )
+    .type(Membership, m => m
+        .predecessor("tenant", Tenant)
+        .predecessor("creator", User)
+    )
+    .type(MembershipDeleted, m => m
+        .predecessor("membership", Membership)
+    )
+    .type(MembershipRestored, m => m
+        .predecessor("deleted", MembershipDeleted)
+    )
+);
+
+function randomIdentifier() {
+    const bytes = new Uint8Array(8);
+    for (let i = 0; i < 8; i++) {
+        bytes[i] = Math.random() * 0xFF;
+    }
+    return encode(bytes);
+}
+
+function randomRoot() {
+    return new Root(randomIdentifier());
+}
+
+function randomTenant(creator) {
+    return new Tenant(randomIdentifier(), creator);
+}
+
+const successorsOfRoot = model.given(Root).match((root, facts) =>
+    facts.ofType(Successor)
+        .join(s => s.predecessor, root)
+);
+
+const unknownOfRoot = model.given(Root).match((root, facts) =>
+    facts.ofType(UnknownType)
+        .join(s => s.predecessor, root)
+);
+
+const configurationFromDevice = model.given(Device).match((device, facts) =>
+    facts.ofType(Configuration)
+        .join(s => s.from, device)
+);
+
+const namesOfUser = model.given(User).match((user, facts) =>
+    facts.ofType(UserName)
+        .join(name => name.user, user)
+        .notExists(name => facts.ofType(UserName)
+            .join(next => next.prior, name)
+        )
+);
+
+const defaultTenantsOfDevice = model.given(Device).match((device, facts) =>
+    facts.ofType(DefaultTenant)
+        .join(defaultTenant => defaultTenant.device, device)
+        .notExists(defaultTenant => facts.ofType(DefaultTenant)
+            .join(next => next.prior, defaultTenant)
+        )
+);
+
+const membershipsForUser = model.given(User).match((user, facts) =>
+    facts.ofType(Membership)
+        .join(membership => membership.creator, user)
+        .notExists(membership => facts.ofType(MembershipDeleted)
+            .join(deleted => deleted.membership, membership)
+            .notExists(deleted => facts.ofType(MembershipRestored)
+                .join(restored => restored.deleted, deleted)
+            )
+        )
+);
+
+async function check(callback) {
+    const { j, close } = JinagaServer.create({
+        pgKeystore: connectionString,
+        pgStore:    connectionString
+    });
+
+    try {
+        await callback(j);
+    }
+    finally {
+        await close();
+    }
+}
+
+function authorization(a) {
+    return a
+        .type(UserName, n => n.user)
+        .type(Tenant, t => t.creator)
+        .type(DefaultTenant, t => t.tenant.creator)
+        .type(Membership, m => m.tenant.creator)
+        .type(MembershipDeleted, d => d.membership.tenant.creator)
+        .type(MembershipRestored, r => r.deleted.membership.tenant.creator)
+        ;
+}
+
 describe("Jinaga as a device", () => {
     let j;
     let close;
@@ -39,11 +245,7 @@ describe("Jinaga as a device", () => {
     it("should save a successor fact", async () => {
         const root = await j.fact(randomRoot());
 
-        const successor = await j.fact({
-            type: "IntegrationTest.Successor",
-            identifier: "test-successor",
-            predecessor: root
-        });
+        const successor = await j.fact(new Successor("test-successor", root));
 
         expect(successor.identifier).toEqual("test-successor");
         expect(successor.predecessor).toEqual(root);
@@ -52,19 +254,15 @@ describe("Jinaga as a device", () => {
     it("should query a successor fact", async () => {
         const root = await j.fact(randomRoot());
 
-        const successor = await j.fact({
-            type: "IntegrationTest.Successor",
-            identifier: "test-successor",
-            predecessor: root
-        });
-        const successors = await j.query(root, j.for(successorsOfRoot));
+        const successor = await j.fact(new Successor("test-successor", root));
+        const successors = await j.query(successorsOfRoot, root);
 
         expect(successors).toEqual([successor]);
     })
 
     it("should query a type that has never been seen", async () => {
         const root = await j.fact(randomRoot());
-        const unknown = await j.query(root, j.for(unknownOfRoot));
+        const unknown = await j.query(unknownOfRoot, root);
 
         expect(unknown).toEqual([]);
     });
@@ -72,16 +270,8 @@ describe("Jinaga as a device", () => {
     it("should save a successor fact twice", async () => {
         const root = await j.fact(randomRoot());
 
-        await j.fact({
-            type: "IntegrationTest.Successor",
-            identifier: "test-successor",
-            predecessor: root
-        });
-        const successor = await j.fact({
-            type: "IntegrationTest.Successor",
-            identifier: "test-successor",
-            predecessor: root
-        });
+        await j.fact(new Successor("test-successor", root));
+        const successor = await j.fact(new Successor("test-successor", root));
 
         expect(successor.identifier).toEqual("test-successor");
         expect(successor.predecessor).toEqual(root);
@@ -89,11 +279,7 @@ describe("Jinaga as a device", () => {
 
 
     it("should save multiple facts", async () => {
-        const successor = await j.fact({
-            type: "IntegrationTest.Successor",
-            identifier: "test-successor",
-            predecessor: randomRoot()
-        });
+        const successor = await j.fact(new Successor("test-successor", randomRoot()));
 
         expect(successor.identifier).toEqual("test-successor");
         expect(successor.predecessor.type).toEqual("IntegrationTest.Root");
@@ -108,16 +294,13 @@ describe("Jinaga as a device", () => {
     it("should get device information", async () => {
         const device = await j.local();
 
-        await j.fact({
-            type: "Configuration",
-            from: device
-        });
+        await j.fact(new Configuration(device));
 
         await check(async j => {
             const checkDevice = await j.local();
             expect(checkDevice).toEqual(device);
 
-            const configurations = await j.query(checkDevice, j.for(configurationFromDevice));
+            const configurations = await j.query(configurationFromDevice, checkDevice);
 
             expect(configurations.length).toEqual(1);
             expect(configurations[0].type).toEqual("Configuration");
@@ -139,13 +322,14 @@ describe("Jinaga as a user", () => {
             done = resolve;
         });
         ({ j: jDevice, close, withSession } = JinagaServer.create({
+            model,
             pgKeystore: connectionString,
             pgStore:    connectionString,
             authorization
         }));
         session = withSession({ user: {
             provider: "test",
-            id: "test-user",
+            id: randomIdentifier(),
             profile: {
                 displayName: "Test User"
             }
@@ -168,6 +352,8 @@ describe("Jinaga as a user", () => {
     });
 
     it("should not allow an unauthorized fact", async () => {
+        await j.login();
+
         try {
             await j.fact({
                 type: "IntegrationTest.Unauthorized",
@@ -183,15 +369,10 @@ describe("Jinaga as a user", () => {
     it("should save user name", async () => {
         const { userFact: user, profile } = await j.login();
 
-        const userName = {
-            type: "MyApplication.UserName",
-            value: profile.displayName,
-            from: user,
-            prior: []
-        };
+        const userName = new UserName([], user, profile.displayName);
         await j.fact(userName);
 
-        const userNames = await jDevice.query(user, Jinaga.for(namesOfUser));
+        const userNames = await jDevice.query(namesOfUser, user);
 
         expect(userNames.length).toEqual(1);
         expect(userNames[0].value).toEqual("Test User");
@@ -201,226 +382,61 @@ describe("Jinaga as a user", () => {
         const { userFact: user } = await j.login();
         const device = await j.local();
 
-        const defaultTenant = await j.fact({
-            type: "MyApplication.DefaultTenant",
-            tenant: {
-                type: "MyApplication.Tenant",
-                identifier: "test-tenant",
-                creator: user
-            },
-            device
-        });
+        const prior = await jDevice.query(defaultTenantsOfDevice, device);
+
+        const defaultTenant = await j.fact(new DefaultTenant(
+            randomTenant(user),
+            device,
+            prior
+        ));
 
-        const defaultTenants = await jDevice.query(device, Jinaga.for(defaultTenantsOfDevice));
+        const defaultTenants = await jDevice.query(defaultTenantsOfDevice, device);
         expect(defaultTenants).toEqual([defaultTenant]);
     });
 
     it("should find no memberships", async () => {
         const { userFact: user } = await j.login();
 
-        const memberships = await j.query(user, Jinaga.for(membershipsForUser));
+        const memberships = await j.query(membershipsForUser, user);
         expect(memberships).toEqual([]);
     });
 
     it("should find assigned membership", async () => {
         const { userFact: user } = await j.login();
 
-        const membership = await j.fact({
-            type: "MyApplication.Membership",
-            tenant: {
-                type: "MyApplication.Tenant",
-                identifier: "test-tenant",
-                creator: user
-            },
+        const membership = await j.fact(new Membership(
+            randomTenant(user),
             user
-        });
+        ));
 
-        const memberships = await j.query(user, Jinaga.for(membershipsForUser));
+        const memberships = await j.query(membershipsForUser, user);
         expect(memberships).toEqual([membership]);
     });
 
     it("should not find deleted membership", async () => {
         const { userFact: user } = await j.login();
 
-        const membership = await j.fact({
-            type: "MyApplication.Membership",
-            tenant: {
-                type: "MyApplication.Tenant",
-                identifier: "test-tenant",
-                creator: user
-            },
+        const membership = await j.fact(new Membership(
+            randomTenant(user),
             user
-        });
-        await j.fact({
-            type: "MyApplication.Membership.Deleted",
-            membership
-        });
+        ));
+        await j.fact(new MembershipDeleted(membership));
 
-        const memberships = await j.query(user, Jinaga.for(membershipsForUser));
+        const memberships = await j.query(membershipsForUser, user);
         expect(memberships).toEqual([]);
     });
 
     it("should find restored membership", async () => {
         const { userFact: user } = await j.login();
 
-        const membership = await j.fact({
-            type: "MyApplication.Membership",
-            tenant: {
-                type: "MyApplication.Tenant",
-                identifier: "test-tenant",
-                creator: user
-            },
+        const membership = await j.fact(new Membership(
+            randomTenant(user),
             user
-        });
-        const deleted = await j.fact({
-            type: "MyApplication.Membership.Deleted",
-            membership
-        });
-        await j.fact({
-            type: "MyApplication.Membership.Restored",
-            deleted
-        });
+        ));
+        const deleted = await j.fact(new MembershipDeleted(membership));
+        await j.fact(new MembershipRestored(deleted));
 
-        const memberships = await j.query(user, Jinaga.for(membershipsForUser));
+        const memberships = await j.query(membershipsForUser, user);
         expect(memberships).toEqual([membership]);
     });
-})
-
-function randomRoot() {
-    const num = Math.random();
-    const identifier = encode(num);
-
-    return {
-        type: "IntegrationTest.Root",
-        identifier
-    };
-}
-
-function successorsOfRoot(root) {
-    return Jinaga.match({
-        type: "IntegrationTest.Successor",
-        predecessor: root
-    });
-}
-
-function unknownOfRoot(root) {
-    return Jinaga.match({
-        type: "IntegrationTest.UnknownType",
-        predecessor: root
-    });
-}
-
-function configurationFromDevice(device) {
-    return Jinaga.match({
-        type: "Configuration",
-        from: device
-    });
-}
-
-function namesOfUser(user) {
-    return Jinaga.match({
-        type: "MyApplication.UserName",
-        from: user
-    }).suchThat(nameIsCurrent);
-}
-
-function nameIsCurrent(name) {
-    return Jinaga.notExists({
-        type: "MyApplication.UserName",
-        prior: [name]
-    });
-}
-
-function nameUser(name) {
-    ensure(name).has("from", "Jinaga.User");
-    return Jinaga.match(name.from);
-}
-
-function defaultTenantIsCurrent(defaultTenant) {
-    return Jinaga.notExists({
-        type: "MyApplication.DefaultTenant",
-        prior: [defaultTenant]
-    });
-}
-
-function defaultTenantsOfDevice(device) {
-    return Jinaga.match({
-        type: "MyApplication.DefaultTenant",
-        device
-    }).suchThat(defaultTenantIsCurrent);
-}
-
-function tenantCreator(tenant) {
-    ensure(tenant).has("creator", "Jinaga.User");
-    return Jinaga.match(tenant.creator);
-}
-
-function defaultTenantCreator(defaultTenant) {
-    ensure(defaultTenant)
-        .has("tenant", "MyApplication.Tenant")
-        .has("creator", "Jinaga.User");
-    return Jinaga.match(defaultTenant.tenant.creator);
-}
-
-function membershipsForUser(user) {
-    return Jinaga.match({
-        type: "MyApplication.Membership",
-        user
-    }).suchThat(Jinaga.not(membershipIsDeleted));
-}
-
-function membershipIsDeleted(membership) {
-    return Jinaga.exists({
-        type: "MyApplication.Membership.Deleted",
-        membership
-    }).suchThat(Jinaga.not(membershipIsRestored));
-}
-
-function membershipIsRestored(deleted) {
-    return Jinaga.exists({
-        type: "MyApplication.Membership.Restored",
-        deleted
-    });
-}
-
-function tenantOfMembership(membership) {
-    ensure(membership).has("tenant", "MyApplication.Tenant");
-    return Jinaga.match(membership.tenant);
-}
-
-function deletedMembership(deleted) {
-    ensure(deleted).has("membership", "MyApplication.Membership");
-    return Jinaga.match(deleted.membership);
-}
-
-function restoredMembership(restored) {
-    ensure(restored)
-        .has("deleted", "MyApplication.Membership.Deleted")
-        .has("membership", "MyApplication.Membership");
-    return Jinaga.match(restored.deleted.membership);
-}
-
-async function check(callback) {
-    const { j, close } = JinagaServer.create({
-        pgKeystore: connectionString,
-        pgStore:    connectionString
-    });
-
-    try {
-        await callback(j);
-    }
-    finally {
-        await close();
-    }
-}
-
-function authorization(a) {
-    return a
-        .type("MyApplication.UserName", Jinaga.for(nameUser))
-        .type("MyApplication.Tenant", Jinaga.for(tenantCreator))
-        .type("MyApplication.DefaultTenant", Jinaga.for(defaultTenantCreator))
-        .type("MyApplication.Membership", Jinaga.for(tenantOfMembership).then(tenantCreator))
-        .type("MyApplication.Membership.Deleted", Jinaga.for(deletedMembership).then(tenantOfMembership).then(tenantCreator))
-        .type("MyApplication.Membership.Restored", Jinaga.for(restoredMembership).then(tenantOfMembership).then(tenantCreator))
-        ;
-}
+})

package/integration-test/jinaga-test/package-lock.json

@@ -13,12 +13,9 @@
         "express": "^4.17.2",
         "jest": "^29.7.0",
         "jest-compact-reporter": "^1.2.9",
-        "jinaga": "^5.6.0",
+        "jinaga": "^6.0.0",
         "node-forge": "^1.3.0",
-        "passport": "^0.6.0",
-        "pg": "^8.11.3",
-        "tweetnacl": "^1.0.3",
-        "tweetnacl-util": "^0.15.1"
+        "pg": "^8.11.3"
       }
     },
     "node_modules/@ampproject/remapping": {
@@ -1031,9 +1028,9 @@
       }
     },
     "node_modules/@stablelib/utf8": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/@stablelib/utf8/-/utf8-1.0.1.tgz",
-      "integrity": "sha512-FrYD1xadah/TtAP6VJ04lDD5h9rdDj/d8wH/jMYTtHqZBv9z2btdvEU8vTxdjdkFmo1b/BH+t3R1wi/mYhCCNg=="
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@stablelib/utf8/-/utf8-1.0.2.tgz",
+      "integrity": "sha512-sDL1aB2U8FIpj7SjQJMxbOFIFkKvDKQGPHSrYejHZhtLNSK3qHe6ZIfa0woWkOiaJsdYslFzrc0VWXJZHmSIQQ=="
     },
     "node_modules/@stablelib/wipe": {
       "version": "1.0.1",
@@ -2894,13 +2891,13 @@
       }
     },
     "node_modules/jinaga": {
-      "version": "5.6.0",
-      "resolved": "https://registry.npmjs.org/jinaga/-/jinaga-5.6.0.tgz",
-      "integrity": "sha512-cw78Ik0TI6yq8ndAyXdlSaAeLdasPid+r+xpU0kuKXCxV43XAXxBfaoeHHG0iNrZwsq8hm1PmbYtfgb2zt39sw==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/jinaga/-/jinaga-6.0.0.tgz",
+      "integrity": "sha512-LWUCAO5L3FQgM+SBVHQYlZ2ot1TkPgdDp3SzhfmhgPN9Vapv5l15zKtUs0ggPHECvAskRMmAZIDXWHC3rt0pmg==",
       "dependencies": {
         "@stablelib/base64": "^1.0.1",
         "@stablelib/sha512": "^1.0.1",
-        "@stablelib/utf8": "^1.0.1"
+        "@stablelib/utf8": "^1.0.2"
       },
       "engines": {
         "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0"
@@ -3302,31 +3299,6 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/passport": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/passport/-/passport-0.6.0.tgz",
-      "integrity": "sha512-0fe+p3ZnrWRW74fe8+SvCyf4a3Pb2/h7gFkQ8yTJpAO50gDzlfjZUZTO1k5Eg9kUct22OxHLqDZoKUWRHOh9ug==",
-      "dependencies": {
-        "passport-strategy": "1.x.x",
-        "pause": "0.0.1",
-        "utils-merge": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4.0"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/jaredhanson"
-      }
-    },
-    "node_modules/passport-strategy": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/passport-strategy/-/passport-strategy-1.0.0.tgz",
-      "integrity": "sha512-CB97UUvDKJde2V0KDWWB3lyf6PC3FaZP7YxZ2G8OAtn9p4HI9j9JLP9qjOGZFvyl8uwNT8qM+hGnz/n16NI7oA==",
-      "engines": {
-        "node": ">= 0.4.0"
-      }
-    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -3361,11 +3333,6 @@
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
       "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ=="
     },
-    "node_modules/pause": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/pause/-/pause-0.0.1.tgz",
-      "integrity": "sha512-KG8UEiEVkR3wGEb4m5yZkVCzigAD+cVEJck2CzYZO37ZGJfctvVptVO192MwrtPhzONn6go8ylnOdMhKqi4nfg=="
-    },
     "node_modules/pg": {
       "version": "8.11.3",
       "resolved": "https://registry.npmjs.org/pg/-/pg-8.11.3.tgz",
@@ -3982,16 +3949,6 @@
         "node": ">=0.6"
       }
     },
-    "node_modules/tweetnacl": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz",
-      "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw=="
-    },
-    "node_modules/tweetnacl-util": {
-      "version": "0.15.1",
-      "resolved": "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz",
-      "integrity": "sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw=="
-    },
     "node_modules/type-detect": {
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",