@shipworthy/openapi-cli 0.0.0-stage → 0.0.2

package/dist/commands/generate/plugins/standard-schema/plugin.js

@@ -0,0 +1,44 @@
+import { generate as transform } from "@shipworthy/openapi-generator";
+import { Clock, Effect, Option, Path, Result, Schema } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/cli";
+import { asCliError, schemaSource } from "../../../input.js";
+import { publish } from "../../publish.js";
+import { fileHeader, generatorStamp } from "../../stamp.js";
+import { writeStdout } from "../typescript/plugin.js";
+export const dependencies = [];
+const specifier = "@shipworthy/openapi-standard-schema";
+const run = Effect.fn("run")(function* (flags) {
+    const output = Option.getOrUndefined(flags.output);
+    const started = yield* Clock.currentTimeMillis;
+    const decoded = Schema.decodeUnknownResult(Schema.String)(yield* transform({
+        specifier,
+        exportName: "standardSchema",
+        source: flags.input,
+    }));
+    if (Result.isFailure(decoded)) {
+        return yield* new CliError.UserError({ cause: decoded.failure });
+    }
+    const text = `${fileHeader(yield* generatorStamp(specifier, flags.input))}${decoded.success}`;
+    if (!output) {
+        yield* writeStdout(text);
+        return;
+    }
+    const path = yield* Path.Path;
+    yield* publish({
+        result: text,
+        outputPath: path.resolve(output),
+        check: false,
+        label: flags.input.href,
+        outputLabel: output,
+        started,
+    });
+}, Effect.mapError(asCliError));
+export const standardSchema = Command.make("standard-schema", {
+    input: Argument.String("input").pipe(Argument.withDescription("OpenAPI schema file or URL."), Argument.mapEffect(schemaSource)),
+    output: Flag.String("output").pipe(Flag.withAlias("o"), Flag.withDescription("Output file. Writes to stdout when omitted."), Flag.optional),
+}, run).pipe(Command.withDescription("Generate Standard Schema validators from an OpenAPI schema."), Command.withShortDescription("Generate Standard Schema validators"), Command.withExamples([
+    {
+        command: "openapi generate standard-schema ./openapi.yaml -o ./schemas.ts",
+        description: "Write Standard Schema validators",
+    },
+]));

package/dist/commands/generate/plugins/tanstack-query/plugin.d.ts

@@ -0,0 +1,9 @@
+import { Path } from "effect";
+import { CliError, Command } from "effect/cli";
+export declare const dependencies: readonly ["typescript"];
+export declare const tanstackQuery: Command.Command<"tanstack-query", {
+    readonly input: URL;
+    readonly output: string;
+    readonly name: string;
+    readonly force: boolean;
+}, {}, CliError.UserError, import("effect/Crypto").Crypto | import("effect/Stdio").Stdio | (import("effect/FileSystem").FileSystem | import("effect/http/HttpClient").HttpClient | Path.Path)>;

package/dist/commands/generate/plugins/tanstack-query/plugin.js

@@ -0,0 +1,42 @@
+import { generate as transform } from "@shipworthy/openapi-generator";
+import { Clock, Effect, Path, Result, Schema } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/cli";
+import { asCliError, schemaSource } from "../../../input.js";
+import { ensureDependencies } from "../../ensure.js";
+import { force } from "../../force.js";
+import { ClientName, pascalCase, writeGenerated } from "../../files.js";
+import { fileHeader, generatorStamp } from "../../stamp.js";
+export const dependencies = ["typescript"];
+const specifier = "@shipworthy/openapi-tanstack-query/generator";
+const run = Effect.fn("run")(function* (flags) {
+    const started = yield* Clock.currentTimeMillis;
+    const path = yield* Path.Path;
+    yield* ensureDependencies(dependencies, {
+        source: flags.input,
+        directory: path.resolve(flags.output, flags.name),
+        started,
+        force: flags.force,
+    });
+    const decoded = Schema.decodeUnknownResult(Schema.String)(yield* transform({
+        specifier,
+        exportName: "tanstackQuery",
+        source: flags.input,
+        pluginOptions: { prefix: pascalCase(flags.name), name: flags.name },
+    }));
+    if (Result.isFailure(decoded)) {
+        return yield* new CliError.UserError({ cause: decoded.failure });
+    }
+    const header = fileHeader(yield* generatorStamp(specifier, flags.input));
+    yield* writeGenerated(flags.output, flags.name, { "client.ts": `${header}${decoded.success}` });
+}, Effect.mapError(asCliError));
+export const tanstackQuery = Command.make("tanstack-query", {
+    input: Argument.String("input").pipe(Argument.withDescription("OpenAPI schema file or URL."), Argument.mapEffect(schemaSource)),
+    output: Flag.String("output").pipe(Flag.withAlias("o"), Flag.withDescription("Directory that will contain <name>/client.ts.")),
+    name: Flag.String("name").pipe(Flag.withDescription("Client name. Used as the output directory and the generated function prefix."), Flag.withSchema(ClientName)),
+    force,
+}, run).pipe(Command.withDescription("Generate TanStack Query utils from an OpenAPI schema."), Command.withShortDescription("Generate TanStack Query utils"), Command.withExamples([
+    {
+        command: "openapi generate tanstack-query ./openapi.yaml -o ./src/generated --name hotels",
+        description: "Write hotels/client.ts",
+    },
+]));

