@chainlink/cre-sdk 0.0.0 → 0.0.1-alpha

package/scripts/src/compile-all-standard-tests.ts

@@ -0,0 +1,81 @@
+// compile-all-standard-tests.ts
+import path from 'node:path'
+import fg from 'fast-glob'
+import { main as compileWorkflow } from './compile-workflow'
+
+/** Mirror the input file under .temp/<original path> and swap extension to .wasm */
+export function toTempMirrorWasmPath(inputPath: string) {
+	const resolved = path.resolve(inputPath)
+	const relFromCwd = path.relative(process.cwd(), resolved)
+	const pathParts = relFromCwd.split(path.sep)
+	const filteredParts = pathParts.filter((part) => part !== 'src')
+	const mirrored = path.join('.temp', ...filteredParts)
+	return mirrored.replace(/\.[^.]+$/, '.wasm')
+}
+
+export const main = async (baseDir?: string, pattern?: string) => {
+	// CLI fallback: bun test:standard:compile:all [baseDir] [pattern]
+	const args = process.argv.slice(3)
+	const root = baseDir ?? args[0] ?? 'src/standard_tests'
+	const glob = pattern ?? args[1] ?? '**/test.ts'
+
+	console.info('🚀 Compiling all standard tests...\n')
+	console.info(`📂 Root:    ${path.resolve(root)}`)
+	console.info(`🔎 Pattern: ${glob}\n`)
+
+	// Find all test.ts files
+	const files = await fg(`${root.replace(/\\/g, '/')}/${glob}`, { dot: false })
+
+	if (files.length === 0) {
+		console.error('❌ No standard test files found')
+		process.exit(1)
+	}
+
+	console.info(`📋 Found ${files.length} test(s):`)
+	for (const f of files) console.info(`   • ${f}`)
+	console.info('')
+
+	let success = 0
+	let failed = 0
+	const failures: string[] = []
+
+	// Sequential for readable logs (switch to Promise.allSettled for parallel if desired)
+	for (const testPath of files) {
+		const rel = path.relative(process.cwd(), testPath)
+		const wasmOut = toTempMirrorWasmPath(testPath)
+
+		try {
+			console.info(`🔨 Compiling: ${rel}`)
+			console.info(`   → Output:  ${path.relative(process.cwd(), wasmOut)}`)
+			await compileWorkflow(testPath, wasmOut)
+			console.info(`✅ Success:   ${rel}\n`)
+			success++
+		} catch (err) {
+			console.error(`❌ Failed:    ${rel}`)
+			console.error(`   Error: ${err}\n`)
+			failed++
+			failures.push(rel)
+		}
+	}
+
+	// Summary
+	console.info('📊 Compilation Summary:')
+	console.info(`   ✅ Successful: ${success}`)
+	console.info(`   ❌ Failed:     ${failed}`)
+
+	if (failures.length > 0) {
+		console.info('   Failed tests:')
+		for (const f of failures) console.info(`   • ${f}`)
+		process.exit(1)
+	}
+
+	console.info(`\n🎉 All ${success} standard tests compiled successfully!`)
+}
+
+// Allow direct CLI usage
+if (import.meta.main) {
+	main().catch((e) => {
+		console.error(e)
+		process.exit(1)
+	})
+}

package/scripts/src/compile-to-js.ts

