jinaga-server 2.5.0 → 2.6.1

package/integration-test/jinaga-test/package.json

@@ -15,12 +15,12 @@
   "dependencies": {
     "@stablelib/base64": "^1.0.1",
     "express": "^4.17.2",
-    "jest": "^28.1.0",
+    "jest": "^29.7.0",
     "jest-compact-reporter": "^1.2.9",
-    "jinaga": "^5.4.0",
+    "jinaga": "^5.6.0",
     "node-forge": "^1.3.0",
     "passport": "^0.6.0",
-    "pg": "^8.11.0",
+    "pg": "^8.11.1",
     "tweetnacl": "^1.0.3",
     "tweetnacl-util": "^0.15.1"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinaga-server",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Data management for web and mobile applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "express": "^4.18.2",
-    "jinaga": "^5.5.0",
+    "jinaga": "^5.6.0",
     "node-forge": "^1.3.1",
     "passport": "^0.6.0",
     "pg": "^8.11.0"

package/replicator/package-lock.json

@@ -11,7 +11,7 @@
       "dependencies": {
         "cors": "^2.8.5",
         "express": "^4.18.1",
-        "pg": "8.11"
+        "pg": "^8.11.3"
       },
       "devDependencies": {
         "@types/cors": "^2.8.12",
@@ -530,14 +530,14 @@
       "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ=="
     },
     "node_modules/pg": {
-      "version": "8.11.0",
-      "resolved": "https://registry.npmjs.org/pg/-/pg-8.11.0.tgz",
-      "integrity": "sha512-meLUVPn2TWgJyLmy7el3fQQVwft4gU5NGyvV0XbD41iU9Jbg8lCH4zexhIkihDzVHJStlt6r088G6/fWeNjhXA==",
+      "version": "8.11.3",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.11.3.tgz",
+      "integrity": "sha512-+9iuvG8QfaaUrrph+kpF24cXkH1YOOUeArRNYIxq1viYHZagBxrTno7cecY1Fa44tJeZvaoG+Djpkc3JwehN5g==",
       "dependencies": {
         "buffer-writer": "2.0.0",
         "packet-reader": "1.0.0",
-        "pg-connection-string": "^2.6.0",
-        "pg-pool": "^3.6.0",
+        "pg-connection-string": "^2.6.2",
+        "pg-pool": "^3.6.1",
         "pg-protocol": "^1.6.0",
         "pg-types": "^2.1.0",
         "pgpass": "1.x"
@@ -546,7 +546,7 @@
         "node": ">= 8.0.0"
       },
       "optionalDependencies": {
-        "pg-cloudflare": "^1.1.0"
+        "pg-cloudflare": "^1.1.1"
       },
       "peerDependencies": {
         "pg-native": ">=3.0.1"
@@ -558,15 +558,15 @@
       }
     },
     "node_modules/pg-cloudflare": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.1.0.tgz",
-      "integrity": "sha512-tGM8/s6frwuAIyRcJ6nWcIvd3+3NmUKIs6OjviIm1HPPFEt5MzQDOTBQyhPWg/m0kCl95M6gA1JaIXtS8KovOA==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.1.1.tgz",
+      "integrity": "sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q==",
       "optional": true
     },
     "node_modules/pg-connection-string": {
-      "version": "2.6.0",
-      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.6.0.tgz",
-      "integrity": "sha512-x14ibktcwlHKoHxx9X3uTVW9zIGR41ZB6QNhHb21OPNdCCO3NaRnpJuwKIQSR4u+Yqjx4HCvy7Hh7VSy1U4dGg=="
+      "version": "2.6.2",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.6.2.tgz",
+      "integrity": "sha512-ch6OwaeaPYcova4kKZ15sbJ2hKb/VP48ZD2gE7i1J+L4MspCtBMAx8nMgz7bksc7IojCIIWuEhHibSMFH8m8oA=="
     },
     "node_modules/pg-int8": {
       "version": "1.0.1",
@@ -577,9 +577,9 @@
       }
     },
     "node_modules/pg-pool": {
-      "version": "3.6.0",
-      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.6.0.tgz",
-      "integrity": "sha512-clFRf2ksqd+F497kWFyM21tMjeikn60oGDmqMT8UBrynEwVEX/5R5xd2sdvdo1cZCFlguORNpVuqxIj+aK4cfQ==",
+      "version": "3.6.1",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.6.1.tgz",
+      "integrity": "sha512-jizsIzhkIitxCGfPRzJn1ZdcosIt3pz9Sh3V01fm1vZnbnCMgmGl5wvGGdNN2EL9Rmb0EcFoCkixH4Pu+sP9Og==",
       "peerDependencies": {
         "pg": ">=8.0"
       }

package/replicator/package.json

@@ -17,7 +17,7 @@
   "dependencies": {
     "cors": "^2.8.5",
     "express": "^4.18.1",
-    "pg": "8.11"
+    "pg": "8.11.3"
   },
   "devDependencies": {
     "@types/cors": "^2.8.12",

package/src/authorization/authorization-keystore.ts

@@ -6,11 +6,12 @@ import {
     DistributionRules,
     FactEnvelope,
     FactFeed,
+    FactManager,
     FactRecord,
     FactReference,
-    Feed,
     Forbidden,
     Query,
+    ReferencesByName,
     Specification,
     Storage,
     UserIdentity,
@@ -19,7 +20,6 @@ import {
 } from "jinaga";
 
 import { Keystore } from "../keystore";
-import { distinct } from "../util/fn";
 import { DistributedFactCache } from "./distributed-fact-cache";
 
 export class AuthorizationKeystore implements Authorization {
@@ -28,6 +28,7 @@ export class AuthorizationKeystore implements Authorization {
     private distributedFacts: DistributedFactCache = new DistributedFactCache();
 
     constructor(
+        private factManager: FactManager,
         private store: Storage,
         private keystore: Keystore,
         authorizationRules: AuthorizationRules | null,
@@ -52,7 +53,7 @@ export class AuthorizationKeystore implements Authorization {
     }
 
     query(userIdentity: UserIdentity | null, start: FactReference, query: Query) {
-        return this.store.query(start, query);
+        return this.factManager.query(start, query);
     }
 
     async read(userIdentity: UserIdentity | null, start: FactReference[], specification: Specification) {
@@ -60,26 +61,34 @@ export class AuthorizationKeystore implements Authorization {
             const userReference: FactReference | null = userIdentity
                 ? await this.keystore.getUserFact(userIdentity)
                 : null;
+            const namedStart = specification.given.reduce((map, label, index) => ({
+                ...map,
+                [label.name]: start[index]
+            }), {} as ReferencesByName);
             // Break the specification into feeds and check distribution.
             const feeds = buildFeeds(specification);
-            const canDistribute = await this.distributionEngine.canDistributeToAll(feeds, start, userReference);
+            const canDistribute = await this.distributionEngine.canDistributeToAll(feeds, namedStart, userReference);
             if (canDistribute.type === "failure") {
                 throw new Forbidden(canDistribute.reason);
             }
         }
-        return await this.store.read(start, specification);
+        return await this.factManager.read(start, specification);
     }
 
-    async feed(userIdentity: UserIdentity | null, feed: Feed, start: FactReference[], bookmark: string): Promise<FactFeed> {
+    async feed(userIdentity: UserIdentity | null, specification: Specification, 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);
+            const namedStart = specification.given.reduce((map, label, index) => ({
+                ...map,
+                [label.name]: start[index]
+            }), {} as ReferencesByName);
+            const canDistribute = await this.distributionEngine.canDistributeToAll([specification], namedStart, userReference);
             if (canDistribute.type === "failure") {
                 throw new Forbidden(canDistribute.reason);
             }
-            const factFeed = await this.store.feed(feed, start, bookmark);
+            const factFeed = await this.store.feed(specification, start, bookmark);
             const factReferences = factFeed.tuples
                 .flatMap(tuple => tuple.facts)
                 .filter((value, index, self) => self.findIndex(factReferenceEquals(value)) === index);
@@ -87,7 +96,7 @@ export class AuthorizationKeystore implements Authorization {
             return factFeed;
         }
         else {
-            return await this.store.feed(feed, start, bookmark);
+            return await this.store.feed(specification, start, bookmark);
         }
     }
 
@@ -99,12 +108,12 @@ export class AuthorizationKeystore implements Authorization {
                 throw new Forbidden("Unauthorized");
             }
         }
-        return await this.store.load(references);
+        return await this.factManager.load(references);
     }
 
     async save(userIdentity: UserIdentity | null, facts: FactRecord[]) {
         if (!this.authorizationEngine) {
-            const envelopes = await this.store.save(facts.map(fact => ({
+            const envelopes = await this.factManager.save(facts.map(fact => ({
                 fact,
                 signatures: []
             })));
@@ -115,7 +124,7 @@ export class AuthorizationKeystore implements Authorization {
         const authorizedFacts = await this.authorizationEngine.authorizeFacts(facts, userFact);
         if (userIdentity) {
             const signedFacts = await this.keystore.signFacts(userIdentity, authorizedFacts);
-            const envelopes = await this.store.save(signedFacts);
+            const envelopes = await this.factManager.save(signedFacts);
             return envelopes.map(envelope => envelope.fact);
         }
         else {
@@ -123,7 +132,7 @@ export class AuthorizationKeystore implements Authorization {
         }
     }
 
-    async verifyDistribution(userIdentity: UserIdentity | null, feeds: Feed[], start: FactReference[]): Promise<void> {
+    async verifyDistribution(userIdentity: UserIdentity | null, feeds: Specification[], namedStart: ReferencesByName): Promise<void> {
         if (!this.distributionEngine) {
             return;
         }
@@ -131,7 +140,7 @@ export class AuthorizationKeystore implements Authorization {
         const userReference: FactReference | null = userIdentity
             ? await this.keystore.getUserFact(userIdentity)
             : null;
-        const canDistribute = await this.distributionEngine.canDistributeToAll(feeds, start, userReference);
+        const canDistribute = await this.distributionEngine.canDistributeToAll(feeds, namedStart, userReference);
         if (canDistribute.type === "failure") {
             throw new Forbidden(canDistribute.reason);
         }

package/src/http/router.ts

@@ -2,9 +2,11 @@ import { Handler, Router } from "express";
 import {
     Authorization,
     Declaration,
+    FactManager,
     FactRecord,
     FactReference,
-    Feed,
+    FeedCache,
+    FeedObject,
     FeedResponse,
     FeedsResponse,
     Forbidden,
@@ -14,6 +16,7 @@ import {
     ProjectedResult,
     QueryMessage,
     QueryResponse,
+    ReferencesByName,
     SaveMessage,
     Specification,
     SpecificationParser,
@@ -21,42 +24,91 @@ import {
     UserIdentity,
     buildFeeds,
     computeObjectHash,
+    computeTupleSubsetHash,
     fromDescriptiveString,
+    invertSpecification,
     parseLoadMessage,
     parseQueryMessage,
-    parseSaveMessage,
+    parseSaveMessage
 } from "jinaga";
 
-import { FeedCache, FeedDefinition } from "./feed-cache";
+import { Stream } from "./stream";
 
 interface ParsedQs { [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[] }
 
-function get<U>(method: ((req: RequestUser, params: { [key: string]: string }, query: ParsedQs) => Promise<U>)): Handler {
+function getOrStream<U>(
+    getMethod: ((req: RequestUser, params: { [key: string]: string }, query: ParsedQs) => Promise<U | null>),
+    streamMethod: ((req: RequestUser, params: { [key: string]: string }, query: ParsedQs) => Promise<Stream<U> | null>)
+): Handler {
     return (req, res, next) => {
         const user = <RequestUser>req.user;
-        method(user, req.params, req.query)
-            .then(response => {
-                if (!response) {
-                    res.sendStatus(404);
+        const accept = req.headers["accept"];
+        if (accept && accept.indexOf("application/x-jinaga-feed-stream") >= 0) {
+            streamMethod(user, req.params, req.query)
+                .then(response => {
+                    if (!response) {
+                        res.sendStatus(404);
+                        next();
+                    }
+                    else {
+                        res.type("application/x-jinaga-feed-stream");
+                        res.set("Connection", "keep-alive");
+                        res.set("Cache-Control", "no-cache");
+                        res.set("Access-Control-Allow-Origin", "*");
+                        res.flushHeaders();
+                        req.on("close", () => {
+                            response.close();
+                        });
+                        const timeout = setTimeout(() => {
+                            response.close();
+                        }, 5 * 60 * 1000);
+                        response
+                            .next(data => {
+                                res.write(JSON.stringify(data) + "\n\n");
+                            })
+                            .done(() => {
+                                clearTimeout(timeout);
+                                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();
-                }
-                else {
-                    res.type("json");
-                    res.send(JSON.stringify(response));
+                });
+        }
+        else {
+            getMethod(user, req.params, req.query)
+                .then(response => {
+                    if (!response) {
+                        res.sendStatus(404);
+                        next();
+                    }
+                    else {
+                        res.type("json");
+                        res.send(JSON.stringify(response));
+                        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 => {
-                if (error instanceof Forbidden) {
-                    res.type("text");
-                    res.status(403).send(error.message);
-                }
-                else {
-                    Trace.error(error);
-                    res.status(500).send(error.message);
-                }
-                next();
-            });
+                });
+        }
     };
 }
 
@@ -124,7 +176,7 @@ function postString<U>(method: (user: RequestUser, message: string) => Promise<U
     return (req, res, next) => {
         const user = <RequestUser>req.user;
         const input = parseString(req.body);
-        if (!input || typeof(input) !== 'string') {
+        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()).');
         }
@@ -187,7 +239,7 @@ function postStringCreate(method: (user: RequestUser, message: string) => Promis
     return (req, res, next) => {
         const user = <RequestUser>req.user;
         const input = parseString(req.body);
-        if (!input || typeof(input) !== 'string') {
+        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()).');
         }
@@ -214,7 +266,7 @@ function postStringCreate(method: (user: RequestUser, message: string) => Promis
     };
 }
 
-function serializeUserIdentity(user: RequestUser | null) : UserIdentity | null {
+function serializeUserIdentity(user: RequestUser | null): UserIdentity | null {
     if (!user) {
         return null;
     }
@@ -233,7 +285,7 @@ export interface RequestUser {
 export class HttpRouter {
     handler: Handler;
 
-    constructor(private authorization: Authorization, private feedCache: FeedCache, backwardCompatible: boolean) {
+    constructor(private factManager: FactManager, private authorization: Authorization, private feedCache: FeedCache, backwardCompatible: boolean) {
         const router = Router();
         router.get('/login', getAuthenticate(user => this.login(user)));
         if (backwardCompatible) {
@@ -257,7 +309,9 @@ export class HttpRouter {
             parseString,
             (user, input: string) => this.feeds(user, input)
         ));
-        router.get('/feeds/:hash', get((user, params, query) => this.feed(user, params, query)));
+        router.get('/feeds/:hash', getOrStream<FeedResponse>(
+            (user, params, query) => this.feed(user, params, query),
+            (user, params, query) => this.streamFeed(user, params, query)));
 
         this.handler = router;
     }
@@ -273,7 +327,7 @@ export class HttpRouter {
         };
     }
 
-    private async query(user: RequestUser | null, 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);
@@ -282,7 +336,7 @@ export class HttpRouter {
         };
     }
 
-    private async load(user: RequestUser, loadMessage: LoadMessage) : Promise<LoadResponse> {
+    private async load(user: RequestUser, loadMessage: LoadMessage): Promise<LoadResponse> {
         const userIdentity = serializeUserIdentity(user);
         const result = await this.authorization.load(userIdentity, loadMessage.references);
         return {
@@ -290,7 +344,7 @@ export class HttpRouter {
         };
     }
 
-    private async save(user: RequestUser | null, 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);
     }
@@ -346,33 +400,21 @@ export class HttpRouter {
                 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 namedStart = specification.given.reduce((map, label, index) => ({
+            ...map,
+            [label.name]: start[index]
+        }), {} as ReferencesByName);
 
         // 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 d of feedDefinitionsByHash) {
-            await this.feedCache.storeFeed(d.hash, d.feedDefinition);
-        }
+        await this.authorization.verifyDistribution(userIdentity, feeds, namedStart);
+
+        const feedHashes = this.feedCache.addFeeds(feeds, namedStart);
 
         return {
-            feeds: feedDefinitionsByHash.map(f => f.hash)
+            feeds: feedHashes
         }
     }
 
@@ -390,10 +432,7 @@ export class HttpRouter {
         const bookmark = query["b"] as string ?? "";
 
         const userIdentity = serializeUserIdentity(user);
-        const start = feedDefinition.start.reduce((start, input) => {
-            start[input.index] = input.factReference;
-            return start;
-        }, [] as FactReference[]);
+        const start = feedDefinition.feed.given.map(label => feedDefinition.namedStart[label.name]);
         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) =>
@@ -406,6 +445,62 @@ export class HttpRouter {
         return response;
     }
 
+    private async streamFeed(user: RequestUser | null, params: { [key: string]: string }, query: ParsedQs): Promise<Stream<FeedResponse> | null> {
+        const feedHash = params["hash"];
+        if (!feedHash) {
+            return null;
+        }
+
+        const feedDefinition = await this.feedCache.getFeed(feedHash);
+        if (!feedDefinition) {
+            return null;
+        }
+
+        let bookmark = query["b"] as string ?? "";
+
+        const userIdentity = serializeUserIdentity(user);
+        const start = feedDefinition.feed.given.map(label => feedDefinition.namedStart[label.name]);
+        const givenHash = computeObjectHash(feedDefinition.namedStart);
+
+        const stream = new Stream<FeedResponse>();
+        Trace.info("Initial response");
+        bookmark = await this.streamFeedResponse(userIdentity, feedDefinition, start, bookmark, stream);
+        const inverses = invertSpecification(feedDefinition.feed);
+        const listeners = inverses.map(inverse => this.factManager.addSpecificationListener(
+            inverse.inverseSpecification,
+            async (results) => {
+                // Filter out results that do not match the given.
+                const matchingResults = results.filter(pr =>
+                    givenHash === computeTupleSubsetHash(pr.tuple, inverse.givenSubset));
+                if (matchingResults.length != 0) {
+                    bookmark = await this.streamFeedResponse(userIdentity, feedDefinition, start, bookmark, stream, true);
+                }
+            }
+        ));
+        stream.done(() => {
+            Trace.info("Done");
+            for (const listener of listeners) {
+                this.factManager.removeSpecificationListener(listener);
+            }
+        });
+        return stream;
+    }
+
+    private async streamFeedResponse(userIdentity: UserIdentity | null, feedDefinition: FeedObject, start: FactReference[], bookmark: string, stream: Stream<FeedResponse>, skipIfEmpty = false): Promise<string> {
+        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
+        );
+        if (!skipIfEmpty || references.length > 0) {
+            const response: FeedResponse = {
+                references,
+                bookmark: results.bookmark
+            };
+            stream.feed(response);
+        }
+        return results.bookmark;
+    }
+
     private async getKnownFacts(user: RequestUser | null): Promise<Declaration> {
         if (user) {
             const userFact = await this.authorization.getOrCreateUserFact({
@@ -430,7 +525,7 @@ export class HttpRouter {
         }
     }
 
-    private selectStart(specification: Specification, declaration: Declaration) : FactReference[] {
+    private selectStart(specification: Specification, declaration: Declaration): FactReference[] {
         // Select starting facts that match the inputs
         return specification.given.map(input => {
             const declaredFact = declaration.find(d => d.name === input.name);
@@ -449,11 +544,6 @@ function parseString(input: any): string {
     return input;
 }
 
-function urlSafeHash(feed: Feed): string {
-    const base64 = computeObjectHash(feed);
-    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-}
-
 function extractResults(obj: any): any {
     if (Array.isArray(obj)) {
         const projectedResults: ProjectedResult[] = obj;

package/src/http/stream.ts

@@ -0,0 +1,32 @@
+export class Stream<T> {
+    private queue: T[] = [];
+    private handlers: ((data: T) => void)[] = [];
+    private doneHandlers: (() => void)[] = [];
+    private closed = false;
+
+    next(handler: (data: T) => void): Stream<T> {
+        this.handlers.push(handler);
+        this.queue.forEach(data => handler(data));
+        return this;
+    }
+
+    done(handler: () => void): Stream<T> {
+        this.doneHandlers.push(handler);
+        return this;
+    }
+
+    close(): void {
+        this.closed = true;
+        this.doneHandlers.forEach(handler => handler());
+        this.queue = [];
+        this.handlers = [];
+        this.doneHandlers = [];
+    }
+
+    feed(data: any): void {
+        if (!this.closed) {
+            this.queue.push(data);
+            this.handlers.forEach(handler => handler(data));
+        }
+    }
+}

package/src/index.ts

@@ -2,11 +2,10 @@ export { AuthenticationDevice } from "./authentication/authentication-device";
 export { AuthenticationSession } from "./authentication/authentication-session";
 export { AuthorizationKeystore } from "./authorization/authorization-keystore";
 export { DistributedFactCache } from "./authorization/distributed-fact-cache";
-export { FeedCache, FeedDefinition } from "./http/feed-cache";
 export { HttpRouter, RequestUser } from "./http/router";
+export { Stream } from "./http/stream";
 export { JinagaServer, JinagaServerConfig, JinagaServerInstance, tracePool } from "./jinaga-server";
 export { Keystore } from "./keystore";
-export { MemoryFeedCache } from "./memory/memory-feed-cache";
 export { MemoryKeystore } from "./memory/memory-keystore";
 export { PostgresKeystore } from "./postgres/postgres-keystore";
 export { PostgresStore } from "./postgres/postgres-store";