@savvy-web/github-action-builder 2.1.1 → 2.2.0

package/services/build-live.js

@@ -1,282 +0,0 @@
-import { BundleFailed, CleanError, WriteError } from "../errors.js";
-import { BuildService } from "./build.js";
-import { ConfigService } from "./config.js";
-import { buildNativeDynamicImportRules } from "./native-dynamic-imports.js";
-import { Effect, Layer, Result } from "effect";
-import { existsSync, mkdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createRsbuild } from "@rsbuild/core";
-
-//#region src/services/build-live.ts
-/* v8 ignore start - build service requires actual bundling for integration testing */
-/**
-* BuildService Layer implementation.
-*
-*/
-/**
-* Source of the stub module that replaces packages listed in `build.ignore`.
-* It is bundled in place of the real module and throws if ever loaded.
-*/
-const IGNORE_STUB_SOURCE = `throw new Error("A module excluded via the build 'ignore' option was loaded at runtime.");\n`;
-/**
-* Self-referencing specifier for the `webpackIgnore`-injecting loader
-* shipped from `public/loaders/webpack-ignore-dynamic-imports.cjs` (see
-* `package.json` `exports`). Resolved through the package's own `exports`
-* map via `import.meta.resolve`, which stays correct whether this module is
-* running from `src` (the map points at `./public/loaders/...`) or from a
-* built `dist` (the map points at the flattened `./loaders/...`, since the
-* `public/` copy step drops the `public/` prefix both on disk and in the
-* built manifest) — no relative-path assumption needed either way.
-*/
-const WEBPACK_IGNORE_LOADER_SPECIFIER = "@savvy-web/github-action-builder/loaders/webpack-ignore-dynamic-imports.cjs";
-/**
-* Resolve the absolute on-disk path to the `webpackIgnore`-injecting loader.
-*/
-function resolveWebpackIgnoreLoaderPath() {
-	return fileURLToPath(import.meta.resolve(WEBPACK_IGNORE_LOADER_SPECIFIER));
-}
-/**
-* Format bytes as a human-readable string.
-*/
-function formatBytes(bytes) {
-	if (bytes < 1024) return `${bytes} B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-/**
-* Format build result for terminal output.
-*/
-/* v8 ignore start - formatting function tested via integration */
-function formatBuildResult(result) {
-	const lines = [];
-	if (result.success) {
-		lines.push("Build Summary:");
-		for (const entry of result.entries) if (entry.success && entry.stats) {
-			const { entry: name, size, duration, outputPath } = entry.stats;
-			lines.push(`  ✓ ${name}: ${formatBytes(size)} (${duration}ms) → ${outputPath}`);
-		}
-		lines.push(`\nTotal time: ${result.duration}ms`);
-	} else {
-		lines.push("Build Failed:");
-		for (const entry of result.entries) if (!entry.success) lines.push(`  ✗ ${entry.error}`);
-	}
-	return lines.join("\n");
-}
-/* v8 ignore stop */
-/**
-* Clean output directory.
-*/
-function cleanDirectory(dir) {
-	return Effect.try({
-		try: () => {
-			if (existsSync(dir)) rmSync(dir, {
-				recursive: true,
-				force: true
-			});
-		},
-		/* v8 ignore next 5 - error branch requires fs permission failures */
-		catch: (error) => new CleanError({
-			directory: dir,
-			cause: error
-		})
-	});
-}
-/**
-* Write file with directory creation.
-*/
-function writeFile(path, content) {
-	return Effect.try({
-		try: () => {
-			mkdirSync(resolve(path, ".."), { recursive: true });
-			writeFileSync(path, content, "utf8");
-		},
-		/* v8 ignore next 5 - error branch requires fs permission failures */
-		catch: (error) => new WriteError({
-			path,
-			cause: error
-		})
-	});
-}
-/**
-* Fold an extracted `*.LICENSE.txt` sidecar back into its bundle.
-*
-* `legalComments: "linked"` is the only mode whose extraction actually sees
-* bundled license banners — the "inline" mode's SWC comment-preservation path
-* never receives them and silently drops attribution (verified against
-* rsbuild 2.1.8). A committed action still must not carry sidecar files
-* (issue #94), so the sidecar's verbatim comment blocks replace the
-* `LICENSE:` reference banner in the bundle and the sidecar is deleted —
-* attribution inline, no extra dist file.
-*/
-function inlineLicenseSidecar(outputPath) {
-	return Effect.try({
-		try: () => {
-			const sidecarPath = `${outputPath}.LICENSE.txt`;
-			if (!existsSync(sidecarPath)) return;
-			const licenses = readFileSync(sidecarPath, "utf8").trim();
-			const bundle = readFileSync(outputPath, "utf8");
-			const reference = `/*! LICENSE: ${basename(sidecarPath)} */`;
-			const afterReference = bundle.startsWith(reference) && bundle.charAt(reference.length) === "\n" ? reference.length + 1 : bundle.startsWith(reference) ? reference.length : 0;
-			writeFileSync(outputPath, `${licenses}\n${bundle.slice(afterReference)}`, "utf8");
-			unlinkSync(sidecarPath);
-		},
-		/* v8 ignore next 5 - error branch requires fs permission failures */
-		catch: (error) => new WriteError({
-			path: outputPath,
-			cause: error
-		})
-	});
-}
-/**
-* Bundle a single entry with rsbuild.
-*/
-/* v8 ignore start - bundling requires actual rsbuild execution */
-function bundleEntry(entry, config, cwd) {
-	return Effect.gen(function* () {
-		const startTime = Date.now();
-		const outputDir = resolve(cwd, "dist");
-		const externalsSet = new Set(config.build.externals);
-		const ignoreSet = new Set(config.build.ignore);
-		const ignoreAlias = {};
-		// webpackIgnore-injecting loader below leaves those calls as native
-		const nativeDynamicImportRules = config.build.nativeDynamicImports.length > 0 ? buildNativeDynamicImportRules(config.build.nativeDynamicImports, resolveWebpackIgnoreLoaderPath()) : [];
-		if (config.build.ignore.length > 0) {
-			const stubPath = resolve(cwd, "node_modules", ".cache", "github-action-builder", "ignore-stub.mjs");
-			yield* writeFile(stubPath, IGNORE_STUB_SOURCE);
-			for (const moduleName of config.build.ignore) ignoreAlias[`${moduleName}$`] = stubPath;
-		}
-		const rsbuild = yield* Effect.tryPromise({
-			try: () => createRsbuild({ rsbuildConfig: {
-				mode: "production",
-				source: { entry: { [entry.type]: entry.path } },
-				resolve: { alias: ignoreAlias },
-				output: {
-					target: "node",
-					module: true,
-					distPath: { root: outputDir },
-					filename: { js: "[name].js" },
-					externals: (data) => {
-						const request = data.request;
-						if (!request) return false;
-						if (request.startsWith("node:")) return `node-commonjs ${request}`;
-						if (externalsSet.has(request) && !ignoreSet.has(request)) return request;
-						return false;
-					},
-					cleanDistPath: false,
-					legalComments: "linked",
-					minify: config.build.minify,
-					sourceMap: config.build.sourceMap ? { js: "source-map" } : false
-				},
-				performance: { chunkSplit: { strategy: "all-in-one" } },
-				tools: { rspack: {
-					node: {
-						__dirname: "node-module",
-						__filename: "node-module"
-					},
-					module: {
-						parser: { javascript: { importMeta: false } },
-						// webpackIgnore-injecting loader (empty when the option is unset).
-						rules: nativeDynamicImportRules
-					},
-					output: { asyncChunks: false }
-				} }
-			} }),
-			catch: (error) => new BundleFailed({
-				entry: entry.path,
-				cause: error
-			})
-		});
-		const buildResult = yield* Effect.tryPromise({
-			try: () => rsbuild.build(),
-			catch: (error) => new BundleFailed({
-				entry: entry.path,
-				cause: error
-			})
-		});
-		yield* Effect.tryPromise({
-			try: () => buildResult.close(),
-			catch: (error) => new BundleFailed({
-				entry: entry.path,
-				cause: /* @__PURE__ */ new Error(`rsbuild close() failed: ${error}`)
-			})
-		});
-		const outputPath = resolve(outputDir, `${entry.type}.js`);
-		yield* inlineLicenseSidecar(outputPath);
-		const size = yield* Effect.try({
-			try: () => statSync(outputPath).size,
-			catch: (error) => new BundleFailed({
-				entry: entry.path,
-				cause: error
-			})
-		});
-		const duration = Date.now() - startTime;
-		return {
-			success: true,
-			stats: {
-				entry: entry.type,
-				size,
-				duration,
-				outputPath: entry.output
-			}
-		};
-	});
-}
-/* v8 ignore stop */
-/**
-* Live implementation of BuildService.
-*
-* @remarks
-* Uses rsbuild for bundling.
-*/
-const BuildServiceLive = Layer.effect(BuildService, Effect.gen(function* () {
-	const configService = yield* ConfigService;
-	return {
-		/* v8 ignore start - build execution requires actual rsbuild bundling */
-		build: (config, options = {}) => Effect.gen(function* () {
-			const cwd = options.cwd ?? process.cwd();
-			const shouldClean = options.clean ?? true;
-			const startTime = Date.now();
-			const entriesConfig = { main: config.entries.main };
-			if (config.entries.pre) entriesConfig.pre = config.entries.pre;
-			if (config.entries.post) entriesConfig.post = config.entries.post;
-			if (config.entries.workers) entriesConfig.workers = config.entries.workers;
-			const entriesResult = yield* configService.detectEntries(cwd, entriesConfig);
-			if (shouldClean) yield* cleanDirectory(resolve(cwd, "dist"));
-			const entryResults = [];
-			for (const entry of entriesResult.entries) {
-				const result = yield* Effect.result(bundleEntry(entry, config, cwd));
-				if (Result.isFailure(result)) {
-					const err = result.failure;
-					entryResults.push({
-						success: false,
-						error: err.cause instanceof Error ? err.cause.message : String(err.cause)
-					});
-				} else entryResults.push(result.success);
-			}
-			yield* writeFile(resolve(cwd, "dist/package.json"), "{ \"type\": \"module\" }");
-			const duration = Date.now() - startTime;
-			const success = entryResults.every((r) => r.success);
-			if (!success) return {
-				success,
-				entries: entryResults,
-				duration,
-				error: "One or more entries failed to build"
-			};
-			return {
-				success,
-				entries: entryResults,
-				duration
-			};
-		}),
-		/* v8 ignore stop */
-		bundle: (entry, config) => bundleEntry(entry, config, process.cwd()),
-		clean: (outputDir) => cleanDirectory(outputDir),
-		formatResult: formatBuildResult,
-		formatBytes
-	};
-}));
-/* v8 ignore stop */
-
-//#endregion
-export { BuildServiceLive };

package/services/config-live.js

@@ -1,138 +0,0 @@
-import { ConfigInvalid, ConfigLoadFailed, ConfigNotFound, MainEntryMissing, WorkerEntryInvalidName, WorkerEntryMissing } from "../errors.js";
-import { defineConfig } from "../schemas/config.js";
-import { ConfigService } from "./config.js";
-import { Effect, Layer } from "effect";
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { createJiti } from "jiti";
-
-//#region src/services/config-live.ts
-/**
-* ConfigService Layer implementation.
-*
-*/
-const CONFIG_FILENAMES = [
-	"action.config.ts",
-	"action.config.js",
-	"action.config.mjs"
-];
-const DEFAULT_ENTRIES = {
-	main: "src/main.ts",
-	pre: "src/pre.ts",
-	post: "src/post.ts"
-};
-/** Lifecycle bundle names a worker entry must not reuse — they own `dist/main.js` etc. */
-const RESERVED_ENTRY_NAMES = /* @__PURE__ */ new Set([
-	"main",
-	"pre",
-	"post"
-]);
-/**
-* Find config file in the given directory.
-*/
-function findConfigFile(cwd) {
-	for (const filename of CONFIG_FILENAMES) {
-		const configPath = resolve(cwd, filename);
-		if (existsSync(configPath)) return configPath;
-	}
-}
-/**
-* Detect a single optional entry.
-*/
-function detectOptionalEntry(cwd, type, explicitPath) {
-	const defaultPath = DEFAULT_ENTRIES[type];
-	const absolutePath = resolve(cwd, explicitPath ?? defaultPath);
-	if (existsSync(absolutePath)) return {
-		type,
-		path: absolutePath,
-		output: `dist/${type}.js`
-	};
-}
-/**
-* Live implementation of ConfigService.
-*/
-const ConfigServiceLive = Layer.succeed(ConfigService, {
-	load: (options = {}) => Effect.gen(function* () {
-		const cwd = options.cwd ?? process.cwd();
-		const configPath = options.configPath ?? findConfigFile(cwd);
-		if (!configPath) return {
-			config: defineConfig({}),
-			usingDefaults: true
-		};
-		/* v8 ignore start - requires explicit configPath to non-existent file */
-		if (!existsSync(configPath)) return yield* Effect.fail(new ConfigNotFound({
-			path: configPath,
-			message: "Specified config file does not exist"
-		}));
-		/* v8 ignore stop */
-		const absolutePath = resolve(cwd, configPath);
-		/* v8 ignore stop */
-		const configInput = (yield* Effect.tryPromise({
-			try: async () => {
-				if (absolutePath.endsWith(".ts")) return createJiti(absolutePath, { interopDefault: true }).import(absolutePath);
-				return import(absolutePath);
-			},
-			catch: (error) => new ConfigLoadFailed({
-				path: configPath,
-				cause: error
-			})
-		})).default;
-		/* v8 ignore start - requires config file with non-object default export */
-		if (!configInput || typeof configInput !== "object") return yield* Effect.fail(new ConfigInvalid({
-			path: configPath,
-			errors: ["Config file must export a default configuration object"]
-		}));
-		return {
-			config: defineConfig(configInput),
-			configPath,
-			usingDefaults: false
-		};
-	}),
-	resolve: (input = {}) => Effect.succeed(defineConfig(input)),
-	detectEntries: (cwd, entries) => Effect.gen(function* () {
-		const detected = [];
-		const mainPath = entries?.main ?? DEFAULT_ENTRIES.main;
-		const absoluteMainPath = resolve(cwd, mainPath);
-		if (!existsSync(absoluteMainPath)) return yield* Effect.fail(new MainEntryMissing({
-			expectedPath: mainPath,
-			cwd
-		}));
-		detected.push({
-			type: "main",
-			path: absoluteMainPath,
-			output: "dist/main.js"
-		});
-		const preEntry = detectOptionalEntry(cwd, "pre", entries?.pre);
-		if (preEntry) detected.push(preEntry);
-		const postEntry = detectOptionalEntry(cwd, "post", entries?.post);
-		if (postEntry) detected.push(postEntry);
-		for (const [name, workerPath] of Object.entries(entries?.workers ?? {})) {
-			if (RESERVED_ENTRY_NAMES.has(name)) return yield* Effect.fail(new WorkerEntryInvalidName({
-				workerName: name,
-				reason: `"${name}" is a reserved lifecycle bundle name (main/pre/post)`
-			}));
-			if (name.length === 0 || name.includes("/") || name.includes("\\") || name.includes("..")) return yield* Effect.fail(new WorkerEntryInvalidName({
-				workerName: name,
-				reason: "worker names must be non-empty and free of path separators"
-			}));
-			const absoluteWorkerPath = resolve(cwd, workerPath);
-			if (!existsSync(absoluteWorkerPath)) return yield* Effect.fail(new WorkerEntryMissing({
-				workerName: name,
-				expectedPath: workerPath,
-				cwd
-			}));
-			detected.push({
-				type: name,
-				path: absoluteWorkerPath,
-				output: `dist/${name}.js`
-			});
-		}
-		return {
-			success: true,
-			entries: detected
-		};
-	})
-});
-
-//#endregion
-export { ConfigServiceLive };

package/services/persist-local-live.js

@@ -1,211 +0,0 @@
-import { ActionYmlPathError, PersistLocalError } from "../errors.js";
-import { PersistLocalService } from "./persist-local.js";
-import { Effect, Layer } from "effect";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-import { createHash } from "node:crypto";
-import { Yaml } from "@effected/yaml";
-
-//#region src/services/persist-local-live.ts
-/**
-* PersistLocalService Layer implementation.
-*
-*/
-/**
-* Compute SHA-256 hash of a file's contents.
-*/
-function fileHash(filePath) {
-	const content = readFileSync(filePath);
-	return createHash("sha256").update(content).digest("hex");
-}
-/**
-* Sync a single file from src to dest using hash comparison.
-* Returns true if the file was copied, false if skipped.
-*/
-function syncFile(src, dest) {
-	if (existsSync(dest)) {
-		if (fileHash(src) === fileHash(dest)) return false;
-	}
-	mkdirSync(dirname(dest), { recursive: true });
-	copyFileSync(src, dest);
-	return true;
-}
-/**
-* Recursively collect all file paths relative to a base directory.
-*/
-function walkDirectory(dir, base = dir) {
-	const files = [];
-	if (!existsSync(dir)) return files;
-	for (const entry of readdirSync(dir, { withFileTypes: true })) {
-		const fullPath = join(dir, entry.name);
-		if (entry.isDirectory()) files.push(...walkDirectory(fullPath, base));
-		else files.push(relative(base, fullPath));
-	}
-	return files;
-}
-/**
-* Smart-sync a directory: copy changed files, remove stale dest files.
-*/
-function syncDirectory(srcDir, destDir) {
-	const stats = {
-		copied: 0,
-		skipped: 0
-	};
-	const srcFiles = walkDirectory(srcDir);
-	for (const relPath of srcFiles) if (syncFile(join(srcDir, relPath), join(destDir, relPath))) stats.copied++;
-	else stats.skipped++;
-	const srcFileSet = new Set(srcFiles);
-	const destFiles = walkDirectory(destDir);
-	for (const relPath of destFiles) if (!srcFileSet.has(relPath)) {
-		rmSync(join(destDir, relPath), { force: true });
-		let parent = dirname(join(destDir, relPath));
-		while (parent !== destDir && existsSync(parent)) if (readdirSync(parent).length === 0) {
-			rmSync(parent, { recursive: true });
-			parent = dirname(parent);
-		} else break;
-	}
-	return stats;
-}
-/**
-* Validate that action.yml runs paths resolve correctly relative to the destination.
-*/
-function validateActionYmlPaths(actionYmlPath, destDir) {
-	return Effect.gen(function* () {
-		if (!existsSync(actionYmlPath)) return;
-		const content = readFileSync(actionYmlPath, "utf8");
-		const parsed = yield* Yaml.parse(content).pipe(Effect.catch(() => Effect.succeed(null)));
-		if (!parsed?.runs) return;
-		for (const entryType of [
-			"main",
-			"pre",
-			"post"
-		]) {
-			const specifiedPath = parsed.runs[entryType];
-			if (!specifiedPath) continue;
-			const expectedPath = resolve(destDir, specifiedPath);
-			if (!existsSync(expectedPath)) return yield* Effect.fail(new ActionYmlPathError({
-				entryType,
-				specifiedPath,
-				expectedPath
-			}));
-		}
-	});
-}
-const ACTRC_CONTENT = `--container-architecture linux/amd64
--W .github/workflows/act-test.yml
-`;
-const ACT_WORKFLOW_CONTENT = `name: Local Test
-on:
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - uses: ./.github/actions/local
-`;
-function formatPersistResult(result) {
-	const lines = [];
-	if (result.success) {
-		lines.push("Persist Local Summary:");
-		lines.push(`  Output: ${result.outputPath}`);
-		lines.push(`  Files copied: ${result.filesCopied}`);
-		lines.push(`  Files skipped (unchanged): ${result.filesSkipped}`);
-		if (result.actTemplateGenerated) lines.push("  Act template files generated");
-	} else lines.push(`Persist Local Failed: ${result.error}`);
-	return lines.join("\n");
-}
-/**
-* Live implementation of PersistLocalService.
-*/
-const PersistLocalServiceLive = Layer.succeed(PersistLocalService, {
-	persist: (config, options = {}) => Effect.gen(function* () {
-		const cwd = options.cwd ?? process.cwd();
-		const outputPath = resolve(cwd, config.persistLocal.path);
-		if (!config.persistLocal.enabled) return {
-			success: true,
-			filesCopied: 0,
-			filesSkipped: 0,
-			actTemplateGenerated: false,
-			outputPath
-		};
-		yield* Effect.try({
-			try: () => mkdirSync(outputPath, { recursive: true }),
-			/* v8 ignore next 5 - error branch requires fs permission failures */
-			catch: (error) => new PersistLocalError({
-				path: outputPath,
-				cause: error
-			})
-		});
-		let totalCopied = 0;
-		let totalSkipped = 0;
-		const actionYmlSrc = resolve(cwd, "action.yml");
-		const actionYmlDest = resolve(outputPath, "action.yml");
-		if (existsSync(actionYmlSrc)) if (yield* Effect.try({
-			try: () => syncFile(actionYmlSrc, actionYmlDest),
-			/* v8 ignore next 5 - error branch requires fs permission failures */
-			catch: (error) => new PersistLocalError({
-				path: actionYmlSrc,
-				cause: error
-			})
-		})) totalCopied++;
-		else totalSkipped++;
-		else if (existsSync(actionYmlDest)) rmSync(actionYmlDest, { force: true });
-		const distSrc = resolve(cwd, "dist");
-		if (existsSync(distSrc) && statSync(distSrc).isDirectory()) {
-			const distStats = yield* Effect.try({
-				try: () => syncDirectory(distSrc, resolve(outputPath, "dist")),
-				/* v8 ignore next 5 - error branch requires fs permission failures */
-				catch: (error) => new PersistLocalError({
-					path: distSrc,
-					cause: error
-				})
-			});
-			totalCopied += distStats.copied;
-			totalSkipped += distStats.skipped;
-		}
-		yield* validateActionYmlPaths(resolve(outputPath, "action.yml"), outputPath);
-		let actTemplateGenerated = false;
-		if (config.persistLocal.actTemplate) {
-			const actrcPath = resolve(cwd, ".actrc");
-			const actWorkflowPath = resolve(cwd, ".github/workflows/act-test.yml");
-			if (!existsSync(actrcPath)) {
-				yield* Effect.try({
-					try: () => writeFileSync(actrcPath, ACTRC_CONTENT, "utf8"),
-					/* v8 ignore next 5 - error branch requires fs permission failures */
-					catch: (error) => new PersistLocalError({
-						path: actrcPath,
-						cause: error
-					})
-				});
-				actTemplateGenerated = true;
-			}
-			if (!existsSync(actWorkflowPath)) {
-				yield* Effect.try({
-					try: () => {
-						mkdirSync(dirname(actWorkflowPath), { recursive: true });
-						writeFileSync(actWorkflowPath, ACT_WORKFLOW_CONTENT, "utf8");
-					},
-					/* v8 ignore next 5 - error branch requires fs permission failures */
-					catch: (error) => new PersistLocalError({
-						path: actWorkflowPath,
-						cause: error
-					})
-				});
-				actTemplateGenerated = true;
-			}
-		}
-		return {
-			success: true,
-			filesCopied: totalCopied,
-			filesSkipped: totalSkipped,
-			actTemplateGenerated,
-			outputPath
-		};
-	}),
-	formatResult: formatPersistResult
-});
-
-//#endregion
-export { PersistLocalServiceLive };