galbe 0.2.0 → 0.4.1

package/.github/workflows/build_test.yml

@@ -1,10 +1,10 @@
-name: Build & Test
+name: Install & Test
 on:
   push:
   pull_request:
 jobs:
   build:
-    name: Build & Test
+    name: Install & Test
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -13,7 +13,5 @@ jobs:
           bun-version: latest
       - name: Install
         run: bun install
-      - name: Build
-        run: bun run build
       - name: Test
         run: bun test

package/.github/workflows/release.yml

@@ -30,9 +30,9 @@ jobs:
         run: |
           git config user.email "${GITHUB_ACTOR}@users.noreply.github.com"
           git config user.name "${GITHUB_ACTOR}"
-      - name: Install dependencies & build
+      - name: Install dependencies
         run: |
-          bun install && bun run build
+          bun install
       - name: Release
         run: |
           npm config set //registry.npmjs.org/:_authToken $NPM_TOKEN

package/bin/cli.ts

@@ -1,113 +1,17 @@
 #!/usr/bin/env bun
 
-import { $, Glob } from 'bun'
-import type { RouteMeta } from '../src/routes'
 import { program } from 'commander'
-import { relative, resolve } from 'path'
-import { mkdir, readdir, lstat, rm } from 'fs/promises'
-import { DEFAULT_ROUTE_PATTERN, metaAnalysis } from '../src/routes'
-import { randomUUID } from 'crypto'
-import { Galbe } from '../src'
 
-const ROOT = process.cwd()
-const BUILD_ID = randomUUID()
+import { pckg } from './util'
 
-Bun.env.FORCE_COLOR = '1'
+import dev from './commands/dev'
+import build from './commands/build'
+import generate from './commands/generate'
 
-const parseRoutes = async (routes?: boolean | string | string[]): Promise<{ path: string; meta: RouteMeta }[]> => {
-  routes = routes === true ? DEFAULT_ROUTE_PATTERN : routes
-  if (!routes) return []
-  let files: { path: string; meta: RouteMeta }[] = []
-  if (typeof routes === 'string') {
-    for await (const path of new Glob(routes).scan({ cwd: ROOT, absolute: true, onlyFiles: false })) {
-      const isDir = (await lstat(path)).isDirectory()
-      if (isDir) {
-        files = files.concat(
-          await Promise.all(
-            (
-              await readdir(path)
-            ).map(async f => ({
-              path: f,
-              meta: await metaAnalysis(path)
-            }))
-          )
-        )
-      } else files.push({ path, meta: await metaAnalysis(path) })
-    }
-  }
-  if (Array.isArray(routes)) for (const r of routes) files = files.concat(await parseRoutes(r))
-  return files
-}
+program.name('galbe').description(pckg.description).version(pckg.version)
 
-const createBuildIndex = async (indexPath: string, routes: { path: string; meta: RouteMeta }[]) => {
-  const buildPath = resolve(ROOT, '.galbe', 'build', BUILD_ID)
-  await mkdir(buildPath, { recursive: true })
-  await Bun.write(
-    resolve(buildPath, 'index.ts'),
-    `import galbe from '${relative(buildPath, indexPath)}';
-${routes.map((r, idx) => `import _${idx} from '${relative(buildPath, r.path)}'`).join(';\n')}
-${routes
-  .map(
-    (r, idx) => `galbe.routesMetadata = {...${JSON.stringify(r.meta)}}
-_${idx}(galbe)`
-  )
-  .join(';\n')}
-galbe.listen();
-`
-  )
-  return resolve(buildPath, 'index.ts')
-}
-
-program.name('galbe').description('CLI to execute galbe utilities').version('0.1.0')
-
-program
-  .command('dev')
-  .description('Start a dev server running your Galbe application')
-  .argument('<string>', 'filename')
-  .option('-p, --port <number>', 'port number', '')
-  .option('-w, --watch', 'watch file changes', 'true')
-  .action(async (fileName, props) => {
-    const { port, watch } = props
-    const devRoot = resolve(ROOT, '.galbe', 'dev')
-    await mkdir(devRoot, { recursive: true })
-    await Bun.write(
-      resolve(devRoot, 'index.ts'),
-      `import galbe from '${relative(devRoot, fileName)}';galbe.listen(${port});`
-    )
-    process.on('SIGINT', async () => {
-      await rm(resolve(ROOT, '.galbe', 'dev'), { recursive: true })
-    })
-
-    await $`BUN_ENV=development bun run ${watch ? '--watch' : ''} ${resolve(devRoot, 'index.ts')}`.cwd(ROOT)
-  })
-
-program
-  .command('build')
-  .description('undle your Galbe application')
-  .argument('<string>', 'filename')
-  .option('-o, --out <string>', 'output file/directory', '')
-  .option('-c, --compile', 'create a standalone executable', false)
-  .action(async (fileName, props) => {
-    const { out, compile } = props
-    const g: Galbe = (await import(resolve(ROOT, fileName))).default
-    const routes = await parseRoutes(g?.config?.routes)
-    const buildIndex = await createBuildIndex(fileName, routes)
-
-    const cmds = [
-      'bun',
-      'build',
-      buildIndex,
-      '--target',
-      'bun',
-      ...(compile ? ['--compile', '--outfile', out ? out : 'app'] : ['--outdir', out ? out : 'dist'])
-    ].filter(c => c)
-    Bun.spawn(cmds, {
-      cwd: ROOT,
-      stdout: 'inherit',
-      async onExit() {
-        await rm(resolve(ROOT, '.galbe', 'build', BUILD_ID), { recursive: true })
-      }
-    })
-  })
+dev(program.command('dev'))
+build(program.command('build'))
+generate(program.command('generate'))
 
 program.parse()

