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

package/src/shell/api-client/openapi-compat-path.ts

@@ -0,0 +1,82 @@
+import { serializeArrayParam, serializeObjectParam, serializePrimitiveParam } from "./openapi-compat-serializers.js"
+import { isPrimitive, isRecord } from "./openapi-compat-value-guards.js"
+
+const PATH_PARAM_RE = /\{[^{}]+\}/g
+
+type PathStyle = "simple" | "label" | "matrix"
+
+type PathTokenMeta = {
+  name: string
+  explode: boolean
+  style: PathStyle
+}
+
+const toPathTokenMeta = (rawName: string): PathTokenMeta => {
+  let name = rawName
+  let explode = false
+  let style: PathStyle = "simple"
+
+  if (name.endsWith("*")) {
+    explode = true
+    name = name.slice(0, Math.max(0, name.length - 1))
+  }
+
+  if (name.startsWith(".")) {
+    style = "label"
+    name = name.slice(1)
+  } else if (name.startsWith(";")) {
+    style = "matrix"
+    name = name.slice(1)
+  }
+
+  return { name, explode, style }
+}
+
+const serializePathValue = (
+  name: string,
+  value: unknown,
+  meta: PathTokenMeta
+): string | undefined => {
+  if (Array.isArray(value)) {
+    return serializeArrayParam(name, value, { style: meta.style, explode: meta.explode })
+  }
+
+  if (isRecord(value)) {
+    return serializeObjectParam(name, value, { style: meta.style, explode: meta.explode })
+  }
+
+  if (!isPrimitive(value)) {
+    return
+  }
+
+  if (meta.style === "matrix") {
+    return `;${serializePrimitiveParam(name, value)}`
+  }
+
+  const encoded = encodeURIComponent(String(value))
+  return meta.style === "label" ? `.${encoded}` : encoded
+}
+
+export const defaultPathSerializer = (
+  pathname: string,
+  pathParams: Record<string, unknown>
+): string => {
+  let nextURL = pathname
+
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    const rawName = match.slice(1, -1)
+    const meta = toPathTokenMeta(rawName)
+    const value = pathParams[meta.name]
+
+    if (value === undefined || value === null) {
+      continue
+    }
+
+    const serializedValue = serializePathValue(meta.name, value, meta)
+    if (serializedValue !== undefined) {
+      nextURL = nextURL.replace(match, serializedValue)
+    }
+  }
+
+  return nextURL
+}

package/src/shell/api-client/openapi-compat-request.ts

