jinaga-server 2.6.1 → 3.0.0

package/src/postgres/postgres-store.ts

@@ -1,25 +1,18 @@
 import {
     canonicalPredecessors,
-    Direction,
-    ExistentialCondition,
     FactEnvelope,
     FactFeed,
-    FactPath,
     FactRecord,
     FactReference,
     factReferenceEquals,
+    FactSignature,
     FactTuple,
     getAllFactTypes,
     getAllRoles,
-    Join,
     PredecessorCollection,
     ProjectedResult,
-    PropertyCondition,
-    Query,
     Specification,
-    Step,
-    Storage,
-    TopologicalSorter
+    Storage
 } from "jinaga";
 import { Pool, PoolClient } from "pg";
 
@@ -51,7 +44,6 @@ import {
 } from "./maps";
 import { ResultSetFact, ResultSetRow, ResultSetTree, resultSqlFromSpecification, SqlQueryTree } from "./specification-result-sql";
 import { sqlFromFeed } from "./specification-sql";
-import { sqlFromSteps } from "./sql";
 
 interface FactTypeResult {
     rows: {
@@ -96,6 +88,8 @@ interface AncestorResult {
         name: string;
         hash: string;
         data: string;
+        public_key: string;
+        signature: string;
     }[];
 }
 
@@ -125,21 +119,6 @@ function loadFactTuple(labels: SpecificationLabel[], row: Row): FactTuple {
     };
 }
 
-function loadFactPath(pathLength: number, factTypeNames: string[], r: Row): FactPath {
-    let path: FactPath = [];
-    for (let i = 0; i < pathLength; i++) {
-        const hash = r['hash' + (i + 2)];
-        if (!hash) {
-            throw new Error(`Cannot find column 'hash${i + 2}'`);
-        }
-        path.push({
-            type: factTypeNames[i],
-            hash: hash
-        });
-    }
-    return path;
-}
-
 export class PostgresStore implements Storage {
     private connectionFactory: ConnectionFactory;
     private factTypeMap: FactTypeMap = emptyFactTypeMap();
@@ -204,32 +183,6 @@ export class PostgresStore implements Storage {
         }
     }
 
-    async query(start: FactReference, query: Query): Promise<FactPath[]> {
-        if (query.steps.length === 0) {
-            return [[start]];
-        }
-
-        try {
-            const factTypes = await this.loadFactTypesFromSteps(query.steps, start.type);
-            const roleMap = await this.loadRolesFromSteps(query.steps, factTypes, start.type);
-
-            const sqlQuery = sqlFromSteps(start, query.steps, factTypes, roleMap, this.schema);
-            if (!sqlQuery) {
-                throw new Error(`Could not generate SQL for query "${query.toDescriptiveString()}" starting at "${start.type}"`);
-            }
-            if (sqlQuery.empty) {
-                return [];
-            }
-            const { rows } = await this.connectionFactory.with(async (connection) => {
-                return await connection.query(sqlQuery.sql, sqlQuery.parameters);
-            });
-            return rows.map(row => loadFactPath(sqlQuery.pathLength, sqlQuery.factTypeNames, row));
-        }
-        catch (e) {
-            throw new Error(`Could not generate SQL for query "${query.toDescriptiveString()}" starting at "${start.type}": ${e}`);
-        }
-    }
-
     async read(start: FactReference[], specification: Specification): Promise<ProjectedResult[]> {
         const factTypes = await this.loadFactTypesFromSpecification(specification);
         const roleMap = await this.loadRolesFromSpecification(specification, factTypes);
@@ -253,7 +206,8 @@ export class PostgresStore implements Storage {
         const factReferences: FactReference[] = composer.findFactReferences(resultSets);
 
         // Load the references into a fact tree
-        const factRecords = await this.load(factReferences);
+        const factEnvelopes = await this.load(factReferences);
+        const factRecords = factEnvelopes.map(envelope => envelope.fact);
 
         return composer.compose(resultSets, factRecords);
     }
@@ -279,22 +233,6 @@ export class PostgresStore implements Storage {
         };
     }
 
