rajt 0.0.58 → 0.0.59

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.58",
+  "version": "0.0.59",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -10,8 +10,11 @@
   "exports": {
     ".": "./src/index.ts",
     "./auth": "./src/auth/index.ts",
-    "./dynamodb": "./src/dynamodb/index.ts",
-    "./dynamodb/types": "./src/dynamodb/types.ts",
+    "./d1": "./src/db/d1.ts",
+    "./d1/types": "./src/db.d.ts",
+    "./dynamodb": "./src/db/dynamodb.ts",
+    "./dynamodb/types": "./src/db/dynamodb.d.ts",
+    "./enum": "./src/enum.ts",
     "./http": "./src/http.ts",
     "./types": "./src/types.ts",
     "./env": "./src/utils/environment.ts",
@@ -48,12 +51,10 @@
     "start": "node ../../dist/index.js"
   },
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "3.817.0",
-    "@aws-sdk/lib-dynamodb": "3.817.0",
     "@hono/zod-validator": "^0.4.3",
     "cripta": "^0.1",
+    "forj": "^0.0.2",
     "hono": "^4.7.6",
-    "pluralize": "^8.0",
     "t0n": "^0.1.5",
     "ua-parser-js": "^2.0.4"
   },
@@ -71,7 +72,6 @@
     "@miniflare/storage-file": "^2.14.4",
     "@miniflare/web-sockets": "^2.14.4",
     "@types/node": "^20.11.0",
-    "@types/pluralize": "^0.0.33",
     "bun-types": "^1.2.14",
     "chokidar-cli": "^3.0.0",
     "citty": "^0.1.6",

package/src/action-old.ts

@@ -0,0 +1,72 @@
+// import { Context, Handler, HonoRequest, MiddlewareHandler, Next, ValidationTargets } from 'hono'
+// import { JSONValue } from 'hono/utils/types'
+import { Context, Handler, ValidationTargets } from 'hono'
+import { z, ZodObject } from 'zod'
+import { zValidator } from '@hono/zod-validator'
+import response from './response'
+import cx from './context'
+
+export type ActionType = Function | Handler | Action | (new () => Action)
+
+type RuleDefinition = {
+  schema: z.ZodObject<any>
+  target: keyof ValidationTargets
+  eTarget?: 'fieldErrors' | 'formErrors'
+}
+
+export default class Action {
+  static rule<T extends keyof ValidationTargets>(target: T): { schema: (schema: ZodObject<any>) => RuleDefinition }
+  static rule<T extends keyof ValidationTargets>(target: T, schema: ZodObject<any>): RuleDefinition
+  static rule<T extends keyof ValidationTargets>(target: T, schema?: ZodObject<any>):
+    | { schema: (schema: ZodObject<any>) => RuleDefinition }
+    | RuleDefinition
+  {
+    if (schema !== undefined) {
+      return {
+        target,
+        schema,
+        eTarget: 'fieldErrors' // | 'formErrors'
+      } satisfies RuleDefinition
+    }
+
+    return {
+      schema: (schema: ZodObject<any>) => ({
+        target,
+        schema,
+        eTarget: 'fieldErrors' // | 'formErrors'
+      })
+    }
+  }
+
+  static validate() {
+    const rules = this.rules()
+    const h = async (c: Context) => {
+      return await this.handle(cx.cx)
+    }
+    if (!rules) return [h]
+
+    const rulesArray: Function[] = (Array.isArray(rules) ? rules : [rules])
+      // @ts-ignore
+      .map(rule => zValidator(rule.target, rule.schema, (result, c) => {
+        if (!result.success) {
+          // @ts-ignore
+          return response.badRequest({ ...result.error.flatten()[rule.eTarget] })
+        }
+      }))
+
+    rulesArray.push(h)
+    return rulesArray
+  }
+
+  static run() {
+    return this.validate()
+  }
+
+  static rules(): RuleDefinition[] | RuleDefinition | null {
+    return null
+  }
+
+  static async handle(c: Context): Promise<Response> {
+    return Promise.resolve(response.raw(200, 'Action handle not implemented'))
+  }
+}

package/src/action.ts

