@divmain/jdm-asm 0.2.0

package/src/compiler/nodes/function.ts

@@ -0,0 +1,316 @@
+import type { CompilationContext } from '../types';
+import { CompilationError, ErrorCode, type SourceLocation } from '../errors';
+import { parse as parseAcorn } from 'acorn';
+import { sanitizeId } from '../utils';
+
+/**
+ * Function node content interface
+ */
+export interface FunctionNodeContent {
+  /** The JavaScript source code for the function */
+  source: string;
+  /** Parsed AST of the function body */
+  ast?: any;
+  /** Extracted function parameters */
+  parameters: string[];
+}
+
+/**
+ * Extract the source code from a function node content field.
+ *
+ * Handles both legacy format (plain string) and v2 format (object with source property).
+ * TODO: Verify if legacy format still exists in fixtures, update comment accordingly
+ *
+ * @param content - The content field from a function node
+ * @param location - Optional source location for error reporting
+ * @returns The JavaScript source code string
+ */
+export function extractFunctionSource(content: any, location?: SourceLocation): string {
+  if (content === null || content === undefined) {
+    throw new CompilationError(
+      'Function node content is missing',
+      ErrorCode.INVALID_NODE_STRUCTURE,
+      location,
+    );
+  }
+
+  if (typeof content === 'object' && content.source !== undefined) {
+    if (typeof content.source !== 'string') {
+      throw new CompilationError(
+        'Function node content.source must be a string',
+        ErrorCode.INVALID_NODE_STRUCTURE,
+        { ...location, field: 'content.source' },
+      );
+    }
+    return content.source;
+  }
+
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  throw new CompilationError(
+    'Function node content must be either a string or an object with a source property',
+    ErrorCode.INVALID_NODE_STRUCTURE,
+    { ...location, field: 'content' },
+  );
+}
+
+/**
+ * Parse JavaScript function code to extract parameters and body.
+ *
+ * @param source - The JavaScript source code string
+ * @param location - Optional source location for error reporting
+ * @returns A FunctionNodeContent with extracted information
+ */
+export function parseFunctionCode(source: string, location?: SourceLocation): FunctionNodeContent {
+  const content: FunctionNodeContent = {
+    source,
+    parameters: [],
+  };
+
+  try {
+    // Parse the source code using Acorn.
+    const ast = parseAcorn(source, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      allowAwaitOutsideFunction: true,
+    });
+
+    content.ast = ast;
+
+    const functionNode = findExportedFunction(ast);
+
+    if (functionNode) {
+      content.parameters = extractParameters(functionNode);
+    }
+  } catch (error) {
+    // Parse errors in function code should fail compilation immediately with clear error
+    // messages, rather than deferring to runtime where the error context would be lost.
+    if (error instanceof Error) {
+      throw new CompilationError(
+        `Failed to parse function code: ${error.message}`,
+        ErrorCode.PARSE_ERROR,
+        { ...location, field: 'content.source' },
+      );
+    }
+    throw error;
+  }
+
+  return content;
+}
+
+/**
+ * Validate a function node's content structure.
+ *
+ * @param node - The JDM function node to validate
+ * @returns Extracted and validated function node content
+ */
+export function validateFunctionNode(node: {
+  id: string;
+  name: string;
+  content?: any;
+}): FunctionNodeContent {
+  const location: SourceLocation = { nodeId: node.id, nodeName: node.name };
+
+  if (!node.content) {
+    throw new CompilationError(
+      `Function node "${node.name}" (${node.id}) is missing required content field`,
+      ErrorCode.INVALID_NODE_STRUCTURE,
+      { ...location, field: 'content' },
+    );
+  }
+
+  const source = extractFunctionSource(node.content, location);
+
+  const parsedContent = parseFunctionCode(source, location);
+
+  return {
+    ...parsedContent,
+    source,
+  };
+}
+
+/**
+ * Find an exported function in the AST.
+ *
+ * Looks for patterns like:
+ * - `export const handler = (input) => { ... }`
+ * - `export function handler(input) { ... }`
+ *
+ * @param ast - The parsed AST
+ * @returns The function declaration or expression, or null if not found
+ */
+function findExportedFunction(ast: any): any {
+  if (!ast.body) {
+    return null;
+  }
+
+  for (const node of ast.body) {
+    // Pattern: export function name(...) { ... }
+    if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+      if (node.declaration.type === 'FunctionDeclaration') {
+        return node.declaration;
+      }
+    }
+
+    // Pattern: export const/let/var name = (input) => { ... }
+    if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+      if (node.declaration.type === 'VariableDeclaration') {
+        const declarator = node.declaration.declarations[0];
+        if (declarator && declarator.init) {
+          // Arrow function: (input) => { ... }
+          if (declarator.init.type === 'ArrowFunctionExpression') {
+            return declarator.init;
+          }
+          // Regular function: function(input) { ... }
+          if (declarator.init.type === 'FunctionExpression') {
+            return declarator.init;
+          }
+        }
+      }
+    }
+
+    // Pattern: export default ...) => { ... }
+    if (node.type === 'ExportDefaultDeclaration') {
+      if (node.declaration.type === 'FunctionDeclaration') {
+        return node.declaration;
+      }
+      if (node.declaration.type === 'ArrowFunctionExpression') {
+        return node.declaration;
+      }
+      if (node.declaration.type === 'FunctionExpression') {
+        return node.declaration;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract parameter names from a function AST node.
+ *
+ * @param functionNode - The function AST node
+ * @returns Array of parameter names
+ */
+function extractParameters(functionNode: any): string[] {
+  if (!functionNode.params || !Array.isArray(functionNode.params)) {
+    return [];
+  }
+
+  return functionNode.params
+    .map((param: any) => {
+      // Simple identifier: input
+      if (param.type === 'Identifier') {
+        return param.name;
+      }
+
+      // Destructuring: { input, context } or [input, context]
+      if (param.type === 'ObjectPattern') {
+        return param.properties
+          .map((prop: any) => prop.key?.name || prop.value?.name)
+          .filter(Boolean);
+      }
+
+      if (param.type === 'ArrayPattern') {
+        return param.elements.map((elem: any) => elem?.name).filter(Boolean);
+      }
+
+      return null;
+    })
+    .flat()
+    .filter(Boolean) as string[];
+}
+
+/**
+ * Compile a function node to AssemblyScript code.
+ *
+ * This function generates AssemblyScript code that:
+ * 1. Reads input parameters from the context
+ * 2. Calls the JavaScript bridge function to execute the user's function
+ * 3. Converts the return value to the Value type
+ *
+ * @param node - The JDM function node
+ * @param context - The compilation context
+ * @returns Generated AssemblyScript code for evaluating the function node
+ */
+export function compileFunctionNode(
+  node: {
+    id: string;
+    name: string;
+    content?: any;
+    parsedContent?: FunctionNodeContent;
+  },
+  context: CompilationContext,
+): string {
+  const sanitizedId = sanitizeId(node.id);
+
+  if (!node.parsedContent) {
+    throw new CompilationError(
+      `Function node "${node.name}" (${node.id}) has not been parsed`,
+      ErrorCode.INVALID_NODE_STRUCTURE,
+      { nodeId: node.id, nodeName: node.name, field: 'parsedContent' },
+    );
+  }
+
+  const { source, parameters } = node.parsedContent;
+
+  // Store the function source in the compilation context for later retrieval.
+  // Function sources must be kept separate from runtime context data to avoid naming conflicts
+  // and ensure proper scoping. The prefix prevents collisions with user-defined fields.
+  if (!context.functionSources) {
+    context.functionSources = new Map();
+  }
+  context.functionSources.set(sanitizedId, source);
+
+  // Generate parameter reading and marshaling code
+  // Parameters need to be collected into an array for the bridge call
+  const paramReads =
+    parameters.length > 0
+      ? parameters
+          .map((param) => {
+            return `  let ${param} = ctx.get("${param}");`;
+          })
+          .join('\n')
+      : '';
+
+  const paramArray =
+    parameters.length > 0
+      ? `
+  // Create parameter array for JavaScript bridge
+  let params = new Array<Value>(0);
+${parameters.map((param) => `  params.push(${param});`).join('\n')}
+`
+      : `
+  // No parameters
+  let params = new Array<Value>(0);
+`;
+
+  // Generate the main evaluateNode function
+  // TODO: Mock execution returns a placeholder result for testing purposes.
+  // This allows the compiler to generate valid code and tests to run while the JavaScript
+  // function execution bridge is not yet implemented. This will be replaced with actual
+  // JavaScript bridge functionality in a future phase
+  return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  // Function node: ${node.name}
+  // This node would execute JavaScript code and return the result
+  // For now, we return a mock result to allow compilation and testing
+
+${paramReads}
+${paramArray}
+  // Mock result: return an object indicating function execution
+  // This is a placeholder - actual JavaScript execution will be implemented
+  // via a JavaScript bridge in the runtime
+  let mockResult = new Map<string, Value>();
+  mockResult.set("_isFunctionNode", Value.Bool(true));
+  mockResult.set("_nodeName", Value.String("${node.name}"));
+${parameters.length > 0 ? parameters.map((param) => `  mockResult.set("_${param}", ${param});`).join('\n') : ''}
+  mockResult.set("_output", Value.String("Function execution not yet implemented"));
+  
+  let result = Value.Object(mockResult);
+
+  return result;
+}`;
+}

package/src/compiler/nodes/input.ts

@@ -0,0 +1,60 @@
+import type { JDMNode } from '../parser';
+import type { CompilationContext, AssemblyScriptCode } from '../types';
+import { sanitizeId } from '../utils';
+
+/**
+ * Compile an input node.
+ *
+ * Input nodes serve as entry points for the decision model and simply
+ * pass through the context data.
+ *
+ * @param node - The JDM input node
+ * @param context - The compilation context
+ * @returns Generated AssemblyScript code
+ */
+export function compileInputNode(node: JDMNode, _context: CompilationContext): AssemblyScriptCode {
+  const sanitizedId = sanitizeId(node.id);
+  return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  // Input nodes are markers - they trigger evaluation but don't produce output.
+  // Null is used as a semantic marker meaning "input processed, no output to add".
+  // This distinguishes from actual output values while avoiding undefined/error states.
+  return Value.Null();
+}
+`;
+}
+
+/**
+ * Compile an output node.
+ *
+ * Output nodes mark the end of the decision model and return the final result.
+ * They return the accumulated context data from passThrough nodes.
+ *
+ * @param node - The JDM output node
+ * @param context - The compilation context
+ * @returns Generated AssemblyScript code
+ */
+export function compileOutputNode(node: JDMNode, _context: CompilationContext): AssemblyScriptCode {
+  const sanitizedId = sanitizeId(node.id);
+  return `
+export function evaluateNode_${sanitizedId}(ctx: Context): Value {
+  // Output nodes return the accumulated context data (passThrough values)
+  // Build result from all non-internal context entries
+  let __finalResult = new Map<string, Value>();
+  const __ctxKeys = ctx.data.keys();
+  for (let __i = 0; __i < __ctxKeys.length; __i++) {
+    const __key = __ctxKeys[__i];
+    // $-prefixed keys are internal namespaces ($nodes, $)
+    // # is iteration variable
+    // acc is reduce accumulator
+    // None should appear in final output - only actual output fields.
+    if (!__key.startsWith("$") && __key !== "#" && __key !== "acc") {
+      // AssemblyScript has no Map.filter(), so we must iterate and conditionally add keys.
+      // This is more verbose but necessary given AS limitations.
+      __finalResult.set(__key, ctx.data.get(__key));
+    }
+  }
+  return Value.Object(__finalResult);
+}
+`;
+}