@effect/openapi-generator 4.0.0-beta.0

package/src/ParsedOperation.ts

@@ -0,0 +1,43 @@
+import type * as Types from "effect/Types"
+import type { OpenAPISpecMethodName } from "effect/unstable/httpapi/OpenApi"
+
+export interface ParsedOperation {
+  readonly id: string
+  readonly method: OpenAPISpecMethodName
+  readonly description: string | undefined
+  readonly params?: string
+  readonly paramsOptional: boolean
+  readonly urlParams: ReadonlyArray<string>
+  readonly headers: ReadonlyArray<string>
+  readonly cookies: ReadonlyArray<string>
+  readonly payload?: string
+  readonly payloadFormData: boolean
+  readonly pathIds: ReadonlyArray<string>
+  readonly pathTemplate: string
+  readonly successSchemas: ReadonlyMap<string, string>
+  readonly errorSchemas: ReadonlyMap<string, string>
+  readonly voidSchemas: ReadonlySet<string>
+  // SSE streaming response schema (text/event-stream)
+  readonly sseSchema?: string
+  // Binary stream response (application/octet-stream)
+  readonly binaryResponse: boolean
+}
+
+export const makeDeepMutable = (options: {
+  readonly id: string
+  readonly method: OpenAPISpecMethodName
+  readonly pathIds: Array<string>
+  readonly pathTemplate: string
+  readonly description: string | undefined
+}): Types.DeepMutable<ParsedOperation> => ({
+  ...options,
+  urlParams: [],
+  headers: [],
+  cookies: [],
+  payloadFormData: false,
+  successSchemas: new Map(),
+  errorSchemas: new Map(),
+  voidSchemas: new Set(),
+  paramsOptional: true,
+  binaryResponse: false
+})

package/src/Utils.ts

@@ -0,0 +1,50 @@
+import * as String from "effect/String"
+import * as UndefinedOr from "effect/UndefinedOr"
+
+export const camelize = (self: string): string => {
+  let str = ""
+  let hadSymbol = false
+  for (let i = 0; i < self.length; i++) {
+    const charCode = self.charCodeAt(i)
+    if (
+      (charCode >= 65 && charCode <= 90) ||
+      (charCode >= 97 && charCode <= 122)
+    ) {
+      str += hadSymbol ? self[i].toUpperCase() : self[i]
+      hadSymbol = false
+    } else if (charCode >= 48 && charCode <= 57) {
+      if (str.length > 0) {
+        str += self[i]
+        hadSymbol = true
+      }
+    } else if (str.length > 0) {
+      hadSymbol = true
+    }
+  }
+  return str
+}
+
+export const identifier = (operationId: string) => String.capitalize(camelize(operationId))
+
+export const nonEmptyString = (a: unknown): string | undefined => {
+  if (typeof a === "string") {
+    const trimmed = String.trim(a)
+    if (String.isNonEmpty(trimmed)) {
+      return trimmed
+    }
+  }
+}
+
+export const toComment = UndefinedOr.match({
+  onUndefined: () => "",
+  onDefined: (description: string) =>
+    `/**
+* ${description.replace(/\*\//g, " * /").split("\n").join("\n* ")}
+*/\n`
+})
+
+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/bin.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as Effect from "effect/Effect"
+import { run } from "./main.ts"
+
+run.pipe(
+  Effect.provide(NodeServices.layer),
+  NodeRuntime.runMain
+)

package/src/main.ts

@@ -0,0 +1,68 @@
+import * as Console from "effect/Console"
+import * as Effect from "effect/Effect"
+import type * as Schema from "effect/Schema"
+import * as CliError from "effect/unstable/cli/CliError"
+import * as Command from "effect/unstable/cli/Command"
+import * as Flag from "effect/unstable/cli/Flag"
+import type { OpenAPISpec } from "effect/unstable/httpapi/OpenApi"
+import * as OpenApiGenerator from "./OpenApiGenerator.ts"
+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")
+)
+
+const name = Flag.string("name").pipe(
+  Flag.withAlias("n"),
+  Flag.withDescription("The name of the generated client"),
+  Flag.withDefault("Client")
+)
+
+const typeOnly = Flag.boolean("type-only").pipe(
+  Flag.withAlias("t"),
+  Flag.withDescription("Generate a type-only client without schemas")
+)
+
+const patch = Flag.string("patch").pipe(
+  Flag.withAlias("p"),
+  Flag.withDescription(
+    "JSON patch to apply to OpenAPI spec before generation. " +
+      "Can be a file path (.json, .yaml, .yml) or inline JSON array. " +
+      "Multiple patches are applied in order."
+  ),
+  Flag.between(0, Infinity)
+)
+
+const root = Command.make("openapigen", { spec, typeOnly, name, patch }).pipe(
+  Command.withHandler(Effect.fnUntraced(function*({ name, spec, typeOnly, patch }) {
+    let patchedSpec: Schema.Json = spec as Schema.Json
+
+    if (patch.length > 0) {
+      const parsedPatches = yield* Effect.forEach(
+        patch,
+        (input) =>
+          OpenApiPatch.parsePatchInput(input).pipe(
+            Effect.map((p) => ({ source: input, patch: p })),
+            Effect.mapError((error) => new CliError.UserError({ cause: error }))
+          )
+      )
+      patchedSpec = yield* OpenApiPatch.applyPatches(parsedPatches, patchedSpec).pipe(
+        Effect.mapError((error) => new CliError.UserError({ cause: error }))
+      )
+    }
+
+    const generator = yield* OpenApiGenerator.OpenApiGenerator
+    const source = yield* generator.generate(patchedSpec as unknown as OpenAPISpec, { name, typeOnly })
+    return yield* Console.log(source)
+  })),
+  Command.provide(({ typeOnly }) =>
+    typeOnly
+      ? OpenApiGenerator.layerTransformerTs
+      : OpenApiGenerator.layerTransformerSchema
+  )
+)
+
+export const run: Effect.Effect<void, CliError.CliError, Command.Environment> = Command.run(root, {
+  version: "0.0.0"
+})