jinaga-server 3.1.4 → 3.2.0

package/src/postgres/purge-sql.ts

@@ -0,0 +1,125 @@
+import { FactReference, Specification } from "jinaga";
+import { FactTypeMap, RoleMap } from "./maps";
+import { EdgeDescription, FactByLabel, QueryDescription, QueryDescriptionBuilder } from "./query-description";
+
+export function purgeSqlFromSpecification(specification: Specification, factTypes: FactTypeMap, roleMap: RoleMap, schema: string):
+    { sql: string, parameters: (string | number)[] } | null {
+    const queryDescriptionBuilder = new QueryDescriptionBuilder(factTypes, roleMap);
+
+    let queryDescription = QueryDescription.unsatisfiable;
+    let knownFacts: FactByLabel = {};
+    const given = specification.given;
+    const start: FactReference[] = specification.given.map(g => ({ type: g.type, hash: 'xxxxx' }));
+    ({ queryDescription, knownFacts } = queryDescriptionBuilder.addEdges(queryDescription, given, start, knownFacts, [], specification.matches));
+
+    if (!queryDescription.isSatisfiable()) {
+        return null;
+    }
+
+    const query = generatePurgeSqlQuery(queryDescription, schema);
+    return query;
+}
+
+
+function generatePurgeSqlQuery(queryDescription: QueryDescription, schema: string):
+    { sql: string, parameters: (string | number)[] } {
+    if (queryDescription.existentialConditions.length > 0) {
+        throw new Error("Purge conditions should not have existential conditions");
+    }
+
+    const columns = queryDescription.outputs
+        .map((label, index) => `f${label.factIndex}.fact_id as trigger${index + 1}`)
+        .join(",\n        ");
+    const firstEdge = queryDescription.edges[0];
+    const predecessorFact = queryDescription.inputs.find(i => i.factIndex === firstEdge.predecessorFactIndex);
+    const successorFact = queryDescription.inputs.find(i => i.factIndex === firstEdge.successorFactIndex);
+    const firstFactIndex = predecessorFact ? predecessorFact.factIndex : successorFact!.factIndex;
+    const writtenFactIndexes = new Set<number>().add(firstFactIndex);
+    const joins: string[] = generateJoins(queryDescription.edges, writtenFactIndexes, schema);
+    const inputWhereClauses = queryDescription.inputs
+        .map(input => `f${input.factIndex}.fact_type_id = $${input.factTypeParameter}`)
+        .join(" AND ");
+    const triggerWhereClauses = queryDescription.outputs
+        .map((label, index) => `a.fact_id = c2.trigger${index + 1}`)
+        .join("\n            OR ");
+
+    const sql =
+        `WITH candidates AS (\n` +
+        `    SELECT\n` +
+        `        f${firstFactIndex}.fact_id as purge_root,\n` +
+        `        ${columns}\n` +
+        `    FROM ${schema}.fact f${firstFactIndex}\n${joins.join("")}` +
+        `    WHERE ${inputWhereClauses}\n` +
+        `), targets AS (\n` +
+        `    SELECT a.fact_id\n` +
+        `    FROM public.ancestor a\n` +
+        `    JOIN candidates c ON c.purge_root = a.ancestor_fact_id\n` +
+        `    WHERE NOT EXISTS (\n` +
+        `        SELECT 1\n` +
+        `        FROM candidates c2\n` +
+        `        WHERE ${triggerWhereClauses}\n` +
+        `    )\n` +
+        `), facts AS (\n` +
+        `    DELETE\n` +
+        `    FROM public.fact f\n` +
+        `    USING targets t WHERE t.fact_id = f.fact_id\n` +
+        `    RETURNING f.fact_id\n` +
+        `)\n` +
+        `SELECT fact_id FROM facts\n`;
+    
+    // Remove parameter 1, which is the hash of the first fact
+    const parameters = [
+        queryDescription.parameters[0],
+        ...queryDescription.parameters.slice(2)
+    ];
+        
+
+    return {
+        sql,
+        parameters: parameters
+    };
+}
+
+function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>, schema: string) {
+    const joins: string[] = [];
+    edges.forEach(edge => {
+        if (writtenFactIndexes.has(edge.predecessorFactIndex)) {
+            if (writtenFactIndexes.has(edge.successorFactIndex)) {
+                joins.push(
+                    `    JOIN ${schema}.edge e${edge.edgeIndex}\n` +
+                    `        ON e${edge.edgeIndex}.predecessor_fact_id = f${edge.predecessorFactIndex}.fact_id\n` +
+                    `        AND e${edge.edgeIndex}.successor_fact_id = f${edge.successorFactIndex}.fact_id\n` +
+                    `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1}\n`
+                );
+            }
+            else {
+                joins.push(
+                    `    JOIN ${schema}.edge e${edge.edgeIndex}\n` +
+                    `        ON e${edge.edgeIndex}.predecessor_fact_id = f${edge.predecessorFactIndex}.fact_id\n` +
+                    `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1}\n`
+                );
+                joins.push(
+                    `    JOIN ${schema}.fact f${edge.successorFactIndex}\n` +
+                    `        ON f${edge.successorFactIndex}.fact_id = e${edge.edgeIndex}.successor_fact_id\n`
+                );
+                writtenFactIndexes.add(edge.successorFactIndex);
+            }
+        }
+        else if (writtenFactIndexes.has(edge.successorFactIndex)) {
+            joins.push(
+                `    JOIN ${schema}.edge e${edge.edgeIndex}\n` +
+                `        ON e${edge.edgeIndex}.successor_fact_id = f${edge.successorFactIndex}.fact_id\n` +
+                `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1}\n`
+            );
+            joins.push(
+                `    JOIN ${schema}.fact f${edge.predecessorFactIndex}\n` +
+                `        ON f${edge.predecessorFactIndex}.fact_id = e${edge.edgeIndex}.predecessor_fact_id\n`
+            );
+            writtenFactIndexes.add(edge.predecessorFactIndex);
+        }
+        else {
+            throw new Error("Neither predecessor nor successor fact has been written");
+        }
+    });
+    return joins;
+}

