Introduction

pnpm add @orion-js/trpc @trpc/server superjson

// app/exampleComponent/controllers/trpc/ExampleProcedures/index.ts
import {Procedures, TQuery, TMutation, createTQuery, createTMutation} from '@orion-js/trpc'
import {Inject} from '@orion-js/services'
import {ExampleSchema} from 'app/exampleComponent/schemas/ExampleSchema'
import {ExampleService} from 'app/exampleComponent/services/ExampleService'

@Procedures()
export class ExampleProcedures {
  @Inject(() => ExampleService)
  private exampleService: ExampleService

  @TQuery()
  getExample = createTQuery({
    params: {exampleId: {type: String}},
    returns: ExampleSchema,
    resolve: async ({exampleId}) => {
      return await this.exampleService.getExample(exampleId)
    },
  })

  @TQuery()
  listExamples = createTQuery({
    returns: [ExampleSchema],
    resolve: async () => {
      return await this.exampleService.getExamples()
    },
  })

  @TMutation()
  createExample = createTMutation({
    params: {name: {type: String}},
    returns: {message: {type: String}},
    resolve: async ({name}) => {
      await this.exampleService.createExample(name)
      return {message: 'Created successfully'}
    },
  })
}

// app/exampleComponent/index.ts
import {component} from '@orion-js/components'
import trpc from './controllers/trpc'

export default component({
  trpc,
  // ...other controllers
})

// app/config/trpc/index.ts
import {initTRPC} from '@trpc/server'
import {
  defaultErrorFormatter,
  registerTRPCRoute,
  type TRPCContext,
} from '@orion-js/trpc'
import {logger} from '@orion-js/logger'
import type {TRPCRouterRecord} from '@trpc/server'
import {deserialize as superjsonDeserialize, serialize as superjsonSerialize} from 'superjson'

export const transformer = {
  serialize: superjsonSerialize,
  deserialize: superjsonDeserialize,
}

export const t = initTRPC.context<TRPCContext>().create({
  transformer,
  errorFormatter: defaultErrorFormatter,
})

export function startTrpc<T extends TRPCRouterRecord>(procedures: T) {
  const appRouter = t.router(procedures)
  registerTRPCRoute({appRouter, path: '/trpc'})

  logger.info('tRPC started at /trpc')
  return appRouter
}

// app/config/index.ts
import {type Component, mergeComponents} from '@orion-js/components'

export async function startApp<T extends Component<any>[]>(components: [...T]) {
  const controllers = mergeComponents(components)
  return {procedures: controllers.trpc}
}

// app/index.ts
import {registerTRPCRoute} from '@orion-js/trpc'
import {startApp} from './config'
import {t} from './config/trpc'
import exampleComponent from './exampleComponent'

const {procedures} = await startApp([exampleComponent])
const appRouter = t.router(procedures)
registerTRPCRoute({appRouter})

// Export the router type for client usage — transformer types flow through!
export type AppRouter = typeof appRouter

{
  "compilerOptions": {
    "strictNullChecks": true
  }
}

app/
└── exampleComponent/
    └── controllers/
        └── trpc/
            ├── ExampleProcedures/
            │   └── index.ts
            └── index.ts  # Exports procedure classes as array

import {ExampleProcedures} from './ExampleProcedures'

export default [ExampleProcedures]