duto 0.260808.0 → 0.260915.0

package/src/server/cli/utils.ts

@@ -0,0 +1,437 @@
+import ts from 'typescript'
+import { Miniflare } from 'miniflare'
+import { mkdirSync, existsSync, statSync, readdirSync, rmSync, unlinkSync, copyFileSync, writeFileSync } from 'node:fs'
+import { stat } from 'node:fs/promises'
+import { basename, dirname, join } from 'pathe'
+import { createHash, createHmac } from 'node:crypto'
+
+import { findWranglerConfig, parseWranglerConfig, WRANGLER_CONFIG_FILES } from 'localflare-core'
+import type { WranglerConfig, LocalflareManifest } from 'localflare-core'
+
+import { gray, bold, italic, purple, yellow, red } from 't0n/color'
+import { substep, event, error, warn } from 't0n/log'
+
+import { cacheRoutes } from '$/routes'
+import { _root, _server, filesize } from '@/utils'
+
+import type { Platform } from './types'
+
+export const platforms = [
+  'aws', 'lambda',
+  'cf', 'cloudflare', 'worker', 'workers', 'workerd',
+  'node', 'bun',
+  'vercel',
+] as const
+
+export function normalizePlatform(platform: Platform) {
+  platform = platform?.toLowerCase() as Platform
+  if (!platforms?.includes(platform)) return null
+
+  switch (platform) {
+    case 'lambda':
+      return 'aws'
+
+    case 'cf':
+    case 'cloudflare':
+    case 'worker':
+    case 'workers':
+      return 'workerd'
+
+    case 'bun':
+      return 'node'
+
+    default:
+      return platform
+  }
+}
+
+const formatArgs = (...args: any[]) => args.flat().map(a => gray(italic(bold(a)))).join(', ')
+export const platformError = () => error(`Provide a valid platform: ${formatArgs(platforms)}.\n`)
+
+const nodeModules = [
+  'crypto', 'buffer', 'http', 'fs', 'path', 'events', 'stream', 'util',
+  'url', 'querystring', 'os', 'child_process', 'cluster', 'dns', 'net',
+  'tls', 'https', 'zlib', 'readline', 'repl', 'vm', 'module', 'assert',
+  'timers', 'string_decoder', 'punycode', 'perf_hooks', 'dgram', 'tty',
+  'worker_threads', 'wasi', 'process', 'diagnostics_channel', 'sqlite',
+  'async_hooks', 'console', 'fsevents',
+].flatMap(lib => ['node:'+ lib, lib])
+
+const printer = ts.createPrinter()
+function stripDecorators(source: string) {
+  const sourceFile = ts.createSourceFile(
+    'tmp.ts', source, ts.ScriptTarget.ESNext, false
+  )
+
+  const transformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
+    const visit: ts.Visitor = (node) => {
+      if (ts.isClassDeclaration(node) && node.modifiers?.length) {
+        let hasDecorator = false
+        const modifiers = []
+
+        for (const m of node.modifiers) {
+          if (m.kind === ts.SyntaxKind.Decorator) {
+            hasDecorator = true
+            continue
+          }
+          modifiers.push(m)
+        }
+
+        if (hasDecorator) {
+          return ts.factory.updateClassDeclaration(
+            node,
+            modifiers.length ? modifiers : undefined,
+            node.name,
+            node.typeParameters,
+            node.heritageClauses,
+            node.members
+          )
+        }
+      }
+
+      return ts.visitEachChild(node, visit, context)
+    }
+
+    return (node) => ts.visitNode(node, visit) as ts.SourceFile
+  }
+
+  const result = ts.transform(sourceFile, [transformer])
+  const code = printer.printFile(result.transformed[0])
+
+  result.dispose()
+  return code
+}
+
+const dist = '.duto'
+export const build = async ({
+  env = 'prd',
+  platform,
+  silent = false,
+  minify = true,
+}: {
+  env: string,
+  platform: Platform,
+  silent: boolean,
+  minify: boolean,
+}) => {
+  const startTime = performance.now()
+  const isWorkerd = platform === 'workerd'
+  cleanDir(join(_root, dist))
+
+  if (isWorkerd) {
+    for (let file of WRANGLER_CONFIG_FILES) {
+      file = join(_root, file)
+      if (existsSync(file))
+        copyFileSync(file, join(_root, dist, basename(file)))
+    }
+  }
+
+  if (['bun', 'vercel'].includes(platform)) platform = 'workerd'
+
+  const outdir = join(_root, dist)
+
+  const USE_STRICT_RE = /(["'`])\s*use strict\s*\1;?/g
+
+  await cacheRoutes()
+  if (!silent) event('Routes cached')
+
+  const result = await Bun.build({
+    entrypoints: [join(_server, 'adapter', `${platform}.ts`)],
+    outdir,
+    format: 'esm',
+    target: 'bun',
+    conditions: isWorkerd ? ['worker', 'browser'] : [],
+    minify: !!minify,
+
+    treeShaking: true,
+    legalComments: 'none',
+    metafile: false,
+    external: [
+      '@aws-sdk', '@smithy',
+      ...(isWorkerd ? [
+        'cloudflare:workers',
+        ...nodeModules,
+      ] : []),
+    ],
+
+    define: {
+      'process.env.DUTO_ENV': JSON.stringify(env),
+    },
+
+    plugins: [
+      {
+        name: 'duto',
+        setup(build) {
+          build.onResolve({ filter: /\.duto[\/\\]/ }, args => ({ path: join(_root, args.path) }))
+          build.onLoad({ filter: /\.ts$/ }, async (args) => {
+            return { contents: stripDecorators(await Bun.file(args.path).text()), loader: 'ts' }
+          })
+        },
+      },
+    ],
+  })
+
+  if (!result.success || !result?.outputs?.length)
+    throw new Error('build fail')
+
+  const output = result.outputs.find(file => file.kind === 'entry-point' && file.path.endsWith('.js'))
+  if (!output)
+    throw new Error('Build output not found')
+
+  let code = (await output.text()).replace(/\/\/\s*@bun\s*\n/g, '')
+
+  if (USE_STRICT_RE.test(code)) {
+    code = code.replace(USE_STRICT_RE, '')
+    await Bun.write(output.path, code)
+  }
+
+  const outfile = join(outdir, 'index.js')
+  if (output.path !== outfile) {
+    await Bun.write(outfile, code)
+
+    if (existsSync(output.path))
+      await Bun.file(output.path).delete()
+  }
+
+  if (!silent) {
+    event(`Build done in ${Math.ceil(performance.now() - startTime)}ms`)
+    substep(
+      // `${relative(join(_root, 'node_modules/duto/src'), opts.entryPoints[0])} → ${relative(_root, opts.outfile)}`,
+      `Size: ${filesize((await stat(outfile)).size)}`,
+      `Files: ${Object.keys(result.outputs).length}`
+    )
+  }
+}
+
+export function cleanDir(path: string) {
+  try {
+    if (!existsSync(path))
+      return mkdirSync(path, {recursive: true})
+
+    const files = readdirSync(path)
+
+    for (const file of files) {
+      const filePath = join(path, file)
+      const stat = statSync(filePath)
+
+      stat.isDirectory()
+        ? rmSync(filePath, {recursive: true, force: true})
+        : unlinkSync(filePath)
+    }
+  } catch {}
+}
+
+function durableObjectNamespace(name: string, uniqueKey: string) {
+  const key = createHash('sha256').update(uniqueKey).digest()
+  const nameHmac = createHmac('sha256', key).update(name).digest().subarray(0, 16)
+  return Buffer.concat([
+    nameHmac,
+    createHmac('sha256', key).update(nameHmac).digest().subarray(0, 16)
+  ]).toString('hex')
+}
+
+export function cleanDB(key: string, config?: WranglerConfig) {
+  config ??= wranglerConfig()
+  if (!config?.d1_databases) return
+  for (const db of config.d1_databases) {
+    if (key === db.database_name || key === db.binding) {
+      const ns = 'miniflare-D1DatabaseObject'
+      const fileName = join(ns, durableObjectNamespace(db.preview_database_id || db.database_id || db.binding, ns) +'.sqlite')
+
+      for (const file of [
+        fileName,
+        fileName +'-shm',
+        fileName +'-wal',
+      ]) {
+        const filePath = join(d1Path, file)
+        if (existsSync(filePath))
+          unlinkSync(filePath)
+      }
+    }
+  }
+}
+
+export function wranglerConfig(file: string | null = null) {
+  file ??= findWranglerConfig(_root)
+  if (!file) {
+    error('Could not find wrangler config file')
+    error('Looking for: '+ formatArgs(WRANGLER_CONFIG_FILES))
+    process.exit(1)
+  }
+
+  try {
+    return parseWranglerConfig(file)
+  } catch (e) {
+    warn(`Could not parse '${file}', using defaults`)
+    return {}
+  }
+}
+
+export function localflareManifest(opts: WranglerConfig): LocalflareManifest {
+  return {
+    name: opts.name || 'worker',
+    d1: (opts.d1_databases || []).map((db) => ({
+      binding: db.binding,
+      database_name: db.database_name,
+    })),
+    kv: (opts.kv_namespaces || []).map((kv) => ({
+      binding: kv.binding,
+    })),
+    r2: (opts.r2_buckets || []).map((r2) => ({
+      binding: r2.binding,
+      bucket_name: r2.bucket_name,
+    })),
+    queues: {
+      producers: (opts.queues?.producers || []).map((p) => ({
+        binding: p.binding,
+        queue: p.queue,
+      })),
+      consumers: (opts.queues?.consumers || []).map((c) => ({
+        queue: c.queue,
+        max_batch_size: c.max_batch_size,
+        max_batch_timeout: c.max_batch_timeout,
+        max_retries: c.max_retries,
+        dead_letter_queue: c.dead_letter_queue,
+      })),
+    },
+    do: (opts.durable_objects?.bindings || []).map((d) => ({
+      binding: d.name,
+      className: d.class_name,
+    })),
+    vars: Object.entries(opts.vars || {}).map(([key, value]) => ({
+      key,
+      value,
+      isSecret: false,
+      // isSecret: looksLikeSecret(key, value),
+    })),
+  }
+}
+
+const wranglerPath = '.wrangler/state/v3'
+export const kvPath = join(_root, wranglerPath, 'kv')
+export const d1Path = join(_root, wranglerPath, 'd1')
+export const r2Path = join(_root, wranglerPath, 'r2')
+export const doPath = join(_root, wranglerPath, 'durable_objects')
+
+export function createMiniflare(opts = {}) {
+  const entry = join(_root, opts?.main || opts?.script)
+  return new Miniflare({
+    host: opts.host || 'localhost',
+    port: opts.port || 8787,
+    https: opts.https || false,
+    httpsKey: opts.httpsKey,
+    httpsCert: opts.httpsCert,
+    liveReload: opts.liveReload !== false,
+    updateCheck: false,
+    scriptPath: entry,
+    modules: [
+      {type: 'ESModule', path: entry},
+    ],
+    compatibilityDate: opts.compatibility_date || '2024-11-01',
+    compatibilityFlags: opts.compatibility_flags || [
+      'nodejs_compat',
+    ],
+    bindings: {
+      ...opts.vars,
+    },
+
+    d1Databases: Array.isArray(opts.d1_databases) ? Object.fromEntries(opts.d1_databases.map(db => [db.binding, db.database_id])) : {},
+    kvNamespaces: Object.fromEntries((opts.kv_namespaces || []).map(ns => [ns.binding, ns.id])),
+    // r2Buckets: Object.fromEntries((opts.r2_buckets || []).map(r2 => [r2.binding, r2.bucket_name])),
+    // durableObjects: Object.fromEntries((opts.durable_objects?.bindings || []).map(do => [do.name, do.class_name])),
+
+    kvPersist: kvPath,
+    cachePersist: join(_root, wranglerPath, 'cache'),
+    d1Persist: d1Path,
+    r2Persist: r2Path,
+    durablesPersist: doPath,
+
+    verbose: false,
+
+    // Logging
+    // log: new console.Console({
+    //   stdout: process.stdout,
+    //   stderr: process.stderr,
+    //   inspectOptions: { depth: 3 }
+    // }),
+
+    cfFetch: false, // disable cf requests
+    upstream: opts.upstream || 'https://example.com',
+
+    sitePath: opts.site?.bucket ?
+      join(_root, opts.site.bucket) : undefined,
+    siteInclude: opts.site?.include || ['**/*'],
+    siteExclude: opts.site?.exclude || [],
+
+    globalAsyncIO: true,
+    globalTimers: true,
+    globalRandom: true,
+
+    inspectorPort: opts.inspectorPort || 9229,
+
+    cache: true,
+    cacheWarnUsage: true,
+  })
+}
+
+export async function wait(ms: number) {
+	return new Promise(r => setTimeout(r, ms))
+}
+
+export 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')
+}
+
+export function makeFile(path: string, content: string) {
+  const dir = dirname(path)
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+
+  writeFileSync(path, content)
+}
+
+export function hasExt(path: string) {
+  const index = path.lastIndexOf('.')
+  return index > 0 && index < path.length - 1
+}
+
+export const highlightedMethod = (method: string, str?: string | null, siblings: boolean = false): string => {
+  const val = str || method
+
+  switch (method) {
+    case 'HEAD':
+    case 'OPTIONS':
+    case 'CONNECT':
+    case 'TRACE':
+      return gray(val)
+    case 'GET':
+      return purple(val) + (siblings ? gray('|') + highlightedMethod('HEAD') : '')
+    case 'POST':
+    case 'PUT':
+    case 'PATCH':
+      return yellow(val)
+    case 'DELETE':
+      return red(val)
+  }
+
+  return val
+}
+
+export const highlightedURI = (uri: string, method: string) => uri.replace(
+  /(?::([a-zA-Z_][a-zA-Z0-9_]*)(\{[^}]+\})?|\*)/g,
+  _ => highlightedMethod(method, _)
+)

