duto 0.260808.0 → 0.260915.0

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

@@ -0,0 +1,279 @@
+import { join } from 'pathe'
+import { spawn, type ChildProcess } from 'node:child_process'
+
+import { command } from 't0n/cli'
+import type { Miniflare } from 'miniflare'
+import { WRANGLER_CONFIG_FILES, type WranglerConfig } from 'localflare-core'
+
+import { error, event, log, rn, warn } from 't0n/log'
+import { getRuntime, shutdown, watch } from 't0n/cli'
+
+import {
+	build, wait, normalizePlatform, platformError,
+	wranglerConfig, createMiniflare, localflareManifest,
+	getDockerHost,
+  // findTsx
+} from '../utils'
+import { _root } from '@/utils'
+import { withPort } from 't0n/port'
+import { getEnv } from 't0n'
+import { $dev, setEnv } from '$/utils/environment'
+
+export default command({
+	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,
+		},
+		minify: {
+			description: 'Minify the result',
+			type: 'boolean',
+			default: true,
+		},
+	},
+  async run({ args }) {
+    setEnv($dev)
+    const duto = getEnv('duto', {})
+		const platform = normalizePlatform(args.p || args.platform || duto.platform || args._[0] || 'node')
+		if (!platform)
+			return platformError()
+
+		const desiredPort = Number(args.port || duto?.dev?.port || 3000)
+		const host = String(args.host || duto?.dev?.host || 'localhost')
+		// const desiredPort = args.port ? Number(args.port) : duto?.dev?.port || 3000
+		// const host = args.host ? String(args.host) : duto?.dev?.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 (silent: boolean = false) => { // @ts-ignore
+        building && await build({ platform, silent, minify: args.minify, env: 'dev' })
+				await start()
+			}
+
+			try {
+				await fn()
+				watch(async () => {
+          // event('Restarting..')
+          try {
+					  await fn(true)
+          } catch (e) {
+            error(e)
+          }
+					// event('Restarted...')
+				}, [
+          join(_root, '{actions,features,routes,configs,enums,libs,locales,middlewares,models,utils}/**/*.ts'),
+          join(_root, 'node_modules/{duto,cripta,t0n}/**/*.ts'),
+          join(_root, '.env.dev'),
+          join(_root, '.env.prod'),
+          join(_root, 'package.json'),
+          ...WRANGLER_CONFIG_FILES.map(f => join(_root, f)),
+        ], _root)
+				// @ts-ignore
+				stop && shutdown(stop)
+			} catch (e: any) {
+        error(e?.stack || e?.message || 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}`)
+			if (platform === 'workerd')
+				log(`Localflare on https://studio.localflare.dev`)
+			rn()
+    }
+
+    withPort(desiredPort, async port => {
+      switch (platform) {
+        case 'aws':
+          started(port)
+          let lambda: ChildProcess | null = null
+          const stopLambda = async () => {
+            lambda = await killProcess(lambda)
+          }
+          const startLambda = async () => {
+            if (lambda) await stopLambda()
+
+            lambda = spawn(
+              'sam',
+              [
+                'local', 'start-api',
+                '--warm-containers', 'LAZY',
+                '--debug', '--template-file', join(_root, 'template-dev.yaml'),
+                '--port', String(port),
+              ],
+              {
+                stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+                // stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+                shell: process.platform === 'win32',
+                env: {...process.env, DOCKER_HOST: getDockerHost()},
+              }
+            )
+            //.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)
+          }
+
+          await startApp(startLambda, stopLambda)
+          break
+
+        case 'workerd':
+          started(port)
+
+          let localflare: Miniflare | null = null
+          const startLocalflare = async (workerConfig: WranglerConfig) => {
+            if (localflare) return
+
+            localflare = createMiniflare({
+              ...workerConfig,
+              vars: {
+                ...workerConfig.vars,
+                LOCALFLARE_MANIFEST: JSON.stringify(localflareManifest(workerConfig)),
+              },
+              main: '.duto/localfire.js',
+              port: 8788,
+              inspectorPort: 9230,
+            })
+
+            await localflare.ready
+          }
+
+          let worker: Miniflare | null = null
+          const startWorker = async () => {
+            if (worker) await worker.dispose()
+
+            const workerConfig = await wranglerConfig() // @ts-ignore
+            workerConfig.host = host // @ts-ignore
+            workerConfig.liveReload = false
+
+            worker = createMiniflare({ ...workerConfig, port })
+            await worker.ready
+
+            if (!localflare) await startLocalflare(workerConfig)
+          }
+
+          await startApp(startWorker)
+          break
+        default:
+        case 'node':
+          return console.error('@Deprecated')
+          const isBun = getRuntime() === 'bun'
+          const isWin32 = process.platform === 'win32'
+
+          const _arg = isBun ? 'run' : findTsx()
+
+          if (!_arg) {
+            console.error('Error: "tsx" is not available. Please install tsx:')
+            console.error('  npm i -D tsx')
+            console.error('  or')
+            console.error('  bun i -D tsx')
+            process.exit(1)
+          }
+
+          started(port)
+          const params = isBun
+            ? ['--port=' + port, '--hot', '--silent', '--no-clear-screen', '--no-summary']
+            : ['watch']
+
+          let nodeApp: ChildProcess | null = null
+          const stopNode = async () => {
+            nodeApp = await killProcess(nodeApp)
+          }
+
+          const startNode = async () => {
+            if (nodeApp) await stopNode()
+
+            nodeApp = spawn(
+              isBun && isWin32 ? 'bun' : process.execPath,
+              [_arg, ...params, join(_root, `node_modules/duto/src/${isBun ? 'app/dev' : 'adapter/node'}.ts`)],
+              {
+                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)
+              })
+            }
+
+            applyExit(nodeApp)
+          }
+
+          await startApp(startNode, stopNode, false)
+      }
+    })
+	},
+})

