flowquery 1.0.16 → 1.0.17

package/misc/apps/RAG/src/components/AdaptiveCardRenderer.tsx

@@ -235,10 +235,16 @@ export class AdaptiveCardRenderer extends React.Component<AdaptiveCardRendererPr
         this.containerRef.current.innerHTML = '';
         
         try {
+            // Normalize the card to standard Adaptive Card format
+            let cardPayload = normalizeAdaptiveCard(card);
+            
+            if (!cardPayload) {
+                throw new Error('Invalid Adaptive Card format');
+            }
+            
             // Apply data binding if data is provided
-            let cardPayload = card;
             if (data) {
-                const template = new ACData.Template(card);
+                const template = new ACData.Template(cardPayload);
                 cardPayload = template.expand({
                     $root: data
                 });
@@ -299,14 +305,76 @@ export class AdaptiveCardRenderer extends React.Component<AdaptiveCardRendererPr
 }
 
 /**
- * Helper function to check if an object looks like an Adaptive Card
+ * Helper function to check if an object looks like an Adaptive Card.
+ * Supports both standard format (type: 'AdaptiveCard') and alternative format (cardType: 'AdaptiveCard').
  */
 export function isAdaptiveCard(obj: unknown): obj is Record<string, unknown> {
-    return (
-        typeof obj === 'object' &&
-        obj !== null &&
-        (obj as Record<string, unknown>).type === 'AdaptiveCard'
-    );
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    
+    const card = obj as Record<string, unknown>;
+    
+    // Standard Adaptive Card format
+    if (card.type === 'AdaptiveCard') {
+        return true;
+    }
+    
+    // Alternative format with cardType/cardBody
+    if (card.cardType === 'AdaptiveCard') {
+        return true;
+    }
+    
+    // Check if it's an array containing Adaptive Cards
+    if (Array.isArray(obj) && obj.length > 0) {
+        return obj.some(item => isAdaptiveCard(item));
+    }
+    
+    return false;
+}
+
+/**
+ * Normalizes a card payload to the standard Adaptive Card format.
+ * Handles:
+ * - Arrays of cards (returns the first card)
+ * - Alternative format with cardType/cardBody properties
+ * - Standard format (passed through unchanged)
+ */
+export function normalizeAdaptiveCard(obj: unknown): Record<string, unknown> | null {
+    if (typeof obj !== 'object' || obj === null) {
+        return null;
+    }
+    
+    // Handle arrays - extract the first valid card
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            const normalized = normalizeAdaptiveCard(item);
+            if (normalized) {
+                return normalized;
+            }
+        }
+        return null;
+    }
+    
+    const card = obj as Record<string, unknown>;
+    
+    // Standard format - return as-is
+    if (card.type === 'AdaptiveCard') {
+        return card;
+    }
+    
+    // Alternative format - convert to standard format
+    if (card.cardType === 'AdaptiveCard') {
+        return {
+            type: 'AdaptiveCard',
+            $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+            version: (card.version as string) || '1.5',
+            body: card.cardBody || card.body || [],
+            actions: card.actions || []
+        };
+    }
+    
+    return null;
 }
 
 export default AdaptiveCardRenderer;

package/misc/apps/RAG/src/components/index.ts

@@ -1,19 +1,28 @@
 // Chat components exports
-export { ChatContainer } from './ChatContainer';
-export { ChatMessage } from './ChatMessage';
-export { ChatInput } from './ChatInput';
-export { ApiKeySettings } from './ApiKeySettings';
+export { ChatContainer } from "./ChatContainer";
+export { ChatMessage } from "./ChatMessage";
+export { ChatInput } from "./ChatInput";
+export { ApiKeySettings } from "./ApiKeySettings";
 
 // FlowQuery Runner
-export { FlowQueryRunner } from './FlowQueryRunner';
+export { FlowQueryRunner } from "./FlowQueryRunner";
 
 // Adaptive Card Renderer
-export { AdaptiveCardRenderer, isAdaptiveCard } from './AdaptiveCardRenderer';
+export {
+    AdaptiveCardRenderer,
+    isAdaptiveCard,
+    normalizeAdaptiveCard,
+} from "./AdaptiveCardRenderer";
 
 // FlowQuery Agent