package/src/server/config.ts

@@ -0,0 +1,19 @@
+
+import { get, set } from 't0n'
+
+const obj: Record<string, unknown> = {}
+
+export function getConfig<T = unknown>(key: string, defaultValue: T): T
+export function getConfig<T = unknown>(key: string, defaultValue?: T): T | undefined
+export function getConfig<T = unknown>(key: string, defaultValue?: T) {
+  return get<T>(obj, key, defaultValue)
+}
+export const setConfig = (key: string, val: unknown) => set(obj, key, val)
+export function addConfig<T = unknown>(data: Record<string, T>) {
+  Object.assign(obj, data)
+}
+// export const getConfig = <T = unknown>(key: string, defaultValue?: T) => get<T>(obj, key, defaultValue)
+// import { DataBag } from 't0n'
+
+// const Config = new DataBag()
+// export default Config

package/src/server/db/d1.d.ts

@@ -0,0 +1 @@
+export * from 'forj/d1/types'

package/src/server/db/d1.ts

@@ -0,0 +1 @@
+export * from 'forj/d1'

package/src/server/db/dynamodb.d.ts

@@ -0,0 +1 @@
+export * from 'forj/dynamodb/types'

package/src/server/db/dynamodb.ts

@@ -0,0 +1 @@
+export * from 'forj/dynamodb'

