@prover-coder-ai/openapi-effect 1.0.19

package/src/generated/decoders.ts

@@ -0,0 +1,318 @@
+// CHANGE: Auto-generated decoder stubs for all operations
+// WHY: Provide type-safe runtime validation entry points
+// QUOTE(ТЗ): "при изменении схемы сборка обязана падать, пока декодеры не обновлены"
+// REF: issue-2, section 5.2
+// SOURCE: Generated from tests/fixtures/petstore.openapi.json
+// FORMAT THEOREM: ∀ op, status: decoder(op, status) → Effect<T, DecodeError, never>
+// PURITY: SHELL
+// EFFECT: Effect<T, DecodeError, never>
+// INVARIANT: All decoders return typed DecodeError on failure
+// COMPLEXITY: O(n) where n = size of parsed object
+
+import { Effect } from "effect"
+import type { DecodeError } from "../core/api-client/strict-types.js"
+
+/**
+ * JSON value type - result of JSON.parse()
+ */
+type Json = null | boolean | number | string | ReadonlyArray<Json> | { readonly [k: string]: Json }
+
+/**
+ * Decoder for listPets status 200 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodelistPets_200 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for listPets status 500 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodelistPets_500 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for createPet status 201 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodecreatePet_201 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for createPet status 400 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodecreatePet_400 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for createPet status 500 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodecreatePet_500 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for getPet status 200 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodegetPet_200 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for getPet status 404 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodegetPet_404 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for getPet status 500 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodegetPet_500 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for deletePet status 404 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodedeletePet_404 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}
+
+/**
+ * Decoder for deletePet status 500 (application/json)
+ * STUB: Replace with real schema decoder when needed
+ *
+ * @pure false - performs validation
+ * @effect Effect<T, DecodeError, never>
+ */
+export const decodedeletePet_500 = (
+  _status: number,
+  _contentType: string,
+  _body: string,
+  parsed: Json
+): Effect.Effect<Json, DecodeError> => {
+  // STUB: Always succeeds with parsed value
+  // Replace with: Schema.decodeUnknown(YourSchema)(parsed)
+  return Effect.succeed(parsed)
+
+  // Example of real decoder:
+  // return Effect.mapError(
+  //   Schema.decodeUnknown(YourSchema)(parsed),
+  //   (error): DecodeError => ({
+  //     _tag: "DecodeError",
+  //     status,
+  //     contentType,
+  //     error,
+  //     body
+  //   })
+  // )
+}

package/src/generated/dispatch.ts