-export { processQuery, processQueryStream } from './FlowQueryAgent';
-export type { AgentStep, AgentResult, FlowQueryAgentOptions, AgentStreamCallback } from './FlowQueryAgent';
+export { processQuery, processQueryStream } from "./FlowQueryAgent";
+export type {
+    AgentStep,
+    AgentResult,
+    FlowQueryAgentOptions,
+    AgentStreamCallback,
+} from "./FlowQueryAgent";
 
 // Types
-export type { Message } from './ChatMessage';
-export type { AdaptiveCardRendererProps } from './AdaptiveCardRenderer';
+export type { Message } from "./ChatMessage";
+export type { AdaptiveCardRendererProps } from "./AdaptiveCardRenderer";

package/misc/apps/RAG/src/plugins/loaders/MockData.ts

@@ -1,171 +1,101 @@
-/**
- * Example plugin: Generate mock data for testing.
- *
- * Usage in FlowQuery:
- *   CALL mockUsers(10) YIELD name, email
- */
 import { AsyncFunction, FunctionDef } from "flowquery/extensibility";
 
-/**
- * MockUsers class - generates mock user data for testing.
- */
+const usersData = [
+    { id: 1, name: "Alice Johnson", email: "alice@example.com", age: 28 },
+    { id: 2, name: "Bob Smith", email: "bob@example.com", age: 34 },
+    { id: 3, name: "Charlie Brown", email: "charlie@example.com", age: 22 },
+    { id: 4, name: "Diana Ross", email: "diana@example.com", age: 45 },
+    { id: 5, name: "Eve Wilson", email: "eve@example.com", age: 31 },
+];
+
+const productsData = [
+    { id: 101, name: "Laptop", price: 999.99, category: "Electronics", stock: 50 },
+    { id: 102, name: "Headphones", price: 149.99, category: "Electronics", stock: 200 },
+    { id: 103, name: "Coffee Mug", price: 12.99, category: "Kitchen", stock: 500 },
+    { id: 104, name: "Notebook", price: 8.99, category: "Office", stock: 300 },
+    { id: 105, name: "Backpack", price: 59.99, category: "Accessories", stock: 75 },
+];
+
+const ordersData = [
+    { id: 1001, userId: 1, productId: 101, quantity: 1, total: 999.99, date: "2025-12-01" },
+    { id: 1002, userId: 2, productId: 102, quantity: 2, total: 299.98, date: "2025-12-05" },
+    { id: 1003, userId: 1, productId: 103, quantity: 4, total: 51.96, date: "2025-12-10" },
+    { id: 1004, userId: 3, productId: 104, quantity: 10, total: 89.9, date: "2025-12-15" },
+    { id: 1005, userId: 4, productId: 105, quantity: 1, total: 59.99, date: "2025-12-20" },
+    { id: 1006, userId: 5, productId: 101, quantity: 1, total: 999.99, date: "2025-12-25" },
+];
+
 @FunctionDef({
-    description: "Generates mock user data for testing purposes",
+    description: "Returns mock user data",
     category: "async",
-    parameters: [
-        {
-            name: "count",
-            description: "Number of mock users to generate",
-            type: "number",
-            required: false,
-            default: 5,
-        },
-    ],
+    parameters: [],
     output: {
-        description: "Mock user object",
+        description: "User object",
         type: "object",
         properties: {
             id: { description: "User ID", type: "number" },
-            name: { description: "Full name", type: "string" },
-            email: { description: "Email address", type: "string" },
-            age: { description: "Age in years", type: "number" },
-            active: { description: "Whether user is active", type: "boolean" },
+            name: { description: "User name", type: "string" },
+            email: { description: "User email", type: "string" },
+            age: { description: "User age", type: "number" },
         },
     },
-    examples: [
-        "CALL mockUsers(10) YIELD name, email",
-        "CALL mockUsers(20) YIELD name, email, active WHERE active = true",
-    ],
+    examples: ["CALL users() YIELD id, name, email, age"],
 })