package/src/server/db/index.ts

@@ -0,0 +1 @@
+export { Migration, Schema, Blueprint } from 'forj'

package/src/server/entry.ts

@@ -0,0 +1,19 @@
+import { getConfig } from '$/config'
+import { registerOpenAPI } from '$/open-api/register'
+import { Ability } from '$/auth'
+import $ from '$/app'
+
+// @ts-ignore
+import '.duto/imports.mjs'
+// @ts-ignore
+import { routes, middlewares } from '.duto/imports.mjs'
+
+// @ts-ignore
+Ability.fromRoutes(routes)
+Ability.roles = getConfig('roles', {})
+
+// @ts-ignore
+const app = $({ routes, middlewares })
+registerOpenAPI(app, getConfig('duto.docs', {}))
+
+export { app }

package/src/server/handle.ts

@@ -0,0 +1,30 @@
+import res from './response'
+import $v from './validator'
+import { GET_REQUEST } from './request'
+import type { Context, Next, RuleFactory } from './types'
+
+export const _mw: Record<string, Function> = {}
+export const getMiddlewares = () => _mw
+export function getMiddleware(id: string | Function): Function {
+  if (typeof id === 'function') return id
+  const mw = _mw[id] || null
+  if (!mw) throw new Error(`Handler ${id} not registered`)
+  return mw
+}
+export function registerMiddleware(id: string, handler: Function) {
+  _mw[id] = handler
+}
+
+export const resolveMw = (mw: Function) => {
+  return mw.length < 3 ? mw : async (c: Context, next: Next) => await getMiddleware(mw)(c.get(GET_REQUEST as unknown as string), res, next, c)
+}
+
+export const resolveHandle = (mw: (string | Function)[], handle: Function, ruleFn?: RuleFactory) => {
+  const h = async (c: Context) => await handle(c.get(GET_REQUEST as unknown as string), res)
+  mw = mw?.length ? mw.map(getMiddleware) : []
+
+  const rules = typeof ruleFn === 'function' ? ruleFn($v) : null
+  if (!rules) return [...mw, h]
+
+  return [...mw, ...$v.parse(rules), h]
+}

