jinaga-server 3.1.5 → 3.3.0

package/scripts/purge.sql

@@ -0,0 +1,33 @@
+ROLLBACK TRANSACTION;
+
+BEGIN TRANSACTION;
+
+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 = 26
+    JOIN public.fact f2
+        ON f2.fact_id = e1.successor_fact_id
+    WHERE f1.fact_type_id = 2
+), 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 = c.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;
+
+ROLLBACK TRANSACTION;

package/setup.sh

@@ -23,12 +23,12 @@ psql -v ON_ERROR_STOP=1 $JINAGA_ADMIN_CONNECTION_STRING <<-EOSQL
     GRANT SELECT, USAGE ON SEQUENCE fact_type_fact_type_id_seq TO $JINAGA_POSTGRES_APP_USER;
     GRANT SELECT,INSERT ON TABLE public.role TO $JINAGA_POSTGRES_APP_USER;
     GRANT SELECT, USAGE ON SEQUENCE role_role_id_seq TO $JINAGA_POSTGRES_APP_USER;
-    GRANT SELECT,INSERT ON TABLE public.fact TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.fact TO $JINAGA_POSTGRES_APP_USER;
     GRANT SELECT, USAGE ON SEQUENCE fact_fact_id_seq TO $JINAGA_POSTGRES_APP_USER;
-    GRANT SELECT,INSERT ON TABLE public.edge TO $JINAGA_POSTGRES_APP_USER;
-    GRANT SELECT,INSERT ON TABLE public.ancestor TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.edge TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.ancestor TO $JINAGA_POSTGRES_APP_USER;
     GRANT SELECT,INSERT ON TABLE public.public_key TO $JINAGA_POSTGRES_APP_USER;
     GRANT SELECT, USAGE ON SEQUENCE public_key_public_key_id_seq TO $JINAGA_POSTGRES_APP_USER;
-    GRANT SELECT,INSERT ON TABLE public.signature TO $JINAGA_POSTGRES_APP_USER;
+    GRANT SELECT,INSERT,DELETE ON TABLE public.signature TO $JINAGA_POSTGRES_APP_USER;
     GRANT SELECT,INSERT ON TABLE public.user TO $JINAGA_POSTGRES_APP_USER;
 EOSQL

package/setup.sql

@@ -127,11 +127,13 @@ IF (SELECT to_regclass('public.edge') IS NULL) THEN
         successor_fact_id integer NOT NULL,
         CONSTRAINT fk_successor_fact_id
             FOREIGN KEY (successor_fact_id)
-            REFERENCES fact (fact_id),
+            REFERENCES fact (fact_id)
+            ON DELETE CASCADE,
         predecessor_fact_id integer NOT NULL,
         CONSTRAINT fk_predecessor_fact_id
             FOREIGN KEY (predecessor_fact_id)
             REFERENCES fact (fact_id)
+            ON DELETE CASCADE
     );
 
 
@@ -156,11 +158,13 @@ IF (SELECT to_regclass('public.ancestor') IS NULL) THEN
         fact_id integer NOT NULL,
         CONSTRAINT fk_fact_id
             FOREIGN KEY (fact_id)
-            REFERENCES fact (fact_id),
+            REFERENCES fact (fact_id)
+            ON DELETE CASCADE,
         ancestor_fact_id integer NOT NULL,
         CONSTRAINT fk_ancestor_fact_id
             FOREIGN KEY (ancestor_fact_id)
             REFERENCES fact (fact_id)
+            ON DELETE CASCADE
     );
 
 
@@ -198,7 +202,8 @@ IF (SELECT to_regclass('public.signature') IS NULL) THEN
         fact_id integer NOT NULL,
         CONSTRAINT fk_fact_id
             FOREIGN KEY (fact_id)
-            REFERENCES fact (fact_id),
+            REFERENCES fact (fact_id)
+            ON DELETE CASCADE,
         public_key_id integer NOT NULL,
         CONSTRAINT fk_public_key_id
             FOREIGN KEY (public_key_id)
