jinaga-server 1.1.4 → 2.0.1

package/src/postgres/postgres-store.ts

@@ -3,6 +3,7 @@ import {
     Direction,
     ExistentialCondition,
     FactEnvelope,
+    FactFeed,
     FactPath,
     FactRecord,
     FactReference,
@@ -20,9 +21,8 @@ import {
     Specification,
     Step,
     Storage,
-    TopologicalSorter,
+    TopologicalSorter
 } from "jinaga";
-import { FactFeed } from "jinaga/dist/storage";
 import { PoolClient } from "pg";
 
 import { distinct, flatten } from "../util/fn";
@@ -37,6 +37,7 @@ import {
     emptyFactTypeMap,
     emptyPublicKeyMap,
     emptyRoleMap,
+    ensureGetFactTypeId,
     FactMap,
     FactTypeMap,
     getFactId,
@@ -48,7 +49,7 @@ import {
     mergeFactTypes,
     mergeRoleMaps,
     PublicKeyMap,
-    RoleMap,
+    RoleMap
 } from "./maps";
 import { ResultSetTree, resultSqlFromSpecification, SqlQueryTree } from "./specification-result-sql";
 import { sqlFromFeed } from "./specification-sql";
@@ -167,7 +168,7 @@ export class PostgresStore implements Storage {
             } = await this.connectionFactory.withTransaction(async (connection) => {
                 const factTypes = await storeFactTypes(facts, this.factTypeMap, connection);
                 const existingFacts = await findExistingFacts(facts, factTypes, connection);
-                const newFacts = facts.filter(f => !hasFact(existingFacts, f.hash, factTypes.get(f.type)));
+                const newFacts = facts.filter(f => !hasFact(existingFacts, f.hash, ensureGetFactTypeId(factTypes, f.type)));
                 if (newFacts.length === 0) {
                     return {
                         newEnvelopes: [],
@@ -235,6 +236,11 @@ export class PostgresStore implements Storage {
         const factTypes = await this.loadFactTypesFromSpecification(specification);
         const roleMap = await this.loadRolesFromSpecification(specification, factTypes);
 
+        // If any of the start facts are not known types, the specification cannot be satisfied.
+        if (start.filter(f => getFactTypeId(factTypes, f.type) === undefined).length > 0) {
+            return [];
+        }
+
         const composer = resultSqlFromSpecification(start, specification, factTypes, roleMap);
         if (composer === null) {
             return [];
@@ -317,7 +323,7 @@ export class PostgresStore implements Storage {
     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.defining_fact_type_id, r.role));
+            .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);
@@ -332,11 +338,12 @@ export class PostgresStore implements Storage {
     async loadRolesFromSpecification(specification: Specification, factTypes: FactTypeMap): Promise<RoleMap> {
         const roleMap = this.roleMap;
         const unknownRoles = getAllRoles(specification)
+            .filter(r => getFactTypeId(factTypes, r.successorType))
             .map(r => ({
-                defining_fact_type_id: getFactTypeId(factTypes, r.definingFactType),
+                successor_type_id: ensureGetFactTypeId(factTypes, r.successorType),
                 role: r.name
             }))
-            .filter(r => !hasRole(roleMap, r.defining_fact_type_id, r.role));
+            .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);
@@ -352,10 +359,10 @@ export class PostgresStore implements Storage {
         const roleMap = this.roleMap;
         const unknownRoles = getAllRolesFromFeed(feed)
             .map(r => ({
-                defining_fact_type_id: getFactTypeId(factTypes, r.definingFactType),
+                successor_type_id: ensureGetFactTypeId(factTypes, r.successorType),
                 role: r.name
             }))
-            .filter(r => !hasRole(roleMap, r.defining_fact_type_id, r.role));
+            .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);
@@ -535,21 +542,21 @@ async function loadFactTypes(factTypeNames: string[], connection: PoolClient) {
 async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap: RoleMap, connection: PoolClient) {
     // Find distinct roles
     const roles = flatten(facts, fact => {
-        const defining_fact_type_id = factTypes.get(fact.type);
+        const successor_type_id = ensureGetFactTypeId(factTypes, fact.type);
         return Object.keys(fact.predecessors).map(role => ({
             role,
-            defining_fact_type_id
+            successor_type_id
         }));
     }).filter((role, index, array) => array.findIndex(r =>
         r.role === role.role &&
-        r.defining_fact_type_id === role.defining_fact_type_id
+        r.successor_type_id === role.successor_type_id
     ) === index);
 
     if (roles.length > 0) {
         // Look up existing roles
         const roleIds = await loadRoles(roles, roleMap, connection);
         const remainingRoles = roles.filter(role => !hasRole(
-            roleIds, role.defining_fact_type_id, role.role));
+            roleIds, role.successor_type_id, role.role));
         if (remainingRoles.length === 0) {
             return roleIds;
         }
@@ -562,7 +569,7 @@ async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap:
             ' RETURNING role_id, name, defining_fact_type_id;';
         const remainingRoleParameters = flatten(remainingRoles, (role) => [
             role.role,
-            role.defining_fact_type_id
+            role.successor_type_id
         ]);
         const { rows: newRows }: RoleResult = await connection.query(insertSql, remainingRoleParameters);
         if (newRows.length !== remainingRoles.length) {
@@ -579,12 +586,12 @@ async function storeRoles(facts: FactRecord[], factTypes: FactTypeMap, roleMap:
     }
 }
 
-async function loadRoles(roles: { role: string; defining_fact_type_id: number; }[], roleMap: RoleMap, connection: PoolClient) {
+async function loadRoles(roles: { role: string; successor_type_id: number; }[], roleMap: RoleMap, connection: PoolClient) {
     const roleValues = roles.map((role, index) =>
         `($${index * 2 + 1}, $${index * 2 + 2}::integer)`);
     const roleParameters = flatten(roles, (role) => [
         role.role,
-        role.defining_fact_type_id
+        role.successor_type_id
     ]);
 
     const lookUpSql = 'SELECT role.name, role.defining_fact_type_id, role.role_id' +
@@ -646,7 +653,7 @@ async function insertFactsEdgesAndAncestors(facts: FactRecord[], factTypes: Fact
 
 function sqlInsertFacts(facts: FactRecord[], roles: RoleMap, factTypes: FactTypeMap) {
     const factValues = facts.map((f, i) => `(\$${i * 3 + 1}, \$${i * 3 + 2}::integer, \$${i * 3 + 3}::jsonb)`);
-    const factParameters = flatten(facts, (f) => [f.hash, factTypes.get(f.type), {
+    const factParameters = flatten(facts, (f) => [f.hash, ensureGetFactTypeId(factTypes, f.type), {
         fields: f.fields,
         predecessors: canonicalPredecessors(f.predecessors)
     }]);
@@ -669,8 +676,8 @@ function sqlInsertFactsEdgesAndAncestors(facts: FactRecord[], factParameters: (s
     let parameterOffset = factParameters.length;
     const edgeValues = edgeRecords.map((e, i) => `(\$${i * 5 + 1 + parameterOffset}, \$${i * 5 + 2 + parameterOffset}::integer, \$${i * 5 + 3 + parameterOffset}, \$${i * 5 + 4 + parameterOffset}::integer, \$${i * 5 + 5 + parameterOffset}::integer)`);
     const edgeParameters = flatten(edgeRecords, (e) => {
-        const successor_fact_type_id = getFactTypeId(factTypes, e.successor_type);
-        const predecessor_fact_type_id = getFactTypeId(factTypes, e.predecessor_type);
+        const successor_fact_type_id = ensureGetFactTypeId(factTypes, e.successor_type);
+        const predecessor_fact_type_id = ensureGetFactTypeId(factTypes, e.predecessor_type);
         return [
             e.successor_hash,
             successor_fact_type_id,
@@ -833,7 +840,7 @@ async function storePublicKeys(envelopes: FactEnvelope[], connection: PoolClient
 
 async function insertSignatures(envelopes: FactEnvelope[], allFacts: FactMap, factTypes: FactTypeMap, publicKey: PublicKeyMap, connection: PoolClient) {
     const signatureRecords = flatten(envelopes, envelope => envelope.signatures.map(signature => ({
-        factId: getFactId(allFacts, envelope.fact.hash, getFactTypeId(factTypes, envelope.fact.type)),
+        factId: getFactId(allFacts, envelope.fact.hash, ensureGetFactTypeId(factTypes, envelope.fact.type)),
         publicKeyId: getPublicKeyId(publicKey, signature.publicKey),
         signature: signature.signature
     })));
@@ -862,35 +869,35 @@ function allFactTypes(steps: Step[]): string[] {
     return [...factTypes, ...childFactTypes].filter(distinct);
 }
 
-function allRoles(steps: Step[], factTypes: FactTypeMap, initialTypeId: number) {
-    let roles: { defining_fact_type_id: number; role: string }[] = [];
-    let defining_fact_type_id = initialTypeId;
+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') {
-                defining_fact_type_id = getFactTypeId(factTypes, step.value);
-                if (defining_fact_type_id && role) {
-                    roles.push({ defining_fact_type_id, role });
+                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 (defining_fact_type_id) {
-                    roles.push({ defining_fact_type_id, role: step.role });
+                if (successor_type_id) {
+                    roles.push({ successor_type_id: successor_type_id, role: step.role });
                 }
                 role = undefined;
             }
             else {
                 role = step.role;
             }
-            defining_fact_type_id = undefined;
+            successor_type_id = undefined;
         }
         else if (step instanceof ExistentialCondition) {
-            roles = roles.concat(allRoles(step.steps, factTypes, defining_fact_type_id));
+            roles = roles.concat(allRoles(step.steps, factTypes, successor_type_id));
         }
     }
 

package/src/postgres/specification-result-sql.ts

@@ -1,17 +1,19 @@
 import {
-    ChildProjections,
-    ElementProjection,
+    ComponentProjection,
+    FactProjection,
     FactReference,
+    FieldProjection,
+    HashProjection,
     Label,
     Match,
     PathCondition,
-    ResultProjection,
+    Projection,
     SingularProjection,
     Specification,
-    SpecificationProjection,
+    SpecificationProjection
 } from "jinaga";
 
-import { FactTypeMap, getFactTypeId, getRoleId, RoleMap } from "./maps";
+import { ensureGetFactTypeId, FactTypeMap, getFactTypeId, getRoleId, RoleMap } from "./maps";
 
 interface SpecificationLabel {
     name: string;
@@ -222,7 +224,7 @@ class QueryDescription {
         const firstEdge = this.edges[0];
         const predecessorFact = this.inputs.find(i => i.factIndex === firstEdge.predecessorFactIndex);
         const successorFact = this.inputs.find(i => i.factIndex === firstEdge.successorFactIndex);
-        const firstFactIndex = predecessorFact ? predecessorFact.factIndex : successorFact.factIndex;
+        const firstFactIndex = predecessorFact ? predecessorFact.factIndex : successorFact!.factIndex;
         const writtenFactIndexes = new Set<number>().add(firstFactIndex);
         const joins: string[] = generateJoins(this.edges, writtenFactIndexes);
         const inputWhereClauses = this.inputs
@@ -410,13 +412,13 @@ function generateExistentialWhereClause(existentialCondition: ExistentialConditi
 return `SELECT 1 FROM public.edge e${firstEdge.edgeIndex}${joins.join("")} WHERE ${whereClause.join(" AND ")}${inputWhereClauses}${existentialWhereClauses}`;
 }
 
-type FactByIdentifier = {
-    [identifier: string]: FactDescription;
+type FactByLabel = {
+    [label: string]: FactDescription;
 };
 
 interface ResultDescription {
     queryDescription: QueryDescription;
-    resultProjection: ResultProjection;
+    resultProjection: Projection;
     childResultDescriptions: NamedResultDescription[];
 }
 
@@ -455,7 +457,7 @@ interface NamedResultSetTree extends ResultSetTree {
 export class ResultComposer {
     constructor(
         private readonly sqlQuery: SpecificationSqlQuery,
-        private readonly resultProjection: ResultProjection,
+        private readonly resultProjection: Projection,
         private readonly parentFactIdLength: number,
         private readonly childResultComposers: NamedResultComposer[]
     ) { }
@@ -555,40 +557,77 @@ export class ResultComposer {
     }
 
     private projectionOf(row: any): any {
-        if (!Array.isArray(this.resultProjection)) {
-            return this.singularValue(this.resultProjection, row);
+        if (this.resultProjection.type === "field") {
+            return this.fieldValue(this.resultProjection, row);
         }
-        else if (this.resultProjection.length === 0 && this.childResultComposers.length === 0) {
-            return this.sqlQuery.labels
-                .slice(this.parentFactIdLength)
-                .reduce((acc, label) => ({
+        else if (this.resultProjection.type === "composite") {
+            if (
+                this.resultProjection.components.length === 0 &&
+                this.childResultComposers.length === 0) {
+                return this.sqlQuery.labels
+                    .slice(this.parentFactIdLength)
+                    .reduce((acc, label) => ({
+                        ...acc,
+                        [label.name]: row[`data${label.index}`].fields
+                    }), {})
+            }
+            else {
+                return this.resultProjection.components.reduce((acc, component) => ({
                     ...acc,
-                    [label.name]: row[`data${label.index}`].fields
-                }), {})
+                    [component.name]: this.elementValue(component, row)
+                }), {});
+            }
+        }
+        else if (this.resultProjection.type === "hash") {
+            return this.hashValue(this.resultProjection, row);
+        }
+        else if (this.resultProjection.type === "fact") {
+            return this.factValue(this.resultProjection, row);
         }
         else {
-            return this.resultProjection.reduce((acc, elementProjection) => ({
-                ...acc,
-                [elementProjection.name]: this.elementValue(elementProjection, row)
-            }), {});
+            const _exhaustiveCheck: never = this.resultProjection;
+            throw new Error(`Unknown projection type ${(this.resultProjection as any).type}`);
         }
     }
 
-    private elementValue(projection: ElementProjection, row: any): any {
-        const label = this.getLabel(projection.label);
+    private elementValue(projection: ComponentProjection, row: any): any {
         if (projection.type === "field") {
+            const label = this.getLabel(projection.label);
             return row[`data${label.index}`].fields[projection.field];
         }
         else if (projection.type === "hash") {
+            const label = this.getLabel(projection.label);
             return row[`hash${label.index}`];
         }
+        else if (projection.type === "fact") {
+            const label = this.getLabel(projection.label);
+            return row[`data${label.index}`].fields;
+        }
+        else if (projection.type === "specification") {
+            // This should have already been taken care of
+            return null;
+        }
+        else {
+            const _exhaustiveCheck: never = projection;
+            throw new Error(`Unknown projection type ${(projection as any).type}`);
+        }
     }
 
-    private singularValue(projection: SingularProjection, row: any): any {
+    private fieldValue(projection: FieldProjection, row: any): any {
         const label = this.getLabel(projection.label);
         return row[`data${label.index}`].fields[projection.field];
     }
 
+    private hashValue(projection: HashProjection, row: any): any {
+        const label = this.getLabel(projection.label);
+        return row[`hash${label.index}`];
+    }
+
+    private factValue(projection: FactProjection, row: any): any {
+        const label = this.getLabel(projection.label);
+        return row[`data${label.index}`].fields;
+    }
+
     private getLabel(name: string) {
         const label = this.sqlQuery.labels.find(label => label.name === name);
         if (!label) {
@@ -626,27 +665,30 @@ class ResultDescriptionBuilder {
         // The DescriptionBuilder will branch at various points, and
         // build on the current query description along each branch.
         const initialQueryDescription = new QueryDescription([], [], [], [], [], []);
-        return this.createResultDescription(initialQueryDescription, specification.given, start, specification.matches, specification.childProjections, {}, []);
+        return this.createResultDescription(initialQueryDescription, specification.given, start, specification.matches, specification.projection, {}, []);
     }
 
-    private createResultDescription(queryDescription: QueryDescription, given: Label[], start: FactReference[], matches: Match[], childProjections: ChildProjections, knownFacts: FactByIdentifier, path: number[]): ResultDescription {
+    private createResultDescription(queryDescription: QueryDescription, given: Label[], start: FactReference[], matches: Match[], projection: Projection, knownFacts: FactByLabel, path: number[]): ResultDescription {
         ({ queryDescription, knownFacts } = this.addEdges(queryDescription, given, start, knownFacts, path, matches));
         if (!queryDescription.isSatisfiable()) {
             // Abort the branch if the query is not satisfiable
             return {
                 queryDescription,
-                resultProjection: [],
+                resultProjection: {
+                    type: "composite",
+                    components: []
+                },
                 childResultDescriptions: []
             }
         }
         const childResultDescriptions: NamedResultDescription[] = [];
-        if (Array.isArray(childProjections)) {
-            const specificationProjections = childProjections
-                .filter(projection => projection.type === "specification") as SpecificationProjection[];
-            const elementProjections = childProjections
-                .filter(projection => projection.type === "field" || projection.type === "hash") as ElementProjection[];
+        if (projection.type === "composite") {
+            const specificationProjections = projection.components
+                .filter(projection => projection.type === "specification") as ({ name: string } & SpecificationProjection)[];
+            const singularProjections = projection.components
+                .filter(projection => projection.type === "field" || projection.type === "hash" || projection.type === "fact") as ({ name: string } & SingularProjection)[];
             for (const child of specificationProjections) {
-                const childResultDescription = this.createResultDescription(queryDescription, given, start, child.matches, child.childProjections, knownFacts, []);
+                const childResultDescription = this.createResultDescription(queryDescription, given, start, child.matches, child.projection, knownFacts, []);
                 childResultDescriptions.push({
                     name: child.name,
                     ...childResultDescription
@@ -654,20 +696,23 @@ class ResultDescriptionBuilder {
             }
             return {
                 queryDescription,
-                resultProjection: elementProjections,
+                resultProjection: {
+                    type: "composite",
+                    components: singularProjections
+                },
                 childResultDescriptions
             };
         }
         else {
             return {
                 queryDescription,
-                resultProjection: childProjections,
+                resultProjection: projection,
                 childResultDescriptions: []
             }
         }
     }
 
-    private addEdges(queryDescription: QueryDescription, given: Label[], start: FactReference[], knownFacts: FactByIdentifier, path: number[], matches: Match[]): { queryDescription: QueryDescription, knownFacts: FactByIdentifier } {
+    private addEdges(queryDescription: QueryDescription, given: Label[], start: FactReference[], knownFacts: FactByLabel, path: number[], matches: Match[]): { queryDescription: QueryDescription, knownFacts: FactByLabel } {
         for (const match of matches) {
             for (const condition of match.conditions) {
                 if (condition.type === "path") {
@@ -701,7 +746,7 @@ class ResultDescriptionBuilder {
         };
     }
 
-    private addPathCondition(queryDescription: QueryDescription, given: Label[], start: FactReference[], knownFacts: FactByIdentifier, path: number[], unknown: Label, prefix: string, condition: PathCondition): { queryDescription: QueryDescription, knownFacts: FactByIdentifier } {
+    private addPathCondition(queryDescription: QueryDescription, given: Label[], start: FactReference[], knownFacts: FactByLabel, path: number[], unknown: Label, prefix: string, condition: PathCondition): { queryDescription: QueryDescription, knownFacts: FactByLabel } {
         // If no input parameter has been allocated, allocate one now.
         if (!knownFacts.hasOwnProperty(condition.labelRight)) {
             const givenIndex = given.findIndex(given => given.name === condition.labelRight);
@@ -710,7 +755,7 @@ class ResultDescriptionBuilder {
             }
             const { queryDescription: newQueryDescription, factDescription } = queryDescription.withInputParameter(
                 given[givenIndex],
-                getFactTypeId(this.factTypes, start[givenIndex].type),
+                ensureGetFactTypeId(this.factTypes, start[givenIndex].type),
                 start[givenIndex].hash,
                 path
             );
@@ -753,11 +798,11 @@ class ResultDescriptionBuilder {
             }
             else {
                 // If we have not written the fact, we need to write it now.
-                const { query, factIndex: predecessorFactIndex } = queryWithParameter.withFact(role.targetType);
+                const { query, factIndex: predecessorFactIndex } = queryWithParameter.withFact(role.predecessorType);
                 queryDescription = query.withEdge(predecessorFactIndex, factIndex, roleParameter, path);
                 factIndex = predecessorFactIndex;
             }
-            type = role.targetType;
+            type = role.predecessorType;
         }
 
         const rightType = type;
@@ -785,7 +830,7 @@ class ResultDescriptionBuilder {
                 roleId,
                 declaringType: type
             });
-            type = role.targetType;
+            type = role.predecessorType;
         }
 
         if (type !== rightType) {
@@ -823,7 +868,7 @@ function idsEqual(a: number[], b: number[]) {
     return a.every((value, index) => value === b[index]);
 }
 
-export function resultSqlFromSpecification(start: FactReference[], specification: Specification, factTypes: FactTypeMap, roleMap: RoleMap): ResultComposer {
+export function resultSqlFromSpecification(start: FactReference[], specification: Specification, factTypes: FactTypeMap, roleMap: RoleMap): ResultComposer | null {
     const descriptionBuilder = new ResultDescriptionBuilder(factTypes, roleMap);
     const description = descriptionBuilder.buildDescription(start, specification);
 

package/src/postgres/specification-sql.ts

@@ -63,7 +63,7 @@ class QueryDescription {
         const firstEdge = this.edges[0];
         const predecessorFact = this.inputs.find(i => i.factIndex === firstEdge.predecessorFactIndex);
         const successorFact = this.inputs.find(i => i.factIndex === firstEdge.successorFactIndex);
-        const firstFactIndex = predecessorFact ? predecessorFact.factIndex : successorFact.factIndex;
+        const firstFactIndex = predecessorFact ? predecessorFact.factIndex : successorFact!.factIndex;
         const writtenFactIndexes = new Set<number>().add(firstFactIndex);
         const joins: string[] = generateJoins(this.edges, writtenFactIndexes);
         const inputWhereClauses = this.inputs

package/src/postgres/sql.ts

@@ -1,6 +1,6 @@
 import { Direction, ExistentialCondition, FactReference, Join, PropertyCondition, Quantifier, Step } from "jinaga";
 
-import { FactTypeMap, getFactTypeId, getRoleId, RoleMap } from "./maps";
+import { ensureGetFactTypeId, FactTypeMap, getFactTypeId, getRoleId, RoleMap } from "./maps";
 
 export type SqlQuery = {
     empty: boolean,
@@ -10,7 +10,7 @@ export type SqlQuery = {
     factTypeNames: string[]
 };
 
-export function sqlFromSteps(start: FactReference, steps: Step[], factTypes: FactTypeMap, roleMap: RoleMap) : SqlQuery {
+export function sqlFromSteps(start: FactReference, steps: Step[], factTypes: FactTypeMap, roleMap: RoleMap) : SqlQuery | null {
     const builder = new QueryBuilder(factTypes, roleMap);
 
     return builder.buildQuery(start, steps);
@@ -90,18 +90,18 @@ class QueryBuilder {
     constructor(private factTypes: FactTypeMap, private roleMap: RoleMap) {
     }
 
-    buildQuery(start: FactReference, steps: Step[]): SqlQuery {
+    buildQuery(start: FactReference, steps: Step[]): SqlQuery | null {
         if (steps.length === 0) {
             return null;
         }
 
-        const startTypeId = getFactTypeId(this.factTypes, start.type);
+        const startTypeId = ensureGetFactTypeId(this.factTypes, start.type);
         const startState: QueryBuilderState = {
             state: 'start',
             typeId: startTypeId,
             typeName: start.type
         };
-        const finalState = steps.reduce((state, step) => {
+        const finalState = steps.reduce((state: QueryBuilderState, step) => {
             return this.matchStep(state, step);
         }, startState);
         this.end(finalState);
@@ -134,6 +134,14 @@ class QueryBuilder {
     }
 
     private buildJoins(joins: QueryJoin[], priorFactId: string) {
+        interface Joins {
+            priorFactId: string,
+            clauses: string[]
+        };
+        const initialJoins: Joins = {
+            priorFactId,
+            clauses: []
+        };
         const clauses = joins.reduce((joins, join) => {
             if (join.table === 'edge') {
                 if (join.direction === 'successor') {
@@ -161,10 +169,7 @@ class QueryBuilder {
                     clauses: [...joins.clauses, clause]
                 };
             }
-        }, {
-            priorFactId,
-            clauses: []
-        }).clauses;
+        }, initialJoins).clauses;
         return clauses.join('');
     }
 
@@ -209,7 +214,7 @@ class QueryBuilder {
             typeId: typeId,
             typeName: typeName
         };
-        const finalState = steps.reduce((state, step) => {
+        const finalState = steps.reduce((state: QueryBuilderState, step) => {
             return this.matchStep(state, step);
         }, startState);
         this.end(finalState);
@@ -270,12 +275,15 @@ class QueryBuilder {
                     position: `${state.typeName}.${step.role}`
                 }
             }
-            if (step.direction === Direction.Successor) {
+            else if (step.direction === Direction.Successor) {
                 return {
                     state: 'successor-join',
                     role: step.role
                 }
             }
+            else {
+                throw new Error(`Unknown direction ${step.direction}`);
+            }
         }
         else if (step instanceof ExistentialCondition) {
             return this.pushExistentialCondition(state.typeId, state.typeName, state, step);
@@ -311,13 +319,16 @@ class QueryBuilder {
                     position: `${state.typeName}.${step.role}`
                 }
             }
-            if (step.direction === Direction.Successor) {
+            else if (step.direction === 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 ExistentialCondition) {
             return this.pushExistentialCondition(state.typeId, state.typeName, state, step);

package/test/postgres/postgresReadSpec.ts

@@ -27,7 +27,7 @@ function sqlFor(descriptiveString: string, bookmarks: string[] = []) {
     // Filter out the roles named "unknown", and those of unknown fact types.
     let roleMap = getAllRoles(specification).filter(r => r.name !== 'unknown').reduce(
         (r, role, i) => {
-            const factTypeId = getFactTypeId(factTypes, role.definingFactType);
+            const factTypeId = getFactTypeId(factTypes, role.successorType);
             if (!factTypeId) {
                 return r;
             }
@@ -44,6 +44,9 @@ function sqlFor(descriptiveString: string, bookmarks: string[] = []) {
         throw new Error(`Unknown input type ${input.type}`);
     });
     const composer = resultSqlFromSpecification(start, specification, factTypes, roleMap);
+    if (!composer) {
+        throw new Error("The specification is not satisfiable.");
+    }
     return { composer, factTypes, roleMap };
 }