jinaga-server 3.5.1 → 3.5.3

package/dist/http/router.js

@@ -12,58 +12,125 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpRouter = void 0;
 const express_1 = require("express");
 const jinaga_1 = require("jinaga");
+const csv_validator_1 = require("./csv-validator");
 const line_reader_1 = require("./line-reader");
+const output_formatters_1 = require("./output-formatters");
+const result_stream_1 = require("./result-stream");
 const stream_1 = require("./stream");
 function getOrStream(getMethod, streamMethod) {
     return (req, res, next) => {
+        const connectionId = Math.random().toString(36).substring(2, 10);
         const user = req.user;
         const accept = req.headers["accept"];
+        console.log(`[HttpConnection:${connectionId}] New request - User: ${(user === null || user === void 0 ? void 0 : user.id) || 'anonymous'}, Accept: ${accept}, URL: ${req.url}`);
         if (accept && accept.indexOf("application/x-jinaga-feed-stream") >= 0) {
+            console.log(`[HttpConnection:${connectionId}] STREAMING request detected`);
             streamMethod(user, req.params, req.query)
                 .then(response => {
                 if (!response) {
+                    console.log(`[HttpConnection:${connectionId}] Stream method returned null - sending 404`);
                     res.sendStatus(404);
                     next();
                 }
                 else {
+                    console.log(`[HttpConnection:${connectionId}] Setting up streaming response`);
                     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();
+                    console.log(`[HttpConnection:${connectionId}] Headers flushed - setting up event handlers`);
+                    let clientDisconnected = false;
+                    let timeoutTriggered = false;
+                    let streamClosed = false;
+                    // Client disconnect handler
                     req.on("close", () => {
-                        response.close();
+                        console.log(`[HttpConnection:${connectionId}] CLIENT DISCONNECTED`);
+                        clientDisconnected = true;
+                        if (!streamClosed) {
+                            console.log(`[HttpConnection:${connectionId}] Closing stream due to client disconnect`);
+                            response.close();
+                            streamClosed = true;
+                        }
                     });
+                    // Timeout handler
                     const timeout = setTimeout(() => {
-                        response.close();
+                        console.log(`[HttpConnection:${connectionId}] TIMEOUT TRIGGERED (5 minutes)`);
+                        timeoutTriggered = true;
+                        if (!streamClosed) {
+                            console.log(`[HttpConnection:${connectionId}] Closing stream due to timeout`);
+                            response.close();
+                            streamClosed = true;
+                        }
                     }, 5 * 60 * 1000);
+                    let messageCount = 0;
                     response
                         .next(data => {
-                        res.write(JSON.stringify(data) + "\n\n");
+                        messageCount++;
+                        const writeStart = Date.now();
+                        if (clientDisconnected) {
+                            console.warn(`[HttpConnection:${connectionId}] Attempted to write to disconnected client - Message #${messageCount}`);
+                            return;
+                        }
+                        try {
+                            const jsonData = JSON.stringify(data) + "\n\n";
+                            res.write(jsonData);
+                            const writeDuration = Date.now() - writeStart;
+                            console.log(`[HttpConnection:${connectionId}] Message #${messageCount} sent - Size: ${jsonData.length} bytes, Duration: ${writeDuration}ms`);
+                            if (writeDuration > 50) {
+                                console.warn(`[HttpConnection:${connectionId}] SLOW write operation - Duration: ${writeDuration}ms`);
+                            }
+                        }
+                        catch (error) {
+                            console.error(`[HttpConnection:${connectionId}] ERROR writing message #${messageCount}: ${error}`);
+                        }
                     })
                         .done(() => {
                         var _a;
+                        console.log(`[HttpConnection:${connectionId}] STREAM DONE - Messages sent: ${messageCount}, Client disconnected: ${clientDisconnected}, Timeout triggered: ${timeoutTriggered}`);
                         clearTimeout(timeout);
-                        (_a = res.socket) === null || _a === void 0 ? void 0 : _a.end();
+                        streamClosed = true;
+                        try {
+                            if (!clientDisconnected) {
+                                console.log(`[HttpConnection:${connectionId}] Ending socket connection`);
+                                (_a = res.socket) === null || _a === void 0 ? void 0 : _a.end();
+                            }
+                            else {
+                                console.log(`[HttpConnection:${connectionId}] Client already disconnected - skipping socket end`);
+                            }
+                        }
+                        catch (error) {
+                            console.error(`[HttpConnection:${connectionId}] ERROR ending socket: ${error}`);
+                        }
                     });
+                    console.log(`[HttpConnection:${connectionId}] Stream handlers configured`);
                 }
             })
-                .catch(error => handleError(error, req, res, next));
+                .catch(error => {
+                console.error(`[HttpConnection:${connectionId}] ERROR in stream method: ${error}`);
+                handleError(error, req, res, next);
+            });
         }
         else {
+            console.log(`[HttpConnection:${connectionId}] Regular GET request`);
             getMethod(user, req.params, req.query)
                 .then(response => {
                 if (!response) {
+                    console.log(`[HttpConnection:${connectionId}] Get method returned null - sending 404`);
                     res.sendStatus(404);
                     next();
                 }
                 else {
+                    console.log(`[HttpConnection:${connectionId}] Sending JSON response`);
                     res.type("json");
                     res.send(JSON.stringify(response));
                     next();
                 }
             })
-                .catch(error => handleError(error, req, res, next));
+                .catch(error => {
+                console.error(`[HttpConnection:${connectionId}] ERROR in get method: ${error}`);
+                handleError(error, req, res, next);
+            });
         }
     };
 }
