jinaga-server 1.1.3 → 2.0.0

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

@@ -0,0 +1,292 @@
+import { dehydrateReference, getAllFactTypes, getAllRoles, SpecificationParser } from "jinaga";
+import { addFactType, addRole, emptyFactTypeMap, emptyRoleMap, getFactTypeId, getRoleId } from "../../src/postgres/maps";
+import { resultSqlFromSpecification } from "../../src/postgres/specification-result-sql";
+
+const company = dehydrateReference({ type: "Company" });
+const companyHash = company.hash;
+const user = dehydrateReference({ type: "Jinaga.User", publicKey: "PUBLIC KEY"});
+const userHash = user.hash;
+
+function parseSpecification(input: string) {
+    const parser = new SpecificationParser(input);
+    parser.skipWhitespace();
+    return parser.parseSpecification();
+}
+
+function sqlFor(descriptiveString: string, bookmarks: string[] = []) {
+    const specification = parseSpecification(descriptiveString);
+    const factTypeNames = getAllFactTypes(specification);
+
+    // Build a fact type map containing all fact types in the specification.
+    // Filter out fact types named "Unknown".
+    const factTypes = factTypeNames.filter(t => t !== 'Unknown').reduce(
+        (f, factType, i) => addFactType(f, factType, i + 1),
+        emptyFactTypeMap());
+
+    // Build a role map containing all roles in the specification.
+    // 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.successorType);
+            if (!factTypeId) {
+                return r;
+            }
+            return addRole(r, factTypeId, role.name, i + 1);
+        },
+        emptyRoleMap());
+    const start = specification.given.map(input => {
+        if (input.type === "Company") {
+            return company;
+        }
+        if (input.type === "Jinaga.User") {
+            return user;
+        }
+        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 };
+}
+
+function roleParameter(roleMap: Map<number, Map<string, number>>, factTypes: Map<string, number>, factTypeName: string, roleName: string): number {
+    const factTypeId = getFactTypeId(factTypes, factTypeName);
+    if (!factTypeId) {
+        throw new Error(`Unknown fact type ${factTypeName}`);
+    }
+    const roleId = getRoleId(roleMap, factTypeId, roleName);
+    if (!roleId) {
+        throw new Error(`Unknown role ${roleName} in fact type ${factTypeName}`);
+    }
+    return roleId;
+}
+
+describe("Postgres read", () => {
+    it("should join successors", () => {
+        const { composer } = sqlFor(`
+            (company: Company) {
+                department: Department [
+                    department->company: Company = company
+                ]
+            }
+        `);
+
+        const sql = composer.getSqlQueries().sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT f2.hash as hash2, f2.fact_id as id2, f2.data as data2 ` +
+            `FROM public.fact f1 ` +
+            `JOIN public.edge e1 ` +
+                `ON e1.predecessor_fact_id = f1.fact_id ` +
+                `AND e1.role_id = $3 ` +
+            `JOIN public.fact f2 ` +
+                `ON f2.fact_id = e1.successor_fact_id ` +
+            `WHERE f1.fact_type_id = $1 AND f1.hash = $2 ` +
+            `ORDER BY f2.fact_id ASC`
+        );
+    });
+
+    it("should apply negative existential conditions", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                project: Project [
+                    project->department: Department->company: Company = company
+                    !E {
+                        deleted: Project.Deleted [
+                            deleted->project: Project = project
+                        ]
+                    }
+                ]
+            }
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT f3.hash as hash3, f3.fact_id as id3, f3.data as data3 ` +
+            `FROM public.fact f1 ` +
+            `JOIN public.edge e1 ` +
+                `ON e1.predecessor_fact_id = f1.fact_id ` +
+                `AND e1.role_id = $3 ` +
+            `JOIN public.fact f2 ` +
+                `ON f2.fact_id = e1.successor_fact_id ` +
+            `JOIN public.edge e2 ` +
+                `ON e2.predecessor_fact_id = f2.fact_id ` +
+                `AND e2.role_id = $4 ` +
+            `JOIN public.fact f3 ` +
+                `ON f3.fact_id = e2.successor_fact_id ` +
+            `WHERE f1.fact_type_id = $1 AND f1.hash = $2 ` +
+            `AND NOT EXISTS (` +
+                `SELECT 1 ` +
+                `FROM public.edge e3 ` +
+                `JOIN public.fact f4 ` +
+                    `ON f4.fact_id = e3.successor_fact_id ` +
+                `WHERE e3.predecessor_fact_id = f3.fact_id ` +
+                    `AND e3.role_id = $5` +
+            `) ` +
+            `ORDER BY f3.fact_id ASC`
+        );
+        expect(tree.sqlQuery.parameters).toEqual([
+            getFactTypeId(factTypes, 'Company'),
+            companyHash,
+            roleParameter(roleMap, factTypes, 'Department', 'company'),
+            roleParameter(roleMap, factTypes, 'Project', 'department'),
+            roleParameter(roleMap, factTypes, 'Project.Deleted', 'project')
+        ]);
+    });
+
+    it("should apply positive existential conditions", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                project: Project [
+                    project->department: Department->company: Company = company
+                    E {
+                        deleted: Project.Deleted [
+                            deleted->project: Project = project
+                        ]
+                    }
+                ]
+            }
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT f3.hash as hash3, f3.fact_id as id3, f3.data as data3 ` +
+            `FROM public.fact f1 ` +
+            `JOIN public.edge e1 ` +
+                `ON e1.predecessor_fact_id = f1.fact_id ` +
+                `AND e1.role_id = $3 ` +
+            `JOIN public.fact f2 ` +
+                `ON f2.fact_id = e1.successor_fact_id ` +
+            `JOIN public.edge e2 ` +
+                `ON e2.predecessor_fact_id = f2.fact_id ` +
+                `AND e2.role_id = $4 ` +
+            `JOIN public.fact f3 ` +
+                `ON f3.fact_id = e2.successor_fact_id ` +
+            `WHERE f1.fact_type_id = $1 AND f1.hash = $2 ` +
+            `AND EXISTS (` +
+                `SELECT 1 ` +
+                `FROM public.edge e3 ` +
+                `JOIN public.fact f4 ` +
+                    `ON f4.fact_id = e3.successor_fact_id ` +
+                `WHERE e3.predecessor_fact_id = f3.fact_id ` +
+                    `AND e3.role_id = $5` +
+            `) ` +
+            `ORDER BY f3.fact_id ASC`
+        );
+        expect(tree.sqlQuery.parameters).toEqual([
+            getFactTypeId(factTypes, 'Company'),
+            companyHash,
+            roleParameter(roleMap, factTypes, 'Department', 'company'),
+            roleParameter(roleMap, factTypes, 'Project', 'department'),
+            roleParameter(roleMap, factTypes, 'Project.Deleted', 'project')
+        ]);
+    });
+
+    it("should read complex specifications", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company, user: Jinaga.User) {
+                project: Project [
+                    project->department: Department->company: Company = company
+                    !E {
+                        deleted: Project.Deleted [
+                            deleted->project: Project = project
+                            !E {
+                                restored: Project.Restored [
+                                    restored->deleted: Project.Deleted = deleted
+                                ]
+                            }
+                        ]
+                    }
+                    E {
+                        assignment: Project.Assignment [
+                            assignment->project: Project = project
+                            assignment->user: Jinaga.User = user
+                            !E {
+                                revoked: Project.Assignment.Revoked [
+                                    revoked->assignment: Project.Assignment = assignment
+                                ]
+                            }
+                        ]
+                    }
+                ]
+                deliverable: Deliverable [
+                    deliverable->project: Project = project
+                ]
+            } => {
+                assignedTasks = {
+                    task: Task [
+                        task->deliverable: Deliverable = deliverable
+                        E {
+                            assignment: Task.Assignment [
+                                assignment->task: Task = task
+                                assignment->user: Jinaga.User = user
+                            ]
+                        }
+                    ]
+                } => {
+                    number = task.number
+                }
+            }
+        `);
+
+        const queries = composer.getSqlQueries();
+        expect(queries.sqlQuery.sql).toEqual(
+            `SELECT ` +
+                `f3.hash as hash3, f3.fact_id as id3, f3.data as data3, ` +
+                `f9.hash as hash9, f9.fact_id as id9, f9.data as data9 ` +
+            `FROM public.fact f1 ` +
+            `JOIN public.edge e1 ` +
+                `ON e1.predecessor_fact_id = f1.fact_id ` +
+                `AND e1.role_id = $3 ` +
+            `JOIN public.fact f2 ` +
+                `ON f2.fact_id = e1.successor_fact_id ` +
+            `JOIN public.edge e2 ` +
+                `ON e2.predecessor_fact_id = f2.fact_id ` +
+                `AND e2.role_id = $4 ` +
+            `JOIN public.fact f3 ` +
+                `ON f3.fact_id = e2.successor_fact_id ` +
+            `JOIN public.edge e8 ` +
+                `ON e8.predecessor_fact_id = f3.fact_id ` +
+                `AND e8.role_id = $12 ` +
+            `JOIN public.fact f9 ` +
+                `ON f9.fact_id = e8.successor_fact_id ` +
+            `WHERE f1.fact_type_id = $1 AND f1.hash = $2 ` +
+                `AND NOT EXISTS (` +
+                    `SELECT 1 ` +
+                    `FROM public.edge e3 ` +
+                    `JOIN public.fact f4 ` +
+                        `ON f4.fact_id = e3.successor_fact_id ` +
+                    `WHERE e3.predecessor_fact_id = f3.fact_id ` +
+                        `AND e3.role_id = $5 ` +
+                        `AND NOT EXISTS (` +
+                            `SELECT 1 ` +
+                            `FROM public.edge e4 ` +
+                            `JOIN public.fact f5 ` +
+                                `ON f5.fact_id = e4.successor_fact_id ` +
+                            `WHERE e4.predecessor_fact_id = f4.fact_id AND e4.role_id = $6` +
+                        `)` +
+                `) AND EXISTS (` +
+                    `SELECT 1 ` +
+                    `FROM public.edge e5 ` +
+                    `JOIN public.fact f6 ` +
+                        `ON f6.fact_id = e5.successor_fact_id ` +
+                    `JOIN public.edge e6 ` +
+                        `ON e6.successor_fact_id = f6.fact_id ` +
+                        `AND e6.role_id = $10 ` +
+                    `JOIN public.fact f7 ` +
+                        `ON f7.fact_id = e6.predecessor_fact_id ` +
+                    `WHERE e5.predecessor_fact_id = f3.fact_id AND e5.role_id = $7 ` +
+                        `AND f7.fact_type_id = $8 AND f7.hash = $9 ` +
+                        `AND NOT EXISTS (` +
+                            `SELECT 1 ` +
+                            `FROM public.edge e7 ` +
+                            `JOIN public.fact f8 ` +
+                                `ON f8.fact_id = e7.successor_fact_id ` +
+                            `WHERE e7.predecessor_fact_id = f6.fact_id AND e7.role_id = $11` +
+                        `)` +
+                `) ` +
+            `ORDER BY f3.fact_id ASC, f9.fact_id ASC`);
+    });
+});

