jinaga-server 3.6.0 → 3.7.1

package/src/http/router.ts

@@ -3,14 +3,14 @@ import {
     Authorization,
     buildFeeds,
     computeObjectHash,
-    computeTupleSubsetHash,
     Declaration,
+    DistributionDenialCode,
     FactEnvelope,
     FactManager,
     FactRecord,
     FactReference,
     FeedCache,
-    FeedObject,
+    FeedDecision,
     FeedResponse,
     FeedsResponse,
     Forbidden,
@@ -18,7 +18,6 @@ import {
     GraphSerializer,
     GraphSource,
     Invalid,
-    invertSpecification,
     LoadMessage,
     LoadResponse,
     parseLoadMessage,
@@ -33,6 +32,7 @@ import {
     verifyEnvelopes
 } from "jinaga";
 import { DistributionIntersectionBranch, FeedResult, SubscriptionAuthorizer } from "../authorization/authorization-keystore";
+import { FeedStreamSession, FeedStreamSessionConfig } from "../feeds/feed-stream-session";
 import { CsvMetadata } from "./csv-metadata";
 import { validateSpecificationForCsv } from "./csv-validator";
 import { createLineReader } from "./line-reader";
@@ -385,7 +385,8 @@ export class HttpRouter {
         private factManager: FactManager,
         private authorization: Authorization & SubscriptionAuthorizer,
         private feedCache: FeedCache,
-        private allowedOrigin: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void)
+        private allowedOrigin: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void),
+        private feedStreamConfig: Partial<FeedStreamSessionConfig> = {}
     ) {
         const router = Router();
         const applyAllowOrigin = this.applyAllowOrigin.bind(this);
@@ -468,12 +469,24 @@ export class HttpRouter {
     private save(user: RequestUser | null, graphSource: GraphSource): Promise<void> {
         return Trace.dependency("save", "", async () => {
             const userIdentity = serializeUserIdentity(user);
+            // Signatures are verified per flush as they stream in, but the
+            // envelopes are accumulated and authorized as a single batch.
+            // Otherwise, a graph body that flushes in chunks (GraphDeserializer
+            // flushes every 20 facts) would authorize each chunk independently,
+            // and a fact whose rule needs a predecessor from an earlier chunk
+            // would fail with "The fact <type>:<hash> is not defined." (issue #175).
+            const allEnvelopes: FactEnvelope[] = [];
             await graphSource.read(async (envelopes) => {
                 if (!verifyEnvelopes(envelopes)) {
                     throw new Forbidden("The signatures on the facts are invalid.");
                 }
-                await this.authorization.save(userIdentity, envelopes);
+                allEnvelopes.push(...envelopes);
             });
+            try {
+                await this.authorization.save(userIdentity, allEnvelopes);
+            } catch (error) {
+                throw toSaveAuthorizationError(error, allEnvelopes);
+            }
         });
     }
 
@@ -591,7 +604,17 @@ export class HttpRouter {
             let branches: DistributionIntersectionBranch[];
             let intersected: boolean;
             if (intersectResult.type === "denied") {
-                Trace.warn(`/feeds accepting spec without applicable distribution rule: ${intersectResult.reason}`);
+                // Structured, dashboard-observable signal that a feed was
+                // registered without an applicable distribution rule (issue
+                // #168 S3). The metric name is stable so a backend sees
+                // bounded cardinality; the denial code (a fixed 4-value enum)
+                // is the measurement dimension, so authoring errors
+                // (no-matching-rule / spec-more-restrictive-than-rule) are
+                // distinguishable from auth states (principal-excluded /
+                // not-authenticated) in CI and dashboards without grepping
+                // logs. The human-readable line is retained for correlation.
+                Trace.metric("distribution.unmatched", { [intersectResult.code]: 1 });
+                Trace.warn(`/feeds accepting spec without applicable distribution rule (${intersectResult.code}): ${intersectResult.reason}`);
                 branches = [{ start, specification }];
                 intersected = false;
             } else {
@@ -599,8 +622,44 @@ export class HttpRouter {
                 intersected = branches.length !== 1 || branches[0].specification !== specification;
             }
 
+            // Classify the spec's distribution decision once; it applies to
+            // every feed hash the spec produces (issue #168 S1). Registration
+            // and keep-alive are unchanged — reactive and denied feeds are
+            // still accepted and served exactly as before; this only reports
+            // the decision. `reactive` is authorized-via-intersection: denied
+            // now, self-heals when the authorizing fact arrives.
+            //
+            // S2: the decision is recomputed from verifyDistributionOrIntersect
+            // on every POST /feeds — it is NOT cached by feed hash — so a
+            // repeated request always returns the correct *per-user* decision.
+            // This matters because a non-intersected feed hash is shared across
+            // users (it excludes the requester's identity): the same hash is
+            // `authorized` for a permitted user and `denied` for another, and
+            // a `reactive` decision becomes `authorized` once the authorizing
+            // fact arrives. Caching the FeedDecision by hash would leak one
+            // user's decision to another. addFeeds stays idempotent on the
+            // hash; only the classification is per-request.
+            let decision: FeedDecision["decision"];
+            let decisionCode: DistributionDenialCode | undefined;
+            let decisionReason: string;
+            if (intersectResult.type === "denied") {
+                decision = "denied";
+                decisionCode = intersectResult.code;
+                decisionReason = intersectResult.reason;
+            } else if (intersected) {
+                decision = "reactive";
+                decisionCode = intersectResult.denial?.code;
+                decisionReason = intersectResult.denial?.reason
+                    ?? "Authorized via intersection; awaiting the authorizing fact.";
+            } else {
+                decision = "authorized";
+                decisionCode = undefined;
+                decisionReason = "Distribution authorized.";
+            }
+
             const ownerKey = subscriptionOwnerKey(userIdentity);
             const feedHashes: string[] = [];
+            const decisions: FeedDecision[] = [];
             for (const branch of branches) {
                 const branchNamedStart = branch.specification.given.reduce((map, g, index) => ({
                     ...map,
@@ -609,6 +668,14 @@ export class HttpRouter {
                 const branchFeeds = buildFeeds(branch.specification);
                 const branchHashes = this.feedCache.addFeeds(branchFeeds, branchNamedStart);
                 feedHashes.push(...branchHashes);
+                for (const hash of branchHashes) {
+                    decisions.push({
+                        feed: hash,
+                        decision,
+                        ...(decisionCode !== undefined ? { code: decisionCode } : {}),
+                        reason: decisionReason
+                    });
+                }
                 if (intersected) {
                     for (const hash of branchHashes) {
                         // Bind the hash to its owner so a different
@@ -635,7 +702,8 @@ export class HttpRouter {
             }
 
             return {
-                feeds: feedHashes
+                feeds: feedHashes,
+                decisions
             }
         });
     }
@@ -664,12 +732,16 @@ export class HttpRouter {
         return Trace.dependency("feed", params["hash"], async () => {
             const feedHash = params["hash"];
             if (!feedHash) {
+                // No hash in the route at all — a wrong URL, not a feed lookup.
                 return null;
             }
 
             const feedDefinition = await this.feedCache.getFeed(feedHash);
             if (!feedDefinition) {
-                return null;
+                // Known route, but the feed hash is unknown or expired. Signal
+                // this distinctly (issue #168 S4) so the client can re-register
+                // via POST /feeds instead of treating it as a routing error.
+                throw new FeedNotFound(feedHash);
             }
 
             const bookmark = query["b"] as string ?? "";
@@ -698,304 +770,51 @@ export class HttpRouter {
 
     private async streamFeed(user: RequestUser | null, params: { [key: string]: string }, query: qs.ParsedQs): Promise<Stream<FeedResponse> | null> {
         const connectionId = Math.random().toString(36).substring(2, 10);
-        const startTime = Date.now();
-        
-        console.log(`[StreamFeed:${connectionId}] NEW CONNECTION - User: ${user?.id || 'anonymous'}, Hash: ${params["hash"]}`);
-        
+
         const feedHash = params["hash"];
         if (!feedHash) {
-            console.log(`[StreamFeed:${connectionId}] No feed hash provided`);
+            // No hash in the route at all — a wrong URL, not a feed lookup.
             return null;
         }
 
         const feedDefinition = await this.feedCache.getFeed(feedHash);
         if (!feedDefinition) {
-            console.log(`[StreamFeed:${connectionId}] Feed definition not found for hash: ${feedHash}`);
-            return null;
+            // Known route, but the feed hash is unknown or expired. Signal
+            // this distinctly (issue #168 S4) so the client can re-register
+            // via POST /feeds instead of treating it as a routing error.
+            throw new FeedNotFound(feedHash);
         }
 
-        let bookmark = query["b"] as string ?? "";
-        console.log(`[StreamFeed:${connectionId}] Initial bookmark: ${bookmark || 'empty'}`);
+        const bookmark = query["b"] as string ?? "";
 
         const userIdentity = serializeUserIdentity(user);
         const start = feedDefinition.feed.given.map(g => feedDefinition.namedStart[g.label.name]);
         const givenHash = computeObjectHash(feedDefinition.namedStart);
 
-        console.log(`[StreamFeed:${connectionId}] Feed setup - Given hash: ${givenHash.substring(0, 8)}..., Start facts: ${start.length}`);
-
         const stream = new Stream<FeedResponse>();
-        
-        try {
-            // Continuous initial query until exhausted
-            console.log(`[StreamFeed:${connectionId}] Starting initial data streaming...`);
-            const initialStart = Date.now();
-            bookmark = await this.streamAllInitialResults(feedHash, userIdentity, feedDefinition, start, bookmark, stream);
-            const initialDuration = Date.now() - initialStart;
-            console.log(`[StreamFeed:${connectionId}] Initial data streaming complete - Duration: ${initialDuration}ms, Final bookmark: ${bookmark || 'empty'}`);
-            
-            // Set up real-time listeners after initial data is complete
-            console.log(`[StreamFeed:${connectionId}] Setting up real-time listeners...`);
-            const inverses = invertSpecification(feedDefinition.feed);
-            console.log(`[StreamFeed:${connectionId}] Created ${inverses.length} inverse specifications`);
-            
-            const listeners = inverses.map((inverse, index) => {
-                console.log(`[StreamFeed:${connectionId}] Adding listener ${index + 1}/${inverses.length}`);
-                
-                return this.factManager.addSpecificationListener(
-                    inverse.inverseSpecification,
-                    async (results) => {
-                        const eventStart = Date.now();
-                        console.log(`[StreamFeed:${connectionId}] EVENT RECEIVED - Listener ${index + 1}, Results: ${results.length}`);
-                        
-                        try {
-                            // Filter out results that do not match the given.
-                            const matchingResults = results.filter(pr =>
-                                givenHash === computeTupleSubsetHash(pr.tuple, inverse.givenSubset));
-                            
-                            console.log(`[StreamFeed:${connectionId}] Filtered results - Matching: ${matchingResults.length}/${results.length}`);
-                            
-                            if (matchingResults.length != 0) {
-                                console.log(`[StreamFeed:${connectionId}] Processing matching results...`);
-                                const responseStart = Date.now();
-                                bookmark = await this.streamFeedResponse(feedHash, userIdentity, feedDefinition, start, bookmark, stream, true);
-                                const responseDuration = Date.now() - responseStart;
-                                console.log(`[StreamFeed:${connectionId}] Feed response sent - Duration: ${responseDuration}ms, New bookmark: ${bookmark || 'empty'}`);
-                            } else {
-                                console.log(`[StreamFeed:${connectionId}] No matching results - skipping response`);
-                            }
-                        } catch (error) {
-                            console.error(`[StreamFeed:${connectionId}] ERROR processing event: ${error}`);
-                        }
-                        
-                        const eventDuration = Date.now() - eventStart;
-                        if (eventDuration > 100) {
-                            console.warn(`[StreamFeed:${connectionId}] SLOW event processing - Duration: ${eventDuration}ms`);
-                        }
-                    }
-                );
-            });
-            
-            console.log(`[StreamFeed:${connectionId}] All listeners registered - Count: ${listeners.length}`);
-
-            // Anchor listeners (jinaga.js#129): the inverse-listener path
-            // above only fires when a descendant of the given arrives. If
-            // the given fact itself isn't yet in the store when the client
-            // subscribes, neither the initial query nor any later inverse
-            // can deliver results until the given is recorded — and the
-            // given fact has no descendants whose save would re-trigger the
-            // inverse with the matching givenHash. Register a listener per
-            // unique anchor that re-runs streamFeedResponse the moment a
-            // saved fact matches the anchor's (type, hash).
-            const uniqueAnchors = start.filter((s, i, arr) =>
-                arr.findIndex(other => other.type === s.type && other.hash === s.hash) === i);
-            console.log(`[StreamFeed:${connectionId}] Registering ${uniqueAnchors.length} anchor listener(s)`);
-            const anchorListeners = uniqueAnchors.map(anchor => {
-                const anchorSpec: Specification = {
-                    given: [{ label: { name: "x", type: anchor.type }, conditions: [] }],
-                    matches: [],
-                    projection: { type: "fact", label: "x" }
-                };
-                return this.factManager.addSpecificationListener(anchorSpec, async (results) => {
-                    try {
-                        const matched = results.some(pr => {
-                            const ref = pr.tuple && (pr.tuple as any).x;
-                            return ref && ref.type === anchor.type && ref.hash === anchor.hash;
-                        });
-                        if (matched) {
-                            console.log(`[StreamFeed:${connectionId}] Anchor fact arrived - Type: ${anchor.type}, Hash: ${anchor.hash.substring(0, 8)}...`);
-                            bookmark = await this.streamFeedResponse(feedHash, userIdentity, feedDefinition, start, bookmark, stream, true);
-                        }
-                    } catch (error) {
-                        console.error(`[StreamFeed:${connectionId}] ERROR in anchor listener: ${error}`);
-                    }
-                });
-            });
-
-            stream.done(() => {
-                const cleanupStart = Date.now();
-                console.log(`[StreamFeed:${connectionId}] CLEANUP STARTED - Removing ${listeners.length + anchorListeners.length} listener(s)`);
-
-                for (let i = 0; i < listeners.length; i++) {
-                    try {
-                        this.factManager.removeSpecificationListener(listeners[i]);
-                        console.log(`[StreamFeed:${connectionId}] Removed listener ${i + 1}/${listeners.length}`);
-                    } catch (error) {
-                        console.error(`[StreamFeed:${connectionId}] ERROR removing listener ${i + 1}: ${error}`);
-                    }
-                }
-                for (let i = 0; i < anchorListeners.length; i++) {
-                    try {
-                        this.factManager.removeSpecificationListener(anchorListeners[i]);
-                    } catch (error) {
-                        console.error(`[StreamFeed:${connectionId}] ERROR removing anchor listener ${i + 1}: ${error}`);
-                    }
-                }
-
-                const cleanupDuration = Date.now() - cleanupStart;
-                const totalDuration = Date.now() - startTime;
-                console.log(`[StreamFeed:${connectionId}] CLEANUP COMPLETE - Cleanup duration: ${cleanupDuration}ms, Total connection duration: ${totalDuration}ms`);
-            });
-            
-            const setupDuration = Date.now() - startTime;
-            console.log(`[StreamFeed:${connectionId}] Stream setup complete - Duration: ${setupDuration}ms`);
-            
-            return stream;
-            
-        } catch (error) {
-            console.error(`[StreamFeed:${connectionId}] ERROR during setup: ${error}`);
-            throw error;
-        }
-    }
-
-    private async streamAllInitialResults(
-        feedHash: string,
-        userIdentity: UserIdentity | null,
-        feedDefinition: FeedObject,
-        start: FactReference[],
-        initialBookmark: string,
-        stream: Stream<FeedResponse>
-    ): Promise<string> {
-        const streamId = Math.random().toString(36).substring(2, 8);
-        console.log(`[InitialResults:${streamId}] Starting initial data fetch - Bookmark: ${initialBookmark || 'empty'}`);
-        
-        let bookmark = initialBookmark;
-        let hasMoreResults = true;
-        let pageCount = 0;
-        let totalReferences = 0;
-        const maxPages = 1000; // Safety limit to prevent infinite loops
-        const startTime = Date.now();
-        
-        while (hasMoreResults && pageCount < maxPages) {
-            const pageStart = Date.now();
-            console.log(`[InitialResults:${streamId}] Fetching page ${pageCount + 1} - Bookmark: ${bookmark || 'empty'}`);
-
-            const queryResult = await this.queryFeed(feedHash, userIdentity, feedDefinition.feed, start, bookmark);
-            if (queryResult.type === "denied") {
-                // The subscription has already been accepted; tearing
-                // down the stream on a distribution failure would force
-                // the client to re-subscribe just to keep waiting.
-                // Treat as empty and let the listener path re-evaluate
-                // when an authorizing fact arrives.
-                console.log(`[InitialResults:${streamId}] Distribution failed (${queryResult.reason}) - serving empty and keeping stream live`);
-                return bookmark;
-            }
-            const results = queryResult.feed;
-            const fetchDuration = Date.now() - pageStart;
 
-            console.log(`[InitialResults:${streamId}] Page ${pageCount + 1} fetched - Tuples: ${results.tuples.length}, Duration: ${fetchDuration}ms`);
-            
-            // Check if we got results
-            if (results.tuples.length === 0) {
-                console.log(`[InitialResults:${streamId}] No more results - ending pagination`);
-                hasMoreResults = false;
-                break;
-            }
-            
-            // Process and send results
-            const processStart = Date.now();
-            const references = results.tuples.flatMap(t => t.facts).filter((value, index, self) =>
-                self.findIndex(f => f.hash === value.hash && f.type === value.type) === index
-            );
-            const processDuration = Date.now() - processStart;
-            
-            console.log(`[InitialResults:${streamId}] Page ${pageCount + 1} processed - References: ${references.length}, Process duration: ${processDuration}ms`);
-            
-            if (references.length > 0) {
-                const response: FeedResponse = {
-                    references,
-                    bookmark: results.bookmark
-                };
-                
-                const feedStart = Date.now();
-                stream.feed(response);
-                const feedDuration = Date.now() - feedStart;
-                
-                totalReferences += references.length;
-                console.log(`[InitialResults:${streamId}] Page ${pageCount + 1} sent to stream - Feed duration: ${feedDuration}ms`);
-            }
-            
-            // Update bookmark for next iteration
-            const newBookmark = results.bookmark;
-            if (newBookmark === bookmark) {
-                console.log(`[InitialResults:${streamId}] Bookmark unchanged - ending pagination`);
-                hasMoreResults = false;
-            } else {
-                bookmark = newBookmark;
-            }
-            
-            // Check if we got fewer results than the page size (indicates end)
-            if (results.tuples.length < 100) {
-                console.log(`[InitialResults:${streamId}] Partial page received (${results.tuples.length} < 100) - ending pagination`);
-                hasMoreResults = false;
-            }
-            
-            pageCount++;
-            
-            // Add small delay to prevent overwhelming the database
-            if (hasMoreResults && pageCount % 10 === 0) {
-                console.log(`[InitialResults:${streamId}] Adding delay after ${pageCount} pages`);
-                await new Promise(resolve => setTimeout(resolve, 10));
-            }
-        }
-        
-        const totalDuration = Date.now() - startTime;
-        console.log(`[InitialResults:${streamId}] Initial data streaming complete - Pages: ${pageCount}, Total references: ${totalReferences}, Duration: ${totalDuration}ms, Final bookmark: ${bookmark || 'empty'}`);
-        
-        if (pageCount >= maxPages) {
-            console.warn(`[InitialResults:${streamId}] Hit maximum page limit (${maxPages}) - possible infinite loop`);
-        }
-        
-        return bookmark;
-    }
+        // The session serializes every fetch and stream operation through a
+        // single bookmark-driven query cycle. Inverse and anchor observers
+        // only enqueue references onto a waitlist and wake the cycle; they
+        // never fetch or stream directly. This removes the race between
+        // listener callbacks and bookmark mutation, guarantees tuple
+        // completeness, and ensures no update is lost between pages.
+        const session = new FeedStreamSession(
+            (b: string) => this.queryFeed(feedHash, userIdentity, feedDefinition.feed, start, b),
+            this.factManager,
+            feedDefinition,
+            start,
+            givenHash,
+            stream,
+            bookmark,
+            connectionId,
+            this.feedStreamConfig
+        );
 
-    private async streamFeedResponse(feedHash: string, userIdentity: UserIdentity | null, feedDefinition: FeedObject, start: FactReference[], bookmark: string, stream: Stream<FeedResponse>, skipIfEmpty = false): Promise<string> {
-        const responseId = Math.random().toString(36).substring(2, 6);
-        const startTime = Date.now();
-        
-        console.log(`[FeedResponse:${responseId}] Starting feed response - Bookmark: ${bookmark || 'empty'}, Skip if empty: ${skipIfEmpty}`);
-        
-        const feedStart = Date.now();
-        const queryResult = await this.queryFeed(feedHash, userIdentity, feedDefinition.feed, start, bookmark);
-        if (queryResult.type === "denied") {
-            // The subscription stays live across distribution failures
-            // so the inverse / anchor listeners can deliver results
-            // once the authorizing fact arrives.
-            console.log(`[FeedResponse:${responseId}] Distribution failed (${queryResult.reason}) - keeping stream live`);
-            return bookmark;
-        }
-        const results = queryResult.feed;
-        const feedDuration = Date.now() - feedStart;
+        stream.done(() => session.dispose());
+        session.start();
 
-        console.log(`[FeedResponse:${responseId}] Authorization feed complete - Tuples: ${results.tuples.length}, Duration: ${feedDuration}ms`);
-        
-        // Return distinct fact references from all the tuples.
-        const processStart = Date.now();
-        const references = results.tuples.flatMap(t => t.facts).filter((value, index, self) =>
-            self.findIndex(f => f.hash === value.hash && f.type === value.type) === index
-        );
-        const processDuration = Date.now() - processStart;
-        
-        console.log(`[FeedResponse:${responseId}] References processed - Count: ${references.length}, Duration: ${processDuration}ms`);
-        
-        if (!skipIfEmpty || references.length > 0) {
-            const response: FeedResponse = {
-                references,
-                bookmark: results.bookmark
-            };
-            
-            const streamStart = Date.now();
-            stream.feed(response);
-            const streamDuration = Date.now() - streamStart;
-            
-            console.log(`[FeedResponse:${responseId}] Response sent to stream - Duration: ${streamDuration}ms`);
-        } else {
-            console.log(`[FeedResponse:${responseId}] Skipping empty response`);
-        }
-        
-        const totalDuration = Date.now() - startTime;
-        console.log(`[FeedResponse:${responseId}] Feed response complete - New bookmark: ${results.bookmark || 'empty'}, Total duration: ${totalDuration}ms`);
-        
-        return results.bookmark;
+        return stream;
     }
 
     private async getKnownFacts(user: RequestUser | null): Promise<Declaration> {
@@ -1158,9 +977,50 @@ function extractResults(obj: any): { result: any, count: number } {
     }
 }
 
+// A known/expired feed hash missed the feed cache. Distinct from a route
+// miss (wrong URL) so clients can tell "unknown/expired feed hash" — which is
+// recoverable by re-registering via POST /feeds — from "wrong URL" (issue
+// #168 S4). handleError maps this to a 404 with a machine-readable body.
+export class FeedNotFound extends Error {
+    constructor(public readonly feedHash: string) {
+        super(`Feed not found: ${feedHash}`);
+        this.name = "FeedNotFound";
+    }
+}
+
+// Authorization rule evaluation reports a missing predecessor as a plain
+// Error of this shape (see authorizationRules.ts / specification-runner.ts
+// in jinaga). It surfaces when the client's save request didn't include the
+// full closure of facts a rule needs to walk. Map it to a diagnosable 4xx
+// instead of an opaque 500 (issue #175).
+const FACT_NOT_DEFINED_PATTERN = /^The fact (\S+):(\S+) is not defined\.$/;
+
+function toSaveAuthorizationError(error: any, envelopes: FactEnvelope[]): any {
+    if (error instanceof Error) {
+        const match = FACT_NOT_DEFINED_PATTERN.exec(error.message);
+        if (match) {
+            const [, factType, factHash] = match;
+            const factTypesInBatch = Array.from(new Set(envelopes.map(e => e.fact.type))).join(", ");
+            Trace.warn(
+                `Save authorization could not resolve predecessor ${factType}:${factHash} ` +
+                `among ${envelopes.length} fact(s) in the request (types: ${factTypesInBatch}).`
+            );
+            return new Invalid(
+                `The fact ${factType}:${factHash} is required to authorize this save but was not included in the request. ` +
+                `Ensure the full closure of predecessors needed by your authorization rules is sent together.`
+            );
+        }
+    }
+    return error;
+}
+
 function handleError(error: any, req: Request, res: Response, next: NextFunction) {
     const requestPath = req.path;
-    if (error instanceof Forbidden) {
+    if (error instanceof FeedNotFound) {
+        Trace.warn(`Feed not found: ${error.feedHash} (Path: ${requestPath})`);
+        res.type("text");
+        res.status(404).send("feed_not_found");
+    } else if (error instanceof Forbidden) {
         Trace.warn(`Forbidden: ${error.message} (Path: ${requestPath})`);
         res.type("text");
         res.status(403).send(error.message);

package/src/index.ts

@@ -2,8 +2,9 @@ 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 { FeedStreamSession, FeedStreamSessionConfig, defaultFeedStreamSessionConfig } from "./feeds/feed-stream-session";
 export { createLineReader } from "./http/line-reader";
-export { HttpRouter, RequestUser } from "./http/router";
+export { FeedNotFound, HttpRouter, RequestUser } from "./http/router";
 export { Stream } from "./http/stream";
 export { JinagaServer, JinagaServerConfig, JinagaServerInstance, tracePool } from "./jinaga-server";
 export { Keystore } from "./keystore";

package/src/jinaga-server.ts

@@ -37,6 +37,7 @@ import { Pool } from "pg";
 import { AuthenticationDevice } from "./authentication/authentication-device";
 import { AuthenticationSession } from "./authentication/authentication-session";
 import { AuthorizationKeystore, DistributionBranchesResult, FeedResult, SubscriptionAuthorizer } from "./authorization/authorization-keystore";
+import { FeedStreamSessionConfig } from "./feeds/feed-stream-session";
 import { HttpRouter, RequestUser } from "./http/router";
 import { Keystore } from "./keystore";
 import { PostgresKeystore } from "./postgres/postgres-keystore";
@@ -56,7 +57,13 @@ export type JinagaServerConfig = {
     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)
+    origin?: string | string[] | ((origin: string, callback: (err: Error | null, allow?: boolean) => void) => void),
+    /**
+     * Tuning for the per-connection feed streaming session
+     * (/feeds/:hash with Accept: application/x-jinaga-feed-stream).
+     * See FeedStreamSessionConfig for the available limits and defaults.
+     */
+    feedStream?: Partial<FeedStreamSessionConfig>
 };
 
 export type JinagaServerInstance = {
@@ -91,7 +98,7 @@ export class JinagaServer {
         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 router = new HttpRouter(factManager, authorization, feedCache, config.origin || '*', config.feedStream || {});
         const j: Jinaga = new Jinaga(authentication, factManager, syncStatusNotifier);
 
         async function close() {