@@ -105,25 +172,6 @@ function post(parse, method, output) {
             .catch(error => handleError(error, req, res, next));
     };
 }
-function postString(method) {
-    return (req, res, next) => {
-        const user = req.user;
-        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()).');
-        }
-        else {
-            method(user, input)
-                .then(response => {
-                res.type("text");
-                res.send(JSON.stringify(response, null, 2));
-                next();
-            })
-                .catch(error => handleError(error, req, res, next));
-        }
-    };
-}
 function postCreate(parse, method) {
     return (req, res, next) => {
         const user = req.user;
@@ -154,6 +202,32 @@ function postStringCreate(method) {
         }
     };
 }
+function postReadWithStreaming(method) {
+    return (req, res, next) => {
+        const user = req.user;
+        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()).');
+        }
+        else {
+            // Check if Accept header explicitly prefers a specific format
+            const acceptHeader = req.get('Accept');
+            let acceptType = 'text/plain'; // Default for backward compatibility
+            if (acceptHeader && acceptHeader !== '*/*') {
+                // Only use req.accepts() when there's a specific preference
+                const preferredType = req.accepts(['text/csv', 'application/x-ndjson', 'application/json', 'text/plain']);
+                acceptType = preferredType ? String(preferredType) : 'text/plain';
+            }
+            method(user, input, acceptType)
+                .then(({ resultStream, csvMetadata }) => {
+                outputReadResults(resultStream, res, acceptType, csvMetadata);
+                next();
+            })
+                .catch(error => handleError(error, req, res, next));
+        }
+    };
+}
 function serializeUserIdentity(user) {
     if (!user) {
         return null;
@@ -203,6 +277,16 @@ function outputFeeds(result, res, accepts) {
     res.type("json");
     res.send(JSON.stringify(result));
 }
+function outputReadResults(result, res, acceptType, csvMetadata) {
+    // Use streaming output formatter
+    (0, output_formatters_1.outputReadResultsStreaming)(result, res, acceptType, csvMetadata)
+        .catch(error => {
+        console.error('Error in outputReadResults:', error);
+        if (!res.headersSent) {
+            res.status(500).send('Internal server error');
+        }
+    });
+}
 class HttpRouter {
     constructor(factManager, authorization, feedCache, allowedOrigin) {
         this.factManager = factManager;
@@ -214,7 +298,7 @@ class HttpRouter {
         router.get('/login', applyAllowOrigin, getAuthenticate(user => this.login(user)));
         router.post('/load', applyAllowOrigin, post(jinaga_1.parseLoadMessage, (user, loadMessage) => this.load(user, loadMessage), outputGraph));
         router.post('/save', applyAllowOrigin, postCreate(inputSaveMessage, (user, graphSource) => this.save(user, graphSource)));
-        router.post('/read', applyAllowOrigin, postString((user, input) => this.read(user, input)));
+        router.post('/read', applyAllowOrigin, postReadWithStreaming((user, input, acceptType) => this.readWithStreaming(user, input, acceptType === 'text/csv' ? preProcessForCsv : preProcessForOther)));
         router.post('/write', applyAllowOrigin, postStringCreate((user, input) => this.write(user, input)));
         router.post('/feeds', applyAllowOrigin, post(parseString, (user, input, accepts) => this.feeds(user, input), outputFeeds));
         router.get('/feeds/:hash', applyAllowOrigin, getOrStream((user, params, query) => this.feed(user, params, query), (user, params, query) => this.streamFeed(user, params, query)));
@@ -273,25 +357,38 @@ class HttpRouter {
             }));
         }));
     }