@@ -264,6 +269,57 @@ IF (SELECT character_maximum_length
 
 END IF;
 
+--
+-- If the foreign keys on the edge table are not set to cascade delete, then set them.
+--
+
+IF (SELECT confdeltype
+    FROM pg_constraint
+    WHERE conname = 'fk_predecessor_fact_id') != 'c' THEN
+
+    -- Configure cascade delete from fact to edge
+    ALTER TABLE public.edge
+        DROP CONSTRAINT fk_predecessor_fact_id;
+    ALTER TABLE public.edge
+        ADD CONSTRAINT fk_predecessor_fact_id
+        FOREIGN KEY (predecessor_fact_id)
+        REFERENCES public.fact (fact_id)
+        ON DELETE CASCADE;
+    ALTER TABLE public.edge
+        DROP CONSTRAINT fk_successor_fact_id;
+    ALTER TABLE public.edge
+        ADD CONSTRAINT fk_successor_fact_id
+        FOREIGN KEY (successor_fact_id)
+        REFERENCES public.fact (fact_id)
+        ON DELETE CASCADE;
+
+    -- Configure cascade delete from fact to signature
+    ALTER TABLE public.signature
+        DROP CONSTRAINT fk_fact_id;
+    ALTER TABLE public.signature
+        ADD CONSTRAINT fk_fact_id
+        FOREIGN KEY (fact_id)
+        REFERENCES public.fact (fact_id)
+        ON DELETE CASCADE;
+
+    -- Configure cascade delete from fact to ancestor
+    ALTER TABLE public.ancestor
+        DROP CONSTRAINT fk_fact_id;
+    ALTER TABLE public.ancestor
+        ADD CONSTRAINT fk_fact_id
+        FOREIGN KEY (fact_id)
+        REFERENCES public.fact (fact_id)
+        ON DELETE CASCADE;
+    ALTER TABLE public.ancestor
+        DROP CONSTRAINT fk_ancestor_fact_id;
+    ALTER TABLE public.ancestor
+        ADD CONSTRAINT fk_ancestor_fact_id
+        FOREIGN KEY (ancestor_fact_id)
+        REFERENCES public.fact (fact_id)
+        ON DELETE CASCADE;
+
+END IF;
+
 IF (SELECT to_regclass('legacy.fact') IS NOT NULL) THEN
 
 	INSERT INTO public."user"

package/src/http/router.ts

@@ -14,6 +14,7 @@ import {
     GraphDeserializer,
     GraphSerializer,
     GraphSource,
+    Invalid,
     LoadMessage,
     LoadResponse,
     ProfileMessage,
@@ -72,17 +73,7 @@ function getOrStream<U>(
                             });
                     }
                 })
-                .catch(error => {
-                    if (error instanceof Forbidden) {
-                        res.type("text");
-                        res.status(403).send(error.message);
-                    }
-                    else {
-                        Trace.error(error);
-                        res.status(500).send(error.message);
-                    }
-                    next();
-                });
+                .catch(error => handleError(error, res, next));
         }
         else {
             getMethod(user, req.params, req.query)
@@ -97,17 +88,7 @@ function getOrStream<U>(
                         next();
                     }
                 })
-                .catch(error => {
-                    if (error instanceof Forbidden) {
-                        res.type("text");
-                        res.status(403).send(error.message);
-                    }
-                    else {
-                        Trace.error(error);
-                        res.status(500).send(error.message);
-                    }
-                    next();
-                });
+                .catch(error => handleError(error, res, next));
         }
     };
 }
@@ -125,11 +106,7 @@ function getAuthenticate<U>(method: ((req: RequestUser, params?: { [key: string]
                     res.send(JSON.stringify(response));
                     next();
                 })
-                .catch(error => {
-                    Trace.error(error);
-                    res.sendStatus(500);
-                    next();
-                });
+                .catch(error => handleError(error, res, next));
         }
     };
 }
@@ -156,19 +133,7 @@ function post<T, U>(
                     next();
                 }
             })
-            .catch(error => {
-                if (error instanceof Forbidden) {
-                    Trace.warn(error.message);
-                    res.type("text");
-                    res.status(403).send(error.message);
-                }
-                else {
-                    Trace.error(error);
-                    res.type("text");
-                    res.status(500).send(error.message);
-                }
-                next();
-            });
+        .catch(error => handleError(error, res, next));
     };
 }
 
@@ -187,19 +152,7 @@ function postString<U>(method: (user: RequestUser, message: string) => Promise<U
                     res.send(JSON.stringify(response, null, 2));
                     next();
                 })
