@halleyassist/rule-templater 0.0.16 → 0.0.18

package/src/HalleyFunctionBlob.js

@@ -0,0 +1,126 @@
+class HalleyFunctionBlob {
+    constructor(jsonData) {
+        const blobData = jsonData && typeof jsonData === 'object' ? jsonData : {};
+
+        this._schema = blobData._schema;
+        this.version = blobData.version;
+        this.functions = [];
+        this.functionMap = new Map();
+
+        const functions = Array.isArray(blobData.functions) ? blobData.functions : [];
+        for (const definition of functions) {
+            if (!definition || typeof definition.name !== 'string') {
+                continue;
+            }
+
+            const normalizedDefinition = {
+                name: definition.name,
+                arguments: Array.isArray(definition.arguments) ? definition.arguments.slice() : []
+            };
+
+            this.functions.push(normalizedDefinition);
+            this.functionMap.set(normalizedDefinition.name, normalizedDefinition);
+        }
+    }
+
+    static async fromURL(url) {
+        if (typeof url !== 'string' || !url.trim()) {
+            throw new Error('A function blob URL must be provided');
+        }
+
+        if (typeof globalThis.fetch !== 'function') {
+            throw new Error('Fetch API is not available');
+        }
+
+        const response = await globalThis.fetch(url);
+        if (!response || !response.ok) {
+            throw new Error(`Failed to fetch function blob from '${url}'`);
+        }
+
+        return new HalleyFunctionBlob(await response.json());
+    }
+
+    validate(functionName, variables = []) {
+        const warnings = [];
+        const functionDefinition = this.functionMap.get(functionName);
+
+        if (!functionDefinition) {
+            return [`function '${functionName}' does not exist`];
+        }
+
+        const providedVariables = Array.isArray(variables) ? variables : [];
+        const providedCount = providedVariables.length;
+        const parameterRange = this._getParameterRange(functionDefinition.arguments);
+
+        for (let idx = 0; idx < functionDefinition.arguments.length; idx++) {
+            const argumentName = functionDefinition.arguments[idx];
+            if (argumentName === '...') {
+                break;
+            }
+
+            if (providedCount > idx || argumentName.endsWith('?')) {
+                continue;
+            }
+
+            warnings.push(
+                `parameter ${idx + 1} of ${functionName} '${argumentName}' is missing, function expects ${parameterRange}`
+            );
+        }
+
+        if (this._hasTooManyArguments(functionDefinition.arguments, providedCount)) {
+            warnings.push(
+                `${functionName} received ${providedCount} parameters, function expects ${parameterRange}`
+            );
+        }
+
+        return warnings;
+    }
+
+    _hasTooManyArguments(argumentList, providedCount) {
+        const { max } = this._getArgumentBounds(argumentList);
+        return max !== Infinity && providedCount > max;
+    }
+
+    _getParameterRange(argumentList) {
+        const { min, max } = this._getArgumentBounds(argumentList);
+
+        if (max === Infinity) {
+            if (min === 0) {
+                return 'any number of parameters';
+            }
+
+            return `at least ${min} ${min === 1 ? 'parameter' : 'parameters'}`;
+        }
+
+        if (min === max) {
+            return `${min} ${min === 1 ? 'parameter' : 'parameters'}`;
+        }
+
+        return `${min} to ${max} parameters`;
+    }
+
+    _getArgumentBounds(argumentList) {
+        let min = 0;
+        let max = 0;
+        let variadic = false;
+
+        for (const argumentName of argumentList) {
+            if (argumentName === '...') {
+                variadic = true;
+                continue;
+            }
+
+            max++;
+            if (!argumentName.endsWith('?')) {
+                min++;
+            }
+        }
+
+        return {
+            min,
+            max: variadic ? Infinity : max
+        };
+    }
+}
+
+module.exports = HalleyFunctionBlob;

package/src/RuleTemplate.js