package/test/postgres/postgresSpec.ts

@@ -10,7 +10,7 @@ import {
   Step,
 } from "jinaga";
 
-import { addFactType, addRole, emptyFactTypeMap, emptyRoleMap, getFactTypeId, getRoleId } from "../../src/postgres/maps";
+import { addFactType, addRole, emptyFactTypeMap, emptyRoleMap, ensureGetFactTypeId, getFactTypeId, getRoleId } from "../../src/postgres/maps";
 import { sqlFromSteps } from "../../src/postgres/sql";
 import { distinct } from "../../src/util/fn";
 
@@ -24,8 +24,8 @@ describe('Postgres', () => {
     const factTypes = allFactTypes(query.steps).filter(t => t !== 'Unknown').reduce(
       (f, factType, i) => addFactType(f, factType, i + 1),
       emptyFactTypeMap());
-    let roleMap = allRoles(query.steps, 'Root').filter(r => r.role !== 'unknown').reduce(
-      (r, role, i) => addRole(r, getFactTypeId(factTypes, role.type), role.role, i + 1),
+    let roleMap = allRoles(query.steps, 'Root').filter(r => r.type !== 'Unknown' && r.role !== 'unknown').reduce(
+      (r, role, i) => addRole(r, ensureGetFactTypeId(factTypes, role.type), role.role, i + 1),
       emptyRoleMap());
     const sqlQuery = sqlFromSteps(start, query.steps, factTypes, roleMap);
     return sqlQuery ? { sql: sqlQuery.sql, parameters: sqlQuery.parameters, pathLength: sqlQuery.pathLength, empty: sqlQuery.empty, factTypes, roleMap } : null;
@@ -61,7 +61,7 @@ describe('Postgres', () => {
     );
     expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
     expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
+    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
     expect(pathLength).toEqual(1);
   });
 
@@ -76,7 +76,7 @@ describe('Postgres', () => {
     );
     expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
     expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'Root'), 'parent'));