package/src/server/cli/commands/make.ts

@@ -0,0 +1,98 @@
+import { join, relative } from 'pathe'
+import { command } from 't0n/cli'
+import { dim } from 't0n/color'
+import { event, error } from 't0n/log'
+import { Migrator } from 'forj'
+import { camelCase, kebabCase } from 't0n'
+import { makeFile, hasExt } from '../utils'
+import { _root } from '@/utils'
+import * as stub from '../stubs'
+
+export default command({
+	meta: {
+		name: 'make',
+		description: '📄 Create new files\n',
+	},
+	async run({ args }) {
+		const alias = process.argv[2]?.startsWith('make:')
+		const action = alias ? process.argv[2].replace('make:', '') : process.argv[3]
+		const name = alias ? args._[0] : args._[1]
+
+		const command = 'make'+ (alias ? ':': ' ') + action +' <name> '
+
+		if (!name)
+			return error('File name is required')
+
+    const makeFileName = (s: string) => {
+      const lastDotIndex = s.lastIndexOf('.')
+      const hasExtension = lastDotIndex > 0 && lastDotIndex < s.length - 1
+
+      return hasExtension
+        ? `${kebabCase(s.substring(0, lastDotIndex))}.${s.substring(lastDotIndex + 1)}`
+        : s
+    }
+
+		const path = (p: string, dir: string = action) => join(_root, dir + 's', p)
+		let fileName = ''
+		switch (action) {
+			case 'config':
+				fileName = path(makeFileName(name))
+				if (!hasExt(fileName)) fileName += '.ts'
+				makeFile(fileName, name.endsWith('.json') ? '{\n}' : 'export default {\n\n}\n')
+				break
+			case 'enum':
+				error('Action not yet implemented, contact the webmaster')
+				break
+			case 'route':
+			case 'action':
+			case 'endpoint':
+				fileName = path(makeFileName(name))
+				if (!fileName.endsWith('.ts')) fileName += '.ts'
+				makeFile(fileName, stub.replace(stub.route, { R_NAME: camelCase(name) }))
+				break
+			case 'migrate':
+			case 'migration':
+				const binding = alias ? args._[1] : args._[2]
+				if (!binding)
+					return error(`Provide a database: `+ dim(command +'<database>'))
+
+				fileName = Migrator.fileName(name)
+				const [table, create] = Migrator.guess(name)
+				fileName = path(join(binding || '', fileName), 'migration')
+				if (!fileName.endsWith('.ts')) fileName += '.ts'
+				makeFile(fileName, stub.replace(stub.migration, {
+					M_NAME: Migrator.className(name),
+					S_NAME: create ? 'create' : 'table',
+					T_NAME: table || 'TABLE_NAME',
+					M_CONTENT: create ? stub.migrationCreate : '//',
+				}))
+				break
+			case 'model':
+				error('Action not yet implemented, contact the webmaster')
+				break
+			case 'job':
+				error('Action not yet implemented, contact the webmaster')
+				break
+			case 'seed':
+			case 'seeder':
+				error('Action not yet implemented, contact the webmaster')
+				break
+			case 'test':
+				error('Action not yet implemented, contact the webmaster')
+				break
+			default:
+				return error('Invalid action: '+ dim('make <action>['+ [
+					'config',
+					'enum',
+					'route', // 'action', 'endpoint',
+					'migrate', // 'migration',
+					'model',
+					'job',
+					'seed', // 'seeder',
+					'test',
+				].join('|') +'] <name>'))
+		}
+
+		event(action.charAt(0).toUpperCase() + action.slice(1) +' "'+ relative(_root, fileName) +'" created successfully')
+	},
+})