package/bin/commands/build.ts

@@ -0,0 +1,95 @@
+import { $ } from 'bun'
+
+import { Command, Option } from 'commander'
+import { resolve, relative, dirname } from 'path'
+import { tmpdir } from 'os'
+import { mkdir, rm } from 'fs/promises'
+
+import { CWD, fmtVal, silentExec } from '../util'
+import { Galbe } from '../../src'
+import { defineRoutes } from '../../src/routes'
+import { BuildConfig } from 'bun'
+
+const createBuildIndex = async (indexPath: string, g: Galbe) => {
+  const buildId = crypto.randomUUID()
+  const buildPath = resolve(tmpdir(), buildId)
+  const routes = new Set<string>()
+  let errors: any[] = []
+  await defineRoutes({ routes: g?.config?.routes }, g, ({ type, error, filepath }) => {
+    if (!filepath) return
+    routes.add(filepath)
+    if (type === 'error') errors.push(error)
+  })
+  if (errors.length) throw errors
+  await mkdir(buildPath, { recursive: true })
+  await Bun.write(
+    resolve(buildPath, 'index.ts'),
+    `import galbe from '${relative(buildPath, indexPath)}';
+${[...routes].map((r, idx) => `import _${idx} from '${relative(buildPath, r)}'`).join(';\n')}
+galbe.meta = ${JSON.stringify(g.meta)};
+${[...routes].map((_, idx) => `_${idx}(galbe)`).join(';\n')}
+galbe.listen();
+`
+  )
+  return resolve(buildPath, 'index.ts')
+}
+
+export default (cmd: Command) => {
+  cmd
+    .description('bundle your \x1b[1;30m\x1b[36mGalbe\x1b[0m application')
+    .argument('<index>', 'index file')
+    .addOption(new Option('-o, --out <dir>', 'output directory').default('dist/app', fmtVal('dist/app')))
+    .addOption(new Option('-C, --compile', 'create a standalone executable').default(false, fmtVal(false)))
+    .option('-c, --config <file>', 'bun js or ts config file')
+    .action(async (index, props) => {
+      const { out, compile, config } = props
+
+      const bunfig = config ? (await import(resolve(CWD, config)))?.default || {} : {}
+
+      let error = null
+      process.stdout.write('📦 \x1b[1;30mBuilding \x1b[36mGalbe\x1b[0m\x1b[1;30m app\x1b[0m')
+      let g: Galbe = await silentExec(async () => {
+        try {
+          const g = (await import(resolve(CWD, index))).default
+          return g
+        } catch (err) {
+          error = err
+        }
+      })
+      if (error) {
+        console.log(`\nerror: galbe instance import failed`)
+        console.log(error)
+        return process.exit(1)
+      }
+      let buildIndex: string = ''
+      try {
+        buildIndex = await createBuildIndex(index, g)
+      } catch (errors) {
+        console.log(`\nerror: build errors`)
+        for (let error of errors) console.log(error)
+        return process.exit(1)
+      }
+      if (!buildIndex) {
+        console.log(`\nerror: could not create build index`)
+        return process.exit(1)
+      }
+
+      const buildConfig: BuildConfig = {
+        publicPath: `${resolve(CWD, out)}/`,
+        ...Object.fromEntries(Object.entries(bunfig).filter(([k, v]) => v)),
+        entrypoints: [buildIndex],
+        outdir: resolve(CWD, out),
+        target: 'bun'
+      }
+
+      let bo = await Bun.build(buildConfig)
+      if (bo.success) process.stdout.write(' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+      else {
+        console.log(`\nerror: build errors`)
+        console.log(...bo.logs)
+      }
+      if (compile) await $`bun build --compile ${resolve(CWD, out, 'index.js')} --outfile ${resolve(CWD, out, 'app')}`
+
+      await rm(dirname(buildIndex), { recursive: true })
+    })
+}

package/bin/commands/dev.ts

