jinaga-server 3.1.5 → 3.2.0

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/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 { 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.");
     }

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)