package/dist/commands/generate/plugins/typescript/flags.d.ts

@@ -0,0 +1,35 @@
+import { Flag } from "effect/cli";
+export interface TypeFlags {
+    readonly arrayLength: boolean;
+    readonly conditionalEnums: boolean;
+    readonly dedupeEnums: boolean;
+    readonly enum: boolean;
+    readonly enumValues: boolean;
+    readonly exportType: boolean;
+    readonly readWriteMarkers: boolean;
+    readonly rootTypes: boolean;
+}
+export declare const defaultTypeFlags: TypeFlags;
+export declare const typeFlags: {
+    enum: Flag.Flag<boolean>;
+    enumValues: Flag.Flag<boolean>;
+    conditionalEnums: Flag.Flag<boolean>;
+    dedupeEnums: Flag.Flag<boolean>;
+    exportType: Flag.Flag<boolean>;
+    arrayLength: Flag.Flag<boolean>;
+    rootTypes: Flag.Flag<boolean>;
+    readWriteMarkers: Flag.Flag<boolean>;
+};
+export declare function pluginOptions(flags: TypeFlags & {
+    readonly silent?: boolean;
+}): {
+    arrayLength: boolean;
+    conditionalEnums: boolean;
+    dedupeEnums: boolean;
+    enum: boolean;
+    enumValues: boolean;
+    exportType: boolean;
+    readWriteMarkers: boolean;
+    rootTypes: boolean;
+    silent: boolean;
+};

package/dist/commands/generate/plugins/typescript/flags.js

@@ -0,0 +1,37 @@
+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 = {
+    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."),
+    dedupeEnums: flag("dedupe-enums", "Dedupe enum types when --enum is set."),
+    exportType: Flag.Boolean("export-type").pipe(Flag.withAlias("t"), Flag.withDescription("Export top-level type aliases instead of interfaces."), Flag.withDefault(false)),
+    arrayLength: Flag.Boolean("array-length").pipe(Flag.withDescription("Generate tuples using array minItems / maxItems."), Flag.withDefault(true)),
+    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) {
+    return {
+        arrayLength: flags.arrayLength,
+        conditionalEnums: flags.conditionalEnums,
+        dedupeEnums: flags.dedupeEnums,
+        enum: flags.enum,
+        enumValues: flags.enumValues,
+        exportType: flags.exportType,
+        readWriteMarkers: flags.readWriteMarkers,
+        rootTypes: flags.rootTypes,
+        silent: flags.silent ?? false,
+    };
+}

package/dist/commands/generate/plugins/typescript/plugin.d.ts

