jinaga-server 2.6.2 → 3.0.0

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

@@ -17,11 +17,8 @@
     "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"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinaga-server",
-  "version": "2.6.2",
+  "version": "3.0.0",
   "description": "Data management for web and mobile applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,9 +48,8 @@
   },
   "dependencies": {
     "express": "^4.18.2",
-    "jinaga": "^5.6.0",
+    "jinaga": "^6.0.0",
     "node-forge": "^1.3.1",
-    "passport": "^0.6.0",
     "pg": "^8.11.3"
   }
 }

package/src/authentication/authentication-device.ts

@@ -1,4 +1,4 @@
-import { Authentication, AuthorizationEngine, AuthorizationRules, FactEnvelope, FactRecord, LoginResponse, Storage, UserIdentity } from "jinaga";
+import { Authentication, AuthorizationEngine, AuthorizationRules, FactEnvelope, FactRecord, LoginResponse, Storage, UserIdentity, factReferenceEquals } from "jinaga";
 
 import { Keystore } from "../keystore";
 
@@ -33,11 +33,33 @@ export class AuthenticationDevice implements Authentication {
 
     async authorize(envelopes: FactEnvelope[]): Promise<FactEnvelope[]> {
         const deviceFact = await this.keystore.getOrCreateDeviceFact(this.localDeviceIdentity);
-        const facts = envelopes.map(envelope => envelope.fact);
-        const authorizedFacts = this.authorizationEngine
-            ? await this.authorizationEngine.authorizeFacts(facts, deviceFact)
-            : facts;
-        const signedFacts = await this.keystore.signFacts(this.localDeviceIdentity, authorizedFacts);
-        return signedFacts;
+
+        if (this.authorizationEngine) {
+            const results = await this.authorizationEngine.authorizeFacts(envelopes, deviceFact);
+            const authorizedEnvelopes: FactEnvelope[] = results.map(r => {
+                const isFact = factReferenceEquals(r.fact);
+                const envelope = envelopes.find(e => isFact(e.fact));
+                if (!envelope) {
+                    throw new Error("Fact not found in envelopes.");
+                }
+                if (r.verdict === "Accept") {
+                    return {
+                        fact: r.fact,
+                        signatures: envelope.signatures
+                            .filter(s => r.newPublicKeys.includes(s.publicKey))
+                    };
+                }
+                else if (r.verdict === "Existing") {
+                    return envelope;
+                }
+                else {
+                    throw new Error("Unexpected verdict.");
+                }
+            });
+            return authorizedEnvelopes;
+        }
+        else {
+            return envelopes;
+        }
     }
 }

package/src/authentication/authentication-session.ts

@@ -1,4 +1,4 @@
-import { Authentication, AuthorizationEngine, AuthorizationRules, FactEnvelope, FactRecord, LoginResponse, Storage, UserIdentity } from "jinaga";
+import { Authentication, AuthorizationEngine, AuthorizationRules, FactEnvelope, FactRecord, LoginResponse, Storage, UserIdentity, factReferenceEquals } from "jinaga";
 
 import { Keystore } from "../keystore";
 
@@ -41,11 +41,33 @@ export class AuthenticationSession implements Authentication {
 
     async authorize(envelopes: FactEnvelope[]): Promise<FactEnvelope[]> {
         const userFact = await this.keystore.getUserFact(this.userIdentity);
-        const facts = envelopes.map(envelope => envelope.fact);
-        const authorizedFacts = this.authorizationEngine
-            ? await this.authorizationEngine.authorizeFacts(facts, userFact)
-            : facts;
-        const signedFacts = await this.keystore.signFacts(this.userIdentity, authorizedFacts);
-        return signedFacts;
+
+        if (this.authorizationEngine) {
+            const results = await this.authorizationEngine.authorizeFacts(envelopes, userFact);
+            const authorizedEnvelopes: FactEnvelope[] = results.map(r => {
+                const isFact = factReferenceEquals(r.fact);
+                const envelope = envelopes.find(e => isFact(e.fact));
+                if (!envelope) {
+                    throw new Error("Fact not found in envelopes.");
+                }
+                if (r.verdict === "Accept") {
+                    return {
+                        fact: r.fact,
+                        signatures: envelope.signatures
+                            .filter(s => r.newPublicKeys.includes(s.publicKey))
+                    };
+                }
+                else if (r.verdict === "Existing") {
+                    return envelope;
+                }
+                else {
+                    throw new Error("Unexpected verdict.");
+                }
+            });
+            return authorizedEnvelopes;
+        }
+        else {
+            return envelopes;
+        }
     }
 }

