@prover-coder-ai/openapi-effect 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prover-coder-ai/openapi-effect",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Drop-in replacement for openapi-fetch with an opt-in Effect API",
   "type": "module",
   "main": "dist/index.js",
@@ -35,11 +35,10 @@
   },
   "homepage": "https://github.com/ProverCoderAI/effect-template#readme",
   "dependencies": {
-    "@effect/platform": "^0.94.4",
+    "@effect/platform": "^0.94.5",
     "@effect/platform-node": "^0.104.1",
     "@effect/schema": "^0.75.5",
-    "effect": "^3.19.16",
-    "openapi-fetch": "^0.15.2"
+    "effect": "^3.19.17"
   },
   "scripts": {
     "build": "vite build",

package/src/index.ts

@@ -1,23 +1,16 @@
-// 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 поведение"
+// CHANGE: Expose Effect-only public API
+// WHY: Enforce Effect-first paradigm and remove Promise-based client surface
 // 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 {
+  ClientOptions,
   DispatchersFor,
   StrictApiClient,
   StrictApiClientWithDispatchers
@@ -26,17 +19,29 @@ export type {
 export type { Decoder, Dispatcher, RawResponse, StrictClient, StrictRequestInit } from "./shell/api-client/index.js"
 
 export {
-  createClient as createClientStrict,
+  createClient,
   createClientEffect,
   createDispatcher,
+  createFinalURL,
+  createPathBasedClient,
+  createQuerySerializer,
   createStrictClient,
   createUniversalDispatcher,
+  defaultBodySerializer,
+  defaultPathSerializer,
   executeRequest,
+  mergeHeaders,
   parseJSON,
   registerDefaultDispatchers,
+  removeTrailingSlash,
+  serializeArrayParam,
+  serializeObjectParam,
+  serializePrimitiveParam,
   unexpectedContentType,
   unexpectedStatus
 } from "./shell/api-client/index.js"
 
+export { createClient as default } from "./shell/api-client/index.js"
+
 // Generated dispatchers (auto-generated from OpenAPI schema)
 export * from "./generated/index.js"

package/src/shell/api-client/create-client-middleware.ts

@@ -0,0 +1,179 @@
+import { Effect } from "effect"
+
+import { toError } from "./create-client-response.js"
+import type { AsyncValue, MergedOptions, Middleware, MiddlewareRequestParams, Thenable } from "./create-client-types.js"
+
+const isThenable = <T>(value: unknown): value is Thenable<T> => (
+  typeof value === "object"
+  && value !== null
+  && "then" in value
+  && typeof Reflect.get(value, "then") === "function"
+)
+
+export const toPromiseEffect = <T>(value: AsyncValue<T>): Effect.Effect<T, Error> => (
+  isThenable(value)
+    ? Effect.async<T, Error>((resume) => {
+      value.then(
+        (result) => {
+          resume(Effect.succeed(result))
+        },
+        (error) => {
+          resume(Effect.fail(toError(error)))
+        }
+      )
+    })
+    : Effect.succeed(value)
+)
+
+export type MiddlewareContext = {
+  schemaPath: string
+  params: MiddlewareRequestParams
+  options: MergedOptions
+  id: string
+  middleware: Array<Middleware>
+}
+
+const reverseMiddleware = (middleware: Array<Middleware>): Array<Middleware> => {
+  const output: Array<Middleware> = []
+
+  for (let index = middleware.length - 1; index >= 0; index -= 1) {
+    const item = middleware[index]
+    if (item !== undefined) {
+      output.push(item)
+    }
+  }
+
+  return output
+}
+
+type RequestMiddlewareResult = {
+  request: Request
+  response?: Response
+}
+
+const createMiddlewareParams = (
+  request: Request,
+  context: MiddlewareContext
+): {
+  request: Request
+  schemaPath: string
+  params: MiddlewareRequestParams
+  options: MergedOptions
+  id: string
+} => ({
+  request,
+  schemaPath: context.schemaPath,
+  params: context.params,
+  options: context.options,
+  id: context.id
+})
+
+export const applyRequestMiddleware = (
+  request: Request,
+  context: MiddlewareContext
+): Effect.Effect<RequestMiddlewareResult, Error> =>
+  Effect.gen(function*() {
+    let nextRequest = request
+
+    for (const item of context.middleware) {
+      if (typeof item.onRequest !== "function") {
+        continue
+      }
+
+      const result = yield* toPromiseEffect(item.onRequest(createMiddlewareParams(nextRequest, context)))
+
+      if (result === undefined) {
+        continue
+      }
+
+      if (result instanceof Request) {
+        nextRequest = result
+        continue
+      }
+
+      if (result instanceof Response) {
+        return { request: nextRequest, response: result }
+      }
+
+      return yield* Effect.fail(
+        new Error("onRequest: must return new Request() or Response() when modifying the request")
+      )
+    }
+
+    return { request: nextRequest }
+  })
+
+export const applyResponseMiddleware = (
+  request: Request,
+  response: Response,
+  context: MiddlewareContext
+): Effect.Effect<Response, Error> =>
+  Effect.gen(function*() {
+    let nextResponse = response
+
+    for (const item of reverseMiddleware(context.middleware)) {
+      if (typeof item.onResponse !== "function") {
+        continue
+      }
+
+      const result = yield* toPromiseEffect(item.onResponse({
+        ...createMiddlewareParams(request, context),
+        response: nextResponse
+      }))
+
+      if (result === undefined) {
+        continue
+      }
+
+      if (!(result instanceof Response)) {
+        return yield* Effect.fail(
+          new Error("onResponse: must return new Response() when modifying the response")
+        )
+      }
+
+      nextResponse = result
+    }
+
+    return nextResponse
+  })
+
+const normalizeErrorResult = (
+  result: Response | Error | undefined
+): Effect.Effect<Response | Error | undefined, Error> => {
+  if (result === undefined || result instanceof Response || result instanceof Error) {
+    return Effect.succeed(result)
+  }
+
+  return Effect.fail(new Error("onError: must return new Response() or instance of Error"))
+}
+
+export const applyErrorMiddleware = (
+  request: Request,
+  fetchError: Error,
+  context: MiddlewareContext
+): Effect.Effect<Response, Error> =>
+  Effect.gen(function*() {
+    let nextError: Error = fetchError
+
+    for (const item of reverseMiddleware(context.middleware)) {
+      if (typeof item.onError !== "function") {
+        continue
+      }
+
+      const rawResult = yield* toPromiseEffect(item.onError({
+        ...createMiddlewareParams(request, context),
+        error: nextError
+      }))
+
+      const result = yield* normalizeErrorResult(rawResult)
+      if (result instanceof Response) {
+        return result
+      }
+
+      if (result instanceof Error) {
+        nextError = result
+      }
+    }
+
+    return yield* Effect.fail(nextError)
+  })

package/src/shell/api-client/create-client-response.ts

@@ -0,0 +1,115 @@
+import { Effect } from "effect"
+
+import { asJson } from "../../core/axioms.js"
+import type { ParseAs } from "./create-client-types.js"
+
+type RuntimeFetchResponse = {
+  data?: unknown
+  error?: unknown
+  response: Response
+}
+
+export const toError = (error: unknown): Error => (
+  error instanceof Error ? error : new Error(String(error))
+)
+
+const parseJsonText = (rawText: string): Effect.Effect<unknown, Error> => (
+  rawText.length === 0
+    ? Effect.void
+    : Effect.try({
+      try: () => asJson(JSON.parse(rawText)),
+      catch: toError
+    })
+)
+
+const readResponseText = (response: Response): Effect.Effect<string, Error> => (
+  Effect.tryPromise({
+    try: () => response.text(),
+    catch: toError
+  })
+)
+
+const parseSuccessData = (
+  response: Response,
+  parseAs: ParseAs,
+  contentLength: string | null
+): Effect.Effect<unknown, Error> => {
+  if (parseAs === "stream") {
+    return Effect.succeed(response.body)
+  }
+
+  if (parseAs === "text") {
+    return Effect.tryPromise({ try: () => response.text(), catch: toError })
+  }
+
+  if (parseAs === "blob") {
+    return Effect.tryPromise({ try: () => response.blob(), catch: toError })
+  }
+
+  if (parseAs === "arrayBuffer") {
+    return Effect.tryPromise({ try: () => response.arrayBuffer(), catch: toError })
+  }
+
+  if (contentLength === null) {
+    return readResponseText(response).pipe(
+      Effect.flatMap((rawText) => parseJsonText(rawText))
+    )
+  }
+
+  return Effect.tryPromise({ try: () => response.json(), catch: toError })
+}
+
+const parseErrorData = (response: Response): Effect.Effect<unknown, Error> => (
+  readResponseText(response).pipe(
+    Effect.flatMap((rawText) =>
+      Effect.match(
+        Effect.try({
+          try: () => asJson(JSON.parse(rawText)),
+          catch: toError
+        }),
+        {
+          onFailure: () => rawText,
+          onSuccess: (parsed) => parsed
+        }
+      )
+    )
+  )
+)
+
+const hasChunkedTransferEncoding = (response: Response): boolean => (
+  response.headers.get("Transfer-Encoding")?.includes("chunked") === true
+)
+
+const isEmptyResponse = (
+  request: Request,
+  response: Response,
+  contentLength: string | null
+): boolean => (
+  response.status === 204
+  || request.method === "HEAD"
+  || (contentLength === "0" && !hasChunkedTransferEncoding(response))
+)
+
+export const createResponseEnvelope = (
+  request: Request,
+  response: Response,
+  parseAs: ParseAs
+): Effect.Effect<RuntimeFetchResponse, Error> => {
+  const contentLength = response.headers.get("Content-Length")
+
+  if (isEmptyResponse(request, response, contentLength)) {
+    return response.ok
+      ? Effect.succeed({ data: undefined, response })
+      : Effect.succeed({ error: undefined, response })
+  }
+
+  if (response.ok) {
+    return parseSuccessData(response, parseAs, contentLength).pipe(
+      Effect.map((data) => ({ data, response }))
+    )
+  }
+
+  return parseErrorData(response).pipe(
+    Effect.map((error) => ({ error, response }))
+  )
+}

package/src/shell/api-client/create-client-runtime-helpers.ts

@@ -0,0 +1,142 @@
+import { Effect } from "effect"
+
+import { asStrictApiClient } from "../../core/axioms.js"
+import { toError } from "./create-client-response.js"
+import type { FetchWithRequestInitExt, HeaderRecord } from "./create-client-runtime-types.js"
+import type {
+  BodySerializer,
+  ClientOptions,
+  MergedOptions,
+  MiddlewareRequestParams,
+  ParseAs,
+  PathSerializer,
+  QuerySerializer,
+  QuerySerializerOptions
+} from "./create-client-types.js"
+import { createQuerySerializer } from "./openapi-compat-utils.js"
+
+export const supportsRequestInitExt = (): boolean => (
+  typeof process === "object"
+  && Number.parseInt(process.versions.node.slice(0, 2), 10) >= 18
+  && typeof process.versions["undici"] === "string"
+)
+
+export const randomID = (): string => (
+  globalThis.crypto.randomUUID().replaceAll("-", "").slice(0, 9)
+)
+
+const isQuerySerializerOptions = (
+  value: QuerySerializer<unknown> | QuerySerializerOptions | undefined
+): value is QuerySerializerOptions => (
+  value !== undefined && typeof value === "object"
+)
+
+export const resolveQuerySerializer = (
+  globalQuerySerializer: ClientOptions["querySerializer"],
+  requestQuerySerializer: QuerySerializer<unknown> | QuerySerializerOptions | undefined
+): QuerySerializer<unknown> => {
+  let serializer = typeof globalQuerySerializer === "function"
+    ? globalQuerySerializer
+    : createQuerySerializer(globalQuerySerializer)
+
+  if (requestQuerySerializer) {
+    serializer = typeof requestQuerySerializer === "function"
+      ? requestQuerySerializer
+      : createQuerySerializer({
+        ...(isQuerySerializerOptions(globalQuerySerializer) ? globalQuerySerializer : {}),
+        ...requestQuerySerializer
+      })
+  }
+
+  return serializer
+}
+
+const isHeaderPrimitive = (value: unknown): value is string | number | boolean => (
+  typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+)
+
+export const toHeaderOverrides = (headers: MiddlewareRequestParams["header"]): HeaderRecord => {
+  if (headers === undefined) {
+    return {}
+  }
+
+  const normalized: HeaderRecord = {}
+  for (const [key, rawValue] of Object.entries(headers)) {
+    if (rawValue === undefined || rawValue === null || isHeaderPrimitive(rawValue)) {
+      normalized[key] = rawValue
+      continue
+    }
+
+    if (Array.isArray(rawValue)) {
+      normalized[key] = rawValue.filter((item) => isHeaderPrimitive(item))
+    }
+  }
+
+  return normalized
+}
+
+const isBodyInit = (value: BodyInit | object): value is BodyInit => (
+  typeof value === "string"
+  || value instanceof Blob
+  || value instanceof URLSearchParams
+  || value instanceof ArrayBuffer
+  || value instanceof FormData
+  || value instanceof ReadableStream
+)
+
+export type SerializedBody =
+  | { hasBody: false }
+  | { hasBody: true; value: BodyInit }
+
+export const serializeBody = (
+  body: BodyInit | object | undefined,
+  serializer: BodySerializer<unknown>,
+  headers: Headers
+): SerializedBody => {
+  if (body === undefined) {
+    return { hasBody: false }
+  }
+
+  if (isBodyInit(body)) {
+    return { hasBody: true, value: body }
+  }
+
+  return { hasBody: true, value: serializer(body, headers) }
+}
+
+export const setCustomRequestFields = (request: Request, init: Record<string, unknown>): void => {
+  for (const key in init) {
+    if (!(key in request)) {
+      Reflect.set(request, key, init[key])
+    }
+  }
+}
+
+export const invokeFetch = (
+  fetch: NonNullable<ClientOptions["fetch"]>,
+  request: Request,
+  requestInitExt?: Record<string, unknown>
+): Effect.Effect<Response, Error> => {
+  const fetchWithExt = asStrictApiClient<FetchWithRequestInitExt>(fetch)
+  return Effect.tryPromise({
+    try: () => fetchWithExt(request, requestInitExt),
+    catch: toError
+  })
+}
+
+export const createMergedOptions = (options: {
+  baseUrl: string
+  parseAs: ParseAs
+  querySerializer: QuerySerializer<unknown>
+  bodySerializer: BodySerializer<unknown>
+  pathSerializer: PathSerializer
+  fetch: NonNullable<ClientOptions["fetch"]>
+}): MergedOptions =>
+  Object.freeze<MergedOptions>({
+    baseUrl: options.baseUrl,
+    parseAs: options.parseAs,
+    querySerializer: options.querySerializer,
+    bodySerializer: options.bodySerializer,
+    pathSerializer: options.pathSerializer,
+    fetch: asStrictApiClient<typeof globalThis.fetch>(options.fetch)
+  })

package/src/shell/api-client/create-client-runtime-types.ts

@@ -0,0 +1,97 @@
+import type { Effect } from "effect"
+
+import type { MiddlewareContext } from "./create-client-middleware.js"
+import type {
+  BodySerializer,
+  ClientOptions,
+  HeadersOptions,
+  Middleware,
+  MiddlewareRequestParams,
+  ParseAs,
+  PathSerializer,
+  QuerySerializer,
+  QuerySerializerOptions
+} from "./create-client-types.js"
+
+export type RuntimeFetchResponse = {
+  data?: unknown
+  error?: unknown
+  response: Response
+}
+
+export type RuntimeFetchOptions = Omit<RequestInit, "body" | "headers" | "method"> & {
+  baseUrl?: string
+  fetch?: NonNullable<ClientOptions["fetch"]>
+  Request?: ClientOptions["Request"]
+  headers?: HeadersOptions
+  params?: MiddlewareRequestParams
+  parseAs?: ParseAs
+  querySerializer?: QuerySerializer<unknown> | QuerySerializerOptions
+  pathSerializer?: PathSerializer
+  bodySerializer?: BodySerializer<unknown>
+  body?: BodyInit | object
+  middleware?: Array<Middleware>
+  method?: string
+  [key: string]: unknown
+}
+
+export type RuntimeClient = {
+  request: (method: string, url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  GET: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  PUT: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  POST: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  DELETE: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  OPTIONS: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  HEAD: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  PATCH: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  TRACE: (url: string, init?: RuntimeFetchOptions) => Effect.Effect<RuntimeFetchResponse, Error>
+  use: (...middleware: Array<Middleware>) => void
+  eject: (...middleware: Array<Middleware>) => void
+}
+
+export type HeaderValue =
+  | string
+  | number
+  | boolean
+  | Array<string | number | boolean>
+  | null
+  | undefined
+
+export type HeaderRecord = Record<string, HeaderValue>
+
+export type BaseRuntimeConfig = {
+  Request: typeof Request
+  baseUrl: string
+  bodySerializer: BodySerializer<unknown> | undefined
+  fetch: NonNullable<ClientOptions["fetch"]>
+  pathSerializer: PathSerializer | undefined
+  headers: HeadersOptions | undefined
+  querySerializer: QuerySerializer<unknown> | QuerySerializerOptions | undefined
+  requestInitExt: Record<string, unknown> | undefined
+  baseOptions: Omit<
+    ClientOptions,
+    | "Request"
+    | "baseUrl"
+    | "bodySerializer"
+    | "fetch"
+    | "headers"
+    | "querySerializer"
+    | "pathSerializer"
+    | "requestInitExt"
+  >
+  globalMiddlewares: Array<Middleware>
+}
+
+export type PreparedRequest = {
+  request: Request
+  fetch: NonNullable<ClientOptions["fetch"]>
+  parseAs: ParseAs
+  context: MiddlewareContext
+  middleware: Array<Middleware>
+  requestInitExt: Record<string, unknown> | undefined
+}
+
+export type FetchWithRequestInitExt = (
+  input: Request,
+  requestInitExt?: Record<string, unknown>
+) => ReturnType<typeof globalThis.fetch>