-export class MockUsers extends AsyncFunction {
-    private readonly firstNames: string[];
-    private readonly lastNames: string[];
-    private readonly domains: string[];
-
-    constructor(
-        firstNames: string[] = [
-            "Alice",
-            "Bob",
-            "Charlie",
-            "Diana",
-            "Eve",
-            "Frank",
-            "Grace",
-            "Henry",
-            "Ivy",
-            "Jack",
-        ],
-        lastNames: string[] = [
-            "Smith",
-            "Johnson",
-            "Williams",
-            "Brown",
-            "Jones",
-            "Garcia",
-            "Miller",
-            "Davis",
-            "Rodriguez",
-            "Martinez",
-        ],
-        domains: string[] = ["example.com", "test.org", "demo.net"]
-    ) {
-        super();
-        this.firstNames = firstNames;
-        this.lastNames = lastNames;
-        this.domains = domains;
-    }
-
-    /**
-     * Generates mock user data.
-     *
-     * @param count - Number of mock users to generate
-     */
-    async *generate(count: number = 5): AsyncGenerator<any, void, unknown> {
-        for (let i = 0; i < count; i++) {
-            const firstName = this.firstNames[Math.floor(Math.random() * this.firstNames.length)];
-            const lastName = this.lastNames[Math.floor(Math.random() * this.lastNames.length)];
-            const domain = this.domains[Math.floor(Math.random() * this.domains.length)];
-
-            yield {
-                id: i + 1,
-                name: `${firstName} ${lastName}`,
-                email: `${firstName.toLowerCase()}.${lastName.toLowerCase()}@${domain}`,
-                age: Math.floor(Math.random() * 50) + 18,
-                active: Math.random() > 0.3,
-            };
+export class Users extends AsyncFunction {
+    async *generate(): AsyncGenerator<any, void, unknown> {
+        for (const user of usersData) {
+            yield user;
         }
     }
 }
 
-/**
- * MockProducts class - generates mock product data for testing.
- */
 @FunctionDef({
-    description: "Generates mock product data for testing purposes",
+    description: "Returns mock product data",
     category: "async",
-    parameters: [
-        {
-            name: "count",
-            description: "Number of mock products to generate",
-            type: "number",
-            required: false,
-            default: 5,
-        },
-    ],
+    parameters: [],
     output: {
-        description: "Mock product object",
+        description: "Product object",
         type: "object",
         properties: {
             id: { description: "Product ID", type: "number" },
             name: { description: "Product name", type: "string" },
+            price: { description: "Product price", type: "number" },
             category: { description: "Product category", type: "string" },
-            price: { description: "Price in dollars", type: "number" },
-            inStock: { description: "Whether product is in stock", type: "boolean" },
-            rating: { description: "Customer rating (0-5)", type: "number" },
+            stock: { description: "Stock quantity", type: "number" },
         },
     },
-    examples: [
-        "CALL mockProducts(10) YIELD name, price",
-        "CALL mockProducts(50) YIELD name, price, category WHERE category = 'Electronics'",
-    ],
+    examples: ["CALL products() YIELD id, name, price, category, stock"],
 })
-export class MockProducts extends AsyncFunction {
-    private readonly categories: string[];
-    private readonly adjectives: string[];
-    private readonly nouns: string[];
-
-    constructor(
-        categories: string[] = ["Electronics", "Clothing", "Books", "Home", "Sports"],
-        adjectives: string[] = ["Premium", "Basic", "Pro", "Ultra", "Classic"],
-        nouns: string[] = ["Widget", "Gadget", "Item", "Product", "Thing"]
-    ) {
-        super();
-        this.categories = categories;
-        this.adjectives = adjectives;
-        this.nouns = nouns;
+export class Products extends AsyncFunction {
+    async *generate(): AsyncGenerator<any, void, unknown> {
+        for (const product of productsData) {
+            yield product;
+        }
     }
+}
 
-    /**
-     * Generates mock product data.
-     *
-     * @param count - Number of mock products to generate
-     */
-    async *generate(count: number = 5): AsyncGenerator<any, void, unknown> {
-        for (let i = 0; i < count; i++) {
-            const adj = this.adjectives[Math.floor(Math.random() * this.adjectives.length)];
-            const noun = this.nouns[Math.floor(Math.random() * this.nouns.length)];
-            const category = this.categories[Math.floor(Math.random() * this.categories.length)];
-
-            yield {
-                id: i + 1,
-                name: `${adj} ${noun} ${i + 1}`,
-                category,
-                price: Math.round(Math.random() * 1000 * 100) / 100,
-                inStock: Math.random() > 0.2,
-                rating: Math.round(Math.random() * 50) / 10,
-            };
+@FunctionDef({
+    description: "Returns mock order data",
+    category: "async",
+    parameters: [],
+    output: {
+        description: "Order object",
+        type: "object",
+        properties: {
+            id: { description: "Order ID", type: "number" },
+            userId: { description: "User ID who placed the order", type: "number" },
+            productId: { description: "Product ID ordered", type: "number" },
+            quantity: { description: "Quantity ordered", type: "number" },
+            total: { description: "Order total", type: "number" },
+            date: { description: "Order date", type: "string" },
+        },
+    },
+    examples: ["CALL orders() YIELD id, userId, productId, quantity, total, date"],
+})
+export class Orders extends AsyncFunction {
+    async *generate(): AsyncGenerator<any, void, unknown> {
+        for (const order of ordersData) {
+            yield order;
         }
     }
 }
-
-export { MockUsers as default };

package/misc/apps/RAG/src/prompts/FlowQuerySystemPrompt.ts

@@ -69,6 +69,18 @@ FlowQuery is a declarative query language for data processing pipelines. It uses
    UNWIND myArray AS item
    UNWIND range(0, 10) AS index
    \`\`\`
+   
+   **IMPORTANT**: An UNWIND statement cannot be followed directly by a WHERE statement. If you need to filter after unwinding, use a WITH clause in between:
+   \`\`\`
+   // WRONG - UNWIND cannot be directly followed by WHERE:
+   // UNWIND items AS item
+   // WHERE item.active = true
+   
+   // CORRECT - use WITH between UNWIND and WHERE:
+   UNWIND items AS item
+   WITH item
+   WHERE item.active = true
+   \`\`\`
 
 6. **WHERE** - Filter results
    \`\`\`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowquery",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "A declarative query language for data processing pipelines.",
   "main": "dist/index.node.js",
   "types": "dist/index.node.d.ts",

package/src/compute/runner.ts

@@ -1,14 +1,15 @@
+import ASTNode from "../parsing/ast_node";
+import Function from "../parsing/functions/function";
+import { FunctionMetadata } from "../parsing/functions/function_metadata";
 import Operation from "../parsing/operations/operation";
 import Parser from "../parsing/parser";
-import { FunctionMetadata } from "../parsing/functions/function_metadata";
-import Function from "../parsing/functions/function";
 
 /**
  * Executes a FlowQuery statement and retrieves the results.
- * 
+ *
  * The Runner class parses a FlowQuery statement into an AST and executes it,
  * managing the execution flow from the first operation to the final return statement.
- * 
+ *
  * @example
  * ```typescript
  * const runner = new Runner("WITH 1 as x RETURN x");
@@ -24,7 +25,11 @@ class Runner {
      * List all registered functions with their metadata.
      * Added dynamically in index.browser.ts / index.node.ts
      */
-    static listFunctions: (options?: { category?: string; asyncOnly?: boolean; syncOnly?: boolean }) => FunctionMetadata[];
+    static listFunctions: (options?: {
+        category?: string;
+        asyncOnly?: boolean;
+        syncOnly?: boolean;
+    }) => FunctionMetadata[];
 
     /**
      * Get metadata for a specific function.
@@ -37,32 +42,32 @@ class Runner {
      * Added dynamically in index.browser.ts / index.node.ts
      */
     static Function: typeof Function;
-    
+
     /**
      * Creates a new Runner instance and parses the FlowQuery statement.
-     * 
+     *
      * @param statement - The FlowQuery statement to execute
      * @throws {Error} If the statement is null, empty, or contains syntax errors
      */
-    constructor(statement: string | null = null) {
-        if(statement === null || statement === "") {
-            throw new Error("Statement cannot be null or empty");
+    constructor(statement: string | null = null, ast: ASTNode | null = null) {
+        if ((statement === null || statement === "") && ast === null) {
+            throw new Error("Either statement or AST must be provided");
         }
-        const parser = new Parser();
-        const ast = parser.parse(statement);
-        this.first = ast.firstChild() as Operation;
-        this.last = ast.lastChild() as Operation;
+        const _ast = ast !== null ? ast : new Parser().parse(statement!);
+        this.first = _ast.firstChild() as Operation;
+        this.last = _ast.lastChild() as Operation;
     }
-    
+
     /**
      * Executes the parsed FlowQuery statement.
-     * 
+     *
      * @returns A promise that resolves when execution completes
      * @throws {Error} If an error occurs during execution
      */
     public async run(): Promise<void> {
         return new Promise<void>(async (resolve, reject) => {
             try {
+                await this.first.initialize();
                 await this.first.run();
                 await this.first.finish();
                 resolve();
@@ -71,10 +76,10 @@ class Runner {
             }
         });
     }
-    
+
     /**
      * Gets the results from the executed statement.
-     * 
+     *
      * @returns The results from the last operation (typically a RETURN statement)
      */
     public get results(): any {
@@ -82,4 +87,4 @@ class Runner {
     }
 }
 
-export default Runner;
+export default Runner;

package/src/graph/data.ts

@@ -0,0 +1,112 @@
+class IndexEntry {
+    private _positions: number[];
+    private _index: number = -1;
+
+    constructor(positions: number[] = []) {
+        this._positions = positions;
+    }
+    public add(position: number): void {
+        this._positions.push(position);
+    }
+    public get position(): number {
+        return this._positions[this._index];
+    }
+    public reset(): void {
+        this._index = -1;
+    }
+    public next(): boolean {
+        if (this._index < this._positions.length - 1) {
+            this._index++;
+            return true;
+        }
+        return false;
+    }
+    public clone(): IndexEntry {
+        return new IndexEntry([...this._positions]);
+    }
+}
+
+class Layer {
+    private _index: Map<string, IndexEntry> = new Map();
+    private _current: number = -1;
+    constructor(index: Map<string, IndexEntry>) {
+        this._index = index;
+    }
+    public get index(): Map<string, IndexEntry> {
+        return this._index;
+    }
+    public get current(): number {
+        return this._current;
+    }
+    public set current(value: number) {
+        this._current = value;
+    }
+}
+
+class Data {
+    protected _records: Record<string, any>[] = [];
+    private _layers: Map<number, Layer> = new Map();
+
+    constructor(records: Record<string, any>[] = []) {
+        this._records = records;
+        this._layers.set(0, new Layer(new Map()));
+    }
+    protected _buildIndex(key: string, level: number = 0): void {
+        this.layer(level).index.clear();
+        this._records.forEach((record, idx) => {
+            if (record.hasOwnProperty(key)) {
+                if (!this.layer(level).index.has(record[key])) {
+                    this.layer(level).index.set(record[key], new IndexEntry());
+                }
+                this.layer(level).index.get(record[key])!.add(idx);
+            }
+        });
+    }
+    public layer(level: number = 0): Layer {
+        if (!this._layers.has(level)) {
+            const first = this._layers.get(0)!;
+            const cloned = new Map<string, IndexEntry>();
+            for (const [key, entry] of first.index) {
+                cloned.set(key, entry.clone());
+            }
+            this._layers.set(level, new Layer(cloned));
+        }
+        return this._layers.get(level)!;
+    }
+    protected _find(key: string, level: number = 0): boolean {
+        if (!this.layer(level).index.has(key)) {
+            this.layer(level).current = this._records.length; // Move to end
+            return false;
+        } else {
+            const entry = this.layer(level).index.get(key)!;
+            const more = entry.next();
+            if (!more) {
+                this.layer(level).current = this._records.length; // Move to end
+                return false;
+            }
+            this.layer(level).current = entry.position;
+            return true;
+        }
+    }
+    public reset(): void {
+        this.layer(0).current = -1;
+        for (const entry of this.layer(0).index.values()) {
+            entry.reset();
+        }
+    }
+    public next(level: number = 0): boolean {
+        if (this.layer(level).current < this._records.length - 1) {
+            this.layer(level).current++;
+            return true;
+        }
+        return false;
+    }
+    public current(level: number = 0): Record<string, any> | null {
+        if (this.layer(level).current < this._records.length) {
+            return this._records[this.layer(level).current];
+        }
+        return null;
+    }
+}
+
+export default Data;