jinaga-server 3.1.5 → 3.2.0

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