@@ -0,0 +1,153 @@
+import type { HeadersOptions, PathSerializer, QuerySerializer } from "./create-client-types.js"
+
+const isRecord = (value: unknown): value is Record<string, unknown> => (
+  value !== null && typeof value === "object" && !Array.isArray(value)
+)
+
+const toFormRecord = (value: unknown): Record<string, string> => {
+  if (!isRecord(value)) {
+    return {}
+  }
+
+  const formRecord: Record<string, string> = {}
+  for (const [key, item] of Object.entries(value)) {
+    formRecord[key] = String(item)
+  }
+
+  return formRecord
+}
+
+type HeaderRecord = Record<
+  string,
+  string | number | boolean | Array<string | number | boolean> | null | undefined
+>
+
+const isHeaderRecord = (headers: HeadersOptions): headers is HeaderRecord => (
+  !(headers instanceof Headers) && !Array.isArray(headers)
+)
+
+const getHeaderValue = (headers: Headers | HeadersOptions | undefined, key: string): string | undefined => {
+  if (headers === undefined) {
+    return
+  }
+
+  if (headers instanceof Headers) {
+    return headers.get(key) ?? undefined
+  }
+
+  if (!isHeaderRecord(headers)) {
+    return
+  }
+
+  const value = headers[key]
+  if (value === undefined || value === null || Array.isArray(value)) {
+    return
+  }
+
+  return String(value)
+}
+
+const stringifyBody = (body: unknown): string => {
+  return JSON.stringify(body)
+}
+
+export const defaultBodySerializer = (
+  body: unknown,
+  headers?: Headers | HeadersOptions
+): string => {
+  if (body === undefined) {
+    return ""
+  }
+
+  const contentType = getHeaderValue(headers, "Content-Type") ?? getHeaderValue(headers, "content-type")
+  if (contentType === "application/x-www-form-urlencoded") {
+    return new URLSearchParams(toFormRecord(body)).toString()
+  }
+
+  return stringifyBody(body)
+}
+
+export const createFinalURL = (
+  pathname: string,
+  options: {
+    baseUrl: string
+    params: {
+      query?: Record<string, unknown>
+      path?: Record<string, unknown>
+    }
+    querySerializer: QuerySerializer<object>
+    pathSerializer: PathSerializer
+  }
+): string => {
+  let finalURL = `${options.baseUrl}${pathname}`
+
+  if (options.params.path) {
+    finalURL = options.pathSerializer(finalURL, options.params.path)
+  }
+
+  let queryString = options.querySerializer(options.params.query ?? {})
+  if (queryString.startsWith("?")) {
+    queryString = queryString.slice(1)
+  }
+
+  if (queryString.length > 0) {
+    finalURL = `${finalURL}?${queryString}`
+  }
+
+  return finalURL
+}
+
+const applyHeaderValue = (target: Headers, key: string, value: HeaderRecord[string]): void => {
+  if (value === null) {
+    target.delete(key)
+    return
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      target.append(key, String(item))
+    }
+    return
+  }
+
+  if (value !== undefined) {
+    target.set(key, String(value))
+  }
+}
+
+const mergeHeaderSource = (target: Headers, source: HeadersOptions): void => {
+  if (source instanceof Headers) {
+    for (const [key, value] of source.entries()) {
+      target.set(key, value)
+    }
+    return
+  }
+
+  if (!isHeaderRecord(source)) {
+    return
+  }
+
+  for (const [key, value] of Object.entries(source)) {
+    applyHeaderValue(target, key, value)
+  }
+}
+
+export const mergeHeaders = (
+  ...allHeaders: Array<HeadersOptions | undefined>
+): Headers => {
+  const finalHeaders = new Headers()
+
+  for (const source of allHeaders) {
+    if (source === undefined || typeof source !== "object") {
+      continue
+    }
+
+    mergeHeaderSource(finalHeaders, source)
+  }
+
+  return finalHeaders
+}
+
+export const removeTrailingSlash = (url: string): string => (
+  url.endsWith("/") ? url.slice(0, Math.max(0, url.length - 1)) : url
+)

package/src/shell/api-client/openapi-compat-serializers.ts

