bunderstack 0.17.0-beta.2 → 0.17.0-beta.3

package/src/errors.ts

@@ -1,123 +0,0 @@
-import {
-  COMMON_ERROR_STATUS_MAP,
-  ORPCError,
-  os,
-  type ErrorMap,
-} from '@orpc/server'
-import * as v from 'valibot'
-
-import { StandardSchemaValidationError } from './standard-schema'
-
-/**
- * Every code we raise is one oRPC already knows, so handlers derive the HTTP
- * status from `COMMON_ERROR_STATUS_MAP` on their own and clients can use the
- * standard `isDefinedError` helpers. Do not add a code oRPC has no status for —
- * it would silently answer 500.
- */
-export const BUNDERSTACK_ERROR_CODES = [
-  'BAD_REQUEST',
-  'UNAUTHORIZED',
-  'FORBIDDEN',
-  'NOT_FOUND',
-  'CONFLICT',
-  'PAYLOAD_TOO_LARGE',
-  'TOO_MANY_REQUESTS',
-] as const satisfies readonly (keyof typeof COMMON_ERROR_STATUS_MAP)[]
-
-export type BunderstackErrorCode = (typeof BUNDERSTACK_ERROR_CODES)[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 = {
-  BAD_REQUEST: { data: errorDataSchema('BAD_REQUEST') },
-  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') },
-  TOO_MANY_REQUESTS: { data: errorDataSchema('TOO_MANY_REQUESTS') },
-} 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 = COMMON_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(
-              'BAD_REQUEST',
-              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,
-      })
-    }
-  })
-
-/**
- * Sub-codes carried in `data.details.code` when the oRPC code alone loses
- * information the client may want to branch on. Codes that duplicate an oRPC
- * code are suppressed as redundant, see {@link CrudOperationError}.
- */
-export const ErrorCode = {
-  BAD_REQUEST: 'BAD_REQUEST',
-  FORBIDDEN: 'FORBIDDEN',
-  NOT_FOUND: 'NOT_FOUND',
-  CONFLICT: 'CONFLICT',
-  INVALID_CURSOR: 'INVALID_CURSOR',
-  TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
-  IDEMPOTENCY_REPLAY: 'IDEMPOTENCY_REPLAY',
-  IDEMPOTENCY_CONFLICT: 'IDEMPOTENCY_CONFLICT',
-} as const
-
-export type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode]
-
-export class ListQueryError extends Error {
-  readonly code: ErrorCodeValue
-  readonly details?: unknown
-
-  constructor(
-    message: string,
-    code: ErrorCodeValue = ErrorCode.BAD_REQUEST,
-    details?: unknown,
-  ) {
-    super(message)
-    this.name = 'ListQueryError'
-    this.code = code
-    this.details = details
-  }
-}

package/src/handler.ts

@@ -1,30 +0,0 @@
-// src/handler.ts
-import { createRateLimiter, type RateLimitConfig } from './rate-limit'
-
-interface HandlerParts {
-  authHandler?: (req: Request) => Promise<Response>
-  apiHandler?: (req: Request) => Promise<Response | null>
-  rateLimit?: boolean | RateLimitConfig
-}
-
-export function buildHandler(parts: HandlerParts): (req: Request) => Promise<Response> {
-  const checkRateLimit = createRateLimiter(parts.rateLimit)
-
-  return async (req: Request): Promise<Response> => {
-    const limited = await checkRateLimit(req)
-    if (limited) return limited
-
-    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 })
-  }
-}

package/src/idempotency.ts

@@ -1,97 +0,0 @@
-import { and, eq, lt } from 'drizzle-orm'
-import { createHash } from 'node:crypto'
-
-import type { AnyDb } from './dialect'
-
-import { idempotencyTableFor } from './internal-tables'
-
-export type IdempotencyConfig = {
-  ttlMs?: number
-}
-
-const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000
-
-function hashBody(body: string): string {
-  return createHash('sha256').update(body).digest('hex')
-}
-
-export type IdempotencyLookup =
-  | { type: 'replay'; status: number; response: string }
-  | { type: 'conflict' }
-  | { type: 'proceed' }
-
-export async function lookupIdempotency(
-  db: AnyDb,
-  tableName: string,
-  key: string,
-  body: string,
-  config: IdempotencyConfig,
-): Promise<IdempotencyLookup> {
-  const t = idempotencyTableFor(db)
-  const now = Date.now()
-
-  // TTL sweep: drop expired rows before reading.
-  await db.delete(t).where(lt(t.expiresAt, now))
-
-  const bodyHash = hashBody(body)
-  const rows = await db
-    .select({
-      bodyHash: t.bodyHash,
-      status: t.status,
-      response: t.response,
-      expiresAt: t.expiresAt,
-    })
-    .from(t)
-    .where(and(eq(t.key, key), eq(t.tableName, tableName)))
-    .limit(1)
-
-  const row = rows[0]
-
-  if (!row) return { type: 'proceed' }
-  if (Number(row.expiresAt) < now) return { type: 'proceed' }
-  if (row.bodyHash !== bodyHash) return { type: 'conflict' }
-  return {
-    type: 'replay',
-    status: Number(row.status),
-    response: String(row.response),
-  }
-}
-
-export async function storeIdempotency(
-  db: AnyDb,
-  tableName: string,
-  key: string,
-  body: string,
-  status: number,
-  response: unknown,
-  config: IdempotencyConfig,
-): Promise<void> {
-  const t = idempotencyTableFor(db)
-  const ttlMs = config.ttlMs ?? DEFAULT_TTL_MS
-  const expiresAt = Date.now() + ttlMs
-  const bodyHash = hashBody(body)
-  const responseText = JSON.stringify(response)
-
-  await db
-    .insert(t)
-    .values({
-      key,
-      tableName,
-      bodyHash,
-      status,
-      response: responseText,
-      expiresAt,
-    })
-    .onConflictDoUpdate({
-      target: [t.key, t.tableName],
-      set: { bodyHash, status, response: responseText, expiresAt },
-    })
-}
-
-export function resolveIdempotencyConfig(
-  config: boolean | IdempotencyConfig | undefined,
-): IdempotencyConfig | null {
-  if (!config) return null
-  if (config === true) return {}
-  return config
-}