package/src/server/cli/commands/migrate.ts

@@ -0,0 +1,93 @@
+import { command } from 't0n/cli'
+import { spawn } from 'node:child_process'
+import { join } from 'pathe'
+import { Migrator } from 'forj'
+import { gray } from 't0n/color'
+import { getRuntime } from 't0n/cli'
+import { wait, info, event, rn, error, log } from 't0n/log'
+
+import { cleanDB, cleanDir } from '../utils'
+import { _root } from '@/utils'
+
+export default command({
+	meta: {
+		name: 'migrate',
+		description: '🗃️ Migration performs\n',
+	},
+	args: {
+		remote: {
+			description: 'Execute against remote environment',
+			type: 'boolean',
+		},
+	},
+	async run({ args }) {
+		if (args._.length !== 2) {
+			error('Invalid args: '+ gray('[ACTION] [DATABASE]'))
+			return rn()
+		}
+
+		const [action, database] = args._
+		const isBun = getRuntime() === 'bun'
+		const isRemote = !!args?.remote
+
+		try {
+			const migrations = await Migrator.dir(database).queue()
+			const pending = migrations.pending
+      const migrated = migrations.migrated
+
+			switch (action) {
+				case 'migrate':
+				case 'apply':
+				case 'fresh':
+				case 'refresh':
+					if (!pending?.length)
+						log('Nothing to compile')
+					wait('Running migrations')
+
+					if (action.includes('fresh')) {
+						cleanDir(join(_root, 'migrations', database, 'sql'))
+						cleanDB(database)
+					}
+
+					await Migrator.compile([...migrated, ...pending])
+
+					const child = spawn(
+						isBun ? 'bunx' : 'npx',
+						['wrangler', 'd1', 'migrations', 'apply', database, isRemote ? '--remove' : '--local'],
+						{
+							stdio: 'inherit',
+							cwd: _root,
+							env: {
+								...process.env,
+								CI: 'true', // bypass wrangler confirmation msg
+							},
+						}
+					)
+
+					child.on('exit', code => process.exit(code ?? 0))
+						.on('message', msg => process.send && process.send(msg))
+						.on('disconnect', () => process.disconnect && process.disconnect())
+
+					pending.forEach(item => event(item.name))
+					break
+				case 'status':
+					if (migrated?.length) {
+						event('Migrated')
+						migrated.forEach(item => info(item.name))
+					}
+
+					if (pending?.length) {
+						wait('Pending')
+						pending.forEach(item => info(item.name))
+					}
+
+					break
+				default:
+					return error('Invalid action')
+			}
+
+		} finally {
+			rn()
+		}
+	},
+})

package/src/server/cli/commands/routes.ts

