@effect/openapi-generator 4.0.0-beta.66 → 4.0.0-beta.67

package/src/OpenApiGenerator.ts

@@ -1,3 +1,15 @@
+/**
+ * The `OpenApiGenerator` module orchestrates converting OpenAPI and Swagger
+ * documents into generated Effect source.
+ *
+ * It normalizes Swagger 2.0 input, resolves local references, builds the
+ * parsed operation model, registers request and response schemas, applies
+ * HttpApi-specific adaptations such as multipart helpers and security metadata,
+ * emits warnings for unsupported or lossy OpenAPI features, and then delegates
+ * final rendering to the HttpClient or HttpApi code generators.
+ *
+ * @since 4.0.0
+ */
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import type * as JsonSchema from "effect/JsonSchema"
@@ -12,13 +24,23 @@ import * as OpenApiTransformer from "./OpenApiTransformer.ts"
 import * as ParsedOperation from "./ParsedOperation.ts"
 import * as Utils from "./Utils.ts"
 
+/**
+ * Service for turning OpenAPI or Swagger specifications into generated Effect
+ * HTTP client or HttpApi source code.
+ */
 export class OpenApiGenerator extends Context.Service<
   OpenApiGenerator,
   { readonly generate: (spec: OpenAPISpec, options: OpenApiGenerateOptions) => Effect.Effect<string> }
 >()("OpenApiGenerator") {}
 
+/**
+ * Output targets supported by the OpenAPI generator.
+ */
 export type OpenApiGeneratorFormat = "httpclient" | "httpclient-type-only" | "httpapi"
 
+/**
+ * Stable identifiers for non-fatal OpenAPI generation warnings.
+ */
 export type OpenApiGeneratorWarningCode =
   | "cookie-parameter-dropped"
   | "additional-tags-dropped"
@@ -30,6 +52,10 @@ export type OpenApiGeneratorWarningCode =
   | "no-body-method-request-body-skipped"
   | "naming-collision"
 