+    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Root'), 'parent'));
     expect(pathLength).toEqual(1);
   });
 
@@ -94,8 +94,8 @@ describe('Postgres', () => {
     );
       expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
       expect(parameters[1]).toEqual(startHash);
-      expect(parameters[2]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
-      expect(parameters[3]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'IntegrationTest.Grandchild'), 'successor'));
+      expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
+      expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Grandchild'), 'successor'));
       expect(pathLength).toEqual(1);
   });
 
@@ -113,8 +113,8 @@ describe('Postgres', () => {
     );
     expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
     expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
-    expect(parameters[3]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'IntegrationTest.Grandchild'), 'successor'));
+    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Successor'), 'predecessor'));
+    expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'IntegrationTest.Grandchild'), 'successor'));
     expect(pathLength).toEqual(1);
   });
 
@@ -132,8 +132,8 @@ describe('Postgres', () => {
     );
     expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
     expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'Child'), 'parent'));
-    expect(parameters[3]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'Child'), 'uncle'));
+    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'parent'));
+    expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'uncle'));
     expect(pathLength).toEqual(1);
   });
 
@@ -151,8 +151,8 @@ describe('Postgres', () => {
     );
     expect(parameters[0]).toEqual(getFactTypeId(factTypes, 'Root'));
     expect(parameters[1]).toEqual(startHash);
-    expect(parameters[2]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'Child'), 'parent'));
-    expect(parameters[3]).toEqual(getRoleId(roleMap, getFactTypeId(factTypes, 'Child'), 'uncle'));
+    expect(parameters[2]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'parent'));
+    expect(parameters[3]).toEqual(getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'uncle'));
     expect(pathLength).toEqual(1);
   });
 
