@divmain/jdm-asm 0.2.1 → 0.2.3

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

@@ -1,243 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * 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';