rajt 0.0.68 → 0.0.70

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rajt",
   "description": "A serverless bundler layer, fully typed for AWS Lambda (Node.js and LLRT) and Cloudflare Workers.",
-  "version": "0.0.68",
+  "version": "0.0.70",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -26,13 +26,6 @@
   ],
   "scripts": {
     "rajt": "./src/bin/rajt.js",
-    "dev": "tsx watch src/dev.ts",
-    "aws:build": "bun run --silent cache:routes && bun run --silent aws:export && bun run --silent clean:temp",
-    "cf:build": "bun run --silent cache:routes && bun run --silent cf:export && bun run --silent clean:temp",
-    "aws:build:watch": "chokidar \"../../{actions,configs,enums,locales,middlewares,models,utils}/**/*.ts\" -c \"bun run --silent aws:build\" --initial",
-    "cf:build:watch": "chokidar \"../../{actions,configs,enums,locales,middlewares,models,utils}/**/*.ts\" -c \"bun run --silent cf:build\" --initial",
-    "aws:export": "node src/esbuild.mjs aws",
-    "cf:export": "node src/esbuild.mjs cf",
     "aws:local": "bun run --silent aws:build && bun run --silent sam:local",
     "aws:package": "bun run --silent aws:build && bun run --silent sam:package",
     "aws:deploy": "bun run --silent aws:build && bun run --silent sam:package && bun run --silent sam:deploy",
@@ -41,10 +34,6 @@
     "sam:package": "sam package --template-file ../../template-prod.yaml --output-template-file ../../packaged.yaml",
     "sam:deploy": "sam deploy --template-file ../../packaged.yaml --stack-name rajt-llrt --capabilities CAPABILITY_IAM",
     "sam:update": "source ../../.env.prod && aws lambda update-function-code --function-name $AWS_NAME --zip-file fileb://../../lambda.zip --region $AWS_REGION --no-cli-pager 2>&1 >/dev/null",
-    "cf:local-": "source ../../.env.dev && bun run --silent cf:build:watch -- cd ../../dist && bunx wrangler dev --port=$PORT --persist-to='../.wrangler/state'",
-    "cf:deploy": "bun run --silent cf:build && cd ../../dist && bunx wrangler deploy",
-    "cache:routes": "tsx src/scripts/cache-routes.ts",
-    "ensure-dirs": "rm -rf ../../dist ../../tmp && mkdir -p ../../tmp && chmod 755 ../../tmp && mkdir -p ../../dist && chmod 755 ../../dist",
     "clean": "rm -rf ../../dist ../../tmp",
     "clean:build": "rm -rf ../../dist",
     "clean:temp": "rm -rf ../../tmp",
@@ -64,7 +53,6 @@
     "esbuild": "^0.25.2",
     "hono": "^4.11.7",
     "miniflare": "^4.20251217.0",
-    "picocolors": "^1.1.1",
     "tiny-glob": "^0.2",
     "tsx": "^4.19.3",
     "ua-parser-js": "^2.0.8"

package/src/action.ts

@@ -1,7 +1,10 @@
 import response from './response'
 import validator from './validator'
 import { GET_REQUEST } from './request'
-import type { Context, IRequest, IResponse, IValidator, Rules } from './types'
+import type {
+  Context,
+  IRequest, IResponse, IValidator, Rules
+} from './types'
 
 export default class Action {
   static run() {

package/src/cli/commands/build.ts

@@ -1,8 +1,7 @@
 import { defineCommand } from 'citty'
-import { gray } from 'picocolors'
-
+import { gray } from '../../utils/colors'
 import { build, normalizePlatform, platformError } from './utils'
-import { wait, error, } from '../../utils/log'
+import { wait, error } from '../../utils/log'
 
 import { platforms } from './constants'
 

package/src/cli/commands/utils.ts

@@ -6,7 +6,7 @@ import { readFile, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative } from 'node:path'
 
 import chokidar from 'chokidar'
-import { gray } from 'picocolors'
+import { gray } from '../../utils/colors'
 import type { ChokidarEventName, Platform } from './types'
 
 import { cacheRoutes } from '../../routes'

package/src/cli/index.ts

@@ -1,11 +1,10 @@
 import { defineCommand, runMain, renderUsage } from 'citty'
 import type { ArgsDef, CommandDef } from 'citty'
-import colors from 'picocolors'
 import { createConsola } from 'consola'
-
+import { logo } from '../utils/log'
+import { isColorSupported, gray } from '../utils/colors'
 import { version as rajtVersion } from '../../package.json'
 
-import { logo } from '../utils/log'
 
 import dev from './commands/dev'
 import build from './commands/build'
@@ -26,7 +25,7 @@ const directly = () => {
 }
 
 const name = 'Rajt CLI'
-const version = [name, colors.isColorSupported ? colors.gray('v'+rajtVersion) : rajtVersion].join(' ')
+const version = [name, isColorSupported ? gray('v'+rajtVersion) : rajtVersion].join(' ')
 
 if (directly()) {
   const _args = process.argv.slice(2)

package/src/create-app.ts

@@ -1,48 +1,28 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Hono } from 'hono'
 import { logger } from 'hono/logger'
-import type { Env, Context, ErrorHandler, NotFoundHandler, Next } from 'hono'
-// import type { MiddlewareHandler } from 'hono'
-// import { createMiddleware } from 'hono/factory'
-// import type { H, Handler, HandlerResponse } from 'hono/types'
-import type { HTTPResponseError } from 'hono/types'
-import { createColors } from 'picocolors'
-import { getColorEnabledAsync } from 'hono/utils/color'
 import { Envir } from 't0n'
-import type { Routes } from './types'
-import { BadRequest, Unauthorized } from './exceptions'
+import type {
+  Env, Context, Next,
+  HTTPResponseError,
+  ServerOptions,
+} from './types'
 import { resolve, resolveMiddleware } from './utils/resolve'
 import { getMiddlewares, getHandler } from './register'
-import { isDev } from './utils/environment'
-import localDate from './utils/local-date'
 import request, { GET_REQUEST } from './request'
 import response from './response'
-
-const colors = createColors(await getColorEnabledAsync())
-
-type InitFunction<E extends Env = Env> = (app: Hono<E>) => void
-
-export type ServerOptions<E extends Env = Env> = Partial<{
-  routes: Routes,
-  notFound: NotFoundHandler<E>,
-  onError: ErrorHandler<E>,
-  root: string,
-  app?: Hono<E>,
-  init?: InitFunction<E>,
-}>
+import { isDev } from './utils/environment'
+import localDate from './utils/local-date'
+import { gray } from './utils/colors'
 
 const NFHandler = () => response.notFound()
 const EHandler = async (e: Error | HTTPResponseError) => {
   console.error(e)
 
   switch (true) {
-    case e instanceof Unauthorized:
     case 'status' in e && e.status == 401:
       return response.unauthorized()
 
-    case e instanceof BadRequest:
-    case 'status' in e && e.status == 400:
-      // @ts-ignore
+    case 'status' in e && e.status == 400: // @ts-ignore
       return response.badRequest(null, e?.message)
 
     default:
@@ -85,7 +65,7 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
   const app = options?.app ?? new Hono<E>()
 
   if (isDev())
-    app.use('*', logger((...args: any[]) => console.log(colors.gray(localDate()), ...args)))
+    app.use('*', logger((...args: any[]) => console.log(gray(localDate()), ...args)))
 
   app.use(async (c: Context, next: Next) => {
     c.set(GET_REQUEST as unknown as string, new request(c))

package/src/http.ts

@@ -1,10 +1,12 @@
-import type { Context, Next } from 'hono'
 import { MiddlewareType } from './middleware'
 import response from './response'
 import { GET_REQUEST } from './request'
 import { Ability } from './auth'
 import mergeMiddleware from './utils/merge-middleware'
-import { IRequest } from './types'
+import type {
+  Context, Next,
+  IRequest
+} from './types'
 
 function method(method: string, ...args: any[]): void | ClassDecorator {
   if (args.length == 1 && typeof args[0] == 'function')

package/src/index.ts

@@ -1,5 +1,5 @@
 export { default as Action, default as Route } from './action'
-export { default as Middleware } from './middleware'
+export * from './middleware'
 export { default as Response } from './response'
 export { default as Config } from './config'
 

package/src/middleware.ts

@@ -1,7 +1,11 @@
-import type { Context, MiddlewareHandler, Next } from 'hono'
+import type {
+  Context, MiddlewareHandler, Next,
+  IRequest,
+} from './types'
 
 export type MiddlewareType = MiddlewareHandler | Middleware | (new () => Middleware)
-export default class Middleware {
+
+export class Middleware {
   static factory?: Function
   static opts?: object | any[]
   static path: string = '*'
@@ -9,3 +13,5 @@ export default class Middleware {
     await next()
   }
 }
+
+export const toHonoMiddleware = (mw: MiddlewareHandler) => async (req: IRequest, next: Next) => await mw(req.cx, next)

package/src/response.ts

@@ -1,13 +1,9 @@
-import type { ContentfulStatusCode, RedirectStatusCode, StatusCode } from 'hono/utils/http-status'
-import type { BaseMime } from 'hono/utils/mime'
-import type { ResponseHeader } from 'hono/utils/headers'
-import type { ErrorResponse, Errors } from './types'
 import { HtmlEscapedCallbackPhase, resolveCallback } from 'hono/utils/html'
-
-type HeaderRecord =
-  | Record<'Content-Type', BaseMime>
-  | Record<ResponseHeader, string | string[]>
-  | Record<string, string | string[]>
+import type {
+  ContentfulStatusCode, RedirectStatusCode, StatusCode,
+  BaseMime, HeaderRecord,
+  ErrorResponse, Errors,
+} from './types'
 
 type RBag = {
   status?: StatusCode,

package/src/types.ts

@@ -1,14 +1,34 @@
-import type { Handler, ValidationTargets } from 'hono'
-import { ResponseHeader } from 'hono/utils/headers'
-import { StatusCode } from 'hono/utils/http-status'
-import { BaseMime } from 'hono/utils/mime'
+import type {
+  Hono, Env, Handler,
+  ErrorHandler, NotFoundHandler,
+  ValidationTargets,
+  // MiddlewareHandler,
+} from 'hono'
+import type { ResponseHeader } from 'hono/utils/headers'
+// import type { StatusCode } from 'hono/utils/http-status'
+import type { BaseMime } from 'hono/utils/mime'
 import z from 'zod'
 import Action from './action'
 import request from './request'
 import response from './response'
 import validator from './validator'
 
-export type { Context, Next } from 'hono'
+
+// export type { H, Handler, HandlerResponse } from 'hono/types'
+export type {
+  Env, Context, Next,
+  // ErrorHandler, NotFoundHandler,
+  MiddlewareHandler, // TODO: remove..
+  ValidationTargets,
+} from 'hono'
+export type { HTTPResponseError } from 'hono/types'
+
+export type {
+  ContentfulStatusCode,
+  RedirectStatusCode,
+  StatusCode,
+} from 'hono/utils/http-status'
+export type { BaseMime }
 
 type PublicMethods<T> = {
   [K in keyof T]: K extends `#${string}` | `$${string}` | symbol | 'prototype' ? never : K
@@ -34,16 +54,32 @@ export type Route = {
   handle: Handlers,
 }
 
-export type ActionType = Function | Handler | Action | (new () => Action)
+// export type ActionType = Function | Handler | Action | (new () => Action)
 
 export type Handlers = (Function | Handler | (new () => Action))[]
 
 export type Routes = Route[]
 
-export type LambdaResponse = {
-  statusCode: StatusCode,
-  body: string,
+export type HeaderRecord =
+  | Record<'Content-Type', BaseMime>
+  | Record<ResponseHeader, string | string[]>
+  | Record<string, string | string[]>
+
+
+export type InitFunction<E extends Env = Env> = (app: Hono<E>) => void
+export type ServerOptions<E extends Env = Env> = Partial<{
+  routes: Routes,
+  notFound: NotFoundHandler<E>,
+  onError: ErrorHandler<E>,
+  root: string,
+  app?: Hono<E>,
+  init?: InitFunction<E>,
+}>
+
+export interface MiddlewareFactory {
+
 }
+// export type MiddlewareType = MiddlewareHandler | Middleware | (new () => Middleware)
 
 export type Errors = Record<string, string | string[]>
 export type ErrorResponse = {
@@ -51,16 +87,23 @@ export type ErrorResponse = {
   e?: Errors, // error bag
 }
 
-export type ResponseHeadersInit = [
-    string,
-    string
-][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers
-export type ResponseInit<T extends StatusCode = StatusCode> = {
-    headers?: ResponseHeadersInit,
-    status?: T,
-    statusText?: string,
-}
-export type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response
+// TODO: not used..
+
+// export type LambdaResponse = {
+//   statusCode: StatusCode,
+//   body: string,
+// }
+
+// export type ResponseHeadersInit = [
+//     string,
+//     string
+// ][] | Record<"Content-Type", BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers
+// export type ResponseInit<T extends StatusCode = StatusCode> = {
+//     headers?: ResponseHeadersInit,
+//     status?: T,
+//     statusText?: string,
+// }
+// export type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response
 // export type JSONValue =
 //   | string
 //   | number

package/src/utils/colors.ts

@@ -0,0 +1,102 @@
+// ISC License
+
+// Copyright (c) 2021 Alexey Raspopov, Kostiantyn Denysov, Anton Verinov
+
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+// https://github.com/alexeyraspopov/picocolors/commit/6f0a4638348ed20633d623ee973f9c9a96f65104
+
+import { getColorEnabledAsync } from 'hono/utils/color'
+
+export const enabled = await getColorEnabledAsync()
+export const isColorSupported = enabled
+
+// const { env, stdout } = globalThis?.process ?? {}
+// const enabled =
+//   env &&
+//   !env.NO_COLOR &&
+//   (env.FORCE_COLOR || (stdout?.isTTY && !env.CI && env.TERM !== 'dumb'))
+
+const replaceClose = (
+  str: string,
+  close: string,
+  replace: string,
+  index: number
+): string => {
+  const start = str.substring(0, index) + replace
+  const end = str.substring(index + close.length)
+  const nextIndex = end.indexOf(close)
+  return ~nextIndex
+    ? start + replaceClose(end, close, replace, nextIndex)
+    : start + end
+}
+
+const formatter = (open: string, close: string, replace = open) => {
+  if (!enabled) return String
+  return (input: string) => {
+    const string = '' + input
+    const index = string.indexOf(close, open.length)
+    return ~index
+      ? open + replaceClose(string, close, replace, index) + close
+      : open + string + close
+  }
+}
+
+export const reset = enabled ? (s: string) => `\x1b[0m${s}\x1b[0m` : String
+export const bold = formatter('\x1b[1m', '\x1b[22m', '\x1b[22m\x1b[1m')
+export const dim = formatter('\x1b[2m', '\x1b[22m', '\x1b[22m\x1b[2m')
+export const italic = formatter('\x1b[3m', '\x1b[23m')
+export const underline = formatter('\x1b[4m', '\x1b[24m')
+export const inverse = formatter('\x1b[7m', '\x1b[27m')
+export const hidden = formatter('\x1b[8m', '\x1b[28m')
+export const strikethrough = formatter('\x1b[9m', '\x1b[29m')
+
+const endText = '\x1b[39m'
+export const black = formatter('\x1b[30m', endText)
+export const red = formatter('\x1b[31m', endText)
+export const green = formatter('\x1b[32m', endText)
+export const yellow = formatter('\x1b[33m', endText)
+export const blue = formatter('\x1b[34m', endText)
+export const magenta = formatter('\x1b[35m', endText)
+export const purple = formatter('\x1b[38;2;173;127;168m', endText)
+export const cyan = formatter('\x1b[36m', endText)
+export const white = formatter('\x1b[37m', endText)
+export const gray = formatter('\x1b[90m', endText)
+
+const endBg = '\x1b[49m'
+export const bgBlack = formatter('\x1b[40m', endBg)
+export const bgRed = formatter('\x1b[41m', endBg)
+export const bgGreen = formatter('\x1b[42m', endBg)
+export const bgYellow = formatter('\x1b[43m', endBg)
+export const bgBlue = formatter('\x1b[44m', endBg)
+export const bgMagenta = formatter('\x1b[45m', endBg)
+export const bgCyan = formatter('\x1b[46m', endBg)
+export const bgWhite = formatter('\x1b[47m', endBg)
+
+export const blackBright = formatter("\x1b[90m", endText)
+export const redBright = formatter("\x1b[91m", endText)
+export const greenBright = formatter("\x1b[92m", endText)
+export const yellowBright = formatter("\x1b[93m", endText)
+export const blueBright = formatter("\x1b[94m", endText)
+export const magentaBright = formatter("\x1b[95m", endText)
+export const cyanBright = formatter("\x1b[96m", endText)
+export const whiteBright = formatter("\x1b[97m", endText)
+
+export const bgBlackBright = formatter("\x1b[100m", endBg)
+export const bgRedBright = formatter("\x1b[101m", endBg)
+export const bgGreenBright = formatter("\x1b[102m", endBg)
+export const bgYellowBright = formatter("\x1b[103m", endBg)
+export const bgBlueBright = formatter("\x1b[104m", endBg)
+export const bgMagentaBright = formatter("\x1b[105m", endBg)
+export const bgCyanBright = formatter("\x1b[106m", endBg)
+export const bgWhiteBright = formatter("\x1b[107m", endBg)

package/src/utils/log.ts

@@ -1,4 +1,4 @@
-import { blue, bold, gray, green, magenta, red, yellow, white } from 'picocolors'
+import { blue, bold, gray, green, magenta, red, yellow, white } from './colors'
 
 const _step = (color: Function, ...msg: any[]) => {
   const length = msg.length

package/src/utils/port.ts

@@ -1,5 +1,5 @@
 import net from 'node:net'
-import { exec } from 'child_process'
+import { exec } from 'node:child_process'
 import { error, warn } from './log'
 
 export function withPort(desiredPort: number, cb: (port: number) => void, maxAttempts = 10) {

package/src/utils/resolve.ts

@@ -1,8 +1,4 @@
-import Action from '../action'
-import { MiddlewareType } from '../middleware'
-import type { ActionType } from '../types'
-
-export function resolve(obj: ActionType, id: string) {
+export function resolve(obj: any, id: string) {
   if (typeof obj == 'function' && obj?.length == 2)
     return [obj]
 
@@ -12,7 +8,7 @@ export function resolve(obj: ActionType, id: string) {
   if (obj?.handle)
     return obj.handle()
 
-  const instance = new (obj as new () => Action)()
+  const instance = new obj()
   if (obj?.prototype?.run)
     return instance.run()
 
@@ -22,7 +18,7 @@ export function resolve(obj: ActionType, id: string) {
   throw new Error(`Invalid action "${id}" - unsupported type`)
 }
 
-export function resolveMiddleware(obj: MiddlewareType) {
+export function resolveMiddleware(obj: any) {
   if (typeof obj == 'function' && obj.length == 2)
     return obj
 

package/src/validator.ts

@@ -1,62 +1,40 @@
 import { ZodObject } from 'zod'
 import { zValidator } from '@hono/zod-validator'
-import type { ValidationTargets } from 'hono'
-import type { Rule, Rules } from './types'
 import response from './response'
+import type {
+  Rule, Rules,
+  ValidationTargets,
+} from './types'
 
 export default class $Validator {
-  private static cache = new Map<string, any>()
+  private static cache = new Map<string, (schema: ZodObject<any>) => Rule>()
 
   private static createRule<T extends keyof ValidationTargets>(
     target: T,
-    schema?: ZodObject<any>
-  ):
-    | { schema: (schema: ZodObject<any>) => Rule }
-    | Rule
-  {
-    if (schema != null) {
-      return {
-        target,
-        schema,
-        eTarget: 'fieldErrors'
-      } satisfies Rule
-    }
-
+    schema: ZodObject<any>
+  ): Rule {
     return {
-      schema: (schema: ZodObject<any>) => ({
-        target,
-        schema,
-        eTarget: 'fieldErrors'
-      })
+      target,
+      schema,
+      eTarget: 'fieldErrors'
     }
   }
 
-  private static getOrCreateAlias<T extends keyof ValidationTargets>(target: T) {
+  private static fn<T extends keyof ValidationTargets>(target: T) {
     if (this.cache.has(target))
       return this.cache.get(target)
 
-    const aliasFunc = (schema?: ZodObject<any>) => {
-      if (schema != null)
-        return this.createRule(target, schema)
-
-      return this.createRule(target)
-    }
-
-    const typedAlias = aliasFunc as {
-      (): { schema: (schema: ZodObject<any>) => Rule },
-      (schema: ZodObject<any>): Rule,
-    }
-
-    this.cache.set(target, typedAlias)
-    return typedAlias
+    const fn = (schema: ZodObject<any>) => this.createRule(target, schema)
+    this.cache.set(target, fn)
+    return fn
   }
 
-  static readonly json = $Validator.getOrCreateAlias('json')
-  static readonly form = $Validator.getOrCreateAlias('form')
-  static readonly query = $Validator.getOrCreateAlias('query')
-  static readonly param = $Validator.getOrCreateAlias('param')
-  static readonly header = $Validator.getOrCreateAlias('header')
-  static readonly cookie = $Validator.getOrCreateAlias('cookie')
+  static readonly json = $Validator.fn('json')
+  static readonly form = $Validator.fn('form')
+  static readonly query = $Validator.fn('query')
+  static readonly param = $Validator.fn('param')
+  static readonly header = $Validator.fn('header')
+  static readonly cookie = $Validator.fn('cookie')
 
   static parse(rules: Rules): Function[] {
     return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore

package/src/context.ts

@@ -1,43 +0,0 @@
-import { Context } from 'hono'
-import { getCookie, getSignedCookie, setCookie, setSignedCookie, deleteCookie } from 'hono/cookie'
-import type { CookieOptions, CookiePrefixOptions } from 'hono/utils/cookie'
-
-const cookieWrapper = (c: Context) => ({
-  all: () => getCookie(c),
-  allSigned: (secret: string) => getSignedCookie(c, secret),
-  get: (name: string, prefixOptions?: CookiePrefixOptions) => prefixOptions ? getCookie(c, name, prefixOptions) : getCookie(c, name),
-  getSigned: (secret: string, name: string, prefixOptions?: CookiePrefixOptions) => prefixOptions ? getSignedCookie(c, secret, name, prefixOptions) : getSignedCookie(c, secret, name),
-  set: (name: string, value: string, opt?: CookieOptions) => setCookie(c, name, value, opt),
-  setSigned: (name: string, value: string, secret: string, opt?: CookieOptions) => setSignedCookie(c, name, value, secret, opt),
-  delete: (name: string, opt?: CookieOptions) => deleteCookie(c, name, opt)
-})
-
-export default class CX {
-  static #c: Context
-  static #cookie: ReturnType<typeof cookieWrapper>
-
-  static setContext(c: Context) {
-    this.#c = c
-    this.#cookie = cookieWrapper(c)
-  }
-
-  static get cx(): Context {
-    return this.#c
-  }
-
-  static get cookie() {
-    return this.#cookie
-  }
-
-  static get ip(): string | undefined {
-    return this.#c.req.header('cf-connecting-ip')
-      || this.#c.req.header('x-forwarded-for')?.split(',')[0]?.trim()
-      || this.#c.env?.aws?.lambda?.event?.requestContext?.identity?.sourceIp
-      || this.#c.req.header('x-real-ip')
-      || this.#c.env?.remoteAddr?.hostname
-  }
-
-  static get userAgent(): string | undefined {
-    return this.#c.req.header('user-agent')
-  }
-}

package/src/esbuild.mjs

@@ -1,124 +0,0 @@
-import esbuild from 'esbuild'
-import { basename, dirname, join, relative } from 'node:path'
-import { mkdirSync, existsSync, readdirSync, rmSync, copyFileSync } from 'node:fs'
-import { readFile, stat, writeFile } from 'node:fs/promises'
-
-const fail = (e) => {
-  console.error('❌ Build failed' + (e ? ':' : ''), e || '')
-  process.exit(1)
-}
-
-const args = process.argv.slice(2)
-const platform = args[0] || ''
-
-const platforms = ['aws', 'cf']
-if (!platform || !platforms.includes(platform))
-  fail()
-
-const __dirname = dirname(new URL(import.meta.url).pathname)
-
-const formatSize = (bytes) => {
-  if (bytes < 1024) return `${bytes}b`
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)}kb`
-  return `${(bytes / (1024 * 1024)).toFixed(2)}mb`
-}
-const formatTime = (ms) => {
-  if (ms < 1000) return `${ms}ms`
-  return `${(ms / 1000).toFixed(2)}s`
-}
-
-const isCF = platform == 'cf'
-const buildOptions = {
-  entryPoints: [join(__dirname, `prod-${platform}.ts`)],
-  bundle: true,
-  minify: true,
-  outfile: join(__dirname, '../../../dist/index.js'),
-  platform: isCF ? 'browser' : 'node',
-  target: isCF ? 'es2022' : 'node20',
-  conditions: isCF ? ['worker', 'browser'] : [],
-  format: 'esm',
-  treeShaking: true,
-  legalComments: 'none',
-  external: [
-    '@aws-sdk', '@smithy',
-    ...(isCF ? [
-      'cloudflare:workers',
-      'node:crypto', 'crypto',
-      'node:buffer', 'buffer',
-    ] : []),
-  ],
-  metafile: true,
-  write: false,
-  plugins: [
-    {
-      name: 'preserve-class-names',
-      setup(build) {
-        build.onLoad(
-          { filter: /(actions|features|routes)\/.*\.ts$/ },
-          async (args) => {
-            const contents = await readFile(args.path, 'utf8')
-            const result = await esbuild.transform(contents, {
-              loader: 'ts',
-              minify: true,
-              keepNames: true
-            })
-            return { contents: result.code, loader: 'ts' }
-          }
-        )
-      },
-    },
-    {
-      name: 'remove-use-strict',
-      setup(build) {
-        build.onEnd(async (result) => {
-          if (!result.outputFiles) return
-
-          const files = result.outputFiles.filter(file => file.path.endsWith('.js'))
-          await Promise.all(files.map(async file => {
-            if (!file.path.endsWith('.js')) return
-
-            await writeFile(
-              file.path,
-              new TextDecoder()
-                .decode(file.contents)
-                .replace(/(["'`])\s*use strict\s*\1;?|`use strict`;?/g, '')
-            )
-          }))
-        })
-      }
-    }
-  ]
-}
-
-const startTime = Date.now()
-const cwd = join(__dirname, '../../..')
-
-const distDir = join(cwd, 'dist')
-existsSync(distDir)
-  ? readdirSync(distDir).forEach(file => rmSync(join(distDir, file), { recursive: true, force: true }))
-  : mkdirSync(distDir, { recursive: true })
-
-for (const file of await readdirSync(distDir))
-  await rmSync(join(distDir, file))
-
-if (isCF) {
-  for (let file of [
-    'wrangler.toml',
-  ]) {
-    file = join(cwd, file)
-    if (existsSync(file))
-      copyFileSync(file, join(cwd, 'dist', basename(file)))
-  }
-}
-
-esbuild.build(buildOptions)
-  .then(async result => {
-    const outputFile = buildOptions.outfile
-    const stats = await stat(outputFile)
-    const size = formatSize(stats.size)
-
-    console.log(`\n⚡️ Done in ${formatTime(Date.now() - startTime)}`)
-    console.log(`    ${relative(join(cwd, 'node_modules/rajt/src'), buildOptions.entryPoints[0])} → ${relative(cwd, outputFile)}`)
-    console.log(`    Size: ${size}`)
-    console.log(`    Files: ${Object.keys(result.metafile.outputs).length}`)
-  }).catch(fail)

package/src/exceptions.ts

@@ -1,15 +0,0 @@
-export class Unauthorized extends Error {
-  status = 401
-  constructor(message = 'Unauthorized') {
-    super(message)
-    this.name = 'UnauthorizedError'
-  }
-}
-
-export class BadRequest extends Error {
-  status = 400
-  constructor(message = 'Bad Request') {
-    super(message)
-    this.name = 'BadRequestError'
-  }
-}

package/src/scripts/cache-routes.ts

@@ -1,10 +0,0 @@
-import { cacheRoutes } from '../routes'
-
-cacheRoutes()
-  .then(() => {
-    console.log('✅ Routes cached!')
-    process.exit(0)
-  }).catch(e => {
-    console.error('❌ Error: ', e)
-    process.exit(1)
-  })