package/src/server/middlewares/auth.ts

@@ -0,0 +1,40 @@
+import { Ability } from '$/auth'
+import type { Req, Res, Next } from '@/.'
+
+import { RegExpRouter } from 'hono/router/reg-exp-router'
+import { SmartRouter } from 'hono/router/smart-router'
+import { TrieRouter } from 'hono/router/trie-router'
+
+let used = false
+export const useAuth = () => used
+
+const whiteList = new SmartRouter({
+  routers: [new RegExpRouter(), new TrieRouter()],
+})
+
+export function autorizedPath(path: string, method = 'ALL'){
+  return used ? whiteList.match(method, path)[0][0]?.[0] !== undefined : true
+}
+
+export function auth(publicPaths: (string | [string, string])[]) {
+  if (!used) {
+    used = true
+    for (const route of publicPaths) {
+      const str = typeof route === 'string'
+      const path = str ? route : route[1]
+
+      whiteList.add(str ? 'ALL' : route[0], path, path)
+    }
+  }
+
+  return async (req: Req, res: Res, next: Next) => {
+    if (!autorizedPath(req.path, req.method)) {
+      const ability = Ability.fromRequest(req)
+
+      if (!req?.user || !ability || req.cant(ability))
+        return res.unauthorized()
+    }
+
+    await next()
+  }
+}

