flowquery 1.0.8 → 1.0.10

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

@@ -0,0 +1,271 @@
+/**
+ * Table loader plugin - transforms tabular data into Adaptive Card format.
+ * 
+ * Adaptive Cards are platform-agnostic UI snippets that can be rendered in
+ * Microsoft Teams, Outlook, Windows, and other applications.
+ * 
+ * Usage in FlowQuery:
+ *   // First collect data from an async provider, then pass to table:
+ *   LOAD JSON FROM mockUsers(5) AS u
+ *   WITH collect(u) AS users
+ *   LOAD JSON FROM table(users, 'Users') AS card
+ *   RETURN card
+ * 
+ * Note: Async providers cannot be nested as function arguments.
+ */
+
+import { FunctionDef } from 'flowquery/extensibility';
+
+/**
+ * Interface for Adaptive Card structure
+ */
+interface AdaptiveCard {
+    type: 'AdaptiveCard';
+    $schema: string;
+    version: string;
+    body: AdaptiveCardElement[];
+}
+
+interface AdaptiveCardElement {
+    type: string;
+    [key: string]: any;
+}
+
+interface TableCell {
+    type: 'TableCell';
+    items: AdaptiveCardElement[];
+}
+
+interface TableRow {
+    type: 'TableRow';
+    cells: TableCell[];
+}
+
+/**
+ * Table loader - transforms tabular data into an Adaptive Card table format.
+ */
+@FunctionDef({
+    description: 'Transforms tabular data into an Adaptive Card JSON format with a table layout',
+    category: 'async',
+    parameters: [
+        {
+            name: 'data',
+            description: 'Array of objects or async generator to display as a table',
+            type: 'array',
+            required: true
+        },
+        {
+            name: 'title',
+            description: 'Optional title for the card',
+            type: 'string',
+            required: false,
+            default: 'Data Table'
+        },
+        {
+            name: 'columns',
+            description: 'Optional array of column names to include (defaults to all columns from first row)',
+            type: 'array',
+            required: false
+        },
+        {
+            name: 'maxRows',
+            description: 'Maximum number of rows to display',
+            type: 'number',
+            required: false,
+            default: 100
+        }
+    ],
+    output: {
+        description: 'Adaptive Card JSON object',
+        type: 'object',
+        properties: {
+            type: { description: 'Always "AdaptiveCard"', type: 'string' },
+            $schema: { description: 'Adaptive Card schema URL', type: 'string' },
+            version: { description: 'Adaptive Card version', type: 'string' },
+            body: { description: 'Card body elements including table', type: 'array' }
+        }
+    },
+    examples: [
+        "LOAD JSON FROM mockUsers(5) AS u WITH collect(u) AS users LOAD JSON FROM table(users, 'User List') AS card RETURN card",
+        "LOAD JSON FROM mockProducts(10) AS p WITH collect(p) AS products LOAD JSON FROM table(products, 'Products', ['name', 'price', 'category']) AS card RETURN card"
+    ]
+})
+export class TableLoader {
+    /**
+     * Transforms data into an Adaptive Card with table layout.
+     * 
+     * @param data - Array or async iterable of objects
+     * @param title - Card title
+     * @param columns - Optional column names to include
+     * @param maxRows - Maximum rows to include
+     */
+    async *fetch(
+        data: any[] | AsyncIterable<any>,
+        title: string = 'Data Table',
+        columns?: string[],
+        maxRows: number = 100
+    ): AsyncGenerator<AdaptiveCard, void, unknown> {
+        // Collect data from array or async iterable
+        const rows: any[] = [];
+        
+        if (Symbol.asyncIterator in Object(data)) {
+            for await (const item of data as AsyncIterable<any>) {
+                rows.push(item);
+                if (rows.length >= maxRows) break;
+            }
+        } else if (Array.isArray(data)) {
+            rows.push(...data.slice(0, maxRows));
+        } else {
+            // Single object
+            rows.push(data);
+        }
+
+        if (rows.length === 0) {
+            yield this.createEmptyCard(title);
+            return;
+        }
+
+        // Determine columns from first row if not specified
+        const columnNames = columns || Object.keys(rows[0]);
+
+        yield this.createTableCard(title, columnNames, rows);
+    }
+
+    /**
+     * Creates an Adaptive Card with a table displaying the data.
+     * Uses ColumnSet/Column for better compatibility across renderers.
+     */
+    private createTableCard(title: string, columnNames: string[], rows: any[]): AdaptiveCard {
+        const card: AdaptiveCard = {
+            type: 'AdaptiveCard',
+            $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+            version: '1.3',
+            body: []
+        };
+
+        // Add title
+        card.body.push({
+            type: 'TextBlock',
+            text: title,
+            weight: 'Bolder',
+            size: 'Large',
+            wrap: true
+        });
+
+        // Add separator
+        card.body.push({
+            type: 'TextBlock',
+            text: ' ',
+            separator: true
+        });
+
+        // Create header row using ColumnSet
+        const headerColumnSet: AdaptiveCardElement = {
+            type: 'ColumnSet',
+            columns: columnNames.map(col => ({
+                type: 'Column',
+                width: 'stretch',
+                items: [{
+                    type: 'TextBlock',
+                    text: this.formatColumnName(col),
+                    weight: 'Bolder',
+                    wrap: true
+                }]
+            })),
+            style: 'accent'
+        };
+        card.body.push(headerColumnSet);
+
+        // Add data rows using ColumnSets
+        for (const row of rows) {
+            const dataColumnSet: AdaptiveCardElement = {
+                type: 'ColumnSet',
+                columns: columnNames.map(col => ({
+                    type: 'Column',
+                    width: 'stretch',
+                    items: [{
+                        type: 'TextBlock',
+                        text: this.formatCellValue(row[col]),
+                        wrap: true
+                    }]
+                })),
+                separator: true
+            };
+            card.body.push(dataColumnSet);
+        }
+
+        // Add row count footer
+        card.body.push({
+            type: 'TextBlock',
+            text: `Showing ${rows.length} row${rows.length !== 1 ? 's' : ''}`,
+            size: 'Small',
+            isSubtle: true,
+            horizontalAlignment: 'Right',
+            separator: true
+        });
+
+        return card;
+    }
+
+    /**
+     * Creates an empty card when no data is available.
+     */
+    private createEmptyCard(title: string): AdaptiveCard {
+        return {
+            type: 'AdaptiveCard',
+            $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+            version: '1.3',
+            body: [
+                {
+                    type: 'TextBlock',
+                    text: title,
+                    weight: 'Bolder',
+                    size: 'Large',
+                    wrap: true
+                },
+                {
+                    type: 'TextBlock',
+                    text: 'No data available',
+                    isSubtle: true,
+                    wrap: true
+                }
+            ]
+        };
+    }
+
+    /**
+     * Formats a column name for display (converts camelCase/snake_case to Title Case).
+     */
+    private formatColumnName(name: string): string {
+        return name
+            .replace(/([A-Z])/g, ' $1')  // camelCase
+            .replace(/_/g, ' ')           // snake_case
+            .replace(/^\w/, c => c.toUpperCase())
+            .trim();
+    }
+
+    /**
+     * Formats a cell value for display in the table.
+     */
+    private formatCellValue(value: any): string {
+        if (value === null || value === undefined) {
+            return '-';
+        }
+        if (typeof value === 'boolean') {
+            return value ? '✓' : '✗';
+        }
+        if (typeof value === 'number') {
+            // Format numbers nicely
+            if (Number.isInteger(value)) {
+                return value.toString();
+            }
+            return value.toFixed(2);
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    }
+}
+
+export { TableLoader as default };

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

@@ -33,6 +33,18 @@ FlowQuery is a declarative query language for data processing pipelines. It uses
    LOAD JSON FROM 'https://api.example.com/data' AS item
    LOAD JSON FROM myFunction(arg1, arg2) AS item
    \`\`\`
+   
+   **IMPORTANT**: Async data providers (functions used after LOAD JSON FROM) cannot be nested inside other function calls. If you need to pass data from one async provider to another, first load the data into a variable using collect(), then pass that variable:
+   \`\`\`
+   // WRONG - async providers cannot be nested:
+   // LOAD JSON FROM table(mockProducts(5), 'Products') AS card
+   
+   // CORRECT - collect data first, then pass to next provider:
+   LOAD JSON FROM mockProducts(5) AS p
+   WITH collect(p) AS products
+   LOAD JSON FROM table(products, 'Products') AS card
+   RETURN card
+   \`\`\`
 
 3. **LOAD JSON FROM ... HEADERS ... POST** - Make HTTP requests with headers and body
    \`\`\`

package/package.json

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

package/src/parsing/functions/function_factory.ts

@@ -9,12 +9,14 @@ import "./rand";
 import "./round";
 import "./split";
 import "./join";
+import "./keys";
 import "./to_json";
 import "./replace";
 import "./stringify";
 import "./size";
 import "./functions";
 import "./predicate_sum";
+import "./type";
 import { 
     FunctionMetadata, 
     getRegisteredFunctionMetadata,

package/src/parsing/functions/keys.ts

@@ -0,0 +1,31 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Returns the keys of an object (associative array) as an array",
+    category: "scalar",
+    parameters: [
+        { name: "object", description: "Object to extract keys from", type: "object" }
+    ],
+    output: { description: "Array of keys", type: "array", example: "['name', 'age']" },
+    examples: ["WITH { name: 'Alice', age: 30 } AS obj RETURN keys(obj)"]
+})
+class Keys extends Function {
+    constructor() {
+        super("keys");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const obj = this.getChildren()[0].value();
+        if (obj === null || obj === undefined) {
+            return [];
+        }
+        if (typeof obj !== "object" || Array.isArray(obj)) {
+            throw new Error("keys() expects an object, not an array or primitive");
+        }
+        return Object.keys(obj);
+    }
+}
+
+export default Keys;

package/src/parsing/functions/type.ts

@@ -0,0 +1,39 @@
+import Function from "./function";
+import { FunctionDef } from "./function_metadata";
+
+@FunctionDef({
+    description: "Returns the type of a value as a string",
+    category: "scalar",
+    parameters: [
+        { name: "value", description: "Value to check the type of", type: "any" }
+    ],
+    output: { description: "Type of the input value", type: "string", example: "string" },
+    examples: [
+        "WITH 'hello' AS val RETURN type(val)",
+        "WITH 42 AS val RETURN type(val)",
+        "WITH [1, 2, 3] AS val RETURN type(val)"
+    ]
+})
+class Type extends Function {
+    constructor() {
+        super("type");
+        this._expectedParameterCount = 1;
+    }
+
+    public value(): any {
+        const val = this.getChildren()[0].value();
+        
+        if (val === null) {
+            return "null";
+        }
+        if (val === undefined) {
+            return "undefined";
+        }
+        if (Array.isArray(val)) {
+            return "array";
+        }
+        return typeof val;
+    }
+}
+
+export default Type;

package/tests/compute/runner.test.ts

@@ -495,4 +495,12 @@ test('Test range with size', async () => {
     const results = runner.results;
     expect(results.length).toBe(1);
     expect(results[0]).toEqual({'indices': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]});
+});
+
+test('Test keys function', async () => {
+    const runner = new Runner('RETURN keys({name: "Alice", age: 30}) as keys');
+    await runner.run();
+    const results = runner.results;
+    expect(results.length).toBe(1);
+    expect(results[0]).toEqual({'keys': ['name', 'age']});
 });