jinaga-server 3.1.5 → 3.3.0

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/purgeDescendantsSqlSpec.ts

@@ -0,0 +1,41 @@
+import { purgeDescendantsSql } from "../../src/postgres/purge-sql";
+
+describe("Purge Descendants SQL", () => {
+    it("should handle single trigger", () => {
+        const sql = purgeDescendantsSql(1, 'public');
+
+        const expected =
+            `WITH purge_root AS (\n` +
+            `    SELECT pr.fact_id\n` +
+            `    FROM public.fact pr\n` +
+            `    WHERE pr.fact_type_id = $1\n` +
+            `        AND pr.hash = $2\n` +
+            `), triggers AS (\n` +
+            `    SELECT t.fact_id\n` +
+            `    FROM public.fact t\n` +
+            `    WHERE (t.fact_type_id = $3 AND t.hash = $4)\n` +
+            `), triggers_and_ancestors AS (\n` +
+            `    SELECT t.fact_id\n` +
+            `    FROM triggers t\n` +
+            `    UNION\n` +
+            `    SELECT a.ancestor_fact_id\n` +
+            `    FROM public.ancestor a\n` +
+            `    JOIN triggers t\n` +
+            `        ON a.fact_id = t.fact_id\n` +
+            `), targets AS (\n` +
+            `    SELECT a.fact_id\n` +
+            `    FROM public.ancestor a\n` +
+            `    JOIN purge_root pr\n` +
+            `        ON a.ancestor_fact_id = pr.fact_id\n` +
+            `    WHERE a.fact_id NOT IN (SELECT * FROM triggers_and_ancestors)\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`;
+
+        expect(sql).toBe(expected);
+    });
+});

package/test/postgres/purgeSqlSpec.ts

@@ -0,0 +1,246 @@
+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
+    )
+    AND NOT EXISTS (
+        SELECT 1
+        FROM candidates c2
+        JOIN public.ancestor a2
+            ON a2.fact_id = c2.trigger1
+        WHERE a.fact_id = a2.ancestor_fact_id
+    )
+), 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
+    )
+    AND NOT EXISTS (
+        SELECT 1
+        FROM candidates c2
+        JOIN public.ancestor a2
+            ON a2.fact_id = c2.trigger1
+        WHERE a.fact_id = a2.ancestor_fact_id
+    )
+), 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
+    )
+    AND NOT EXISTS (
+        SELECT 1
+        FROM candidates c2
+        JOIN public.ancestor a2
+            ON a2.fact_id = c2.trigger1
+        WHERE a.fact_id = a2.ancestor_fact_id
+    )
+    AND NOT EXISTS (
+        SELECT 1
+        FROM candidates c2
+        JOIN public.ancestor a2
+            ON a2.fact_id = c2.trigger2
+        WHERE a.fact_id = a2.ancestor_fact_id
+    )
+), 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;
+}