jinaga-server 2.3.5 → 2.4.1

package/src/authorization/authorization-keystore.ts

@@ -2,29 +2,41 @@ import {
     Authorization,
     AuthorizationEngine,
     AuthorizationRules,
+    DistributionEngine,
+    DistributionRules,
     FactEnvelope,
     FactFeed,
     FactRecord,
     FactReference,
     Feed,
+    Forbidden,
     Query,
     Specification,
     Storage,
-    UserIdentity
+    UserIdentity,
+    buildFeeds,
+    factReferenceEquals
 } from "jinaga";
 
 import { Keystore } from "../keystore";
+import { distinct } from "../util/fn";
+import { DistributedFactCache } from "./distributed-fact-cache";
 
 export class AuthorizationKeystore implements Authorization {
     private authorizationEngine: AuthorizationEngine | null;
+    private distributionEngine: DistributionEngine | null;
+    private distributedFacts: DistributedFactCache = new DistributedFactCache();
 
     constructor(
         private store: Storage,
         private keystore: Keystore,
-        authorizationRules: AuthorizationRules | null
+        authorizationRules: AuthorizationRules | null,
+        distributionRules: DistributionRules | null
     ) {
         this.authorizationEngine = authorizationRules &&
             new AuthorizationEngine(authorizationRules, store);
+        this.distributionEngine = distributionRules &&
+            new DistributionEngine(distributionRules, store);
     }
 
     async getOrCreateUserFact(userIdentity: UserIdentity) {
@@ -39,20 +51,55 @@ export class AuthorizationKeystore implements Authorization {
         return userFact;
     }
 
-    query(userIdentity: UserIdentity, start: FactReference, query: Query) {
+    query(userIdentity: UserIdentity | null, start: FactReference, query: Query) {
         return this.store.query(start, query);
     }
 
-    read(userIdentity: UserIdentity, start: FactReference[], specification: Specification) {
-        return this.store.read(start, specification);
+    async read(userIdentity: UserIdentity | null, start: FactReference[], specification: Specification) {
+        if (this.distributionEngine) {
+            const userReference: FactReference | null = userIdentity
+                ? await this.keystore.getUserFact(userIdentity)
+                : null;
+            // Break the specification into feeds and check distribution.
+            const feeds = buildFeeds(specification);
+            const canDistribute = await this.distributionEngine.canDistributeToAll(feeds, start, userReference);
+            if (!canDistribute) {
+                throw new Forbidden("Unauthorized");
+            }
+        }
+        return await this.store.read(start, specification);
     }
 
-    feed(userIdentity: UserIdentity, feed: Feed, bookmark: string): Promise<FactFeed> {
-        return this.store.feed(feed, bookmark);
+    async feed(userIdentity: UserIdentity | null, feed: Feed, start: FactReference[], bookmark: string): Promise<FactFeed> {
+        if (this.distributionEngine) {
+            const userReference: FactReference | null = userIdentity
+                ? await this.keystore.getUserFact(userIdentity)
+                : null;
+            const canDistribute = await this.distributionEngine.canDistributeToAll([feed], start, userReference);
+            if (!canDistribute) {
+                throw new Forbidden("Unauthorized");
+            }
+            const factFeed = await this.store.feed(feed, start, bookmark);
+            const factReferences = factFeed.tuples
+                .flatMap(tuple => tuple.facts)
+                .filter((value, index, self) => self.findIndex(factReferenceEquals(value)) === index);
+            this.distributedFacts.add(factReferences, userReference);
+            return factFeed;
+        }
+        else {
+            return await this.store.feed(feed, start, bookmark);
+        }
     }
 
-    load(userIdentity: UserIdentity, references: FactReference[]) {
-        return this.store.load(references);
+    async load(userIdentity: UserIdentity, references: FactReference[]) {
+        if (this.distributionEngine) {
+            const userFact = userIdentity ? await this.keystore.getUserFact(userIdentity) : null;
+            const canDistribute = this.distributedFacts.includesAll(references, userFact);
+            if (!canDistribute) {
+                throw new Forbidden("Unauthorized");
+            }
+        }
+        return await this.store.load(references);
     }
 
     async save(userIdentity: UserIdentity | null, facts: FactRecord[]) {
@@ -75,4 +122,18 @@ export class AuthorizationKeystore implements Authorization {
             return authorizedFacts;
         }
     }
+
+    async verifyDistribution(userIdentity: UserIdentity | null, feeds: Feed[], start: FactReference[]): Promise<void> {
+        if (!this.distributionEngine) {
+            return;
+        }
+
+        const userReference: FactReference | null = userIdentity
+            ? await this.keystore.getUserFact(userIdentity)
+            : null;
+        const canDistribute = await this.distributionEngine.canDistributeToAll(feeds, start, userReference);
+        if (!canDistribute) {
+            throw new Forbidden("Unauthorized");
+        }
+    }
 }

package/src/authorization/distributed-fact-cache.ts

@@ -0,0 +1,34 @@
+import { FactReference, factReferenceEquals } from "jinaga";
+
+interface Batch {
+  factReferences: FactReference[];
+  userReference: FactReference | null;
+  createdAt: Date;
+}
+
+export class DistributedFactCache {
+  private batches: Batch[] = [];
+
+  add(factReferences: FactReference[], userReference: FactReference | null): void {
+    this.removeOldBatches();
+    this.batches.push({
+      factReferences,
+      userReference,
+      createdAt: new Date()
+    });
+  }
+
+  includesAll(references: FactReference[], userFact: FactReference | null): boolean {
+    this.removeOldBatches();
+    return references.every(reference =>
+      this.batches.some(batch =>
+        batch.factReferences.some(factReferenceEquals(reference)) &&
+        (batch.userReference === null || batch.userReference === userFact)));
+  }
+
+  removeOldBatches() {
+    const cutoff = new Date().getTime() - 1000 * 60 * 5;
+    this.batches = this.batches.filter(batch =>
+      batch.createdAt.getTime() > cutoff);
+  }
+}

package/src/http/feed-cache.ts

@@ -1,6 +1,14 @@
-import { Feed } from "jinaga";
+import { FactReference, Feed } from "jinaga";
+
+export interface FeedDefinition {
+    start: {
+        factReference: FactReference,
+        index: number
+    }[],
+    feed: Feed
+}
 
 export interface FeedCache {
-    storeFeed(feedHash: string, feed: Feed): Promise<void>;
-    getFeed(feedHash: string): Promise<Feed | undefined>;
+    storeFeed(feedHash: string, feedDefinition: FeedDefinition): Promise<void>;
+    getFeed(feedHash: string): Promise<FeedDefinition | undefined>;
 }

package/src/http/router.ts

@@ -1,14 +1,13 @@
 import { Handler, Router } from "express";
 import {
     Authorization,
-    buildFeeds,
-    computeObjectHash,
     Declaration,
     FactRecord,
     FactReference,
     Feed,
+    FeedResponse,
+    FeedsResponse,
     Forbidden,
-    fromDescriptiveString,
     LoadMessage,
     LoadResponse,
     ProfileMessage,
@@ -20,10 +19,15 @@ import {
     SpecificationParser,
     Trace,
     UserIdentity,
+    buildFeeds,
+    computeObjectHash,
+    fromDescriptiveString,
+    parseLoadMessage,
+    parseQueryMessage,
+    parseSaveMessage,
 } from "jinaga";
-import { FeedResponse, FeedsResponse } from "jinaga/dist/http/messages";
 
-import { FeedCache } from "./feed-cache";
+import { FeedCache, FeedDefinition } from "./feed-cache";
 
 interface ParsedQs { [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[] }
 
@@ -43,8 +47,14 @@ function get<U>(method: ((req: RequestUser, params: { [key: string]: string }, q
                 }
             })
             .catch(error => {
-                Trace.error(error);
-                res.status(500).send(error.message);
+                if (error instanceof Forbidden) {
+                    res.type("text");
+                    res.status(403).send(error.message);
+                }
+                else {
+                    Trace.error(error);
+                    res.status(500).send(error.message);
+                }
                 next();
             });
     };
@@ -72,10 +82,13 @@ function getAuthenticate<U>(method: ((req: RequestUser, params?: { [key: string]
     };
 }
 
-function post<T, U>(method: (user: RequestUser, message: T, params?: { [key: string]: string }) => Promise<U>): Handler {
+function post<T, U>(
+    parse: (input: any) => T,
+    method: (user: RequestUser, message: T, params?: { [key: string]: string }) => Promise<U>
+): Handler {
     return (req, res, next) => {
         const user = <RequestUser>req.user;
-        const message = <T>req.body;
+        const message = parse(req.body);
         if (!message) {
             throw new Error('Ensure that you have called app.use(express.json()).');
         }
@@ -110,7 +123,7 @@ function post<T, U>(method: (user: RequestUser, message: T, params?: { [key: str
 function postString<U>(method: (user: RequestUser, message: string) => Promise<U>): Handler {
     return (req, res, next) => {
         const user = <RequestUser>req.user;
-        const input = <string>req.body;
+        const input = parseString(req.body);
         if (!input || typeof(input) !== 'string') {
             res.type("text");
             res.status(500).send('Expected Content-Type text/plain. Ensure that you have called app.use(express.text()).');
@@ -139,10 +152,13 @@ function postString<U>(method: (user: RequestUser, message: string) => Promise<U
     };
 }
 
-function postCreate<T>(method: (user: RequestUser, message: T) => Promise<void>): Handler {
+function postCreate<T>(
+    parse: (input: any) => T,
+    method: (user: RequestUser, message: T) => Promise<void>
+): Handler {
     return (req, res, next) => {
         const user = <RequestUser>req.user;
-        const message = <T>req.body;
+        const message = parse(req.body);
         if (!message) {
             throw new Error('Ensure that you have called app.use(express.json()).');
         }
@@ -170,7 +186,7 @@ function postCreate<T>(method: (user: RequestUser, message: T) => Promise<void>)
 function postStringCreate(method: (user: RequestUser, message: string) => Promise<void>): Handler {
     return (req, res, next) => {
         const user = <RequestUser>req.user;
-        const input = <string>req.body;
+        const input = parseString(req.body);
         if (!input || typeof(input) !== 'string') {
             res.type("text");
             res.status(500).send('Expected Content-Type text/plain. Ensure that you have called app.use(express.text()).');
@@ -198,7 +214,7 @@ function postStringCreate(method: (user: RequestUser, message: string) => Promis
     };
 }
 
-function serializeUserIdentity(user: RequestUser) : UserIdentity | null {
+function serializeUserIdentity(user: RequestUser | null) : UserIdentity | null {
     if (!user) {
         return null;
     }
@@ -217,16 +233,30 @@ export interface RequestUser {
 export class HttpRouter {
     handler: Handler;
 
-    constructor(private authorization: Authorization, private feedCache: FeedCache) {
+    constructor(private authorization: Authorization, private feedCache: FeedCache, backwardCompatible: boolean) {
         const router = Router();
         router.get('/login', getAuthenticate(user => this.login(user)));
-        router.post('/query', post((user, queryMessage: QueryMessage) => this.query(user, queryMessage)));
-        router.post('/load', post((user, loadMessage: LoadMessage) => this.load(user, loadMessage)));
-        router.post('/save', postCreate((user, saveMessage: SaveMessage) => this.save(user, saveMessage)));
+        if (backwardCompatible) {
+            router.post('/query', post(
+                parseQueryMessage,
+                (user, queryMessage) => this.query(user, queryMessage)
+            ));
+        }
+        router.post('/load', post(
+            parseLoadMessage,
+            (user, loadMessage) => this.load(user, loadMessage)
+        ));
+        router.post('/save', postCreate(
+            parseSaveMessage,
+            (user, saveMessage) => this.save(user, saveMessage)
+        ));
 
         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((user, input: string) => this.feeds(user, input)));
+        router.post('/feeds', post(
+            parseString,
+            (user, input: string) => this.feeds(user, input)
+        ));
         router.get('/feeds/:hash', get((user, params, query) => this.feed(user, params, query)));
 
         this.handler = router;
@@ -243,7 +273,7 @@ export class HttpRouter {
         };
     }
 
-    private async query(user: RequestUser, queryMessage: QueryMessage) : Promise<QueryResponse> {
+    private async query(user: RequestUser | null, queryMessage: QueryMessage) : Promise<QueryResponse> {
         const userIdentity = serializeUserIdentity(user);
         const query = fromDescriptiveString(queryMessage.query);
         const result = await this.authorization.query(userIdentity, queryMessage.start, query);
@@ -260,17 +290,18 @@ export class HttpRouter {
         };
     }
 
-    private async save(user: RequestUser, saveMessage: SaveMessage) : Promise<void> {
+    private async save(user: RequestUser | null, saveMessage: SaveMessage) : Promise<void> {
         const userIdentity = serializeUserIdentity(user);
         await this.authorization.save(userIdentity, saveMessage.facts);
     }
 
-    private async read(user: RequestUser, input: string): Promise<any[]> {
+    private async read(user: RequestUser | null, input: string): Promise<any[]> {
         const knownFacts = await this.getKnownFacts(user);
         const parser = new SpecificationParser(input);
         parser.skipWhitespace();
         const declaration = parser.parseDeclaration(knownFacts);
         const specification = parser.parseSpecification();
+        parser.expectEnd();
         const start = this.selectStart(specification, declaration);
 
         const userIdentity = serializeUserIdentity(user);
@@ -278,11 +309,12 @@ export class HttpRouter {
         return extractResults(results);
     }
 
-    private async write(user: RequestUser, input: string): Promise<void> {
+    private async write(user: RequestUser | null, input: string): Promise<void> {
         const knownFacts = await this.getKnownFacts(user);
         const parser = new SpecificationParser(input);
         parser.skipWhitespace();
         var declaration = parser.parseDeclaration(knownFacts);
+        parser.expectEnd();
 
         const factRecords: FactRecord[] = [];
         for (const value of declaration) {
@@ -296,7 +328,7 @@ export class HttpRouter {
         await this.authorization.save(userIdentity, factRecords);
     }
 
-    private async feeds(user: RequestUser, input: string): Promise<FeedsResponse> {
+    private async feeds(user: RequestUser | null, input: string): Promise<FeedsResponse> {
         const knownFacts = await this.getKnownFacts(user);
         const parser = new SpecificationParser(input);
         parser.skipWhitespace();
@@ -304,35 +336,65 @@ export class HttpRouter {
         const specification = parser.parseSpecification();
         const start = this.selectStart(specification, declaration);
 
-        const feedDefinitions = buildFeeds(start, specification).map(feed => ({
-            hash: urlSafeHash(feed),
-            feed
-        }));
+        // 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})`);
+        }
+        // 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})`);
+            }
+        }
+
+        // Verify that I can distribute all feeds to the user.
+        const feeds = buildFeeds(specification);
+        const userIdentity = serializeUserIdentity(user);
+        await this.authorization.verifyDistribution(userIdentity, feeds, start);
+
+        const feedDefinitionsByHash = feeds.map(feed => {
+            const indexedStart = feed.inputs.map(input => ({
+                factReference: start[input.inputIndex],
+                index: input.inputIndex
+            }));
+            const feedDefinition: FeedDefinition = {
+                start: indexedStart,
+                feed
+            };
+            return {
+                hash: urlSafeHash(feed),
+                feedDefinition
+            };
+        });
         // Store all feeds in the cache.
-        for (const feedDefinition of feedDefinitions) {
-            await this.feedCache.storeFeed(feedDefinition.hash, feedDefinition.feed);
+        for (const d of feedDefinitionsByHash) {
+            await this.feedCache.storeFeed(d.hash, d.feedDefinition);
         }
 
         return {
-            feeds: feedDefinitions.map(f => f.hash)
+            feeds: feedDefinitionsByHash.map(f => f.hash)
         }
     }
 
-    private async feed(user: RequestUser, params: { [key: string]: string }, query: ParsedQs): Promise<FeedResponse | null> {
+    private async feed(user: RequestUser | null, params: { [key: string]: string }, query: ParsedQs): Promise<FeedResponse | null> {
         const feedHash = params["hash"];
         if (!feedHash) {
             return null;
         }
 
-        const feed = await this.feedCache.getFeed(feedHash);
-        if (!feed) {
+        const feedDefinition = await this.feedCache.getFeed(feedHash);
+        if (!feedDefinition) {
             return null;
         }
 
         const bookmark = query["b"] as string ?? "";
 
         const userIdentity = serializeUserIdentity(user);
-        const results = await this.authorization.feed(userIdentity, feed, bookmark);
+        const start = feedDefinition.start.reduce((start, input) => {
+            start[input.index] = input.factReference;
+            return start;
+        }, [] as FactReference[]);
+        const results = await this.authorization.feed(userIdentity, feedDefinition.feed, start, bookmark);
         // Return distinct fact references from all the tuples.
         const references = results.tuples.flatMap(t => t.facts).filter((value, index, self) =>
             self.findIndex(f => f.hash === value.hash && f.type === value.type) === index
@@ -344,7 +406,7 @@ export class HttpRouter {
         return response;
     }
 
-    private async getKnownFacts(user: RequestUser): Promise<Declaration> {
+    private async getKnownFacts(user: RequestUser | null): Promise<Declaration> {
         if (user) {
             const userFact = await this.authorization.getOrCreateUserFact({
                 provider: user.provider,
@@ -380,6 +442,13 @@ 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.");
+    }
+    return input;
+}
+
 function urlSafeHash(feed: Feed): string {
     const base64 = computeObjectHash(feed);
     return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');

package/src/jinaga-server.ts

@@ -4,6 +4,7 @@ import {
     Authorization,
     AuthorizationNoOp,
     AuthorizationRules,
+    DistributionRules,
     FactManager,
     Jinaga,
     MemoryStore,
@@ -35,7 +36,8 @@ export type JinagaServerConfig = {
     pgKeystore?: string | Pool,
     pgKeystoreSchema?: string,
     model?: Model,
-    authorization?: (a: AuthorizationRules) => AuthorizationRules
+    authorization?: (a: AuthorizationRules) => AuthorizationRules,
+    distribution?: (d: DistributionRules) => DistributionRules,
 };
 
 export type JinagaServerInstance = {
@@ -59,9 +61,11 @@ export class JinagaServer {
         const fork = new PassThroughFork(store);
         const keystore = createKeystore(config, pools);
         const authorizationRules = config.authorization ? config.authorization(new AuthorizationRules(config.model)) : null;
-        const authorization = createAuthorization(authorizationRules, store, keystore);
+        const distributionRules = config.distribution ? config.distribution(new DistributionRules([])) : null;
+        const authorization = createAuthorization(authorizationRules, distributionRules, store, keystore);
         const feedCache = new MemoryFeedCache();
-        const router = new HttpRouter(authorization, feedCache);
+        // Retain backward compatibility until the user provides distribution rules.
+        const router = new HttpRouter(authorization, feedCache, distributionRules === null);
         const authentication = createAuthentication(store, keystore, authorizationRules);
         const network = new NetworkNoOp();
         const factManager = new FactManager(authentication, fork, source, store, network);
@@ -106,9 +110,9 @@ function createKeystore(config: JinagaServerConfig, pools: { [uri: string]: Pool
     }
 }
 
-function createAuthorization(authorizationRules: AuthorizationRules | null, store: Storage, keystore: Keystore | null): Authorization {
+function createAuthorization(authorizationRules: AuthorizationRules | null, distributionRules: DistributionRules | null, store: Storage, keystore: Keystore | null): Authorization {
     if (keystore) {
-        const authorization = new AuthorizationKeystore(store, keystore, authorizationRules);
+        const authorization = new AuthorizationKeystore(store, keystore, authorizationRules, distributionRules);
         return authorization;
     }
     else {

package/src/memory/memory-feed-cache.ts

@@ -1,15 +1,14 @@
-import { Feed } from "jinaga";
-import { FeedCache } from "../http/feed-cache";
+import { FeedCache, FeedDefinition } from "../http/feed-cache";
 
 export class MemoryFeedCache implements FeedCache {
-    private feeds: { [feedHash: string]: Feed } = {};
+    private feedDefinitions: { [feedHash: string]: FeedDefinition } = {};
 
-    storeFeed(feedHash: string, feed: Feed): Promise<void> {
-        this.feeds[feedHash] = feed;
+    storeFeed(feedHash: string, feedDefinition: FeedDefinition): Promise<void> {
+        this.feedDefinitions[feedHash] = feedDefinition;
         return Promise.resolve();
     }
 
-    getFeed(feedHash: string): Promise<Feed | undefined> {
-        return Promise.resolve(this.feeds[feedHash]);
+    getFeed(feedHash: string): Promise<FeedDefinition | undefined> {
+        return Promise.resolve(this.feedDefinitions[feedHash]);
     }
 }

package/src/postgres/postgres-store.ts

@@ -261,10 +261,10 @@ export class PostgresStore implements Storage {
         return composer.compose(resultSets, factRecords);
     }
 
-    async feed(feed: Feed, bookmark: string): Promise<FactFeed> {
+    async feed(feed: Feed, start: FactReference[], bookmark: string): Promise<FactFeed> {
         const factTypes: FactTypeMap = await this.loadFactTypesFromFeed(feed);
         const roleMap: RoleMap = await this.loadRolesFromFeed(feed, factTypes);
-        const sql = sqlFromFeed(feed, this.schema, bookmark, 100, factTypes, roleMap);
+        const sql = sqlFromFeed(feed, start, this.schema, bookmark, 100, factTypes, roleMap);
         if (!sql) {
             return {
                 tuples: [],

package/src/postgres/specification-sql.ts

@@ -228,7 +228,7 @@ class DescriptionBuilder {
         return true;
     }
 
-    buildDescription(feed: Feed): QueryDescription {
+    buildDescription(feed: Feed, start: FactReference[]): QueryDescription {
         const parameters: (string | number)[] = [];
         function addParameter(value: string | number) {
             parameters.push(value);
@@ -237,7 +237,7 @@ class DescriptionBuilder {
 
         // Allocate parameters for the inputs.
         const inputs: InputDescription[] = feed.inputs.map(input =>
-            this.buildInputDescription(feed, input, addParameter)
+            this.buildInputDescription(feed, input, start, addParameter)
         );
 
         // Allocate parameters for the edge roles.
@@ -266,7 +266,7 @@ class DescriptionBuilder {
         );
     }
 
-    private buildInputDescription(feed: Feed, input: FeedInputDescription, addParameter: (value: string | number) => number): InputDescription {
+    private buildInputDescription(feed: Feed, input: FeedInputDescription, start: FactReference[], addParameter: (value: string | number) => number): InputDescription {
         const fact = feed.facts.find(f => f.factIndex === input.factIndex);
         if (!fact) {
             throw new Error(`Fact not found: ${input.factIndex}`);
@@ -278,7 +278,7 @@ class DescriptionBuilder {
         }
 
         const factTypeParameter = addParameter(factTypeId);
-        const factHashParameter = addParameter(input.factHash);
+        const factHashParameter = addParameter(start[input.inputIndex].hash);
         return {
             factIndex: input.factIndex,
             factTypeParameter,
@@ -335,7 +335,18 @@ class DescriptionBuilder {
 }
 
 export function sqlFromSpecification(start: FactReference[], schema: string, bookmarks: string[], limit: number, specification: Specification, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery[] {
-    const feeds = buildFeeds(start, specification);
+    // 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})`);
+    }
+    // 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})`);
+        }
+    }
+
+    const feeds = buildFeeds(specification);
     const descriptionBuilder = new DescriptionBuilder(factTypes, roleMap);
     const feedAndBookmark = feeds.map((feed, index) => ({
         feed,
@@ -344,19 +355,19 @@ export function sqlFromSpecification(start: FactReference[], schema: string, boo
     const satisfiableFeedsAndBookmarks = feedAndBookmark.filter(fb =>
         descriptionBuilder.isSatisfiable(fb.feed, fb.feed.edges));
     const sqlQueries = satisfiableFeedsAndBookmarks.map(fb => {
-        const description = descriptionBuilder.buildDescription(fb.feed);
+        const description = descriptionBuilder.buildDescription(fb.feed, start);
         const sql = description.generateSqlQuery(schema, fb.bookmark, limit);
         return sql;
     });
     return sqlQueries;
 }
 
-export function sqlFromFeed(feed: Feed, schema: string, bookmark: string, limit: number, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery | null {
+export function sqlFromFeed(feed: Feed, start: FactReference[], schema: string, bookmark: string, limit: number, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery | null {
     const descriptionBuilder = new DescriptionBuilder(factTypes, roleMap);
     if (!descriptionBuilder.isSatisfiable(feed, feed.edges)) {
         return null;
     }
-    const description = descriptionBuilder.buildDescription(feed);
+    const description = descriptionBuilder.buildDescription(feed, start);
     const sql = description.generateSqlQuery(schema, bookmark, limit);
     return sql;
 }

package/test/authorization/authorizationSpec.ts

@@ -167,7 +167,7 @@ function givenAuthorizationWithStorage(storage: MemoryStore) {
         .type('Like', j.for(likeUser))
         .type('Delete', j.for(deleteSender))
         ;
-    return new AuthorizationKeystore(storage, keystore, authorizationRules);
+    return new AuthorizationKeystore(storage, keystore, authorizationRules, null);
 }
 
 function givenOtherUser() {