@mondaydotcomorg/atp-compiler 0.18.2 → 0.18.4-rc.1

package/src/plugin-system/examples/timeout-plugin.ts

@@ -0,0 +1,158 @@
+/**
+ * Example Plugin: Async Timeout Wrapper
+ * 
+ * Automatically wraps await expressions with timeout protection
+ * 
+ * @example
+ * // Before:
+ * const result = await fetch('https://api.example.com');
+ * 
+ * // After:
+ * const result = await Promise.race([
+ *   fetch('https://api.example.com'),
+ *   new Promise((_, reject) => 
+ *     setTimeout(() => reject(new Error('Timeout')), 5000)
+ *   )
+ * ]);
+ */
+
+import * as t from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+import type { TransformationPlugin, BabelVisitor } from '../plugin-api.js';
+import type { CompilerConfig, TransformMetadata } from '../../types.js';
+
+export interface TimeoutPluginOptions {
+	/**
+	 * Default timeout in milliseconds
+	 */
+	timeout?: number;
+
+	/**
+	 * Patterns to match (namespace.method)
+	 */
+	patterns?: string[];
+
+	/**
+	 * Whether to add timeout to all await expressions
+	 */
+	wrapAll?: boolean;
+}
+
+export class AsyncTimeoutPlugin implements TransformationPlugin {
+	name = 'async-timeout';
+	version = '1.0.0';
+	priority = 40; // Run after main transformations
+
+	private options: TimeoutPluginOptions;
+	private transformCount = 0;
+
+	constructor(options: TimeoutPluginOptions = {}) {
+		this.options = {
+			timeout: options.timeout || 5000,
+			patterns: options.patterns || ['fetch', 'axios.*', 'http.*'],
+			wrapAll: options.wrapAll || false,
+		};
+	}
+
+	getVisitor(config: CompilerConfig): BabelVisitor {
+		return {
+			AwaitExpression: (path: NodePath<t.AwaitExpression>) => {
+				// Check if should wrap this await
+				if (!this.shouldWrap(path.node.argument)) {
+					return;
+				}
+
+				// Create timeout promise
+				const timeoutPromise = t.newExpression(
+					t.identifier('Promise'),
+					[
+						t.arrowFunctionExpression(
+							[t.identifier('_'), t.identifier('reject')],
+							t.blockStatement([
+								t.expressionStatement(
+									t.callExpression(t.identifier('setTimeout'), [
+										t.arrowFunctionExpression(
+											[],
+											t.callExpression(t.identifier('reject'), [
+												t.newExpression(t.identifier('Error'), [
+													t.stringLiteral(
+														`Timeout after ${this.options.timeout}ms`
+													),
+												]),
+											])
+										),
+										t.numericLiteral(this.options.timeout!),
+									])
+								),
+							])
+						),
+					]
+				);
+
+				// Wrap in Promise.race
+				const raceCall = t.callExpression(
+					t.memberExpression(t.identifier('Promise'), t.identifier('race')),
+					[t.arrayExpression([path.node.argument, timeoutPromise])]
+				);
+
+				// Replace await expression
+				path.node.argument = raceCall;
+				this.transformCount++;
+			},
+		};
+	}
+
+	getMetadata(): Partial<TransformMetadata> {
+		return {
+			// Custom metadata
+			loopCount: 0,
+			arrayMethodCount: 0,
+			parallelCallCount: this.transformCount,
+			batchableCount: 0,
+		};
+	}
+
+	reset(): void {
+		this.transformCount = 0;
+	}
+
+	/**
+	 * Check if this await should be wrapped with timeout
+	 */
+	private shouldWrap(node: t.Expression): boolean {
+		if (this.options.wrapAll) {
+			return true;
+		}
+
+		// Check if matches patterns
+		if (t.isCallExpression(node)) {
+			const funcName = this.getFunctionName(node);
+			if (funcName) {
+				return this.options.patterns!.some((pattern) => {
+					const regex = new RegExp(pattern.replace('*', '.*'));
+					return regex.test(funcName);
+				});
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Get function name from call expression
+	 */
+	private getFunctionName(node: t.CallExpression): string | null {
+		if (t.isIdentifier(node.callee)) {
+			return node.callee.name;
+		}
+
+		if (t.isMemberExpression(node.callee)) {
+			const obj = t.isIdentifier(node.callee.object) ? node.callee.object.name : '';
+			const prop = t.isIdentifier(node.callee.property) ? node.callee.property.name : '';
+			return `${obj}.${prop}`;
+		}
+
+		return null;
+	}
+}
+

package/src/plugin-system/index.ts

@@ -0,0 +1,19 @@
+/**
+ * check 
+ * 
+ * ATP Compiler Plugin System
+ * 
+ * Extensible plugin architecture for custom transformations
+ */
+
+export * from './plugin-api.js';
+export * from './pluggable-compiler.js';
+export * from './create-default-compiler.js';
+
+// Default plugins
+export * from './default-plugins/index.js';
+
+// Re-export examples for convenience
+export * from './examples/timeout-plugin.js';
+export * from './examples/security-validator-plugin.js';
+

package/src/plugin-system/pluggable-compiler.ts

@@ -0,0 +1,318 @@
+/**
+ * Plugin-based ATP Compiler
+ * 
+ * Extensible compiler that supports custom plugins for detection,
+ * transformation, optimization, and validation
+ */
+
+import { parse } from '@babel/parser';
+import _traverse from '@babel/traverse';
+const traverse = (_traverse as any).default || _traverse;
+import _generate from '@babel/generator';
+const generate = (_generate as any).default || _generate;
+import type * as t from '@babel/types';
+import type { TransformResult, CompilerConfig, TransformMetadata, DetectionResult } from '../types.js';
+import { DEFAULT_COMPILER_CONFIG } from '../types.js';
+import { TransformationError } from '../runtime/errors.js';
+import { resetIdCounter } from '../runtime/context.js';
+import { PluginRegistry, type CompilerPlugin, type PluginContext } from './plugin-api.js';
+import type { ICompiler } from '../types/compiler-interface.js';
+
+/**
+ * Plugin-based ATP Compiler
+ * 
+ * @example
+ * ```typescript
+ * const compiler = new PluggableCompiler({
+ *   enableBatchParallel: true
+ * });
+ * 
+ * // Register custom plugin
+ * compiler.use(myCustomPlugin);
+ * 
+ * // Transform code
+ * const result = compiler.transform(code);
+ * ```
+ */
+export class PluggableCompiler implements ICompiler {
+	private config: CompilerConfig;
+	private registry: PluginRegistry;
+	private initialized: boolean = false;
+	
+	/**
+	 * AST cache - maps code string to parsed AST
+	 * This avoids re-parsing the same code multiple times
+	 * (e.g., once in detect() and once in transform())
+	 * 
+	 * Performance Impact: ~30% reduction in compile time
+	 */
+	private astCache: Map<string, t.File> = new Map();
+
+	constructor(config: Partial<CompilerConfig> = {}) {
+		this.config = { ...DEFAULT_COMPILER_CONFIG, ...config };
+		this.registry = new PluginRegistry();
+	}
+
+	/**
+	 * Register a plugin (chainable)
+	 */
+	use(plugin: CompilerPlugin): this {
+		this.registry.register(plugin);
+		return this;
+	}
+
+	/**
+	 * Unregister a plugin by name
+	 */
+	remove(pluginName: string): boolean {
+		return this.registry.unregister(pluginName);
+	}
+
+	/**
+	 * Initialize all plugins
+	 */
+	async initialize(): Promise<void> {
+		if (this.initialized) return;
+		await this.registry.initializeAll(this.config);
+		this.initialized = true;
+	}
+
+	/**
+	 * Detect patterns using all detection plugins
+	 */
+	async detect(code: string): Promise<DetectionResult> {
+		if (!this.initialized) {
+			await this.initialize();
+		}
+
+		try {
+			const ast = this.parseCode(code);
+			const detectors = this.registry.getDetectors();
+
+			// Aggregate results from all detectors
+			const allPatterns = new Set<string>();
+			let batchableParallel = false;
+
+			for (const detector of detectors) {
+				const result = await detector.detect(code, ast);
+				result.patterns.forEach((p) => allPatterns.add(p));
+				if (result.batchableParallel) {
+					batchableParallel = true;
+				}
+			}
+
+			return {
+				needsTransform: allPatterns.size > 0,
+				patterns: Array.from(allPatterns) as any[],
+				batchableParallel,
+			};
+		} catch (error) {
+			return {
+				needsTransform: false,
+				patterns: [],
+				batchableParallel: false,
+			};
+		}
+	}
+
+	/**
+	 * Transform code using all transformation plugins
+	 */
+	async transform(code: string): Promise<TransformResult> {
+		if (!this.initialized) {
+			await this.initialize();
+		}
+
+		resetIdCounter();
+
+		// 1. Pre-validation
+		await this.runValidation(code, 'pre');
+
+		// 2. Detection
+		const detection = await this.detect(code);
+
+		if (!detection.needsTransform) {
+			return {
+				code,
+				transformed: false,
+				patterns: [],
+				metadata: {
+					loopCount: 0,
+					arrayMethodCount: 0,
+					parallelCallCount: 0,
+					batchableCount: 0,
+				},
+			};
+		}
+
+		try {
+			// 3. Parse AST
+			const ast = this.parseCode(code);
+
+			// 4. Reset all transformers
+			const transformers = this.registry.getTransformers();
+			for (const transformer of transformers) {
+				transformer.reset();
+			}
+
+			// 5. Apply all transformation visitors
+			// Combine visitors from all plugins, merging handlers for the same node type
+			const visitors: any = {};
+			for (const transformer of transformers) {
+				const visitor = transformer.getVisitor(this.config);
+				
+				// Merge visitors, combining multiple handlers for the same node type
+				for (const [nodeType, handler] of Object.entries(visitor)) {
+					if (!visitors[nodeType]) {
+						visitors[nodeType] = handler;
+					} else {
+						// Combine multiple handlers for the same node type
+						const existing = visitors[nodeType];
+						visitors[nodeType] = (path: any) => {
+							existing(path);
+							(handler as any)(path);
+						};
+					}
+				}
+			}
+
+			traverse(ast, visitors);
+
+			// 6. Optimization
+			let optimizedAst = ast;
+			const optimizers = this.registry.getOptimizers();
+			for (const optimizer of optimizers) {
+				optimizedAst = await optimizer.optimize(optimizedAst, this.config);
+			}
+
+			// 7. Generate code
+			const output = generate(optimizedAst, {
+				sourceMaps: false,
+				retainLines: true,
+				comments: true,
+			});
+
+			// 8. Aggregate metadata
+			const metadata: TransformMetadata = {
+				loopCount: 0,
+				arrayMethodCount: 0,
+				parallelCallCount: 0,
+				batchableCount: detection.batchableParallel ? 1 : 0,
+			};
+
+			for (const transformer of transformers) {
+				const pluginMetadata = transformer.getMetadata();
+				metadata.loopCount += pluginMetadata.loopCount || 0;
+				metadata.arrayMethodCount += pluginMetadata.arrayMethodCount || 0;
+				metadata.parallelCallCount += pluginMetadata.parallelCallCount || 0;
+				metadata.batchableCount += pluginMetadata.batchableCount || 0;
+			}
+
+			// 9. Post-validation
+			await this.runValidation(output.code, 'post');
+
+			return {
+				code: output.code,
+				transformed: true,
+				patterns: detection.patterns,
+				metadata,
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			// Include context about which phase failed
+			const context = detection.patterns.length > 0 
+				? `[Plugin transformation] ${message}` 
+				: message;
+			throw new TransformationError(context, code, 'plugin-error');
+		}
+	}
+
+	/**
+	 * Dispose compiler and all plugins
+	 */
+	async dispose(): Promise<void> {
+		await this.registry.disposeAll();
+		this.astCache.clear(); // Clear cache on disposal
+		this.initialized = false;
+	}
+
+	/**
+	 * Get current configuration
+	 */
+	getConfig(): CompilerConfig {
+		return { ...this.config };
+	}
+
+	/**
+	 * Update configuration
+	 */
+	setConfig(config: Partial<CompilerConfig>): void {
+		this.config = { ...this.config, ...config };
+	}
+
+	/**
+	 * Parse code to AST with caching
+	 * 
+	 * Caches parsed AST to avoid re-parsing the same code multiple times.
+	 * This provides ~30% performance improvement when detect() and transform()
+	 * are called on the same code.
+	 */
+	private parseCode(code: string): t.File {
+		// Check cache first
+		const cached = this.astCache.get(code);
+		if (cached) {
+			return cached;
+		}
+
+		// Parse and cache
+		const ast = parse(code, {
+			sourceType: 'module',
+			plugins: ['typescript'],
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+		}) as t.File;
+
+		this.astCache.set(code, ast);
+		return ast;
+	}
+
+	/**
+	 * Clear AST cache
+	 * 
+	 * Call this method to free memory if you've compiled many different code snippets.
+	 * The cache is automatically managed and uses Map, so old entries don't leak memory.
+	 */
+	clearCache(): void {
+		this.astCache.clear();
+	}
+
+	/**
+	 * Get the compiler type identifier (ICompiler interface requirement)
+	 */
+	getType(): string {
+		return 'PluggableCompiler';
+	}
+
+	/**
+	 * Get cache statistics (for debugging/monitoring)
+	 */
+	getCacheStats(): { size: number; enabled: boolean } {
+		return {
+			size: this.astCache.size,
+			enabled: true,
+		};
+	}
+
+	/**
+	 * Run validators
+	 */
+	private async runValidation(code: string, phase: 'pre' | 'post'): Promise<void> {
+		const validators = this.registry.getValidators();
+		const ast = this.parseCode(code);
+
+		for (const validator of validators) {
+			await validator.validate(code, ast, phase);
+		}
+	}
+}
+