-                .catch(error => {
-                    if (error instanceof Forbidden) {
-                        Trace.warn(error.message);
-                        res.type("text");
-                        res.status(403).send(error.message);
-                    }
-                    else {
-                        Trace.error(error);
-                        res.type("text");
-                        res.status(400).send(error.message);
-                    }
-                    next();
-                });
+                .catch(error => handleError(error, res, next));
         }
     };
 }
@@ -216,19 +169,7 @@ function postCreate<T>(
                 res.sendStatus(201);
                 next();
             })
-            .catch(error => {
-                if (error instanceof Forbidden) {
-                    Trace.warn(error.message);
-                    res.type("text");
-                    res.status(403).send(error.message);
-                }
-                else {
-                    Trace.error(error);
-                    res.type("text");
-                    res.status(500).send(error.message);
-                }
-                next();
-            });
+            .catch(error => handleError(error, res, next));
     };
 }
 
@@ -246,19 +187,7 @@ function postStringCreate(method: (user: RequestUser, message: string) => Promis
                     res.sendStatus(201);
                     next();
                 })
-                .catch(error => {
-                    if (error instanceof Forbidden) {
-                        Trace.warn(error.message);
-                        res.type("text");
-                        res.status(403).send(error.message);
-                    }
-                    else {
-                        Trace.error(error);
-                        res.type("text");
-                        res.status(400).send(error.message);
-                    }
-                    next();
-                });
+                .catch(error => handleError(error, res, next));
         }
     };
 }