@@ -0,0 +1,78 @@
+import { command } from 't0n/cli'
+import { rn } from 't0n/log'
+import { highlightedURI, highlightedMethod } from '../utils'
+import { getRoutes } from '$/routes'
+
+export default command({
+	meta: {
+		name: 'routes',
+		description: '📒 Displays all registered routes\n',
+	},
+	args: {
+		path: {
+			description: 'Filter the routes by path',
+			type: 'string',
+		},
+		method: {
+			description: 'Filter the routes by method',
+			type: 'string',
+		},
+		reverse: {
+			description: 'Reverse the ordering of the routes',
+			type: 'boolean',
+		},
+	},
+	async run({ args }) {
+		const opts = {
+			path: args?.path || '',
+			method: args?.method?.toUpperCase() || '',
+			reverse: !!args?.reverse,
+		}
+
+		const keys: Set<string> = new Set()
+		let maxMethodLength = 0
+		let maxPathLength = 0
+
+		let routes = (await getRoutes())
+      .filter(({ method, path }) => {
+        method = method.toUpperCase()
+				const key = method + '-' + path
+				if (keys.has(key)) return false
+				keys.add(key)
+
+				let mLength = method.length
+				if (method === 'GET') mLength += 5
+
+				maxMethodLength = Math.max(maxMethodLength, mLength)
+				maxPathLength = Math.max(maxPathLength, path.length)
+
+				return [
+					opts.path ? path.startsWith(opts.path) : true,
+					opts.method ? method === opts.method : true,
+				].every(Boolean)
+			})
+
+    if (!routes.length) {
+      console.log('  No route found.')
+      return rn()
+    }
+
+		if (opts.reverse)
+			routes = routes.reverse()
+
+		routes.forEach(route => {
+			if (!route) return
+      const method = route.method.toUpperCase()
+
+			let mLength = method.length
+			let str = highlightedMethod(method, null, true)
+
+			if (method === 'GET')
+				mLength += 5
+
+			console.log(str + ' '.repeat(maxMethodLength - mLength) +'  '+ highlightedURI(route.path, method))
+		})
+
+		rn()
+	},
+})

package/src/server/cli/index.ts

@@ -0,0 +1,27 @@
+import { join } from 'pathe'
+
+const cmd = (c: string) => join(import.meta.dirname, 'commands', c)
+const make = cmd('make')
+const routes = cmd('routes')
+
+export default {
+  dev: cmd('dev'),
+  build: cmd('build'),
+  deploy: cmd('deploy'),
+  routes,
+  endpoints: routes,
+  migrate: cmd('migrate'),
+  make,
+  'make:config': make,
+  'make:enum': make,
+  'make:route': make,
+  'make:action': make,
+  'make:endpoint': make,
+  'make:migrate': make,
+  'make:migration': make,
+  'make:model': make,
+  'make:job': make,
+  'make:seed': make,
+  'make:seeder': make,
+  'make:test': make,
+}

package/src/server/cli/stubs.ts

@@ -0,0 +1,39 @@
+export const replace = (str: string, map: Record<string, string>) => {
+  if (!str || typeof str !== 'string' || !map || typeof map !== 'object') return str
+  const entries = Object.entries(map)
+  const length = entries?.length || 0
+  if (!length) return str
+
+  str = str.trimStart()
+  if (length === 1)
+    return str.replaceAll(entries[0][0], entries[0][1])
+
+  return entries.reduce(
+    (acc, entry) => acc.replace(new RegExp(entry[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), entry[1]),
+    str
+  )
+}
+
+export const route = `
+import type { Req, Res } from 'duto'
+
+export async function handle(req: Req, res: Res) {
+  return res.ok('R_NAME')
+}
+`
+
+export const migration = `
+import { Migration, Schema, Blueprint } from 'duto/db'
+
+export default class M_NAME extends Migration {
+  static async run() {
+    Schema.S_NAME('T_NAME', (table: Blueprint) => {
+      M_CONTENT
+    })
+  }
+}
+`
+export const migrationCreate = `
+      table.id()
+      table.timestamps()
+`.trim()

package/src/server/cli/types.ts

@@ -0,0 +1,3 @@
+import { platforms } from './utils'
+
+export type Platform = typeof platforms[number]