rajt 0.0.57 → 0.0.58

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

@@ -0,0 +1,206 @@
+import esbuild from 'esbuild'
+import TOML from '@iarna/toml'
+import { Miniflare } from 'miniflare'
+import { fileURLToPath } from 'node:url'
+import { mkdirSync, existsSync, readdirSync, rmSync, copyFileSync } from 'node:fs'
+import { readFile, stat, writeFile } from 'node:fs/promises'
+import { basename, dirname, join, relative } from 'node:path'
+
+const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../../../../')
+const __rajt = join(__dirname, 'node_modules/rajt/src')
+
+export const formatSize = (bytes: number) => {
+  if (bytes < 1024) return `${bytes}b`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)}kb`
+  return `${(bytes / (1024 * 1024)).toFixed(2)}mb`
+}
+
+export const formatTime = (ms: number) => {
+  if (ms < 1000) return `${ms}ms`
+  return `${(ms / 1000).toFixed(2)}s`
+}
+
+export const build = async (platform: 'aws' | 'cf' | 'node') => {
+  const startTime = Date.now()
+
+  const isCF = platform == 'cf'
+  const distDir = join(__dirname, 'dist')
+
+  existsSync(distDir)
+    ? readdirSync(distDir).forEach(file => rmSync(join(distDir, file), { recursive: true, force: true }))
+    : mkdirSync(distDir, { recursive: true })
+
+  if (isCF) {
+    for (let file of [
+      'wrangler.toml',
+    ]) {
+      file = join(__dirname, file)
+      if (existsSync(file))
+        copyFileSync(file, join(__dirname, 'dist', basename(file)))
+    }
+  }
+
+  const opts = {
+    entryPoints: [join(__rajt, `prod-${platform}.ts`)],
+    bundle: true,
+    minify: false,
+    outfile: join(__dirname, 'dist/index.js'),
+    format: 'esm',
+    target: isCF ? 'es2022' : 'node20',
+    // platform: 'neutral',
+    platform: isCF ? 'browser' : 'node',
+    conditions: isCF ? ['worker', 'browser'] : [],
+    treeShaking: true,
+    legalComments: 'none',
+    external: [
+      '@aws-sdk', '@smithy',
+      ...(isCF ? [
+        'cloudflare:workers',
+        'node:crypto', 'crypto',
+        'node:buffer', 'buffer',
+      ] : []),
+    ],
+    metafile: true,
+    write: false,
+    // define: {
+    //   'process.env.NODE_ENV': '"development"'
+    // },
+    // loader: {
+    //   '.ts': 'ts',
+    //   '.js': 'js'
+    // },
+    // tsconfig: join(__dirname, 'tsconfig.json'),
+    // sourcemap: true,
+    // logLevel: 'info',
+    plugins: [
+      {
+        name: 'preserve-class-names',
+        setup(build) {
+          build.onLoad(
+            { filter: /(actions|features)\/.*\.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 result = await esbuild.build(opts)
+  if (!result?.metafile) throw Error('build fail')
+
+  logger.step('Build completed successfully')
+
+  const stats = await stat(opts.outfile)
+  const size = formatSize(stats.size)
+
+  logger.step(
+    `Build done in ${formatTime(Date.now() - startTime)}`,
+    `${relative(join(__dirname, 'node_modules/rajt/src'), opts.entryPoints[0])} → ${relative(__dirname, opts.outfile)}`,
+    `Size: ${size}`,
+    `Files: ${Object.keys(result.metafile.outputs).length}`
+  )
+}
+
+async function parseWranglerConfig(file: string) {
+  try {
+    return TOML.parse(await readFile(join(__dirname, file), 'utf-8'))
+  } catch (e) {
+    logger.warn(`Could not parse ${file}, using defaults`)
+    return {}
+  }
+}
+
+export async function createMiniflare(options = {}, configPath = 'wrangler.toml') {
+  const config = await parseWranglerConfig(configPath)
+
+  return new Miniflare({
+    host: options.host || 'localhost',
+    port: options.port || 8787,
+    https: options.https || false,
+    httpsKey: options.httpsKey,
+    httpsCert: options.httpsCert,
+    liveReload: options.liveReload !== false,
+    updateCheck: false,
+
+    scriptPath: join(__dirname, 'dist/index.js'),
+    compatibilityDate: config.compatibility_date || '2024-11-01',
+    compatibilityFlags: config.compatibility_flags || [
+      'nodejs_compat',
+    ],
+
+    bindings: {
+      // MY_VARIABLE: 'value',
+      // ENVIRONMENT: 'development',
+      ...config.vars,
+    },
+
+    d1Databases: Object.fromEntries(config.d1_databases.map(db => [db.binding, db.database_id])),
+
+    modules: true,
+    modulesRules: [
+      { type: 'ESModule', include: ['**/*.js', '**/*.ts'] },
+    ],
+
+    kvPersist: join(__dirname, '.wrangler/state/v3/kv'),
+    cachePersist: join(__dirname, '.wrangler/state/v3/cache'),
+    d1Persist: join(__dirname, '.wrangler/state/v3/d1'),
+    r2Persist: join(__dirname, '.wrangler/state/v3/r2'),
+    durablesPersist: join(__dirname, '.wrangler/state/v3/durable_objects'),
+
+    verbose: false,
+
+    // Logging
+    // log: new console.Console({
+    //   stdout: process.stdout,
+    //   stderr: process.stderr,
+    //   inspectOptions: { depth: 3 }
+    // }),
+
+    cfFetch: false, // disable cf requests
+    upstream: config.upstream || 'https://example.com',
+
+    sitePath: config.site?.bucket ?
+      join(__dirname, config.site.bucket) : undefined,
+    siteInclude: config.site?.include || ['**/*'],
+    siteExclude: config.site?.exclude || [],
+
+    globalAsyncIO: true,
+    globalTimers: true,
+    globalRandom: true,
+
+    inspectorPort: options.inspectorPort || 9229,
+
+    cache: true,
+    cacheWarnUsage: true,
+
+    ...options
+  })
+}

package/src/cli/index.ts

@@ -0,0 +1,69 @@
+import { defineCommand, runMain, renderUsage } from 'citty'
+import type { ArgsDef, CommandDef } from 'citty'
+import colors from 'picocolors'
+import { createConsola } from 'consola'
+
+import { version as rajtVersion } from '../../package.json'
+
+import logger, { type ILogger } from '../utils/logger'
+
+import dev from './commands/dev'
+
+// Prevent non-internal logs
+(globalThis as any).logger = logger // Make it global in Node.js and browser
+declare global { var logger: ILogger }
+
+// console.log = () => {}
+console.info = () => {}
+console.warn = () => {}
+console.error = () => {}
+
+/**
+ * The main entrypoint for the CLI.
+ * main only gets called when the script is run directly, not when it's imported as a module.
+ */
+const directly = () => {
+  try {
+    // @ts-ignore
+		return typeof vitest == 'undefined'
+			&& (
+				![typeof require, typeof module].includes('undefined') && require.main == module
+				|| import.meta.url == `file://${process.argv[1]}`
+			)
+	} catch {
+		return false
+	}
+}
+
+const name = 'Rajt CLI'
+const version = [name, colors.isColorSupported ? colors.gray('v'+rajtVersion) : rajtVersion].join(' ')
+
+if (directly()) {
+  const _args = process.argv.slice(2)
+  if (_args.length == 1 && ['-v', '--version', '--v', '-version'].includes(_args[0])) {
+    console.log(version)
+    process.exit(0)
+  }
+
+  const consola = createConsola({ formatOptions: {date: false} })
+  async function showUsage<T extends ArgsDef = ArgsDef>(cmd: CommandDef<T>, parent?: CommandDef<T>) {
+    try {
+      consola.log((await renderUsage(cmd, parent)).split('\n').slice(1).join('\n') + '\n')
+    } catch (error) {
+      consola.error(error)
+    }
+  }
+
+  const main = defineCommand({
+    meta: {
+      name: 'rajt',
+      version: rajtVersion,
+      description: name,
+    },
+    subCommands: {
+      dev,
+    },
+  })
+
+  runMain(main, { rawArgs: _args?.length ? undefined : ['-h'], showUsage })
+}