@@ -0,0 +1,32 @@
+import { Effect, Option, Path, Stdio } from "effect";
+import { CliError, Command } from "effect/cli";
+import { type TypeFlags } from "./flags.ts";
+export declare const dependencies: readonly [];
+export declare const typescriptSpecifier = "@shipworthy/openapi-typescript";
+export declare const writeStdout: (text: string) => Effect.Effect<void, import("effect/PlatformError").PlatformError, Stdio.Stdio>;
+export declare const renderTypescript: (options: {
+    readonly source: URL | string;
+    readonly generator: {
+        readonly name: string;
+        readonly stamp: string;
+    };
+    readonly outputPath?: string;
+    readonly flags: TypeFlags;
+    readonly check: boolean;
+    readonly label: string;
+    readonly outputLabel: string;
+    readonly started: number;
+}) => Effect.Effect<void, import("effect/PlatformError").BadArgument | import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError | CliError.UserError | import("@shipworthy/openapi-generator").GenerateError, Stdio.Stdio | (import("effect/FileSystem").FileSystem | import("effect/http/HttpClient").HttpClient | Path.Path)>;
+export declare const typescript: Command.Command<"typescript", {
+    readonly enum: boolean;
+    readonly enumValues: boolean;
+    readonly conditionalEnums: boolean;
+    readonly dedupeEnums: boolean;
+    readonly exportType: boolean;
+    readonly arrayLength: boolean;
+    readonly rootTypes: boolean;
+    readonly readWriteMarkers: boolean;
+    readonly input: Option.Option<URL>;
+    readonly output: Option.Option<string>;
+    readonly check: boolean;
+}, {}, CliError.UserError, import("effect/Crypto").Crypto | Stdio.Stdio | (import("effect/FileSystem").FileSystem | import("effect/http/HttpClient").HttpClient | Path.Path)>;

package/dist/commands/generate/plugins/typescript/plugin.js

@@ -0,0 +1,84 @@
+import { generate as transform } from "@shipworthy/openapi-generator";
+import { Clock, Console, Effect, Option, Path, Stdio, Stream } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/cli";
+import { asCliError, schemaSource } from "../../../input.js";
+import { version } from "../../../../version.js";
+import { publish } from "../../publish.js";
+import { fileHeader, generatorStamp } from "../../stamp.js";
+import { pluginOptions, typeFlags } from "./flags.js";
+export const dependencies = [];
+export const typescriptSpecifier = "@shipworthy/openapi-typescript";
+const typescriptModule = Effect.fn("typescriptModule")(function* () {
+    return yield* Effect.tryPromise({
+        try: () => import("@shipworthy/openapi-typescript"),
+        catch: (cause) => new CliError.UserError({ cause }),
+    });
+});
+const readStdin = Effect.fn("readStdin")(function* () {
+    const stdio = yield* Stdio.Stdio;
+    return yield* stdio.stdin.pipe(Stream.decodeText(), Stream.mkString);
+});
+export const writeStdout = Effect.fn("writeStdout")(function* (text) {
+    const stdio = yield* Stdio.Stdio;
+    yield* Stream.run(Stream.make(text), stdio.stdout({ endOnDone: false }));
+});
+export const renderTypescript = Effect.fn("renderTypescript")(function* (options) {
+    if (options.outputPath)
+        yield* Console.info(`openapi generate typescript ${yield* version}`);
+    const nodes = yield* transform({
+        specifier: typescriptSpecifier,
+        exportName: "typescript",
+        source: options.source,
+        pluginOptions: pluginOptions({ ...options.flags, silent: options.outputPath === undefined }),
+    });
+    const types = yield* typescriptModule();
+    // Print each top-level declaration on its own so a blank line separates them.
+    const body = nodes.map((node) => types.astToString([node])).join("\n");
+    const printed = yield* Effect.tryPromise({
+        try: () => types.formatTypeScript(`${fileHeader(options.generator)}${body}`),
+        catch: (cause) => new CliError.UserError({ cause }),
+    });
+    if (!options.outputPath) {
+        yield* writeStdout(printed);
+        return;
+    }
+    yield* publish({
+        result: printed,
+        outputPath: options.outputPath,
+        check: options.check,
+        label: options.label,
+        outputLabel: options.outputLabel,
+        started: options.started,
+    });
+});
+const run = Effect.fn("run")(function* (flags) {
+    const output = Option.getOrUndefined(flags.output);
+    const input = Option.getOrUndefined(flags.input);
+    const started = yield* Clock.currentTimeMillis;
+    const path = yield* Path.Path;
+    const source = input ?? (yield* readStdin());
+    yield* renderTypescript({
+        source,
+        generator: yield* generatorStamp(typescriptSpecifier, source),
+        outputPath: output === undefined ? undefined : path.resolve(output),
+        flags,
+        check: flags.check,
+        label: input?.href ?? "stdin",
+        outputLabel: output ?? "stdout",
+        started,
+    });
+}, Effect.mapError(asCliError));
+export const typescript = Command.make("typescript", {
+    input: Argument.String("input").pipe(Argument.withDescription("OpenAPI schema file or URL. Omit to read stdin."), Argument.optional, Argument.mapEffect((input) => Option.match(input, {
+        onNone: () => Effect.succeed(Option.none()),
+        onSome: (value) => Effect.asSome(schemaSource(value)),
+    }))),
+    output: Flag.String("output").pipe(Flag.withAlias("o"), Flag.withDescription("Output file. Writes to stdout when omitted."), Flag.optional),
+    check: Flag.Boolean("check").pipe(Flag.withDescription("Check that the generated types are up-to-date."), Flag.withDefault(false)),
+    ...typeFlags,
+}, run).pipe(Command.withDescription("Convert an OpenAPI schema to TypeScript."), Command.withShortDescription("Generate TypeScript types"), Command.withExamples([
+    {
+        command: "openapi generate typescript ./openapi.yaml -o ./schema.ts",
+        description: "Write TypeScript types for a local schema",
+    },
+]));

