duto 0.260808.0 → 0.260915.0

package/src/{preact → pages/preact}/server.ts

@@ -8,7 +8,7 @@ import { getContext, incrementIslandId } from './context'
 import { restoreSignalsOnProps, serializeSignals } from './signals'
 import StaticHtml from './static-html'
 import type { IslandAttrs } from './types'
-import type { IslandMeta } from '@/types'
+import type { IslandMeta } from '#/compiler/types'
 // import type { AstroPreactAttrs, RendererContext } from './types.js'
 // import { createFilter } from '@astrojs/internal-helpers/create-filter'
 

package/src/server/adapter/aws.ts

@@ -0,0 +1,4 @@
+import { handle } from 'hono/aws-lambda'
+import { app } from '$/entry'
+
+export const handler = handle(app)

package/src/server/adapter/workerd.ts

@@ -0,0 +1,4 @@
+import { app } from '$/entry'
+export default app
+
+// export { app as default } from '$/entry'

package/src/server/app.ts

@@ -0,0 +1,91 @@
+import { Hono } from 'hono'
+import type {
+  Env, Context, Next,
+  HTTPResponseError,
+  ServerOptions, Route
+} from './types'
+import request from './request'
+import response from './response'
+import { isDev } from './utils/environment'
+import { getVerb } from './utils'
+import { registerMiddleware, resolveHandle, resolveMw } from './handle'
+
+async function EHandler(e: Error | HTTPResponseError) {
+  console.error(e)
+
+  switch (true) {
+    // case 'status' in e && e.status === 401:
+    case e?.status === 401:
+      return response.unauthorized()
+
+    // case 'status' in e && e.status === 400: // @ts-ignore
+    case e?.status === 400:
+      return response.badRequest(null, e?.message)
+
+    default:
+      return response.internalError(
+        // @ts-ignore
+        isDev() // TODO: remover ou migrar para um middleware / melhorar
+          ? e.stack?.split('\n').map(line =>
+              line.replace(
+                /at (.+ )?\(?([^)]+)\)?/g,
+                (match, method, path) => {
+                  if (!path) return match
+
+                  const nodeModulesIndex = path.indexOf('node_modules')
+                  if (nodeModulesIndex > -1)
+                    return `${method || ''}(node_modules${path.slice(nodeModulesIndex + 'node_modules'.length)})`
+
+                  const projectRoot = process.cwd()
+                  const relativePath = path.startsWith(projectRoot) ? path.slice(projectRoot.length + 1) : path
+                  return `${method || ''}(${relativePath})`
+                }
+              ).trim()
+            )
+          : undefined,
+        e.message || 'Internal Error'
+      )
+  }
+
+  // return json.internalError(
+  //   // @ts-ignore
+  //   isDev() ? e.stack?.split('\n    at ').map() : undefined,
+  //   e.message || 'Internal Error'
+  // )
+  // error: e.message,
+  // cause: e.cause || '???',
+  // stack: isDev (? e.stack : undefined
+}
+
+export default function createApp<E extends Env>(options?: ServerOptions<E>) {
+  // const root = options?.root ?? '/'
+  const app = options?.app ?? new Hono<E>()
+
+  app.use(async (c: Context, next: Next) => {
+    await request.toContext(c)
+    await next()
+  })
+
+  const middlewares = options?.middlewares || []
+  for (const mw of middlewares) { // @ts-ignore
+    registerMiddleware(mw[2], mw[1]) // @ts-ignore
+    mw[0] ? app.use(String(mw[0]), resolveMw(mw[1])) : app.use(resolveMw(mw[1]))
+  }
+
+  // @ts-ignore
+  app.onError(options?.onError || EHandler)
+  app.notFound(options?.notFound || response.notFound)
+
+  if (options?.init) options.init(app)
+
+  const routes = options?.routes || [] // @ts-ignore
+  const routeRegister = options?.routeRegister ? options.routeRegister : (_: Hono, route: Route) => {
+    // @ts-ignore
+    _[getVerb[route[0]]](route[1], ...resolveHandle(route[2], route[3], route[4]))
+  }
+
+  for (const route of routes)
+    routeRegister(app, route)
+
+  return app
+}

package/src/server/auth/ability.ts

