@savvy-web/github-action-builder 0.7.4 → 0.7.6

package/github-action.js

@@ -0,0 +1,302 @@
+import { BuildResultSchema, BuildService } from "./services/build.js";
+import { defineConfig } from "./schemas/config.js";
+import { ConfigService } from "./services/config.js";
+import { PersistLocalResultSchema, PersistLocalService } from "./services/persist-local.js";
+import { ValidationResultSchema, ValidationService } from "./services/validation.js";
+import { AppLayer } from "./layers/app.js";
+import { Effect, ManagedRuntime, Schema } from "effect";
+
+//#region src/github-action.ts
+/**
+* Result of a GitHubAction build operation.
+*
+* @remarks
+* The result contains detailed information about both validation and build steps.
+* Check the `success` property first, then examine `error`, `validation`, or `build`
+* for details.
+*
+* @internal
+*/
+const GitHubActionBuildResultSchema = Schema.Struct({
+	/** Whether the build completed successfully. */
+	success: Schema.Boolean,
+	/** Build result details if the build step ran. */
+	build: Schema.optional(BuildResultSchema),
+	/** Validation result if validation was performed. */
+	validation: Schema.optional(ValidationResultSchema),
+	/** Persist-local result if persist was performed. */
+	persistLocal: Schema.optional(PersistLocalResultSchema),
+	/** Error message if the build or validation failed. */
+	error: Schema.optional(Schema.String),
+	/** Raw error object for programmatic inspection. */
+	cause: Schema.optional(Schema.Unknown)
+});
+/**
+* Main API class for building GitHub Actions.
+*
+* @remarks
+* This class provides a Promise-based interface wrapping Effect services.
+* It handles configuration loading, validation, and bundling in a single workflow.
+*
+* For Effect consumers, use the services directly:
+* - {@link ConfigService} for configuration
+* - {@link ValidationService} for validation
+* - {@link BuildService} for building
+*
+* @example Complete build workflow
+* ```typescript
+* import { GitHubAction } from "@savvy-web/github-action-builder";
+*
+* async function buildAction(): Promise<void> {
+*   const action = GitHubAction.create();
+*   const result = await action.build();
+*
+*   if (result.success) {
+*     console.log(`Built ${result.build?.entries.length} entry points`);
+*   } else {
+*     console.error(`Build failed: ${result.error}`);
+*     process.exit(1);
+*   }
+* }
+*
+* buildAction();
+* ```
+*
+* @example With custom configuration
+* ```typescript
+* import { GitHubAction } from "@savvy-web/github-action-builder";
+*
+* async function main(): Promise<void> {
+*   const action = GitHubAction.create({
+*     config: {
+*       entries: { main: "src/action.ts" },
+*       build: { minify: true },
+*     },
+*     cwd: "/path/to/project",
+*   });
+*
+*   const result = await action.build();
+*   console.log(result.success ? "Success" : result.error);
+* }
+*
+* main();
+* ```
+*
+* @public
+*/
+var GitHubAction = class GitHubAction {
+	/**
+	* Managed runtime for running Effects.
+	* @internal
+	*/
+	runtime;
+	/**
+	* Cached configuration after first load.
+	* @internal
+	*/
+	config = null;
+	/**
+	* Resolved options.
+	* @internal
+	*/
+	cwd;
+	configSource;
+	skipValidation;
+	clean;
+	constructor(options = {}) {
+		const layer = options.layer ?? AppLayer;
+		this.runtime = ManagedRuntime.make(layer);
+		this.configSource = options.config;
+		this.cwd = options.cwd ?? process.cwd();
+		this.skipValidation = options.skipValidation ?? false;
+		this.clean = options.clean ?? true;
+	}
+	/**
+	* Create a new GitHubAction builder instance.
+	*
+	* @param options - Builder options
+	* @returns A new GitHubAction instance
+	*
+	* @example
+	* ```typescript
+	* import { GitHubAction } from "@savvy-web/github-action-builder";
+	*
+	* // Auto-detect configuration
+	* const action = GitHubAction.create();
+	*
+	* // With inline config
+	* const action2 = GitHubAction.create({
+	*   config: { build: { minify: false } },
+	* });
+	*
+	* // With config file path
+	* const action3 = GitHubAction.create({
+	*   config: "./custom.config.ts",
+	* });
+	* ```
+	*/
+	static create(options = {}) {
+		return new GitHubAction(options);
+	}
+	/**
+	* Load and resolve configuration.
+	*
+	* @remarks
+	* Configuration is cached after the first load. Subsequent calls
+	* return the cached configuration.
+	*
+	* @returns Resolved configuration with all defaults applied
+	* @throws Error if configuration file cannot be loaded or is invalid
+	*/
+	async loadConfig() {
+		if (this.config) return this.config;
+		const configSource = this.configSource;
+		const cwd = this.cwd;
+		const program = Effect.gen(function* () {
+			const configService = yield* ConfigService;
+			/* v8 ignore next 6 - requires config file path string */
+			if (typeof configSource === "string") return (yield* configService.load({
+				cwd,
+				configPath: configSource
+			})).config;
+			if (configSource) return defineConfig(configSource);
+			return (yield* configService.load({ cwd })).config;
+		});
+		const config = await this.runtime.runPromise(program);
+		this.config = config;
+		return config;
+	}
+	/**
+	* Validate the action configuration and action.yml.
+	*
+	* @remarks
+	* Validation checks:
+	* - Entry point files exist
+	* - Output directory is writable
+	* - action.yml exists and is valid (if required)
+	*
+	* In CI environments, warnings are treated as errors by default.
+	*
+	* @param options - Validation options
+	* @returns Validation result with errors and warnings
+	*/
+	async validate(options = {}) {
+		const config = await this.loadConfig();
+		const cwd = this.cwd;
+		const program = Effect.gen(function* () {
+			return yield* (yield* ValidationService).validate(config, {
+				cwd,
+				...options
+			});
+		});
+		return this.runtime.runPromise(program);
+	}
+	/**
+	* Build the GitHub Action.
+	*
+	* @remarks
+	* The build process:
+	* 1. Loads configuration (if not already loaded)
+	* 2. Validates the project (unless `skipValidation` is set)
+	* 3. Bundles each entry point with rsbuild
+	* 4. Writes output to the `dist/` directory
+	*
+	* @returns Build result with success status and details
+	*
+	* @example
+	* ```typescript
+	* import { GitHubAction } from "@savvy-web/github-action-builder";
+	*
+	* async function main(): Promise<void> {
+	*   const action = GitHubAction.create();
+	*   const result = await action.build();
+	*
+	*   if (result.success && result.build) {
+	*     console.log(`Built ${result.build.entries.length} entries`);
+	*   } else {
+	*     console.error(result.error);
+	*   }
+	* }
+	*
+	* main();
+	* ```
+	*/
+	/* v8 ignore start - build execution requires actual rsbuild bundling */
+	async build() {
+		try {
+			const config = await this.loadConfig();
+			let validationResult;
+			if (!this.skipValidation) {
+				validationResult = await this.validate();
+				if (!validationResult.valid) return {
+					success: false,
+					validation: validationResult,
+					error: "Validation failed"
+				};
+			}
+			const cwd = this.cwd;
+			const clean = this.clean;
+			const program = Effect.gen(function* () {
+				const buildService = yield* BuildService;
+				const buildOptions = {
+					cwd,
+					clean
+				};
+				return yield* buildService.build(config, buildOptions);
+			});
+			const buildResult = await this.runtime.runPromise(program);
+			if (!buildResult.success) {
+				if (validationResult) return {
+					success: false,
+					build: buildResult,
+					validation: validationResult,
+					error: buildResult.error ?? "Build failed"
+				};
+				return {
+					success: false,
+					build: buildResult,
+					error: buildResult.error ?? "Build failed"
+				};
+			}
+			let persistLocalResult;
+			if (config.persistLocal.enabled) {
+				const persistProgram = Effect.gen(function* () {
+					return yield* (yield* PersistLocalService).persist(config, { cwd });
+				});
+				persistLocalResult = await this.runtime.runPromise(persistProgram);
+			}
+			if (validationResult) return {
+				success: true,
+				build: buildResult,
+				validation: validationResult,
+				persistLocal: persistLocalResult
+			};
+			return {
+				success: true,
+				build: buildResult,
+				persistLocal: persistLocalResult
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error",
+				cause: error
+			};
+		}
+	}
+	/* v8 ignore stop */
+	/**
+	* Dispose the runtime and release resources.
+	*
+	* @remarks
+	* Call this when you're done using the GitHubAction instance
+	* to clean up any resources held by the Effect runtime.
+	*/
+	/* v8 ignore next 3 - cleanup method */
+	async dispose() {
+		await this.runtime.dispose();
+	}
+};
+
+//#endregion
+export { GitHubAction, GitHubActionBuildResultSchema };