-    private async loadFactTypesFromSteps(steps: Step[], startType: string): Promise<FactTypeMap> {
-        const factTypes = this.factTypeMap;
-        const unknownFactTypes = [...allFactTypes(steps), startType]
-            .filter(factType => !factTypes.has(factType))
-            .filter(distinct);
-        if (unknownFactTypes.length > 0) {
-            const loadedFactTypes = await this.connectionFactory.with(async (connection) => {
-                return await loadFactTypes(unknownFactTypes, connection, this.schema);
-            });
-            const merged = mergeFactTypes(this.factTypeMap, loadedFactTypes);
-            this.factTypeMap = merged;
-            return merged;
-        }
-        return factTypes;
-    }
-
     async loadFactTypesFromFeed(feed: Specification): Promise<FactTypeMap> {
         const factTypes = this.factTypeMap;
         const unknownFactTypes = getAllFactTypes(feed)
@@ -325,21 +263,6 @@ export class PostgresStore implements Storage {
         return factTypes;
     }
 
-    private async loadRolesFromSteps(steps: Step[], factTypes: FactTypeMap, initialType: string) {
-        const roleMap = this.roleMap;
-        const unknownRoles = allRoles(steps, factTypes, getFactTypeId(factTypes, initialType))
-            .filter(r => !hasRole(roleMap, r.successor_type_id, r.role));
-        if (unknownRoles.length > 0) {
-            const loadedRoles = await this.connectionFactory.with(async (connection) => {
-                return await loadRoles(unknownRoles, roleMap, connection, this.schema);
-            });
-            const merged = mergeRoleMaps(this.roleMap, loadedRoles);
-            this.roleMap = merged;
-            return merged;
-        }
-        return roleMap;
-    }
-
     async loadRolesFromSpecification(specification: Specification, factTypes: FactTypeMap): Promise<RoleMap> {
         const roleMap = this.roleMap;
         const unknownRoles = getAllRoles(specification)
@@ -407,7 +330,7 @@ export class PostgresStore implements Storage {
         return existing;
     }
 
-    async load(references: FactReference[]): Promise<FactRecord[]> {
+    async load(references: FactReference[]): Promise<FactEnvelope[]> {
         if (references.length === 0) {
             return [];
         }
@@ -419,23 +342,30 @@ export class PostgresStore implements Storage {
         const factParameters = flatten(references, (f) =>
             [f.hash, factTypes.get(f.type)]);
         const sql =
-            'SELECT f.fact_type_id, t.name, f.hash, f.data ' +
-            `FROM ${this.schema}.fact f ` +
-            `JOIN ${this.schema}.fact_type t ` +
-            '  ON f.fact_type_id = t.fact_type_id ' +
-            'JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id) ' +
-            '  ON v.fact_type_id = f.fact_type_id AND v.hash = f.hash ' +
-            'UNION ' +
-            'SELECT f2.fact_type_id, t.name, f2.hash, f2.data ' +
-            `FROM ${this.schema}.fact f1 ` +
-            'JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id) ' +
-            '  ON v.fact_type_id = f1.fact_type_id AND v.hash = f1.hash ' +
-            `JOIN ${this.schema}.ancestor a ` +
-            '  ON a.fact_id = f1.fact_id ' +
-            `JOIN ${this.schema}.fact f2 ` +
-            '  ON f2.fact_id = a.ancestor_fact_id ' +
-            `JOIN ${this.schema}.fact_type t ` +
-            '  ON t.fact_type_id = f2.fact_type_id;';
+            'SELECT f.fact_type_id, f.name, f.hash, f.data, s.public_key, s.signature ' +
+            'FROM (SELECT f.fact_id, f.fact_type_id, t.name, f.hash, f.data ' +
+                `FROM ${this.schema}.fact f ` +
+                `JOIN ${this.schema}.fact_type t ` +
+                '  ON f.fact_type_id = t.fact_type_id ' +
+                'JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id) ' +
+                '  ON v.fact_type_id = f.fact_type_id AND v.hash = f.hash ' +
+                'UNION ' +
+                'SELECT f2.fact_id, f2.fact_type_id, t.name, f2.hash, f2.data ' +
+                `FROM ${this.schema}.fact f1 ` +
+                'JOIN (VALUES ' + factValues.join(', ') + ') AS v (hash, fact_type_id) ' +
+                '  ON v.fact_type_id = f1.fact_type_id AND v.hash = f1.hash ' +
+                `JOIN ${this.schema}.ancestor a ` +
+                '  ON a.fact_id = f1.fact_id ' +
+                `JOIN ${this.schema}.fact f2 ` +
+                '  ON f2.fact_id = a.ancestor_fact_id ' +
+                `JOIN ${this.schema}.fact_type t ` +
+                '  ON t.fact_type_id = f2.fact_type_id) as f ' +
+            'LEFT JOIN (SELECT p.public_key, s.signature, s.fact_id ' +
+                `FROM ${this.schema}.signature s ` +
+                `JOIN ${this.schema}.public_key p ` +
+                '  ON p.public_key_id = s.public_key_id) as s ' +
+            'ON s.fact_id = f.fact_id ' +
+            'ORDER BY f.fact_id, s.public_key;';
         const result: AncestorResult = await this.connectionFactory.with(async (connection) => {
             return await connection.query(sql, factParameters);
         })
@@ -444,17 +374,46 @@ export class PostgresStore implements Storage {
             emptyFactTypeMap()
         );
         this.factTypeMap = mergeFactTypes(this.factTypeMap, resultFactTypes);
-        const sorter = new TopologicalSorter<FactRecord>();
         const records = result.rows.map((r) => {
             const { fields, predecessors }: { fields: {}, predecessors: PredecessorCollection } = r.data as any;
-            return <FactRecord>{
+            const fact: FactRecord = {
                 type: r.name,
                 hash: r.hash,
                 fields,
                 predecessors
+            };
+            const signature: FactSignature = {
+                publicKey: r.public_key,
+                signature: r.signature
+            };
+            return {
+                fact,
+                signature
             }
         });
-        return sorter.sort(records, (p, r) => r);
+        // Group the records by fact type and hash.
+        const envelopes: FactEnvelope[] = records.reduce((acc: FactEnvelope[], record) => {
+            // Because the records are sorted by fact ID, we can just look at the last envelope.
+            const last = acc.length > 0 ? acc[acc.length - 1] : undefined;
+            if (last && last.fact.type === record.fact.type && last.fact.hash === record.fact.hash) {
+                last.signatures.push(record.signature);
+            }
+            else if (record.signature.signature === null) {
+                acc.push({
+                    fact: record.fact,
+                    signatures: []
+                });
+            }
+            else {
+                acc.push({
+                    fact: record.fact,
+                    signatures: [record.signature]
+                });
+            }
+            return acc;
+        }, []);
+        // Assuming that the facts were inserted in topological order, they don't need to be sorted.
+        return envelopes;
     }
 
     private async loadFactTypesFromReferences(references: FactReference[]): Promise<FactTypeMap> {
@@ -894,51 +853,6 @@ async function insertSignatures(envelopes: FactEnvelope[], allFacts: FactMap, fa
     }
 }
 
-function allFactTypes(steps: Step[]): string[] {
-    const factTypes = steps
-        .filter(step => step instanceof PropertyCondition && step.name === 'type')
-        .map(step => (step as PropertyCondition).value);
-    const childFactTypes = steps
-        .filter(step => step instanceof ExistentialCondition)
-        .flatMap(step => allFactTypes((step as ExistentialCondition).steps));
-    return [...factTypes, ...childFactTypes].filter(distinct);
-}
-
-function allRoles(steps: Step[], factTypes: FactTypeMap, initialTypeId: number | undefined) {
-    let roles: { successor_type_id: number; role: string }[] = [];
-    let successor_type_id = initialTypeId;
-    let role: string | undefined = undefined;
-
-    for (const step of steps) {
-        if (step instanceof PropertyCondition) {
-            if (step.name === 'type') {
-                successor_type_id = getFactTypeId(factTypes, step.value);
-                if (successor_type_id && role) {
-                    roles.push({ successor_type_id: successor_type_id, role });
-                }
-                role = undefined;
-            }
-        }
-        else if (step instanceof Join) {
-            if (step.direction === Direction.Predecessor) {
-                if (successor_type_id) {
-                    roles.push({ successor_type_id: successor_type_id, role: step.role });
-                }
-                role = undefined;
-            }
-            else {
-                role = step.role;
-            }
-            successor_type_id = undefined;
-        }
-        else if (step instanceof ExistentialCondition) {
-            roles = roles.concat(allRoles(step.steps, factTypes, successor_type_id));
-        }
-    }
-
-    return roles;
-}
-
 function predecessorsOf(fact: FactRecord): FactReference[] {
     const references = Object.values(fact.predecessors).flatMap(predecessor =>
         Array.isArray(predecessor) ? predecessor : [predecessor]

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;