+/**
+ * Describes a non-fatal issue encountered while mapping an OpenAPI operation to
+ * generated Effect source.
+ */
 export interface OpenApiGeneratorWarning {
   readonly code: OpenApiGeneratorWarningCode
   readonly message: string
@@ -38,6 +64,9 @@ export interface OpenApiGeneratorWarning {
   readonly operationId?: string | undefined
 }
 
+/**
+ * Options that control one OpenAPI generation run.
+ */
 export interface OpenApiGenerateOptions {
   /**
    * The name to give to the generated output.
@@ -73,6 +102,9 @@ const methodNames: ReadonlyArray<OpenAPISpecMethodName> = [
   "trace"
 ]
 
+/**
+ * Constructs the OpenAPI generator service implementation.
+ */
 export const make = Effect.gen(function*() {
   const generate = Effect.fn(
     function*(spec: OpenAPISpec, options: OpenApiGenerateOptions) {
@@ -1018,8 +1050,14 @@ function getDialect(spec: OpenAPISpec): "openapi-3.0" | "openapi-3.1" {
   return spec.openapi.trim().startsWith("3.0") ? "openapi-3.0" : "openapi-3.1"
 }
 
+/**
+ * Layer providing an OpenAPI generator for Schema-backed HTTP client and HttpApi output.
+ */
 export const layerTransformerSchema: Layer.Layer<OpenApiGenerator> = Layer.effect(OpenApiGenerator, make)
 
+/**
+ * Layer providing an OpenAPI generator for type-only HTTP client output.
+ */
 export const layerTransformerTs: Layer.Layer<OpenApiGenerator> = Layer.effect(OpenApiGenerator, make)
 
 const isSwaggerSpec = (spec: OpenAPISpec) => "swagger" in spec

package/src/OpenApiPatch.ts

@@ -6,8 +6,6 @@
  * - JSON files (.json)
  * - YAML files (.yaml, .yml)
  * - Inline JSON strings
- *
- * @module OpenApiPatch
  */
 
 import * as Effect from "effect/Effect"
@@ -31,7 +29,8 @@ import * as Yaml from "yaml"
  * - JSON or YAML syntax is invalid
  * - The file format is unsupported
  *
- * @example
+ * **Example** (Creating a parse error)
+ *
  * ```ts
  * import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
  *
@@ -44,8 +43,8 @@ import * as Yaml from "yaml"
  * // "Failed to parse patch from ./patches/fix.json: Unexpected token at position 42"
  * ```
  *
- * @since 1.0.0
  * @category errors
+ * @since 4.0.0
  */
 export class JsonPatchParseError extends Schema.ErrorClass<JsonPatchParseError>("JsonPatchParseError")({
   _tag: Schema.tag("JsonPatchParseError"),
@@ -66,7 +65,8 @@ export class JsonPatchParseError extends Schema.ErrorClass<JsonPatchParseError>(
  * - An operation has an unsupported op value
  * - An add/replace operation is missing the value field
  *
- * @example
+ * **Example** (Creating a validation error)
+ *
  * ```ts
  * import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
  *
@@ -79,8 +79,8 @@ export class JsonPatchParseError extends Schema.ErrorClass<JsonPatchParseError>(
  * // "Invalid JSON Patch from inline: Expected 'add' | 'remove' | 'replace' at [0].op, got 'copy'"
  * ```
  *
- * @since 1.0.0
  * @category errors
+ * @since 4.0.0
  */
 export class JsonPatchValidationError extends Schema.ErrorClass<JsonPatchValidationError>("JsonPatchValidationError")({
   _tag: Schema.tag("JsonPatchValidationError"),
@@ -100,7 +100,8 @@ export class JsonPatchValidationError extends Schema.ErrorClass<JsonPatchValidat
  * - An array index is out of bounds
  * - The target location is not a valid container
  *
- * @example
+ * **Example** (Creating an application error)
+ *
  * ```ts
  * import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
  *
@@ -116,8 +117,8 @@ export class JsonPatchValidationError extends Schema.ErrorClass<JsonPatchValidat
  * // "Failed to apply patch from ./patches/fix.json: operation 2 (remove at /paths/~1users): Property \"users\" does not exist"
  * ```
  *
- * @since 1.0.0
  * @category errors
+ * @since 4.0.0
  */
 export class JsonPatchApplicationError
   extends Schema.ErrorClass<JsonPatchApplicationError>("JsonPatchApplicationError")({
@@ -141,7 +142,8 @@ export class JsonPatchApplicationError
  * This error aggregates all application errors so users can see every
  * failing operation at once instead of fixing them one at a time.
  *
- * @example
+ * **Example** (Creating an aggregate error)
+ *
  * ```ts
  * import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
  *
@@ -168,8 +170,8 @@ export class JsonPatchApplicationError
  * // "2 patch operations failed:\n  1. ..."
  * ```
  *
- * @since 1.0.0
  * @category errors
+ * @since 4.0.0
  */
 export class JsonPatchAggregateError extends Schema.ErrorClass<JsonPatchAggregateError>("JsonPatchAggregateError")({
   _tag: Schema.tag("JsonPatchAggregateError"),
@@ -193,8 +195,8 @@ export class JsonPatchAggregateError extends Schema.ErrorClass<JsonPatchAggregat
 /**
  * Schema for a JSON Patch "add" operation.
  *
- * @since 1.0.0
  * @category schemas
+ * @since 4.0.0
  */
 export const JsonPatchAdd: Schema.Codec<
   Extract<
@@ -211,8 +213,8 @@ export const JsonPatchAdd: Schema.Codec<
 /**
  * Schema for a JSON Patch "remove" operation.
  *
- * @since 1.0.0
  * @category schemas
+ * @since 4.0.0
  */
 export const JsonPatchRemove: Schema.Codec<
   Extract<
@@ -228,8 +230,8 @@ export const JsonPatchRemove: Schema.Codec<
 /**
  * Schema for a JSON Patch "replace" operation.
  *
- * @since 1.0.0
  * @category schemas
+ * @since 4.0.0
  */
 export const JsonPatchReplace: Schema.Codec<
   Extract<
@@ -249,8 +251,8 @@ export const JsonPatchReplace: Schema.Codec<
  * Supports the subset of RFC 6902 operations that Effect's JsonPatch module
  * implements: `add`, `remove`, and `replace`.
  *
- * @since 1.0.0
  * @category schemas
+ * @since 4.0.0
  */
 export const JsonPatchOperation: Schema.Codec<JsonPatch.JsonPatchOperation> = Schema.Union([
   JsonPatchAdd,
@@ -265,7 +267,8 @@ export const JsonPatchOperation: Schema.Codec<JsonPatch.JsonPatchOperation> = Sc
  * document. Operations are applied in sequence, with each operation seeing
  * the result of previous operations.
  *
- * @example
+ * **Example** (Decoding a patch document)
+ *
  * ```ts
  * import { Schema } from "effect"
  * import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
@@ -277,16 +280,16 @@ export const JsonPatchOperation: Schema.Codec<JsonPatch.JsonPatchOperation> = Sc
  * ])
  * ```
  *
- * @since 1.0.0
  * @category schemas
+ * @since 4.0.0
  */
 export const JsonPatchDocument = Schema.Array(JsonPatchOperation)
 
 /**
  * Type for a JSON Patch document.
  *
- * @since 1.0.0
  * @category types
+ * @since 4.0.0
  */
 export type JsonPatchDocument = typeof JsonPatchDocument.Type
 
@@ -413,7 +416,8 @@ const parseInlinePatch = Effect.fn("parseInlinePatch")(function*(input: string)
  * and parsed based on its extension (.json, .yaml, .yml). Otherwise, the
  * input is parsed as inline JSON.
  *
- * @example
+ * **Example** (Parsing patch input)
+ *
  * ```ts
  * import { Effect } from "effect"
  * import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
@@ -433,8 +437,8 @@ const parseInlinePatch = Effect.fn("parseInlinePatch")(function*(input: string)
  * })
  * ```
  *
- * @since 1.0.0
  * @category parsing
+ * @since 4.0.0
  */
 export const parsePatchInput = Effect.fn("parsePatchInput")(function*(input: string) {
   if (looksLikeFilePath(input)) {
@@ -457,7 +461,8 @@ export const parsePatchInput = Effect.fn("parsePatchInput")(function*(input: str
  * the previous one. All operations are attempted, and if any fail, the errors
  * are accumulated and reported together so users can fix all issues at once.
  *
- * @example
+ * **Example** (Applying patches)
+ *
  * ```ts
  * import { Effect } from "effect"
  * import * as OpenApiPatch from "@effect/openapi-generator/OpenApiPatch"
@@ -477,8 +482,8 @@ export const parsePatchInput = Effect.fn("parsePatchInput")(function*(input: str
  * })
  * ```
  *
- * @since 1.0.0
  * @category application
+ * @since 4.0.0
  */
 export const applyPatches = Effect.fn("applyPatches")(function*(
   patches: ReadonlyArray<{ readonly source: string; readonly patch: JsonPatchDocument }>,

package/src/OpenApiTransformer.ts

@@ -1,9 +1,32 @@
+/**
+ * OpenAPI-to-HttpClient code generation for the OpenAPI generator.
+ *
+ * This module defines the `OpenApiTransformer` service used to render parsed
+ * OpenAPI operations into Effect `HttpClient` modules. It provides both
+ * schema-backed and type-only transformer implementations, including generated
+ * imports, public client interfaces, operation implementations, typed API
+ * errors, optional response handling, and helpers for server-sent events and
+ * binary response streams.
+ *
+ * @since 4.0.0
+ */
 import * as Context from "effect/Context"
 import * as Layer from "effect/Layer"
 import * as Predicate from "effect/Predicate"
 import type { ParsedOpenApi, ParsedOperation } from "./ParsedOperation.ts"
 import * as Utils from "./Utils.ts"
 
+/**
+ * Service used by the OpenAPI generator to render parsed operations as an
+ * Effect HttpClient module.
+ *
+ * A transformer owns the code-generation dialect for imports, public client
+ * types, and the implementation body. The generator swaps implementations to
+ * choose between schema-backed clients and type-only clients.
+ *
+ * @category code generation
+ * @since 4.0.0
+ */
 export class OpenApiTransformer extends Context.Service<
   OpenApiTransformer,
   {
@@ -35,6 +58,16 @@ const computeImportRequirements = (operations: ReadonlyArray<ParsedOperation>):
 const requiresStreaming = (requirements: ImportRequirements): boolean =>
   requirements.eventStream || requirements.octetStream
 
+/**
+ * Create the transformer used for schema-backed HttpClient output.
+ *
+ * Generated clients import Effect Schema values and use them at runtime to
+ * decode successful responses and typed API errors. Request parameters and
+ * payloads are typed against each schema's encoded representation.
+ *
+ * @category code generation
+ * @since 4.0.0
+ */
 export const makeTransformerSchema = () => {
   const operationsToInterface = (
     _importName: string,
@@ -417,11 +450,31 @@ export const make = (
   })
 }
 
+/**
+ * Layer that provides the schema-backed OpenApiTransformer service.
+ *
+ * Use this layer when generated HttpClient code should perform runtime response
+ * decoding with generated Effect Schema values.
+ *
+ * @category code generation
+ * @since 4.0.0
+ */
 export const layerTransformerSchema = Layer.sync(
   OpenApiTransformer,
   makeTransformerSchema
 )
 
+/**
+ * Create the transformer used for type-only HttpClient output.
+ *
+ * Generated clients reference emitted TypeScript types directly and do not
+ * import schema decoders for JSON response bodies. Responses are typed as the
+ * declared operation result while preserving generated error and stream method
+ * shapes.
+ *
+ * @category code generation
+ * @since 4.0.0
+ */
 export const makeTransformerTs = () => {
   const operationsToInterface = (
     _importName: string,
@@ -803,6 +856,16 @@ export const make = (
   })
 }
 
+/**
+ * Layer that provides the type-only OpenApiTransformer service.
+ *
+ * Use this layer for the `httpclient-type-only` generator format, where the
+ * generated client relies on TypeScript types instead of runtime Schema
+ * decoding.
+ *
+ * @category code generation
+ * @since 4.0.0
+ */
 export const layerTransformerTs = Layer.sync(
   OpenApiTransformer,
   makeTransformerTs

package/src/ParsedOperation.ts

@@ -1,3 +1,15 @@
+/**
+ * Normalized OpenAPI operation model shared by the generator pipeline.
+ *
+ * This module records the shape produced after an OpenAPI document is resolved
+ * into stable generator inputs: document metadata, tags, security schemes,
+ * per-operation parameters, request bodies, response media types, derived
+ * schema references, path templates, and streaming capabilities. Renderers
+ * consume this representation to emit HttpClient or HttpApi modules without
+ * reinterpreting raw OpenAPI path-item structures.
+ *
+ * @since 4.0.0
+ */
 import type * as Types from "effect/Types"
 import type {
   OpenAPISecurityRequirement,
@@ -7,6 +19,9 @@ import type {
   OpenAPISpecServer
 } from "effect/unstable/httpapi/OpenApi"
 
+/**
+ * Root OpenAPI metadata preserved for generated client and HttpApi output.
+ */
 export interface ParsedOpenApiMetadata {
   readonly title: string
   readonly version: string
@@ -16,12 +31,18 @@ export interface ParsedOpenApiMetadata {
   readonly servers: ReadonlyArray<OpenAPISpecServer> | undefined
 }
 
+/**
+ * Tag metadata used to group and annotate generated operations.
+ */
 export interface ParsedOpenApiTag {
   readonly name: string
   readonly description: string | undefined
   readonly externalDocs: OpenAPISpecExternalDocs | undefined
 }
 
+/**
+ * Supported security scheme extracted from an OpenAPI components section.
+ */
 export interface ParsedOpenApiSecurityScheme {
   readonly name: string
   readonly type: "basic" | "bearer" | "apiKey"
@@ -31,6 +52,9 @@ export interface ParsedOpenApiSecurityScheme {
   readonly in: "header" | "query" | "cookie" | undefined
 }
 
+/**
+ * Normalized OpenAPI document consumed by the generator renderers.
+ */
 export interface ParsedOpenApi {
   readonly metadata: ParsedOpenApiMetadata
   readonly tags: ReadonlyArray<ParsedOpenApiTag>
@@ -38,6 +62,9 @@ export interface ParsedOpenApi {
   readonly operations: ReadonlyArray<ParsedOperation>
 }
 
+/**
+ * Documentation and lifecycle metadata associated with an operation.
+ */
 export interface ParsedOperationMetadata {
   readonly summary: string | undefined
   readonly description: string | undefined
@@ -45,6 +72,9 @@ export interface ParsedOperationMetadata {
   readonly externalDocs: OpenAPISpecExternalDocs | undefined
 }
 
+/**
+ * Resolved OpenAPI parameter grouped by where it appears in the request.
+ */
 export interface ParsedOperationParameter {
   readonly name: string
   readonly in: "path" | "query" | "header" | "cookie"
@@ -53,11 +83,17 @@ export interface ParsedOperationParameter {
   readonly schema: {}
 }
 
+/**
+ * Summary of the request body declaration before per-media schemas are rendered.
+ */
 export interface ParsedOperationRequestBody {
   readonly required: boolean
   readonly contentTypes: Array<string>
 }
 
+/**
+ * Encoding strategy the generator can use for a request or response media type.
+ */
 export type ParsedOperationMediaTypeEncoding =
   | "json"
   | "multipart"
@@ -65,12 +101,18 @@ export type ParsedOperationMediaTypeEncoding =
   | "text"
   | "binary"
 
+/**
+ * Media type whose schema can be represented in generated Effect code.
+ */
 export interface ParsedOperationMediaTypeSchema {
   readonly contentType: string
   readonly encoding: ParsedOperationMediaTypeEncoding
   readonly schema: string
 }
 
+/**
+ * Parsed response metadata together with generated schema references.
+ */
 export interface ParsedOperationResponse {
   readonly status: string
   readonly description: string | undefined
@@ -80,8 +122,14 @@ export interface ParsedOperationResponse {
   readonly representable: ReadonlyArray<ParsedOperationMediaTypeSchema>
 }
 
+/**
+ * Resolved security requirement applied to a parsed operation.
+ */
 export type ParsedOperationSecurityRequirement = Readonly<OpenAPISecurityRequirement>
 
+/**
+ * Normalized operation model shared by all OpenAPI generator backends.
+ */
 export interface ParsedOperation {
   readonly id: string
   readonly operationId: string | undefined
@@ -125,6 +173,9 @@ export interface ParsedOperation {
   readonly binaryResponse: boolean
 }
 
+/**
+ * Creates a mutable operation accumulator populated with parser defaults.
+ */
 export const makeDeepMutable = (options: {
   readonly id: string
   readonly method: OpenAPISpecMethodName

package/src/Utils.ts

@@ -1,6 +1,22 @@
+/**
+ * Shared utility helpers for the OpenAPI generator.
+ *
+ * This module centralizes the small transformations used while rendering
+ * generated TypeScript, including operation-name normalization, optional
+ * description handling, safe JSDoc comment emission, and direct array merging
+ * for code-generation accumulators.
+ *
+ * @since 4.0.0
+ */
 import * as String from "effect/String"
 import * as UndefinedOr from "effect/UndefinedOr"
 
+/**
+ * Converts an OpenAPI name into the generator's camel-case form.
+ *
+ * Separators are removed, leading digits are ignored, and letters following a
+ * separator or digit are upper-cased without otherwise changing letter casing.
+ */
 export const camelize = (self: string): string => {
   let str = ""
   let hadSymbol = false
@@ -24,8 +40,18 @@ export const camelize = (self: string): string => {
   return str
 }
 
+/**
+ * Converts an OpenAPI operation id into the exported operation identifier used
+ * by generated TypeScript modules.
+ */
 export const identifier = (operationId: string) => String.capitalize(camelize(operationId))
 
+/**
+ * Extracts a trimmed, non-empty string from an unknown value.
+ *
+ * Returns `undefined` for non-string values and for strings containing only
+ * whitespace.
+ */
 export const nonEmptyString = (a: unknown): string | undefined => {
   if (typeof a === "string") {
     const trimmed = String.trim(a)
@@ -35,6 +61,12 @@ export const nonEmptyString = (a: unknown): string | undefined => {
   }
 }
 
+/**
+ * Renders an optional description as a JSDoc block for generated TypeScript.
+ *
+ * Returns an empty string when the description is absent and escapes any
+ * closing comment marker so generated source remains syntactically valid.
+ */
 export const toComment = UndefinedOr.match({
   onUndefined: () => "",
   onDefined: (description: string) =>
@@ -43,6 +75,12 @@ export const toComment = UndefinedOr.match({
 */\n`
 })
 
+/**
+ * Appends every element from `source` into `destination` in order.
+ *
+ * This mutates `destination` directly, which avoids allocating an intermediate
+ * array when generator code needs to merge collections.
+ */
 export const spreadElementsInto = <A>(source: Array<A>, destination: Array<A>): void => {
   for (let i = 0; i < source.length; i++) {
     destination.push(source[i])

package/src/main.ts

@@ -1,3 +1,13 @@
+/**
+ * Command-line entry point for generating Effect HTTP clients or HttpApi
+ * definitions from an OpenAPI specification.
+ *
+ * The CLI reads a spec file, optionally applies JSON patches in order, selects
+ * the generator layer for the requested output format, reports generation
+ * warnings to stderr, and writes the generated source to stdout.
+ *
+ * @since 4.0.0
+ */
 import * as Console from "effect/Console"
 import * as Effect from "effect/Effect"
 import type * as Schema from "effect/Schema"
@@ -78,6 +88,13 @@ const root = Command.make("openapigen", { spec, format, name, patch }).pipe(
   )
 )
 
+/**
+ * Runs the OpenAPI generator command-line program.
+ *
+ * The command reads an OpenAPI specification, optionally applies JSON patches,
+ * generates source code in the selected format, writes any generation warnings
+ * to stderr, and prints the generated source to stdout.
+ */
 export const run: Effect.Effect<void, CliError.CliError, Command.Environment> = Command.run(root, {
   version: "0.0.0"
 })