@divmain/jdm-asm 0.2.0

package/src/compiler/codegen/js-validation.ts

@@ -0,0 +1,243 @@
+/**
+ * JavaScript Validation Code Generation
+ *
+ * This module generates JavaScript code for validating input data against
+ * TypeBox schemas before marshaling. The generated code performs:
+ *
+ * - Type checking for primitives (string, number, boolean)
+ * - Required field validation
+ * - Nested object validation
+ * - Array element validation
+ * - Union type validation
+ * - Literal value validation
+ *
+ * The generated validators are standalone JavaScript code that doesn't
+ * require runtime schema compilation, making validation fast and predictable.
+ */
+
+import { type TSchema, Kind } from '@sinclair/typebox';
+
+/**
+ * Generate JavaScript validation code.
+ *
+ * This function generates JavaScript code that validates input data
+ * against the TypeBox schema before marshaling.
+ *
+ * Generates custom validation code that checks types and required fields
+ * without requiring runtime schema compilation.
+ *
+ * @param schema - The TypeBox schema to validate against
+ * @returns Generated validation code as a string
+ */
+export function generateValidationCode(schema: TSchema): string {
+  const validatorCode = generateSchemaValidator(schema, 'data');
+
+  return `// Generated validation code for TypeBox schema
+
+/**
+ * Validate input data against the schema.
+ * Throws an error if validation fails.
+ *
+ * @param data - The input data to validate
+ * @throws {ValidationError} If validation fails
+ */
+export function validateInput(data) {
+  const errors = ${validatorCode};
+  if (errors.length > 0) {
+    throw new ValidationError('Invalid input data', errors);
+  }
+}
+
+/**
+ * Custom error class for validation errors
+ */
+export class ValidationError extends Error {
+  constructor(message, errors) {
+    const errorList = errors
+      .map((e, i) => '[' + (i + 1) + '] ' + e.path + ': ' + e.message)
+      .join('\\n  ');
+    super(message + ':\\n  ' + errorList);
+    this.name = 'ValidationError';
+    this.errors = errors;
+  }
+}
+
+/**
+ * Safely validate input without throwing.
+ *
+ * @param data - The input data to validate
+ * @returns true if valid, false otherwise
+ */
+export function checkInput(data) {
+  try {
+    validateInput(data);
+    return true;
+  } catch {
+    return false;
+  }
+}
+`;
+}
+
+/**
+ * Generate validation code for a given schema.
+ *
+ * @param schema - The TypeBox schema to generate validation for
+ * @param dataPath - JavaScript expression for accessing the data at this level
+ * @returns JavaScript code that returns an array of error objects
+ */
+function generateSchemaValidator(schema: TSchema, dataPath: string): string {
+  const kind = (schema as any)[Kind];
+
+  switch (kind) {
+    case 'Object': {
+      return validateObject(schema, dataPath);
+    }
+
+    case 'String': {
+      return validatePrimitive(dataPath, 'string', 'Expected string');
+    }
+
+    case 'Number': {
+      return validatePrimitive(dataPath, 'number', 'Expected number');
+    }
+
+    case 'Integer': {
+      return `${validatePrimitive(dataPath, 'number', 'Expected integer')}.concat(
+        ${dataPath} !== undefined && ${dataPath} !== null && !Number.isInteger(${dataPath})
+          ? [{ path: '${dataPath}', message: 'Expected integer', value: ${dataPath} }]
+          : []
+      )`;
+    }
+
+    case 'Boolean': {
+      return validatePrimitive(dataPath, 'boolean', 'Expected boolean');
+    }
+
+    case 'Array': {
+      return validateArray(schema, dataPath);
+    }
+
+    case 'Union': {
+      return validateUnion(schema, dataPath);
+    }
+
+    case 'Literal': {
+      const literalValue = (schema as any).const;
+      const literalStr =
+        typeof literalValue === 'string' ? `'${literalValue}'` : String(literalValue);
+      const message2 = 'Expected literal value ' + String(literalStr);
+      return `${validatePrimitive(dataPath, typeof literalValue, '${message2}')}.concat(
+        ${dataPath} !== undefined && ${dataPath} !== null && ${dataPath} !== ${literalStr}
+          ? [{ path: '${dataPath}', message: '${message2}', value: ${dataPath} }]
+          : []
+      )`;
+    }
+
+    default:
+      // Unknown type - accept anything
+      return '[]';
+  }
+}
+
+/**
+ * Generate validation for object schema.
+ */
+function validateObject(schema: TSchema, dataPath: string): string {
+  const properties = (schema as any).properties || {};
+  const required = new Set((schema as any).required || []);
+
+  let code = `[]`;
+
+  // Check if data is an object
+  code = `(${dataPath} === null || ${dataPath} === undefined || typeof ${dataPath} !== 'object' || Array.isArray(${dataPath})) ? [{ path: '${dataPath}', message: 'Expected object', value: ${dataPath} }] : []`;
+
+  // Check each property
+  for (const [key, propSchema] of Object.entries(properties)) {
+    const propPath = `${dataPath}.${key}`;
+    const isRequired = required.has(key);
+
+    // Check if required field is present
+    if (isRequired) {
+      code += `.concat(
+        ${propPath} === undefined || ${propPath} === null
+          ? [{ path: '${propPath}', message: 'Required field is missing', value: undefined }]
+          : []
+      )`;
+    } else {
+      // Skip validation if optional field is missing
+      code += `.concat(
+        ${propPath} === undefined || ${propPath} === null
+          ? []
+          : ${generateSchemaValidator(propSchema as TSchema, propPath)}
+      )`;
+    }
+
+    // Validate the field if present
+    if (isRequired) {
+      code += `.concat(
+        ${propPath} !== undefined && ${propPath} !== null
+          ? ${generateSchemaValidator(propSchema as TSchema, propPath)}
+          : []
+      )`;
+    }
+  }
+
+  return code;
+}
+
+/**
+ * Generate validation for array schema.
+ */
+function validateArray(schema: TSchema, dataPath: string): string {
+  const itemsSchema = (schema as any).items;
+
+  // Check if data is an array
+  const arrayCheck = `Array.isArray(${dataPath})`;
+
+  // Validate array elements
+  if (itemsSchema) {
+    const elementValidation = `
+      ${dataPath}.reduce((errs, item, idx) => {
+        const itemPath = '${dataPath}[' + idx + ']';
+        const elementErrors = ${generateSchemaValidator(itemsSchema as TSchema, 'item')};
+        return errs.concat(elementErrors.map(e => ({
+          ...e,
+          path: itemPath
+        })));
+      }, [])
+    `;
+
+    return `(${arrayCheck} ? ${elementValidation} : [{ path: '${dataPath}', message: 'Expected array', value: ${dataPath} }])`;
+  }
+
+  return `${arrayCheck} ? [] : [{ path: '${dataPath}', message: 'Expected array', value: ${dataPath} }]`;
+}
+
+/**
+ * Generate validation for union schema.
+ */
+function validateUnion(schema: TSchema, dataPath: string): string {
+  const anyOf = (schema as any).anyOf || [];
+  if (anyOf.length === 0) {
+    return '[]';
+  }
+
+  // Generate validators for each option
+  const validators = anyOf.map((option: TSchema) => generateSchemaValidator(option, dataPath));
+
+  // Check if at least one option passes
+  return `(${dataPath} === undefined || ${dataPath} === null) ? []
+    : ${validators.join('.length === 0 || ')}.length === 0
+      ? []
+      : [{ path: '${dataPath}', message: 'Value does not match any allowed type', value: ${dataPath} }]`;
+}
+
+/**
+ * Generate validation for primitive types.
+ */
+function validatePrimitive(dataPath: string, expectedType: string, message: string): string {
+  return `(${dataPath} === undefined || ${dataPath} === null || typeof ${dataPath} !== '${expectedType}')
+    ? [{ path: '${dataPath}', message: '${message}', value: ${dataPath} }]
+    : []`;
+}

package/src/compiler/codegen.ts

@@ -0,0 +1,19 @@
+/**
+ * Code generation module for JDM decisions.
+ *
+ * This module re-exports the compilation pipeline from the orchestrator module.
+ * The actual implementation is split into focused modules:
+ * - orchestrator.ts: Main compilation pipeline coordination
+ * - result-selection.ts: Final result determination logic
+ * - switch-branch-detection.ts: Switch branch target detection algorithm
+ * - code-generators.ts: Shared code generation helpers (passThrough, outputPath, etc.)
+ */
+
+// Re-export the main compilation function for backward compatibility
+export { compileDecision } from './orchestrator';
+
+// Export result selection utilities for use by other modules
+export { isCollectStyleHitPolicy, generateResultCode } from './result-selection';
+
+// Export switch branch detection for use by other modules
+export { findSwitchBranchTargets } from './switch-branch-detection';