-    read(user, input) {
-        return jinaga_1.Trace.dependency("read", "", () => __awaiter(this, void 0, void 0, function* () {
-            const knownFacts = yield this.getKnownFacts(user);
-            const parser = new jinaga_1.SpecificationParser(input);
-            parser.skipWhitespace();
-            const declaration = parser.parseDeclaration(knownFacts);
-            const specification = parser.parseSpecification();
-            parser.expectEnd();
-            const start = this.selectStart(specification, declaration);
-            var failures = this.factManager.testSpecificationForCompliance(specification);
-            if (failures.length > 0) {
-                throw new jinaga_1.Invalid(failures.join("\n"));
-            }
-            const userIdentity = serializeUserIdentity(user);
-            const results = yield this.authorization.read(userIdentity, start, specification);
-            const extracted = extractResults(results);
-            jinaga_1.Trace.counter("facts_read", extracted.count);
-            return extracted.result;
-        }));
+    /**
+     * Read with streaming support.
+     * Uses readStream if available on the authorization object, otherwise falls back to read().
+     *
+     * When CSV format is requested, validates that the specification contains only flat projections.
+     */
+    readWithStreaming(user, input, preProcess) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return jinaga_1.Trace.dependency("readWithStreaming", "", () => __awaiter(this, void 0, void 0, function* () {
+                const knownFacts = yield this.getKnownFacts(user);
+                const parser = new jinaga_1.SpecificationParser(input);
+                parser.skipWhitespace();
+                const declaration = parser.parseDeclaration(knownFacts);
+                const specification = parser.parseSpecification();
+                parser.expectEnd();
+                var failures = this.factManager.testSpecificationForCompliance(specification);
+                if (failures.length > 0) {
+                    throw new jinaga_1.Invalid(failures.join("\n"));
+                }
+                const csvMetadata = preProcess(specification);
+                const userIdentity = serializeUserIdentity(user);
+                const start = this.selectStart(specification, declaration);
+                const results = yield this.authorization.read(userIdentity, start, specification);
+                const extracted = extractResults(results);
+                jinaga_1.Trace.counter("facts_read", extracted.count);
+                const resultStream = (0, result_stream_1.arrayToResultStream)(extracted.result);
+                return {
+                    resultStream,
+                    csvMetadata
+                };
+            }));
+        });
     }
     write(user, input) {
         return jinaga_1.Trace.dependency("write", "", () => __awaiter(this, void 0, void 0, function* () {
@@ -329,8 +426,8 @@ class HttpRouter {
             }
             // 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 jinaga_1.Invalid(`The type of start fact ${i} (${start[i].type}) does not match the type of input ${i} (${specification.given[i].type})`);
+                if (start[i].type !== specification.given[i].label.type) {
+                    throw new jinaga_1.Invalid(`The type of start fact ${i} (${start[i].type}) does not match the type of input ${i} (${specification.given[i].label.type})`);
                 }
             }
             // Verify that the specification is compliant with purge conditions
@@ -338,7 +435,7 @@ class HttpRouter {
             if (failures.length > 0) {
                 throw new jinaga_1.Invalid(failures.join("\n"));
             }
-            const namedStart = specification.given.reduce((map, label, index) => (Object.assign(Object.assign({}, map), { [label.name]: start[index] })), {});
+            const namedStart = specification.given.reduce((map, g, index) => (Object.assign(Object.assign({}, map), { [g.label.name]: start[index] })), {});
             // Verify that I can distribute all feeds to the user.
             const feeds = (0, jinaga_1.buildFeeds)(specification);
             const userIdentity = serializeUserIdentity(user);
@@ -362,7 +459,7 @@ class HttpRouter {
             }
             const bookmark = (_a = query["b"]) !== null && _a !== void 0 ? _a : "";
             const userIdentity = serializeUserIdentity(user);
-            const start = feedDefinition.feed.given.map(label => feedDefinition.namedStart[label.name]);
+            const start = feedDefinition.feed.given.map(g => feedDefinition.namedStart[g.label.name]);
             const results = yield 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);
@@ -376,64 +473,135 @@ class HttpRouter {
     streamFeed(user, params, query) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const connectionId = Math.random().toString(36).substring(2, 10);
+            const startTime = Date.now();
+            console.log(`[StreamFeed:${connectionId}] NEW CONNECTION - User: ${(user === null || user === void 0 ? void 0 : user.id) || 'anonymous'}, Hash: ${params["hash"]}`);
             const feedHash = params["hash"];
             if (!feedHash) {
+                console.log(`[StreamFeed:${connectionId}] No feed hash provided`);
                 return null;
             }
             const feedDefinition = yield this.feedCache.getFeed(feedHash);
             if (!feedDefinition) {
+                console.log(`[StreamFeed:${connectionId}] Feed definition not found for hash: ${feedHash}`);
                 return null;
             }
             let bookmark = (_a = query["b"]) !== null && _a !== void 0 ? _a : "";
+            console.log(`[StreamFeed:${connectionId}] Initial bookmark: ${bookmark || 'empty'}`);
             const userIdentity = serializeUserIdentity(user);
-            const start = feedDefinition.feed.given.map(label => feedDefinition.namedStart[label.name]);
+            const start = feedDefinition.feed.given.map(g => feedDefinition.namedStart[g.label.name]);
             const givenHash = (0, jinaga_1.computeObjectHash)(feedDefinition.namedStart);
+            console.log(`[StreamFeed:${connectionId}] Feed setup - Given hash: ${givenHash.substring(0, 8)}..., Start facts: ${start.length}`);
             const stream = new stream_1.Stream();
-            // Continuous initial query until exhausted
-            bookmark = yield this.streamAllInitialResults(userIdentity, feedDefinition, start, bookmark, stream);
-            // Set up real-time listeners after initial data is complete
-            const inverses = (0, jinaga_1.invertSpecification)(feedDefinition.feed);
-            const listeners = inverses.map(inverse => this.factManager.addSpecificationListener(inverse.inverseSpecification, (results) => __awaiter(this, void 0, void 0, function* () {
-                // Filter out results that do not match the given.
-                const matchingResults = results.filter(pr => givenHash === (0, jinaga_1.computeTupleSubsetHash)(pr.tuple, inverse.givenSubset));
-                if (matchingResults.length != 0) {
-                    bookmark = yield this.streamFeedResponse(userIdentity, feedDefinition, start, bookmark, stream, true);
-                }
-            })));
-            stream.done(() => {
-                for (const listener of listeners) {
-                    this.factManager.removeSpecificationListener(listener);
-                }
-            });
-            return stream;
+            try {
+                // Continuous initial query until exhausted
+                console.log(`[StreamFeed:${connectionId}] Starting initial data streaming...`);
+                const initialStart = Date.now();
+                bookmark = yield this.streamAllInitialResults(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 = (0, jinaga_1.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, (results) => __awaiter(this, void 0, void 0, function* () {
+                        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 === (0, jinaga_1.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 = yield this.streamFeedResponse(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}`);
+                stream.done(() => {
+                    const cleanupStart = Date.now();
+                    console.log(`[StreamFeed:${connectionId}] CLEANUP STARTED - Removing ${listeners.length} listeners`);
+                    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}`);
+                        }
+                    }
+                    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;
+            }
         });
     }
     streamAllInitialResults(userIdentity, feedDefinition, start, initialBookmark, stream) {
         return __awaiter(this, void 0, void 0, function* () {
+            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 results = yield this.authorization.feed(userIdentity, feedDefinition.feed, start, bookmark);
+                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 = {
                         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) {
-                    // No progress made, avoid infinite loop
+                    console.log(`[InitialResults:${streamId}] Bookmark unchanged - ending pagination`);
                     hasMoreResults = false;
                 }
                 else {
@@ -441,29 +609,53 @@ class HttpRouter {
                 }
                 // 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`);
                     yield 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;
         });
     }
     streamFeedResponse(userIdentity, feedDefinition, start, bookmark, stream, skipIfEmpty = false) {
         return __awaiter(this, void 0, void 0, function* () {
+            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 results = yield this.authorization.feed(userIdentity, feedDefinition.feed, start, bookmark);
+            const feedDuration = Date.now() - feedStart;
+            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 = {
                     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;
         });
     }
@@ -495,9 +687,9 @@ class HttpRouter {
     selectStart(specification, declaration) {
         // Select starting facts that match the inputs
         return specification.given.map(input => {
-            const declaredFact = declaration.find(d => d.name === input.name);
+            const declaredFact = declaration.find(d => d.name === input.label.name);
             if (!declaredFact) {
-                throw new jinaga_1.Invalid(`No fact named ${input.name} was declared`);
+                throw new jinaga_1.Invalid(`No fact named ${input.label.name} was declared`);
             }
             return declaredFact.declared.reference;
         });
@@ -568,6 +760,20 @@ class HttpRouter {
     }
 }
 exports.HttpRouter = HttpRouter;
+function preProcessForCsv(specification) {
+    const csvMetadata = (0, csv_validator_1.validateSpecificationForCsv)(specification);
+    if (!csvMetadata.isValid) {
+        throw new jinaga_1.Invalid(`Specification is not compatible with CSV format:\n\n` +
+            csvMetadata.errors.join('\n\n') +
+            `\n\nHint: CSV requires flat projections with single-valued fields. ` +
+            `Avoid nested specifications.`);
+    }
+    return csvMetadata;
+}
+function preProcessForOther(specification) {
+    // For non-CSV formats, no special preprocessing is needed.
+    return undefined;
+}
 function parseString(input) {
     if (typeof input !== 'string') {
         throw new jinaga_1.Invalid("Expected a string. Check the content type of the request.");