jinaga-server 1.1.4 → 2.0.0

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
-    }
-}

package/interactive/index.js

@@ -1,56 +0,0 @@
-const { SpecificationParser } = require("../dist/specification/specification-parser");
-const { dehydrateFact } = require("../dist/fact/hydrate");
-const { PostgresStore } = require("../dist/postgres/postgres-store")
-const fs = require("fs");
-
-var user = {"publicKey":"-----BEGIN RSA PUBLIC KEY-----\nMIGJAoGBAIBsKomutukULWw2zoTW2ECMrM8VmD2xvfpl3R4qh1whzuXV+A4EfRKMb/UAjEfw\n5nBmWvcObGyYUgygKrlNeOhf3MnDj706rej6ln9cKGL++ZNsJgJsogaAtmkPihWVGi908fdP\nLQrWTF5be0b/ZP258Zs3CTpcRTpTvhzS5TC1AgMBAAE=\n-----END RSA PUBLIC KEY-----\n","type":"Jinaga.User"};
-
-async function run() {
-    try {
-        var postgresStore = new PostgresStore("postgresql://dev:devpw@localhost:5432/improvingu");
-        try {
-            var input = fs.readFileSync(0, 'utf-8');
-            const parser = new SpecificationParser(input);
-            parser.skipWhitespace();
-            const userRecord = dehydrateFact(user)[0];
-            const knownFacts = {
-                me: {
-                    fact: userRecord,
-                    reference: {
-                        type: userRecord.type,
-                        hash: userRecord.hash
-                    }
-                }
-            };
-            var declaration = parser.parseDeclaration(knownFacts);
-            var specification = parser.parseSpecification();
-
-            // Select starting facts that match the inputs
-            const start = specification.given.map(input => {
-                const fact = declaration[input.name];
-                if (!fact) {
-                    throw new Error(`No fact named ${input.name} was declared`);
-                }
-                return fact.reference;
-            });
-
-            const args = process.argv.slice(2);
-            const produceResults = args.includes("--results");
-            if (produceResults) {
-                const results = await postgresStore.resultsFromSpecification(start, specification);
-                console.log(JSON.stringify(results, null, 2));
-            }
-            else {
-                const streams = await postgresStore.streamsFromSpecification(start, [], 3, specification);
-                console.log(JSON.stringify(streams, null, 2));
-            }
-        }
-        finally {
-            postgresStore.close();
-        }
-    } catch (e) {
-        console.error(e);
-    }
-}
-
-run();