flowquery 1.0.15 → 1.0.17

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

@@ -1,26 +1,24 @@
 /**
  * Table 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
- * 
+ *   CALL mockUsers(5) YIELD id, name, email
+ *   WITH collect({ id, name, email }) AS users
+ *   CALL table(users, 'Users') YIELD type, body
+ *
  * Note: Async providers cannot be nested as function arguments.
  */
-
-import { FunctionDef, AsyncFunction } from 'flowquery/extensibility';
+import { AsyncFunction, FunctionDef } from "flowquery/extensibility";
 
 /**
  * Interface for Adaptive Card structure
  */
 interface AdaptiveCard {
-    type: 'AdaptiveCard';
+    type: "AdaptiveCard";
     $schema: string;
     version: string;
     body: AdaptiveCardElement[];
@@ -32,12 +30,12 @@ interface AdaptiveCardElement {
 }
 
 interface TableCell {
-    type: 'TableCell';
+    type: "TableCell";
     items: AdaptiveCardElement[];
 }
 
 interface TableRow {
-    type: 'TableRow';
+    type: "TableRow";
     cells: TableCell[];
 }
 
@@ -45,55 +43,56 @@ interface TableRow {
  * Table class - 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',
+    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: "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',
+            name: "title",
+            description: "Optional title for the card",
+            type: "string",
             required: false,
-            default: 'Data Table'
+            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: "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',
+            name: "maxRows",
+            description: "Maximum number of rows to display",
+            type: "number",
             required: false,
-            default: 100
-        }
+            default: 100,
+        },
     ],
     output: {
-        description: 'Adaptive Card JSON object',
-        type: 'object',
+        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' }
-        }
+            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"
-    ]
+        "CALL mockUsers(5) YIELD id, name, email WITH collect({ id, name, email }) AS users CALL table(users, 'User List') YIELD type, body",
+        "CALL mockProducts(10) YIELD name, price, category WITH collect({ name, price, category }) AS products CALL table(products, 'Products', ['name', 'price', 'category']) YIELD type, body",
+    ],
 })
 export class Table extends AsyncFunction {
     /**
      * 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
@@ -101,13 +100,13 @@ export class Table extends AsyncFunction {
      */
     async *generate(
         data: any[] | AsyncIterable<any>,
-        title: string = 'Data Table',
+        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);
@@ -137,71 +136,75 @@ export class Table extends AsyncFunction {
      */
     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: []
+            type: "AdaptiveCard",
+            $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+            version: "1.3",
+            body: [],
         };
 
         // Add title
         card.body.push({
-            type: 'TextBlock',
+            type: "TextBlock",
             text: title,
-            weight: 'Bolder',
-            size: 'Large',
-            wrap: true
+            weight: "Bolder",
+            size: "Large",
+            wrap: true,
         });
 
         // Add separator
         card.body.push({
-            type: 'TextBlock',
-            text: ' ',
-            separator: true
+            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
-                }]
+            type: "ColumnSet",
+            columns: columnNames.map((col) => ({
+                type: "Column",
+                width: "stretch",
+                items: [
+                    {
+                        type: "TextBlock",
+                        text: this.formatColumnName(col),
+                        weight: "Bolder",
+                        wrap: true,
+                    },
+                ],
             })),
-            style: 'accent'
+            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
-                    }]
+                type: "ColumnSet",
+                columns: columnNames.map((col) => ({
+                    type: "Column",
+                    width: "stretch",
+                    items: [
+                        {
+                            type: "TextBlock",
+                            text: this.formatCellValue(row[col]),
+                            wrap: true,
+                        },
+                    ],
                 })),
-                separator: 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',
+            type: "TextBlock",
+            text: `Showing ${rows.length} row${rows.length !== 1 ? "s" : ""}`,
+            size: "Small",
             isSubtle: true,
-            horizontalAlignment: 'Right',
-            separator: true
+            horizontalAlignment: "Right",
+            separator: true,
         });
 
         return card;
