rajt 0.0.57 → 0.0.59

package/src/response.ts

@@ -1,37 +1,88 @@
-import type { ContentfulStatusCode, StatusCode } from 'hono/utils/http-status'
+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 c from './context'
+import { HtmlEscapedCallbackPhase, resolveCallback } from 'hono/utils/html'
 
-export default class Response {
-  static raw(status?: StatusCode, body?: string) {
-    return c.cx.newResponse(body ? body : null, { status })
+type HeaderRecord =
+  | Record<'Content-Type', BaseMime>
+  | Record<ResponseHeader, string | string[]>
+  | Record<string, string | string[]>
+
+type RBag = {
+  status?: StatusCode,
+  headers?: HeaderRecord,
+}
+
+export default class $Response {
+  static raw(
+    status?: StatusCode,
+    body?: any,
+    cType?: BaseMime,
+    headers?: HeaderRecord
+  ) {
+    const b: RBag = { status: status || 200 }
+
+    if (cType || headers) {
+      headers ??= {}
+      if (cType) headers['Content-Type'] = cType
+      b.headers = headers
+    }
+
+    return new Response(body ?? null, b)
+  }
+
+  static text(data?: string, status?: StatusCode) {
+    return this.raw(status, data, 'text/plain; charset=UTF-8' as BaseMime)
+  }
+
+  static json<T>(data?: T, status?: StatusCode, headers?: HeaderRecord) {
+    if (data == null)
+      return this.raw(status)
+
+    return this.raw(status, JSON.stringify(data), 'application/json', headers)
+  }
+
+  static redirect(
+    location: string | URL,
+    status?: RedirectStatusCode,
+    headers?: HeaderRecord
+  ) {
+    const loc = String(location)
+
+    return new Response(null, {
+      status: status || 302,
+      headers: { ...headers, 'Location': /[^\x00-\xFF]/.test(loc) ? encodeURI(loc) : loc }
+    })
+  }
+
+  static html(
+    html: string | Promise<string>,
+    status?: ContentfulStatusCode,
+    headers?: HeaderRecord
+  ): Response | Promise<Response> {
+    const res = (html: string) => this.raw(status, html, 'text/html; charset=UTF-8' as BaseMime, headers)
+    return typeof html == 'string'
+      ? res(html)
+      : resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res)
   }
 
   static ok(): Response
   static ok<T>(data: T): Response
   static ok<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(200)
-
-    return c.cx.json(data, 200)
+    return this.json(data, 200)
   }
 
   static created(): Response
   static created<T>(data: T): Response
   static created<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(201)
-
-    return c.cx.json(data, 201)
+    return this.json(data, 201)
   }
 
   static accepted(): Response
   static accepted<T>(data: T): Response
   static accepted<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(202)
-
-    return c.cx.json(data, 202)
+    return this.json(data, 202)
   }
 
   static deleted() {
@@ -50,19 +101,13 @@ export default class Response {
   static unauthorized(): Response
   static unauthorized<T>(data: T): Response
   static unauthorized<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(401)
-
-    return c.cx.json(data, 401)
+    return this.json(data, 401)
   }
 
   static forbidden(): Response
   static forbidden<T>(data: T): Response
   static forbidden<T>(data?: T) {
-    if (data === undefined)
-      return this.raw(403)
-
-    return c.cx.json(data, 403)
+    return this.json(data, 403)
   }
 
   static notFound(): Response
@@ -95,6 +140,6 @@ export default class Response {
     if (msg) resp.m = msg
     if (errors) resp.e = errors
 
-    return c.cx.json(resp, status)
+    return this.json(resp, status)
   }
 }

package/src/routes.ts

@@ -4,6 +4,11 @@ import { fileURLToPath } from 'node:url'
 import { Route } from './types'
 import { isAnonFn } from './utils/func'
 
