asphodelos 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Console, Effect, FileSystem, Option, Schema, Stream } from "effect";
+import path, { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Argument, CliError, Command, Flag } from "effect/unstable/cli";
+//#region src/cli/index.ts
+const COMMAND_NAME = "asphodelos";
+/** Config file `asphodelos` picks up from the working directory when `--config` is omitted. */
+const DEFAULT_CONFIG_FILE = "asphodelos.config.ts";
+/** Extensions a change has to carry to be worth regenerating for. */
+const INPUT_EXTENSIONS = [
+	".yaml",
+	".json",
+	".tsp"
+];
+const DocumentPathSchema = Schema.String.pipe(Schema.refine(Schema.is(Schema.TemplateLiteral([Schema.String, Schema.Literals(INPUT_EXTENSIONS)])), { message: "an OpenAPI (.yaml, .json) or TypeSpec (.tsp) document" }));
+const TypeScriptPathSchema = Schema.String.pipe(Schema.refine(Schema.is(Schema.TemplateLiteral([Schema.String, ".ts"])), { message: "a TypeScript file path ending in .ts" }));
+/**
+* The command line itself: what `asphodelos` accepts, what each piece means, and the schema every
+* value is decoded through before {@link generate} ever sees it.
+*/
+const commandLine = {
+	input: Argument.file("input", { mustExist: true }).pipe(Argument.withSchema(DocumentPathSchema), Argument.withDescription("OpenAPI (.yaml, .json) or TypeSpec (.tsp) document to generate from"), Argument.withMetavar("input.{yaml,json,tsp}"), Argument.optional),
+	output: Flag.string("output").pipe(Flag.withAlias("o"), Flag.withSchema(TypeScriptPathSchema), Flag.withDescription("TypeScript file the generated app is written to"), Flag.withMetavar("output.ts"), Flag.optional),
+	config: Flag.file("config", { mustExist: true }).pipe(Flag.withAlias("c"), Flag.withDescription(`Config file to run (default: ./${DEFAULT_CONFIG_FILE})`), Flag.withMetavar("file"), Flag.optional),
+	watch: Flag.boolean("watch").pipe(Flag.withAlias("w"), Flag.withDescription("Rerun the config on every change to its documents or itself"), Flag.withDefault(false))
+};
+/**
+* One pass over a config file: read it, parse the document it names, and run every generator it
+* opts into.
+*
+* `reload` is for the passes after the first, where the config file may have been edited since it
+* was imported.
+*
+* The generator pipeline pulls in the OpenAPI parser, the TypeSpec compiler and ts-morph.
+* `--help`, `--version`, `--completions` and every rejected command line must not pay for that,
+* so it is loaded here rather than at module scope. After the first pass the loader answers from
+* cache, so a watch tick pays nothing.
+*/
+function runConfigPass(configPath, reload) {
+	return Effect.gen(function* () {
+		const [{ readConfig }, { parseOpenAPI }, { FormatOptions }, { cleanSplitOutputs, makeJob }] = yield* Effect.promise(() => Promise.all([
+			import("./index.mjs"),
+			import("./openapi-B4aAnx4P.mjs").then((n) => n.t),
+			import("./format-B0W7HIAg.mjs").then((n) => n.r),
+			import("./shared-CrbXsFUJ.mjs").then((n) => n.a)
+		]));
+		const config = yield* readConfig(configPath, reload);
+		const jobs = makeJob(yield* parseOpenAPI(config.input), config);
+		yield* cleanSplitOutputs(jobs);
+		return {
+			config,
+			report: (yield* Effect.all(jobs.map((job) => job.run(job.output)), { concurrency: "unbounded" }).pipe(Effect.provideService(FormatOptions, config.format ?? {}))).filter((message) => message !== "").join("\n")
+		};
+	});
+}
+/**
+* A pass whose failure is printed rather than raised, so the watch loop survives it, and which
+* answers with the input directory the config now names.
+*
+* `undefined` means the pass did not get far enough to say — the config is missing, will not
+* import, or does not validate. The loop keeps watching the config either way.
+*/
+function reportConfigPass(configPath, reload) {
+	return Effect.gen(function* () {
+		const result = yield* Effect.result(runConfigPass(configPath, reload));
+		if (result._tag === "Failure") {
+			yield* Console.error(`❌ ${result.failure.message}`);
+			return;
+		}
+		yield* Console.log(result.success.report);
+		return path.dirname(resolve(process.cwd(), result.success.config.input));
+	});
+}
+/**
+* Waits for the first change worth regenerating for.
+*
+* `runHead` is what ends the wait: it takes the first change that survives the filter and the
+* debounce, then tears the stream down, so the next round can watch wherever the reloaded config
+* points. Changes are debounced because one save is several filesystem events — an editor writes,
+* renames and touches — and a round per event would race itself.
+*
+* `WatchEvent.path` is relative to the directory it came from, which is why each stream is
+* filtered after being resolved back to an absolute path.
+*/
+function awaitChange(configPath, inputDirectory) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const stream = [path.dirname(configPath), ...inputDirectory === void 0 ? [] : [inputDirectory]].filter((directory, index, all) => all.indexOf(directory) === index).map((directory) => Stream.map(fs.watch(directory), (event) => path.resolve(directory, event.path))).reduce((merged, next) => Stream.merge(merged, next));
+		yield* Stream.runHead(Stream.debounce(Stream.filter(stream, (changed) => changed === configPath || INPUT_EXTENSIONS.some((extension) => changed.endsWith(extension))), "200 millis"));
+	});
+}
+/**
+* Regenerates on every change to the input documents or the config, until interrupted.
+*
+* Two things can invalidate the output, so both are watched: the config file, and the directory
+* the document it names lives in — a TypeSpec entry imports its siblings and a `$ref` can point
+* at one, so the file named by `input` is rarely the only one that matters. The config file is
+* watched through its directory rather than directly, so an editor that saves by renaming does
+* not take the watcher down with it.
+*
+* Recursive rather than a loop because the directory to watch comes from the config, and the
+* config is re-read every round: an edit that repoints `input` elsewhere has to move the watcher
+* with it, which means new streams rather than new values.
+*/
+function watchConfig(configPath, inputDirectory) {
+	return Effect.gen(function* () {
+		yield* Console.log(inputDirectory === void 0 ? `\n👀 Watching ${configPath} — Ctrl-C to stop` : `\n👀 Watching ${inputDirectory} and ${configPath} — Ctrl-C to stop`);
+		yield* awaitChange(configPath, inputDirectory);
+		return yield* watchConfig(configPath, yield* reportConfigPass(configPath, true));
+	});
+}
+/**
+* Everything the command does once the command line has parsed.
+*
+* It resolves to one of two modes and nothing else: an `<input>` with an `-o` writes a single app
+* from a single document, and anything else runs a config file — which is what opts in the
+* components, eden, types, test, mock and client-hook generators. `--config` and `<input>` are
+* mutually exclusive, and each of `<input>` / `--output` is meaningless without the other.
+*
+* Everything past the guard clauses fails with something carrying a `message`, so the single
+* `mapError` at the end is where all of it turns into rendered CLI output.
+*/
+function generate(args) {
+	return Effect.gen(function* () {
+		const input = Option.getOrUndefined(args.input);
+		const output = Option.getOrUndefined(args.output);
+		const configPath = Option.getOrUndefined(args.config);
+		const reject = (message) => new CliError.ShowHelp({
+			commandPath: [COMMAND_NAME],
+			errors: [new CliError.UserError({
+				cause: new Error(message),
+				userMessage: message
+			})]
+		});
+		if (configPath !== void 0 && (input !== void 0 || output !== void 0)) return yield* reject("--config cannot be combined with <input> or --output. A config file already names its own input and outputs.");
+		if (input !== void 0 && output === void 0) return yield* reject("<input> requires -o <output.ts>.");
+		if (output !== void 0 && input === void 0) return yield* reject("-o <output.ts> requires an <input> document.");
+		if (args.watch && (input !== void 0 || output !== void 0)) return yield* reject("--watch runs a config file, so it cannot be combined with <input> or --output.");
+		if (input !== void 0 && output !== void 0) {
+			const [{ parseOpenAPI }, { elysia }] = yield* Effect.promise(() => Promise.all([import("./openapi-B4aAnx4P.mjs").then((n) => n.t), import("./core-DS3sAabb.mjs").then((n) => n.t)]));
+			return yield* Console.log(yield* elysia(yield* parseOpenAPI(input), { output }));
+		}
+		const resolvedConfig = configPath ?? DEFAULT_CONFIG_FILE;
+		if (args.watch) return yield* watchConfig(resolve(process.cwd(), resolvedConfig), yield* reportConfigPass(resolvedConfig, false));
+		const first = yield* runConfigPass(resolvedConfig, false).pipe(Effect.mapError((error) => configPath === void 0 && error._tag === "ConfigError" && error.notFound === true ? reject(error.message) : error));
+		yield* Console.log(first.report);
+	}).pipe(Effect.mapError((error) => CliError.isCliError(error) ? error : new CliError.UserError({
+		cause: error,
+		userMessage: error.message
+	})));
+}
+/**
+* The `asphodelos` command: parsing, validation, `--help`, `--version` and shell completions are
+* owned by `effect/unstable/cli`, {@link generate} is the rest.
+*/
+const cli = Command.make(COMMAND_NAME, commandLine, generate).pipe(Command.withDescription("Generate Elysia code from OpenAPI or TypeSpec"), Command.withExamples([
+	{
+		command: "asphodelos openapi.yaml -o src/index.ts",
+		description: "Generate a single app from one document"
+	},
+	{
+		command: "asphodelos",
+		description: `Run every generator declared in ./${DEFAULT_CONFIG_FILE}`
+	},
+	{
+		command: "asphodelos --config config/api.config.ts",
+		description: "Run a config file from another location"
+	},
+	{
+		command: "asphodelos --watch",
+		description: "Rerun on every change to the input documents or the config"
+	}
+]));
+/**
+* Runs `asphodelos` against an argument list.
+*
+* `entryUrl` is the `import.meta.url` of the executable, and `--version` is read from the
+* `package.json` next to it rather than baked in, so the two can never disagree.
+*/
+function asphodelos(argv, entryUrl) {
+	return Effect.gen(function* () {
+		const manifestPath = fileURLToPath(new URL("../package.json", entryUrl));
+		const source = yield* (yield* FileSystem.FileSystem).readFileString(manifestPath);
+		const manifest = yield* Effect.try({
+			try: () => JSON.parse(source),
+			catch: (cause) => new Error(`${manifestPath} is not valid JSON`, { cause })
+		});
+		const { version } = yield* Schema.decodeUnknownEffect(Schema.Struct({ version: Schema.String }))(manifest);
+		return yield* Command.runWith(cli, { version })(argv);
+	});
+}
+//#endregion
+//#region src/index.ts
+NodeRuntime.runMain(asphodelos(process.argv.slice(2), import.meta.url).pipe(Effect.provide(NodeServices.layer)));
+//#endregion
+export {};