@@ -0,0 +1,53 @@
+import { $ } from 'bun'
+import { Command, Option } from 'commander'
+import { resolve } from 'path'
+
+import { CWD, fmtInterval, fmtVal, instanciateRoutes, watchDir } from '../util'
+import { Galbe } from '../../src'
+
+const defaultPort = 3000
+
+export default (cmd: Command) => {
+  cmd
+    .description('start a dev server running your \x1b[1;30m\x1b[36mGalbe\x1b[0m application')
+    .argument('<index>', 'index file')
+    .addOption(
+      new Option('-p, --port <number>', `port number ${fmtInterval(1, 65535)}`)
+        .argParser(v => {
+          if (parseInt(v) >= 1 && parseInt(v) <= 65535) return v
+          console.log(`error: port range must be between ${fmtInterval(1, 65535)}`)
+          process.exit(1)
+        })
+        .default(null, fmtVal(defaultPort))
+    )
+    .addOption(new Option('-w, --watch', 'watch file changes').default(false, fmtVal(false)))
+    .addOption(new Option('-nc, --noclear', "don't clear on file changes").default(false, fmtVal(false)))
+    .action(async (index, props) => {
+      const { port, watch, noclear } = props
+      const clear = !noclear
+      const indexPath = resolve(CWD, index)
+      let g: Galbe
+
+      Bun.env.BUN_ENV = 'development'
+
+      if (watch) {
+        await watchDir(
+          CWD,
+          async () => {
+            g.stop()
+            if (clear) await $`clear`
+            Loader.registry.clear()
+            g = (await import(indexPath)).default
+            await instanciateRoutes(g)
+            await g.listen(port)
+          },
+          { ignore: /node_modules/ }
+        )
+      }
+
+      if (watch && clear) await $`clear`
+      g = (await import(indexPath)).default
+      await instanciateRoutes(g)
+      await g.listen(port)
+    })
+}

package/bin/commands/generate/client.ts

