@shipworthy/openapi-cli 0.0.1 → 1.0.0

package/dist/commands/generate/{plugins/typescript/flags.d.ts → flags.d.ts}

@@ -1,6 +1,7 @@
 import { Flag } from "effect/cli";
 export interface TypeFlags {
     readonly arrayLength: boolean;
+    readonly camelCase: boolean;
     readonly conditionalEnums: boolean;
     readonly dedupeEnums: boolean;
     readonly enum: boolean;
@@ -9,8 +10,8 @@ export interface TypeFlags {
     readonly readWriteMarkers: boolean;
     readonly rootTypes: boolean;
 }
-export declare const defaultTypeFlags: TypeFlags;
 export declare const typeFlags: {
+    camelCase: Flag.Flag<boolean>;
     enum: Flag.Flag<boolean>;
     enumValues: Flag.Flag<boolean>;
     conditionalEnums: Flag.Flag<boolean>;
@@ -20,10 +21,10 @@ export declare const typeFlags: {
     rootTypes: Flag.Flag<boolean>;
     readWriteMarkers: Flag.Flag<boolean>;
 };
-export declare function pluginOptions(flags: TypeFlags & {
-    readonly silent?: boolean;
-}): {
+/** Options for the `typescript` plugin. */
+export declare function pluginOptions(flags: TypeFlags, silent: boolean): {
     arrayLength: boolean;
+    camelCase: boolean;
     conditionalEnums: boolean;
     dedupeEnums: boolean;
     enum: boolean;

package/dist/commands/generate/{plugins/typescript/flags.js → flags.js}

@@ -2,17 +2,8 @@ import { Flag } from "effect/cli";
 function flag(name, description) {
     return Flag.Boolean(name).pipe(Flag.withDescription(description), Flag.withDefault(false));
 }
-export const defaultTypeFlags = {
-    arrayLength: true,
-    conditionalEnums: false,
-    dedupeEnums: false,
-    enum: false,
-    enumValues: false,
-    exportType: false,
-    readWriteMarkers: false,
-    rootTypes: false,
-};
 export const typeFlags = {
+    camelCase: flag("camel-case", "Use camelCase for snake_case schema fields and parameters in every generated file."),
     enum: flag("enum", "Export true TS enums instead of unions."),
     enumValues: flag("enum-values", "Export enum values as arrays."),
     conditionalEnums: flag("conditional-enums", "Only generate true TS enums when enum metadata is available."),
@@ -22,9 +13,11 @@ export const typeFlags = {
     rootTypes: flag("root-types", "Export component and operation types at the root level."),
     readWriteMarkers: flag("read-write-markers", "Generate $Read/$Write markers for readOnly/writeOnly properties."),
 };
-export function pluginOptions(flags) {
+/** Options for the `typescript` plugin. */
+export function pluginOptions(flags, silent) {
     return {
         arrayLength: flags.arrayLength,
+        camelCase: flags.camelCase,
         conditionalEnums: flags.conditionalEnums,
         dedupeEnums: flags.dedupeEnums,
         enum: flags.enum,
@@ -32,6 +25,6 @@ export function pluginOptions(flags) {
         exportType: flags.exportType,
         readWriteMarkers: flags.readWriteMarkers,
         rootTypes: flags.rootTypes,
-        silent: flags.silent ?? false,
+        silent,
     };
 }

package/dist/commands/generate/output.d.ts

@@ -0,0 +1,15 @@
+import { Effect, FileSystem, Path, Stdio } from "effect";
+import { CliError } from "effect/cli";
+import type { RenderedFile } from "./render.ts";
+export declare const writeStdout: (text: string) => Effect.Effect<void, import("effect/PlatformError").PlatformError, Stdio.Stdio>;
+/** Writes every file into `directory` concurrently, then logs one line per file. */
+export declare const writeFiles: (files: readonly RenderedFile[], options: {
+    readonly directory: string;
+    /** Input URL href, or `stdin`. */
+    readonly label: string;
+    /** `--output` as typed. */
+    readonly outputLabel: string;
+    readonly started: number;
+}) => Effect.Effect<void, import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+/** Fails unless every file in `directory` matches its generated contents. */
+export declare const checkFiles: (files: readonly RenderedFile[], directory: string) => Effect.Effect<undefined, CliError.UserError, FileSystem.FileSystem | Path.Path>;

package/dist/commands/generate/output.js

@@ -0,0 +1,35 @@
+import { Array, Clock, Console, Effect, FileSystem, Option, Path, pipe, Stdio, Stream, String, } from "effect";
+import { CliError } from "effect/cli";
+function formatTime(t) {
+    if (t < 1000)
+        return `${Math.round(10 * t) / 10}ms`;
+    if (t < 60000)
+        return `${Math.round(t / 100) / 10}s`;
+    return `${Math.round(t / 6000) / 10}m`;
+}
+export const writeStdout = Effect.fn("writeStdout")(function* (text) {
+    const stdio = yield* Stdio.Stdio;
+    yield* Stream.run(Stream.make(text), stdio.stdout({ endOnDone: false }));
+});
+/** Writes every file into `directory` concurrently, then logs one line per file. */
+export const writeFiles = Effect.fn("writeFiles")(function* (files, options) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    yield* fs.makeDirectory(options.directory, { recursive: true });
+    yield* Effect.forEach(files, (file) => fs.writeFileString(path.join(options.directory, file.name), file.contents), { concurrency: "unbounded", discard: true });
+    const elapsed = formatTime((yield* Clock.currentTimeMillis) - options.started);
+    const output = pipe(options.outputLabel, String.replace(/(?<=.)\/+$/, ""));
+    yield* Effect.forEach(files, (file) => Console.log(`${options.label} → ${output}/${file.name} [${elapsed}]`), { discard: true });
+});
+/** Fails unless every file in `directory` matches its generated contents. */
+export const checkFiles = Effect.fn("checkFiles")(function* (files, directory) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const stale = yield* Effect.forEach(files, (file) => fs.readFileString(path.join(directory, file.name)).pipe(Effect.option, Effect.map((existing) => Option.contains(existing, file.contents) ? Option.none() : Option.some(file.name))), { concurrency: "unbounded" });
+    const names = Array.getSomes(stale);
+    if (names.length === 0)
+        return;
+    return yield* new CliError.UserError({
+        cause: `Generated files are not up-to-date: ${Array.join(names, ", ")}`,
+    });
+});

package/dist/commands/generate/plan.d.ts

@@ -0,0 +1,53 @@
+import { Option, Result, Schema } from "effect";
+declare const pluginNames: readonly ["standard-schema", "tanstack-query", "typescript", "zod"];
+type PluginName = (typeof pluginNames)[number];
+export declare const ClientName: Schema.String;
+interface Generator {
+    readonly specifier: string;
+    readonly exportName: string;
+}
+interface Plugin {
+    readonly generator: Generator;
+    /** Whether the plugin's file imports the shared `types.ts`. */
+    readonly types: boolean;
+}
+export declare const plugins: Readonly<Record<PluginName, Plugin>>;
+/** One file a run writes, with the plugin that renders it. */
+export type OutputFile = {
+    readonly plugin: "typescript";
+    readonly name: "types.ts" | "wire-types.ts";
+    readonly camelCase: boolean;
+} | {
+    readonly plugin: "zod";
+    readonly name: "zod-schema.ts";
+    readonly camelCase: boolean;
+} | {
+    readonly plugin: "tanstack-query";
+    readonly name: "client.ts";
+    readonly camelCase: boolean;
+    readonly clientName: string;
+} | {
+    readonly plugin: "standard-schema";
+    readonly name: "standard-schema.ts";
+    readonly camelCase: boolean;
+};
+interface PlanOptions {
+    /** Positional plugin names, as typed. */
+    readonly plugins: ReadonlyArray<string>;
+    /** `--output`, as typed. */
+    readonly output: Option.Option<string>;
+    /** Basename of the resolved output directory. */
+    readonly outputName: Option.Option<string>;
+    readonly name: Option.Option<string>;
+    readonly camelCase: boolean;
+    readonly wireTypes: boolean;
+    readonly check: boolean;
+}
+/** Converts a `ClientName` (single `-` or `_` separators) to PascalCase. */
+export declare function pascalCase(value: string): string;
+/**
+ * Validates a `generate` invocation and lists the files it writes, sorted by name.
+ * Fails with the message shown to the user.
+ */
+export declare function planFiles(options: PlanOptions): Result.Result<ReadonlyArray<OutputFile>, string>;
+export {};

package/dist/commands/generate/plan.js

@@ -0,0 +1,93 @@
+import { Array, Option, Order, pipe, Predicate, Result, Schema, String } from "effect";
+const pluginNames = ["standard-schema", "tanstack-query", "typescript", "zod"];
+export const ClientName = Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-zA-Z][a-zA-Z0-9]*(?:[-_][a-zA-Z0-9]+)*$/, {
+    message: "--name must start with a letter and contain only letters, numbers, and single hyphen or underscore separators.",
+})));
+export const plugins = {
+    "standard-schema": {
+        generator: {
+            specifier: "@shipworthy/openapi-standard-schema",
+            exportName: "standardSchema",
+        },
+        types: false,
+    },
+    "tanstack-query": {
+        generator: {
+            specifier: "@shipworthy/openapi-tanstack-query/generator",
+            exportName: "tanstackQuery",
+        },
+        types: true,
+    },
+    typescript: {
+        generator: { specifier: "@shipworthy/openapi-typescript", exportName: "typescript" },
+        types: true,
+    },
+    zod: {
+        generator: { specifier: "@shipworthy/openapi-zod", exportName: "zod" },
+        types: true,
+    },
+};
+const isPluginName = Schema.is(Schema.Literals(pluginNames));
+const isClientName = Schema.is(ClientName);
+const byName = Order.mapInput(Order.String, (file) => file.name);
+/** Converts a `ClientName` (single `-` or `_` separators) to PascalCase. */
+export function pascalCase(value) {
+    return pipe(value, String.split(/[-_]/), Array.map(String.capitalize), Array.join(""));
+}
+function isFilePath(output) {
+    return /\.(?:[mc]?ts|[mc]?js|json)$/i.test(output);
+}
+/**
+ * Validates a `generate` invocation and lists the files it writes, sorted by name.
+ * Fails with the message shown to the user.
+ */
+export function planFiles(options) {
+    const unknown = Array.findFirst(options.plugins, Predicate.not(isPluginName));
+    if (Option.isSome(unknown)) {
+        return Result.fail(`Unknown plugin: ${unknown.value}. Available plugins: ${Array.join(pluginNames, ", ")}.`);
+    }
+    const selected = Array.dedupe(Array.filter(options.plugins, isPluginName));
+    const types = Array.some(selected, (plugin) => plugins[plugin].types);
+    if (options.wireTypes && !options.camelCase) {
+        return Result.fail("--wire-types requires --camel-case.");
+    }
+    if (options.wireTypes && !types) {
+        return Result.fail("--wire-types requires typescript, zod, or tanstack-query.");
+    }
+    if (options.check && Option.isNone(options.output)) {
+        return Result.fail("--check requires --output.");
+    }
+    const camelCase = options.camelCase;
+    const client = Array.contains(selected, "tanstack-query");
+    // Every file but client.ts, whose name is resolved only once the other checks pass.
+    const files = [
+        ...(types ? [{ plugin: "typescript", name: "types.ts", camelCase }] : []),
+        ...(options.wireTypes
+            ? [{ plugin: "typescript", name: "wire-types.ts", camelCase: false }]
+            : []),
+        ...(Array.contains(selected, "zod")
+            ? [{ plugin: "zod", name: "zod-schema.ts", camelCase }]
+            : []),
+        ...(Array.contains(selected, "standard-schema")
+            ? [{ plugin: "standard-schema", name: "standard-schema.ts", camelCase }]
+            : []),
+    ];
+    if (files.length + (client ? 1 : 0) > 1 && Option.isNone(options.output)) {
+        return Result.fail("--output is required when generating more than one file.");
+    }
+    if (Option.exists(options.output, isFilePath)) {
+        return Result.fail("--output must be a directory. Each plugin writes its own file inside it.");
+    }
+    if (!client)
+        return Result.succeed(Array.sort(files, byName));
+    return Result.map(clientName(options), (clientName) => Array.sort([...files, { plugin: "tanstack-query", name: "client.ts", camelCase, clientName }], byName));
+}
+/** `--name`, or the output directory's basename when it is a valid client name. */
+function clientName(options) {
+    if (Option.isSome(options.name))
+        return Result.succeed(options.name.value);
+    return Option.match(Option.filter(options.outputName, isClientName), {
+        onSome: Result.succeed,
+        onNone: () => Result.fail(`Cannot derive a client name from the output directory "${Option.getOrElse(options.outputName, () => "")}". Pass --name.`),
+    });
+}

package/dist/commands/generate/render.d.ts

@@ -0,0 +1,25 @@
+import { type RunPluginOptions } from "@shipworthy/openapi-generator";
+import { Effect, Path } from "effect";
+import { CliError } from "effect/cli";
+import { type TypeFlags } from "./flags.ts";
+import { type OutputFile } from "./plan.ts";
+interface RenderContext {
+    readonly model: RunPluginOptions["model"];
+    /** Schema text the stamps hash. */
+    readonly text: string;
+    /** Absolute output directory. */
+    readonly directory: string;
+    readonly typeFlags: TypeFlags;
+    /** Whether output goes to stdout, so generators must not log. */
+    readonly silent: boolean;
+}
+export interface RenderedFile {
+    readonly name: OutputFile["name"];
+    readonly contents: string;
+}
+/** Runs the plugin for `file` against the loaded model and prepends its stamped header. */
+export declare const renderFile: (file: OutputFile, context: RenderContext) => Effect.Effect<{
+    name: "client.ts" | "standard-schema.ts" | "types.ts" | "wire-types.ts" | "zod-schema.ts";
+    contents: string;
+}, import("@shipworthy/openapi-generator").InvalidPlugin | import("@shipworthy/openapi-generator").MissingPlugin | import("@shipworthy/openapi-generator").TransformError | CliError.UserError, import("effect/crypto/Digest").Digest | import("effect/FileSystem").FileSystem | Path.Path>;
+export {};

package/dist/commands/generate/render.js

@@ -0,0 +1,63 @@
+import { runPlugin } from "@shipworthy/openapi-generator";
+import { Array, Effect, Path, pipe, Predicate, Schema } from "effect";
+import { CliError } from "effect/cli";
+import { pluginOptions } from "./flags.js";
+import { pascalCase, plugins } from "./plan.js";
+import { fileHeader, generatorStamp } from "./stamp.js";
+const AstNodes = Schema.Array(Schema.declare((value) => Predicate.hasProperty(value, "kind")));
+const typescriptModule = Effect.tryPromise({
+    try: () => import("@shipworthy/openapi-typescript"),
+    catch: (cause) => new CliError.UserError({ cause }),
+});
+function asUserError(cause) {
+    return new CliError.UserError({ cause });
+}
+function generate(run, options) {
+    return runPlugin({
+        ...plugins[run.file.plugin].generator,
+        model: run.context.model,
+        pluginOptions: options,
+    });
+}
+/** Text output from a string-returning plugin, after the header. */
+function renderText(run, options) {
+    return generate(run, options).pipe(Effect.flatMap((value) => Effect.mapError(Schema.decodeUnknownEffect(Schema.String)(value), asUserError)), Effect.map((body) => `${run.header}${body}`));
+}
+/** Prints the `typescript` plugin's AST and formats it together with the header. */
+const renderTypes = Effect.fnUntraced(function* (run) {
+    const nodes = yield* generate(run, pluginOptions({ ...run.context.typeFlags, camelCase: run.file.camelCase }, run.context.silent)).pipe(Effect.flatMap((value) => Effect.mapError(Schema.decodeUnknownEffect(AstNodes)(value), asUserError)));
+    const types = yield* typescriptModule;
+    // Print each top-level declaration on its own so a blank line separates them.
+    const body = pipe(nodes, Array.map((node) => types.astToString(node)), Array.join("\n"));
+    return yield* Effect.tryPromise({
+        try: () => types.formatTypeScript(`${run.header}${body}`),
+        catch: asUserError,
+    });
+});
+function renderContents(run) {
+    const file = run.file;
+    switch (file.plugin) {
+        case "typescript":
+            return renderTypes(run);
+        case "zod":
+            return renderText(run, { outputPath: run.outputPath, camelCase: file.camelCase });
+        case "tanstack-query":
+            return renderText(run, {
+                prefix: pascalCase(file.clientName),
+                name: file.clientName,
+                camelCase: file.camelCase,
+            });
+        case "standard-schema":
+            return renderText(run, { camelCase: file.camelCase });
+    }
+}
+/** Runs the plugin for `file` against the loaded model and prepends its stamped header. */
+export const renderFile = Effect.fn("renderFile")(function* (file, context) {
+    const path = yield* Path.Path;
+    const generator = plugins[file.plugin].generator;
+    const stamp = yield* generatorStamp(generator.specifier, context.text, file.camelCase);
+    const header = fileHeader(stamp, file.camelCase);
+    const outputPath = path.join(context.directory, file.name);
+    const contents = yield* renderContents({ file, context, header, outputPath });
+    return { name: file.name, contents };
+});

package/dist/commands/generate/source.d.ts

@@ -0,0 +1,5 @@
+import { Effect, FileSystem, Stdio } from "effect";
+import { HttpClient } from "effect/http";
+export declare const readStdin: () => Effect.Effect<string, import("effect/PlatformError").PlatformError, Stdio.Stdio>;
+/** The schema text at `source`, read once to stamp generated files. */
+export declare const readSource: (source: URL) => Effect.Effect<string, import("effect/http/HttpClientError").HttpClientError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | HttpClient.HttpClient>;

package/dist/commands/generate/source.js

@@ -0,0 +1,18 @@
+import { fileURLToPath } from "node:url";
+import { Effect, FileSystem, Stdio, Stream } from "effect";
+import { HttpClient } from "effect/http";
+export const readStdin = Effect.fn("readStdin")(function* () {
+    const stdio = yield* Stdio.Stdio;
+    return yield* stdio.stdin.pipe(Stream.decodeText(), Stream.mkString);
+});
+/** The schema text at `source`, read once to stamp generated files. */
+export const readSource = Effect.fn("readSource")(function* (source) {
+    if (source.protocol === "file:") {
+        const fs = yield* FileSystem.FileSystem;
+        return yield* fs.readFileString(fileURLToPath(source));
+    }
+    const http = yield* HttpClient.HttpClient;
+    const client = HttpClient.filterStatusOk(http);
+    const response = yield* client.get(source.href);
+    return yield* response.text;
+});

package/dist/commands/generate/stamp.d.ts

@@ -1,13 +1,17 @@
-import { Crypto, Effect, FileSystem, Path } from "effect";
+import { Effect, FileSystem, Path } from "effect";
 import { CliError } from "effect/cli";
-import { HttpClient } from "effect/http";
-/** `<package>@<version>:<sha256 of the schema contents>` for the generator at `specifier`. */
-export declare const generatorStamp: (specifier: string, source: string | URL) => Effect.Effect<{
-    name: string;
-    stamp: string;
-}, import("effect/http/HttpClientError").HttpClientError | import("effect/PlatformError").PlatformError | CliError.UserError, Crypto.Crypto | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
-export declare function fileHeader(generator: {
+import { Digest } from "effect/crypto";
+interface Stamp {
     readonly name: string;
     readonly stamp: string;
-}): string;
-export declare function readStamp(text: string): string | undefined;
+}
+/**
+ * `<package>@<version>:<sha256 of the schema text>` for the generator at `specifier`.
+ * camelCase output hashes the text with a casing marker, so toggling the flag changes the stamp.
+ */
+export declare const generatorStamp: (specifier: string, text: string, camelCase: boolean) => Effect.Effect<{
+    name: string;
+    stamp: string;
+}, CliError.UserError, Digest.Digest | FileSystem.FileSystem | Path.Path>;
+export declare function fileHeader(generator: Stamp, camelCase: boolean): string;
+export {};

package/dist/commands/generate/stamp.js

@@ -1,33 +1,32 @@
 import { fileURLToPath } from "node:url";
-import { Crypto, Effect, FileSystem, Option, Path, Schema } from "effect";
+import { Array, Effect, FileSystem, Option, Path, pipe, Schema, String } from "effect";
 import { CliError } from "effect/cli";
-import { HttpClient } from "effect/http";
+import { Digest } from "effect/crypto";
 const PackageJson = Schema.Struct({ name: Schema.String, version: Schema.String });
-/** Matches the ` * <package>@<version>:<sha256>` line in a generated file's header. */
-const stampPattern = /^ \* (\S+@[^\s@:]+:[0-9a-f]{64})$/m;
-/** `<package>@<version>:<sha256 of the schema contents>` for the generator at `specifier`. */
-export const generatorStamp = Effect.fn("generatorStamp")(function* (specifier, source) {
+/**
+ * `<package>@<version>:<sha256 of the schema text>` for the generator at `specifier`.
+ * camelCase output hashes the text with a casing marker, so toggling the flag changes the stamp.
+ */
+export const generatorStamp = Effect.fn("generatorStamp")(function* (specifier, text, camelCase) {
     const generator = yield* generatorPackage(specifier);
-    const hash = yield* sha256(typeof source === "string" ? source : yield* readSource(source));
+    const hash = yield* sha256(camelCase ? `${text}\0camel-case` : text);
     return { name: generator.name, stamp: `${generator.name}@${generator.version}:${hash}` };
 });
-export function fileHeader(generator) {
+export function fileHeader(generator, camelCase) {
+    const casingLine = camelCase ? " * Field casing: camelCase\n" : "";
     return `/**
  * This file was auto-generated by ${generator.name}.
  * Do not make direct changes to the file.
  *
  * ${generator.stamp}
- */
-
-`;
-}
-export function readStamp(text) {
-    return stampPattern.exec(text)?.[1];
+${casingLine} */
+\n`;
 }
 const generatorPackage = Effect.fn("generatorPackage")(function* (specifier) {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const name = specifier.split("/", specifier.startsWith("@") ? 2 : 1).join("/");
+    const segments = pipe(specifier, String.split("/"));
+    const name = pipe(segments, Array.take(pipe(specifier, String.startsWith("@")) ? 2 : 1), Array.join("/"));
     const resolved = yield* Effect.try({
         try: () => fileURLToPath(import.meta.resolve(specifier)),
         catch: (cause) => new CliError.UserError({ cause }),
@@ -44,18 +43,7 @@ const generatorPackage = Effect.fn("generatorPackage")(function* (specifier) {
         }
     }
 });
-const readSource = Effect.fn("readSource")(function* (source) {
-    if (source.protocol === "file:") {
-        const fs = yield* FileSystem.FileSystem;
-        return yield* fs.readFileString(fileURLToPath(source));
-    }
-    const http = yield* HttpClient.HttpClient;
-    const client = HttpClient.filterStatusOk(http);
-    const response = yield* client.get(source.href);
-    return yield* response.text;
-});
 const sha256 = Effect.fn("sha256")(function* (text) {
-    const crypto = yield* Crypto.Crypto;
-    const digest = yield* crypto.digest("SHA-256", new TextEncoder().encode(text));
-    return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    const digest = yield* Digest.Digest;
+    return yield* digest.digestHex(Digest.sha256, new TextEncoder().encode(text));
 });

package/dist/commands/input.js

@@ -1,7 +1,7 @@
-import { Effect, Path } from "effect";
+import { Effect, Path, pipe, String } from "effect";
 import { CliError } from "effect/cli";
 export const schemaSource = Effect.fn("schemaSource")(function* (input) {
-    if (input.includes("*")) {
+    if (pipe(input, String.includes("*"))) {
         return yield* new CliError.UserError({ cause: "Globbing is unsupported." });
     }
     if (/^(https?:|file:)/i.test(input))

package/dist/commands/overlay/command.js

@@ -1,4 +1,4 @@
-import { applyOverlay } from "@shipworthy/overlay";
+import { applyOverlayWithWarnings } from "@shipworthy/openapi-overlay";
 import { bundleDocument } from "@shipworthy/openapi-parser";
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { Argument, Command, Flag } from "effect/cli";
@@ -11,11 +11,12 @@ const run = Effect.fn("overlay")(function* ({ input, overlay, output, removeUnus
     const text = overlay.protocol === "file:"
         ? yield* fs.readFileString(fileURLToPath(overlay))
         : yield* HttpClient.get(overlay.href).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.flatMap((response) => response.text));
-    const result = yield* applyOverlay(document, text, { removeUnusedComponents });
+    const result = yield* applyOverlayWithWarnings(document, text, { removeUnusedComponents });
+    yield* Effect.forEach(result.warnings, (warning) => Console.warn(`WARNING Overlay action ${warning.action} (${warning.target}): ${warning.message}`), { discard: true });
     const path = yield* Path.Path;
     const outputPath = path.resolve(output);
     yield* fs.makeDirectory(path.dirname(outputPath), { recursive: true });
-    const serialized = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown, { space: 2 }))(result);
+    const serialized = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown, { space: 2 }))(result.document);
     yield* fs.writeFileString(outputPath, `${serialized}\n`);
     yield* Console.log(`${input.href} + ${overlay.href} → ${output}`);
 }, Effect.mapError(asCliError));

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "@shipworthy/openapi-cli",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@effect/platform-node": "^4.0.0",
-    "@shipworthy/openapi-generator": "0.0.1",
-    "@shipworthy/openapi-parser": "0.0.1",
-    "@shipworthy/openapi-validator": "0.0.1",
-    "@shipworthy/overlay": "0.0.1",
-    "effect": "^4.0.0"
+    "@effect/platform-node": "4.1.4",
+    "@effect/platform-node-shared": "4.1.4",
+    "@shipworthy/openapi-generator": "1.0.0",
+    "@shipworthy/openapi-overlay": "1.0.0",
+    "@shipworthy/openapi-parser": "1.0.0",
+    "@shipworthy/openapi-validator": "1.0.0",
+    "effect": "4.1.4"
   },
   "peerDependencies": {
-    "@shipworthy/openapi-standard-schema": "0.0.1",
-    "@shipworthy/openapi-tanstack-query": "0.0.1",
-    "@shipworthy/openapi-typescript": "0.0.1",
-    "@shipworthy/openapi-zod": "0.0.1"
+    "@shipworthy/openapi-standard-schema": "1.0.0",
+    "@shipworthy/openapi-tanstack-query": "1.0.0",
+    "@shipworthy/openapi-typescript": "1.0.0",
+    "@shipworthy/openapi-zod": "1.0.0"
   },
   "bin": {
     "openapi": "./dist/bin.js"
@@ -40,14 +41,14 @@
     "build": "rm -rf dist && tsc -p tsconfig.build.json && sed -i.bak '1s|^#!.*|#!/usr/bin/env node|' dist/bin.js && rm dist/bin.js.bak"
   },
   "devDependencies": {
-    "@shipworthy/openapi-standard-schema": "0.0.1",
-    "@shipworthy/openapi-tanstack-query": "0.0.1",
-    "@shipworthy/openapi-typescript": "0.0.1",
-    "@shipworthy/openapi-zod": "0.0.1",
+    "@shipworthy/openapi-standard-schema": "1.0.0",
+    "@shipworthy/openapi-tanstack-query": "1.0.0",
+    "@shipworthy/openapi-typescript": "1.0.0",
+    "@shipworthy/openapi-zod": "1.0.0",
     "@shipworthy/typescript-config": "0.0.1",
-    "@types/node": "^24.10.3",
+    "@types/node": "^26.6.6",
     "typescript": "^7.0.2",
-    "vitest": "5.0.3"
+    "vitest": "5.1.0"
   },
   "peerDependenciesMeta": {
     "@shipworthy/openapi-standard-schema": {

package/dist/commands/generate/ensure.d.ts

@@ -1,9 +0,0 @@
-import { Effect, FileSystem, Path } from "effect";
-import { CliError } from "effect/cli";
-export interface EnsureTarget {
-    readonly source: URL;
-    readonly directory: string;
-    readonly started: number;
-    readonly force: boolean;
-}
-export declare const ensureDependencies: (dependencies: readonly string[], target: EnsureTarget) => Effect.Effect<void, import("effect/PlatformError").BadArgument | import("effect/http/HttpClientError").HttpClientError | import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError | CliError.UserError | import("@shipworthy/openapi-generator").GenerateError, import("effect/Crypto").Crypto | import("effect/Stdio").Stdio | (FileSystem.FileSystem | import("effect/http/HttpClient").HttpClient | Path.Path)>;

package/dist/commands/generate/ensure.js

@@ -1,31 +0,0 @@
-import { Effect, FileSystem, Option, Path } from "effect";
-import { CliError } from "effect/cli";
-import { defaultTypeFlags } from "./plugins/typescript/flags.js";
-import { renderTypescript, typescriptSpecifier } from "./plugins/typescript/plugin.js";
-import { generatorStamp, readStamp } from "./stamp.js";
-export const ensureDependencies = Effect.fn("ensureDependencies")(function* (dependencies, target) {
-    yield* Effect.forEach(dependencies, (dependency) => dependency === "typescript"
-        ? ensureTypescript(target)
-        : Effect.fail(new CliError.UserError({ cause: `Unknown generator dependency: ${dependency}.` })), { discard: true });
-});
-const ensureTypescript = Effect.fn("ensureTypescript")(function* (target) {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const typesPath = path.join(target.directory, "types.ts");
-    const generator = yield* generatorStamp(typescriptSpecifier, target.source);
-    if (!target.force) {
-        const types = yield* fs.readFileString(typesPath).pipe(Effect.option);
-        if (Option.isSome(types) && readStamp(types.value) === generator.stamp)
-            return;
-    }
-    yield* renderTypescript({
-        source: target.source,
-        generator,
-        outputPath: typesPath,
-        flags: defaultTypeFlags,
-        check: false,
-        label: target.source.href,
-        outputLabel: typesPath,
-        started: target.started,
-    });
-});

package/dist/commands/generate/files.d.ts

@@ -1,4 +0,0 @@
-import { Effect, FileSystem, Path, Schema } from "effect";
-export declare function pascalCase(value: string): string;
-export declare const ClientName: Schema.String;
-export declare const writeGenerated: (directory: string, name: string, files: Record<string, string>) => Effect.Effect<void, import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;

package/dist/commands/generate/files.js

@@ -1,16 +0,0 @@
-import { Console, Effect, FileSystem, Path, Schema } from "effect";
-export function pascalCase(value) {
-    return value.replace(/(?:^|[-_])([a-zA-Z0-9])/g, (_, letter) => letter.toUpperCase());
-}
-export const ClientName = Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-zA-Z][a-zA-Z0-9]*(?:[-_][a-zA-Z0-9]+)*$/, {
-    message: "--name must start with a letter and contain only letters, numbers, and single hyphen or underscore separators.",
-})));
-export const writeGenerated = Effect.fn("writeGenerated")(function* (directory, name, files) {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const output = path.resolve(directory, name);
-    yield* fs.makeDirectory(output, { recursive: true });
-    yield* Effect.forEach(Object.entries(files), ([file, contents]) => fs.writeFileString(path.join(output, file), contents), { discard: true });
-    const written = Object.keys(files).map((file) => `${output}/${file}`);
-    yield* Console.log(`Generated ${written.join(", ")}`);
-});