package/dist/commands/generate/plugins/zod/plugin.d.ts

@@ -0,0 +1,8 @@
+import { Path } from "effect";
+import { CliError, Command } from "effect/cli";
+export declare const dependencies: readonly ["typescript"];
+export declare const zod: Command.Command<"zod", {
+    readonly input: URL;
+    readonly output: string;
+    readonly force: boolean;
+}, {}, CliError.UserError, import("effect/Crypto").Crypto | import("effect/Stdio").Stdio | (import("effect/FileSystem").FileSystem | import("effect/http/HttpClient").HttpClient | Path.Path)>;

package/dist/commands/generate/plugins/zod/plugin.js

@@ -0,0 +1,48 @@
+import { generate as transform } from "@shipworthy/openapi-generator";
+import { Clock, Effect, Path, Result, Schema } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/cli";
+import { asCliError, schemaSource } from "../../../input.js";
+import { ensureDependencies } from "../../ensure.js";
+import { force } from "../../force.js";
+import { publish } from "../../publish.js";
+import { fileHeader, generatorStamp } from "../../stamp.js";
+export const dependencies = ["typescript"];
+const specifier = "@shipworthy/openapi-zod";
+const run = Effect.fn("run")(function* (flags) {
+    const started = yield* Clock.currentTimeMillis;
+    const path = yield* Path.Path;
+    const outputPath = path.resolve(flags.output);
+    yield* ensureDependencies(dependencies, {
+        source: flags.input,
+        directory: path.dirname(outputPath),
+        started,
+        force: flags.force,
+    });
+    const decoded = Schema.decodeUnknownResult(Schema.String)(yield* transform({
+        specifier,
+        exportName: "zod",
+        source: flags.input,
+    }));
+    if (Result.isFailure(decoded)) {
+        return yield* new CliError.UserError({ cause: decoded.failure });
+    }
+    const header = fileHeader(yield* generatorStamp(specifier, flags.input));
+    yield* publish({
+        result: `${header}${decoded.success}`,
+        outputPath,
+        check: false,
+        label: flags.input.href,
+        outputLabel: flags.output,
+        started,
+    });
+}, Effect.mapError(asCliError));
+export const zod = Command.make("zod", {
+    input: Argument.String("input").pipe(Argument.withDescription("OpenAPI schema file or URL."), Argument.mapEffect(schemaSource)),
+    output: Flag.String("output").pipe(Flag.withAlias("o"), Flag.withDescription("Output file. types.ts is written next to it.")),
+    force,
+}, run).pipe(Command.withDescription("Generate Zod validators from an OpenAPI schema."), Command.withShortDescription("Generate Zod validators"), Command.withExamples([
+    {
+        command: "openapi generate zod ./openapi.yaml -o ./src/generated/hotels/zod-schema.ts",
+        description: "Write hotels/zod-schema.ts and hotels/types.ts",
+    },
+]));

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

@@ -0,0 +1,11 @@
+import { Effect, FileSystem, Path } from "effect";
+import { CliError } from "effect/cli";
+export declare function formatTime(t: number): string;
+export declare const publish: (options: {
+    readonly result: string;
+    readonly outputPath: string;
+    readonly check: boolean;
+    readonly label: string;
+    readonly outputLabel: string;
+    readonly started: number;
+}) => Effect.Effect<undefined, import("effect/PlatformError").PlatformError | CliError.UserError, FileSystem.FileSystem | Path.Path>;

package/dist/commands/generate/publish.js

