rajt 0.0.57 → 0.0.59

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

@@ -0,0 +1,294 @@
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join, relative } from 'node:path'
+import { spawn, type ChildProcess } from 'node:child_process'
+
+import chokidar from 'chokidar'
+import colors from 'picocolors'
+import { defineCommand } from 'citty'
+import type { ChokidarEventName } from '../../types'
+
+import type { Miniflare } from 'miniflare'
+import { build, createMiniflare } from './utils'
+import { getAvailablePort } from '../../../utils/port'
+import shutdown from '../../../utils/shutdown'
+
+const __dirname = join(dirname(fileURLToPath(import.meta.url)), '../../../../../../')
+
+export default defineCommand({
+	meta: {
+		name: 'dev',
+		description: '💻 Start the localhost server\n',
+	},
+	args: {
+		port: {
+			description: 'Port to listen on',
+			type: 'number',
+			default: 3000,
+		},
+		host: {
+			description: 'Host to forward requests to, defaults to the zone of project',
+			type: 'string',
+			default: 'localhost',
+		},
+		platform: {
+			alias: 'p',
+			description: 'Environment platform',
+			type: 'enum',
+			options: ['aws', 'cf', 'node'] as const,
+			required: true,
+		},
+	},
+	async run({ args }) {
+		const platform = args.p || args.platform
+		const desiredPort = args.port ? Number(args.port) : 3000
+		const host = args.host ? String(args.host) : 'localhost'
+		switch (platform) {
+			case 'aws':
+				return withPort(desiredPort, async (port) => {
+					let isBuilding = false
+					let lambda: ChildProcess | null = null
+
+					const buildLambda = async () => {
+						if (isBuilding) return
+						isBuilding = true
+						logger.step('Building lambda')
+						try {
+							await build(platform)
+							if (!lambda) await startLambda()
+						} catch (e) {
+							logger.error('Build failed:', e)
+							process.exit(0)
+						} finally {
+							isBuilding = false
+						}
+					}
+
+					const stopLambda = async () => {
+						if (!lambda) return
+						logger.step('Stopping lambda process...')
+						try {
+							if (!lambda?.killed) {
+								lambda.kill('SIGTERM')
+								await wait(1000)
+
+								if (!lambda?.killed) { // force kill
+									lambda.kill('SIGKILL')
+									await wait(1000)
+								}
+							}
+
+							lambda = null
+						} catch (e) {
+							logger.warn('Error stopping lambda:', e)
+						}
+					}
+
+					const startLambda = async () => {
+						await stopLambda()
+
+						lambda = spawn(
+							'sam',
+							[
+								'local', 'start-api',
+								'--warm-containers', 'LAZY',
+								'--debug', '--template-file', join(__dirname, 'template-dev.yaml'),
+								'--port', args.port,
+							],
+							{
+								stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+								// stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+								shell: process.platform == 'win32',
+								env: {...process.env, DOCKER_HOST: getDockerHost()},
+							}
+						).on('exit', code => {
+							logger.step(`Lambda process exited with code ${code ?? 0}`)
+							if (code != 0 && code != null)
+								logger.error('Lambda process crashed, waiting for restart...')
+
+							lambda = null
+						})
+						.on('message', msg => {
+							if (process.send) process.send(msg)
+						}).on('disconnect', () => {
+							if (process.disconnect) process.disconnect()
+						}).on('error', e => {
+							logger.error('Lambda process error:', e)
+							lambda = null
+						})
+
+						await wait(2000)
+
+						logger.step('Lambda process started successfully')
+					}
+
+					await buildLambda()
+					logger.step(`API running on http://${host}:${port}`)
+
+					watch(async () => {
+						await buildLambda()
+					})
+
+					shutdown(async () => {
+						await stopLambda()
+					})
+				})
+			case 'cf':
+				return withPort(desiredPort, async (port) => {
+					let isBuilding = false
+
+					const buildWorker = async () => {
+						if (isBuilding) return
+						isBuilding = true
+						logger.step('Building worker')
+						try {
+							await build(platform)
+							await startWorker()
+						} catch (e) {
+							logger.error('Build failed:', e)
+							process.exit(0)
+						} finally {
+							isBuilding = false
+						}
+					}
+
+					let worker: Miniflare | null = null
+					const startWorker = async () => {
+						if (worker) await worker.dispose()
+
+						worker = await createMiniflare({ port, host, liveReload: false })
+					}
+
+					await buildWorker()
+					logger.step(`API running on http://${host}:${port}`)
+
+					watch(async () => {
+						logger.step('Restarting server')
+						await buildWorker()
+						logger.step('Server restarted')
+					})
+				})
+			case 'node':
+				return withPort(desiredPort, async (port) => {
+					logger.step(`API running on http://${host}:${port}`)
+
+					spawn(
+						process.execPath,
+						[
+							join(__dirname, 'node_modules/.bin/tsx'), 'watch', join(__dirname, 'node_modules/rajt/src/dev.ts'),
+						],
+						{
+							stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+							env: {...process.env, PORT: args.port},
+						}
+					).on('exit', code => process.exit(code ?? 0))
+					.on('message', msg => {
+						if (process.send) process.send(msg)
+					}).on('disconnect', () => {
+						if (process.disconnect) process.disconnect()
+					})
+				})
+			default:
+				return logger.warn(
+					`🟠 Provide a valid platform: ${['aws', 'cf', 'node'].map(p => colors.blue(p)).join(', ')}.\n`
+				)
+    }
+	},
+})
+
+function withPort(desiredPort: number, cb: (port: number) => void) {
+	getAvailablePort(desiredPort)
+		.then((port: number) => {
+			if (port != desiredPort)
+				logger.warn(`Port ${desiredPort} was in use, using ${port} as a fallback`)
+
+			cb(port)
+		}).catch(e => logger.error('Error finding available port:', e))
+}
+
+function getAssetChangeMessage(
+	e: ChokidarEventName,
+	path: string
+): string {
+	path = relative(__dirname, path)
+	switch (e) {
+		case 'add':
+			return `File ${path} was added`
+		case 'addDir':
+			return `Directory ${path} was added`
+		case 'unlink':
+			return `File ${path} was removed`
+		case 'unlinkDir':
+			return `Directory ${path} was removed`
+		case 'change':
+		default:
+			return `${path} changed`
+	}
+}
+
+async function watch(cb: (e: ChokidarEventName | string, file: string) => Promise<void>) {
+	const codeWatcher = chokidar.watch([
+		join(__dirname, 'actions/**/*.ts'),
+		join(__dirname, 'configs/**/*.ts'),
+		join(__dirname, 'enums/**/*.ts'),
+		join(__dirname, 'locales/**/*.ts'),
+		join(__dirname, 'middlewares/**/*.ts'),
+		join(__dirname, 'models/**/*.ts'),
+		join(__dirname, 'utils/**/*.ts'),
+		join(__dirname, '.env.dev'),
+		join(__dirname, '.env.prod'),
+		join(__dirname, 'package.json'),
+		join(__dirname, 'wrangler.toml'),
+	], {
+		ignored: /(^|[/\\])\../, // ignore hidden files
+		persistent: true,
+		ignoreInitial: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 200,
+			pollInterval: 100,
+		},
+	})
+	let restartTimeout: NodeJS.Timeout | null = null
+
+	const watcher = (e: ChokidarEventName) => async (file: string) => {
+		logger.step(getAssetChangeMessage(e, file))
+
+		if (restartTimeout)
+			clearTimeout(restartTimeout)
+
+		restartTimeout = setTimeout(async () => {
+			await cb(e, file)
+		}, 300)
+	}
+
+	codeWatcher.on('change', watcher('change'))
+	codeWatcher.on('add', watcher('add'))
+	codeWatcher.on('unlink', watcher('unlink'))
+	codeWatcher.on('addDir', watcher('addDir'))
+	codeWatcher.on('unlinkDir', watcher('unlinkDir'))
+
+	logger.step('Watching for file changes')
+}
+
+async function wait(ms: number) {
+	return new Promise(r => setTimeout(r, ms))
+}
+
+function getDockerHost() {
+	const platform = process.platform
+
+	if (platform == 'darwin') {
+		for (const socket of [
+			'/Users/'+ process.env.USER +'/.docker/run/docker.sock',
+			'/var/run/docker.sock',
+			process.env.DOCKER_HOST
+		]) {
+			if (socket && existsSync(socket.replace(/^unix:\/\//, '')))
+				return socket.includes('://') ? socket : `unix://${socket}`
+		}
+
+		return 'tcp://localhost:2375'
+	}
+
+	return process.env.DOCKER_HOST || (platform == 'win32' ? 'tcp://localhost:2375' : 'unix:///var/run/docker.sock')
+}

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

@@ -0,0 +1,215 @@
+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'
+
+import { cacheRoutes } from '../../../routes'
+
+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, '')
+              )
+            }))
+          })
+        }
+      },
+    ],
+  }
+
+  await cacheRoutes()
+
+  logger.step('Routes cached')
+
+  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: [
+      { 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'),
+    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,18 +1,21 @@
 /* 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 { 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 { Auth } from './auth'
+import localDate from './utils/local-date'
+import request from './request'
 import response from './response'
-import cx from './context'
 
 type InitFunction<E extends Env = Env> = (app: Hono<E>) => void
 
@@ -31,13 +34,13 @@ 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)
+      return response.badRequest(null, e?.message)
 
     default:
       return response.internalError(
@@ -78,13 +81,16 @@ 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()
+    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)
   })
@@ -111,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'