+import { writeFileSync } from 'node:fs'
+import { config } from 'dotenv'
+import ensureDir from './utils/ensuredir'
+import versionSHA from './utils/version-sha'
+
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
@@ -29,7 +34,7 @@ const walk = async (dir: string, baseDir: string, fn: Function, parentMw: string
 
     if (stat.isDirectory()) {
       await walk(fullPath, baseDir, fn, currentMw)
-    } else if (file !== 'index.ts' && file.endsWith('.ts') && !file.endsWith('.d.ts')) {
+    } else if (file != 'index.ts' && file.endsWith('.ts') && !file.endsWith('.d.ts')) {
       const mod = await import(fullPath)
       fn(fullPath, baseDir, mod.default, currentMw)
     }
@@ -65,7 +70,7 @@ export async function getRoutes(
 }
 
 function sortRoutes(routes: Route[]) {
-  const metas = new Map<string, { score: number; segmentsCount: number }>()
+  const metas = new Map<string, { score: number, segmentsCount: number }>()
 
   for (const route of routes)
     metas.set(route.path, computeRouteMeta(route.path))
@@ -118,3 +123,62 @@ export async function getMiddlewares(
 
   return mw
 }
+
+const env = Object.entries(
+  config({ path: '../../.env.prod' })?.parsed || {}
+).filter(([key, val]) => key?.toLowerCase().indexOf('aws') != 0) // prevent AWS credentials
+
+const version = versionSHA('../../.git') // @ts-ignore
+env.push(['VERSION_SHA', process.env['VERSION_SHA'] = version]) // @ts-ignore
+env.push(['VERSION_HASH', process.env['VERSION_HASH'] = version?.substring(0, 7)])
+
+export async function cacheRoutes() {
+  const rolePath = join(__dirname, '../../../roles.json')
+  if (!existsSync(rolePath))
+    writeFileSync(rolePath, '{}')
+
+  const routes = await getRoutes()
+  const middlewares = await getMiddlewares()
+
+  const iPath = join(__dirname, '../../../tmp/import-routes.mjs')
+  ensureDir(iPath)
+  writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
+${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key + ':' + JSON.stringify(val)).join(',')}})` : ''}
+
+import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
+
+${routes.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
+${middlewares.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
+
+try {
+  const handlers = {${routes.map(r => r.name).join()}}
+
+  for (const [name, handler] of Object.entries(handlers)) {
+    if (typeof handler == 'function' || handler.prototype?.handle) {
+      registerHandler(name, handler)
+    }
+  }
+
+  const middlewares = {${middlewares.map(r => r.name).join()}}
+
+  for (const [name, mw] of Object.entries(middlewares)) {
+    registerMiddleware(mw)
+  }
+} catch (e) {
+  console.error('Failed to register handlers:', e)
+}
+`)
+
+  const rPath = join(__dirname, '../../../tmp/routes.json')
+  ensureDir(rPath)
+  writeFileSync(rPath, JSON.stringify(routes.filter(r => r.method && r.path).map(route => [
+    route.method,
+    route.path,
+    route.middlewares,
+    route.name,
+  ])))
+}
+
+function normalizePath(file: string) {
+  return file.replace(/\.tsx?$/i, '').replace(/(\/index)+$/i, '').replace(/\/+$/g, '')
+}

package/src/scripts/cache-routes.ts

