update options

Author: dinwwwh

packages/openapi/src/adapters/fetch/openapi-handler.ts

@@ -11,8 +11,8 @@ export class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
   private readonly standardHandler: StandardHandler<T>
 
   constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>) {
-    const matcher = options?.matcher ?? new OpenAPIMatcher(options)
-    const codec = options?.codec ?? new OpenAPICodec(options)
+    const matcher = options?.matcher ?? new OpenAPIMatcher()
+    const codec = options?.codec ?? new OpenAPICodec()
 
     this.standardHandler = new StandardHandler(router, matcher, codec, options)
   }

packages/openapi/src/adapters/standard/openapi-codec.test.ts

@@ -13,9 +13,7 @@ describe('openAPICodec', () => {
     deserialize: vi.fn(),
   } as any
 
-  const codec = new OpenAPICodec({
-    serializer,
-  })
+  const codec = new OpenAPICodec(serializer)
 
   describe('.decode', () => {
     describe('with compact structure', () => {

packages/openapi/src/adapters/standard/openapi-codec.ts

@@ -6,15 +6,10 @@ import { OpenAPISerializer } from '@orpc/client/openapi'
 import { fallbackContractConfig } from '@orpc/contract'
 import { isObject } from '@orpc/shared'
 
-export interface OpenAPICodecOptions {
-  serializer?: OpenAPISerializer
-}
-
 export class OpenAPICodec implements StandardCodec {
-  private readonly serializer: OpenAPISerializer
-
-  constructor(options?: OpenAPICodecOptions) {
-    this.serializer = options?.serializer ?? new OpenAPISerializer()
+  constructor(
+    private readonly serializer: OpenAPISerializer = new OpenAPISerializer(),
+  ) {
   }
 
   async decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown> {

packages/openapi/src/adapters/standard/openapi-handler.ts

@@ -1,7 +1,4 @@
 import type { Context } from '@orpc/server'
 import type { RPCHandlerOptions } from '@orpc/server/standard'
-import type { OpenAPICodecOptions } from './openapi-codec'
-import type { OpenAPIMatcherOptions } from './openapi-matcher'
 
-export interface OpenAPIHandlerOptions<T extends Context>
-  extends RPCHandlerOptions<T>, OpenAPIMatcherOptions, OpenAPICodecOptions {}
+export interface OpenAPIHandlerOptions<T extends Context> extends RPCHandlerOptions<T> {}

packages/openapi/src/adapters/standard/openapi-matcher.test.ts

@@ -185,30 +185,6 @@ describe('openapiMatcher', () => {
     expect(pongLoader).toHaveBeenCalledTimes(4)
   })
 
-  it('with ignoreUndefinedMethod=true', async () => {
-    const rpcMatcher = new OpenAPIMatcher({ ignoreUndefinedMethod: true })
-    rpcMatcher.init(router)
-
-    expect(await rpcMatcher.match('POST', '/base')).toEqual(undefined)
-
-    expect(await rpcMatcher.match('DELETE', '/ping/unnoq')).toEqual({
-      path: ['nested', 'ping'],
-      procedure: routedPing,
-      params: { ping: 'unnoq' },
-    })
-
-    expect(await rpcMatcher.match('GET', '/pong/something')).toEqual({
-      path: ['pong'],
-      procedure: routedPong,
-      params: { pong: 'something' },
-    })
-
-    expect(await rpcMatcher.match('POST', '/nested/pong')).toEqual(undefined)
-
-    expect(await rpcMatcher.match('POST', '/')).toEqual(undefined)
-    expect(await rpcMatcher.match('POST', '/not_found')).toEqual(undefined)
-  })
-
   it('/ in path', async () => {
     const ping1 = new Procedure({
       ...ping['~orpc'],

packages/openapi/src/adapters/standard/openapi-matcher.ts

@@ -5,15 +5,6 @@ import { convertPathToHttpPath, createContractedProcedure, eachContractProcedure
 import { addRoute, createRouter, findRoute } from 'rou3'
 import { standardizeHTTPPath } from '../../utils'
 
-export interface OpenAPIMatcherOptions {
-  /**
-   * Ignore procedure that does not have a method defined in the contract.
-   *
-   * @default false
-   */
-  ignoreUndefinedMethod?: boolean
-}
-
 export class OpenAPIMatcher implements StandardMatcher {
   private readonly tree = createRouter<{
     path: string[]
@@ -22,25 +13,13 @@ export class OpenAPIMatcher implements StandardMatcher {
     router: AnyRouter
   }>()
 
-  private readonly ignoreUndefinedMethod: boolean
-
-  constructor(
-    options?: OpenAPIMatcherOptions,
-  ) {
-    this.ignoreUndefinedMethod = options?.ignoreUndefinedMethod ?? false
-  }
-
   private pendingRouters: (EachContractProcedureLaziedOptions & { httpPathPrefix: HTTPPath, laziedPrefix: string | undefined }) [] = []
 
   init(router: AnyRouter, path: string[] = []): void {
     const laziedOptions = eachContractProcedure({
       router,
       path,
     }, ({ path, contract }) => {
-      if (!contract['~orpc'].route.method && this.ignoreUndefinedMethod) {
-        return
-      }
-
       const method = fallbackContractConfig('defaultMethod', contract['~orpc'].route.method)
       const httpPath = contract['~orpc'].route.path
         ? toRou3Pattern(contract['~orpc'].route.path)