@@ -0,0 +1,192 @@
+import { $ } from 'bun'
+import { devNull } from 'os'
+import { Script, createContext } from 'vm'
+import { Command, Option } from 'commander'
+import { resolve, extname } from 'path'
+import { rm } from 'fs/promises'
+import { transformSync } from '@swc/core'
+import { CWD, fmtList, instanciateRoutes, silentExec } from '../../util'
+import { $T, Galbe, GalbeCLICommand, Method, Route } from '../../../src'
+import { walkRoutes } from '../../../src/util'
+import { schemaToTypeStr, Optional, STSchema } from '../../../src/schema'
+
+const clientTargets = ['ts', 'js', 'cli']
+
+export default (cmd: Command) => {
+  cmd
+    .description('generate a \x1b[1;30m\x1b[36mGalbe\x1b[0m client')
+    .argument('<index>', 'index file')
+    .addOption(
+      new Option('-o, --out <file>', 'output file').default(
+        null,
+        fmtList(['dist/client.ts', 'dist/client.js', 'dist/cli'])
+      )
+    )
+    .addOption(
+      new Option('-t, --target <target>', `build target ${fmtList(clientTargets)}`).argParser(v => {
+        if (clientTargets.includes(v)) return v
+        console.log(`error: target must be one of ${fmtList(clientTargets)}`)
+        process.exit(1)
+      })
+    )
+    .action(async (index, props) => {
+      let { target, out } = props
+      if (!target) target = clientTargets.includes(extname(index)?.slice(1)) ? extname(index)?.slice(1) : 'ts'
+      if (!out) out = { ts: 'dist/client.ts', js: 'dist/client.js', cli: 'dist/cli' }[target]
+      let pckg: any = {}
+      try {
+        pckg = await Bun.file(resolve(CWD, 'package.json')).json()
+      } catch (e) {}
+
+      let error = null
+      process.stdout.write('💻 \x1b[1;30mBuilding \x1b[36mGalbe\x1b[0m\x1b[1;30m client\x1b[0m')
+      let g: Galbe = await silentExec(async () => {
+        try {
+          const g = (await import(resolve(CWD, index))).default
+          await instanciateRoutes(g)
+          await g.init()
+          return g
+        } catch (err) {
+          error = err
+        }
+      })
+      if (error) {
+        console.log(`\nerror: galbe instance import failed`)
+        console.log(error)
+        return process.exit(1)
+      }
+
+      const routes: Record<Method, Route[]> = {
+        get: [],
+        post: [],
+        put: [],
+        patch: [],
+        delete: [],
+        options: [],
+        head: []
+      }
+      let commands: GalbeCLICommand[] = []
+      const metaRoutes = g.meta?.reduce(
+        (routes, c) => ({ ...routes, ...c.routes }),
+        {} as Record<string, Record<string, Record<string, any>>>
+      )
+
+      walkRoutes(g.router.routes, r => {
+        let meta = metaRoutes?.[r.path]?.[r.method]
+        let route = {
+          ...r,
+          ...(meta?.operationId ? { alias: meta?.operationId } : {}),
+          pathT: r.path.replaceAll(/:([^\/]+)/g, '${$1}'),
+          params:
+            Object.fromEntries(
+              [...r.path.matchAll(/:([^\/]+)/g)]?.map(m => [
+                m?.[1],
+                {
+                  ...(r.schema?.params?.[m?.[1]] ? { type: schemaToTypeStr(r.schema.params[m[1]]) } : {})
+                }
+              ])
+            ) || {},
+          schemas: {
+            ...(r.schema.headers ? { headers: schemaToTypeStr($T.object(r.schema.headers)) } : {}),
+            ...(r.schema.query ? { query: schemaToTypeStr($T.object(r.schema.query)) } : {}),
+            ...(r.schema.body ? { body: schemaToTypeStr(r.schema.body) } : {}),
+            ...(r.schema.response
+              ? {
+                  response: Object.fromEntries(
+                    Object.entries(r.schema.response).map(([k, v]) => [k === 'default' ? 200 : k, schemaToTypeStr(v)])
+                  )
+                }
+              : {})
+          }
+        }
+        routes[r.method.toLocaleLowerCase()].push(route)
+        if (target === 'cli' && meta?.operationId)
+          commands.push({
+            name: meta.operationId,
+            description: meta.head,
+            route,
+            arguments:
+              Object.entries((r.schema?.params || {}) as Record<string, STSchema>)?.map(([k, p]) => {
+                let type = schemaToTypeStr({ ...p, [Optional]: false })
+                return {
+                  name: k,
+                  type: type === 'boolean' ? '' : `<${type}>`,
+                  description: p?.description || ''
+                }
+              }) || [],
+            options:
+              Object.entries((r.schema?.query || {}) as Record<string, STSchema>)?.map(([k, o]) => {
+                let type = schemaToTypeStr({ ...o, [Optional]: false })
+                return {
+                  name: k,
+                  short: k[0],
+                  type: type === 'boolean' ? '' : `<${type}>`,
+                  description: o?.description || '',
+                  default: o.default
+                }
+              }) || []
+          })
+      })
+
+      if (target === 'js' || target === 'ts') {
+        const file = await Bun.file(resolve(import.meta.dir, '..', '..', 'res', 'client.template.ts')).text()
+        let filled = file.replaceAll(/\/\*\%([\s\S]*?)\%\*\//g, (_match, p) => {
+          let idt = p.match(/^\n*([ \t]*)/, p)?.[1] || ''
+          const script = new Script(p)
+          const sandbox = {
+            console,
+            version: pckg?.version || '0.1.0',
+            routes
+          }
+          createContext(sandbox)
+          let res = script.runInNewContext(sandbox)
+          if (typeof res === 'string') res = res.split('\n')
+          if (Array.isArray(res)) return res.map((s, i) => (i === 0 ? s : `${idt}${s}`)).join('\n')
+          return res ?? ''
+        })
+
+        if (target === 'js') {
+          filled = transformSync(filled, {
+            jsc: {
+              parser: {
+                syntax: 'typescript'
+              },
+              preserveAllComments: true,
+              target: 'esnext'
+            }
+          }).code
+        }
+
+        await Bun.write(out, filled)
+      } else if (target === 'cli') {
+        const file = await Bun.file(resolve(import.meta.dir, '..', '..', 'res', 'cli.template.js')).text()
+
+        // Plugin CLI hook
+        if (commands) for (let p of g.plugins) if (p.cli) await p.cli(commands)
+
+        let filled = file.replaceAll(/\/\*\%([\s\S]*?)\%\*\//g, (_match, p) => {
+          let idt = p.match(/^\n*([ \t]*)/, p)?.[1] || ''
+          const script = new Script(p)
+          const sandbox = {
+            console,
+            name: pckg?.name || 'Galbe app CLI',
+            description: pckg?.description || '',
+            version: pckg?.version || '0.1.0',
+            commands
+          }
+          createContext(sandbox)
+          let res = script.runInNewContext(sandbox)
+          if (typeof res === 'string') res = res.split('\n')
+          if (Array.isArray(res)) return res.map((s, i) => (i === 0 ? s : `${idt}${s}`)).join('\n')
+          return res ?? ''
+        })
+        const buildId = crypto.randomUUID()
+        const buildPath = resolve(CWD, '.galbe', 'client', `${buildId}.js`)
+        await Bun.write(buildPath, filled)
+        await $`bun build --compile ${buildPath} --outfile ${resolve(CWD, out)} > ${devNull} && printf "\u200B"`
+        await rm(resolve(CWD, '.galbe'), { recursive: true })
+      }
+
+      process.stdout.write(' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+    })
+}