@@ -0,0 +1,72 @@
+import { verbAlias } from '$/utils'
+import type { IRequest, Routes } from '$/types'
+import type { Roles, Abilities } from './types'
+
+export class Ability {
+  static #roles: Roles = {}
+  static #abilities: Abilities = []
+  static #actions: Record<string, string> = {}
+
+  static empty() {
+    this.#roles = {}
+    this.#abilities = []
+  }
+
+  static fromRoutes(routes: Routes) {
+    if (!routes?.length) return
+
+    const actions: Record<string, string> = {}
+    const abilities = new Set()
+    for (const route of routes) {
+      const isArr = Array.isArray(route)
+      const name = isArr ? route[route.length-1] : route.name
+      if (!name || abilities.has(name)) continue
+
+      abilities.add(name)
+      actions[(isArr ? route[1] : route.path) +'$'+ verbAlias[isArr ? route[0] : route.method]] = name
+      const formatted = this.format(name)
+
+      if (formatted)
+        this.#abilities.push(formatted)
+    }
+
+    this.#actions = actions
+  }
+
+  static fromRequest(req: IRequest) {
+    const ability = this.#actions[`${req.routePath}$` + verbAlias[req.method.toLowerCase()]]
+    return ability ? this.format(ability) : ''
+  }
+
+  static fromAction(target: any): string {
+    return !target ? '' : this.format(typeof target === 'string' ? target : (target.name.length > 3 ? target.name : (target?.p || '')))
+  }
+
+  static format(path: string) {
+    return path === '/'
+      ? 'index'
+      : path.normalize('NFD')
+         .replace(/[\u0300-\u036f]/g, '')
+         .replace(/^\/*/, '')
+         .replace(/([a-z])([A-Z])/g, '$1-$2')
+         .replace(/[^a-zA-Z0-9/]|[\s\-.]/g, '_')
+         .replace(/_+/g, '_')
+         .replace(/\//g, '.')
+         .replace(/\._/g, '.')
+         .replace(/^[._-]+/, '')
+         .replace(/[._-]+$/, '')
+         .toLowerCase()
+  }
+
+  static get abilities() {
+    return this.#abilities
+  }
+
+  static get roles() {
+    return this.#roles
+  }
+
+  static set roles(roles: Roles) {
+    this.#roles = roles
+  }
+}

package/src/server/auth/authnz.ts

@@ -0,0 +1,86 @@
+import { Ability } from './ability'
+import type { Token } from 'cripta/token'
+
+export class Authnz<T extends object> {
+  #abilities: string[]
+  #roles: string[]
+  #data: T
+  #token: Token
+
+  constructor(token: Token, data: T, abilities: string[], roles: string[]) {
+    this.#abilities = abilities
+    this.#roles = roles
+    this.#token = token
+    this.#data = data
+  }
+
+  can(...abilities: string[]): boolean {
+    if (this.#abilities.includes('*')) return true
+
+    return abilities.flat().every(ability => {
+      if (this.#roles.includes(ability)) return true
+      return this.#abilities.some(rule => this.#match(rule, ability))
+    })
+  }
+  cant(...abilities: string[]): boolean {
+    return !this.can(...abilities)
+  }
+
+  hasRole(...roles: string[]): boolean {
+    return roles.flat().every(role => this.#roles.includes(role))
+  }
+
+  // has(prop: string, value: any = null): boolean {
+  //   return this.#token?.hasValue(prop, value) || false
+  // }
+  // hasValue(prop: string, value: any = null): boolean {
+  //   return this.has(prop, value)
+  // }
+
+  static fromToken<T extends object>(token: Token): Authnz<T> | null {
+    if (!token || !token?.valid) return null
+    const user = token.body
+    const roles = [...(user?.role ? [user.role] : []), ...(user?.roles ?? [])]
+
+    const combined = [...(user?.perms ?? []), ...roles.flatMap(role => {
+      const perms = Ability.roles[role]
+      if (!perms) return []
+      return perms === '*' ? ['*'] : perms
+    })]
+
+    const abilities = combined.includes('*') ? ['*'] : Array.from(new Set(combined))
+
+    return new Authnz<T>(token, user, abilities, roles)
+  }
+
+  #match(rule: string, ability: string): boolean {
+    if (rule === ability) return true
+    if (
+      this.#wildcardMatch(rule, ability, '_*')
+      || this.#wildcardMatch(rule, ability, '-*')
+      || this.#wildcardMatch(rule, ability, '.*')
+    ) return true
+
+    return false
+  }
+
+  #wildcardMatch(rule: string, ability: string, suffix: string) {
+    return rule.endsWith(suffix)
+      && (ability.startsWith(rule.slice(0, -2) + suffix[0]) || ability === rule.slice(0, -2))
+  }
+
+  get abilities() {
+    return this.#abilities
+  }
+
+  get roles() {
+    return this.#roles
+  }
+
+  get data() {
+    return this.#data
+  }
+  get user() {
+    return this.#data
+  }
+}

package/src/server/auth/index.ts

@@ -0,0 +1,5 @@
+export { Ability } from './ability'
+export { Authnz } from './authnz'
+export { Token } from './token'
+
+export * from './types'

package/src/server/auth/token.ts

@@ -0,0 +1,147 @@
+import { bytesToHex, getEnv, parseUA } from 't0n'
+import { sha256, 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: getEnv('KEY') })
+  }
+
+  static async parse(req: IRequest, token: string) {
+    const host = this.host(req)
+    const serveHost = getEnv('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 = bytesToHex(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 { getEnv } 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 || getEnv('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,81 @@
+import { spawn } from 'node:child_process'
+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] || getEnv('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
+    }
+	},
+})