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

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/types.ts","../src/runtime/batch-parallel.ts","../src/runtime/checkpoint-manager.ts","../src/runtime/context.ts","../src/runtime/errors.ts","../src/runtime/index.ts","../src/runtime/resumable-arrays.ts","../src/runtime/resumable-loops.ts","../src/runtime/resumable-parallel.ts","../src/transformer/array-transformer-batch.ts","../src/transformer/array-transformer-sequential.ts","../src/transformer/array-transformer-utils.ts","../src/transformer/array-transformer-wrappers.ts","../src/transformer/array-transformer.ts","../src/transformer/batch-detector.ts","../src/transformer/batch-optimizer.ts","../src/transformer/detector.ts","../src/transformer/index.ts","../src/transformer/loop-transformer.ts","../src/transformer/promise-transformer.ts","../src/transformer/utils.ts"],"version":"5.9.3"}
+{"root":["../src/index.ts","../src/types.ts","../src/plugin-system/create-default-compiler.ts","../src/plugin-system/index.ts","../src/plugin-system/pluggable-compiler.ts","../src/plugin-system/plugin-api.ts","../src/plugin-system/default-plugins/array-transformer-plugin.ts","../src/plugin-system/default-plugins/detection-plugin.ts","../src/plugin-system/default-plugins/index.ts","../src/plugin-system/default-plugins/loop-transformer-plugin.ts","../src/plugin-system/default-plugins/promise-transformer-plugin.ts","../src/plugin-system/examples/loop-transformer-plugin.ts","../src/plugin-system/examples/security-validator-plugin.ts","../src/plugin-system/examples/timeout-plugin.ts","../src/runtime/batch-parallel.ts","../src/runtime/checkpoint-manager.ts","../src/runtime/context.ts","../src/runtime/errors.ts","../src/runtime/index.ts","../src/runtime/resumable-arrays.ts","../src/runtime/resumable-loops.ts","../src/runtime/resumable-parallel.ts","../src/transformer/array-transformer-batch.ts","../src/transformer/array-transformer-sequential.ts","../src/transformer/array-transformer-utils.ts","../src/transformer/array-transformer-wrappers.ts","../src/transformer/array-transformer.ts","../src/transformer/batch-detector.ts","../src/transformer/batch-optimizer.ts","../src/transformer/detector.ts","../src/transformer/index.ts","../src/transformer/loop-transformer.ts","../src/transformer/promise-transformer.ts","../src/transformer/utils.ts","../src/types/compiler-interface.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mondaydotcomorg/atp-compiler",
-	"version": "0.18.2",
+	"version": "0.18.4-rc.1",
 	"description": "Production-ready compiler for transforming async iteration patterns into resumable operations with checkpoint-based state management",
 	"type": "module",
 	"main": "dist/atp-compiler/src/index.js",
@@ -10,6 +10,14 @@
 			"types": "./dist/atp-compiler/src/index.d.ts",
 			"import": "./dist/atp-compiler/src/index.js"
 		},
+		"./plugin-system": {
+			"types": "./dist/atp-compiler/src/plugin-system/index.d.ts",
+			"import": "./dist/atp-compiler/src/plugin-system/index.js"
+		},
+		"./plugin-system/*": {
+			"types": "./dist/atp-compiler/src/plugin-system/*.d.ts",
+			"import": "./dist/atp-compiler/src/plugin-system/*.js"
+		},
 		"./*": {
 			"types": "./dist/atp-compiler/src/*.d.ts",
 			"import": "./dist/atp-compiler/src/*.js"
@@ -47,15 +55,15 @@
 		"@babel/parser": "^7.26.0",
 		"@babel/traverse": "^7.26.0",
 		"@babel/types": "^7.26.0",
-		"@mondaydotcomorg/atp-protocol": "0.18.2",
-		"@mondaydotcomorg/atp-runtime": "0.18.2",
+		"@mondaydotcomorg/atp-protocol": "0.18.4-rc.1",
+		"@mondaydotcomorg/atp-runtime": "0.18.4-rc.1",
 		"@types/babel__generator": "^7.6.0",
 		"@types/babel__traverse": "^7.20.0",
 		"nanoid": "^5.0.0"
 	},
 	"peerDependencies": {
-		"@mondaydotcomorg/atp-protocol": "0.18.2",
-		"@mondaydotcomorg/atp-runtime": "0.18.2"
+		"@mondaydotcomorg/atp-protocol": "0.18.4-rc.1",
+		"@mondaydotcomorg/atp-runtime": "0.18.4-rc.1"
 	},
 	"devDependencies": {
 		"@stryker-mutator/core": "^8.0.0",

package/src/index.ts

@@ -1,6 +1,32 @@
+// Core exports
 export * from './types.js';
 export * from './transformer/index.js';
 export * from './runtime/index.js';
 
+// Compiler interface exports
+export * from './types/compiler-interface.js';
+
+// Plugin system exports
+export * from './plugin-system/index.js';
+
+// Main exports
 export { ATPCompiler } from './transformer/index.js';
 export { initializeRuntime, cleanupRuntime } from './runtime/index.js';
+export { PluggableCompiler } from './plugin-system/pluggable-compiler.js';
+export { PluginRegistry } from './plugin-system/plugin-api.js';
+export { createDefaultCompiler } from './plugin-system/create-default-compiler.js';
+
+// Plugin type exports for convenience
+export type {
+	CompilerPlugin,
+	DetectionPlugin,
+	TransformationPlugin,
+	OptimizerPlugin,
+	ValidatorPlugin,
+	PluginContext,
+	BabelVisitor,
+} from './plugin-system/plugin-api.js';
+export type { ATPCompilerLike } from './plugin-system/create-default-compiler.js';
+
+// Compiler interface type exports
+export type { ICompiler, CacheStats } from './types/compiler-interface.js';

package/src/plugin-system/create-default-compiler.ts

@@ -0,0 +1,57 @@
+/**
+ * Factory function to create a PluggableCompiler with all default plugins
+ * 
+ * This makes PluggableCompiler a drop-in replacement for ATPCompiler
+ */
+
+import { PluggableCompiler } from './pluggable-compiler.js';
+import { DefaultDetectionPlugin } from './default-plugins/detection-plugin.js';
+import { DefaultLoopTransformerPlugin } from './default-plugins/loop-transformer-plugin.js';
+import { DefaultArrayTransformerPlugin } from './default-plugins/array-transformer-plugin.js';
+import { DefaultPromiseTransformerPlugin } from './default-plugins/promise-transformer-plugin.js';
+import type { CompilerConfig } from '../types.js';
+
+/**
+ * Create a PluggableCompiler with all default ATP transformations
+ * 
+ * This provides the same functionality as ATPCompiler but with plugin extensibility.
+ * 
+ * @example
+ * ```typescript
+ * // Drop-in replacement for ATPCompiler
+ * const compiler = createDefaultCompiler({
+ *     enableBatchParallel: true,
+ *     maxBatchSize: 10,
+ * });
+ * 
+ * // Works exactly like ATPCompiler
+ * const result = await compiler.transform(code);
+ * 
+ * // But you can also add custom plugins!
+ * compiler.use(myCustomPlugin);
+ * ```
+ */
+export function createDefaultCompiler(config: Partial<CompilerConfig> = {}): PluggableCompiler {
+	const compiler = new PluggableCompiler(config);
+
+	// Register default plugins that provide all ATP compiler functionality
+	compiler.use(new DefaultDetectionPlugin());
+	compiler.use(new DefaultLoopTransformerPlugin(config.batchSizeThreshold));
+	compiler.use(new DefaultArrayTransformerPlugin(config.batchSizeThreshold));
+	compiler.use(new DefaultPromiseTransformerPlugin(config.enableBatchParallel));
+
+	return compiler;
+}
+
+/**
+ * Type alias for backward compatibility
+ * 
+ * This allows:
+ * ```typescript
+ * import type { ATPCompilerLike } from '@mondaydotcomorg/atp-compiler';
+ * 
+ * const compiler: ATPCompilerLike = createDefaultCompiler();
+ * ```
+ */
+export type ATPCompilerLike = PluggableCompiler;
+

package/src/plugin-system/default-plugins/array-transformer-plugin.ts

@@ -0,0 +1,57 @@
+/**
+ * Default Array Transformer Plugin
+ * Wraps the existing ArrayTransformer
+ */
+
+import * as t from '@babel/types';
+import type { TransformationPlugin, BabelVisitor } from '../plugin-api.js';
+import type { CompilerConfig, TransformMetadata } from '../../types.js';
+import { ArrayTransformer } from '../../transformer/array-transformer.js';
+
+export class DefaultArrayTransformerPlugin implements TransformationPlugin {
+	name = 'atp-array-transformer';
+	version = '1.0.0';
+	priority = 100;
+
+	private transformer: ArrayTransformer;
+
+	constructor(batchSizeThreshold?: number) {
+		this.transformer = new ArrayTransformer(batchSizeThreshold);
+	}
+
+	getVisitor(config: CompilerConfig): BabelVisitor {
+		return {
+			CallExpression: (path: any) => {
+				const node = path.node;
+				if (this.isArrayMethodCall(node)) {
+					this.transformer.transformArrayMethod(path);
+				}
+			},
+		};
+	}
+
+	getMetadata(): Partial<TransformMetadata> {
+		return {
+			arrayMethodCount: this.transformer.getTransformCount(),
+		};
+	}
+
+	reset(): void {
+		this.transformer.resetTransformCount();
+	}
+
+	private isArrayMethodCall(node: t.CallExpression): boolean {
+		if (!t.isMemberExpression(node.callee)) {
+			return false;
+		}
+
+		const property = node.callee.property;
+		if (!t.isIdentifier(property)) {
+			return false;
+		}
+
+		const arrayMethods = ['map', 'forEach', 'filter', 'reduce', 'find', 'some', 'every', 'flatMap'];
+		return arrayMethods.includes(property.name);
+	}
+}
+

package/src/plugin-system/default-plugins/detection-plugin.ts

@@ -0,0 +1,41 @@
+/**
+ * Default Detection Plugin
+ * Wraps the existing AsyncIterationDetector
+ */
+
+import type * as t from '@babel/types';
+import type { DetectionPlugin } from '../plugin-api.js';
+import type { CompilerConfig, AsyncPattern, DetectionResult } from '../../types.js';
+import { AsyncIterationDetector } from '../../transformer/detector.js';
+
+export class DefaultDetectionPlugin implements DetectionPlugin {
+	name = 'atp-default-detector';
+	version = '1.0.0';
+	priority = 100;
+	patterns: AsyncPattern[] = [
+		'for-of-await',
+		'while-await',
+		'map-async',
+		'forEach-async',
+		'filter-async',
+		'reduce-async',
+		'find-async',
+		'some-async',
+		'every-async',
+		'flatMap-async',
+		'promise-all',
+		'promise-allSettled',
+	];
+
+	private detector: AsyncIterationDetector;
+
+	constructor() {
+		this.detector = new AsyncIterationDetector();
+	}
+
+	async detect(code: string, ast: t.File): Promise<DetectionResult> {
+		// Use existing detector
+		return this.detector.detect(code);
+	}
+}
+

package/src/plugin-system/default-plugins/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Default Plugins
+ * 
+ * These plugins wrap the existing ATP Compiler functionality,
+ * making the PluggableCompiler a drop-in replacement for ATPCompiler.
+ */
+
+export * from './detection-plugin.js';
+export * from './loop-transformer-plugin.js';
+export * from './array-transformer-plugin.js';
+export * from './promise-transformer-plugin.js';
+

package/src/plugin-system/default-plugins/loop-transformer-plugin.ts

@@ -0,0 +1,47 @@
+/**
+ * Default Loop Transformer Plugin
+ * Wraps the existing LoopTransformer
+ */
+
+import type { TransformationPlugin, BabelVisitor } from '../plugin-api.js';
+import type { CompilerConfig, TransformMetadata } from '../../types.js';
+import { LoopTransformer } from '../../transformer/loop-transformer.js';
+
+export class DefaultLoopTransformerPlugin implements TransformationPlugin {
+	name = 'atp-loop-transformer';
+	version = '1.0.0';
+	priority = 100;
+
+	private transformer: LoopTransformer;
+
+	constructor(batchSizeThreshold?: number) {
+		this.transformer = new LoopTransformer(batchSizeThreshold);
+	}
+
+	getVisitor(config: CompilerConfig): BabelVisitor {
+		return {
+			ForOfStatement: (path: any) => {
+				this.transformer.transformForOfLoop(path);
+			},
+
+			WhileStatement: (path: any) => {
+				this.transformer.transformWhileLoop(path);
+			},
+
+			ForStatement: (path: any) => {
+				this.transformer.transformForLoop(path);
+			},
+		};
+	}
+
+	getMetadata(): Partial<TransformMetadata> {
+		return {
+			loopCount: this.transformer.getTransformCount(),
+		};
+	}
+
+	reset(): void {
+		this.transformer.resetTransformCount();
+	}
+}
+

package/src/plugin-system/default-plugins/promise-transformer-plugin.ts

@@ -0,0 +1,63 @@
+/**
+ * Default Promise Transformer Plugin
+ * Wraps the existing PromiseTransformer
+ */
+
+import * as t from '@babel/types';
+import type { TransformationPlugin, BabelVisitor } from '../plugin-api.js';
+import type { CompilerConfig, TransformMetadata } from '../../types.js';
+import { PromiseTransformer } from '../../transformer/promise-transformer.js';
+
+export class DefaultPromiseTransformerPlugin implements TransformationPlugin {
+	name = 'atp-promise-transformer';
+	version = '1.0.0';
+	priority = 100;
+
+	private transformer: PromiseTransformer;
+
+	constructor(enableBatchParallel?: boolean) {
+		this.transformer = new PromiseTransformer(enableBatchParallel);
+	}
+
+	getVisitor(config: CompilerConfig): BabelVisitor {
+		return {
+			CallExpression: (path: any) => {
+				const node = path.node;
+				if (this.isPromiseAllCall(node)) {
+					this.transformer.transformPromiseAll(path);
+				} else if (this.isPromiseAllSettledCall(node)) {
+					this.transformer.transformPromiseAllSettled(path);
+				}
+			},
+		};
+	}
+
+	getMetadata(): Partial<TransformMetadata> {
+		return {
+			parallelCallCount: this.transformer.getTransformCount(),
+		};
+	}
+
+	reset(): void {
+		this.transformer.resetTransformCount();
+	}
+
+	private isPromiseAllCall(node: t.CallExpression): boolean {
+		const callee = node.callee;
+		return (
+			t.isMemberExpression(callee) &&
+			t.isIdentifier(callee.object, { name: 'Promise' }) &&
+			t.isIdentifier(callee.property, { name: 'all' })
+		);
+	}
+
+	private isPromiseAllSettledCall(node: t.CallExpression): boolean {
+		const callee = node.callee;
+		return (
+			t.isMemberExpression(callee) &&
+			t.isIdentifier(callee.object, { name: 'Promise' }) &&
+			t.isIdentifier(callee.property, { name: 'allSettled' })
+		);
+	}
+}
+

package/src/plugin-system/examples/loop-transformer-plugin.ts

@@ -0,0 +1,76 @@
+/**
+ * Example: Loop Transformer as a Plugin
+ * 
+ * Shows how to migrate existing LoopTransformer to plugin architecture
+ * This demonstrates the migration path for built-in transformers
+ */
+
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { TransformationPlugin, BabelVisitor } from '../plugin-api.js';
+import type { CompilerConfig, TransformMetadata } from '../../types.js';
+import { LoopTransformer } from '../../transformer/loop-transformer.js';
+
+/**
+ * Loop Transformer Plugin
+ * 
+ * Transforms for...of, while, and for loops into resumable versions
+ * with checkpoint-based state management
+ */
+export class LoopTransformerPlugin implements TransformationPlugin {
+	name = 'loop-transformer';
+	version = '1.0.0';
+	priority = 50; // Standard priority for core transformations
+
+	private transformer: LoopTransformer;
+
+	constructor(batchSizeThreshold: number = 10) {
+		this.transformer = new LoopTransformer(batchSizeThreshold);
+	}
+
+	initialize(config: CompilerConfig): void {
+		// Initialize with config if needed
+		console.log('[LoopTransformerPlugin] Initialized');
+	}
+
+	getVisitor(config: CompilerConfig): BabelVisitor {
+		return {
+			ForOfStatement: (path: NodePath<t.ForOfStatement>) => {
+				this.transformer.transformForOfLoop(path as any);
+			},
+
+			WhileStatement: (path: NodePath<t.WhileStatement>) => {
+				this.transformer.transformWhileLoop(path as any);
+			},
+
+			ForStatement: (path: NodePath<t.ForStatement>) => {
+				this.transformer.transformForLoop(path as any);
+			},
+		};
+	}
+
+	getMetadata(): Partial<TransformMetadata> {
+		return {
+			loopCount: this.transformer.getTransformCount(),
+			arrayMethodCount: 0,
+			parallelCallCount: 0,
+			batchableCount: 0,
+		};
+	}
+
+	reset(): void {
+		this.transformer.resetTransformCount();
+	}
+
+	dispose(): void {
+		console.log('[LoopTransformerPlugin] Disposed');
+	}
+}
+
+/**
+ * Factory function for easy creation
+ */
+export function createLoopTransformerPlugin(batchSizeThreshold?: number): LoopTransformerPlugin {
+	return new LoopTransformerPlugin(batchSizeThreshold);
+}
+

package/src/plugin-system/examples/security-validator-plugin.ts

@@ -0,0 +1,168 @@
+/**
+ * Example Plugin: Security Validator
+ * 
+ * Validates code for security issues before transformation
+ * 
+ * @example
+ * const compiler = new PluggableCompiler();
+ * compiler.use(new SecurityValidatorPlugin({
+ *   forbiddenPatterns: [/eval\s*\(/],
+ *   maxComplexity: 20
+ * }));
+ */
+
+import type * as t from '@babel/types';
+import _traverse from '@babel/traverse';
+const traverse = (_traverse as any).default || _traverse;
+import type { ValidatorPlugin } from '../plugin-api.js';
+import type { CompilerConfig } from '../../types.js';
+
+export interface SecurityValidatorOptions {
+	/**
+	 * Forbidden patterns (regex)
+	 */
+	forbiddenPatterns?: RegExp[];
+
+	/**
+	 * Maximum cyclomatic complexity
+	 */
+	maxComplexity?: number;
+
+	/**
+	 * Maximum nesting depth
+	 */
+	maxNesting?: number;
+
+	/**
+	 * Forbidden global access
+	 */
+	forbiddenGlobals?: string[];
+}
+
+export class SecurityValidatorPlugin implements ValidatorPlugin {
+	name = 'security-validator';
+	version = '1.0.0';
+	priority = 100; // Run first
+
+	private options: SecurityValidatorOptions;
+
+	constructor(options: SecurityValidatorOptions = {}) {
+		this.options = {
+			forbiddenPatterns: options.forbiddenPatterns || [
+				/\beval\s*\(/,
+				/new\s+Function\s*\(/,
+				/constructor\s*\[\s*['"`]constructor['"`]\s*\]/,
+			],
+			maxComplexity: options.maxComplexity || 50,
+			maxNesting: options.maxNesting || 10,
+			forbiddenGlobals: options.forbiddenGlobals || [
+				'process',
+				'require',
+				'__dirname',
+				'__filename',
+			],
+		};
+	}
+
+	async validate(code: string, ast: t.File, phase: 'pre' | 'post'): Promise<void> {
+		// Only validate before transformation
+		if (phase === 'post') {
+			return;
+		}
+
+		// 1. Check forbidden patterns
+		for (const pattern of this.options.forbiddenPatterns!) {
+			if (pattern.test(code)) {
+				throw new SecurityValidationError(
+					`Forbidden pattern detected: ${pattern}`,
+					'forbidden-pattern'
+				);
+			}
+		}
+
+		// 2. Check complexity and nesting
+		let maxNestingFound = 0;
+		let complexityScore = 0;
+
+		traverse(ast, {
+			enter(path: any) {
+				const depth = path.scope.path.node ? getDepth(path) : 0;
+				maxNestingFound = Math.max(maxNestingFound, depth);
+
+				// Increment complexity for control flow
+				if (
+					path.isIfStatement() ||
+					path.isWhileStatement() ||
+					path.isForStatement() ||
+					path.isForOfStatement() ||
+					path.isSwitchCase() ||
+					path.isCatchClause()
+				) {
+					complexityScore++;
+				}
+			},
+
+			// 3. Check forbidden globals
+			Identifier: (path: any) => {
+				if (
+					this.options.forbiddenGlobals!.includes(path.node.name) &&
+					!path.scope.hasBinding(path.node.name)
+				) {
+					throw new SecurityValidationError(
+						`Access to forbidden global: ${path.node.name}`,
+						'forbidden-global'
+					);
+				}
+			},
+		});
+
+		if (maxNestingFound > this.options.maxNesting!) {
+			throw new SecurityValidationError(
+				`Maximum nesting depth exceeded: ${maxNestingFound} > ${this.options.maxNesting}`,
+				'max-nesting'
+			);
+		}
+
+		if (complexityScore > this.options.maxComplexity!) {
+			throw new SecurityValidationError(
+				`Maximum complexity exceeded: ${complexityScore} > ${this.options.maxComplexity}`,
+				'max-complexity'
+			);
+		}
+	}
+}
+
+/**
+ * Security validation error
+ */
+export class SecurityValidationError extends Error {
+	constructor(
+		message: string,
+		public code: string
+	) {
+		super(message);
+		this.name = 'SecurityValidationError';
+	}
+}
+
+/**
+ * Get nesting depth of a path
+ */
+function getDepth(path: any): number {
+	let depth = 0;
+	let current = path;
+
+	while (current.parentPath) {
+		if (
+			current.isBlockStatement() ||
+			current.isFunctionDeclaration() ||
+			current.isArrowFunctionExpression()
+		) {
+			depth++;
+		}
+		current = current.parentPath;
+	}
+
+	return depth;
+}
+