tRPC

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

// 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/router.ts
import {buildRouter, mergeProcedures} from '@orion-js/trpc'
import {ExampleProcedures} from './exampleComponent/controllers/trpc/ExampleProcedures'
import {UserProcedures} from './userComponent/controllers/trpc/UserProcedures'

// Merge all procedure classes with preserved types
const procedures = mergeProcedures([ExampleProcedures, UserProcedures])

// Build the router
export const appRouter = buildRouter(procedures)

// Export the router type
export type AppRouter = typeof appRouter

// app/config/trpc/index.ts
import {startTRPC} from '@orion-js/trpc'
import {logger} from '@orion-js/logger'
import {appRouter} from 'app/router'

export default async function startTrpc() {
  await startTRPC({
    router: appRouter,
    path: '/trpc',
  })

  logger.info('tRPC started at /trpc')

  return {router: appRouter}
}

@Procedures()
export class MyProcedures {
  // procedures here
}

@TQuery()
myQuery = createTQuery({
  params: {...},
  returns: {...},
  resolve: async (params) => {...}
})

@TMutation()
myMutation = createTMutation({
  params: {...},
  returns: {...},
  resolve: async (params) => {...}
})

// Inline schema
createTQuery({
  params: {
    userId: {type: String},
    includeDetails: {type: Boolean, optional: true}
  },
  returns: UserSchema,
  resolve: async ({userId, includeDetails}) => {...}
})

// Array returns
createTQuery({
  returns: [UserSchema],
  resolve: async () => {...}
})

import {mergeProcedures} from '@orion-js/trpc'

// Supports up to 5 procedure classes with full type inference
const procedures = mergeProcedures([
  UserProcedures,
  PostProcedures,
  CommentProcedures,
])

const {router} = await startApp([...components])

const caller = router.createCaller({})

// Call procedures directly
const example = await caller.getExample({exampleId: '123'})

import {startTRPC} from '@orion-js/trpc'
import {appRouter} from 'app/router'

await startTRPC({
  router: appRouter,        // Required: your tRPC router
  path: '/trpc',            // Optional: endpoint path (default: '/trpc')
  bodyParserOptions: {      // Optional: body parser config
    limit: '10mb'
  }
})

createTQuery({
  resolve: async (params, viewer) => {
    if (!viewer.user) {
      throw new Error('Unauthorized')
    }
    return await this.service.getData(viewer.user._id)
  }
})

import {TRPCError} from '@trpc/server'

createTMutation({
  resolve: async (params) => {
    const item = await this.repo.findOne(params.id)

    if (!item) {
      throw new TRPCError({
        code: 'NOT_FOUND',
        message: 'Item not found'
      })
    }

    return item
  }
})

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

import {ExampleProcedures} from './ExampleProcedures'

export default [ExampleProcedures]