package/src/cli/types.ts

@@ -0,0 +1 @@
+export type ChokidarEventName = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir'

package/src/create-app.ts

@@ -1,15 +1,18 @@
 /* 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 colors from 'picocolors'
 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 response from './response'
 import cx from './context'
@@ -31,11 +34,11 @@ const EHandler = async (e: Error | HTTPResponseError) => {
 
   switch (true) {
     case e instanceof Unauthorized:
-    case 'status' in e && e.status === 401:
+    case 'status' in e && e.status == 401:
       return response.unauthorized()
 
     case e instanceof BadRequest:
-    case 'status' in e && e.status === 400:
+    case 'status' in e && e.status == 400:
       // @ts-ignore
       return response.badRequest(undefined, e?.message)
 
@@ -78,6 +81,9 @@ export const createApp = <E extends Env>(options?: ServerOptions<E>) => {
   // const root = options?.root ?? '/'
   const app = options?.app ?? new Hono<E>()
 
+  if (isDev())
+    app.use('*', logger((...args: any[]) => console.log(colors.gray(localDate()), ...args)))
+
   app.use(async (c: Context, next: Next) => {
     cx.setContext(c)
     Auth.resolve()

package/src/dev.ts

@@ -1,16 +1,20 @@
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
 import { config } from 'dotenv'
-import { serve } from '@hono/node-server'
+import { serve, type ServerType } from '@hono/node-server'
 import createApp from './create-app'
 import { getRoutes, getMiddlewares } from './routes'
 import { registerHandler, registerMiddleware } from './register'
 import { Ability } from './auth'
-import { getAvailablePort } from './utils/port'
 import jsonImport from './utils/json-import'
 import { setEnv, detectEnvironment } from './utils/environment'
+import shutdown from './utils/shutdown'
 
 setEnv(detectEnvironment())
 
-config({ path: '../../.env.dev' })
+const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../')
+
+config({ path: join(__dirname, '.env.dev') })
 
 let routes = await getRoutes()
 routes.forEach(r => registerHandler(r.name, r.handle))
@@ -20,18 +24,17 @@ const middlewares = await getMiddlewares()
 middlewares.forEach(mw => registerMiddleware(mw.handle))
 
 Ability.fromRoutes(routes)
-Ability.roles = jsonImport('../../../../roles.json')
+Ability.roles = jsonImport(join(__dirname, 'roles.json'))
 
 const fetch = createApp({ routes }).fetch
 
-const desiredPort = process.env?.PORT ? Number(process.env.PORT) : 3000
-getAvailablePort(desiredPort)
-  .then(port => {
-    if (port != desiredPort)
-      console.warn(`🟠 Port ${desiredPort} was in use, using ${port} as a fallback`)
-
-    console.log(`🚀 API running on http://localhost:${port}`)
-    serve({ fetch, port })
-  }).catch(err => {
-    console.error('Error finding available port:', err)
-  })
+const port = process.env?.PORT ? Number(process.env.PORT) : 3000
+
+let server: ServerType | null = serve({ fetch, port })
+
+shutdown(() => {
+  if (server) {
+    server?.close()
+    server = null
+  }
+})

package/src/dynamodb/compact.ts

@@ -1,6 +1,6 @@
-import type { SchemaStructure } from './types'
-import getLength from '../utils/lenght'
+import { getLength } from 't0n'
 import { isArraySchema } from './schema'
+import type { SchemaStructure } from './types'
 
 export default class Compact {
   static #typeRegex: RegExp
@@ -89,7 +89,7 @@ export default class Compact {
     if (this.#cantZip(obj)) return obj
 
     return schema.map(key => {
-      if (typeof key === 'string')
+      if (typeof key == 'string')
         return this.memo(obj[key], seen)
 
       const mainKey = Object.keys(key)[0]

package/src/dynamodb/decorators.ts

@@ -1,4 +1,4 @@
-import plur from 'plur'
+import pluralize from 'pluralize'
 import type { ModelMetadata, ModelOpts } from './types'
 
 export function getModelMetadata(target: Function | any): ModelMetadata {
@@ -9,7 +9,7 @@ export function getModelMetadata(target: Function | any): ModelMetadata {
   return {
     table: target.m[0],
     // @ts-ignore
-    keys: typeKeys !== 'undefined' ? (typeKeys === 'string' ? { PK: target.m[1] } : { PK: target.m[1][0], SK: target.m[1][1] }) : undefined,
+    keys: typeKeys != 'undefined' ? (typeKeys == 'string' ? { PK: target.m[1] } : { PK: target.m[1][0], SK: target.m[1][1] }) : undefined,
     defaultSK: target?.defaultSK || undefined,
     zip: target.m[2] || false,
     fields: target.m[3] || [],
@@ -18,9 +18,9 @@ export function getModelMetadata(target: Function | any): ModelMetadata {
 
 function _table(target: Function | any, opt?: ModelOpts) {
   if (!target?.m) target.m = []
-  const table = opt ? (typeof opt === 'string' ? opt : opt?.table) : undefined
+  const table = opt ? (typeof opt == 'string' ? opt : opt?.table) : undefined
 
-  target.m[0] = table || plur(target.name.toLocaleUpperCase())
+  target.m[0] = table || pluralize(target.name.toLocaleUpperCase())
 }
 
 function _zip(target: Function | any) {
@@ -38,7 +38,7 @@ export function _model(target: any, opt?: ModelOpts) {
   _table(target, opt)
   const notStr = typeof opt !== 'string'
 
-  if (!opt || !notStr || (typeof opt?.zip === undefined || opt?.zip))
+  if (!opt || !notStr || (opt?.zip === undefined || opt?.zip))
     _zip(target)
 
   const pk = opt && notStr ? opt?.partitionKey : undefined
@@ -68,7 +68,7 @@ function _sk(target: any, prop: string) {
 export function Entity(target: Function): void
 export function Entity(opt?: ModelOpts): ClassDecorator
 export function Entity(...args: any[]): void | ClassDecorator {
-  if (args.length === 1 && typeof args[0] === 'function')
+  if (args.length == 1 && typeof args[0] == 'function')
     return _table(args[0])
 
   return (target: any) => _table(target, ...args)
@@ -77,7 +77,7 @@ export function Entity(...args: any[]): void | ClassDecorator {
 export function Model(target: Function): void
 export function Model(opt?: ModelOpts): ClassDecorator
 export function Model(...args: any[]): void | ClassDecorator {
-  if (args.length === 1 && typeof args[0] === 'function')
+  if (args.length == 1 && typeof args[0] == 'function')
     return _model(args[0])
 
   return (target: any) => _model(target, ...args)
@@ -86,7 +86,7 @@ export function Model(...args: any[]): void | ClassDecorator {
 export function Zip(target: Function): void
 export function Zip(): ClassDecorator
 export function Zip(...args: any[]): void | ClassDecorator {
-  if (args.length === 1 && typeof args[0] === 'function')
+  if (args.length == 1 && typeof args[0] == 'function')
     return _zip(args[0])
 
   return (target: any) => _zip(target)
@@ -105,10 +105,10 @@ export function PartitionKey(target: any, propertyKey: string | undefined, param
 export function PartitionKey(...args: any[]): void | PropertyDecorator {
   if (!args.length) return
 
-  if (typeof args[0] === 'function' && typeof args[1] === 'string' && args[1])
+  if (typeof args[0] == 'function' && typeof args[1] == 'string' && args[1])
     return _pk(args[0], args[1])
 
-  if (args.length === 1 && args[0])
+  if (args.length == 1 && args[0])
     return (target: any) => _pk(target, args[0])
 }
 
@@ -118,9 +118,9 @@ export function SortKey(target: any, propertyKey: string | undefined, parameterI
 export function SortKey(...args: any[]): void | PropertyDecorator {
   if (!args.length) return
 
-  if (typeof args[0] === 'function' && typeof args[1] === 'string' && args[1])
+  if (typeof args[0] == 'function' && typeof args[1] == 'string' && args[1])
     return _sk(args[0], args[1])
 
-  if (args.length === 1 && args[0])
+  if (args.length == 1 && args[0])
     return (target: any) => _sk(target, args[0])
 }

package/src/dynamodb/model.ts

@@ -4,7 +4,7 @@ import QueryBuilder from './query-builder'
 import Compact from './compact'
 import { RawClient } from './client'
 import { isArraySchema } from './schema'
-import getLength from '../utils/lenght'
+import { getLength } from 't0n'
 
 export default class AbstractModel<T extends object> {
   #meta: ModelMetadata
@@ -21,7 +21,7 @@ export default class AbstractModel<T extends object> {
     this.#queryBuilder = queryBuilder
     this.#model = model
 
-    if (typeof (cls as ModelMetadata).table === 'string') {
+    if (typeof (cls as ModelMetadata).table == 'string') {
       this.#meta = cls as ModelMetadata
       this.cls = model?.cls
       return

package/src/dynamodb/repository.ts

@@ -12,7 +12,7 @@ export function Repository<
   base?: B | ModelOpts,
   opts?: ModelOpts
 ) {
-  const isClass = typeof base === 'function'
+  const isClass = typeof base == 'function'
   type M = z.infer<S>
 
   const Repo = Schema(schema, isClass ? base : undefined)

package/src/esbuild.mjs

@@ -34,7 +34,7 @@ const buildOptions = {
   bundle: true,
   minify: true,
   outfile: join(__dirname, '../../../dist/index.js'),
-  platform: isCF ? 'browser' : 'node20',
+  platform: isCF ? 'browser' : 'node',
   target: isCF ? 'es2022' : 'node20',
   conditions: isCF ? ['worker', 'browser'] : [],
   format: 'esm',
@@ -44,8 +44,8 @@ const buildOptions = {
     '@aws-sdk', '@smithy',
     ...(isCF ? [
       'cloudflare:workers',
-      'node:crypto',
-      'crypto',
+      'node:crypto', 'crypto',
+      'node:buffer', 'buffer',
     ] : []),
   ],
   metafile: true,
@@ -102,12 +102,14 @@ existsSync(distDir)
 for (const file of await readdirSync(distDir))
   await rmSync(join(distDir, file))
 
-for (let file of [
-  'wrangler.toml',
-]) {
-  file = join(cwd, file)
-  if (existsSync(file))
-    copyFileSync(file, join(cwd, 'dist', basename(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)

package/src/http.ts

@@ -5,10 +5,10 @@ import { Ability, Auth as Gate } from './auth'
 import mergeMiddleware from './utils/merge-middleware'
 
 function method(method: string, ...args: any[]): void | ClassDecorator {
-  if (args.length === 1 && typeof args[0] === 'function')
+  if (args.length == 1 && typeof args[0] == 'function')
     return _method(method, '/', args[0])
 
-  const path = typeof args[0] === 'string' ? args[0] : '/'
+  const path = typeof args[0] == 'string' ? args[0] : '/'
   return (target: Function) => _method(method, path, target)
 }
 
@@ -93,7 +93,7 @@ export function Middlewares(...handlers: MiddlewareType[]) {
 export function Auth(target: Function): void
 export function Auth(): ClassDecorator
 export function Auth(...args: any[]): void | ClassDecorator {
-  if (args.length === 1 && typeof args[0] === 'function')
+  if (args.length == 1 && typeof args[0] == 'function')
     return _auth(args[0])
 
   return (target: any) => _auth(target)

package/src/index.ts

@@ -3,4 +3,4 @@ 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 { default as Enum } from './enum'
+export { Enum } from 't0n'

package/src/prod-aws.ts

@@ -1,19 +1,4 @@
 import { handle } from 'hono/aws-lambda'
-import createApp from './create-app'
-import { Ability } from './auth'
+import { app } from './prod'
 
-// @ts-ignore
-await import('../../../tmp/import-routes.mjs')
-
-// @ts-ignore
-const routes = (await import('../../../tmp/routes.json')).default
-
-// @ts-ignore
-Ability.roles = (await import('../../../roles.json')).default
-// @ts-ignore
-Ability.fromRoutes(routes)
-
-// @ts-ignore
-const app = createApp({ routes })
-
-export const handler = handle(app) // AWS Lambda (LLRT)
+export const handler = handle(app)

package/src/prod-cf.ts

@@ -1,18 +1 @@
-import createApp from './create-app'
-import { Ability } from './auth'
-
-// @ts-ignore
-await import('../../../tmp/import-routes.mjs')
-
-// @ts-ignore
-const routes = (await import('../../../tmp/routes.json')).default
-
-// @ts-ignore
-Ability.roles = (await import('../../../roles.json')).default
-// @ts-ignore
-Ability.fromRoutes(routes)
-
-// @ts-ignore
-const app = createApp({ routes })
-
-export default app
+export { app as default } from './prod'

package/src/prod.ts

@@ -0,0 +1,16 @@
+import createApp from './create-app'
+import { Ability } from './auth'
+
+// @ts-ignore
+await import('../../../tmp/import-routes.mjs')
+
+// @ts-ignore
+const routes = (await import('../../../tmp/routes.json')).default
+
+// @ts-ignore
+Ability.roles = (await import('../../../roles.json')).default
+// @ts-ignore
+Ability.fromRoutes(routes)
+
+// @ts-ignore
+export const app = createApp({ routes })

package/src/scripts/cache-routes.ts

@@ -34,7 +34,7 @@ try {
   const handlers = {${routes.map(r => r.name).join()}}
 
   for (const [name, handler] of Object.entries(handlers)) {
-    if (typeof handler === 'function' || handler.prototype?.handle) {
+    if (typeof handler == 'function' || handler.prototype?.handle) {
       registerHandler(name, handler)
     }
   }

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
 }