@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/nodes/function.ts

@@ -1,316 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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);
-}
-`;
-}