jinaga-server 3.1.4 → 3.2.0

package/replicator/package.json

@@ -15,8 +15,8 @@
   "author": "Michael L Perry",
   "license": "MIT",
   "dependencies": {
-    "express": "^4.19.2",
-    "pg": "8.11.5"
+    "express": "^4.21.1",
+    "pg": "8.13.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.13",

package/scripts/migrate_purge.sql

@@ -0,0 +1,45 @@
+GRANT DELETE ON TABLE public.edge TO appuser;
+GRANT DELETE ON TABLE public.signature TO appuser;
+GRANT DELETE ON TABLE public.ancestor TO appuser;
+GRANT DELETE ON TABLE public.fact TO appuser;
+
+-- 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;

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.sql

@@ -56,7 +56,7 @@ IF (SELECT to_regclass('public.fact_type')) IS NULL THEN
 
     CREATE TABLE fact_type (
         fact_type_id serial PRIMARY KEY,
-        name character varying(50) NOT NULL
+        name character varying(200) NOT NULL
     );
 
 
@@ -78,7 +78,7 @@ IF (SELECT to_regclass('public.role')) IS NULL THEN
         CONSTRAINT fk_defining_fact_type_id
             FOREIGN KEY (defining_fact_type_id)
             REFERENCES fact_type (fact_type_id),
-        name character varying(20) NOT NULL
+        name character varying(200) NOT NULL
     );
 
 
@@ -236,6 +236,34 @@ IF (SELECT to_regclass('public.user') IS NULL) THEN
 
 END IF;
 
+--
+-- If the fact_type.name column is less than 200 characters, then increase it.
+--
+
+IF (SELECT character_maximum_length
+    FROM information_schema.columns
+    WHERE table_name = 'fact_type'
+    AND column_name = 'name') < 200 THEN
+
+    ALTER TABLE fact_type
+        ALTER COLUMN name TYPE character varying(200);
+
+END IF;
+
+--
+-- If the role.name column is less than 200 characters, then increase it.
+--
+
+IF (SELECT character_maximum_length
+    FROM information_schema.columns
+    WHERE table_name = 'role'
+    AND column_name = 'name') < 200 THEN
+
+    ALTER TABLE role
+        ALTER COLUMN name TYPE character varying(200);
+
+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));
         }
     };
 }
@@ -335,25 +264,26 @@ export class HttpRouter {
         private allowedOrigin: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void)
     ) {
         const router = Router();
-        router.get('/login', getAuthenticate(user => this.login(user)));
-        router.post('/load', post(
+        const applyAllowOrigin = this.applyAllowOrigin.bind(this);
+        router.get('/login', applyAllowOrigin, getAuthenticate(user => this.login(user)));
+        router.post('/load', applyAllowOrigin, post(
             parseLoadMessage,
             (user, loadMessage) => this.load(user, loadMessage),
             outputGraph
         ));
-        router.post('/save', postCreate(
+        router.post('/save', applyAllowOrigin, postCreate(
             inputSaveMessage,
             (user, graphSource) => this.save(user, graphSource)
         ));
 
-        router.post('/read', postString((user, input: string) => this.read(user, input)));
-        router.post('/write', postStringCreate((user, input: string) => this.write(user, input)));
-        router.post('/feeds', post(
+        router.post('/read', applyAllowOrigin, postString((user, input: string) => this.read(user, input)));
+        router.post('/write', applyAllowOrigin, postStringCreate((user, input: string) => this.write(user, input)));
+        router.post('/feeds', applyAllowOrigin, post(
             parseString,
             (user, input: string, accepts) => this.feeds(user, input),
             outputFeeds
         ));
-        router.get('/feeds/:hash', getOrStream<FeedResponse>(
+        router.get('/feeds/:hash', applyAllowOrigin, getOrStream<FeedResponse>(
             (user, params, query) => this.feed(user, params, query),
             (user, params, query) => this.streamFeed(user, params, query)));
 
@@ -420,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);
@@ -435,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);
         }
@@ -458,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,
@@ -596,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;
         });
@@ -604,7 +544,7 @@ export class HttpRouter {
 
     private setOptions(router: Router, path: string): OptionsConfiguration {
         const addOptions = (allowedMethods: string[], allowedHeaders: string[], allowedTypes: string[]) => {
-            router.options(path, this.applyAllowOrigin((req, res) => {
+            router.options(path, this.applyAllowOrigin.bind(this), (req: Request, res: Response) => {
                 res.set('Allow', allowedMethods.join(', '));
                 res.set('Access-Control-Allow-Methods', allowedMethods.join(', '));
                 res.set('Access-Control-Allow-Headers', allowedHeaders.join(', '));
@@ -612,7 +552,7 @@ export class HttpRouter {
                     res.set('Accept-Post', allowedTypes.join(', '));
                 }
                 res.status(204).send();
-            }));
+            });
         }
 
         return {
@@ -642,41 +582,39 @@ export class HttpRouter {
         };
     }
 
-    private applyAllowOrigin(sendResponse: (req: Request, res: Response) => void) {
+    private applyAllowOrigin(req: Request, res: Response, next: NextFunction) {
         // Specify the allowed origins.
-        return (req: Request, res: Response, next: NextFunction) => {
-            let requestOrigin = req.get('Origin');
-
-            if (typeof this.allowedOrigin === 'string') {
-                // If allowedOrigin is a string, use it as the value of the Access-Control-Allow-Origin header
-                res.set('Access-Control-Allow-Origin', this.allowedOrigin);
-                sendResponse(req, res);
-            } else if (Array.isArray(this.allowedOrigin)) {
-                // If allowedOrigin is an array, check if the request's origin is in the array
-                if (requestOrigin && this.allowedOrigin.includes(requestOrigin)) {
+        let requestOrigin = req.get('Origin');
+
+        if (typeof this.allowedOrigin === 'string') {
+            // If allowedOrigin is a string, use it as the value of the Access-Control-Allow-Origin header
+            res.set('Access-Control-Allow-Origin', this.allowedOrigin);
+            next();
+        } else if (Array.isArray(this.allowedOrigin)) {
+            // If allowedOrigin is an array, check if the request's origin is in the array
+            if (requestOrigin && this.allowedOrigin.includes(requestOrigin)) {
+                res.set('Access-Control-Allow-Origin', requestOrigin);
+            }
+            next();
+        } else if (typeof this.allowedOrigin === 'function' && requestOrigin) {
+            // If allowedOrigin is a function, call it with the request's origin
+            this.allowedOrigin(requestOrigin, (err, allow) => {
+                if (err) {
+                    next(err);
+                } else if (allow) {
                     res.set('Access-Control-Allow-Origin', requestOrigin);
                 }
-                sendResponse(req, res);
-            } else if (typeof this.allowedOrigin === 'function' && requestOrigin) {
-                // If allowedOrigin is a function, call it with the request's origin
-                this.allowedOrigin(requestOrigin, (err, allow) => {
-                    if (err) {
-                        next(err);
-                    } else if (allow) {
-                        res.set('Access-Control-Allow-Origin', requestOrigin);
-                    }
-                    sendResponse(req, res);
-                });
-            } else {
-                sendResponse(req, res);
-            }
-        };
+                next();
+            });
+        } else {
+            next();
+        }
     }
 }
 
 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;
 }
@@ -697,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 { purgeSqlFromSpecification } from "./purge-sql";
 
 interface FactTypeResult {
     rows: {
@@ -433,6 +434,23 @@ 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);
+            });
+        }
+    }
+
     loadBookmark(feed: string): Promise<string> {
         throw new Error("Method not implemented.");
     }