@@ -174,9 +174,9 @@ describe('Postgres', () => {
     expect(parameters).toEqual([
       getFactTypeId(factTypes, 'Root'),
       startHash,
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Child'), 'parent'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Condition'), 'condition'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Other'), 'other')
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Child'), 'parent'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Condition'), 'condition'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Other'), 'other')
     ]);
   });
 
@@ -200,10 +200,10 @@ describe('Postgres', () => {
     expect(parameters).toEqual([
       getFactTypeId(factTypes, 'Root'),
       startHash,
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Identifier'), 'root'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Identifier'), 'prior'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Identifier'), 'identified'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Delete'), 'identified')
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Identifier'), 'root'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Identifier'), 'prior'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Identifier'), 'identified'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Delete'), 'identified')
     ]);
   });
 
@@ -230,10 +230,10 @@ describe('Postgres', () => {
     expect(parameters).toEqual([
       getFactTypeId(factTypes, 'Root'),
       startHash,
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Assignment'), 'user'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Assignment'), 'project'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Task'), 'project'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Task.Title'), 'task')
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'user'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'project'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Task'), 'project'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Task.Title'), 'task')
     ]);
     expect(pathLength).toEqual(4);
   });
@@ -281,7 +281,7 @@ describe('Postgres', () => {
     expect(parameters).toEqual([
       getFactTypeId(factTypes, 'Root'),
       startHash,
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Assignment'), 'root')
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'root')
     ]);
   });
 
