rajt 0.0.74 → 0.0.75

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.74",
+  "version": "0.0.75",
   "type": "module",
   "main": "./src/index.ts",
   "bin": {

package/src/cli/commands/dev.ts

@@ -4,7 +4,7 @@ import { spawn, type ChildProcess } from 'node:child_process'
 import { defineCommand } from 'citty'
 import type { Miniflare } from 'miniflare'
 import { _root, build, wait, watch, normalizePlatform, platformError, getRuntime, createMiniflare, getDockerHost } from './utils'
-import { step, error, event, warn } from '../../utils/log'
+import { error, event, log, rn, warn } from '../../utils/log'
 import { withPort } from '../../utils/port'
 import shutdown from '../../utils/shutdown'
 
@@ -39,49 +39,83 @@ export default defineCommand({
 
 		const desiredPort = args.port ? Number(args.port) : 3000
 		const host = args.host ? String(args.host) : 'localhost'
+
+		let isBuilding = false
+		const startApp = async (start: Function, stop: Function|undefined = undefined, building: boolean = true) => {
+			if (building) {
+				if (isBuilding) return
+				isBuilding = true
+				event('Building..')
+			}
+			const fn = async () => {
+				building && await build(platform)
+				await start()
+			}
+
+			try {
+				await fn()
+				watch(async () => {
+					event('Restarting..')
+					await fn()
+					// event('Restarted...')
+				})
+				// @ts-ignore
+				stop && shutdown(stop)
+			} catch (e: any) {
+				error(e)
+				process.exit(0)
+			} finally {
+				isBuilding = false
+			}
+		}
+
+		const applyExit = async (app: ChildProcess | null) => {
+			if (!app) return null
+
+			app //?.on('exit', code => process.exit(code ?? 0))
+				.on('message', msg => {
+					process.send && process.send(msg)
+				}).on('disconnect', () => {
+					process.disconnect && process.disconnect()
+				})
+		}
+		const killProcess = async (app: ChildProcess | null) => {
+			if (!app) return null
+			// event('Stopping..')
+			try {
+				if (!app?.killed) {
+					app.kill('SIGTERM')
+					await wait(1000)
+
+					if (!app?.killed) { // force kill
+						app.kill('SIGKILL')
+						await wait(1000)
+					}
+				}
+
+				return null
+			} catch (e) {
+				error('Error stopping:', e)
+			}
+
+			return null
+		}
+
+		const started = (port: number) => {
+			log(`Starting API on http://${host}:${port}`)
+			rn()
+		}
+
 		switch (platform) {
 			case 'aws':
 				return withPort(desiredPort, async (port) => {
-					let isBuilding = false
+					started(port)
 					let lambda: ChildProcess | null = null
-
-					const buildLambda = async () => {
-						if (isBuilding) return
-						isBuilding = true
-						step('Building lambda')
-						try {
-							await build(platform)
-							if (!lambda) await startLambda()
-						} catch (e: any) {
-							error('Build failed:', e?.message || e)
-							process.exit(0)
-						} finally {
-							isBuilding = false
-						}
-					}
-
 					const stopLambda = async () => {
-						if (!lambda) return
-						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) {
-							warn('Error stopping lambda:', e)
-						}
+						lambda = await killProcess(lambda)
 					}
-
 					const startLambda = async () => {
-						await stopLambda()
+						if (lambda) await stopLambda()
 
 						lambda = spawn(
 							'sam',
@@ -97,106 +131,77 @@ export default defineCommand({
 								shell: process.platform == 'win32',
 								env: {...process.env, DOCKER_HOST: getDockerHost()},
 							}
-						).on('exit', code => {
-							step(`Lambda process exited with code ${code ?? 0}`)
-							if (code != 0 && code != null)
-								error('Lambda process crashed, waiting for restart...')
-
-							lambda = null
-						})
-						.on('message', msg => {
-							process.send && process.send(msg)
-						}).on('disconnect', () => {
-							process.disconnect && process.disconnect()
-						}).on('error', e => {
-							error('Lambda process error:', e)
-							lambda = null
-						})
-
+						)
+						//.on('exit', code => {
+						// 	warn(`Lambda process exited with code ${code ?? 0}`)
+						// 	if (code != 0 && code != null)
+						// 		error('Lambda process crashed, waiting for restart...')
+
+						// 	lambda = null
+						// }).on('message', msg => {
+						// 	process.send && process.send(msg)
+						// }).on('disconnect', () => {
+						// 	process.disconnect && process.disconnect()
+						// }).on('error', e => {
+						// 	error('Lambda process error:', e)
+						// 	lambda = null
+						// })
+						applyExit(lambda)
 						await wait(2000)
-
-						step('Lambda process started successfully')
 					}
 
-					await buildLambda()
-					event(`API running on http://${host}:${port}`)
-
-					watch(async () => {
-						await buildLambda()
-					})
-
-					shutdown(async () => {
-						await stopLambda()
-					})
+					await startApp(startLambda, stopLambda)
 				})
 			case 'cf':
 				return withPort(desiredPort, async (port) => {
-					let isBuilding = false
-
-					const buildWorker = async () => {
-						if (isBuilding) return
-						isBuilding = true
-						step('Building worker')
-						try {
-							await build(platform)
-							await startWorker()
-						} catch (e: any) {
-							error('Build failed:', e?.message || e)
-							process.exit(0)
-						} finally {
-							isBuilding = false
-						}
-					}
-
+					started(port)
 					let worker: Miniflare | null = null
 					const startWorker = async () => {
 						if (worker) await worker.dispose()
-
 						worker = await createMiniflare({ port, host, liveReload: false })
 					}
 
-					await buildWorker()
-					event(`API running on http://${host}:${port}`)
-
-					watch(async () => {
-						step('Restarting server')
-						await buildWorker()
-						step('Server restarted')
-					})
+					await startApp(startWorker)
 				})
 			default:
 			case 'node':
 				return withPort(desiredPort, async (port) => {
+					started(port)
 					const isBun = getRuntime() == 'bun'
 					const params = isBun
 						? ['run', '--port='+ port, '--hot', '--silent', '--no-clear-screen', '--no-summary', join(_root, 'node_modules/rajt/src/dev.ts')]
 						: [join(_root, 'node_modules/.bin/tsx'), 'watch', join(_root, 'node_modules/rajt/src/dev-node.ts')]
 
-					const child = spawn(
-						process.execPath,
-						params,
-						{
-							stdio: ['inherit', isBun ? 'pipe' : 'inherit', 'inherit', 'ipc'],
-							env: {...process.env, PORT: port},
-						}
-					)
 
-					event(`API running on http://${host}:${port}`)
+					let nodeApp: ChildProcess | null = null
+					const stopNode = async () => {
+						nodeApp = await killProcess(nodeApp)
+					}
+
+					const startNode = async () => {
+						if (nodeApp) await stopNode()
+
+						nodeApp = spawn(
+							process.execPath,
+							params,
+							{
+								stdio: ['inherit', isBun ? 'pipe' : 'inherit', 'inherit', 'ipc'],
+								env: {...process.env, PORT: port},
+							}
+						)
+
+						if (isBun && nodeApp?.stdout) {
+							nodeApp.stdout?.on('data', data => {
+								const output = data.toString()
+								if (!output.includes('Started development server'))
+										process.stdout.write(output)
+							})
+						}
 
-					if (isBun && child?.stdout) {
-						child.stdout?.on('data', data => {
-							const output = data.toString()
-							if (!output.includes('Started development server'))
-									process.stdout.write(output)
-						})
+						applyExit(nodeApp)
 					}
 
-					child.on('exit', code => process.exit(code ?? 0))
-						.on('message', msg => {
-							process.send && process.send(msg)
-						}).on('disconnect', () => {
-							process.disconnect && process.disconnect()
-						})
+					await startApp(startNode, stopNode, false)
 				})
     }
 	},

package/src/cli/commands/utils.ts

@@ -10,7 +10,7 @@ import { gray } from '../../utils/colors'
 import type { ChokidarEventName, Platform } from './types'
 
 import { cacheRoutes } from '../../routes'
-import { step, substep, event, error, warn } from '../../utils/log'
+import { step, substep, event, error, wait as wwait, warn, log } from '../../utils/log'
 import { platforms } from './constants'
 
 export const _root = join(dirname(new URL(import.meta.url).pathname), '../../../../../')
@@ -292,7 +292,7 @@ export async function watch(cb: (e: ChokidarEventName | string, file: string) =>
 	let restartTimeout: NodeJS.Timeout | null = null
 
 	const watcher = (e: ChokidarEventName) => async (file: string) => {
-		step(getAssetChangeMessage(e, file))
+		log(getAssetChangeMessage(e, file))
 
 		if (restartTimeout)
 			clearTimeout(restartTimeout)
@@ -308,7 +308,7 @@ export async function watch(cb: (e: ChokidarEventName | string, file: string) =>
 	codeWatcher.on('addDir', watcher('addDir'))
 	codeWatcher.on('unlinkDir', watcher('unlinkDir'))
 
-	step('Watching for file changes')
+	wwait('Watching for file changes')
 }
 
 export async function wait(ms: number) {

package/src/utils/log.ts

@@ -43,6 +43,7 @@ export const prefixes = {
   info: white(bold(' ')),
   event: green(bold('✓')),
   trace: magenta(bold('»')),
+  log: gray(bold('⁕')),
 } as const
 
 const LOGGING_METHOD = {
@@ -76,6 +77,10 @@ function prefixedLog(prefixType: keyof typeof prefixes, ...msg: any[]) {
   }
 }
 
+export function log(...msg: any[]) {
+  prefixedLog('log', ...msg)
+}
+
 export function wait(...msg: any[]) {
   prefixedLog('wait', ...msg)
 }