@@ -0,0 +1,172 @@
+// CHANGE: Auto-generated dispatchers for all operations with Effect-native error handling
+// WHY: Maintain compile-time correlation between status codes and body types
+// QUOTE(ТЗ): "реализует switch(status) по всем статусам схемы; Failure включает все инварианты протокола и схемы"
+// REF: issue-2, section 5.2, 4.1-4.3
+// SOURCE: Generated from tests/fixtures/petstore.openapi.json
+// FORMAT THEOREM: ∀ op ∈ Operations: dispatcher(op) → Effect<ApiSuccess, HttpError | BoundaryError>
+// PURITY: SHELL
+// EFFECT: Effect<ApiSuccess<Responses>, HttpError<Responses> | BoundaryError, never>
+// INVARIANT: 2xx → success channel, non-2xx → error channel (forced handling)
+// COMPLEXITY: O(1) per dispatch (Match lookup)
+
+import { Effect, Match } from "effect"
+import type { Operations } from "../../tests/fixtures/petstore.openapi.js"
+import type { DecodeError, ResponsesFor } from "../core/api-client/strict-types.js"
+import { asConst, type Json } from "../core/axioms.js"
+import {
+  createDispatcher,
+  parseJSON,
+  unexpectedContentType,
+  unexpectedStatus
+} from "../shell/api-client/strict-client.js"
+import * as Decoders from "./decoders.js"
+
+// Response types for each operation - used for type inference
+type ListPetsResponses = ResponsesFor<Operations["listPets"]>
+type CreatePetResponses = ResponsesFor<Operations["createPet"]>
+type GetPetResponses = ResponsesFor<Operations["getPet"]>
+type DeletePetResponses = ResponsesFor<Operations["deletePet"]>
+
+/**
+ * Helper: process JSON content type for a given status - returns SUCCESS variant
+ * Used for 2xx responses that go to the success channel
+ */
+const processJsonContentSuccess = <S extends number, D>(
+  status: S,
+  contentType: string | undefined,
+  text: string,
+  decoder: (
+    s: number,
+    ct: string,
+    body: string,
+    parsed: Json
+  ) => Effect.Effect<D, DecodeError>
+) =>
+  contentType?.includes("application/json")
+    ? Effect.gen(function*() {
+      const parsed = yield* parseJSON(status, "application/json", text)
+      const decoded = yield* decoder(status, "application/json", text, parsed)
+      return asConst({
+        status,
+        contentType: "application/json" as const,
+        body: decoded
+      })
+    })
+    : Effect.fail(unexpectedContentType(status, ["application/json"], contentType, text))
+
+/**
+ * Helper: process JSON content type for a given status - returns HTTP ERROR variant
+ * Used for non-2xx responses (4xx, 5xx) that go to the error channel.
+ *
+ * Adds `_tag: "HttpError"` discriminator to distinguish from BoundaryError.
+ */
+const processJsonContentError = <S extends number, D>(
+  status: S,
+  contentType: string | undefined,
+  text: string,
+  decoder: (
+    s: number,
+    ct: string,
+    body: string,
+    parsed: Json
+  ) => Effect.Effect<D, DecodeError>
+) =>
+  contentType?.includes("application/json")
+    ? Effect.gen(function*() {
+      const parsed = yield* parseJSON(status, "application/json", text)
+      const decoded = yield* decoder(status, "application/json", text, parsed)
+      // Non-2xx: Return as FAILURE with _tag discriminator (goes to error channel)
+      return yield* Effect.fail(asConst({
+        _tag: "HttpError" as const,
+        status,
+        contentType: "application/json" as const,
+        body: decoded
+      }))
+    })
+    : Effect.fail(unexpectedContentType(status, ["application/json"], contentType, text))
+
+/**
+ * Dispatcher for listPets
+ * Handles statuses: 200 (success), 500 (error)
+ *
+ * Effect channel mapping:
+ * - 200: success channel → ApiSuccess
+ * - 500: error channel → HttpError (forces explicit handling)
+ *
+ * @pure false - applies decoders
+ * @invariant Exhaustive coverage of all schema statuses
+ */
+export const dispatcherlistPets = createDispatcher<ListPetsResponses>((status, contentType, text) =>
+  Match.value(status).pipe(
+    Match.when(200, () => processJsonContentSuccess(200, contentType, text, Decoders.decodelistPets_200)),
+    Match.when(500, () => processJsonContentError(500, contentType, text, Decoders.decodelistPets_500)),
+    Match.orElse(() => Effect.fail(unexpectedStatus(status, text)))
+  )
+)
+
+/**
+ * Dispatcher for createPet
+ * Handles statuses: 201 (success), 400 (error), 500 (error)
+ *
+ * Effect channel mapping:
+ * - 201: success channel → ApiSuccess
+ * - 400, 500: error channel → HttpError (forces explicit handling)
+ *
+ * @pure false - applies decoders
+ * @invariant Exhaustive coverage of all schema statuses
+ */
+export const dispatchercreatePet = createDispatcher<CreatePetResponses>((status, contentType, text) =>
+  Match.value(status).pipe(
+    Match.when(201, () => processJsonContentSuccess(201, contentType, text, Decoders.decodecreatePet_201)),
+    Match.when(400, () => processJsonContentError(400, contentType, text, Decoders.decodecreatePet_400)),
+    Match.when(500, () => processJsonContentError(500, contentType, text, Decoders.decodecreatePet_500)),
+    Match.orElse(() => Effect.fail(unexpectedStatus(status, text)))
+  )
+)
+
+/**
+ * Dispatcher for getPet
+ * Handles statuses: 200 (success), 404 (error), 500 (error)
+ *
+ * Effect channel mapping:
+ * - 200: success channel → ApiSuccess
+ * - 404, 500: error channel → HttpError (forces explicit handling)
+ *
+ * @pure false - applies decoders
+ * @invariant Exhaustive coverage of all schema statuses
+ */
+export const dispatchergetPet = createDispatcher<GetPetResponses>((status, contentType, text) =>
+  Match.value(status).pipe(
+    Match.when(200, () => processJsonContentSuccess(200, contentType, text, Decoders.decodegetPet_200)),
+    Match.when(404, () => processJsonContentError(404, contentType, text, Decoders.decodegetPet_404)),
+    Match.when(500, () => processJsonContentError(500, contentType, text, Decoders.decodegetPet_500)),
+    Match.orElse(() => Effect.fail(unexpectedStatus(status, text)))
+  )
+)
+
+/**
+ * Dispatcher for deletePet
+ * Handles statuses: 204 (success), 404 (error), 500 (error)
+ *
+ * Effect channel mapping:
+ * - 204: success channel → ApiSuccess (no content)
+ * - 404, 500: error channel → HttpError (forces explicit handling)
+ *
+ * @pure false - applies decoders
+ * @invariant Exhaustive coverage of all schema statuses
+ */
+export const dispatcherdeletePet = createDispatcher<DeletePetResponses>((status, contentType, text) =>
+  Match.value(status).pipe(
+    Match.when(204, () =>
+      Effect.succeed(
+        asConst({
+          status: 204,
+          contentType: "none" as const,
+          body: undefined
+        })
+      )),
+    Match.when(404, () => processJsonContentError(404, contentType, text, Decoders.decodedeletePet_404)),
+    Match.when(500, () => processJsonContentError(500, contentType, text, Decoders.decodedeletePet_500)),
+    Match.orElse(() => Effect.fail(unexpectedStatus(status, text)))
+  )
+)

