jinaga-server 2.6.2 → 3.0.0

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;

package/dist/postgres/sql.js

@@ -1,408 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqlFromSteps = void 0;
-const jinaga_1 = require("jinaga");
-const maps_1 = require("./maps");
-function sqlFromSteps(start, steps, factTypes, roleMap, schema) {
-    const builder = new QueryBuilder(factTypes, roleMap);
-    return builder.buildQuery(start, steps, schema);
-}
-exports.sqlFromSteps = sqlFromSteps;
-;
-class QueryBuilder {
-    constructor(factTypes, roleMap) {
-        this.factTypes = factTypes;
-        this.roleMap = roleMap;
-        this.nextEdge = 1;
-        this.nextFact = 2;
-        this.shouldEmitFacts = true;
-        this.queryParts = {
-            joins: [],
-            existentialClauses: []
-        };
-        this.roleIds = [];
-        this.factTypeNames = [];
-    }
-    buildQuery(start, steps, schema) {
-        if (steps.length === 0) {
-            return null;
-        }
-        const startTypeId = (0, maps_1.ensureGetFactTypeId)(this.factTypes, start.type);
-        const startState = {
-            state: 'start',
-            typeId: startTypeId,
-            typeName: start.type
-        };
-        const finalState = steps.reduce((state, step) => {
-            return this.matchStep(state, step);
-        }, startState);
-        this.end(finalState);
-        if (finalState.state === 'empty') {
-            return {
-                empty: true,
-                sql: '',
-                parameters: [],
-                pathLength: 0,
-                factTypeNames: []
-            };
-        }
-        const factAliases = this.queryParts.joins
-            .filter(j => j.table === 'fact')
-            .map(j => j.factAlias);
-        const hashes = factAliases.map(a => `f${a}.hash as hash${a}`).join(', ');
-        const joins = this.buildJoins(schema, this.queryParts.joins, 'f1.fact_id');
-        const whereClause = this.buildWhereClause(schema, this.queryParts.existentialClauses);
-        const sql = `SELECT ${hashes} FROM ${schema}.fact f1${joins} WHERE f1.fact_type_id = $1 AND f1.hash = $2${whereClause}`;
-        return {
-            empty: false,
-            sql,
-            parameters: [startTypeId, start.hash, ...this.roleIds],
-            pathLength: factAliases.length,
-            factTypeNames: this.factTypeNames
-        };
-    }
-    buildJoins(schema, joins, priorFactId) {
-        ;
-        const initialJoins = {
-            priorFactId,
-            clauses: []
-        };
-        const clauses = joins.reduce((joins, join) => {
-            if (join.table === 'edge') {
-                if (join.direction === 'successor') {
-                    const clause = ` JOIN ${schema}.edge e${join.edgeAlias} ` +
-                        `ON e${join.edgeAlias}.predecessor_fact_id = ${joins.priorFactId} ` +
-                        `AND e${join.edgeAlias}.role_id = $${join.roleParameter}`;
-                    return {
-                        priorFactId: `e${join.edgeAlias}.successor_fact_id`,
-                        clauses: [...joins.clauses, clause]
-                    };
-                }
-                else {
-                    const clause = ` JOIN ${schema}.edge e${join.edgeAlias} ` +
-                        `ON e${join.edgeAlias}.successor_fact_id = ${joins.priorFactId} ` +
-                        `AND e${join.edgeAlias}.role_id = $${join.roleParameter}`;
-                    return {
-                        priorFactId: `e${join.edgeAlias}.predecessor_fact_id`,
-                        clauses: [...joins.clauses, clause]
-                    };
-                }
-            }
-            else {
-                const clause = ` JOIN ${schema}.fact f${join.factAlias} ON f${join.factAlias}.fact_id = ${joins.priorFactId}`;
-                return {
-                    priorFactId: joins.priorFactId,
-                    clauses: [...joins.clauses, clause]
-                };
-            }
-        }, initialJoins).clauses;
-        return clauses.join('');
-    }
-    buildWhereClause(schema, existentialClauses) {
-        if (existentialClauses.length === 0) {
-            return '';
-        }
-        const clauses = existentialClauses.map(clause => {
-            const quantifierSql = clause.quantifier === jinaga_1.Quantifier.Exists ? 'EXISTS' : 'NOT EXISTS';
-            const [first, ...rest] = clause.query.joins;
-            const firstHeadFactId = first.direction === 'predecessor'
-                ? `e${first.edgeAlias}.predecessor_fact_id`
-                : `e${first.edgeAlias}.successor_fact_id`;
-            const firstTailFactId = first.direction === 'predecessor'
-                ? `e${first.edgeAlias}.successor_fact_id`
-                : `e${first.edgeAlias}.predecessor_fact_id`;
-            const joins = this.buildJoins(schema, rest, firstHeadFactId);
-            const priorFactId = clause.priorEdgeJoin.direction === 'predecessor'
-                ? `e${clause.priorEdgeJoin.edgeAlias}.predecessor_fact_id`
-                : `e${clause.priorEdgeJoin.edgeAlias}.successor_fact_id`;
-            const whereClause = this.buildWhereClause(schema, clause.query.existentialClauses);
-            return ` AND ${quantifierSql} (SELECT 1 FROM ${schema}.edge e${first.edgeAlias}${joins} ` +
-                `WHERE ${firstTailFactId} = ${priorFactId} ` +
-                `AND e${first.edgeAlias}.role_id = $${first.roleParameter}${whereClause})`;
-        });
-        return clauses.join('');
-    }
-    buildNestedSql(typeId, typeName, steps) {
-        // Push a new query to the stack.
-        const parentQuery = this.queryParts;
-        const parentShouldEmitFact = this.shouldEmitFacts;
-        this.shouldEmitFacts = false;
-        this.queryParts = {
-            joins: [],
-            existentialClauses: []
-        };
-        const startState = {
-            state: 'predecessor-type',
-            typeId: typeId,
-            typeName: typeName
-        };
-        const finalState = steps.reduce((state, step) => {
-            return this.matchStep(state, step);
-        }, startState);
-        this.end(finalState);
-        // Pop the stack and return the nested query.
-        const nestedQuery = this.queryParts;
-        this.shouldEmitFacts = parentShouldEmitFact;
-        this.queryParts = parentQuery;
-        // If the nested query cannot match any results, return null.
-        if (finalState.state === 'empty') {
-            return null;
-        }
-        return nestedQuery;
-    }
-    matchStep(state, step) {
-        switch (state.state) {
-            case 'start':
-                return this.matchStepStart(state, step);
-            case 'predecessor-type':
-                return this.matchStepPredecessorType(state, step);
-            case 'predecessor-join':
-                return this.matchStepPredecessorJoin(state, step);
-            case 'successor-join':
-                return this.matchStepSuccessorJoin(state, step);
-            case 'successor-type':
-                return this.matchStepSuccessorType(state, step);
-            case 'empty':
-                return state;
-            default:
-                throw new Error(`Unknown state: ${state.state}`);
-        }
-    }
-    matchStepStart(state, step) {
-        if (step instanceof jinaga_1.PropertyCondition) {
-            if (step.name !== 'type') {
-                throw new Error(`Property condition on non-type property ${step.name}`);
-            }
-            const typeId = (0, maps_1.getFactTypeId)(this.factTypes, step.value);
-            if (typeId !== state.typeId) {
-                throw new Error(`Two property conditions in a row on different types, ending in ${step.value}`);
-            }
-            return state;
-        }
-        else if (step instanceof jinaga_1.Join) {
-            if (step.direction === jinaga_1.Direction.Predecessor) {
-                const roleId = (0, maps_1.getRoleId)(this.roleMap, state.typeId, step.role);
-                if (!roleId) {
-                    return {
-                        state: 'empty'
-                    };
-                }
-                this.emitEdge('predecessor', roleId);
-                return {
-                    state: 'predecessor-join',
-                    position: `${state.typeName}.${step.role}`
-                };
-            }
-            else if (step.direction === jinaga_1.Direction.Successor) {
-                return {
-                    state: 'successor-join',
-                    role: step.role
-                };
-            }
-            else {
-                throw new Error(`Unknown direction ${step.direction}`);
-            }
-        }
-        else if (step instanceof jinaga_1.ExistentialCondition) {
-            return this.pushExistentialCondition(state.typeId, state.typeName, state, step);
-        }
-        else {
-            throw new Error(`Unknown step ${step.constructor.name}`);
-        }
-    }
-    matchStepPredecessorType(state, step) {
-        if (step instanceof jinaga_1.PropertyCondition) {
-            if (step.name !== 'type') {
-                throw new Error(`Property condition on non-type property ${step.name}`);
-            }
-            const typeId = (0, maps_1.getFactTypeId)(this.factTypes, step.value);
-            if (typeId !== state.typeId) {
-                throw new Error(`Two property conditions in a row on different types, ending in ${step.value}`);
-            }
-            return state;
-        }
-        else if (step instanceof jinaga_1.Join) {
-            if (step.direction === jinaga_1.Direction.Predecessor) {
-                const roleId = (0, maps_1.getRoleId)(this.roleMap, state.typeId, step.role);
-                if (!roleId) {
-                    return {
-                        state: 'empty'
-                    };
-                }
-                this.emitFact(state.typeName);
-                this.emitEdge('predecessor', roleId);
-                return {
-                    state: 'predecessor-join',
-                    position: `${state.typeName}.${step.role}`
-                };
-            }
-            else if (step.direction === jinaga_1.Direction.Successor) {
-                this.emitFact(state.typeName);
-                return {
-                    state: 'successor-join',
-                    role: step.role
-                };
-            }
-            else {
-                throw new Error(`Unknown direction ${step.direction}`);
-            }
-        }
-        else if (step instanceof jinaga_1.ExistentialCondition) {
-            return this.pushExistentialCondition(state.typeId, state.typeName, state, step);
-        }
-        else {
-            throw new Error(`Unknown step ${step.constructor.name}`);
-        }
-    }
-    matchStepPredecessorJoin(state, step) {
-        if (step instanceof jinaga_1.PropertyCondition) {
-            if (step.name !== 'type') {
-                throw new Error(`Property condition on non-type property ${step.name}`);
-            }
-            const typeId = (0, maps_1.getFactTypeId)(this.factTypes, step.value);
-            if (!typeId) {
-                return {
-                    state: 'empty'
-                };
-            }
-            return {
-                state: 'predecessor-type',
-                typeId,
-                typeName: step.value
-            };
-        }
-        else {
-            throw new Error(`Missing type of "${state.position}"`);
-        }
-    }
-    matchStepSuccessorJoin(state, step) {
-        if (step instanceof jinaga_1.PropertyCondition) {
-            if (step.name !== 'type') {
-                throw new Error(`Property condition on non-type property ${step.name}`);
-            }
-            const typeId = (0, maps_1.getFactTypeId)(this.factTypes, step.value);
-            if (!typeId) {
-                return {
-                    state: 'empty'
-                };
-            }
-            const roleId = (0, maps_1.getRoleId)(this.roleMap, typeId, state.role);
-            if (!roleId) {
-                return {
-                    state: 'empty'
-                };
-            }
-            this.emitEdge('successor', roleId);
-            return {
-                state: 'successor-type',
-                typeId: typeId,
-                typeName: step.value
-            };
-        }
-        else {
-            throw new Error(`Missing type for role ${state.role}`);
-        }
-    }
-    matchStepSuccessorType(state, step) {
-        if (step instanceof jinaga_1.PropertyCondition) {
-            if (step.name !== 'type') {
-                throw new Error(`Property condition on non-type property ${step.name}`);
-            }
-            const typeId = (0, maps_1.getFactTypeId)(this.factTypes, step.value);
-            if (typeId !== state.typeId) {
-                throw new Error(`Two property conditions in a row on different types, ending in ${step.value}`);
-            }
-            return state;
-        }
-        else if (step instanceof jinaga_1.Join) {
-            if (step.direction === jinaga_1.Direction.Predecessor) {
-                const roleId = (0, maps_1.getRoleId)(this.roleMap, state.typeId, step.role);
-                if (!roleId) {
-                    return {
-                        state: 'empty'
-                    };
-                }
-                this.emitFact(state.typeName);
-                this.emitEdge('predecessor', roleId);
-                return {
-                    state: 'predecessor-join',
-                    position: `${state.typeName}.${step.role}`
-                };
-            }
-            else {
-                this.emitFact(state.typeName);
-                return {
-                    state: 'successor-join',
-                    role: step.role
-                };
-            }
-        }
-        else if (step instanceof jinaga_1.ExistentialCondition) {
-            return this.pushExistentialCondition(state.typeId, state.typeName, state, step);
-        }
-        else {
-            throw new Error(`Unknown step ${step.constructor.name}`);
-        }
-    }
-    end(finalState) {
-        if (finalState.state === 'successor-join') {
-            throw new Error(`Missing type for role ${finalState.role}`);
-        }
-        else if (finalState.state === 'predecessor-join') {
-            throw new Error(`Missing type of "${finalState.position}"`);
-        }
-        else if (finalState.state === 'predecessor-type' || finalState.state === 'successor-type') {
-            this.emitFact(finalState.typeName);
-        }
-    }
-    emitEdge(direction, roleId) {
-        const edgeAlias = this.nextEdge++;
-        this.roleIds.push(roleId);
-        this.queryParts.joins.push({
-            table: 'edge',
-            direction: direction,
-            edgeAlias: edgeAlias,
-            roleParameter: edgeAlias + 2
-        });
-    }
-    emitFact(factTypeName) {
-        if (this.shouldEmitFacts) {
-            const factAlias = this.nextFact++;
-            this.queryParts.joins.push({
-                table: 'fact',
-                factAlias: factAlias
-            });
-            this.factTypeNames.push(factTypeName);
-        }
-    }
-    pushExistentialCondition(typeId, typeName, state, step) {
-        if (this.queryParts.joins.length === 0) {
-            // We cannot apply a condition until we have some joins.
-            return state;
-        }
-        const lastJoin = this.queryParts.joins[this.queryParts.joins.length - 1];
-        if (lastJoin.table !== 'edge') {
-            throw new Error(`Existential condition on non-edge table ${lastJoin.table}`);
-        }
-        const nested = this.buildNestedSql(typeId, typeName, step.steps);
-        if (!nested) {
-            if (step.quantifier === jinaga_1.Quantifier.Exists) {
-                // An empty positive existential condition cannot match any facts.
-                return {
-                    state: 'empty'
-                };
-            }
-            else {
-                // An empty negative existential condition cannot exclude any facts.
-                return state;
-            }
-        }
-        this.queryParts.existentialClauses.push({
-            quantifier: step.quantifier,
-            priorEdgeJoin: lastJoin,
-            query: nested
-        });
-        return state;
-    }
-}
-//# sourceMappingURL=sql.js.map