bunderstack 0.15.2 → 0.17.0-beta.0

package/src/errors.ts

@@ -1,10 +1,98 @@
-import type { Context } from 'hono'
-import type { ContentfulStatusCode } from 'hono/utils/http-status'
+import { ORPCError, os, type ErrorMap } from '@orpc/server'
+import * as v from 'valibot'
 
+import { StandardSchemaValidationError } from './standard-schema'
+
+export const BUNDERSTACK_ERROR_CODES = [
+  'VALIDATION_ERROR',
+  'UNAUTHORIZED',
+  'FORBIDDEN',
+  'NOT_FOUND',
+  'CONFLICT',
+  'PAYLOAD_TOO_LARGE',
+  'RATE_LIMITED',
+] as const
+
+export type BunderstackErrorCode = (typeof BUNDERSTACK_ERROR_CODES)[number]
+
+export const BUNDERSTACK_ERROR_STATUS_MAP = {
+  VALIDATION_ERROR: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  PAYLOAD_TOO_LARGE: 413,
+  RATE_LIMITED: 429,
+} as const satisfies Record<BunderstackErrorCode, number>
+
+function errorDataSchema<const TCode extends BunderstackErrorCode>(
+  code: TCode,
+) {
+  return v.strictObject({
+    code: v.literal(code),
+    details: v.optional(v.unknown()),
+  })
+}
+
+export const BUNDERSTACK_ERRORS = {
+  VALIDATION_ERROR: { data: errorDataSchema('VALIDATION_ERROR') },
+  UNAUTHORIZED: { data: errorDataSchema('UNAUTHORIZED') },
+  FORBIDDEN: { data: errorDataSchema('FORBIDDEN') },
+  NOT_FOUND: { data: errorDataSchema('NOT_FOUND') },
+  CONFLICT: { data: errorDataSchema('CONFLICT') },
+  PAYLOAD_TOO_LARGE: { data: errorDataSchema('PAYLOAD_TOO_LARGE') },
+  RATE_LIMITED: { data: errorDataSchema('RATE_LIMITED') },
+} as const satisfies ErrorMap
+
+export class BunderstackError extends Error {
+  readonly status: number
+
+  constructor(
+    readonly code: BunderstackErrorCode,
+    message: string,
+    readonly details?: unknown,
+    options?: ErrorOptions,
+  ) {
+    super(message, options)
+    this.name = 'BunderstackError'
+    this.status = BUNDERSTACK_ERROR_STATUS_MAP[code]
+  }
+}
+
+export const mapBunderstackErrors = os
+  .errors(BUNDERSTACK_ERRORS)
+  .middleware(async ({ next }) => {
+    try {
+      return await next()
+    } catch (error) {
+      const mapped =
+        error instanceof StandardSchemaValidationError
+          ? new BunderstackError(
+              'VALIDATION_ERROR',
+              error.message,
+              error.issues,
+              { cause: error },
+            )
+          : error
+      if (!(mapped instanceof BunderstackError)) throw error
+
+      throw new ORPCError(mapped.code, {
+        message: mapped.message,
+        data:
+          mapped.details === undefined
+            ? { code: mapped.code }
+            : { code: mapped.code, details: mapped.details },
+        cause: mapped,
+      })
+    }
+  })
+
+/** @deprecated Legacy internal error codes retained for list-query compatibility. */
 export const ErrorCode = {
   VALIDATION_ERROR: 'VALIDATION_ERROR',
   FORBIDDEN: 'FORBIDDEN',
   NOT_FOUND: 'NOT_FOUND',
+  CONFLICT: 'CONFLICT',
   INVALID_CURSOR: 'INVALID_CURSOR',
   RATE_LIMITED: 'RATE_LIMITED',
   IDEMPOTENCY_REPLAY: 'IDEMPOTENCY_REPLAY',
@@ -13,27 +101,6 @@ export const ErrorCode = {
 
 export type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode]
 
-export type ApiErrorBody = {
-  error: string
-  code?: ErrorCodeValue
-  details?: unknown
-}
-
-export function apiError(
-  c: Context,
-  code: ErrorCodeValue,
-  message: string,
-  status: ContentfulStatusCode,
-  details?: unknown,
-) {
-  const body: ApiErrorBody = {
-    error: message,
-    code,
-    ...(details ? { details } : {}),
-  }
-  return c.json(body, status)
-}
-
 export class ListQueryError extends Error {
   readonly code: ErrorCodeValue
   readonly details?: unknown

package/src/handler.ts

@@ -1,58 +1,30 @@
 // src/handler.ts
-import { Hono } from 'hono'
-
 import { createRateLimiter, type RateLimitConfig } from './rate-limit'
 
 interface HandlerParts {
-  crudRouter: Hono
   authHandler?: (req: Request) => Promise<Response>
-  storageRouter?: Hono
-  realtimeRouter?: Hono
-  cronRouter?: Hono
-  trpcHandler?: (req: Request) => Promise<Response>
+  apiHandler?: (req: Request) => Promise<Response | null>
   rateLimit?: boolean | RateLimitConfig
 }
 
-export function buildHandler(parts: HandlerParts): {
-  handler: (req: Request) => Promise<Response>
-  router: Hono
-} {
-  const app = new Hono()
+export function buildHandler(parts: HandlerParts): (req: Request) => Promise<Response> {
   const checkRateLimit = createRateLimiter(parts.rateLimit)
 
-  const health = (c: { json: (data: unknown) => Response }) =>
-    c.json({ status: 'ok' })
-  app.get('/health', health)
-  app.get('/api/health', health)
-  app.route('/api', parts.crudRouter)
-
-  if (parts.cronRouter) {
-    app.route('/api/_bunderstack', parts.cronRouter)
-  }
-
-  if (parts.authHandler) {
-    app.all('/api/auth/*', (c) => parts.authHandler!(c.req.raw))
-  }
-
-  if (parts.storageRouter) {
-    app.route('/api/files', parts.storageRouter)
-    app.route('/files', parts.storageRouter)
-  }
-
-  if (parts.realtimeRouter) {
-    app.route('/api', parts.realtimeRouter)
-  }
-
-  if (parts.trpcHandler) {
-    app.all('/api/trpc/*', (c) => parts.trpcHandler!(c.req.raw))
-  }
-
-  const inner = (req: Request): Promise<Response> =>
-    Promise.resolve(app.fetch(req))
-  const handler = async (req: Request): Promise<Response> => {
+  return async (req: Request): Promise<Response> => {
     const limited = await checkRateLimit(req)
     if (limited) return limited
-    return inner(req)
+
+    const pathname = new URL(req.url).pathname
+    if (
+      parts.authHandler &&
+      (pathname === '/api/auth' || pathname.startsWith('/api/auth/'))
+    ) {
+      return parts.authHandler(req)
+    }
+    if (parts.apiHandler) {
+      const apiRes = await parts.apiHandler(req)
+      if (apiRes) return apiRes
+    }
+    return new Response('Not Found', { status: 404 })
   }
-  return { handler, router: app }
 }