@@ -0,0 +1,23 @@
+import { Clock, Console, Effect, FileSystem, Path } from "effect";
+import { CliError } from "effect/cli";
+export 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 publish = Effect.fn("publish")(function* (options) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    if (options.check) {
+        const previous = yield* fs.readFileString(options.outputPath);
+        if (previous === options.result)
+            return;
+        return yield* new CliError.UserError({ cause: "Generated types are not up-to-date!" });
+    }
+    yield* fs.makeDirectory(path.dirname(options.outputPath), { recursive: true });
+    yield* fs.writeFileString(options.outputPath, options.result);
+    const elapsed = (yield* Clock.currentTimeMillis) - options.started;
+    yield* Console.log(`${options.label} → ${options.outputLabel} [${formatTime(elapsed)}]`);
+});

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

@@ -0,0 +1,13 @@
+import { Crypto, 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: {
+    readonly name: string;
+    readonly stamp: string;
+}): string;
+export declare function readStamp(text: string): string | undefined;

package/dist/commands/generate/stamp.js

@@ -0,0 +1,61 @@
+import { fileURLToPath } from "node:url";
+import { Crypto, Effect, FileSystem, Option, Path, Schema } from "effect";
+import { CliError } from "effect/cli";
+import { HttpClient } from "effect/http";
+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) {
+    const generator = yield* generatorPackage(specifier);
+    const hash = yield* sha256(typeof source === "string" ? source : yield* readSource(source));
+    return { name: generator.name, stamp: `${generator.name}@${generator.version}:${hash}` };
+});
+export function fileHeader(generator) {
+    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];
+}
+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 resolved = yield* Effect.try({
+        try: () => fileURLToPath(import.meta.resolve(specifier)),
+        catch: (cause) => new CliError.UserError({ cause }),
+    });
+    for (let directory = path.dirname(resolved);; directory = path.dirname(directory)) {
+        const text = yield* fs.readFileString(path.join(directory, "package.json")).pipe(Effect.option);
+        if (Option.isSome(text)) {
+            const decoded = yield* Schema.decodeEffect(Schema.fromJsonString(PackageJson))(text.value).pipe(Effect.option);
+            if (Option.isSome(decoded) && decoded.value.name === name)
+                return decoded.value;
+        }
+        if (path.dirname(directory) === directory) {
+            return yield* new CliError.UserError({ cause: `Cannot find package.json for ${name}.` });
+        }
+    }
+});
+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("");
+});

package/dist/commands/input.d.ts

@@ -0,0 +1,4 @@
+import { Effect, Path } from "effect";
+import { CliError } from "effect/cli";
+export declare const schemaSource: (input: string) => Effect.Effect<URL, CliError.UserError, Path.Path>;
+export declare function asCliError(cause: unknown): CliError.UserError;

package/dist/commands/input.js

@@ -0,0 +1,16 @@
+import { Effect, Path } from "effect";
+import { CliError } from "effect/cli";
+export const schemaSource = Effect.fn("schemaSource")(function* (input) {
+    if (input.includes("*")) {
+        return yield* new CliError.UserError({ cause: "Globbing is unsupported." });
+    }
+    if (/^(https?:|file:)/i.test(input))
+        return new URL(input);
+    const path = yield* Path.Path;
+    return yield* Effect.mapError(path.toFileUrl(path.resolve(input)), (cause) => new CliError.UserError({ cause }));
+});
+export function asCliError(cause) {
+    if (CliError.isCliError(cause) && cause._tag === "UserError")
+        return cause;
+    return new CliError.UserError({ cause });
+}

package/dist/commands/lint/command.d.ts

@@ -0,0 +1,7 @@
+import { FileSystem, Path } from "effect";
+import { Command } from "effect/cli";
+import { HttpClient } from "effect/http";
+export declare const lint: Command.Command<"lint", {
+    readonly input: URL;
+    readonly strict: boolean;
+}, {}, import("effect/cli/CliError").UserError, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;

package/dist/commands/lint/command.js