@@ -0,0 +1,57 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { $ } from 'bun'
+
+export const main = async (tsFilePath?: string, outputFilePath?: string) => {
+	const cliArgs = process.argv.slice(3)
+
+	// Prefer function params, fallback to CLI args
+	const inputPath = tsFilePath ?? cliArgs[0]
+	const outputPathArg = outputFilePath ?? cliArgs[1]
+
+	if (!inputPath) {
+		console.error('Usage: bun test:standard:compile:js <path-to-file> [output-file]')
+		console.error('Example:')
+		console.error('  bun test:standard:compile:js src/tests/foo.ts dist/tests/foo.bundle.js')
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+	console.info(`📁 Using input file: ${resolvedInput}`)
+
+	// If no explicit output path → same dir, swap extension to .js
+	const resolvedOutput =
+		outputPathArg != null
+			? path.resolve(outputPathArg)
+			: path.join(
+					path.dirname(resolvedInput),
+					path.basename(resolvedInput).replace(/\.[^.]+$/, '.js'),
+				)
+
+	// Ensure the output directory exists
+	await mkdir(path.dirname(resolvedOutput), { recursive: true })
+
+	// Build step (emit next to output file, then overwrite)
+	await Bun.build({
+		entrypoints: [resolvedInput],
+		outdir: path.dirname(resolvedOutput),
+		target: 'node',
+		format: 'esm',
+		naming: path.basename(resolvedOutput),
+	})
+
+	// The file Bun will emit before bundling
+	const builtFile = path.join(path.dirname(resolvedOutput), path.basename(resolvedOutput))
+
+	if (!existsSync(builtFile)) {
+		console.error(`❌ Expected file not found: ${builtFile}`)
+		process.exit(1)
+	}
+
+	// Bundle into the final file (overwrite)
+	await $`bun build ${builtFile} --bundle --outfile=${resolvedOutput}`
+
+	console.info(`✅ Built: ${resolvedOutput}`)
+	return resolvedOutput
+}

package/scripts/src/compile-to-wasm.ts

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { $ } from 'bun'
+
+const isJsFile = (p: string) => ['.js', '.mjs', '.cjs'].includes(path.extname(p).toLowerCase())
+
+export const main = async (inputFile?: string, outputFile?: string) => {
+	const cliArgs = process.argv.slice(3)
+
+	// Resolve input/output from params or CLI
+	const inputPath = inputFile ?? cliArgs[0]
+	const outputPathArg = outputFile ?? cliArgs[1]
+
+	if (!inputPath) {
+		console.error(
+			'Usage: bun compile:js-to-wasm <path/to/input.(js|mjs|cjs)> [path/to/output.wasm]',
+		)
+		console.error('Examples:')
+		console.error('  bun compile:js-to-wasm ./build/workflows/test.js')
+		console.error('  bun compile:js-to-wasm ./build/workflows/test.mjs ./artifacts/test.wasm')
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+
+	if (!isJsFile(resolvedInput)) {
+		console.error('❌ Input must be a JavaScript file (.js, .mjs, or .cjs)')
+		process.exit(1)
+	}
+	if (!existsSync(resolvedInput)) {
+		console.error(`❌ File not found: ${resolvedInput}`)
+		process.exit(1)
+	}
+
+	// Default output = same dir, same basename, .wasm extension
+	const defaultOut = path.join(
+		path.dirname(resolvedInput),
+		path.basename(resolvedInput).replace(/\.(m|c)?js$/i, '.wasm'),
+	)
+	const resolvedOutput = outputPathArg ? path.resolve(outputPathArg) : defaultOut
+
+	// Ensure output directory exists
+	await mkdir(path.dirname(resolvedOutput), { recursive: true })
+
+	console.info(`🔨 Compiling to WASM`)
+	console.info(`📁 Input:  ${resolvedInput}`)
+	console.info(`🎯 Output: ${resolvedOutput}`)
+
+	// Run compilation
+	try {
+		await $`bun cre-compile-workflow ${resolvedInput} ${resolvedOutput}`
+	} catch {
+		// Use npm script which has the correct path setup
+		await $`bun --bun ../cre-sdk-javy-plugin/bin/compile-workflow.ts ${resolvedInput} ${resolvedOutput}`
+	}
+
+	console.info(`✅ Compiled: ${resolvedOutput}`)
+
+	return resolvedOutput
+}

package/scripts/src/compile-workflow.ts

@@ -0,0 +1,66 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { main as compileToJs } from './compile-to-js'
+import { main as compileToWasm } from './compile-to-wasm'
+
+export const main = async (inputFile?: string, outputWasmFile?: string) => {
+	const cliArgs = process.argv.slice(3)
+
+	// Resolve input/output from params or CLI
+	const inputPath = inputFile ?? cliArgs[0]
+	const outputPathArg = outputWasmFile ?? cliArgs[1]
+
+	if (!inputPath) {
+		console.error('Usage: bun compile:workflow <path/to/workflow.ts> [path/to/output.wasm]')
+		console.error('Examples:')
+		console.error('  bun compile:workflow src/standard_tests/secrets/test.ts')
+		console.error(
+			'  bun compile:workflow src/standard_tests/secrets/test.ts .temp/standard_tests/secrets/test.wasm',
+		)
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+	if (!existsSync(resolvedInput)) {
+		console.error(`❌ File not found: ${resolvedInput}`)
+		process.exit(1)
+	}
+
+	// Default final output = same dir, same basename, .wasm
+	const defaultWasmOut = path.join(
+		path.dirname(resolvedInput),
+		path.basename(resolvedInput).replace(/\.[^.]+$/, '.wasm'),
+	)
+	const resolvedWasmOutput = outputPathArg ? path.resolve(outputPathArg) : defaultWasmOut
+
+	// Put the intermediate JS next to the final wasm (so custom outputs stay together)
+	const resolvedJsOutput = resolvedWasmOutput.replace(/\.wasm$/i, '.js')
+
+	// Ensure directories exist (handles both intermediate JS dir and wasm dir)
+	await mkdir(path.dirname(resolvedJsOutput), { recursive: true })
+
+	console.info(`🚀 Compiling workflow`)
+	console.info(`📁 Input:   ${resolvedInput}`)
+	console.info(`🧪 JS out:  ${resolvedJsOutput}`)
+	console.info(`🎯 WASM out:${resolvedWasmOutput}\n`)
+
+	// Step 1: TS/JS → JS (bundled)
+	console.info('📦 Step 1: Compiling JS...')
+	await compileToJs(resolvedInput, resolvedJsOutput)
+
+	// Step 2: JS → WASM
+	console.info('\n🔨 Step 2: Compiling to WASM...')
+	await compileToWasm(resolvedJsOutput, resolvedWasmOutput)
+
+	console.info(`\n✅ Workflow built: ${resolvedWasmOutput}`)
+	return resolvedWasmOutput
+}
+
+// Optional: allow direct CLI usage
+if (import.meta.main) {
+	main().catch((e) => {
+		console.error(e)
+		process.exit(1)
+	})
+}

package/scripts/src/fix-imports.ts

@@ -0,0 +1,39 @@
+import { glob } from 'fast-glob'
+import { readFile, writeFile } from 'fs/promises'
+import { dirname, join, relative } from 'path'
+
+const fixImports = async () => {
+	console.log('🔧 Fixing @cre/* imports in built files...')
+
+	// Find all .js and .d.ts files in dist
+	const files = await glob(['dist/**/*.js', 'dist/**/*.d.ts'], {
+		cwd: process.cwd(),
+		absolute: true,
+	})
+
+	let fixedCount = 0
+
+	for (const file of files) {
+		const content = await readFile(file, 'utf-8')
+
+		// Replace @cre/* imports with relative paths
+		const fixedContent = content.replace(/@cre\/([^'"]*)/g, (_, path) => {
+			// Convert @cre/sdk/utils to relative path from current file
+			const currentDir = dirname(file)
+			const targetPath = join(process.cwd(), 'dist', path)
+			const relativePath = relative(currentDir, targetPath)
+
+			// Ensure it starts with ./ or ../
+			return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+		})
+
+		if (fixedContent !== content) {
+			await writeFile(file, fixedContent)
+			fixedCount++
+		}
+	}
+
+	console.log(`✅ Fixed imports in ${fixedCount} files`)
+}
+
+export const main = fixImports