@orpc/openapi 0.0.4 → 0.0.5

package/src/generator.ts

@@ -1,20 +1,20 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
 import { type ContractRouter, eachContractRouterLeaf } from '@orpc/contract'
 import { type Router, toContractRouter } from '@orpc/server'
 import { findDeepMatches, isPlainObject, omit } from '@orpc/shared'
 import { preSerialize } from '@orpc/transformer'
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
 import {
   type MediaTypeObject,
-  type OpenAPIObject,
   OpenApiBuilder,
+  type OpenAPIObject,
   type OperationObject,
   type ParameterObject,
   type RequestBodyObject,
   type ResponseObject,
 } from 'openapi3-ts/oas31'
 import {
-  UNSUPPORTED_JSON_SCHEMA,
   extractJSONSchema,
+  UNSUPPORTED_JSON_SCHEMA,
   zodToJsonSchema,
 } from './zod-to-json-schema'
 
@@ -45,17 +45,17 @@ export function generateOpenAPI(
   } & Omit<OpenAPIObject, 'openapi'>,
   options?: GenerateOpenAPIOptions,
 ): OpenAPIObject {
-  const throwOnMissingTagDefinition =
-    options?.throwOnMissingTagDefinition ?? false
-  const ignoreUndefinedPathProcedures =
-    options?.ignoreUndefinedPathProcedures ?? false
+  const throwOnMissingTagDefinition
+    = options?.throwOnMissingTagDefinition ?? false
+  const ignoreUndefinedPathProcedures
+    = options?.ignoreUndefinedPathProcedures ?? false
 
   const builder = new OpenApiBuilder({
     ...omit(opts, ['router']),
     openapi: '3.1.0',
   })
 
-  const rootTags = opts.tags?.map((tag) => tag.name) ?? []
+  const rootTags = opts.tags?.map(tag => tag.name) ?? []
   const router = toContractRouter(opts.router)
 
   eachContractRouterLeaf(router, (procedure, path_) => {
@@ -76,7 +76,7 @@ export function generateOpenAPI(
       : {}
 
     const params: ParameterObject[] | undefined = (() => {
-      const names = path.match(/{([^}]+)}/g)
+      const names = path.match(/\{([^}]+)\}/g)
 
       if (!names || !names.length) {
         return undefined
@@ -89,7 +89,7 @@ export function generateOpenAPI(
       }
 
       return names
-        .map((raw) => raw.slice(1, -1))
+        .map(raw => raw.slice(1, -1))
         .map((name) => {
           let schema = inputSchema.properties?.[name]
           const required = inputSchema.required?.includes(name)
@@ -127,19 +127,20 @@ export function generateOpenAPI(
             ...inputSchema,
             properties: inputSchema.properties
               ? Object.entries(inputSchema.properties).reduce(
-                  (acc, [key, value]) => {
-                    if (key !== name) {
-                      acc[key] = value
-                    }
-
-                    return acc
-                  },
-                  {} as Record<string, JSONSchema>,
-                )
+                (acc, [key, value]) => {
+                  if (key !== name) {
+                    acc[key] = value
+                  }
+
+                  return acc
+                },
+                {} as Record<string, JSONSchema>,
+              )
               : undefined,
-            required: inputSchema.required?.filter((v) => v !== name),
+            required: inputSchema.required?.filter(v => v !== name),
             examples: inputSchema.examples?.map((example) => {
-              if (!isPlainObject(example)) return example
+              if (!isPlainObject(example))
+                return example
 
               return Object.entries(example).reduce(
                 (acc, [key, value]) => {
@@ -220,8 +221,8 @@ export function generateOpenAPI(
         contentMediaType: string
       })[]
 
-      const isStillHasFileSchema =
-        findDeepMatches(isFileSchema, schema).values.length > 0
+      const isStillHasFileSchema
+        = findDeepMatches(isFileSchema, schema).values.length > 0
 
       if (files.length) {
         parameters.push({
@@ -268,8 +269,8 @@ export function generateOpenAPI(
         contentMediaType: string
       })[]
 
-      const isStillHasFileSchema =
-        findDeepMatches(isFileSchema, schema).values.length > 0
+      const isStillHasFileSchema
+        = findDeepMatches(isFileSchema, schema).values.length > 0
 
       const content: Record<string, MediaTypeObject> = {}
 
@@ -295,7 +296,7 @@ export function generateOpenAPI(
     })()
 
     if (throwOnMissingTagDefinition && internal.tags) {
-      const missingTag = internal.tags.find((tag) => !rootTags.includes(tag))
+      const missingTag = internal.tags.find(tag => !rootTags.includes(tag))
 
       if (missingTag !== undefined) {
         throw new Error(
@@ -313,7 +314,7 @@ export function generateOpenAPI(
       parameters: parameters.length ? parameters : undefined,
       requestBody,
       responses: {
-        '200': successResponse,
+        200: successResponse,
       },
     }
 
@@ -326,11 +327,12 @@ export function generateOpenAPI(
 }
 
 function isFileSchema(schema: unknown) {
-  if (typeof schema !== 'object' || schema === null) return false
+  if (typeof schema !== 'object' || schema === null)
+    return false
   return (
-    'type' in schema &&
-    'contentMediaType' in schema &&
-    typeof schema.type === 'string' &&
-    typeof schema.contentMediaType === 'string'
+    'type' in schema
+    && 'contentMediaType' in schema
+    && typeof schema.type === 'string'
+    && typeof schema.contentMediaType === 'string'
   )
 }

package/src/zod-to-json-schema.test.ts

@@ -244,7 +244,7 @@ describe('special types', () => {
 
 describe('transform and effects', () => {
   it('should handle transform effects based on mode', () => {
-    const schema = z.string().transform((val) => val.length)
+    const schema = z.string().transform(val => val.length)
 
     expect(zodToJsonSchema(schema, { mode: 'input' })).toEqual({
       type: 'string',

package/src/zod-to-json-schema.ts

@@ -14,11 +14,8 @@ import {
   type KeySchema,
   type ZodAny,
   type ZodArray,
-  type ZodBigInt,
-  type ZodBoolean,
   type ZodBranded,
   type ZodCatch,
-  type ZodDate,
   type ZodDefault,
   type ZodDiscriminatedUnion,
   type ZodEffects,
@@ -28,7 +25,6 @@ import {
   type ZodLazy,
   type ZodLiteral,
   type ZodMap,
-  type ZodNaN,
   type ZodNativeEnum,
   type ZodNullable,
   type ZodNumber,
@@ -213,8 +209,8 @@ export function zodToJsonSchema(
             json.pattern = `${escapeStringRegexp(check.value)}$`
             break
           case 'emoji':
-            json.pattern =
-              '^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$'
+            json.pattern
+              = '^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$'
             break
           case 'nanoid':
             json.pattern = '^[a-zA-Z0-9_-]{21}$'
@@ -278,14 +274,10 @@ export function zodToJsonSchema(
     }
 
     case ZodFirstPartyTypeKind.ZodNaN: {
-      const schema_ = schema as ZodNaN
-
       return { const: 'NaN' }
     }
 
     case ZodFirstPartyTypeKind.ZodBigInt: {
-      const schema_ = schema as ZodBigInt
-
       const json: JSONSchema = { type: 'string', pattern: '^-?[0-9]+$' }
 
       // WARN: ignore checks
@@ -294,14 +286,10 @@ export function zodToJsonSchema(
     }
 
     case ZodFirstPartyTypeKind.ZodBoolean: {
-      const schema_ = schema as ZodBoolean
-
       return { type: 'boolean' }
     }
 
     case ZodFirstPartyTypeKind.ZodDate: {
-      const schema_ = schema as ZodDate
-
       const jsonSchema: JSONSchema = { type: 'string', format: Format.Date }
 
       // WARN: ignore checks
@@ -398,7 +386,7 @@ export function zodToJsonSchema(
       for (const [key, value] of Object.entries(schema_.shape)) {
         const { schema, matches } = extractJSONSchema(
           zodToJsonSchema(value, childOptions),
-          (schema) => schema === UNDEFINED_JSON_SCHEMA,
+          schema => schema === UNDEFINED_JSON_SCHEMA,
         )
 
         if (schema) {
@@ -423,14 +411,15 @@ export function zodToJsonSchema(
         childOptions,
       )
       if (schema_._def.unknownKeys === 'strict') {
-        json.additionalProperties =
-          additionalProperties === UNSUPPORTED_JSON_SCHEMA
+        json.additionalProperties
+          = additionalProperties === UNSUPPORTED_JSON_SCHEMA
             ? false
             : additionalProperties
-      } else {
+      }
+      else {
         if (
-          additionalProperties &&
-          additionalProperties !== UNSUPPORTED_JSON_SCHEMA
+          additionalProperties
+          && additionalProperties !== UNSUPPORTED_JSON_SCHEMA
         ) {
           json.additionalProperties = additionalProperties
         }
@@ -551,8 +540,8 @@ export function zodToJsonSchema(
       const schema_ = schema as ZodEffects<ZodTypeAny>
 
       if (
-        schema_._def.effect.type === 'transform' &&
-        childOptions?.mode === 'output'
+        schema_._def.effect.type === 'transform'
+        && childOptions?.mode === 'output'
       ) {
         return {}
       }
@@ -602,7 +591,7 @@ export function extractJSONSchema(
   schema: JSONSchema,
   check: (schema: JSONSchema) => boolean,
   matches: JSONSchema[] = [],
-): { schema: JSONSchema | undefined; matches: JSONSchema[] } {
+): { schema: JSONSchema | undefined, matches: JSONSchema[] } {
   if (check(schema)) {
     matches.push(schema)
     return { schema: undefined, matches }
@@ -615,14 +604,14 @@ export function extractJSONSchema(
   // TODO: $ref
 
   if (
-    schema.anyOf &&
-    Object.keys(schema).every(
-      (k) => k === 'anyOf' || NON_LOGIC_KEYWORDS.includes(k as any),
+    schema.anyOf
+    && Object.keys(schema).every(
+      k => k === 'anyOf' || NON_LOGIC_KEYWORDS.includes(k as any),
     )
   ) {
     const anyOf = schema.anyOf
-      .map((s) => extractJSONSchema(s, check, matches).schema)
-      .filter((v) => !!v)
+      .map(s => extractJSONSchema(s, check, matches).schema)
+      .filter(v => !!v)
 
     if (anyOf.length === 1 && typeof anyOf[0] === 'object') {
       return { schema: { ...schema, anyOf: undefined, ...anyOf[0] }, matches }
@@ -640,14 +629,14 @@ export function extractJSONSchema(
   // TODO: $ref
 
   if (
-    schema.oneOf &&
-    Object.keys(schema).every(
-      (k) => k === 'oneOf' || NON_LOGIC_KEYWORDS.includes(k as any),
+    schema.oneOf
+    && Object.keys(schema).every(
+      k => k === 'oneOf' || NON_LOGIC_KEYWORDS.includes(k as any),
     )
   ) {
     const oneOf = schema.oneOf
-      .map((s) => extractJSONSchema(s, check, matches).schema)
-      .filter((v) => !!v)
+      .map(s => extractJSONSchema(s, check, matches).schema)
+      .filter(v => !!v)
 
     if (oneOf.length === 1 && typeof oneOf[0] === 'object') {
       return { schema: { ...schema, oneOf: undefined, ...oneOf[0] }, matches }