@@ -298,7 +298,7 @@ describe('Postgres', () => {
     expect(parameters).toEqual([
       getFactTypeId(factTypes, 'Root'),
       startHash,
-      getRoleId(roleMap, getFactTypeId(factTypes, 'Assignment'), 'root')
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'Assignment'), 'root')
     ]);
   });
 
@@ -332,11 +332,11 @@ describe('Postgres', () => {
         ')' +
       ')');
     expect(parameters).toEqual([
-      getFactTypeId(factTypes, 'Catalog'),
+      getFactTypeId(factTypes, 'Root'),
       startHash,
-      getRoleId(roleMap, getFactTypeId(factTypes, 'ImprovingU.Idea'), 'catalog'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'ImprovingU.Idea.Deletion'), 'idea'),
-      getRoleId(roleMap, getFactTypeId(factTypes, 'ImprovingU.Idea.Restore'), 'ideaDeletion')
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'ImprovingU.Idea'), 'catalog'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'ImprovingU.Idea.Deletion'), 'idea'),
+      getRoleId(roleMap, ensureGetFactTypeId(factTypes, 'ImprovingU.Idea.Restore'), 'ideaDeletion')
     ]);
   });
 });
@@ -348,7 +348,7 @@ function allFactTypes(steps: Step[]): string[] {
   const childFactTypes = steps
     .filter(step => step instanceof ExistentialCondition)
     .flatMap(step => allFactTypes((step as ExistentialCondition).steps));
-  return [...factTypes, ...childFactTypes].filter(distinct);
+  return ["Root", ...factTypes, ...childFactTypes].filter(distinct);
 }
 
 function allRoles(steps: Step[], initialType: string) {

package/test/postgres/postgresSpecificationSpec.ts

@@ -28,7 +28,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;
             }

package/tsconfig.json

@@ -8,6 +8,7 @@
         "sourceMap": true,
         "declaration": true,
         "outDir": "./dist",
+        "strict": true,
         "forceConsistentCasingInFileNames": true,
         "skipLibCheck": true,
         "esModuleInterop": true,

package/tsconfig.test.json

@@ -0,0 +1,26 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "lib": [ "ES2019" ],
+        "noImplicitAny": true,
+        "moduleResolution": "node",
+        "sourceMap": true,
+        "declaration": true,
+        "outDir": "./dist",
+        "strict": true,
+        "forceConsistentCasingInFileNames": true,
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "baseUrl": ".",
+        "paths": {
+            "*": [
+                "./node_modules/*",
+                "./types/*"
+            ]
+        }
+    },
+    "include": [
+        "test/**/*.ts"
+    ]
+}

package/docs/specification.txt

@@ -1,41 +0,0 @@
-let user: Jinaga.User = me
-let semester: ImprovingU.Semester = #Ws6RWV8bWmP7ibBlzwL2UoKKwg6E1iItQPFpX/mvU5u6FLwHJAbRd0SbH+P1hoMn4QndhArLqJqVReRqJdoyBg==
-
-(semester: ImprovingU.Semester, user: Jinaga.User) {
-    catalog: ImprovingU.Catalog [
-        catalog->_in:ImprovingU.Semester = semester
-    ]
-} => {
-    office = catalog.office
-    courses = {
-        course: ImprovingU.Course [
-            course->_in:ImprovingU.Catalog = catalog
-            !E {
-                delete: ImprovingU.Course.Delete [
-                    delete->course:ImprovingU.Course = course
-                ]
-            }
-        ]
-    } => {
-        titles = {
-            title: ImprovingU.Course.Title [
-                title->course: ImprovingU.Course = course
-                !E {
-                    next: ImprovingU.Course.Title [
-                        next->prior: ImprovingU.Course.Title = title
-                    ]
-                }
-            ]
-        } => title.value
-        instructors = {
-            instructor: ImprovingU.Course.Instructor [
-                instructor->course: ImprovingU.Course = course
-                !E {
-                    next: ImprovingU.Course.Instructor [
-                        next->prior: ImprovingU.Course.Instructor = instructor
-                    ]
-                }
-            ]
-        } => instructor.value
-    }
-}