@@ -0,0 +1,35 @@
+import { Linter } from "@shipworthy/openapi-validator";
+import { Effect, FileSystem, Path } from "effect";
+import { Argument, Command, Flag } from "effect/cli";
+import { HttpClient } from "effect/http";
+import { asCliError, schemaSource } from "../input.js";
+const readSource = Effect.fnUntraced(function* (input) {
+    if (input.protocol === "file:") {
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+        return yield* fs.readFileString(yield* path.fromFileUrl(input));
+    }
+    const client = (yield* HttpClient.HttpClient).pipe(HttpClient.filterStatusOk);
+    return yield* client.get(input.href).pipe(Effect.flatMap((response) => response.text));
+});
+const run = Effect.fn("run")(function* ({ input, strict }) {
+    const source = yield* readSource(input);
+    yield* Linter.use((linter) => linter.lintDocument(source, { sourceUrl: input.href, strict }));
+}, Effect.mapError(asCliError), Effect.provide(Linter.layer));
+export const lint = Command.make("lint", {
+    input: Argument.String("input").pipe(Argument.withDescription("OpenAPI schema file or URL."), Argument.mapEffect(schemaSource)),
+    strict: Flag.Boolean("strict").pipe(Flag.withDescription("Keep Spectral's oas rule severities and fail on YAML/JSON syntax errors."), Flag.withDefault(false)),
+}, run).pipe(Command.withDescription("Lint an OpenAPI schema and print diagnostics."), Command.withShortDescription("Lint an OpenAPI schema"), Command.withExamples([
+    {
+        command: "openapi lint ./openapi.yaml",
+        description: "Lint a local schema",
+    },
+    {
+        command: "openapi lint https://example.com/openapi.yaml",
+        description: "Lint a remote schema",
+    },
+    {
+        command: "openapi lint --strict ./openapi.yaml",
+        description: "Fail on every error-severity oas rule and on syntax errors",
+    },
+]));

package/dist/commands/overlay/command.d.ts

@@ -0,0 +1,9 @@
+import { FileSystem, Path } from "effect";
+import { Command } from "effect/cli";
+import { HttpClient } from "effect/http";
+export declare const overlay: Command.Command<"overlay", {
+    readonly input: URL;
+    readonly overlay: URL;
+    readonly output: string;
+    readonly removeUnusedComponents: boolean;
+}, {}, import("effect/cli/CliError").UserError, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;

package/dist/commands/overlay/command.js

@@ -0,0 +1,33 @@
+import { applyOverlayWithWarnings } from "@shipworthy/overlay";
+import { bundleDocument } from "@shipworthy/openapi-parser";
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { Argument, Command, Flag } from "effect/cli";
+import { HttpClient, HttpClientResponse } from "effect/http";
+import { fileURLToPath } from "node:url";
+import { asCliError, schemaSource } from "../input.js";
+const run = Effect.fn("overlay")(function* ({ input, overlay, output, removeUnusedComponents, }) {
+    const document = yield* bundleDocument(input);
+    const fs = yield* FileSystem.FileSystem;
+    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* 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.document);
+    yield* fs.writeFileString(outputPath, `${serialized}\n`);
+    yield* Console.log(`${input.href} + ${overlay.href} → ${output}`);
+}, Effect.mapError(asCliError));
+export const overlay = Command.make("overlay", {
+    input: Argument.String("input").pipe(Argument.withDescription("OpenAPI schema file or URL. Bundled before applying the overlay."), Argument.mapEffect(schemaSource)),
+    overlay: Flag.String("overlay").pipe(Flag.withDescription("Overlay JSON/YAML file or URL."), Flag.mapEffect(schemaSource)),
+    output: Flag.String("output").pipe(Flag.withAlias("o"), Flag.withDescription("Output JSON file. Parent directories are created.")),
+    removeUnusedComponents: Flag.Boolean("remove-unused-components").pipe(Flag.withDescription("Remove paths without operations and unreachable components after overlaying."), Flag.withDefault(false)),
+}, run).pipe(Command.withDescription("Bundle an OpenAPI document, then apply an OpenAPI Overlay."), Command.withShortDescription("Apply an OpenAPI Overlay"), Command.withExamples([
+    {
+        command: "openapi overlay openapi.yaml --overlay overlay.yaml -o bundled.openapi.json",
+        description: "Bundle a schema and apply an overlay before writing JSON",
+    },
+]));

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+export declare const version: Effect.Effect<string, import("effect/PlatformError").BadArgument | import("effect/PlatformError").PlatformError | Schema.SchemaError, FileSystem.FileSystem | Path.Path>;

package/dist/version.js

@@ -0,0 +1,10 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+const PackageJson = Schema.Struct({ version: Schema.String });
+export const version = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const filename = yield* path.fromFileUrl(new URL("../package.json", import.meta.url));
+    const source = yield* fs.readFileString(filename);
+    const manifest = yield* Schema.decodeEffect(Schema.fromJsonString(PackageJson))(source);
+    return manifest.version;
+});