@@ -1,72 +1,23 @@
-// import { Context, Handler, HonoRequest, MiddlewareHandler, Next, ValidationTargets } from 'hono'
-// import { JSONValue } from 'hono/utils/types'
-import { Context, Handler, ValidationTargets } from 'hono'
-import { z, ZodObject } from 'zod'
-import { zValidator } from '@hono/zod-validator'
-import Response from './response'
-import cx from './context'
-
-export type ActionType = Function | Handler | Action | (new () => Action)
-
-type RuleDefinition = {
-  schema: z.ZodObject<any>
-  target: keyof ValidationTargets
-  eTarget?: 'fieldErrors' | 'formErrors'
-}
+import response from './response'
+import validator from './validator'
+import type { Context, IRequest, IResponse, IValidator, Rules } from './types'
 
 export default class Action {
-  static rule<T extends keyof ValidationTargets>(target: T): { schema: (schema: ZodObject<any>) => RuleDefinition }
-  static rule<T extends keyof ValidationTargets>(target: T, schema: ZodObject<any>): RuleDefinition
-  static rule<T extends keyof ValidationTargets>(target: T, schema?: ZodObject<any>):
-    | { schema: (schema: ZodObject<any>) => RuleDefinition }
-    | RuleDefinition
-  {
-    if (schema !== undefined) {
-      return {
-        target,
-        schema,
-        eTarget: 'fieldErrors' // | 'formErrors'
-      } satisfies RuleDefinition
-    }
-
-    return {
-      schema: (schema: ZodObject<any>) => ({
-        target,
-        schema,
-        eTarget: 'fieldErrors' // | 'formErrors'
-      })
-    }
-  }
-
-  static validate() {
-    const rules = this.rules()
-    const h = async (c: Context) => {
-      return await this.handle(cx.cx)
-    }
+  static run() {
+    const rules = this.rules(validator)
+    const h = async (c: Context) => await this.handle(c.get('_'), response)
     if (!rules) return [h]
 
-    const rulesArray: Function[] = (Array.isArray(rules) ? rules : [rules])
-      // @ts-ignore
-      .map(rule => zValidator(rule.target, rule.schema, (result, c) => {
-        if (!result.success) {
-          // @ts-ignore
-          return Response.badRequest({ ...result.error.flatten()[rule.eTarget] })
-        }
-      }))
-
-    rulesArray.push(h)
-    return rulesArray
-  }
-
-  static run() {
-    return this.validate()
+    const pipe = validator.parse(rules)
+    pipe.push(h)
+    return pipe
   }
 
-  static rules(): RuleDefinition[] | RuleDefinition | null {
+  static rules(v: IValidator): Rules {
     return null
   }
 
-  static async handle(c: Context): Promise<Response> {
-    return Promise.resolve(Response.raw(200, 'Action handle not implemented'))
+  static async handle(req: IRequest, res: IResponse): Promise<Response> {
+    return Promise.resolve(res.raw(200, 'Action handle not implemented'))
   }
 }

package/src/auth/ability.ts

@@ -16,8 +16,8 @@ export class Ability {
     const paths = actions?.map(a => Array.isArray(a) ? a[0] + a[1] : a.method + a.path) || []
     const items = new Set(paths)
 
-    if (items.size !== actions.length)
-      throw new Error(`Duplicate routes detected: "${paths.filter((path, index) => paths.indexOf(path) !== index).join('", "')}"`)
+    if (items.size != actions.length)
+      throw new Error(`Duplicate routes detected: "${paths.filter((path, index) => paths.indexOf(path) != index).join('", "')}"`)
 
     this.#abilities = Array.from(new Set(actions?.map(a => Array.isArray(a) ? a[3] : a.name) || []))
       .map(a => this.format(a))

package/src/auth/authnz.ts

@@ -79,4 +79,7 @@ export class Authnz<T extends object> {
   get data() {
     return this.#data
   }
+  get user() {
+    return this.#data
+  }
 }

package/src/auth/index.ts

@@ -1,5 +1,4 @@
 export { Ability } from './ability'
-export { Auth, Auth as Gate } from './auth'
 export { Authnz } from './authnz'
 export { Token } from './token'
 

package/src/auth/token.ts

@@ -1,19 +1,20 @@
 import { Envir } from 't0n'
 import { Token as Factory } from 'cripta'
 import { UAParser } from 'ua-parser-js'
-import c from '../context'
+import type { IRequest } from '@/types'
 
 export class Token {
+  static #cookieName: string = '__auth_'
   static #name: string = 'Authorization'
   static #prefix: string = 'bearer'
 
-  static fromRequest() {
-    const token = this.fromCookie() || this.fromHeader()
-    return token ? this.parse(token) : null
+  static fromRequest(req: IRequest) {
+    const token = this.fromCookie(req) || this.fromHeader(req)
+    return token ? this.parse(req, token) : null
   }
 
-  static fromHeader(): string | null {
-    const header = c.cx.req.header(this.#name) || c.cx.req.header('HTTP_AUTHORIZATION') || c.cx.req.header('REDIRECT_HTTP_AUTHORIZATION') || null
+  static fromHeader(req: IRequest): string | null {
+    const header = req.header(this.#name) || req.header('HTTP_AUTHORIZATION') || req.header('REDIRECT_HTTP_AUTHORIZATION') || null
 
     if (header) {
       const pos = header.toLowerCase().indexOf(this.#prefix.toLowerCase())
@@ -29,39 +30,39 @@ export class Token {
     return null
   }
 
-  static fromCookie(): string | null {
-    const uid = c.cx.req.header('uid')
+  static fromCookie(req: IRequest): string | null {
+    const uid = req.header('uid')
 
     if (uid) {
-      const auth = c.cookie.get('__auth_' + uid)
+      const auth = req.cookie.get(this.#cookieName + uid)
       return auth ? auth : null
     }
 
     return null
   }
 
-  static parse(token: string) {
-    const host = this.host()
+  static parse(req: IRequest, token: string) {
+    const host = this.host(req)
     const serveHost = Envir.get('FLOW_SERVER', host) as string
 
     return Factory.parse(token)
       .issuedBy(serveHost)
       .permittedFor(host)
-      .withClaim('u', this.userAgent())
-      .withClaim('i', this.ip())
+      .withClaim('u', this.userAgent(req))
+      .withClaim('i', this.ip(req))
   }
 
-  static create(user: any, exp: number = 7200) {
+  static create(req: IRequest, user: any, exp: number = 7200) {
     const time = Math.floor(Date.now() / 1000)
-    const host = this.host(c.cx.req.header('host') || '')
+    const host = this.host(req)
 
     return Factory.create()
       .issuedBy(host)
       .permittedFor(host)
       .issuedAt(time)
       .expiresAt(time + exp)
-      .withClaim('u', this.userAgent())
-      .withClaim('i', this.ip())
+      .withClaim('u', this.userAgent(req))
+      .withClaim('i', this.ip(req))
       .body(user)
   }
 
@@ -73,8 +74,9 @@ export class Token {
     this.#name = name
   }
 
-  static host(url?: string | null | undefined): string {
-    if (!url) url = c.cx.req.url || c.cx.req.header('host') || ''
+  static host(req: IRequest): string {
+    const url = req.url || req.header('host')
+    if (!url) return ''
 
     let formattedUrl = String(url)
     if (!formattedUrl.startsWith('http'))
@@ -88,13 +90,14 @@ export class Token {
     }
   }
 
-  static userAgent() {
-    if (!c?.userAgent) return 0
-    const { browser, device, os } = UAParser(c.userAgent)
+  static userAgent(req: IRequest) {
+    const ua = req?.userAgent
+    if (!ua) return 0
+    const { browser, device, os } = UAParser(ua)
     return (browser?.name || '') + (browser?.major || '') + (device?.model || '') + (os?.name || '')
   }
 
-  static ip() {
-     return c?.ip || 0
+  static ip(req: IRequest) {
+     return req?.ip || 0
   }
 }

package/src/bin/rajt.js

@@ -35,7 +35,7 @@ Consider using a Node.js version manager such as https://volta.sh or https://git
 
   let tsxPath;
   for (const pathOption of tsxPaths) {
-    if (pathOption === "tsx" || existsSync(pathOption)) {
+    if (pathOption == "tsx" || existsSync(pathOption)) {
       tsxPath = pathOption;
       break;
     }
@@ -72,7 +72,7 @@ Consider using a Node.js version manager such as https://volta.sh or https://git
     }
   )
     .on("exit", (code) =>
-      process.exit(code === undefined || code === null ? 0 : code)
+      process.exit(code == null ? 0 : code)
     )
     .on("message", (message) => {
       if (process.send) {

package/src/cli/commands/dev/index.ts

@@ -103,7 +103,7 @@ export default defineCommand({
 							}
 						).on('exit', code => {
 							logger.step(`Lambda process exited with code ${code ?? 0}`)
-							if (code !== 0 && code !== null)
+							if (code != 0 && code != null)
 								logger.error('Lambda process crashed, waiting for restart...')
 
 							lambda = null
@@ -277,7 +277,7 @@ async function wait(ms: number) {
 function getDockerHost() {
 	const platform = process.platform
 
-	if (platform === 'darwin') {
+	if (platform == 'darwin') {
 		for (const socket of [
 			'/Users/'+ process.env.USER +'/.docker/run/docker.sock',
 			'/var/run/docker.sock',

package/src/cli/commands/dev/utils.ts

@@ -6,6 +6,8 @@ import { mkdirSync, existsSync, readdirSync, rmSync, copyFileSync } from 'node:f
 import { readFile, stat, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative } from 'node:path'
 
+import { cacheRoutes } from '../../../routes'
+
 const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../../../../')
 const __rajt = join(__dirname, 'node_modules/rajt/src')
 
@@ -113,6 +115,10 @@ export const build = async (platform: 'aws' | 'cf' | 'node') => {
     ],
   }
 
+  await cacheRoutes()
+
+  logger.step('Routes cached')
+
   const result = await esbuild.build(opts)
   if (!result?.metafile) throw Error('build fail')
 
@@ -164,10 +170,13 @@ export async function createMiniflare(options = {}, configPath = 'wrangler.toml'
 
     d1Databases: Object.fromEntries(config.d1_databases.map(db => [db.binding, db.database_id])),
 
-    modules: true,
-    modulesRules: [
-      { type: 'ESModule', include: ['**/*.js', '**/*.ts'] },
+    modules: [
+      { type: "ESModule", path: "dist/index.js" },
     ],
+    // modules: true,
+    // modulesRules: [
+    //   { type: 'ESModule', include: ['**/*.js', '**/*.ts'] },
+    // ],
 
     kvPersist: join(__dirname, '.wrangler/state/v3/kv'),
     cachePersist: join(__dirname, '.wrangler/state/v3/cache'),

package/src/create-app.ts

@@ -7,15 +7,15 @@ import type { Env, Context, ErrorHandler, NotFoundHandler, Next } from 'hono'
 // import type { H, Handler, HandlerResponse } from 'hono/types'
 import type { HTTPResponseError } from 'hono/types'
 import colors from 'picocolors'
+import { Envir } from 't0n'
 import type { Routes } from './types'
 import { BadRequest, Unauthorized } from './exceptions'
 import { resolve, resolveMiddleware } from './utils/resolve'
 import { getMiddlewares, getHandler } from './register'
 import { isDev } from './utils/environment'
 import localDate from './utils/local-date'
-import { Auth } from './auth'
+import request from './request'
 import response from './response'
-import cx from './context'
 
 type InitFunction<E extends Env = Env> = (app: Hono<E>) => void
 
@@ -40,7 +40,7 @@ const EHandler = async (e: Error | HTTPResponseError) => {
     case e instanceof BadRequest:
     case 'status' in e && e.status == 400:
       // @ts-ignore
-      return response.badRequest(undefined, e?.message)
+      return response.badRequest(null, e?.message)
 
     default:
       return response.internalError(
@@ -85,12 +85,12 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
     app.use('*', logger((...args: any[]) => console.log(colors.gray(localDate()), ...args)))
 
   app.use(async (c: Context, next: Next) => {
-    cx.setContext(c)
-    Auth.resolve()
+    c.set('_', new request(c))
+    if (c.env) Envir.add(c.env)
     await next()
   })
   getMiddlewares().forEach(mw => {
-    const h = async (c: Context, next: Next) => await resolveMiddleware(mw)(cx.cx, next)
+    const h = async (c: Context, next: Next) => await resolveMiddleware(mw)(c.get('_'), next)
     // @ts-ignore
     mw?.path ? app.use(String(mw.path), h) : app.use(h)
   })
@@ -117,7 +117,7 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
 
 function mw(...objs: string[]): Function[] {
   return objs.flatMap(obj => {
-    if (typeof obj !== 'string') return null
+    if (typeof obj != 'string') return null
     // @ts-ignore
     return getHandler(obj)?.mw || null
   }).flat().filter(Boolean)

package/src/db/d1.d.ts

@@ -0,0 +1 @@
+export * from 'forj/d1/types'

package/src/db/d1.ts

@@ -0,0 +1 @@
+export * from 'forj/d1'

package/src/enum.ts

@@ -0,0 +1,2 @@
+export { Enum } from 't0n'
+export type { EnumStatic, EnumValue, EnumType } from 't0n'

package/src/http.ts

@@ -1,8 +1,9 @@
 import type { Context, Next } from 'hono'
 import { MiddlewareType } from './middleware'
-import Response from './response'
-import { Ability, Auth as Gate } from './auth'
+import response from './response'
+import { Ability } from './auth'
 import mergeMiddleware from './utils/merge-middleware'
+import { IRequest } from './types'
 
 function method(method: string, ...args: any[]): void | ClassDecorator {
   if (args.length == 1 && typeof args[0] == 'function')
@@ -101,11 +102,11 @@ export function Auth(...args: any[]): void | ClassDecorator {
 
 function _auth(target: Function | any) {
   mergeMiddleware(target, async (c: Context, next: Next) => {
-    const user = Gate.user
+    const req = c.get('_') as IRequest
     const ability = Ability.fromAction(target)
 
-    if (!user || !ability || Gate.cant(ability))
-      return Response.unauthorized()
+    if (!req?.user || !ability || req.cant(ability))
+      return response.unauthorized()
 
     await next()
   })

package/src/index.ts

@@ -1,6 +1,4 @@
 export { default as Action } from './action'
-export { Auth, Auth as Gate } from './auth/auth'
 export { default as Middleware } from './middleware'
-export { default as Request } from './request'
 export { default as Response } from './response'
 export { Enum } from 't0n'

package/src/request-old.ts

@@ -0,0 +1,98 @@
+import { bufferToFormData } from 'hono/utils/buffer'
+import { HTTPException } from 'hono/http-exception'
+import type { BodyData } from 'hono/utils/body'
+import Response from './response'
+import c from './context'
+
+export default class Request {
+  static param(key: string) {
+    return c.cx.req.param(key)
+  }
+
+  static query() {
+    return c.cx.req.query()
+  }
+
+  static async form(cType?: string) {
+    cType ??= c.cx.req.header('Content-Type')
+    if (!cType) return {}
+
+    let formData: FormData
+
+    if (c.cx.req.bodyCache.formData) {
+      formData = await c.cx.req.bodyCache.formData
+    } else {
+      try {
+        const arrayBuffer = await c.cx.req.arrayBuffer()
+        formData = await bufferToFormData(arrayBuffer, cType)
+        c.cx.req.bodyCache.formData = formData
+      } catch (e) {
+        throw new HTTPException(400, {
+          message: 'Malformed FormData request.'
+                   + (e instanceof Error ? ` ${e.message}` : ` ${String(e)}`)
+        })
+      }
+    }
+
+    const form: BodyData<{ all: true }> = {}
+    formData.forEach((value, key) => {
+      if (key.endsWith('[]')) {
+        ;((form[key] ??= []) as unknown[]).push(value)
+      } else if (Array.isArray(form[key])) {
+        ;(form[key] as unknown[]).push(value)
+      } else if (key in form) {
+        form[key] = [form[key] as string | File, value]
+      } else {
+        form[key] = value
+      }
+    })
+
+    return form
+  }
+
+  static async json<E>() {
+    try {
+      return await c.cx.req.json<E>()
+    } catch {
+      throw new HTTPException(400, { message: 'Malformed JSON in request body' })
+    }
+  }
+
+  static async body<E>() {
+    const cType = c.cx.req.header('Content-Type')
+    if (!cType) return {} as E
+
+    if (/^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType)) {
+      return await Request.json<E>()
+    }
+
+    if (
+      /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/.test(cType)
+      && ! /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/.test(cType)
+    ) {
+        return await Request.form() as E
+    }
+
+    return {} as E
+  }
+
+  static get response() {
+    return Response
+  }
+
+  static get cx() {
+    return c.cx
+  }
+
+  static get cookie() {
+    return c.cookie
+  }
+
+  static get ip() {
+    return c.ip
+  }
+
+  static get userAgent() {
+    return c.userAgent
+  }
+}