@@ -421,6 +350,11 @@ export class HttpRouter {
         parser.expectEnd();
         const start = this.selectStart(specification, declaration);
 
+        var failures: string[] = this.factManager.testSpecificationForCompliance(specification);
+        if (failures.length > 0) {
+            throw new Invalid(failures.join("\n"));
+        }
+
         const userIdentity = serializeUserIdentity(user);
         const results = await this.authorization.read(userIdentity, start, specification);
         return extractResults(results);
@@ -436,7 +370,7 @@ export class HttpRouter {
         const factRecords: FactRecord[] = [];
         for (const value of declaration) {
             if (!value.declared.fact) {
-                throw new Error("References are not allowed while saving.");
+                throw new Invalid("References are not allowed while saving.");
             }
             factRecords.push(value.declared.fact);
         }
@@ -459,14 +393,19 @@ export class HttpRouter {
 
         // Verify that the number of start facts equals the number of inputs
         if (start.length !== specification.given.length) {
-            throw new Error(`The number of start facts (${start.length}) does not equal the number of inputs (${specification.given.length})`);
+            throw new Invalid(`The number of start facts (${start.length}) does not equal the number of inputs (${specification.given.length})`);
         }
         // Verify that the input type matches the start fact type
         for (let i = 0; i < start.length; i++) {
             if (start[i].type !== specification.given[i].type) {
-                throw new Error(`The type of start fact ${i} (${start[i].type}) does not match the type of input ${i} (${specification.given[i].type})`);
+                throw new Invalid(`The type of start fact ${i} (${start[i].type}) does not match the type of input ${i} (${specification.given[i].type})`);
             }
         }
+        // Verify that the specification is compliant with purge conditions
+        var failures: string[] = this.factManager.testSpecificationForCompliance(specification);
+        if (failures.length > 0) {
+            throw new Invalid(failures.join("\n"));
+        }
         
         const namedStart = specification.given.reduce((map, label, index) => ({
             ...map,
@@ -597,7 +536,7 @@ export class HttpRouter {
         return specification.given.map(input => {
             const declaredFact = declaration.find(d => d.name === input.name);
             if (!declaredFact) {
-                throw new Error(`No fact named ${input.name} was declared`);
+                throw new Invalid(`No fact named ${input.name} was declared`);
             }
             return declaredFact.declared.reference;
         });
@@ -675,7 +614,7 @@ export class HttpRouter {
 
 function parseString(input: any): string {
     if (typeof input !== 'string') {
-        throw new Error("Expected a string. Check the content type of the request.");
+        throw new Invalid("Expected a string. Check the content type of the request.");
     }
     return input;
 }
@@ -696,6 +635,21 @@ function extractResults(obj: any): any {
     }
 }
 
+function handleError(error: any, res: Response, next: NextFunction) {
+    if (error instanceof Forbidden) {
+        res.type("text");
+        res.status(403).send(error.message);
+    } else if (error instanceof Invalid) {
+        res.type("text");
+        res.status(400).send(error.message);
+    } else {
+        Trace.error(error);
+        res.type("text");
+        res.status(500).send(error.message);
+    }
+    next();
+}
+
 interface OptionsConfiguration {
     intendedForGet(): ResponseConfiguration;
     intendedForPost(...contentTypes: string[]): ResponseConfiguration;

package/src/jinaga-server.ts

@@ -14,10 +14,13 @@ import {
     ObservableSource,
     ObservableSourceImpl,
     PassThroughFork,
+    PurgeConditions,
+    Specification,
     Storage,
     SyncStatusNotifier,
     Trace,
-    UserIdentity
+    UserIdentity,
+    validatePurgeSpecification
 } from "jinaga";
 import { Pool } from "pg";
 
@@ -38,6 +41,7 @@ export type JinagaServerConfig = {
     model?: Model,
     authorization?: (a: AuthorizationRules) => AuthorizationRules,
     distribution?: (d: DistributionRules) => DistributionRules,
+    purgeConditions?: (p: PurgeConditions) => PurgeConditions,
     origin?: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void),
 };
 
@@ -66,7 +70,8 @@ export class JinagaServer {
         const feedCache = new FeedCache();
         const authentication = createAuthentication(store, keystore, authorizationRules);
         const network = new NetworkNoOp();
-        const factManager = new FactManager(fork, source, store, network);
+        const purgeConditions = createPurgeConditions(config);
+        const factManager = new FactManager(fork, source, store, network, purgeConditions);
         const authorization = createAuthorization(authorizationRules, distributionRules, factManager, store, keystore);
         const router = new HttpRouter(factManager, authorization, feedCache, config.origin || '*');
         const j: Jinaga = new Jinaga(authentication, factManager, syncStatusNotifier);
@@ -80,7 +85,7 @@ export class JinagaServer {
             handler: router.handler,
             j,
             withSession: (req, callback) => {
-                return withSession(store, keystore, authorizationRules, req, callback);
+                return withSession(store, keystore, authorizationRules, purgeConditions, req, callback);
             },
             close
         }
@@ -176,7 +181,7 @@ export function tracePool(postgresPool: Pool) {
     }
 }
 
-async function withSession(store: Storage, keystore: Keystore | null, authorizationRules: AuthorizationRules | null, req: Request, callback: ((j: Jinaga) => Promise<void>)) {
+async function withSession(store: Storage, keystore: Keystore | null, authorizationRules: AuthorizationRules | null, purgeConditions: Specification[], req: Request, callback: ((j: Jinaga) => Promise<void>)) {
     const user = <RequestUser>req.user;
     const userIdentity: UserIdentity = {
         provider: user.provider,
@@ -187,7 +192,7 @@ async function withSession(store: Storage, keystore: Keystore | null, authorizat
     const fork = new PassThroughFork(store);
     const observableSource = new ObservableSource(store);
     const network = new NetworkNoOp();
-    const factManager = new FactManager(fork, observableSource, store, network);
+    const factManager = new FactManager(fork, observableSource, store, network, purgeConditions);
     const j = new Jinaga(authentication, factManager, syncStatusNotifier);
     await callback(j);
 }
@@ -205,3 +210,20 @@ function validateSchema(schema: string | undefined): string {
 
     return schema;
 }
+
+function createPurgeConditions(
+    config: JinagaServerConfig
+): Specification[] {
+    if (config.purgeConditions) {
+        var specifications = config.purgeConditions(new PurgeConditions([])).specifications;
+        var validationFailures: string[] = specifications.map(specification =>
+            validatePurgeSpecification(specification)).flat();
+        if (validationFailures.length > 0) {
+            throw new Error(validationFailures.join("\n"));
+        }
+        return specifications;
+    }
+    else {
+        return [];
+    }
+}

package/src/postgres/postgres-store.ts

@@ -44,6 +44,7 @@ import {
 } from "./maps";
 import { ResultSetFact, ResultSetRow, ResultSetTree, resultSqlFromSpecification, SqlQueryTree } from "./specification-result-sql";
 import { sqlFromFeed } from "./specification-sql";
+import { purgeDescendantsSql, purgeSqlFromSpecification } from "./purge-sql";
 
 interface FactTypeResult {
     rows: {
@@ -433,6 +434,42 @@ export class PostgresStore implements Storage {
         return factTypes;
     }
 
+    async purge(purgeConditions: Specification[]): Promise<void> {
+        for (const specification of purgeConditions) {
+            const factTypes = await this.loadFactTypesFromSpecification(specification);
+            const roleMap = await this.loadRolesFromSpecification(specification, factTypes);
+
+            const purgeCommand = purgeSqlFromSpecification(specification, factTypes, roleMap, this.schema);
+            if (!purgeCommand) {
+                continue;
+            }
+
+            const { sql, parameters } = purgeCommand;
+            await this.connectionFactory.with(async (connection) => {
+                await connection.query(sql, parameters);
+            });
+        }
+    }
+
+    async purgeDescendants(purgeRoot: FactReference, triggers: FactReference[]): Promise<void> {
+        const factTypes = await this.loadFactTypesFromReferences([ purgeRoot, ...triggers ]);
+        if (!factTypes.has(purgeRoot.type) || triggers.some(t => !factTypes.has(t.type))) {
+            return;
+        }
+
+        const parameters = [
+            factTypes.get(purgeRoot.type),
+            purgeRoot.hash,
+            ...triggers.map(t => [ factTypes.get(t.type), t.hash ]).flat()
+        ];
+
+        const purgeCommand: string = purgeDescendantsSql(triggers.length, this.schema);
+
+        await this.connectionFactory.with(async (connection) => {
+            await connection.query(purgeCommand, parameters);
+        });
+    }
+
     loadBookmark(feed: string): Promise<string> {
         throw new Error("Method not implemented.");
     }

package/src/postgres/purge-sql.ts

@@ -0,0 +1,176 @@
+import { FactReference, Specification } from "jinaga";
+import { FactTypeMap, RoleMap } from "./maps";
+import { EdgeDescription, FactByLabel, QueryDescription, QueryDescriptionBuilder } from "./query-description";
+
+export function purgeDescendantsSql(triggerCount: number, schema: string): string {
+    let whereClause = "    WHERE (t.fact_type_id = $3 AND t.hash = $4)\n";
+    for (let i = 1; i < triggerCount; i++) {
+        whereClause += `        OR (t.fact_type_id = $${i * 2 + 3} AND t.hash = $${i * 2 + 4})\n`;
+    }
+    const sql =
+        `WITH purge_root AS (\n` +
+        `    SELECT pr.fact_id\n` +
+        `    FROM ${schema}.fact pr\n` +
+        `    WHERE pr.fact_type_id = $1\n` +
+        `        AND pr.hash = $2\n` +
+        `), triggers AS (\n` +
+        `    SELECT t.fact_id\n` +
+        `    FROM ${schema}.fact t\n` +
+        whereClause +
+        `), triggers_and_ancestors AS (\n` +
+        `    SELECT t.fact_id\n` +
+        `    FROM triggers t\n` +
+        `    UNION\n` +
+        `    SELECT a.ancestor_fact_id\n` +
+        `    FROM ${schema}.ancestor a\n` +
+        `    JOIN triggers t\n` +
+        `        ON a.fact_id = t.fact_id\n` +
+        `), targets AS (\n` +
+        `    SELECT a.fact_id\n` +
+        `    FROM ${schema}.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 ${schema}.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`;
+    return sql;
+}
+
+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 triggerAncestorClauses = queryDescription.outputs
+        .map((label, index) =>
+            `    AND NOT EXISTS (\n` +
+            `        SELECT 1\n` +
+            `        FROM candidates c2\n` +
+            `        JOIN ${schema}.ancestor a2\n` +
+            `            ON a2.fact_id = c2.trigger${index + 1}\n` +
+            `        WHERE a.fact_id = a2.ancestor_fact_id\n` +
+            `    )\n`
+        )
+        .join("");
+
+    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 ${schema}.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` +
+        triggerAncestorClauses +
+        `), facts AS (\n` +
+        `    DELETE\n` +
+        `    FROM ${schema}.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