@@ -185,11 +185,13 @@ class RuleTemplate {
         
         // Extract filters
         const filters = [];
+        const filterCalls = [];
         for (const child of templateExpr.children || []) {
             if (child.type === 'template_filter_call') {
-                const filterName = this._extractFilterName(child);
-                if (filterName) {
-                    filters.push(filterName);
+                const filterCall = this._extractFilterCall(child);
+                if (filterCall) {
+                    filters.push(filterCall.name);
+                    filterCalls.push(filterCall);
                 }
             }
         }
@@ -198,38 +200,128 @@ class RuleTemplate {
         const start = node.start;
         const end = node.end;
         
-        return { name, filters, start, end };
+        return { name, filters, filterCalls, start, end };
     }
 
     /**
-     * Extract filter name from template_filter_call node
+     * Extract filter call from template_filter_call node
      * @private
      */
-    _extractFilterName(node) {
+    _extractFilterCall(node) {
         const filterNameNode = node.children?.find(c => c.type === 'template_filter_name');
         if (!filterNameNode || !filterNameNode.text) return null;
-        
-        return filterNameNode.text.trim();
+
+        const argsNode = node.children?.find(c => c.type === 'template_filter_args');
+
+        return {
+            name: filterNameNode.text.trim(),
+            args: this._extractFilterArgs(argsNode)
+        };
+    }
+
+    _extractFilterArgs(node) {
+        if (!node || !Array.isArray(node.children)) {
+            return [];
+        }
+
+        return node.children
+            .filter(child => child.type === 'template_filter_arg')
+            .map(child => this._extractFilterArgValue(child));
+    }
+
+    _extractFilterArgValue(node) {
+        if (!node || !Array.isArray(node.children) || node.children.length === 0) {
+            return this._normalizeFilterArgText(node?.text?.trim() || '');
+        }
+
+        const child = node.children[0];
+        if (!child) {
+            return this._normalizeFilterArgText(node.text?.trim() || '');
+        }
+
+        if (child.type === 'value' && Array.isArray(child.children) && child.children.length > 0) {
+            return this._extractFilterArgValue(child);
+        }
+
+        if (child.type === 'string') {
+            try {
+                return JSON.parse(child.text);
+            } catch (error) {
+                return this._normalizeFilterArgText(child.text);
+            }
+        }
+
+        if (child.type === 'number') {
+            return Number(child.text);
+        }
+
+        if (child.type === 'true') {
+            return true;
+        }
+
+        if (child.type === 'false') {
+            return false;
+        }
+
+        if (child.type === 'null') {
+            return null;
+        }
+
+        return this._normalizeFilterArgText(child.text?.trim() || node.text?.trim() || '');
+    }
+
+    _normalizeFilterArgText(text) {
+        const normalizedText = String(text).trim();
+
+        if ((normalizedText.startsWith('"') && normalizedText.endsWith('"')) || (normalizedText.startsWith("'") && normalizedText.endsWith("'"))) {
+            return normalizedText.slice(1, -1);
+        }
+
+        return normalizedText;
     }
 
     /**
      * Validate variable types against the AST
      * @param {Object} variables - Object mapping variable names to {type} objects
-     * @returns {Object} Object with validation results: {valid: boolean, errors: []}
+     * @param {Object} [functionBlob] - Optional HalleyFunctionBlob used for non-fatal function warnings
+     * @returns {Object} Object with validation results: {valid: boolean, errors: [], warnings: []}
      */
-    validate(variables) {
+    validate(variables, functionBlob) {
         if (!variables || typeof variables !== 'object') {
             return {
                 valid: false,
-                errors: ['Variables must be provided as an object']
+                errors: ['Variables must be provided as an object'],
+                warnings: []
             };
         }
 
         const errors = [];
-        const extractedVars = this.extractVariables();
+        const warnings = [];
+        const extractedVars = this._extractTemplateVariables();
+        const seenVariables = new Set();
+        const seenFilterErrors = new Set();
         
         for (const varInfo of extractedVars) {
             const varName = varInfo.name;
+
+            for (const filter of (varInfo.filterCalls || varInfo.filters || [])) {
+                const filterName = typeof filter === 'string' ? filter : filter?.name;
+                if (filterName && TemplateFilters[filterName]) {
+                    continue;
+                }
+
+                const errorMessage = `Unknown filter '${filterName || filter}' for variable '${varName}'`;
+                if (!seenFilterErrors.has(errorMessage)) {
+                    errors.push(errorMessage);
+                    seenFilterErrors.add(errorMessage);
+                }
+            }
+
+            if (seenVariables.has(varName)) {
+                continue;
+            }
+
+            seenVariables.add(varName);
             
             // Check if variable is provided
             if (!variables.hasOwnProperty(varName)) {
@@ -258,11 +350,72 @@ class RuleTemplate {
                 }
             }
         }
+
+        if (functionBlob && typeof functionBlob.validate === 'function') {
+            for (const functionCall of this._extractFunctionCalls()) {
+                warnings.push(...functionBlob.validate(functionCall.name, functionCall.arguments));
+            }
+        }
         
         return {
             valid: errors.length === 0,
-            errors
+            errors,
+            warnings
+        };
+    }
+
+    _extractFunctionCalls() {
+        const functionCalls = [];
+
+        const traverse = (node) => {
+            if (!node) return;
+
+            if (node.type === 'fcall') {
+                const functionName = node.children?.find(c => c.type === 'fname')?.text?.trim();
+                const argumentsNode = node.children?.find(c => c.type === 'arguments');
+                if (functionName) {
+                    functionCalls.push({
+                        name: functionName,
+                        arguments: argumentsNode?.children
+                            ?.filter(c => c.type === 'argument')
+                            .map(c => c.text) || []
+                    });
+                }
+            }
+
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
         };
+
+        traverse(this.ast);
+        return functionCalls;
+    }
+
+    _extractTemplateVariables() {
+        const variables = [];
+
+        const traverse = (node) => {
+            if (!node) return;
+
+            if (node.type === 'template_value') {
+                const variableInfo = this._extractVariableFromNode(node);
+                if (variableInfo) {
+                    variables.push(variableInfo);
+                }
+            }
+
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+
+        traverse(this.ast);
+        return variables;
     }
 
     /**
@@ -367,12 +520,15 @@ class RuleTemplate {
         
         // Apply filters if present
         if (templateInfo.filters && templateInfo.filters.length > 0) {
-            for (const filterName of templateInfo.filters) {
-                if (!TemplateFilters[filterName]) {
-                    throw new Error(`Unknown filter '${filterName}'`);
+            for (const filter of (templateInfo.filterCalls || templateInfo.filters)) {
+                const filterName = typeof filter === 'string' ? filter : filter?.name;
+                const filterArgs = typeof filter === 'string' ? [] : (Array.isArray(filter?.args) ? filter.args : []);
+
+                if (!filterName || !TemplateFilters[filterName]) {
+                    throw new Error(`Unknown filter '${filterName || filter}'`);
                 }
-               
-                TemplateFilters[filterName](varData);
+
+                TemplateFilters[filterName](varData, ...filterArgs);
             }
         }
 

package/src/RuleTemplate.production.js

@@ -185,11 +185,13 @@ class RuleTemplate {
         
         // Extract filters
         const filters = [];
+        const filterCalls = [];
         for (const child of templateExpr.children || []) {
             if (child.type === 'template_filter_call') {
-                const filterName = this._extractFilterName(child);
-                if (filterName) {
-                    filters.push(filterName);
+                const filterCall = this._extractFilterCall(child);
+                if (filterCall) {
+                    filters.push(filterCall.name);
+                    filterCalls.push(filterCall);
                 }
             }
         }
@@ -198,38 +200,128 @@ class RuleTemplate {
         const start = node.start;
         const end = node.end;
         
-        return { name, filters, start, end };
+        return { name, filters, filterCalls, start, end };
     }
 
     /**
-     * Extract filter name from template_filter_call node
+     * Extract filter call from template_filter_call node
      * @private
      */
-    _extractFilterName(node) {
+    _extractFilterCall(node) {
         const filterNameNode = node.children?.find(c => c.type === 'template_filter_name');
         if (!filterNameNode || !filterNameNode.text) return null;
-        
-        return filterNameNode.text.trim();
+
+        const argsNode = node.children?.find(c => c.type === 'template_filter_args');
+
+        return {
+            name: filterNameNode.text.trim(),
+            args: this._extractFilterArgs(argsNode)
+        };
+    }
+
+    _extractFilterArgs(node) {
+        if (!node || !Array.isArray(node.children)) {
+            return [];
+        }
+
+        return node.children
+            .filter(child => child.type === 'template_filter_arg')
+            .map(child => this._extractFilterArgValue(child));
+    }
+
+    _extractFilterArgValue(node) {
+        if (!node || !Array.isArray(node.children) || node.children.length === 0) {
+            return this._normalizeFilterArgText(node?.text?.trim() || '');
+        }
+
+        const child = node.children[0];
+        if (!child) {
+            return this._normalizeFilterArgText(node.text?.trim() || '');
+        }
+
+        if (child.type === 'value' && Array.isArray(child.children) && child.children.length > 0) {
+            return this._extractFilterArgValue(child);
+        }
+
+        if (child.type === 'string') {
+            try {
+                return JSON.parse(child.text);
+            } catch (error) {
+                return this._normalizeFilterArgText(child.text);
+            }
+        }
+
+        if (child.type === 'number') {
+            return Number(child.text);
+        }
+
+        if (child.type === 'true') {
+            return true;
+        }
+
+        if (child.type === 'false') {
+            return false;
+        }
+
+        if (child.type === 'null') {
+            return null;
+        }
+
+        return this._normalizeFilterArgText(child.text?.trim() || node.text?.trim() || '');
+    }
+
+    _normalizeFilterArgText(text) {
+        const normalizedText = String(text).trim();
+
+        if ((normalizedText.startsWith('"') && normalizedText.endsWith('"')) || (normalizedText.startsWith("'") && normalizedText.endsWith("'"))) {
+            return normalizedText.slice(1, -1);
+        }
+
+        return normalizedText;
     }
 
     /**
      * Validate variable types against the AST
      * @param {Object} variables - Object mapping variable names to {type} objects
-     * @returns {Object} Object with validation results: {valid: boolean, errors: []}
+     * @param {Object} [functionBlob] - Optional HalleyFunctionBlob used for non-fatal function warnings
+     * @returns {Object} Object with validation results: {valid: boolean, errors: [], warnings: []}
      */
-    validate(variables) {
+    validate(variables, functionBlob) {
         if (!variables || typeof variables !== 'object') {
             return {
                 valid: false,
-                errors: ['Variables must be provided as an object']
+                errors: ['Variables must be provided as an object'],
+                warnings: []
             };
         }
 
         const errors = [];
-        const extractedVars = this.extractVariables();
+        const warnings = [];
+        const extractedVars = this._extractTemplateVariables();
+        const seenVariables = new Set();
+        const seenFilterErrors = new Set();
         
         for (const varInfo of extractedVars) {
             const varName = varInfo.name;
+
+            for (const filter of (varInfo.filterCalls || varInfo.filters || [])) {
+                const filterName = typeof filter === 'string' ? filter : filter?.name;
+                if (filterName && TemplateFilters[filterName]) {
+                    continue;
+                }
+
+                const errorMessage = `Unknown filter '${filterName || filter}' for variable '${varName}'`;
+                if (!seenFilterErrors.has(errorMessage)) {
+                    errors.push(errorMessage);
+                    seenFilterErrors.add(errorMessage);
+                }
+            }
+
+            if (seenVariables.has(varName)) {
+                continue;
+            }
+
+            seenVariables.add(varName);
             
             // Check if variable is provided
             if (!variables.hasOwnProperty(varName)) {
@@ -258,11 +350,72 @@ class RuleTemplate {
                 }
             }
         }
+
+        if (functionBlob && typeof functionBlob.validate === 'function') {
+            for (const functionCall of this._extractFunctionCalls()) {
+                warnings.push(...functionBlob.validate(functionCall.name, functionCall.arguments));
+            }
+        }
         
         return {
             valid: errors.length === 0,
-            errors
+            errors,
+            warnings
+        };
+    }
+
+    _extractFunctionCalls() {
+        const functionCalls = [];
+
+        const traverse = (node) => {
+            if (!node) return;
+
+            if (node.type === 'fcall') {
+                const functionName = node.children?.find(c => c.type === 'fname')?.text?.trim();
+                const argumentsNode = node.children?.find(c => c.type === 'arguments');
+                if (functionName) {
+                    functionCalls.push({
+                        name: functionName,
+                        arguments: argumentsNode?.children
+                            ?.filter(c => c.type === 'argument')
+                            .map(c => c.text) || []
+                    });
+                }
+            }
+
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
         };
+
+        traverse(this.ast);
+        return functionCalls;
+    }
+
+    _extractTemplateVariables() {
+        const variables = [];
+
+        const traverse = (node) => {
+            if (!node) return;
+
+            if (node.type === 'template_value') {
+                const variableInfo = this._extractVariableFromNode(node);
+                if (variableInfo) {
+                    variables.push(variableInfo);
+                }
+            }
+
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+
+        traverse(this.ast);
+        return variables;
     }
 
     /**
@@ -367,12 +520,15 @@ class RuleTemplate {
         
         // Apply filters if present
         if (templateInfo.filters && templateInfo.filters.length > 0) {
-            for (const filterName of templateInfo.filters) {
-                if (!TemplateFilters[filterName]) {
-                    throw new Error(`Unknown filter '${filterName}'`);
+            for (const filter of (templateInfo.filterCalls || templateInfo.filters)) {
+                const filterName = typeof filter === 'string' ? filter : filter?.name;
+                const filterArgs = typeof filter === 'string' ? [] : (Array.isArray(filter?.args) ? filter.args : []);
+
+                if (!filterName || !TemplateFilters[filterName]) {
+                    throw new Error(`Unknown filter '${filterName || filter}'`);
                 }
-               
-                TemplateFilters[filterName](varData);
+
+                TemplateFilters[filterName](varData, ...filterArgs);
             }
         }