feat(server): strict .callable/.actionable cannot chainable after call (#88)

Author: dinwwwh

packages/server/src/procedure-decorated.test-d.ts

@@ -1,7 +1,7 @@
 import type { Client, ClientRest, ORPCError } from '@orpc/contract'
 import type { ORPCErrorConstructorMap } from './error'
 import type { Middleware, MiddlewareOutputFn } from './middleware'
-import type { ANY_PROCEDURE } from './procedure'
+import type { ANY_PROCEDURE, Procedure } from './procedure'
 import type { DecoratedProcedure } from './procedure-decorated'
 import type { WELL_CONTEXT } from './types'
 import { z } from 'zod'
@@ -233,7 +233,7 @@ describe('self chainable', () => {
     })
 
     expectTypeOf(callable).toEqualTypeOf<
-      & DecoratedProcedure<{ auth: boolean }, { db: string }, typeof baseSchema, typeof baseSchema, { val: string }, typeof baseErrors>
+      & Procedure<{ auth: boolean }, { db: string }, typeof baseSchema, typeof baseSchema, { val: string }, typeof baseErrors>
       & Client<'something', { val: string }, { val: number }, Error | ORPCError<'CODE', { why: string }>>
     >()
   })
@@ -244,7 +244,7 @@ describe('self chainable', () => {
     })
 
     expectTypeOf(actionable).toEqualTypeOf<
-      & DecoratedProcedure<{ auth: boolean }, { db: string }, typeof baseSchema, typeof baseSchema, { val: string }, typeof baseErrors>
+      & Procedure<{ auth: boolean }, { db: string }, typeof baseSchema, typeof baseSchema, { val: string }, typeof baseErrors>
       & ((...rest: ClientRest<'something', { val: string }>) => Promise<{ val: number }>)
     >()
   })

packages/server/src/procedure-decorated.test.ts

@@ -250,16 +250,14 @@ describe('self chainable', () => {
       expect(createProcedureClient).toBeCalledWith(decorated, options)
     })
 
-    it('can chain after callable', () => {
+    it('can not chain after callable', () => {
       const mid2 = vi.fn()
 
       const applied = decorated.callable({
         context: { auth: true },
-      }).use(mid2)
+      })
 
-      expect(applied).not.toBeInstanceOf(Function)
-      expect(applied).toSatisfy(isProcedure)
-      expect(applied['~orpc'].postMiddlewares).toEqual([mid, mid2])
+      expect(applied).not.haveOwnPropertyDescriptor('use')
     })
   })
 
@@ -274,16 +272,14 @@ describe('self chainable', () => {
       expect(createProcedureClient).toBeCalledWith(decorated, options)
     })
 
-    it('can chain after actionable', () => {
+    it('can not chain after actionable', () => {
       const mid2 = vi.fn()
 
       const applied = decorated.actionable({
         context: { auth: true },
-      }).use(mid2)
+      })
 
-      expect(applied).not.toBeInstanceOf(Function)
-      expect(applied).toSatisfy(isProcedure)
-      expect(applied['~orpc'].postMiddlewares).toEqual([mid, mid2])
+      expect(applied).not.haveOwnPropertyDescriptor('use')
     })
   })
 })

packages/server/src/procedure-decorated.ts

@@ -4,7 +4,6 @@ import type { ANY_MIDDLEWARE, MapInputMiddleware, Middleware } from './middlewar
 import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client'
 import type { Context, MergeContext } from './types'
 import { DecoratedContractProcedure } from '@orpc/contract'
-import { createCallableObject } from '@orpc/shared'
 import { decorateMiddleware } from './middleware-decorated'
 import { Procedure } from './procedure'
 import { createProcedureClient } from './procedure-client'
@@ -150,20 +149,21 @@ export class DecoratedProcedure<
 
   /**
    * Make this procedure callable (works like a function while still being a procedure).
-   * **Note**: this only takes effect when this method is called at the end of the chain.
    */
   callable<TClientContext>(...rest: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>):
-    & DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>
+    & Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>
     & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap> {
-    return createCallableObject(this, createProcedureClient(this, ...rest))
+    return Object.assign(createProcedureClient(this, ...rest), {
+      '~type': 'Procedure' as const,
+      '~orpc': this['~orpc'],
+    })
   }
 
   /**
    * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
-   * **Note**: this only takes effect when this method is called at the end of the chain.
    */
   actionable<TClientContext>(...rest: CreateProcedureClientRest<TContext, TOutputSchema, THandlerOutput, TClientContext>):
-    & DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>
+    & Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>
     & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>) {
     return this.callable(...rest)
   }