@@ -212,24 +215,24 @@ export class Table extends AsyncFunction {
      */
     private createEmptyCard(title: string): AdaptiveCard {
         return {
-            type: 'AdaptiveCard',
-            $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
-            version: '1.3',
+            type: "AdaptiveCard",
+            $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+            version: "1.3",
             body: [
                 {
-                    type: 'TextBlock',
+                    type: "TextBlock",
                     text: title,
-                    weight: 'Bolder',
-                    size: 'Large',
-                    wrap: true
+                    weight: "Bolder",
+                    size: "Large",
+                    wrap: true,
                 },
                 {
-                    type: 'TextBlock',
-                    text: 'No data available',
+                    type: "TextBlock",
+                    text: "No data available",
                     isSubtle: true,
-                    wrap: true
-                }
-            ]
+                    wrap: true,
+                },
+            ],
         };
     }
 
@@ -238,9 +241,9 @@ export class Table extends AsyncFunction {
      */
     private formatColumnName(name: string): string {
         return name
-            .replace(/([A-Z])/g, ' $1')  // camelCase
-            .replace(/_/g, ' ')           // snake_case
-            .replace(/^\w/, c => c.toUpperCase())
+            .replace(/([A-Z])/g, " $1") // camelCase
+            .replace(/_/g, " ") // snake_case
+            .replace(/^\w/, (c) => c.toUpperCase())
             .trim();
     }
 
@@ -249,19 +252,19 @@ export class Table extends AsyncFunction {
      */
     private formatCellValue(value: any): string {
         if (value === null || value === undefined) {
-            return '-';
+            return "-";
         }
-        if (typeof value === 'boolean') {
-            return value ? '✓' : '✗';
+        if (typeof value === "boolean") {
+            return value ? "✓" : "✗";
         }
-        if (typeof value === 'number') {
+        if (typeof value === "number") {
             // Format numbers nicely
             if (Number.isInteger(value)) {
                 return value.toString();
             }
             return value.toFixed(2);
         }
-        if (typeof value === 'object') {
+        if (typeof value === "object") {
             return JSON.stringify(value);
         }
         return String(value);

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

@@ -1,52 +1,60 @@
 /**
  * Example plugin: Fetch weather forecast for a location.
- * 
+ *
  * Usage in FlowQuery:
- *   LOAD JSON FROM weather('Oslo') AS forecast
- *   RETURN forecast
+ *   CALL weather('Oslo') YIELD date, location, temperature, humidity
  */
+import { AsyncFunction, FunctionDef } from "flowquery/extensibility";
 
-import { FunctionDef, AsyncFunction } from 'flowquery/extensibility';
-
-const GEOCODING_API = 'https://geocoding-api.open-meteo.com/v1/search';
-const WEATHER_API = 'https://api.met.no/weatherapi/locationforecast/2.0/compact';
+const GEOCODING_API = "https://geocoding-api.open-meteo.com/v1/search";
+const WEATHER_API = "https://api.met.no/weatherapi/locationforecast/2.0/compact";
 
 /**
  * Weather class - fetches weather forecast for a given location.
  */
 @FunctionDef({
-    description: 'Fetches weather forecast for a location using Open-Meteo geocoding and MET Norway weather API',
-    category: 'async',
+    description:
+        "Fetches weather forecast for a location using Open-Meteo geocoding and MET Norway weather API",
+    category: "async",
     parameters: [
         {
-            name: 'location',
+            name: "location",
             description: 'The name of the location to get weather for (e.g., "Oslo", "New York")',
-            type: 'string',
-            required: true
-        }
+            type: "string",
+            required: true,
+        },
     ],
     output: {
-        description: 'Weather forecast data point with location and weather parameters',
-        type: 'object',
+        description: "Weather forecast data point with location and weather parameters",
+        type: "object",
         properties: {
-            date: { description: 'ISO 8601 timestamp in UTC', type: 'string' },
-            location: { description: 'Name of the location', type: 'string' },
-            lat: { description: 'Latitude in decimal degrees', type: 'number' },
-            lon: { description: 'Longitude in decimal degrees', type: 'number' },
-            temperature: { description: 'Air temperature in celsius', type: 'number' },
-            humidity: { description: 'Relative humidity in %', type: 'number' },
-            pressure: { description: 'Air pressure at sea level in hPa', type: 'number' },
-            cloud_cover: { description: 'Total cloud cover in %', type: 'number' },
-            wind_speed: { description: 'Wind speed in m/s', type: 'number' },
-            wind_direction: { description: 'Wind direction in degrees (0=N, 90=E, 180=S, 270=W)', type: 'number' },
-            precipitation: { description: 'Expected precipitation in mm (next hour if available)', type: 'number' },
-            symbol: { description: 'Weather symbol code (e.g., "partlycloudy_day", "rain")', type: 'string' }
-        }
+            date: { description: "ISO 8601 timestamp in UTC", type: "string" },
+            location: { description: "Name of the location", type: "string" },
+            lat: { description: "Latitude in decimal degrees", type: "number" },
+            lon: { description: "Longitude in decimal degrees", type: "number" },
+            temperature: { description: "Air temperature in celsius", type: "number" },
+            humidity: { description: "Relative humidity in %", type: "number" },
+            pressure: { description: "Air pressure at sea level in hPa", type: "number" },
+            cloud_cover: { description: "Total cloud cover in %", type: "number" },
+            wind_speed: { description: "Wind speed in m/s", type: "number" },
+            wind_direction: {
+                description: "Wind direction in degrees (0=N, 90=E, 180=S, 270=W)",
+                type: "number",
+            },
+            precipitation: {
+                description: "Expected precipitation in mm (next hour if available)",
+                type: "number",
+            },
+            symbol: {
+                description: 'Weather symbol code (e.g., "partlycloudy_day", "rain")',
+                type: "string",
+            },
+        },
     },
     examples: [
-        "LOAD JSON FROM weather('Oslo') AS forecast RETURN forecast",
-        "LOAD JSON FROM weather('London') AS forecast RETURN forecast[0]"
-    ]
+        "CALL weather('Oslo') YIELD date, location, temperature, humidity",
+        "CALL weather('London') YIELD date, location, temperature, wind_speed, precipitation",
+    ],
 })
 export class Weather extends AsyncFunction {
     private readonly geocodingApiUrl: string;
@@ -60,7 +68,7 @@ export class Weather extends AsyncFunction {
 
     /**
      * Fetches weather forecast for a given location.
-     * 
+     *
      * @param location - The name of the location to get weather for
      */
     async *generate(location: string): AsyncGenerator<any, void, unknown> {
@@ -87,8 +95,8 @@ export class Weather extends AsyncFunction {
         const weatherResponse = await fetch(weatherUrl, {
             headers: {
                 // MET Norway API requires a User-Agent header
-                'User-Agent': 'FlowQuery-RAG/1.0'
-            }
+                "User-Agent": "FlowQuery-RAG/1.0",
+            },
         });
 
         if (!weatherResponse.ok) {
@@ -117,8 +125,11 @@ export class Weather extends AsyncFunction {
                 cloud_cover: instant.cloud_area_fraction,
                 wind_speed: instant.wind_speed,
                 wind_direction: instant.wind_from_direction,
-                precipitation: next1h.details?.precipitation_amount ?? next6h.details?.precipitation_amount ?? null,
-                symbol: next1h.summary?.symbol_code ?? next6h.summary?.symbol_code ?? null
+                precipitation:
+                    next1h.details?.precipitation_amount ??
+                    next6h.details?.precipitation_amount ??
+                    null,
+                symbol: next1h.summary?.symbol_code ?? next6h.summary?.symbol_code ?? null,
             };
         }
     }