@@ -0,0 +1,277 @@
+import type { QuerySerializer, QuerySerializerOptions } from "./create-client-types.js"
+import { isPrimitive, isRecord, type Primitive } from "./openapi-compat-value-guards.js"
+
+type PathStyle = "simple" | "label" | "matrix"
+type ObjectParamStyle = PathStyle | "form" | "deepObject"
+type ArrayParamStyle = PathStyle | "form" | "spaceDelimited" | "pipeDelimited"
+
+const OBJECT_JOINER_BY_STYLE: Readonly<Record<ObjectParamStyle, string>> = {
+  simple: ",",
+  label: ".",
+  matrix: ";",
+  form: "&",
+  deepObject: "&"
+}
+
+const ARRAY_JOINER_BY_STYLE: Readonly<
+  Record<ArrayParamStyle, { explodeFalse: string; explodeTrue: string }>
+> = {
+  simple: { explodeFalse: ",", explodeTrue: "," },
+  label: { explodeFalse: ",", explodeTrue: "." },
+  matrix: { explodeFalse: ",", explodeTrue: ";" },
+  form: { explodeFalse: ",", explodeTrue: "&" },
+  spaceDelimited: { explodeFalse: "%20", explodeTrue: "&" },
+  pipeDelimited: { explodeFalse: "|", explodeTrue: "&" }
+}
+
+const encodeValue = (value: Primitive, allowReserved: boolean): string => (
+  allowReserved ? String(value) : encodeURIComponent(String(value))
+)
+
+const formatExplodeFalse = (
+  name: string,
+  style: ObjectParamStyle | ArrayParamStyle,
+  value: string
+): string => {
+  if (style === "simple") {
+    return value
+  }
+  if (style === "label") {
+    return `.${value}`
+  }
+  if (style === "matrix") {
+    return `;${name}=${value}`
+  }
+  return `${name}=${value}`
+}
+
+const formatExplodeTrue = (
+  style: ObjectParamStyle | ArrayParamStyle,
+  joiner: string,
+  value: string
+): string => (
+  style === "label" || style === "matrix" ? `${joiner}${value}` : value
+)
+
+const toPrimitiveList = (value: Array<unknown>): Array<Primitive> => {
+  const items: Array<Primitive> = []
+  for (const item of value) {
+    if (isPrimitive(item)) {
+      items.push(item)
+    }
+  }
+  return items
+}
+
+const getQueryEntries = (queryParams: unknown): Array<[string, unknown]> => (
+  isRecord(queryParams) ? Object.entries(queryParams) : []
+)
+
+const toObjectPairs = (
+  name: string,
+  value: Record<string, unknown>,
+  allowReserved: boolean,
+  explode: boolean,
+  style: ObjectParamStyle
+): Array<string> => {
+  const entries: Array<string> = []
+
+  for (const [key, rawValue] of Object.entries(value)) {
+    if (!isPrimitive(rawValue)) {
+      continue
+    }
+
+    if (!explode) {
+      entries.push(key, encodeValue(rawValue, allowReserved))
+      continue
+    }
+
+    const nextName = style === "deepObject" ? `${name}[${key}]` : key
+    entries.push(
+      serializePrimitiveParam(nextName, rawValue, {
+        allowReserved
+      })
+    )
+  }
+
+  return entries
+}
+
+const toArrayValues = (
+  name: string,
+  value: Array<unknown>,
+  style: ArrayParamStyle,
+  allowReserved: boolean,
+  explode: boolean
+): Array<string> => {
+  const entries: Array<string> = []
+
+  for (const item of toPrimitiveList(value)) {
+    if (explode && style !== "simple" && style !== "label") {
+      entries.push(
+        serializePrimitiveParam(name, item, {
+          allowReserved
+        })
+      )
+      continue
+    }
+
+    entries.push(encodeValue(item, allowReserved))
+  }
+
+  return entries
+}
+
+const finalizeSerializedParam = (options: {
+  name: string
+  style: ObjectParamStyle | ArrayParamStyle
+  explode: boolean
+  values: Array<string>
+  joinerWhenExplodeFalse: string
+  joinerWhenExplodeTrue: string
+}): string => {
+  const joiner = options.explode ? options.joinerWhenExplodeTrue : options.joinerWhenExplodeFalse
+  const serializedValue = options.values.join(joiner)
+
+  return options.explode
+    ? formatExplodeTrue(options.style, options.joinerWhenExplodeTrue, serializedValue)
+    : formatExplodeFalse(options.name, options.style, serializedValue)
+}
+
+export const serializePrimitiveParam = (
+  name: string,
+  value: Primitive,
+  options?: { allowReserved?: boolean }
+): string => (
+  `${name}=${encodeValue(value, options?.allowReserved === true)}`
+)
+
+export const serializeObjectParam = (
+  name: string,
+  value: unknown,
+  options: {
+    style: ObjectParamStyle
+    explode: boolean
+    allowReserved?: boolean
+  }
+): string => {
+  if (!isRecord(value)) {
+    return ""
+  }
+
+  const pairs = toObjectPairs(
+    name,
+    value,
+    options.allowReserved === true,
+    options.explode,
+    options.style
+  )
+
+  return finalizeSerializedParam({
+    name,
+    style: options.style,
+    explode: options.explode,
+    values: pairs,
+    joinerWhenExplodeFalse: ",",
+    joinerWhenExplodeTrue: OBJECT_JOINER_BY_STYLE[options.style]
+  })
+}
+
+export const serializeArrayParam = (
+  name: string,
+  value: Array<unknown>,
+  options: {
+    style: ArrayParamStyle
+    explode: boolean
+    allowReserved?: boolean
+  }
+): string => {
+  if (!Array.isArray(value)) {
+    return ""
+  }
+
+  const values = toArrayValues(
+    name,
+    value,
+    options.style,
+    options.allowReserved === true,
+    options.explode
+  )
+
+  return finalizeSerializedParam({
+    name,
+    style: options.style,
+    explode: options.explode,
+    values,
+    joinerWhenExplodeFalse: ARRAY_JOINER_BY_STYLE[options.style].explodeFalse,
+    joinerWhenExplodeTrue: ARRAY_JOINER_BY_STYLE[options.style].explodeTrue
+  })
+}
+
+const serializeQueryEntry = (
+  name: string,
+  value: unknown,
+  options?: QuerySerializerOptions
+): string | undefined => {
+  if (value === undefined || value === null) {
+    return
+  }
+
+  return Array.isArray(value)
+    ? serializeArrayQueryEntry(name, value, options)
+    : serializeNonArrayQueryEntry(name, value, options)
+}
+
+const serializeArrayQueryEntry = (
+  name: string,
+  value: Array<unknown>,
+  options?: QuerySerializerOptions
+): string | undefined => {
+  if (value.length === 0) {
+    return
+  }
+
+  return serializeArrayParam(name, value, {
+    style: "form",
+    explode: true,
+    ...options?.array,
+    allowReserved: options?.allowReserved === true
+  })
+}
+
+const serializeNonArrayQueryEntry = (
+  name: string,
+  value: unknown,
+  options?: QuerySerializerOptions
+): string | undefined => {
+  if (isRecord(value)) {
+    return serializeObjectParam(name, value, {
+      style: "deepObject",
+      explode: true,
+      ...options?.object,
+      allowReserved: options?.allowReserved === true
+    })
+  }
+
+  if (isPrimitive(value)) {
+    return serializePrimitiveParam(name, value, options)
+  }
+
+  return undefined
+}
+
+export const createQuerySerializer = <T = unknown>(
+  options?: QuerySerializerOptions
+): QuerySerializer<T> =>
+(queryParams) => {
+  const serialized: Array<string> = []
+
+  for (const [name, value] of getQueryEntries(queryParams)) {
+    const entry = serializeQueryEntry(name, value, options)
+    if (entry !== undefined) {
+      serialized.push(entry)
+    }
+  }
+
+  return serialized.join("&")
+}

package/src/shell/api-client/openapi-compat-utils.ts

@@ -0,0 +1,10 @@
+export {
+  createQuerySerializer,
+  serializeArrayParam,
+  serializeObjectParam,
+  serializePrimitiveParam
+} from "./openapi-compat-serializers.js"
+
+export { defaultPathSerializer } from "./openapi-compat-path.js"
+
+export { createFinalURL, defaultBodySerializer, mergeHeaders, removeTrailingSlash } from "./openapi-compat-request.js"

package/src/shell/api-client/openapi-compat-value-guards.ts

@@ -0,0 +1,9 @@
+export type Primitive = string | number | boolean
+
+export const isPrimitive = (value: unknown): value is Primitive => (
+  typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+)
+
+export const isRecord = (value: unknown): value is Record<string, unknown> => (
+  value !== null && typeof value === "object" && !Array.isArray(value)
+)