duto 0.0.0 → 0.260906.0

package/src/server/auth/token.ts

@@ -0,0 +1,147 @@
+import { Envir, parseUA } from 't0n'
+import { sha256, toString, type Config } from 'cripta'
+import { config, create, parse } from 'cripta/token'
+import type { IRequest } from '$/types'
+
+const STABLE_HEADERS = [
+  'host',
+  'connection',
+  'sec-ch-ua',
+  'sec-ch-ua-mobile',
+  'sec-ch-ua-platform',
+  'upgrade-insecure-requests',
+  'user-agent',
+  'accept',
+  'sec-fetch-site',
+  'sec-fetch-mode',
+  'sec-fetch-user',
+  'sec-fetch-dest',
+  'accept-encoding',
+  'accept-language',
+]
+
+function headerOrdering(headers: Record<string, string>) {
+  const order: string[] = []
+
+  for (const name in headers) {
+    const key = name.toLowerCase()
+
+    if (STABLE_HEADERS.includes(key))
+      order.push(key)
+  }
+
+  return order
+}
+
+export class Token {
+  static #cookieName: string = '__auth_'
+  static #name: string = 'Authorization'
+  static #prefix: string = 'bearer'
+  static #cripta: Config
+
+  static async fromRequest(req: IRequest) {
+    const token = this.fromCookie(req) || this.fromHeader(req)
+    return token ? await this.parse(req, token) : null
+  }
+
+  static fromHeader(req: IRequest): string | null {
+    const header = req.header(this.#name) || req.header('HTTP_AUTHORIZATION') || req.header('REDIRECT_HTTP_AUTHORIZATION') || null
+
+    if (header) {
+      const pos = header.toLowerCase().indexOf(this.#prefix.toLowerCase())
+      if (pos < 0) return header
+
+      let token = header.slice(pos + this.#prefix.length).trim()
+      const commaPos = token.indexOf(',')
+      if (commaPos > -1) token = token.slice(0, commaPos).trim()
+
+      return token
+    }
+
+    return null
+  }
+
+  static fromCookie(req: IRequest): string | null {
+    const uid = req.header('uid')
+
+    if (uid) {
+      const auth = req.cookie.get(this.#cookieName + uid)
+      return auth ? auth : null
+    }
+
+    return null
+  }
+
+  static async cripta() {
+    if (this.#cripta)
+      return this.#cripta
+
+    return this.#cripta = await config({ key: Envir.get<string>('KEY') })
+  }
+
+  static async parse(req: IRequest, token: string) {
+    const host = this.host(req)
+    const serveHost = Envir.get('FLOW_SERVER', host) as string
+
+    return parse(await this.cripta(), token, {
+      iss: serveHost,
+      aud: [host],
+      '_': await this.fingerprint(req),
+    })
+  }
+
+  static async create(req: IRequest, user: any, exp: number = 7200) {
+    const time = Math.floor(Date.now() / 1000)
+    const host = this.host(req)
+
+    return create(await this.cripta(), user, {
+      iss: host,
+      aud: [host],
+      iat: time,
+      exp: time + exp,
+      '_': await this.fingerprint(req),
+    })
+  }
+
+  static setPrefix(prefix: string): void {
+    this.#prefix = prefix
+  }
+
+  static setName(name: string): void {
+    this.#name = name
+  }
+
+  static host(req: IRequest): string {
+    const url = req.url || req.header('host')
+    if (!url) return ''
+
+    let formattedUrl = String(url)
+    if (!formattedUrl.startsWith('http'))
+      formattedUrl = 'http://' + formattedUrl
+
+    try {
+      const parsedUrl = new URL(formattedUrl)
+      return parsedUrl.host
+    } catch {
+      return ''
+    }
+  }
+
+  static async fingerprint(req: IRequest) {
+    const ua = parseUA(req.header('user-agent'))
+
+    const id = toString(await sha256(
+      // (req.header('accept-language') || '')
+      this.ip(req)
+      + ua.browser.name + ua.browser.version.split('.')[0]
+      + ua.os.type + ua.os.name
+      + headerOrdering(req.header()).join('')
+    ))
+
+    return id.substring(0, 8) + id.substring(56, 64)
+  }
+
+  static ip(req: IRequest) {
+    return req?.ip || 0
+  }
+}

package/src/server/auth/types.ts

@@ -0,0 +1,2 @@
+export type Roles = Record<string, string[] | '*'>
+export type Abilities = string[]

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

@@ -0,0 +1,41 @@
+import { Envir } from 't0n'
+import { command } from 't0n/cli'
+import { gray } from 't0n/color'
+import { wait, error, rn } from 't0n/log'
+import { platforms, build, normalizePlatform, platformError } from '../utils'
+
+export default command({
+	meta: {
+		name: 'build',
+		description: '🗂️  Perform the build\n',
+	},
+	args: {
+		platform: {
+			alias: 'p',
+			description: 'Environment platform',
+			type: 'enum',
+			options: platforms,
+		},
+		minify: {
+			description: 'Minify the result',
+			type: 'boolean',
+			default: true,
+		},
+	},
+	async run({ args }) {
+    const platform = normalizePlatform(args.p || args.platform || Envir.get('duto.platform') || args._[0] || 'node')
+		if (!platform)
+			return platformError()
+
+		wait('Building for platform: '+ gray(platform))
+
+		try { // @ts-ignore
+      await build({ platform, minify: args.minify })
+    } catch (e: any) {
+			error('Build failed:\n\n', e)
+			process.exit(0)
+		} finally {
+			rn()
+		}
+	},
+})

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

@@ -0,0 +1,82 @@
+import { spawn } from 'node:child_process'
+import { Envir } from 't0n'
+import { command } from 't0n/cli'
+import { error } from 't0n/log'
+import { getRuntime } from 't0n/cli'
+
+import { build, platforms, normalizePlatform, platformError } from '../utils'
+import { _root } from '@/utils'
+
+// import build from './build'
+
+export default command({
+	meta: {
+		name: 'deploy',
+		description: '☁️  Perform the build and execute deploy\n',
+	},
+	args: {
+		platform: {
+			alias: 'p',
+			description: 'Environment platform',
+			type: 'enum',
+			options: platforms,
+    },
+		minify: {
+			description: 'Minify the result',
+			type: 'boolean',
+			default: true,
+		},
+	},
+	async run({ args }) { // @ts-ignore
+		const platform = normalizePlatform(args.p || args.platform || args._[0] || Envir.get('duto.platform'))
+		if (!platform)
+			return platformError()
+
+		// @ts-ignore
+    await build({ platform, minify: args.minify })
+		const isBun = getRuntime() === 'bun'
+
+		switch (platform) {
+			case 'aws':
+				// TODO: perform aws deploy
+				return error('Platform not yet implemented, contact the webmaster')
+			case 'workerd':
+				const child = spawn(
+					isBun ? 'bunx' : 'npx',
+					['wrangler', 'deploy'],
+					{
+						stdio: 'inherit',
+						cwd: _root,
+					}
+				)
+
+				child.on('exit', code => process.exit(code ?? 0))
+					.on('message', msg => {
+						process.send && process.send(msg)
+					}).on('disconnect', () => {
+						process.disconnect && process.disconnect()
+					})
+
+				return
+			case 'vercel':
+				return error('Platform not yet implemented, contact the webmaster')
+				const vchild = spawn(
+					isBun ? 'bunx' : 'npx',
+					['vercel', 'deploy'],
+					{
+						stdio: 'inherit',
+						cwd: _root,
+					}
+				)
+
+				vchild.on('exit', code => process.exit(code ?? 0))
+					.on('message', msg => {
+						process.send && process.send(msg)
+					}).on('disconnect', () => {
+						process.disconnect && process.disconnect()
+					})
+
+				return
+    }
+	},
+})

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

@@ -0,0 +1,277 @@
+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 { Envir } 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 = Envir.get('duto', {})
+		const platform = normalizePlatform(args.p || args.platform || duto.platform || args._[0] || 'node')
+		if (!platform)
+			return platformError()
+
+		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')
+	},
+})