package/src/generated/dispatchers-by-path.ts

@@ -0,0 +1,40 @@
+// CHANGE: Auto-generated dispatcher map by path+method
+// WHY: Provide a single dispatcher registry without manual wiring in examples
+// QUOTE(ТЗ): "Этого в плане вообще не должно быть"
+// REF: user-msg-3
+// SOURCE: Generated from tests/fixtures/petstore.openapi.json
+// FORMAT THEOREM: ∀ path, method: dispatchersByPath[path][method] = dispatcher(op)
+// PURITY: SHELL
+// EFFECT: none
+// INVARIANT: dispatcher map is total for all operations in Paths
+// COMPLEXITY: O(1)
+
+import type { Paths } from "../../tests/fixtures/petstore.openapi.js"
+import { type DispatchersFor, registerDefaultDispatchers } from "../shell/api-client/create-client.js"
+import { dispatchercreatePet, dispatcherdeletePet, dispatchergetPet, dispatcherlistPets } from "./dispatch.js"
+
+/**
+ * Dispatcher map keyed by OpenAPI path and HTTP method
+ */
+export const dispatchersByPath: DispatchersFor<Paths> = {
+  "/pets": {
+    get: dispatcherlistPets,
+    post: dispatchercreatePet
+  },
+  "/pets/{petId}": {
+    get: dispatchergetPet,
+    delete: dispatcherdeletePet
+  }
+}
+
+// CHANGE: Register default dispatchers at module load
+// WHY: Enable createClient(options) without passing dispatcher map
+// QUOTE(ТЗ): "const apiClient = createClient<Paths>(clientOptions)"
+// REF: user-msg-4
+// SOURCE: n/a
+// FORMAT THEOREM: ∀ call: createClient(options) uses dispatchersByPath
+// PURITY: SHELL
+// EFFECT: none
+// INVARIANT: registerDefaultDispatchers is called exactly once per module load
+// COMPLEXITY: O(1)
+registerDefaultDispatchers(dispatchersByPath)

package/src/generated/index.ts

@@ -0,0 +1,9 @@
+// CHANGE: Export all generated dispatchers and decoders
+// WHY: Single entry point for generated code
+// REF: issue-2
+// PURITY: CORE
+// COMPLEXITY: O(1)
+
+export * from "./decoders.js"
+export * from "./dispatch.js"
+export * from "./dispatchers-by-path.js"

package/src/index.ts

@@ -0,0 +1,42 @@
+// CHANGE: Make openapi-effect a drop-in replacement for openapi-fetch (Promise API), with an opt-in Effect API.
+// WHY: Consumer projects must be able to swap openapi-fetch -> openapi-effect with near-zero code changes.
+// QUOTE(ТЗ): "openapi-effect должен почти 1 в 1 заменяться с openapi-fetch" / "Просто добавлять effect поведение"
+// SOURCE: n/a
+// PURITY: SHELL (re-exports)
+// COMPLEXITY: O(1)
+
+// Promise-based client (openapi-fetch compatible)
+export { default } from "openapi-fetch"
+export { default as createClient } from "openapi-fetch"
+export * from "openapi-fetch"
+
+// Effect-based client (opt-in)
+export * as FetchHttpClient from "@effect/platform/FetchHttpClient"
+
+// Strict Effect client (advanced)
+export type * from "./core/api-client/index.js"
+export { assertNever } from "./core/api-client/index.js"
+
+export type {
+  DispatchersFor,
+  StrictApiClient,
+  StrictApiClientWithDispatchers
+} from "./shell/api-client/create-client.js"
+
+export type { Decoder, Dispatcher, RawResponse, StrictClient, StrictRequestInit } from "./shell/api-client/index.js"
+
+export {
+  createClient as createClientStrict,
+  createClientEffect,
+  createDispatcher,
+  createStrictClient,
+  createUniversalDispatcher,
+  executeRequest,
+  parseJSON,
+  registerDefaultDispatchers,
+  unexpectedContentType,
+  unexpectedStatus
+} from "./shell/api-client/index.js"
+
+// Generated dispatchers (auto-generated from OpenAPI schema)
+export * from "./generated/index.js"