packages/trpc/src/trpc.ts - develop - dimamir/undb

packages/trpc/src/trpc.ts
80 строк2 KB
nichenqin
fix: fix reference error
07 ноя 2024, 14:45
07 ноя 2024, 14:452004b57
import { tracing } from "@baselime/trpc-opentelemetry-middleware"

import { initTRPC, TRPCError } from "@trpc/server"
import { executionContext, getCurrentUserId } from "@undb/context/server"
import { container } from "@undb/di"
import { createLogger } from "@undb/logger"
import { QUERY_BUILDER, startTransaction, type IQueryBuilder } from "@undb/persistence"
import { ZodError } from "@undb/zod"
import { fromZodError } from "zod-validation-error"
import pkg from "../package.json"

const log = createLogger(pkg.name)

export const t = initTRPC.create({
  errorFormatter(opts) {
    const { shape, error } = opts
    const message = error.cause instanceof ZodError ? fromZodError(error.cause).toString() : error.message

    return {
      ...shape,
      message,
    }
  },
})

export const p = t.procedure
  .use(async ({ type, input, path, next, rawInput }) => {
    const requestId = executionContext.getStore()?.requestId
    const startTime = performance.now()

    const result = await next()

    const responseTime = performance.now() - startTime

    const meta = {
      requestId,
      responseTime,
      type,
      // input,
      // rawInput,
      path,
    }
    if (result.ok) {
      log.info(meta, `trpc.${type}: ${path}`)
    } else {
      log.error({ ...meta, error: result.error }, `trpc.error: ${result.error.message}`)
    }

    return result
  })
  .use(async (ctx) => {
    if (ctx.type === "mutation") {
      const qb = container.resolve<IQueryBuilder>(QUERY_BUILDER)
      return await qb
        .transaction()
        .setIsolationLevel("read committed")
        .execute(async (tx) => {
          startTransaction(tx)
          const result = await ctx.next()

          return result
        })
    } else {
      return await ctx.next()
    }
  })
  .use(tracing({ collectInput: true }))

export const privateProcedure = p.use(async (ctx) => {
  const user = getCurrentUserId()

  if (!user) {
    throw new TRPCError({ code: "UNAUTHORIZED" })
  }
  return ctx.next()
})

export const publicProcedure = p

export const middleware = t.middleware