@@ -1,67 +1,4 @@
-import { existsSync, writeFileSync } from 'node:fs'
-import { config } from 'dotenv'
-import { getRoutes, getMiddlewares } from '../routes'
-import ensureDir from '../utils/ensuredir'
-import versionSHA from '../utils/version-sha'
-
-const env = Object.entries(
-  config({ path: '../../.env.prod' })?.parsed || {}
-).filter(([key, val]) => key?.toLowerCase().indexOf('aws') != 0) // prevent AWS credentials
-
-const version = versionSHA('../../.git')
-env.push(['VERSION_SHA', process.env['VERSION_SHA'] = version])
-env.push(['VERSION_HASH', process.env['VERSION_HASH'] = version?.substring(0, 7)])
-
-async function cacheRoutes() {
-  const rolePath = '../../roles.json'
-  if (!existsSync(rolePath))
-    writeFileSync(rolePath, '{}')
-
-  const routes = await getRoutes()
-  const middlewares = await getMiddlewares()
-
-  const iPath = '../../tmp/import-routes.mjs'
-  ensureDir(iPath)
-  writeFileSync(iPath, `// AUTO-GENERATED FILE - DO NOT EDIT
-${env?.length ? `import { Envir } from '../node_modules/t0n/dist/index'\nEnvir.add({${env.map(([key, val]) => key + ':' + JSON.stringify(val)).join(',')}})` : ''}
-
-import { registerHandler, registerMiddleware } from '../node_modules/rajt/src/register'
-
-${routes.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
-${middlewares.map(r => `import ${r.name} from '../${normalizePath(r.file)}'`).join('\n')}
-
-try {
-  const handlers = {${routes.map(r => r.name).join()}}
-
-  for (const [name, handler] of Object.entries(handlers)) {
-    if (typeof handler === 'function' || handler.prototype?.handle) {
-      registerHandler(name, handler)
-    }
-  }
-
-  const middlewares = {${middlewares.map(r => r.name).join()}}
-
-  for (const [name, mw] of Object.entries(middlewares)) {
-    registerMiddleware(mw)
-  }
-} catch (e) {
-  console.error('Failed to register handlers:', e)
-}
-`)
-
-  const rPath = '../../tmp/routes.json'
-  ensureDir(rPath)
-  writeFileSync(rPath, JSON.stringify(routes.filter(r => r.method && r.path).map(route => [
-    route.method,
-    route.path,
-    route.middlewares,
-    route.name,
-  ])))
-}
-
-function normalizePath(file: string) {
-  return file.replace(/\.tsx?$/i, '').replace(/(\/index)+$/i, '').replace(/\/+$/g, '')
-}
+import { cacheRoutes } from '../routes'
 
 cacheRoutes()
   .then(() => {

package/src/types.ts

@@ -1,8 +1,29 @@
-import { Handler } from 'hono'
+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 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'
+
+type PublicMethods<T> = {
+  [K in keyof T]: K extends `#${string}` | `$${string}` | symbol | 'prototype' ? never : K
+}[keyof T]
+
+export type IRequest = Pick<request, PublicMethods<request>>
+export type IResponse = Pick<typeof response, PublicMethods<typeof response>>
+
+export type IValidator = Pick<typeof validator, PublicMethods<typeof validator>>
+export type Rule = {
+  schema: z.ZodObject<any>
+  target: keyof ValidationTargets
+  eTarget?: 'fieldErrors' | 'formErrors'
+}
+export type Rules = Rule[] | Rule | null
 
 export type Route = {
   method: string,
@@ -13,6 +34,8 @@ export type Route = {
   handle: Handlers,
 }
 
+export type ActionType = Function | Handler | Action | (new () => Action)
+
 export type Handlers = (Function | Handler | (new () => Action))[]
 
 export type Routes = Route[]
@@ -45,6 +68,3 @@ export type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T>
 //   | null
 //   | { [key: string]: JSONValue }
 //   | JSONValue[]
-
-
-export type { Context, Next } from 'hono'

package/src/utils/environment.ts

@@ -10,15 +10,16 @@ export function detectEnvironment() {
   try {
     if (
       process.env?.npm_lifecycle_event == 'dev'
+      || process.env?.npm_lifecycle_script == 'rajt'
       || process.env?.AWS_SAM_LOCAL
       // || process?.argv?.includes('--dev')
-      || process?.argv?.some(arg => ['--dev', '--development', '--watch'].includes(arg))
+      || process?.argv?.some(arg => ['-port', '-platform', '--dev', '--development', '--watch'].includes(arg))
       || process?.execArgv?.includes('--watch')
       || import.meta.url?.includes('localhost')
     ) {
       return dev
     }
-  } catch (e) { }
+  } catch (e) {}
 
   return prd
 }

package/src/utils/func.ts

@@ -1,8 +1,8 @@
 export const isAsyncFn = (fn: any) => {
-  return fn?.constructor?.name === 'AsyncFunction'
+  return fn?.constructor?.name == 'AsyncFunction'
     || fn.toString().toLowerCase().trim().startsWith('async')
 }
 
 export const isAnonFn = (fn: any) => {
-    return fn?.name === '' || fn?.name === 'anonymous'
+    return fn?.name == '' || fn?.name == 'anonymous'
 }

package/src/utils/local-date.ts

@@ -0,0 +1,13 @@
+const getFullYear = Date.prototype.getFullYear
+const getMonth = Date.prototype.getMonth
+const getDate = Date.prototype.getDate
+const getHours = Date.prototype.getHours
+const getMinutes = Date.prototype.getMinutes
+const getSeconds = Date.prototype.getSeconds
+const pad = (n: number) => n > 9 ? n : '0' + n
+
+export const getLocalDateTime = (date = new Date()) =>
+  getFullYear.call(date) + '-' + pad(getMonth.call(date) + 1) + '-' + pad(getDate.call(date))
+   + ' ' + pad(getHours.call(date)) + ':' + pad(getMinutes.call(date)) + ':' + pad(getSeconds.call(date))
+
+export default getLocalDateTime

package/src/utils/logger.ts

@@ -0,0 +1,61 @@
+import colors from 'picocolors'
+
+const _console = { ...console }
+
+export interface ILogger {
+  write(...data: Array<string | ArrayBufferView | ArrayBuffer>): number;
+  error(...data: any[]): void;
+  info(...data: any[]): void;
+  log(...data: any[]): void;
+  // TODO: table(tabularData?: any, properties?: string[]): void;
+  trace(...data: any[]): void;
+  warn(...data: any[]): void;
+  // custom
+  step(...data: any[]): void;
+  substep(...data: any[]): void;
+  ln(): void;
+}
+
+export const logger = {
+	step(...args: any[]) {
+		if (args?.length && args.length < 2) return _console.log(colors.blue('⁕') +` ${args[0]}\n`)
+		const length = args.length - 1
+		args.forEach((arg, index) => {
+				switch (index) {
+					case 0:
+						return _console.log(colors.blue('⁕') + ' ' + arg)
+						// return _console.log(colors.blue('⁕') +` ${arg} \n`)
+					case length:
+						return _console.log(`   ${colors.gray('⁕')} ${arg}\n`)
+					default:
+						return _console.log(`   ${colors.gray('⁕')} ` + arg)
+				}
+    })
+	},
+	substep(...args: any[]) {
+		args.forEach(arg => _console.log(`   ${colors.gray('⁕')} ` + arg))
+	},
+	ln() {
+		_console.log('\n')
+	},
+  log(...args: any[]) {
+    _console.log(...args)
+  },
+  info(...args: any[]) {
+    _console.info(...args)
+  },
+  warn(...args: any[]) {
+    _console.warn(...args)
+  },
+  error(...args: any[]) {
+    _console.error(...args)
+  },
+  trace(...args: any[]) {
+    _console.trace(...args)
+  },
+  write(...args: any[]) {
+    _console.write(...args)
+  },
+}
+
+export default logger

package/src/utils/port.ts

@@ -18,9 +18,7 @@ export async function getAvailablePort(startPort: number, maxAttempts = 100) {
   while (attempts < maxAttempts) {
     const inUse = await isPortInUse(port)
 
-    if (!inUse) {
-      return port
-    }
+    if (!inUse) return port
 
     port++
     attempts++

package/src/utils/resolve.ts

@@ -1,8 +1,9 @@
-import Action, { ActionType } from '../action'
+import Action from '../action'
 import { MiddlewareType } from '../middleware'
+import type { ActionType } from '../types'
 
 export function resolve(obj: ActionType, id: string) {
-  if (typeof obj === 'function' && obj?.length === 2)
+  if (typeof obj == 'function' && obj?.length == 2)
     return [obj]
 
   if (obj?.run)
@@ -22,7 +23,7 @@ export function resolve(obj: ActionType, id: string) {
 }
 
 export function resolveMiddleware(obj: MiddlewareType) {
-  if (typeof obj === 'function' && obj.length === 2)
+  if (typeof obj == 'function' && obj.length == 2)
     return obj
 
   if (obj?.factory)

package/src/utils/shutdown.ts

@@ -0,0 +1,19 @@
+export default function shutdown(cb: (signal: string, e: unknown) => void | Promise<void>) {
+  if (!process) return
+  const down = (signal: string) => (e?: unknown) => {
+    try {
+      cb(signal, e)
+      setTimeout(() => process.exit(0), 100)
+    } catch (e) {
+      process.exit(1)
+    }
+  }
+
+  process.on('SIGINT', down('SIGINT'))
+  process.on('SIGTERM', down('SIGTERM'))
+  process.on('SIGHUP', down('SIGHUP'))
+  process.on('unhandledRejection', down('UNCAUGHT_REJECTION'))
+  process.on('uncaughtException', down('UNCAUGHT_EXCEPTION'))
+  // process.on('beforeExit', down('BEFORE_EXIT'))
+  // process.on('exit', down('EXIT'))
+}

package/src/validator.ts

@@ -0,0 +1,68 @@
+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'
+
+export default class $Validator {
+  private static cache = new Map<string, any>()
+
+  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
+    }
+
+    return {
+      schema: (schema: ZodObject<any>) => ({
+        target,
+        schema,
+        eTarget: 'fieldErrors'
+      })
+    }
+  }
+
+  private static getOrCreateAlias<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
+  }
+
+  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 parse(rules: Rules): Function[] {
+    return (Array.isArray(rules) ? rules : [rules]) // @ts-ignore
+      .flatMap(rule => zValidator(rule.target, rule.schema, (result, c) => {
+        if (!result.success) // @ts-ignore
+          return response.badRequest({ ...result.error.flatten()[rule.eTarget] })
+      }))
+  }
+}

package/src/auth/auth.ts

@@ -1,33 +0,0 @@
-import { Authnz } from './authnz'
-import { Token } from './token'
-
-export class Auth {
-  static #u: Authnz<any> | null = null
-
-  static resolve() {
-    this.#u = Authnz.fromToken(Token.fromRequest())
-  }
-
-  static get user() {
-    return this.#u ? this.#u?.data : null
-  }
-
-  static can(...abilities: string[]): boolean {
-    return this.#u ? this.#u.can(...abilities) : false
-  }
-
-  static cant(...abilities: string[]): boolean {
-    return !this.can(...abilities)
-  }
-
-  static hasRole(...roles: string[]): boolean {
-    return this.#u ? this.#u.hasRole(...roles) : false
-  }
-
-  static has(prop: string, value: any = null): boolean {
-    return this.#u ? this.#u.has(prop, value) : false
-  }
-  static hasValue(prop: string, value: any = null): boolean {
-    return this.has(prop, value)
-  }
-}