jinaga-server 2.6.2 → 3.0.1

package/src/postgres/query-description.ts

@@ -1,5 +1,5 @@
 import { FactReference, Label, Match, PathCondition } from "jinaga";
-import { FactTypeMap, RoleMap, ensureGetFactTypeId, getFactTypeId, getRoleId } from "./maps";
+import { FactTypeMap, RoleMap, getFactTypeId, getRoleId } from "./maps";
 
 export interface FactDescription {
     type: string;
@@ -323,9 +323,13 @@ export class QueryDescriptionBuider {
             if (givenIndex < 0) {
                 throw new Error(`No input parameter found for label ${condition.labelRight}`);
             }
+            const factTypeId = getFactTypeId(this.factTypes, start[givenIndex].type);
+            if (!factTypeId) {
+                return { queryDescription: QueryDescription.unsatisfiable, knownFacts };
+            }
             const { queryDescription: newQueryDescription, factDescription } = queryDescription.withInputParameter(
                 given[givenIndex],
-                ensureGetFactTypeId(this.factTypes, start[givenIndex].type),
+                factTypeId,
                 start[givenIndex].hash,
                 path
             );

package/test/authorization/authorizationSpec.ts

@@ -1,21 +1,59 @@
 import {
-    AuthenticationNoOp,
     AuthorizationRules,
+    buildModel,
     dehydrateFact,
-    ensure,
+    FactEnvelope,
     FactManager,
     FactRecord,
     hydrate,
-    Jinaga as j,
     MemoryStore,
     NetworkNoOp,
     ObservableSource,
-    PassThroughFork
+    PassThroughFork,
+    User
 } from "jinaga";
 
 import { AuthorizationKeystore } from "../../src/authorization/authorization-keystore";
 import { MemoryKeystore } from "../../src/memory/memory-keystore";
 
+class Hashtag {
+    public static Type = "Hashtag" as const;
+    public type = Hashtag.Type;
+
+    constructor(
+        public word: string
+    ) { }
+}
+
+class Tweet {
+    public static Type = "Tweet" as const;
+    public type = Tweet.Type;
+
+    constructor(
+        public message: string,
+        public sender: User
+    ) { }
+}
+
+class Like {
+    public static Type = "Like" as const;
+    public type = Like.Type;
+
+    constructor(
+        public user: User,
+        public tweet: Tweet
+    ) { }
+}
+
+class Delete {
+    public static Type = "Delete" as const;
+    public type = Delete.Type;
+
+    constructor(
+        public tweet: Tweet
+    ) { }
+}
+
 describe('Authorization', () => {
     it('should authorize empty save', async () => {
         const authorization = givenAuthorization();
@@ -25,19 +63,13 @@ describe('Authorization', () => {
 
     it('should save a new fact', async () => {
         const authorization = givenAuthorization();
-        const result = await whenSave(authorization, dehydrateFact({
-            type: 'Hashtag',
-            word: 'vorpal'
-        }));
+        const result = await whenSave(authorization, dehydrateFact(new Hashtag('vorpal')));
         expect(result.length).toEqual(1);
     });
 
     it('should save a fact once', async () => {
         const authorization = givenAuthorization();
-        const facts = dehydrateFact({
-            type: 'Hashtag',
-            word: 'vorpal'
-        });
+        const facts = dehydrateFact(new Hashtag('vorpal'));
         await whenSave(authorization, facts);
         const result = await whenSave(authorization, facts);
         expect(result.length).toEqual(0);
@@ -46,64 +78,36 @@ describe('Authorization', () => {
     it('should reject a fact from an unauthorized user', async () => {
         const authorization = givenAuthorization();
         const mickeyMouse = givenOtherUser();
-        const promise = whenSave(authorization, dehydrateFact({
-            type: 'Tweet',
-            message: 'Twas brillig',
-            sender: mickeyMouse
-        }));
+        const promise = whenSave(authorization, dehydrateFact(new Tweet("Twas brillig", mickeyMouse)));
         await expect(promise).rejects.not.toBeNull();
     });
 
     it('should accept a fact from an authorized user', async () => {
         const authorization = givenAuthorization();
         const lewiscarrol = await givenLoggedInUser(authorization);
-        const result = await whenSave(authorization, dehydrateFact({
-            type: 'Tweet',
-            message: 'Twas brillig',
-            sender: lewiscarrol
-        }));
+        const result = await whenSave(authorization, dehydrateFact(new Tweet("Twas brillig", lewiscarrol)));
         expect(result.length).toBeGreaterThan(0);
     });
 
     it('should accept a predecessor from an authorized user', async () => {
         const authorization = givenAuthorization();
         const lewiscarrol = await givenLoggedInUser(authorization);
-        const result = await whenSave(authorization, dehydrateFact({
-            type: 'Like',
-            user: lewiscarrol,
-            tweet: {
-                type: 'Tweet',
-                message: 'Twas Brillig',
-                sender: lewiscarrol
-            }
-        }));
-        expect(result.filter(r => r.type === 'Tweet').length).toEqual(1);
+        const result = await whenSave(authorization, dehydrateFact(new Like(lewiscarrol, new Tweet('Twas Brillig', lewiscarrol))));
+        expect(result.filter(r => r.fact.type === 'Tweet').length).toEqual(1);
     });
 
     it('should reject a predecessor from an unauthorized user', async () => {
         const authorization = givenAuthorization();
         const lewiscarrol = await givenLoggedInUser(authorization);
         const mickeyMouse = givenOtherUser();
-        const promise = whenSave(authorization, dehydrateFact({
-            type: 'Like',
-            user: lewiscarrol,
-            tweet: {
-                type: 'Tweet',
-                message: 'Hiya, Pal!',
-                sender: mickeyMouse
-            }
-        }));
+        const promise = whenSave(authorization, dehydrateFact(new Like(lewiscarrol, new Tweet("Hiya, Pal!", mickeyMouse))));
         await expect(promise).rejects.not.toBeNull();
     });
 
     it('should accept a pre-existing predecessor from an unauthorized user', async () => {
         const storage = givenStorage();
         const mickeyMouse = givenOtherUser();
-        const tweet = {
-            type: 'Tweet',
-            message: 'Hiya, Pal!',
-            sender: mickeyMouse
-        };
+        const tweet = new Tweet("Hiya, Pal!", mickeyMouse);
         await storage.save(dehydrateFact(tweet).map(f => ({ fact: f, signatures: [] })));
 
         const authorization = givenAuthorizationWithStorage(storage);
@@ -114,17 +118,13 @@ describe('Authorization', () => {
             tweet: tweet
         }));
         expect(result.length).toBeGreaterThan(0);
-        expect(result.filter(r => r.type === 'Tweet').length).toEqual(0);
+        expect(result.filter(r => r.fact.type === 'Tweet').length).toEqual(0);
     });
 
     it('should accept a fact authorized by predecessor', async () => {
         const authorization = givenAuthorization();
         const lewiscarrol = await givenLoggedInUser(authorization);
-        const tweet = {
-            type: 'Tweet',
-            message: 'Twas brillig',
-            sender: lewiscarrol
-        };
+        const tweet = new Tweet("Twas brillig", lewiscarrol);
         await whenSave(authorization, dehydrateFact(tweet));
 
         const result = await whenSave(authorization, dehydrateFact({
@@ -137,11 +137,7 @@ describe('Authorization', () => {
     it('should accept a fact based on in-flight predecessor', async () => {
         const authorization = givenAuthorization();
         const lewiscarrol = await givenLoggedInUser(authorization);
-        const tweet = {
-            type: 'Tweet',
-            message: 'Twas brillig',
-            sender: lewiscarrol
-        };
+        const tweet = new Tweet("Twas brillig", lewiscarrol);
         // Note that this is missing.
         // await whenSave(authorization, dehydrateFact(tweet));
         
@@ -165,32 +161,39 @@ function givenStorage() {
 function givenAuthorizationWithStorage(storage: MemoryStore) {
     const keystore = new MemoryKeystore();
     keystore.getOrCreateUserFact(givenMockUserIdentity());
-    const authentication = new AuthenticationNoOp();
     const fork = new PassThroughFork(storage);
     const observableSource = new ObservableSource(storage);
     const network = new NetworkNoOp();
-    const factManager = new FactManager(authentication, fork, observableSource, storage, network);
-    const authorizationRules = new AuthorizationRules(undefined)
-        .any('Hashtag')
-        .no('Jinaga.User')
-        .type('Tweet', j.for(tweetSender))
-        .type('Like', j.for(likeUser))
-        .type('Delete', j.for(deleteSender))
+    const factManager = new FactManager(fork, observableSource, storage, network);
+    const model = buildModel(b => b
+        .type(Hashtag)
+        .type(User)
+        .type(Tweet, m => m
+            .predecessor("sender", User))
+        .type(Like, m => m
+            .predecessor("user", User)
+            .predecessor("tweet", Tweet))
+        .type(Delete, m => m
+            .predecessor("tweet", Tweet))
+    );
+    const authorizationRules = new AuthorizationRules(model)
+        .any(Hashtag)
+        .no(User)
+        .type(Tweet, t => t.sender)
+        .type(Like, l => l.user)
+        .type(Delete, d => d.tweet.sender)
         ;
     return new AuthorizationKeystore(factManager, storage, keystore, authorizationRules, null);
 }
 
 function givenOtherUser() {
-    return {
-        type: 'Jinaga.User',
-        publicKey: 'other'
-    };
+    return new User('other');
 }
 
 async function givenLoggedInUser(authorization: AuthorizationKeystore) {
     const userIdentity = givenMockUserIdentity();
     const userFact = await authorization.getOrCreateUserFact(userIdentity);
-    const user = hydrate<{}>(userFact);
+    const user = hydrate<User>(userFact);
     return user;
 }
 
@@ -203,24 +206,7 @@ function givenMockUserIdentity() {
 
 async function whenSave(authorization: AuthorizationKeystore, facts: FactRecord[]) {
     const userIdentity = givenMockUserIdentity();
-    const result = await authorization.save(userIdentity, facts);
+    const envelopes: FactEnvelope[] = facts.map(f => ({ fact: f, signatures: [] }));
+    const result = await authorization.save(userIdentity, envelopes);
     return result;
-}
-
-function tweetSender(t: { sender: {} }) {
-    ensure(t).has("sender", "Jinaga.User");
-
-    return j.match(t.sender);
-}
-
-function likeUser(l: { user: {} }) {
-    ensure(l).has("user", "Jinaga.User");
-
-    return j.match(l.user);
-}
-
-function deleteSender(d: { tweet: { sender: {} } }) {
-    ensure(d).has("tweet", "Tweet").has("sender", "Jinaga.User");
-
-    return j.match(d.tweet.sender);
 }

package/dist/postgres/sql.d.ts

@@ -1,10 +0,0 @@
-import { FactReference, Step } from "jinaga";
-import { FactTypeMap, RoleMap } from "./maps";
-export declare type SqlQuery = {
-    empty: boolean;
-    sql: string;
-    parameters: any[];
-    pathLength: number;
-    factTypeNames: string[];
-};
-export declare function sqlFromSteps(start: FactReference, steps: Step[], factTypes: FactTypeMap, roleMap: RoleMap, schema: string): SqlQuery | null;