package/src/server/middlewares/logger.ts

@@ -0,0 +1,30 @@
+import { logger } from 'hono/logger'
+import { matchedRoutes } from 'hono/route'
+import { Datte } from 't0n'
+import { gray } from 't0n/color'
+import type { Req, Res, Context, Next } from '@/.'
+
+export const path = '*'
+export async function handle(req: Req, res: Res, next: Next, c: Context) {
+  const method = c.req.method
+  const route = matchedRoutes(c).find(route => route.method === method)?.path
+  const logWithRoute = (args: string[]) => {
+    if (!route || !args.length) return args
+    return args.map(arg => {
+      if (!arg) return arg
+      const split = arg?.split(' ')
+      if (split.length < 3 || split[2] === route)
+        return arg
+
+      split.splice(Math.min(3, split.length), 0, gray(route))
+      return split.join(' ')
+    })
+  }
+
+  const devLogger = logger((...args: any[]) => {
+    const timestamp = gray(Datte.dateTime())
+    console.log(timestamp, ...logWithRoute(args))
+  })
+
+  await devLogger(c, next)
+}

package/src/server/open-api/register.ts

@@ -0,0 +1,29 @@
+import { basicAuth } from 'hono/basic-auth'
+import response from '$/response'
+import { getConfig } from '$/config'
+import type { Hono } from '$/types'
+
+export function registerOpenAPI(app: Hono, opts: any) {
+  if (!opts.path) return
+
+  if (opts?.auth?.username && opts?.auth?.password) {
+    app.use(opts.path +'/*', async (c, next) => {
+      const realm = opts.auth?.realm || 'Docs'
+      const unauthorized = response.unauthorized(
+        null,
+        {'WWW-Authenticate': `Basic realm="${realm.replace(/"/g, '\\"')}", charset="UTF-8"`}
+      )
+      if (!c.req.raw.headers.get('Authorization')) return unauthorized
+      const auth = basicAuth({ username: opts.auth.username, password: opts.auth.password, realm })
+
+      try {
+        await auth(c, next)
+      } catch {
+        return unauthorized
+      }
+    })
+  }
+
+  app.get(opts.path, async () => response.html(getConfig('DUTO_OAC')))
+  app.get(opts.path +'/openapi', async () => response.raw(200, getConfig('DUTO_OAS'), 'application/json'))
+}