@orpc/openapi 0.0.3 → 0.0.5

package/src/generator.test.ts

@@ -1,6 +1,6 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31'
 import { oc } from '@orpc/contract'
 import { oz } from '@orpc/zod'
-import type { OpenAPIObject } from 'openapi3-ts/oas31'
 import { z } from 'zod'
 import { generateOpenAPI } from './generator'
 
@@ -36,7 +36,7 @@ it('works', () => {
       '/ping': {
         post: {
           responses: {
-            '200': {
+            200: {
               description: 'OK',
               content: {
                 'application/json': {
@@ -63,7 +63,7 @@ it('works', () => {
             },
           ],
           responses: {
-            '200': {
+            200: {
               description: 'OK',
               content: {
                 'application/json': {
@@ -133,7 +133,7 @@ it('throwOnMissingTagDefinition option', () => {
       '/ping': {
         post: {
           responses: {
-            '200': {
+            200: {
               description: 'OK',
               content: {
                 'application/json': {
@@ -160,7 +160,7 @@ it('throwOnMissingTagDefinition option', () => {
             },
           ],
           responses: {
-            '200': {
+            200: {
               description: 'OK',
               content: {
                 'application/json': {
@@ -237,7 +237,7 @@ it('support single file upload', () => {
             },
           },
           responses: {
-            '200': {
+            200: {
               content: {
                 'image/jpg': {
                   schema: {
@@ -310,7 +310,7 @@ it('support multipart/form-data', () => {
             },
           },
           responses: {
-            '200': {
+            200: {
               content: {
                 'image/*': {
                   schema: {
@@ -415,7 +415,7 @@ it('work with example', () => {
             },
           },
           responses: {
-            '200': {
+            200: {
               content: {
                 'application/json': {
                   schema: {
@@ -463,3 +463,181 @@ it('work with example', () => {
     },
   })
 })
+
+it('should remove params on body', () => {
+  const router = oc.router({
+    upload: oc.route({ method: 'POST', path: '/upload/{id}' }).input(
+      oz.openapi(
+        z.object({
+          id: z.number(),
+          file: z.string().url(),
+        }),
+        {
+          examples: [
+            {
+              id: 123,
+              file: 'https://example.com/file.png',
+            },
+          ],
+        },
+      ),
+    ),
+  })
+
+  const spec = generateOpenAPI({
+    router,
+    info: {
+      title: 'test',
+      version: '1.0.0',
+    },
+  })
+
+  expect(spec).toEqual({
+    info: { title: 'test', version: '1.0.0' },
+    openapi: '3.1.0',
+    paths: {
+      '/upload/{id}': {
+        post: {
+          summary: undefined,
+          description: undefined,
+          deprecated: undefined,
+          tags: undefined,
+          operationId: 'upload',
+          parameters: [
+            {
+              name: 'id',
+              in: 'path',
+              required: true,
+              schema: { examples: [123], type: 'number' },
+              example: undefined,
+            },
+          ],
+          requestBody: {
+            required: false,
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'object',
+                  properties: { file: { type: 'string', format: 'uri' } },
+                  required: ['file'],
+                  examples: [{ file: 'https://example.com/file.png' }],
+                },
+                example: undefined,
+              },
+            },
+          },
+          responses: {
+            200: {
+              description: 'OK',
+              content: {
+                'application/json': { schema: {}, example: undefined },
+              },
+            },
+          },
+        },
+      },
+    },
+  })
+})
+
+it('should remove params on query', () => {
+  const router = oc.router({
+    upload: oc.route({ method: 'GET', path: '/upload/{id}' }).input(
+      oz.openapi(
+        z.object({
+          id: z.number(),
+          file: z.string().url(),
+          object: z
+            .object({
+              name: z.string(),
+            })
+            .optional(),
+        }),
+        {
+          examples: [
+            {
+              id: 123,
+              file: 'https://example.com/file.png',
+              object: { name: 'test' },
+            },
+            {
+              id: 456,
+              file: 'https://example.com/file2.png',
+            },
+          ],
+        },
+      ),
+    ),
+  })
+
+  const spec = generateOpenAPI({
+    router,
+    info: {
+      title: 'test',
+      version: '1.0.0',
+    },
+  })
+
+  expect(spec).toEqual({
+    info: { title: 'test', version: '1.0.0' },
+    openapi: '3.1.0',
+    paths: {
+      '/upload/{id}': {
+        get: {
+          summary: undefined,
+          description: undefined,
+          deprecated: undefined,
+          tags: undefined,
+          operationId: 'upload',
+          parameters: [
+            {
+              name: 'id',
+              in: 'path',
+              required: true,
+              schema: { examples: [123, 456], type: 'number' },
+              example: undefined,
+            },
+            {
+              name: 'file',
+              in: 'query',
+              style: 'deepObject',
+              required: true,
+              schema: {
+                examples: [
+                  'https://example.com/file.png',
+                  'https://example.com/file2.png',
+                ],
+                type: 'string',
+                format: 'uri',
+              },
+              example: undefined,
+            },
+            {
+              name: 'object',
+              in: 'query',
+              style: 'deepObject',
+              required: false,
+              schema: {
+                examples: [{ name: 'test' }],
+                anyOf: undefined,
+                type: 'object',
+                properties: { name: { type: 'string' } },
+                required: ['name'],
+              },
+              example: undefined,
+            },
+          ],
+          requestBody: undefined,
+          responses: {
+            200: {
+              description: 'OK',
+              content: {
+                'application/json': { schema: {}, example: undefined },
+              },
+            },
+          },
+        },
+      },
+    },
+  })
+})

package/src/generator.ts

@@ -1,18 +1,22 @@
+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, omit } from '@orpc/shared'
+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 { extractJSONSchema, zodToJsonSchema } from './zod-to-json-schema'
+import {
+  extractJSONSchema,
+  UNSUPPORTED_JSON_SCHEMA,
+  zodToJsonSchema,
+} from './zod-to-json-schema'
 
 // Reference: https://spec.openapis.org/oas/v3.1.0.html#style-values
 
@@ -41,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_) => {
@@ -64,7 +68,7 @@ export function generateOpenAPI(
     const path = internal.path ?? `/${path_.map(encodeURIComponent).join('/')}`
     const method = internal.method ?? 'POST'
 
-    const inputSchema = internal.InputSchema
+    let inputSchema = internal.InputSchema
       ? zodToJsonSchema(internal.InputSchema, { mode: 'input' })
       : {}
     const outputSchema = internal.OutputSchema
@@ -72,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
@@ -85,12 +89,12 @@ export function generateOpenAPI(
       }
 
       return names
-        .map((raw) => raw.slice(1, -1))
+        .map(raw => raw.slice(1, -1))
         .map((name) => {
-          const schema = inputSchema.properties?.[name]
+          let schema = inputSchema.properties?.[name]
           const required = inputSchema.required?.includes(name)
 
-          if (!schema) {
+          if (schema === undefined) {
             throw new Error(
               `Parameter ${name} is missing in input schema [${path_.join('.')}]`,
             )
@@ -102,6 +106,55 @@ export function generateOpenAPI(
             )
           }
 
+          const examples = inputSchema.examples
+            ?.filter((example) => {
+              return isPlainObject(example) && name in example
+            })
+            .map((example) => {
+              return example[name]
+            })
+
+          schema = {
+            examples: examples?.length ? examples : undefined,
+            ...(schema === true
+              ? {}
+              : schema === false
+                ? UNSUPPORTED_JSON_SCHEMA
+                : schema),
+          }
+
+          inputSchema = {
+            ...inputSchema,
+            properties: inputSchema.properties
+              ? Object.entries(inputSchema.properties).reduce(
+                (acc, [key, value]) => {
+                  if (key !== name) {
+                    acc[key] = value
+                  }
+
+                  return acc
+                },
+                {} as Record<string, JSONSchema>,
+              )
+              : undefined,
+            required: inputSchema.required?.filter(v => v !== name),
+            examples: inputSchema.examples?.map((example) => {
+              if (!isPlainObject(example))
+                return example
+
+              return Object.entries(example).reduce(
+                (acc, [key, value]) => {
+                  if (key !== name) {
+                    acc[key] = value
+                  }
+
+                  return acc
+                },
+                {} as Record<string, unknown>,
+              )
+            }),
+          }
+
           return {
             name,
             in: 'path',
@@ -123,18 +176,35 @@ export function generateOpenAPI(
         )
       }
 
-      return Object.entries(inputSchema.properties ?? {})
-        .filter(([name]) => !params?.find((param) => param.name === name))
-        .map(([name, schema]) => {
+      return Object.entries(inputSchema.properties ?? {}).map(
+        ([name, schema]) => {
+          const examples = inputSchema.examples
+            ?.filter((example) => {
+              return isPlainObject(example) && name in example
+            })
+            .map((example) => {
+              return example[name]
+            })
+
+          const schema_ = {
+            examples: examples?.length ? examples : undefined,
+            ...(schema === true
+              ? {}
+              : schema === false
+                ? UNSUPPORTED_JSON_SCHEMA
+                : schema),
+          }
+
           return {
             name,
             in: 'query',
             style: 'deepObject',
-            required: true,
-            schema: schema as any,
+            required: inputSchema?.required?.includes(name) ?? false,
+            schema: schema_ as any,
             example: internal.inputExample?.[name],
           }
-        })
+        },
+      )
     })()
 
     const parameters = [...(params ?? []), ...(query ?? [])]
@@ -151,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({
@@ -199,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> = {}
 
@@ -226,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(
@@ -244,7 +314,7 @@ export function generateOpenAPI(
       parameters: parameters.length ? parameters : undefined,
       requestBody,
       responses: {
-        '200': successResponse,
+        200: successResponse,
       },
     }
 
@@ -257,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 }