package/src/postgres/query-description.ts

@@ -276,7 +276,7 @@ export type FactByLabel = {
     [label: string]: FactDescription;
 };
 
-export class QueryDescriptionBuider {
+export class QueryDescriptionBuilder {
     constructor(
         private factTypes: FactTypeMap,
         private roleMap: RoleMap

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

@@ -19,7 +19,7 @@ import {
 } from "jinaga";
 
 import { FactTypeMap, RoleMap } from "./maps";
-import { EdgeDescription, ExistentialConditionDescription, FactByLabel, QueryDescription, QueryDescriptionBuider } from "./query-description";
+import { EdgeDescription, ExistentialConditionDescription, FactByLabel, QueryDescription, QueryDescriptionBuilder } from "./query-description";
 
 function generateResultSqlQuery(queryDescription: QueryDescription, schema: string): SpecificationSqlQuery {
     const allLabels = [ ...queryDescription.inputs, ...queryDescription.outputs ];
@@ -481,7 +481,7 @@ interface NamedResultComposer {
 
 class ResultDescriptionBuilder {
     constructor(
-        private queryDescriptionBuilder: QueryDescriptionBuider
+        private queryDescriptionBuilder: QueryDescriptionBuilder
     ) { }
 
     buildDescription(start: FactReference[], specification: Specification): ResultDescription {
@@ -547,7 +547,7 @@ function idsEqual(a: number[], b: number[]) {
 }
 
 export function resultSqlFromSpecification(start: FactReference[], specification: Specification, factTypes: FactTypeMap, roleMap: RoleMap, schema: string): ResultComposer | null {
-    const queryDescriptionBuilder = new QueryDescriptionBuider(factTypes, roleMap);
+    const queryDescriptionBuilder = new QueryDescriptionBuilder(factTypes, roleMap);
     const descriptionBuilder = new ResultDescriptionBuilder(queryDescriptionBuilder);
     const description = descriptionBuilder.buildDescription(start, specification);
 

package/src/postgres/specification-sql.ts

@@ -5,7 +5,7 @@ import {
     validateGiven
 } from "jinaga";
 
-import { EdgeDescription, ExistentialConditionDescription, QueryDescription, QueryDescriptionBuider } from "./query-description";
+import { EdgeDescription, ExistentialConditionDescription, QueryDescription, QueryDescriptionBuilder } from "./query-description";
 
 interface SpecificationLabel {
     type: string;
@@ -173,7 +173,7 @@ export function sqlFromSpecification(start: FactReference[], schema: string, boo
     }, new Map<string, FactReference>());
 
     const feeds = buildFeeds(specification);
-    const queryDescriptionBuilder = new QueryDescriptionBuider(factTypes, roleMap);
+    const queryDescriptionBuilder = new QueryDescriptionBuilder(factTypes, roleMap);
     const feedAndBookmark = feeds.map((feed, index) => ({
         feed,
         bookmark: bookmarks[index]
@@ -193,7 +193,7 @@ export function sqlFromSpecification(start: FactReference[], schema: string, boo
 }
 
 export function sqlFromFeed(feed: Specification, start: FactReference[], schema: string, bookmark: string, limit: number, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery | null {
-    const queryDescriptionBuilder = new QueryDescriptionBuider(factTypes, roleMap);
+    const queryDescriptionBuilder = new QueryDescriptionBuilder(factTypes, roleMap);
     const queryDescription = buildQueryDescription(queryDescriptionBuilder, feed, start);
     if (!queryDescription.isSatisfiable()) {
         return null;
@@ -202,7 +202,7 @@ export function sqlFromFeed(feed: Specification, start: FactReference[], schema:
     return sql;
 }
 
-function buildQueryDescription(queryDescriptionBuilder: QueryDescriptionBuider, specification: Specification, start: FactReference[]): QueryDescription {
+function buildQueryDescription(queryDescriptionBuilder: QueryDescriptionBuilder, specification: Specification, start: FactReference[]): QueryDescription {
     const { queryDescription } = queryDescriptionBuilder.addEdges(
         QueryDescription.unsatisfiable,
         specification.given,

package/test/authorization/authorizationSpec.ts

@@ -164,7 +164,7 @@ function givenAuthorizationWithStorage(storage: MemoryStore) {
     const fork = new PassThroughFork(storage);
     const observableSource = new ObservableSource(storage);
     const network = new NetworkNoOp();
-    const factManager = new FactManager(fork, observableSource, storage, network);
+    const factManager = new FactManager(fork, observableSource, storage, network, []);
     const model = buildModel(b => b
         .type(Hashtag)
         .type(User)

package/test/models/blog.ts

@@ -0,0 +1,92 @@
+import { buildModel, PurgeConditions, User } from "jinaga";
+
+export class Site {
+    static Type = 'Blog.Site' as const;
+    type = Site.Type;
+
+    constructor(
+        public readonly creator: User,
+        public readonly domain: string
+    ) { }
+}
+
+export class SiteDeleted {
+    static Type = 'Blog.Site.Deleted' as const;
+    type = SiteDeleted.Type;
+
+    constructor(
+        public readonly site: Site
+    ) { }
+}
+
+export class SitePurged {
+    static Type = 'Blog.Site.Purged' as const;
+    type = SitePurged.Type;
+
+    constructor(
+        public readonly deleted: SiteDeleted
+    ) { }
+}
+
+export class Post {
+    static Type = 'Blog.Post' as const;
+    type = Post.Type;
+
+    constructor(
+        public readonly site: Site,
+        public readonly createdAt: Date | string
+    ) { }
+}
+
+export class PostDeleted {
+    static Type = 'Blog.Post.Deleted' as const;
+    type = PostDeleted.Type;
+
+    constructor(
+        public readonly post: Post
+    ) { }
+}
+
+export class Title {
+    static Type = 'Blog.Post.Title' as const;
+    type = Title.Type;
+
+    constructor(
+        public readonly post: Post,
+        public readonly value: string,
+        public readonly prior: Title[]
+    ) { }
+}
+
+export const model = buildModel(b => b
+    .type(Site, f => f
+        .predecessor('creator', User)
+    )
+    .type(Post, f => f
+        .predecessor('site', Site)
+    )
+    .type(SiteDeleted, f => f
+        .predecessor('site', Site)
+    )
+    .type(SitePurged, f => f
+        .predecessor('deleted', SiteDeleted)
+    )
+    .type(Title, f => f
+        .predecessor('post', Post)
+        .predecessor('prior', Title)
+    )
+    .type(PostDeleted, f => f
+        .predecessor('post', Post)
+    )
+)
+
+export const purgeConditions = (p: PurgeConditions) => p
+    .whenExists(model.given(Site).match((site, facts) =>
+        facts.ofType(SiteDeleted)
+            .join(deleted => deleted.site, site)
+    ))
+    .whenExists(model.given(Post).match((post, facts) =>
+        facts.ofType(PostDeleted)
+            .join(deleted => deleted.post, post)
+    ))
+    ;

package/test/postgres/purgeSqlSpec.ts

@@ -0,0 +1,218 @@
+import { Specification } from "jinaga";
+import { ensureGetFactTypeId, FactTypeMap, getRoleId } from "../../src/postgres/maps";
+import { purgeSqlFromSpecification } from "../../src/postgres/purge-sql";
+import { model, Site, SiteDeleted, SitePurged } from "../models/blog";
+
+describe("Purge SQL", () => {
+    it("should handle direct successor", () => {
+        const specification = model.given(Site).match((site, facts) =>
+            facts.ofType(SiteDeleted)
+                .join(deleted => deleted.site, site)
+        ).specification;
+        const factTypes = buildFactTypeMap(
+            Site.Type,
+            SiteDeleted.Type
+        );
+        const roleMap = buildRoleMap(factTypes,
+            [Site.Type, ['creator']],
+            [SiteDeleted.Type, ['site']]
+        );
+        const schema = 'public';
+        const { sql, parameters } = whenGeneratePurgeSql(specification, factTypes, roleMap, schema);
+
+        const expected =
+`WITH candidates AS (
+    SELECT
+        f1.fact_id as purge_root,
+        f2.fact_id as trigger1
+    FROM public.fact f1
+    JOIN public.edge e1
+        ON e1.predecessor_fact_id = f1.fact_id
+        AND e1.role_id = $2
+    JOIN public.fact f2
+        ON f2.fact_id = e1.successor_fact_id
+    WHERE f1.fact_type_id = $1
+), targets AS (
+    SELECT a.fact_id
+    FROM public.ancestor a
+    JOIN candidates c ON c.purge_root = a.ancestor_fact_id
+    WHERE NOT EXISTS (
+        SELECT 1
+        FROM candidates c2
+        WHERE a.fact_id = c2.trigger1
+    )
+), facts AS (
+    DELETE
+    FROM public.fact f
+    USING targets t WHERE t.fact_id = f.fact_id
+    RETURNING f.fact_id
+)
+SELECT fact_id FROM facts
+`;
+
+        expect(sql).toBe(expected);
+        expect(parameters).toEqual([
+            ensureGetFactTypeId(factTypes, Site.Type),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SiteDeleted.Type), 'site')
+        ]);
+    });
+
+    it("should handle two levels of successors", () => {
+        const specification = model.given(Site).match((site, facts) =>
+            facts.ofType(SitePurged)
+                .join(purged => purged.deleted.site, site)
+        ).specification;
+        const factTypes = buildFactTypeMap(
+            Site.Type,
+            SiteDeleted.Type,
+            SitePurged.Type
+        );
+        const roleMap = buildRoleMap(factTypes,
+            [Site.Type, ['creator']],
+            [SiteDeleted.Type, ['site']],
+            [SitePurged.Type, ['deleted']]
+        );
+        const schema = 'public';
+        const { sql, parameters } = whenGeneratePurgeSql(specification, factTypes, roleMap, schema);
+
+        const expected =
+`WITH candidates AS (
+    SELECT
+        f1.fact_id as purge_root,
+        f3.fact_id as trigger1
+    FROM public.fact f1
+    JOIN public.edge e1
+        ON e1.predecessor_fact_id = f1.fact_id
+        AND e1.role_id = $2
+    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 = $3
+    JOIN public.fact f3
+        ON f3.fact_id = e2.successor_fact_id
+    WHERE f1.fact_type_id = $1
+), targets AS (
+    SELECT a.fact_id
+    FROM public.ancestor a
+    JOIN candidates c ON c.purge_root = a.ancestor_fact_id
+    WHERE NOT EXISTS (
+        SELECT 1
+        FROM candidates c2
+        WHERE a.fact_id = c2.trigger1
+    )
+), facts AS (
+    DELETE
+    FROM public.fact f
+    USING targets t WHERE t.fact_id = f.fact_id
+    RETURNING f.fact_id
+)
+SELECT fact_id FROM facts
+`;
+
+        expect(sql).toBe(expected);
+        expect(parameters).toEqual([
+            ensureGetFactTypeId(factTypes, Site.Type),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SiteDeleted.Type), 'site'),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SitePurged.Type), 'deleted')
+        ]);
+    });
+
+    it("should handle two labeled successors", () => {
+        const specification = model.given(Site).match((site, facts) =>
+            facts.ofType(SiteDeleted)
+                .join(deleted => deleted.site, site)
+            .selectMany(deleted =>
+                facts.ofType(SitePurged)
+                    .join(purged => purged.deleted, deleted)
+            )).specification;
+        const factTypes = buildFactTypeMap(
+            Site.Type,
+            SiteDeleted.Type,
+            SitePurged.Type
+        );
+        const roleMap = buildRoleMap(factTypes,
+            [Site.Type, ['creator']],
+            [SiteDeleted.Type, ['site']],
+            [SitePurged.Type, ['deleted']]
+        );
+        const schema = 'public';
+        const { sql, parameters } = whenGeneratePurgeSql(specification, factTypes, roleMap, schema);
+
+        const expected =
+`WITH candidates AS (
+    SELECT
+        f1.fact_id as purge_root,
+        f2.fact_id as trigger1,
+        f3.fact_id as trigger2
+    FROM public.fact f1
+    JOIN public.edge e1
+        ON e1.predecessor_fact_id = f1.fact_id
+        AND e1.role_id = $2
+    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 = $3
+    JOIN public.fact f3
+        ON f3.fact_id = e2.successor_fact_id
+    WHERE f1.fact_type_id = $1
+), targets AS (
+    SELECT a.fact_id
+    FROM public.ancestor a
+    JOIN candidates c ON c.purge_root = a.ancestor_fact_id
+    WHERE NOT EXISTS (
+        SELECT 1
+        FROM candidates c2
+        WHERE a.fact_id = c2.trigger1
+            OR a.fact_id = c2.trigger2
+    )
+), facts AS (
+    DELETE
+    FROM public.fact f
+    USING targets t WHERE t.fact_id = f.fact_id
+    RETURNING f.fact_id
+)
+SELECT fact_id FROM facts
+`;
+
+        expect(sql).toBe(expected);
+        expect(parameters).toEqual([
+            ensureGetFactTypeId(factTypes, Site.Type),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SiteDeleted.Type), 'site'),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SitePurged.Type), 'deleted')
+        ]);
+    });
+});
+
+function whenGeneratePurgeSql(specification: Specification, factTypes: FactTypeMap, roleMap: Map<number, Map<string, number>>, schema: string) {
+    const purgeCommand = purgeSqlFromSpecification(specification, factTypes, roleMap, schema);
+    if (purgeCommand === null) {
+        throw new Error("The specification was not satisfiable.");
+    }
+    return purgeCommand;
+}
+
+function buildFactTypeMap(...types: string[]): FactTypeMap {
+    const factTypeMap: FactTypeMap = new Map();
+    types.forEach((type, index) => {
+        factTypeMap.set(type, index + 1);
+    });
+    return factTypeMap;
+}
+
+function buildRoleMap(factTypes: FactTypeMap, ...args: [string, string[]][]): Map<number, Map<string, number>> {
+    const roleMap = new Map<number, Map<string, number>>();
+    args.forEach(([type, roles]) => {
+        const typeId = factTypes.get(type);
+        if (typeId === undefined) {
+            throw new Error(`Unknown fact type: ${type}`);
+        }
+        const roleIdMap = new Map<string, number>();
+        roles.forEach((role, roleIndex) => {
+            roleIdMap.set(role, typeId * 10 + roleIndex + 1);
+        });
+        roleMap.set(typeId, roleIdMap);
+    });
+    return roleMap;
+}