package/src/authorization/authorization-keystore.ts

@@ -7,10 +7,8 @@ import {
     FactEnvelope,
     FactFeed,
     FactManager,
-    FactRecord,
     FactReference,
     Forbidden,
-    Query,
     ReferencesByName,
     Specification,
     Storage,
@@ -52,10 +50,6 @@ export class AuthorizationKeystore implements Authorization {
         return userFact;
     }
 
-    query(userIdentity: UserIdentity | null, start: FactReference, query: Query) {
-        return this.factManager.query(start, query);
-    }
-
     async read(userIdentity: UserIdentity | null, start: FactReference[], specification: Specification) {
         if (this.distributionEngine) {
             const userReference: FactReference | null = userIdentity
@@ -111,24 +105,50 @@ export class AuthorizationKeystore implements Authorization {
         return await this.factManager.load(references);
     }
 
-    async save(userIdentity: UserIdentity | null, facts: FactRecord[]) {
-        if (!this.authorizationEngine) {
-            const envelopes = await this.factManager.save(facts.map(fact => ({
-                fact,
-                signatures: []
-            })));
-            return envelopes.map(envelope => envelope.fact);
-        }
-
-        const userFact = userIdentity ? await this.keystore.getUserFact(userIdentity) : null;
-        const authorizedFacts = await this.authorizationEngine.authorizeFacts(facts, userFact);
-        if (userIdentity) {
-            const signedFacts = await this.keystore.signFacts(userIdentity, authorizedFacts);
-            const envelopes = await this.factManager.save(signedFacts);
-            return envelopes.map(envelope => envelope.fact);
+    async save(userIdentity: UserIdentity | null, envelopes: FactEnvelope[]): Promise<FactEnvelope[]> {
+        if (this.authorizationEngine) {
+            const userFact = userIdentity ? await this.keystore.getUserFact(userIdentity) : null;
+            const results = await this.authorizationEngine.authorizeFacts(envelopes, userFact);
+            const userKeys : string[] = (userFact && userFact.fields.hasOwnProperty("publicKey"))
+                ? [ userFact.fields.publicKey ]
+                : [];
+            const factsToSign = results
+                .filter(r => r.verdict === "Accept" && r.newPublicKeys.some(k => userKeys.includes(k)))
+                .map(r => r.fact);
+            const signedFacts = (userIdentity && factsToSign.length > 0)
+                ? await this.keystore.signFacts(userIdentity, factsToSign)
+                : [];
+            const authorizedEnvelopes: FactEnvelope[] = results.map(r => {
+                const isFact = factReferenceEquals(r.fact);
+                const envelope = envelopes.find(e => isFact(e.fact));
+                if (!envelope) {
+                    throw new Error("Fact not found in envelopes.");
+                }
+                if (r.verdict === "Accept") {
+                    const signedFact = signedFacts.find(f => isFact(f.fact));
+                    const userSignatures = signedFact
+                        ? signedFact.signatures
+                        : [];
+                    return {
+                        fact: r.fact,
+                        signatures: envelope.signatures
+                            .filter(s => r.newPublicKeys.includes(s.publicKey))
+                            .concat(userSignatures)
+                    };
+                }
+                else if (r.verdict === "Existing") {
+                    return envelope;
+                }
+                else {
+                    throw new Error("Unexpected verdict.");
+                }
+            });
+            const savedEnvelopes = await this.factManager.save(authorizedEnvelopes);
+            return savedEnvelopes;
         }
         else {
-            return authorizedFacts;
+            const savedEnvelopes = await this.factManager.save(envelopes);
+            return savedEnvelopes;
         }
     }
 

package/src/http/router.ts

@@ -14,8 +14,6 @@ import {
     LoadResponse,
     ProfileMessage,
     ProjectedResult,
-    QueryMessage,
-    QueryResponse,
     ReferencesByName,
     SaveMessage,
     Specification,
@@ -25,10 +23,8 @@ import {
     buildFeeds,
     computeObjectHash,
     computeTupleSubsetHash,
-    fromDescriptiveString,
     invertSpecification,
     parseLoadMessage,
-    parseQueryMessage,
     parseSaveMessage
 } from "jinaga";
 
@@ -285,15 +281,9 @@ export interface RequestUser {
 export class HttpRouter {
     handler: Handler;
 
-    constructor(private factManager: FactManager, private authorization: Authorization, private feedCache: FeedCache, backwardCompatible: boolean) {
+    constructor(private factManager: FactManager, private authorization: Authorization, private feedCache: FeedCache) {
         const router = Router();
         router.get('/login', getAuthenticate(user => this.login(user)));
-        if (backwardCompatible) {
-            router.post('/query', post(
-                parseQueryMessage,
-                (user, queryMessage) => this.query(user, queryMessage)
-            ));
-        }
         router.post('/load', post(
             parseLoadMessage,
             (user, loadMessage) => this.load(user, loadMessage)
@@ -327,26 +317,22 @@ export class HttpRouter {
         };
     }
 
-    private async query(user: RequestUser | null, queryMessage: QueryMessage): Promise<QueryResponse> {
-        const userIdentity = serializeUserIdentity(user);
-        const query = fromDescriptiveString(queryMessage.query);
-        const result = await this.authorization.query(userIdentity, queryMessage.start, query);
-        return {
-            results: result
-        };
-    }
-
     private async load(user: RequestUser, loadMessage: LoadMessage): Promise<LoadResponse> {
         const userIdentity = serializeUserIdentity(user);
         const result = await this.authorization.load(userIdentity, loadMessage.references);
+        const facts = result.map(r => r.fact);
         return {
-            facts: result
+            facts
         };
     }
 
     private async save(user: RequestUser | null, saveMessage: SaveMessage): Promise<void> {
         const userIdentity = serializeUserIdentity(user);
-        await this.authorization.save(userIdentity, saveMessage.facts);
+        await this.authorization.save(userIdentity, saveMessage.facts
+            .map(fact => ({
+                fact: fact,
+                signatures: []
+            })));
     }
 
     private async read(user: RequestUser | null, input: string): Promise<any[]> {
@@ -379,7 +365,11 @@ export class HttpRouter {
         }
 
         const userIdentity = serializeUserIdentity(user);
-        await this.authorization.save(userIdentity, factRecords);
+        await this.authorization.save(userIdentity, factRecords
+            .map(fact => ({
+                fact: fact,
+                signatures: []
+            })));
     }
 
     private async feeds(user: RequestUser | null, input: string): Promise<FeedsResponse> {

package/src/jinaga-server.ts

@@ -65,11 +65,10 @@ export class JinagaServer {
         const feedCache = new FeedCache();
         const authentication = createAuthentication(store, keystore, authorizationRules);
         const network = new NetworkNoOp();
-        const factManager = new FactManager(authentication, fork, source, store, network);
+        const factManager = new FactManager(fork, source, store, network);
         const authorization = createAuthorization(authorizationRules, distributionRules, factManager, store, keystore);
-        // Retain backward compatibility until the user provides distribution rules.
-        const router = new HttpRouter(factManager, authorization, feedCache, distributionRules === null);
-        const j: Jinaga = new Jinaga(factManager, syncStatusNotifier);
+        const router = new HttpRouter(factManager, authorization, feedCache);
+        const j: Jinaga = new Jinaga(authentication, factManager, syncStatusNotifier);
 
         async function close() {
             for (const pool of Object.values(pools)) {
@@ -187,8 +186,8 @@ async function withSession(store: Storage, keystore: Keystore | null, authorizat
     const fork = new PassThroughFork(store);
     const observableSource = new ObservableSource(store);
     const network = new NetworkNoOp();
-    const factManager = new FactManager(authentication, fork, observableSource, store, network);
-    const j = new Jinaga(factManager, syncStatusNotifier);
+    const factManager = new FactManager(fork, observableSource, store, network);
+    const j = new Jinaga(authentication, factManager, syncStatusNotifier);
     await callback(j);
 }
 

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]