flowquery 1.0.12 → 1.0.13

package/src/parsing/functions/function_metadata.ts

@@ -78,19 +78,9 @@ export type AsyncDataProvider = (...args: any[]) => AsyncGenerator<any, void, un
 class FunctionRegistry {
     private static metadata: Map<string, FunctionMetadata> = new Map<string, FunctionMetadata>();
     private static factories: Map<string, () => any> = new Map<string, () => any>();
-    private static asyncProviders: Map<string, AsyncDataProvider> = new Map<string, AsyncDataProvider>();
-
-    /** Registers an async data provider class. */
-    static registerAsync<T extends new (...args: any[]) => any>(constructor: T, options: FunctionDefOptions): void {
-        const displayName: string = constructor.name;
-        const registryKey: string = displayName.toLowerCase();
-
-        this.metadata.set(registryKey, { name: displayName, ...options });
-        this.asyncProviders.set(registryKey, (...args: any[]) => new constructor().fetch(...args));
-    }
 
     /** Registers a regular function class. */
-    static registerFunction<T extends new (...args: any[]) => any>(constructor: T, options: FunctionDefOptions): void {
+    static register<T extends new (...args: any[]) => any>(constructor: T, options: FunctionDefOptions): void {
         const instance: any = new constructor();
         const displayName: string = (instance.name?.toLowerCase() || constructor.name.toLowerCase());
         const registryKey: string = options.category ? `${displayName}:${options.category}` : displayName;
@@ -121,10 +111,6 @@ class FunctionRegistry {
         if (category) return this.factories.get(`${lowerName}:${category}`);
         return this.factories.get(lowerName);
     }
-
-    static getAsyncProvider(name: string): AsyncDataProvider | undefined {
-        return this.asyncProviders.get(name.toLowerCase());
-    }
 }
 
 /**
@@ -137,45 +123,74 @@ export type FunctionDefOptions = Omit<FunctionMetadata, 'name'>;
  * The function name is derived from the class's constructor call to super() for regular functions,
  * or from the class name for async providers.
  * 
- * For async providers (category: "async"), the class must have a `fetch` method that returns
- * an AsyncGenerator. The function name is derived from the class name, converted to camelCase
- * (first letter lowercased).
+ * For async providers (category: "async"), the class must have a `generate` method that returns
+ * an AsyncGenerator. This allows the function to be used as a data source in LOAD operations.
  * 
  * @param options - Function metadata (excluding name)
  * @returns Class decorator
  * 
  * @example
  * ```typescript
- * // Regular function
+ * // Scalar function example
  * @FunctionDef({
- *     description: "Calculates the sum of numeric values",
- *     category: "aggregate",
- *     parameters: [{ name: "value", description: "Numeric value to sum", type: "number" }],
- *     output: { description: "Sum of all values", type: "number", example: 150 },
- *     examples: ["WITH [1, 2, 3] AS nums UNWIND nums AS n RETURN sum(n)"]
+ *   description: "Adds two numbers",
+ *   category: "scalar",
+ *   parameters: [
+ *     { name: "a", description: "First number", type: "number" },
+ *     { name: "b", description: "Second number", type: "number" }
+ *   ],
+ *   output: { description: "Sum of a and b", type: "number" },
+ *   examples: ["ADD(2, 3) // returns 5"]
  * })
- * class Sum extends AggregateFunction { ... }
- * 
- * // Async data provider
+ * class AddFunction extends Function {
+ *   constructor() {
+ *     super("add");
+ *   }
+ *   public execute(a: number, b: number): number {
+ *    return a + b;
+ *  }
+ * }
+ * // Aggregate function example
  * @FunctionDef({
- *     description: "Fetches random cat facts from the Cat Facts API",
- *     category: "async",
- *     parameters: [{ name: "count", description: "Number of facts", type: "number", required: false, default: 1 }],
- *     output: { description: "Cat fact object", type: "object" },
- *     examples: ["LOAD JSON FROM catFacts(5) AS fact RETURN fact.text"]
+ *   description: "Calculates the average of a list of numbers",
+ *  category: "aggregate",
+ *  parameters: [
+ *    { name: "values", description: "Array of numbers", type: "array", items: { type: "number" } }
+ *  ],
+ *  output: { description: "Average value", type: "number" },
+ *  examples: ["AVERAGE([1, 2, 3, 4, 5]) // returns 3"]
  * })
- * class CatFacts {
- *     async *fetch(count: number = 1): AsyncGenerator<any> { ... }
+ * class AverageFunction extends AggregateFunction {
+ *   constructor() {
+ *    super("average");
+ *  }
+ *  public execute(values: number[]): number {
+ *   const sum = values.reduce((acc, val) => acc + val, 0);
+ *   return sum / values.length;
+ * }
+ * }
+ * // Async data provider example
+ * @FunctionDef({
+ *  description: "Fetches data from an external API",
+ * category: "async",
+ * parameters: [
+ *   { name: "endpoint", description: "API endpoint URL", type: "string" }
+ * ],
+ * output: { description: "Data object", type: "object" },
+ * examples: ["MyAsyncDataProvider('https://api.example.com/data')"]
+ * })
+ * class MyAsyncDataProvider extends AsyncFunction {
+ *   public async *generate(endpoint: string): AsyncGenerator<any> {
+ *    const response = await fetch(endpoint);
+ *   const data = await response.json();
+ *   for (const item of data) {
+ *    yield item;
+ *  }
  * }
- * ```
  */
 export function FunctionDef(options: FunctionDefOptions) {
     return function <T extends new (...args: any[]) => any>(constructor: T): T {
-        if (options.category === 'async') {
-            FunctionRegistry.registerAsync(constructor, options);
-        } else {
-            FunctionRegistry.registerFunction(constructor, options);
-        }
+        FunctionRegistry.register(constructor, options);
         return constructor;
     };
 }
@@ -200,10 +215,3 @@ export function getRegisteredFunctionFactory(name: string, category?: string): (
 export function getFunctionMetadata(name: string, category?: string): FunctionMetadata | undefined {
     return FunctionRegistry.getMetadata(name, category);
 }
-
-/**
- * Gets a registered async data provider by name.
- */
-export function getRegisteredAsyncProvider(name: string): AsyncDataProvider | undefined {
-    return FunctionRegistry.getAsyncProvider(name);
-}

package/src/parsing/functions/predicate_function.ts

@@ -8,9 +8,9 @@ class PredicateFunction extends ASTNode {
     private _name: string;
     protected _valueHolder: ValueHolder = new ValueHolder();
 
-    constructor(name: string) {
+    constructor(name?: string) {
         super();
-        this._name = name;
+        this._name = name || this.constructor.name;
     }
 
     public get name(): string {

package/src/parsing/operations/load.ts

@@ -87,7 +87,7 @@ class Load extends Operation {
    */
   private async loadFromFunction(): Promise<void> {
     const asyncFunc = this.asyncFunction!;
-    for await (const item of asyncFunc.execute()) {
+    for await (const item of asyncFunc.generate()) {
       this._value = item;
       await this.next?.run();
     }

package/src/parsing/parser.ts

@@ -597,7 +597,7 @@ class Parser extends BaseParser {
         if(!this.peek()?.isLeftParenthesis()) {
             return null;
         }
-        const asyncFunc = new AsyncFunction(this.token.value);
+        const asyncFunc = FunctionFactory.createAsync(this.token.value);
         this.setNextToken(); // skip function name
         this.setNextToken(); // skip left parenthesis
         this.skipWhitespaceAndComments();
@@ -609,6 +609,7 @@ class Parser extends BaseParser {
         this.setNextToken();
         return asyncFunc;
     }
+    
     private parsePredicateFunction(): PredicateFunction | null {
         if(!this.ahead([Token.IDENTIFIER(""), Token.LEFT_PARENTHESIS, Token.IDENTIFIER(""), Token.IN])) {
             return null;

package/tests/extensibility.test.ts

@@ -12,8 +12,8 @@ import {
     FunctionCategory
 } from "../src/extensibility";
 import {
-    getRegisteredAsyncProvider,
-    getFunctionMetadata
+    getFunctionMetadata,
+    getRegisteredFunctionFactory
 } from "../src/parsing/functions/function_metadata";
 
 describe("Extensibility API Exports", () => {
@@ -216,8 +216,8 @@ describe("FunctionDef Decorator", () => {
             ],
             output: { description: "Data object", type: "object" }
         })
-        class Simple {
-            async *fetch(count: number = 1): AsyncGenerator<any> {
+        class Simple extends AsyncFunction {
+            public async *generate(count: number = 1): AsyncGenerator<any> {
                 for (let i = 0; i < count; i++) {
                     yield { id: i, data: `item${i}` };
                 }
@@ -225,9 +225,9 @@ describe("FunctionDef Decorator", () => {
         }
         
         // Verify the decorated class still works correctly
-        const loader = new Simple();
+        const loader = new Simple("simple");
         const results: any[] = [];
-        for await (const item of loader.fetch(2)) {
+        for await (const item of loader.generate(2)) {
             results.push(item);
         }
         expect(results.length).toBe(2);
@@ -235,14 +235,14 @@ describe("FunctionDef Decorator", () => {
         expect(results[1]).toEqual({ id: 1, data: "item1" });
         
         // Verify the async provider was registered
-        const provider = getRegisteredAsyncProvider("simple");
+        const provider = getRegisteredFunctionFactory("simple", "async");
         expect(provider).toBeDefined();
         expect(typeof provider).toBe("function");
         
         // Verify the metadata was registered
-        const metadata = getFunctionMetadata("simple");
+        const metadata = getFunctionMetadata("simple", "async");
         expect(metadata).toBeDefined();
-        expect(metadata?.name).toBe("Simple");
+        expect(metadata?.name).toBe("simple");
         expect(metadata?.category).toBe("async");
         expect(metadata?.description).toBe("Test async provider for extensibility");
     });
@@ -540,17 +540,17 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             description: "Provides example data for testing",
             category: "async",
             parameters: [],
-            output: { description: "Example data object", type: "object" }
+            output: { description: "Example data o.bject", type: "object" }
         })
-        class GetExampleData {
-            async *fetch(): AsyncGenerator<any> {
+        class GetExampleData extends AsyncFunction {
+            public async *generate(): AsyncGenerator<any> {
                 yield { id: 1, name: "Alice" };
                 yield { id: 2, name: "Bob" };
             }
         }
 
         // Verify registration worked
-        expect(getRegisteredAsyncProvider("getExampleData")).toBeDefined();
+        expect(getRegisteredFunctionFactory("getExampleData", "async")).toBeDefined();
 
         // Use the async provider in a FlowQuery statement
         const runner = new Runner("LOAD JSON FROM getExampleData() AS data RETURN data.id AS id, data.name AS name");
@@ -568,22 +568,22 @@ describe("Plugin Functions Integration with FlowQuery", () => {
             parameters: [],
             output: { description: "Test data", type: "object" }
         })
-        class MixedCaseFunc {
-            async *fetch(): AsyncGenerator<any> {
+        class MixedCaseFunc extends AsyncFunction {
+            public async *generate(): AsyncGenerator<any> {
                 yield { value: 42 };
             }
         }
 
         // Verify registration works with different casings
-        expect(getRegisteredAsyncProvider("MixedCaseFunc")).toBeDefined();
-        expect(getRegisteredAsyncProvider("mixedcasefunc")).toBeDefined();
-        expect(getRegisteredAsyncProvider("MIXEDCASEFUNC")).toBeDefined();
-        expect(getRegisteredAsyncProvider("mIxEdCaSeFuNc")).toBeDefined();
+        expect(getRegisteredFunctionFactory("MixedCaseFunc", "async")).toBeDefined();
+        expect(getRegisteredFunctionFactory("mixedcasefunc", "async")).toBeDefined();
+        expect(getRegisteredFunctionFactory("MIXEDCASEFUNC", "async")).toBeDefined();
+        expect(getRegisteredFunctionFactory("mIxEdCaSeFuNc", "async")).toBeDefined();
 
         // Verify metadata lookup is case-insensitive
-        expect(getFunctionMetadata("MixedCaseFunc")).toBeDefined();
-        expect(getFunctionMetadata("mixedcasefunc")).toBeDefined();
-        expect(getFunctionMetadata("MIXEDCASEFUNC")).toBeDefined();
+        expect(getFunctionMetadata("MixedCaseFunc", "async")).toBeDefined();
+        expect(getFunctionMetadata("mixedcasefunc", "async")).toBeDefined();
+        expect(getFunctionMetadata("MIXEDCASEFUNC", "async")).toBeDefined();
 
         // Test using different casings in FlowQuery statements
         const runner1 = new Runner("LOAD JSON FROM mixedcasefunc() AS d RETURN d.value AS v");

package/tests/parsing/parser.test.ts

@@ -17,12 +17,12 @@ test('Test Parser', () => {
 
 test('Test Parser with function', () => {
     const parser = new Parser();
-    const ast = parser.parse('RETURN f()');
+    const ast = parser.parse('RETURN rand()');
     expect(ast.print()).toBe(
         'ASTNode\n' +
         '- Return\n' +
         '-- Expression\n' +
-        '--- Function (f)'
+        '--- Function (rand)'
     );
 });
 

package/misc/apps/RAG/.env.example

@@ -1,14 +0,0 @@
-# OpenAI API Configuration
-# Copy this file to .env and fill in your values
-
-# Your OpenAI API key (required)
-OPENAI_API_KEY=sk-your-api-key-here
-
-# Optional: OpenAI Organization ID
-OPENAI_ORGANIZATION_ID=org-your-org-id
-
-# Optional: Default model
-OPENAI_MODEL=gpt-4o-mini
-
-# Note: These values are read at build time and used as defaults
-# when localStorage is empty. Changes require rebuilding the app.