jinaga-server 3.5.2 → 3.5.3

package/test/postgres/postgresReadSpec.ts

@@ -35,13 +35,13 @@ function sqlFor(descriptiveString: string, bookmarks: string[] = []) {
         },
         emptyRoleMap());
     const start = specification.given.map(input => {
-        if (input.type === "Company") {
+        if (input.label.type === "Company") {
             return company;
         }
-        if (input.type === "Jinaga.User") {
+        if (input.label.type === "Jinaga.User") {
             return user;
         }
-        throw new Error(`Unknown input type ${input.type}`);
+        throw new Error(`Unknown input type ${input.label.type}`);
     });
     const composer = resultSqlFromSpecification(start, specification, factTypes, roleMap, "public");
     if (!composer) {
@@ -75,8 +75,8 @@ describe("Postgres read", () => {
         const sql = composer.getSqlQueries().sqlQuery.sql;
         expect(sql).toEqual(
             `SELECT ` +
-                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, ` +
-                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2 ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2, f2.date_learned as timestamp2 ` +
             `FROM public.fact f1 ` +
             `JOIN public.edge e1 ` +
                 `ON e1.predecessor_fact_id = f1.fact_id ` +
@@ -106,8 +106,8 @@ describe("Postgres read", () => {
         const sql = tree.sqlQuery.sql;
         expect(sql).toEqual(
             `SELECT ` +
-                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, ` +
-                `f3.hash as hash3, f3.fact_id as id3, f3.data as data3 ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f3.hash as hash3, f3.fact_id as id3, f3.data as data3, f3.date_learned as timestamp3 ` +
             `FROM public.fact f1 ` +
             `JOIN public.edge e1 ` +
                 `ON e1.predecessor_fact_id = f1.fact_id ` +
@@ -157,8 +157,8 @@ describe("Postgres read", () => {
         const sql = tree.sqlQuery.sql;
         expect(sql).toEqual(
             `SELECT ` +
-                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, ` +
-                `f3.hash as hash3, f3.fact_id as id3, f3.data as data3 ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f3.hash as hash3, f3.fact_id as id3, f3.data as data3, f3.date_learned as timestamp3 ` +
             `FROM public.fact f1 ` +
             `JOIN public.edge e1 ` +
                 `ON e1.predecessor_fact_id = f1.fact_id ` +
@@ -213,8 +213,8 @@ describe("Postgres read", () => {
         const sql = tree.sqlQuery.sql;
         expect(sql).toEqual(
             `SELECT ` +
-                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, ` +
-                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2 ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2, f2.date_learned as timestamp2 ` +
             `FROM public.fact f1 ` +
             `JOIN public.edge e1 ` +
                 `ON e1.predecessor_fact_id = f1.fact_id ` +
@@ -293,9 +293,9 @@ describe("Postgres read", () => {
         const queries = composer.getSqlQueries();
         expect(queries.sqlQuery.sql).toEqual(
             `SELECT ` +
-                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, ` +
-                `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 ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f3.hash as hash3, f3.fact_id as id3, f3.data as data3, f3.date_learned as timestamp3, ` +
+                `f9.hash as hash9, f9.fact_id as id9, f9.data as data9, f9.date_learned as timestamp9 ` +
             `FROM public.fact f1 ` +
             `JOIN public.edge e1 ` +
                 `ON e1.predecessor_fact_id = f1.fact_id ` +
@@ -349,4 +349,182 @@ describe("Postgres read", () => {
                 `) ` +
             `ORDER BY f3.fact_id ASC, f9.fact_id ASC`);
     });
+
+    it("should read time projection for a successor", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                department: Department [
+                    department->company: Company = company
+                ]
+            } => @department
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2, f2.date_learned as timestamp2 ` +
+            `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`
+        );
+        expect(tree.sqlQuery.parameters).toEqual([
+            getFactTypeId(factTypes, 'Company'),
+            companyHash,
+            roleParameter(roleMap, factTypes, 'Department', 'company')
+        ]);
+    });
+
+    it("should read time projection with field projection", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                department: Department [
+                    department->company: Company = company
+                ]
+            } => {
+                name = department.name
+                createdAt = @department
+            }
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2, f2.date_learned as timestamp2 ` +
+            `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`
+        );
+        expect(tree.sqlQuery.parameters).toEqual([
+            getFactTypeId(factTypes, 'Company'),
+            companyHash,
+            roleParameter(roleMap, factTypes, 'Department', 'company')
+        ]);
+    });
+
+    it("should read time projection with fact projection", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                department: Department [
+                    department->company: Company = company
+                ]
+            } => {
+                department = department
+                createdAt = @department
+            }
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2, f2.date_learned as timestamp2 ` +
+            `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`
+        );
+        expect(tree.sqlQuery.parameters).toEqual([
+            getFactTypeId(factTypes, 'Company'),
+            companyHash,
+            roleParameter(roleMap, factTypes, 'Department', 'company')
+        ]);
+    });
+
+    it("should read time projection with multiple timestamps", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                department: Department [
+                    department->company: Company = company
+                ]
+            } => {
+                companyCreatedAt = @company
+                department = department
+                departmentCreatedAt = @department
+            }
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2, f2.date_learned as timestamp2 ` +
+            `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`
+        );
+        expect(tree.sqlQuery.parameters).toEqual([
+            getFactTypeId(factTypes, 'Company'),
+            companyHash,
+            roleParameter(roleMap, factTypes, 'Department', 'company')
+        ]);
+    });
+
+    it("should read time projection with nested successor", () => {
+        const { composer, factTypes, roleMap } = sqlFor(`
+            (company: Company) {
+                department: Department [
+                    department->company: Company = company
+                ]
+                project: Project [
+                    project->department: Department = department
+                ]
+            } => {
+                projectName = project.name
+                projectCreatedAt = @project
+            }
+        `);
+
+        const tree = composer.getSqlQueries();
+        const sql = tree.sqlQuery.sql;
+        expect(sql).toEqual(
+            `SELECT ` +
+                `f1.hash as hash1, f1.fact_id as id1, f1.data as data1, f1.date_learned as timestamp1, ` +
+                `f2.hash as hash2, f2.fact_id as id2, f2.data as data2, f2.date_learned as timestamp2, ` +
+                `f3.hash as hash3, f3.fact_id as id3, f3.data as data3, f3.date_learned as timestamp3 ` +
+            `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 ` +
+            `ORDER BY f2.fact_id ASC, f3.fact_id ASC`
+        );
+        expect(tree.sqlQuery.parameters).toEqual([
+            getFactTypeId(factTypes, 'Company'),
+            companyHash,
+            roleParameter(roleMap, factTypes, 'Department', 'company'),
+            roleParameter(roleMap, factTypes, 'Project', 'department')
+        ]);
+    });
 });

package/test/postgres/postgresSpecificationSpec.ts

@@ -36,13 +36,13 @@ function sqlFor(descriptiveString: string, bookmarks: string[] = []) {
         },
         emptyRoleMap());
     const start = specification.given.map(input => {
-        if (input.type === 'Root') {
+        if (input.label.type === 'Root') {
             return root;
         }
-        if (input.type === 'Jinaga.User') {
+        if (input.label.type === 'Jinaga.User') {
             return user;
         }
-        throw new Error(`Unknown input type ${input.type}`);
+        throw new Error(`Unknown input type ${input.label.type}`);
     });
     const sqlQueries = sqlFromSpecification(start, "public", bookmarks, 100, specification, factTypes, roleMap);
     return { sqlQueries, factTypes, roleMap };

package/test/postgres/specificationConditionsSpec.ts

@@ -0,0 +1,268 @@
+import { dehydrateReference, getAllFactTypes, getAllRoles, SpecificationParser } from "jinaga";
+
+import { addFactType, addRole, emptyFactTypeMap, emptyRoleMap, getFactTypeId, getRoleId } from "../../src/postgres/maps";
+import { sqlFromSpecification } from "../../src/postgres/specification-sql";
+
+const root = dehydrateReference({ type: 'Root' });
+const rootHash = root.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.label.type === 'Root') {
+            return root;
+        }
+        throw new Error(`Unknown input type ${input.label.type}`);
+    });
+    const sqlQueries = sqlFromSpecification(start, "public", bookmarks, 100, specification, factTypes, roleMap);
+    return { sqlQueries, 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("Specification conditions", () => {
+    describe("Processing given conditions", () => {
+        it("should generate SQL for single existential condition on given", () => {
+            const { sqlQueries, factTypes, roleMap } = sqlFor(`
+                (root: Root [
+                    E {
+                        tag: MyApplication.Tag [
+                            tag->root: Root = root
+                        ]
+                    }
+                ]) {
+                    project: MyApplication.Project [
+                        project->root: Root = root
+                    ]
+                }
+            `);
+
+            expect(sqlQueries.length).toBe(1);
+            const query = sqlQueries[0];
+            
+            // The SQL should include an EXISTS clause for the condition on the given
+            expect(query.sql).toContain('EXISTS');
+            expect(query.sql).toEqual(
+                'SELECT f2.hash as hash2, ' +
+                'sort(array[f2.fact_id], \'desc\') as bookmark ' +
+                '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 ' +
+                'AND EXISTS (' +
+                    'SELECT 1 ' +
+                    'FROM public.edge e2 ' +
+                    'JOIN public.fact f3 ON f3.fact_id = e2.successor_fact_id ' +
+                    'WHERE e2.predecessor_fact_id = f1.fact_id AND e2.role_id = $4' +
+                ') ' +
+                'AND sort(array[f2.fact_id], \'desc\') > $5 ' +
+                'ORDER BY bookmark ASC ' +
+                'LIMIT $6'
+            );
+            expect(query.parameters).toEqual([
+                getFactTypeId(factTypes, 'Root'),
+                rootHash,
+                roleParameter(roleMap, factTypes, 'MyApplication.Project', 'root'),
+                roleParameter(roleMap, factTypes, 'MyApplication.Tag', 'root'),
+                [],
+                100
+            ]);
+            expect(query.labels).toEqual([
+                {
+                    type: 'MyApplication.Project',
+                    index: 2
+                }
+            ]);
+        });
+        it("should generate SQL for multiple conditions on same given", () => {
+            const { sqlQueries, factTypes, roleMap } = sqlFor(`
+                (root: Root [
+                    E {
+                        tag: MyApplication.Tag [
+                            tag->root: Root = root
+                        ]
+                    }
+                    E {
+                        category: MyApplication.Category [
+                            category->root: Root = root
+                        ]
+                    }
+                ]) {
+                    project: MyApplication.Project [
+                        project->root: Root = root
+                    ]
+                }
+            `);
+
+            expect(sqlQueries.length).toBe(1);
+            const query = sqlQueries[0];
+            
+            // The SQL should include TWO EXISTS clauses for the two conditions on the given
+            const existsCount = (query.sql.match(/EXISTS/g) || []).length;
+            expect(existsCount).toBe(2);
+            
+            // Both EXISTS clauses should be connected with AND
+            expect(query.sql).toContain('AND EXISTS');
+            
+            // Verify the complete SQL structure with both EXISTS clauses
+            expect(query.sql).toEqual(
+                'SELECT f2.hash as hash2, ' +
+                'sort(array[f2.fact_id], \'desc\') as bookmark ' +
+                '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 ' +
+                'AND EXISTS (' +
+                    'SELECT 1 ' +
+                    'FROM public.edge e2 ' +
+                    'JOIN public.fact f3 ON f3.fact_id = e2.successor_fact_id ' +
+                    'WHERE e2.predecessor_fact_id = f1.fact_id AND e2.role_id = $4' +
+                ') ' +
+                '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 = f1.fact_id AND e3.role_id = $5' +
+                ') ' +
+                'AND sort(array[f2.fact_id], \'desc\') > $6 ' +
+                'ORDER BY bookmark ASC ' +
+                'LIMIT $7'
+            );
+            expect(query.parameters).toEqual([
+                getFactTypeId(factTypes, 'Root'),
+                rootHash,
+                roleParameter(roleMap, factTypes, 'MyApplication.Project', 'root'),
+                roleParameter(roleMap, factTypes, 'MyApplication.Tag', 'root'),
+                roleParameter(roleMap, factTypes, 'MyApplication.Category', 'root'),
+                [],
+                100
+            ]);
+            expect(query.labels).toEqual([
+                {
+                    type: 'MyApplication.Project',
+                    index: 2
+                }
+            ]);
+        });
+        
+        it("should generate SQL for conditions on multiple givens", () => {
+            const { sqlQueries, factTypes, roleMap } = sqlFor(`
+                (root1: Root [
+                    E {
+                        tag1: MyApplication.Tag [
+                            tag1->root: Root = root1
+                        ]
+                    }
+                ], root2: Root [
+                    E {
+                        tag2: MyApplication.Tag [
+                            tag2->root: Root = root2
+                        ]
+                    }
+                ]) {
+                    project: MyApplication.Project [
+                        project->root1: Root = root1
+                        project->root2: Root = root2
+                    ]
+                }
+            `);
+
+            expect(sqlQueries.length).toBe(1);
+            const query = sqlQueries[0];
+            
+            // The SQL should include TWO EXISTS clauses, one for each given's condition
+            const existsCount = (query.sql.match(/EXISTS/g) || []).length;
+            expect(existsCount).toBe(2);
+            
+            // Verify the SQL contains conditions for both givens
+            expect(query.sql).toContain('AND EXISTS');
+            
+            // The SQL should reference both f1 (root1) and f3 (root2) in the EXISTS clauses
+            expect(query.sql).toMatch(/WHERE e\d+\.predecessor_fact_id = f1\.fact_id/);
+            expect(query.sql).toMatch(/WHERE e\d+\.predecessor_fact_id = f3\.fact_id/);
+            
+            // Verify the complete SQL structure
+            expect(query.sql).toEqual(
+                'SELECT f2.hash as hash2, ' +
+                'sort(array[f2.fact_id], \'desc\') as bookmark ' +
+                '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.successor_fact_id = f2.fact_id AND e2.role_id = $6 ' +
+                'JOIN public.fact f3 ON f3.fact_id = e2.predecessor_fact_id ' +
+                'WHERE f1.fact_type_id = $1 AND f1.hash = $2 ' +
+                'AND f3.fact_type_id = $4 AND f3.hash = $5 ' +
+                '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 = f1.fact_id AND e3.role_id = $7' +
+                ') ' +
+                'AND EXISTS (' +
+                    'SELECT 1 ' +
+                    'FROM public.edge e4 ' +
+                    'JOIN public.fact f5 ON f5.fact_id = e4.successor_fact_id ' +
+                    'WHERE e4.predecessor_fact_id = f3.fact_id AND e4.role_id = $8' +
+                ') ' +
+                'AND sort(array[f2.fact_id], \'desc\') > $9 ' +
+                'ORDER BY bookmark ASC ' +
+                'LIMIT $10'
+            );
+            
+            expect(query.parameters).toEqual([
+                getFactTypeId(factTypes, 'Root'),
+                rootHash,
+                roleParameter(roleMap, factTypes, 'MyApplication.Project', 'root1'),
+                getFactTypeId(factTypes, 'Root'),
+                rootHash,
+                roleParameter(roleMap, factTypes, 'MyApplication.Project', 'root2'),
+                roleParameter(roleMap, factTypes, 'MyApplication.Tag', 'root'),
+                roleParameter(roleMap, factTypes, 'MyApplication.Tag', 'root'),
+                [],
+                100
+            ]);
+            
+            expect(query.labels).toEqual([
+                {
+                    type: 'MyApplication.Project',
+                    index: 2
+                }
+            ]);
+        });
+    });
+});