@divmain/jdm-asm 0.2.1 → 0.2.3

package/tests/unit/compiler/cache.test.ts

@@ -1,238 +0,0 @@
-/**
- * WASM Compilation Cache Tests
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  computeCacheKey,
-  readCacheFromDisk,
-  writeCacheToDisk,
-  clearCache,
-  getCacheStats,
-  isCacheEnabled,
-  getCacheDirectory,
-  getCacheHealth,
-} from '../../../src/compiler/cache';
-import { join } from 'path';
-
-describe('WASM Compilation Cache', () => {
-  const testCacheDir = join(process.cwd(), 'node_modules', '.cache', 'jdm-asm');
-
-  beforeEach(() => {
-    // Clear cache before each test
-    clearCache();
-  });
-
-  describe('computeCacheKey', () => {
-    it('should produce consistent hash for same inputs', () => {
-      const code = 'export function evaluate(): i32 { return 42; }';
-      const options = { optimize: true, debug: false };
-
-      const key1 = computeCacheKey(code, options);
-      const key2 = computeCacheKey(code, options);
-
-      expect(key1).toBe(key2);
-      expect(key1.length).toBe(32); // 128-bit hex
-    });
-
-    it('should produce different hash for different code', () => {
-      const options = { optimize: true, debug: false };
-
-      const key1 = computeCacheKey('export function a(): i32 { return 1; }', options);
-      const key2 = computeCacheKey('export function b(): i32 { return 2; }', options);
-
-      expect(key1).not.toBe(key2);
-    });
-
-    it('should produce different hash for different options', () => {
-      const code = 'export function evaluate(): i32 { return 42; }';
-
-      const key1 = computeCacheKey(code, { optimize: true, debug: false });
-      const key2 = computeCacheKey(code, { optimize: false, debug: false });
-      const key3 = computeCacheKey(code, { optimize: true, debug: true });
-
-      expect(key1).not.toBe(key2);
-      expect(key1).not.toBe(key3);
-      expect(key2).not.toBe(key3);
-    });
-  });
-
-  describe('readCacheFromDisk / writeCacheToDisk', () => {
-    it('should store and retrieve cache entry', () => {
-      const cacheKey = 'test_key_' + Date.now().toString(16);
-      const testBinary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]); // WASM magic
-      const testWat = '(module)';
-
-      writeCacheToDisk(cacheKey, { binary: testBinary, wat: testWat });
-
-      const result = readCacheFromDisk(cacheKey);
-      expect(result).not.toBeNull();
-      expect(result!.binary).toEqual(testBinary);
-      expect(result!.wat).toBe(testWat);
-    });
-  });
-
-  describe('getCacheStats', () => {
-    it('should count cache entries', () => {
-      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
-
-      writeCacheToDisk('test_key_1', { binary, wat: '(module)' });
-      writeCacheToDisk('test_key_2', { binary, wat: '(module)' });
-
-      const stats = getCacheStats();
-      expect(stats.entries).toBe(2);
-      expect(stats.totalSize).toBeGreaterThan(0);
-    });
-  });
-
-  describe('clearCache', () => {
-    it('should remove all cache entries', () => {
-      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
-
-      writeCacheToDisk('test_key_1', { binary, wat: '(module)' });
-      writeCacheToDisk('test_key_2', { binary, wat: '(module)' });
-
-      let stats = getCacheStats();
-      expect(stats.entries).toBe(2);
-
-      clearCache();
-
-      stats = getCacheStats();
-      expect(stats.entries).toBe(0);
-    });
-  });
-
-  describe('isCacheEnabled', () => {
-    it('should be enabled by default', () => {
-      const originalEnv = process.env.JDM_ASM_NO_CACHE;
-      delete process.env.JDM_ASM_NO_CACHE;
-
-      expect(isCacheEnabled()).toBe(true);
-
-      // Restore
-      if (originalEnv !== undefined) {
-        process.env.JDM_ASM_NO_CACHE = originalEnv;
-      }
-    });
-
-    it('should be disabled with JDM_ASM_NO_CACHE=1', () => {
-      const originalEnv = process.env.JDM_ASM_NO_CACHE;
-      process.env.JDM_ASM_NO_CACHE = '1';
-
-      expect(isCacheEnabled()).toBe(false);
-
-      // Restore
-      if (originalEnv !== undefined) {
-        process.env.JDM_ASM_NO_CACHE = originalEnv;
-      } else {
-        delete process.env.JDM_ASM_NO_CACHE;
-      }
-    });
-  });
-
-  describe('getCacheDirectory', () => {
-    it('should return cache directory path', () => {
-      const dir = getCacheDirectory();
-      expect(dir).toBe(testCacheDir);
-      expect(dir).toContain('node_modules/.cache/jdm-asm');
-    });
-  });
-
-  describe('getCacheHealth', () => {
-    it('should report health when cache is enabled and empty', () => {
-      const originalEnv = process.env.JDM_ASM_NO_CACHE;
-      delete process.env.JDM_ASM_NO_CACHE;
-
-      const health = getCacheHealth();
-
-      expect(health.enabled).toBe(true);
-      expect(health.directory).toBe(testCacheDir);
-      expect(health.stats.entries).toBe(0);
-
-      // Restore
-      if (originalEnv !== undefined) {
-        process.env.JDM_ASM_NO_CACHE = originalEnv;
-      }
-    });
-
-    it('should report health when cache is disabled', () => {
-      const originalEnv = process.env.JDM_ASM_NO_CACHE;
-      process.env.JDM_ASM_NO_CACHE = '1';
-
-      const health = getCacheHealth();
-
-      expect(health.enabled).toBe(false);
-      expect(health.issues).toContain(
-        'Cache is disabled via JDM_ASM_NO_CACHE environment variable',
-      );
-
-      // Restore
-      if (originalEnv !== undefined) {
-        process.env.JDM_ASM_NO_CACHE = originalEnv;
-      } else {
-        delete process.env.JDM_ASM_NO_CACHE;
-      }
-    });
-
-    it('should report stats when cache has entries', () => {
-      const originalEnv = process.env.JDM_ASM_NO_CACHE;
-      delete process.env.JDM_ASM_NO_CACHE;
-
-      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
-      writeCacheToDisk('test_key_1', { binary, wat: '(module)' });
-      writeCacheToDisk('test_key_2', { binary, wat: '(module)' });
-
-      const health = getCacheHealth();
-
-      expect(health.enabled).toBe(true);
-      expect(health.accessible).toBe(true);
-      expect(health.stats.entries).toBe(2);
-      expect(health.stats.totalSize).toBeGreaterThan(0);
-
-      // Restore
-      if (originalEnv !== undefined) {
-        process.env.JDM_ASM_NO_CACHE = originalEnv;
-      }
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle cache write failures gracefully', () => {
-      // Create console.warn spy to verify warning is logged
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
-
-      // Try to write to an invalid path by using a cache key with invalid characters
-      // This should not throw but should log a warning
-      writeCacheToDisk('/invalid:key*with?bad<chars>', { binary, wat: '(module)' });
-
-      // Note: On some systems this might actually succeed, so we don't assert on the warning
-      // The important part is that it doesn't throw
-
-      warnSpy.mockRestore();
-    });
-
-    it('should return null when reading non-existent cache file', () => {
-      const result = readCacheFromDisk('nonexistent_key_12345');
-      expect(result).toBeNull();
-    });
-
-    it('should handle corrupted cache files gracefully', () => {
-      const cacheKey = 'test_corrupted_' + Date.now().toString(16);
-
-      // Write a valid cache entry first
-      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
-      writeCacheToDisk(cacheKey, { binary, wat: '(module)' });
-
-      // Corrupt the cache file by writing invalid JSON
-      const fs = require('fs');
-      const cachePath = join(testCacheDir, `${cacheKey}.json`);
-      fs.writeFileSync(cachePath, '{ invalid json }', 'utf-8');
-
-      // Should return null and not throw
-      const result = readCacheFromDisk(cacheKey);
-      expect(result).toBeNull();
-    });
-  });
-});

package/tests/unit/compiler/errors.test.ts

@@ -1,316 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  CompilationError,
-  ErrorCode,
-  type SourceLocation,
-  ErrorCollector,
-  isCompilationError,
-  isStructuralError,
-  isFeatureError,
-  isExpressionError,
-} from '../../../src/compiler/errors';
-
-describe('Error Handling Infrastructure', () => {
-  describe('SourceLocation', () => {
-    it('should accept minimal location information', () => {
-      const location: SourceLocation = { nodeId: 'node-1' };
-      expect(location.nodeId).toBe('node-1');
-      expect(location.nodeName).toBeUndefined();
-      expect(location.line).toBeUndefined();
-    });
-
-    it('should accept complete location information', () => {
-      const location: SourceLocation = {
-        nodeId: 'node-1',
-        nodeName: 'AgeCheck',
-        field: 'expression',
-        line: 10,
-        column: 15,
-      };
-      expect(location.nodeId).toBe('node-1');
-      expect(location.nodeName).toBe('AgeCheck');
-      expect(location.field).toBe('expression');
-      expect(location.line).toBe(10);
-      expect(location.column).toBe(15);
-    });
-  });
-
-  describe('ErrorCode', () => {
-    it('should have all structural error codes', () => {
-      expect(ErrorCode.INVALID_JSON).toBe('INVALID_JSON');
-      expect(ErrorCode.MISSING_INPUT_NODE).toBe('MISSING_INPUT_NODE');
-      expect(ErrorCode.MISSING_OUTPUT_NODE).toBe('MISSING_OUTPUT_NODE');
-      expect(ErrorCode.MULTIPLE_INPUT_NODES).toBe('MULTIPLE_INPUT_NODES');
-      expect(ErrorCode.CYCLE_DETECTED).toBe('CYCLE_DETECTED');
-      expect(ErrorCode.INVALID_EDGE).toBe('INVALID_EDGE');
-    });
-
-    it('should have all feature error codes', () => {
-      expect(ErrorCode.UNSUPPORTED_FUNCTION_NODE).toBe('UNSUPPORTED_FUNCTION_NODE');
-      expect(ErrorCode.UNSUPPORTED_EXPRESSION).toBe('UNSUPPORTED_EXPRESSION');
-    });
-
-    it('should have all expression error codes', () => {
-      expect(ErrorCode.PARSE_ERROR).toBe('PARSE_ERROR');
-      expect(ErrorCode.UNKNOWN_FUNCTION).toBe('UNKNOWN_FUNCTION');
-      expect(ErrorCode.TYPE_MISMATCH).toBe('TYPE_MISMATCH');
-      expect(ErrorCode.UNKNOWN_FIELD).toBe('UNKNOWN_FIELD');
-    });
-
-    it('should have all schema error codes', () => {
-      expect(ErrorCode.SCHEMA_MISMATCH).toBe('SCHEMA_MISMATCH');
-      expect(ErrorCode.INVALID_SCHEMA).toBe('INVALID_SCHEMA');
-    });
-  });
-
-  describe('CompilationError', () => {
-    it('should create error with mandatory fields', () => {
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR);
-      expect(error.message).toBe('Test error');
-      expect(error.code).toBe(ErrorCode.PARSE_ERROR);
-      expect(error.name).toBe('CompilationError');
-      expect(error.location).toBeUndefined();
-      expect(error.context).toBeUndefined();
-    });
-
-    it('should create error with location', () => {
-      const location: SourceLocation = { nodeName: 'MyNode', line: 10, column: 5 };
-      const error = new CompilationError('Test error', ErrorCode.UNKNOWN_FIELD, location);
-      expect(error.message).toBe('Test error');
-      expect(error.code).toBe(ErrorCode.UNKNOWN_FIELD);
-      expect(error.location).toEqual(location);
-    });
-
-    it('should create error with context', () => {
-      const context = { variable: 'age', expectedType: 'number', actualType: 'string' };
-      const error = new CompilationError(
-        'Type mismatch',
-        ErrorCode.TYPE_MISMATCH,
-        undefined,
-        context,
-      );
-      expect(error.context).toEqual(context);
-    });
-
-    it('should create error with both location and context', () => {
-      const location: SourceLocation = { nodeName: 'MyNode', field: 'expression' };
-      const context = { expression: 'age + "hello"' };
-      const error = new CompilationError('Type error', ErrorCode.TYPE_MISMATCH, location, context);
-      expect(error.location).toEqual(location);
-      expect(error.context).toEqual(context);
-    });
-
-    it('should format message without location', () => {
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR);
-      expect(error.getFormattedMessage()).toBe('[PARSE_ERROR] Test error');
-    });
-
-    it('should format message with nodeName', () => {
-      const location: SourceLocation = { nodeName: 'AgeCheck' };
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
-      expect(error.getFormattedMessage()).toBe('[AgeCheck] [PARSE_ERROR] Test error');
-    });
-
-    it('should format message with nodeId', () => {
-      const location: SourceLocation = { nodeId: 'node-123' };
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
-      expect(error.getFormattedMessage()).toBe('[(id: node-123)] [PARSE_ERROR] Test error');
-    });
-
-    it('should format message with field', () => {
-      const location: SourceLocation = { nodeName: 'MyNode', field: 'condition' };
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
-      expect(error.getFormattedMessage()).toBe('[MyNode .condition] [PARSE_ERROR] Test error');
-    });
-
-    it('should format message with line and column', () => {
-      const location: SourceLocation = { line: 10, column: 5 };
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
-      expect(error.getFormattedMessage()).toBe('[@10:5] [PARSE_ERROR] Test error');
-    });
-
-    it('should format message with all location fields', () => {
-      const location: SourceLocation = {
-        nodeId: 'node-1',
-        nodeName: 'MyNode',
-        field: 'expression',
-        line: 10,
-        column: 5,
-      };
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
-      expect(error.getFormattedMessage()).toBe(
-        '[MyNode (id: node-1) .expression @10:5] [PARSE_ERROR] Test error',
-      );
-    });
-  });
-
-  describe('ErrorCollector', () => {
-    it('should start with no errors', () => {
-      const collector = new ErrorCollector();
-      expect(collector.hasErrors()).toBe(false);
-    });
-
-    it('should add single error', () => {
-      const collector = new ErrorCollector();
-      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR);
-      collector.add(error);
-
-      expect(collector.hasErrors()).toBe(true);
-    });
-
-    it('should add multiple errors', () => {
-      const collector = new ErrorCollector();
-      const error1 = new CompilationError('Error 1', ErrorCode.UNKNOWN_FIELD);
-      const error2 = new CompilationError('Error 2', ErrorCode.TYPE_MISMATCH);
-      const error3 = new CompilationError('Error 3', ErrorCode.UNKNOWN_FUNCTION);
-
-      collector.add(error1);
-      collector.add(error2);
-      collector.add(error3);
-
-      expect(collector.hasErrors()).toBe(true);
-    });
-
-    it('should not throw when throwIfErrors called with no errors', () => {
-      const collector = new ErrorCollector();
-      expect(() => collector.throwIfErrors()).not.toThrow();
-    });
-
-    it('should throw single error directly', () => {
-      const collector = new ErrorCollector();
-      const error = new CompilationError('Single error', ErrorCode.PARSE_ERROR);
-      collector.add(error);
-
-      expect(() => collector.throwIfErrors()).toThrow('Single error');
-    });
-
-    it('should throw aggregated error for multiple errors', () => {
-      const collector = new ErrorCollector();
-      collector.add(new CompilationError('Error 1', ErrorCode.UNKNOWN_FIELD));
-      collector.add(new CompilationError('Error 2', ErrorCode.TYPE_MISMATCH));
-
-      expect(() => collector.throwIfErrors()).toThrow('2 compilation errors');
-    });
-
-    it('should include all errors in aggregated message', () => {
-      const collector = new ErrorCollector();
-      collector.add(new CompilationError('First error', ErrorCode.UNKNOWN_FIELD));
-      collector.add(new CompilationError('Second error', ErrorCode.TYPE_MISMATCH));
-      collector.add(new CompilationError('Third error', ErrorCode.UNKNOWN_FUNCTION));
-
-      expect(() => collector.throwIfErrors()).toThrow();
-      try {
-        collector.throwIfErrors();
-      } catch (e) {
-        if (e instanceof CompilationError) {
-          expect(e.message).toContain('3 compilation errors');
-          expect(e.message).toContain('1. UNKNOWN_FIELD: First error');
-          expect(e.message).toContain('2. TYPE_MISMATCH: Second error');
-          expect(e.message).toContain('3. UNKNOWN_FUNCTION: Third error');
-        }
-      }
-    });
-  });
-
-  describe('isCompilationError', () => {
-    it('should return true for CompilationError instance', () => {
-      const error = new CompilationError('Test', ErrorCode.PARSE_ERROR);
-      expect(isCompilationError(error)).toBe(true);
-    });
-
-    it('should return false for regular Error', () => {
-      const error = new Error('Test');
-      expect(isCompilationError(error)).toBe(false);
-    });
-  });
-
-  describe('isStructuralError', () => {
-    it('should return true for structural error codes', () => {
-      expect(isStructuralError(ErrorCode.INVALID_JSON)).toBe(true);
-      expect(isStructuralError(ErrorCode.MISSING_INPUT_NODE)).toBe(true);
-      expect(isStructuralError(ErrorCode.MISSING_OUTPUT_NODE)).toBe(true);
-      expect(isStructuralError(ErrorCode.MULTIPLE_INPUT_NODES)).toBe(true);
-      expect(isStructuralError(ErrorCode.CYCLE_DETECTED)).toBe(true);
-      expect(isStructuralError(ErrorCode.INVALID_EDGE)).toBe(true);
-    });
-
-    it('should return false for non-structural error codes', () => {
-      expect(isStructuralError(ErrorCode.PARSE_ERROR)).toBe(false);
-      expect(isStructuralError(ErrorCode.UNKNOWN_FUNCTION)).toBe(false);
-      expect(isStructuralError(ErrorCode.TYPE_MISMATCH)).toBe(false);
-      expect(isStructuralError(ErrorCode.UNKNOWN_FIELD)).toBe(false);
-      expect(isStructuralError(ErrorCode.UNSUPPORTED_FUNCTION_NODE)).toBe(false);
-      expect(isStructuralError(ErrorCode.SCHEMA_MISMATCH)).toBe(false);
-    });
-  });
-
-  describe('isFeatureError', () => {
-    it('should return true for feature error codes', () => {
-      expect(isFeatureError(ErrorCode.UNSUPPORTED_FUNCTION_NODE)).toBe(true);
-      expect(isFeatureError(ErrorCode.UNSUPPORTED_EXPRESSION)).toBe(true);
-    });
-
-    it('should return false for non-feature error codes', () => {
-      expect(isFeatureError(ErrorCode.PARSE_ERROR)).toBe(false);
-      expect(isFeatureError(ErrorCode.INVALID_JSON)).toBe(false);
-      expect(isFeatureError(ErrorCode.SCHEMA_MISMATCH)).toBe(false);
-    });
-  });
-
-  describe('isExpressionError', () => {
-    it('should return true for expression error codes', () => {
-      expect(isExpressionError(ErrorCode.PARSE_ERROR)).toBe(true);
-      expect(isExpressionError(ErrorCode.UNKNOWN_FUNCTION)).toBe(true);
-      expect(isExpressionError(ErrorCode.TYPE_MISMATCH)).toBe(true);
-      expect(isExpressionError(ErrorCode.UNKNOWN_FIELD)).toBe(true);
-    });
-
-    it('should return false for non-expression error codes', () => {
-      expect(isExpressionError(ErrorCode.INVALID_JSON)).toBe(false);
-      expect(isExpressionError(ErrorCode.CYCLE_DETECTED)).toBe(false);
-      expect(isExpressionError(ErrorCode.UNSUPPORTED_FUNCTION_NODE)).toBe(false);
-      expect(isExpressionError(ErrorCode.SCHEMA_MISMATCH)).toBe(false);
-    });
-  });
-
-  describe('Integration: ErrorCollector workflow', () => {
-    it('should support typical expression parsing workflow', () => {
-      const collector = new ErrorCollector();
-
-      // Simulate collecting errors during parsing
-      collector.add(new CompilationError('Unknown variable', ErrorCode.UNKNOWN_FIELD));
-      collector.add(new CompilationError('Type mismatch', ErrorCode.TYPE_MISMATCH));
-
-      // Check if any errors were collected
-      expect(collector.hasErrors()).toBe(true);
-
-      // Throw all errors at once
-      expect(() => collector.throwIfErrors()).toThrow();
-      try {
-        collector.throwIfErrors();
-      } catch (e) {
-        expect(isCompilationError(e)).toBe(true);
-        if (e instanceof CompilationError) {
-          expect(e.message).toContain('2 compilation errors');
-        }
-      }
-    });
-
-    it('should support batched validation then clean throw', () => {
-      const collector = new ErrorCollector();
-
-      const location1: SourceLocation = { nodeName: 'Node1', field: 'expression' };
-      const location2: SourceLocation = { nodeName: 'Node2', field: 'expression' };
-
-      collector.add(new CompilationError('Invalid syntax', ErrorCode.PARSE_ERROR, location1));
-      collector.add(
-        new CompilationError('Unknown function', ErrorCode.UNKNOWN_FUNCTION, location2),
-      );
-
-      expect(collector.hasErrors()).toBe(true);
-
-      // Should throw with aggregated message
-      expect(() => collector.throwIfErrors()).toThrow('2 compilation errors');
-    });
-  });
-});