@effect/openapi-generator 4.0.0-beta.40 → 4.0.0-beta.41

package/src/OpenApiTransformer.ts

@@ -1,15 +1,15 @@
 import * as Layer from "effect/Layer"
 import * as Predicate from "effect/Predicate"
 import * as ServiceMap from "effect/ServiceMap"
-import type { ParsedOperation } from "./ParsedOperation.ts"
+import type { ParsedOpenApi, ParsedOperation } from "./ParsedOperation.ts"
 import * as Utils from "./Utils.ts"
 
 export class OpenApiTransformer extends ServiceMap.Service<
   OpenApiTransformer,
   {
-    readonly imports: (importName: string, operations: ReadonlyArray<ParsedOperation>) => string
-    readonly toTypes: (importName: string, name: string, operations: ReadonlyArray<ParsedOperation>) => string
-    readonly toImplementation: (importName: string, name: string, operations: ReadonlyArray<ParsedOperation>) => string
+    readonly imports: (importName: string, parsed: ParsedOpenApi) => string
+    readonly toTypes: (importName: string, name: string, parsed: ParsedOpenApi) => string
+    readonly toImplementation: (importName: string, name: string, parsed: ParsedOpenApi) => string
   }
 >()("OpenApiTransformer") {}
 
@@ -382,7 +382,8 @@ export const make = (
   }
 
   return OpenApiTransformer.of({
-    imports: (importName, operations) => {
+    imports: (importName, parsed) => {
+      const operations = parsed.operations
       const requirements = computeImportRequirements(operations)
       const imports = [
         `import * as Data from "effect/Data"`,
@@ -409,8 +410,8 @@ export const make = (
       )
       return imports.join("\n")
     },
-    toTypes: operationsToInterface,
-    toImplementation: operationsToImpl
+    toTypes: (importName, name, parsed) => operationsToInterface(importName, name, parsed.operations),
+    toImplementation: (importName, name, parsed) => operationsToImpl(importName, name, parsed.operations)
   })
 }
 
@@ -777,7 +778,8 @@ export const make = (
   }
 
   return OpenApiTransformer.of({
-    imports: (_importName, operations) => {
+    imports: (_importName, parsed) => {
+      const operations = parsed.operations
       const requirements = computeImportRequirements(operations)
       const imports = [
         `import * as Data from "effect/Data"`,
@@ -794,8 +796,8 @@ export const make = (
       )
       return imports.join("\n")
     },
-    toTypes: operationsToInterface,
-    toImplementation: operationsToImpl
+    toTypes: (importName, name, parsed) => operationsToInterface(importName, name, parsed.operations),
+    toImplementation: (importName, name, parsed) => operationsToImpl(importName, name, parsed.operations)
   })
 }
 

package/src/ParsedOperation.ts

@@ -1,9 +1,104 @@
 import type * as Types from "effect/Types"
-import type { OpenAPISpecMethodName } from "effect/unstable/httpapi/OpenApi"
+import type {
+  OpenAPISecurityRequirement,
+  OpenAPISpecExternalDocs,
+  OpenAPISpecLicense,
+  OpenAPISpecMethodName,
+  OpenAPISpecServer
+} from "effect/unstable/httpapi/OpenApi"
+
+export interface ParsedOpenApiMetadata {
+  readonly title: string
+  readonly version: string
+  readonly summary: string | undefined
+  readonly description: string | undefined
+  readonly license: OpenAPISpecLicense | undefined
+  readonly servers: ReadonlyArray<OpenAPISpecServer> | undefined
+}
+
+export interface ParsedOpenApiTag {
+  readonly name: string
+  readonly description: string | undefined
+  readonly externalDocs: OpenAPISpecExternalDocs | undefined
+}
+
+export interface ParsedOpenApiSecurityScheme {
+  readonly name: string
+  readonly type: "basic" | "bearer" | "apiKey"
+  readonly description: string | undefined
+  readonly bearerFormat: string | undefined
+  readonly key: string | undefined
+  readonly in: "header" | "query" | "cookie" | undefined
+}
+
+export interface ParsedOpenApi {
+  readonly metadata: ParsedOpenApiMetadata
+  readonly tags: ReadonlyArray<ParsedOpenApiTag>
+  readonly securitySchemes: ReadonlyArray<ParsedOpenApiSecurityScheme>
+  readonly operations: ReadonlyArray<ParsedOperation>
+}
+
+export interface ParsedOperationMetadata {
+  readonly summary: string | undefined
+  readonly description: string | undefined
+  readonly deprecated: boolean
+  readonly externalDocs: OpenAPISpecExternalDocs | undefined
+}
+
+export interface ParsedOperationParameter {
+  readonly name: string
+  readonly in: "path" | "query" | "header" | "cookie"
+  readonly required: boolean
+  readonly description: string | undefined
+  readonly schema: {}
+}
+
+export interface ParsedOperationRequestBody {
+  readonly required: boolean
+  readonly contentTypes: Array<string>
+}
+
+export type ParsedOperationMediaTypeEncoding =
+  | "json"
+  | "multipart"
+  | "form-url-encoded"
+  | "text"
+  | "binary"
+
+export interface ParsedOperationMediaTypeSchema {
+  readonly contentType: string
+  readonly encoding: ParsedOperationMediaTypeEncoding
+  readonly schema: string
+}
+
+export interface ParsedOperationResponse {
+  readonly status: string
+  readonly description: string | undefined
+  readonly contentTypes: Array<string>
+  readonly hasHeaders: boolean
+  readonly isEmpty: boolean
+  readonly representable: ReadonlyArray<ParsedOperationMediaTypeSchema>
+}
+
+export type ParsedOperationSecurityRequirement = Readonly<OpenAPISecurityRequirement>
 
 export interface ParsedOperation {
   readonly id: string
+  readonly operationId: string | undefined
+  readonly path: string
   readonly method: OpenAPISpecMethodName
+  readonly tags: ReadonlyArray<string>
+  readonly metadata: ParsedOperationMetadata
+  readonly parameters: {
+    readonly path: ReadonlyArray<ParsedOperationParameter>
+    readonly query: ReadonlyArray<ParsedOperationParameter>
+    readonly header: ReadonlyArray<ParsedOperationParameter>
+    readonly cookie: ReadonlyArray<ParsedOperationParameter>
+  }
+  readonly requestBody: ParsedOperationRequestBody | undefined
+  readonly responses: ReadonlyArray<ParsedOperationResponse>
+  readonly defaultResponse: ParsedOperationResponse | undefined
+  readonly effectiveSecurity: ReadonlyArray<ParsedOperationSecurityRequirement>
   readonly description: string | undefined
   readonly params?: string
   readonly paramsOptional: boolean
@@ -12,6 +107,12 @@ export interface ParsedOperation {
   readonly cookies: ReadonlyArray<string>
   readonly payload?: string
   readonly payloadFormData: boolean
+  readonly pathSchema: string | undefined
+  readonly querySchema: string | undefined
+  readonly querySchemaOptional: boolean
+  readonly headersSchema: string | undefined
+  readonly headersSchemaOptional: boolean
+  readonly requestBodyRepresentable: ReadonlyArray<ParsedOperationMediaTypeSchema>
   readonly pathIds: ReadonlyArray<string>
   readonly pathTemplate: string
   readonly successSchemas: ReadonlyMap<string, string>
@@ -31,10 +132,35 @@ export const makeDeepMutable = (options: {
   readonly description: string | undefined
 }): Types.DeepMutable<ParsedOperation> => ({
   ...options,
+  operationId: undefined,
+  path: "",
+  tags: [],
+  metadata: {
+    summary: undefined,
+    description: options.description,
+    deprecated: false,
+    externalDocs: undefined
+  },
+  parameters: {
+    path: [],
+    query: [],
+    header: [],
+    cookie: []
+  },
+  requestBody: undefined,
+  responses: [],
+  defaultResponse: undefined,
+  effectiveSecurity: [],
   urlParams: [],
   headers: [],
   cookies: [],
   payloadFormData: false,
+  pathSchema: undefined,
+  querySchema: undefined,
+  querySchemaOptional: true,
+  headersSchema: undefined,
+  headersSchemaOptional: true,
+  requestBodyRepresentable: [],
   successSchemas: new Map(),
   errorSchemas: new Map(),
   voidSchemas: new Set(),

package/src/main.ts

@@ -10,18 +10,21 @@ import * as OpenApiPatch from "./OpenApiPatch.ts"
 
 const spec = Flag.fileParse("spec").pipe(
   Flag.withAlias("s"),
-  Flag.withDescription("The OpenAPI spec file to generate the client from")
+  Flag.withDescription("The OpenAPI spec file to generate output from")
 )
 
 const name = Flag.string("name").pipe(
   Flag.withAlias("n"),
-  Flag.withDescription("The name of the generated client"),
+  Flag.withDescription("The name of the generated output"),
   Flag.withDefault("Client")
 )
 
-const typeOnly = Flag.boolean("type-only").pipe(
-  Flag.withAlias("t"),
-  Flag.withDescription("Generate a type-only client without schemas")
+const format = Flag.choice("format", ["httpclient", "httpclient-type-only", "httpapi"] as const).pipe(
+  Flag.withAlias("f"),
+  Flag.withDescription(
+    "Output format to generate: httpclient | httpclient-type-only | httpapi (default: httpclient)"
+  ),
+  Flag.withDefault("httpclient")
 )
 
 const patch = Flag.string("patch").pipe(
@@ -34,8 +37,8 @@ const patch = Flag.string("patch").pipe(
   Flag.between(0, Infinity)
 )
 
-const root = Command.make("openapigen", { spec, typeOnly, name, patch }).pipe(
-  Command.withHandler(Effect.fnUntraced(function*({ name, spec, typeOnly, patch }) {
+const root = Command.make("openapigen", { spec, format, name, patch }).pipe(
+  Command.withHandler(Effect.fnUntraced(function*({ name, spec, format, patch }) {
     let patchedSpec: Schema.Json = spec as Schema.Json
 
     if (patch.length > 0) {
@@ -53,11 +56,23 @@ const root = Command.make("openapigen", { spec, typeOnly, name, patch }).pipe(
     }
 
     const generator = yield* OpenApiGenerator.OpenApiGenerator
-    const source = yield* generator.generate(patchedSpec as unknown as OpenAPISpec, { name, typeOnly })
+    const warnings: Array<OpenApiGenerator.OpenApiGeneratorWarning> = []
+    const source = yield* generator.generate(patchedSpec as unknown as OpenAPISpec, {
+      name,
+      format,
+      onWarning: (warning) => {
+        warnings.push(warning)
+      }
+    })
+    yield* Effect.forEach(
+      warnings,
+      (warning) => Console.error(formatWarning(warning)),
+      { discard: true }
+    )
     return yield* Console.log(source)
   })),
-  Command.provide(({ typeOnly }) =>
-    typeOnly
+  Command.provide(({ format }) =>
+    format === "httpclient-type-only"
       ? OpenApiGenerator.layerTransformerTs
       : OpenApiGenerator.layerTransformerSchema
   )
@@ -66,3 +81,14 @@ const root = Command.make("openapigen", { spec, typeOnly, name, patch }).pipe(
 export const run: Effect.Effect<void, CliError.CliError, Command.Environment> = Command.run(root, {
   version: "0.0.0"
 })
+
+const formatWarning = (warning: OpenApiGenerator.OpenApiGeneratorWarning): string => {
+  const context = [
+    warning.method?.toUpperCase(),
+    warning.path,
+    warning.operationId ? `(${warning.operationId})` : undefined
+  ].filter((value): value is string => value !== undefined)
+  return context.length > 0
+    ? `WARNING [${warning.code}] ${context.join(" ")}: ${warning.message}`
+    : `WARNING [${warning.code}] ${warning.message}`
+}