galbe 0.13.0 → 0.14.0

package/bin/commands/generate/code/route-merge.ts

@@ -0,0 +1,248 @@
+import ts from 'typescript'
+import type { RoutePlanEntry, ScopePlan } from './openapi.parser'
+
+const METHODS = new Set(['get', 'put', 'patch', 'post', 'delete', 'options', 'head'])
+
+export type RouteId = string
+
+export const routeId = (method: string, path: string): RouteId => `${method.toUpperCase()} ${path}`
+
+export type MergeOptions = {
+  /** Delete routes that exist in code but are absent from the plan. Default false (kept as `stale`). */
+  removeStale?: boolean
+  /** Existing route ids (`${METHOD} ${path}`) to leave alone even if absent from plan. */
+  ignore?: Set<RouteId>
+  /** Existing-route id -> new id. Applied before diffing so a renamed route is treated as an update. */
+  rename?: Map<RouteId, RouteId>
+}
+
+export type MergeResult = {
+  content: string
+  added: RouteId[]
+  updated: RouteId[]
+  removed: RouteId[]
+  /** Stale: in code but not in plan, neither removed nor explicitly ignored. */
+  stale: RouteId[]
+}
+
+type ExistingRoute = {
+  origId: RouteId
+  method: string
+  path: string
+  stmt: ts.ExpressionStatement
+  pathArg: ts.StringLiteral
+  schemaArg: ts.Identifier
+  jsdoc: ts.CommentRange | null
+}
+
+type ExistingFile = {
+  text: string
+  sourceFile: ts.SourceFile
+  routes: ExistingRoute[]
+  schemaImport: ts.ImportDeclaration | null
+  bodyOpenBracePos: number | null
+  bodyCloseBracePos: number | null
+}
+
+const importPathForScope = (scopeKey: string): string => {
+  const deepness = scopeKey.split('/').length - 1
+  return `${Array(deepness).fill('../').join('')}schemas${scopeKey}.schema`
+}
+
+const renderFreshRouteFile = (scope: ScopePlan): string => {
+  const importPath = importPathForScope(scope.scopeKey)
+  const rDecl = scope.routes.map(r => `  ${r.meta}\ng.${r.call}`)
+  return (
+    `import { NotImplementedError, type Galbe } from 'galbe'\n` +
+    `import { ${[...scope.routeSchemaImports].sort().join(', ')} } from '${importPath}'\n\n` +
+    `export default (g: Galbe) => {\n` +
+    rDecl.map(d => d.replaceAll('\n', '\n  ')).join('\n\n') +
+    `\n}\n`
+  )
+}
+
+const findLeadingJsDoc = (sf: ts.SourceFile, stmt: ts.Node): ts.CommentRange | null => {
+  const ranges = ts.getLeadingCommentRanges(sf.text, stmt.pos) || []
+  let last: ts.CommentRange | null = null
+  for (const r of ranges) {
+    if (r.kind !== ts.SyntaxKind.MultiLineCommentTrivia) continue
+    const txt = sf.text.slice(r.pos, r.end)
+    if (txt.startsWith('/**')) last = r
+  }
+  return last
+}
+
+const parseExistingFile = (text: string, scope: ScopePlan): ExistingFile => {
+  const sf = ts.createSourceFile('route.ts', text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+
+  const expectedSuffix = `schemas${scope.scopeKey}.schema`
+  let schemaImport: ts.ImportDeclaration | null = null
+  let body: ts.Block | null = null
+
+  for (const stmt of sf.statements) {
+    if (ts.isImportDeclaration(stmt)) {
+      const spec = stmt.moduleSpecifier
+      if (ts.isStringLiteral(spec) && spec.text.endsWith(expectedSuffix)) schemaImport = stmt
+    } else if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
+      const expr = stmt.expression
+      if (ts.isArrowFunction(expr) && ts.isBlock(expr.body)) body = expr.body
+      else if (ts.isFunctionExpression(expr)) body = expr.body
+    }
+  }
+
+  const routes: ExistingRoute[] = []
+  if (body) {
+    for (const stmt of body.statements) {
+      if (!ts.isExpressionStatement(stmt)) continue
+      const call = stmt.expression
+      if (!ts.isCallExpression(call)) continue
+      const fn = call.expression
+      if (!ts.isPropertyAccessExpression(fn)) continue
+      if (!ts.isIdentifier(fn.expression) || fn.expression.text !== 'g') continue
+      if (!ts.isIdentifier(fn.name)) continue
+      const method = fn.name.text.toLowerCase()
+      if (!METHODS.has(method)) continue
+      const args = call.arguments
+      if (args.length < 2) continue
+      const pathArg = args[0]
+      const schemaArg = args[1]
+      if (!ts.isStringLiteral(pathArg)) continue
+      if (!ts.isIdentifier(schemaArg)) continue
+
+      routes.push({
+        origId: routeId(method, pathArg.text),
+        method,
+        path: pathArg.text,
+        stmt,
+        pathArg,
+        schemaArg,
+        jsdoc: findLeadingJsDoc(sf, stmt),
+      })
+    }
+  }
+
+  return {
+    text,
+    sourceFile: sf,
+    routes,
+    schemaImport,
+    bodyOpenBracePos: body ? body.getStart(sf) : null,
+    bodyCloseBracePos: body ? body.end - 1 : null,
+  }
+}
+
+type Edit = { pos: number; end: number; text: string }
+
+const applyEdits = (text: string, edits: Edit[]): string => {
+  // Apply in reverse order of pos so earlier offsets stay valid.
+  const sorted = [...edits].sort((a, b) => b.pos - a.pos || b.end - a.end)
+  let out = text
+  for (const e of sorted) out = out.slice(0, e.pos) + e.text + out.slice(e.end)
+  return out
+}
+
+export const mergeRouteFile = (
+  existing: string | null,
+  scope: ScopePlan,
+  opts: MergeOptions = {}
+): MergeResult => {
+  const removeStale = opts.removeStale ?? false
+  const ignore = opts.ignore ?? new Set<RouteId>()
+  const rename = opts.rename ?? new Map<RouteId, RouteId>()
+
+  const planById = new Map<RouteId, RoutePlanEntry>()
+  for (const r of scope.routes) planById.set(routeId(r.method, r.path), r)
+
+  if (existing === null || existing.trim() === '') {
+    return {
+      content: renderFreshRouteFile(scope),
+      added: [...planById.keys()],
+      updated: [],
+      removed: [],
+      stale: [],
+    }
+  }
+
+  const file = parseExistingFile(existing, scope)
+  const sf = file.sourceFile
+
+  const existingByEffectiveId = new Map<RouteId, ExistingRoute>()
+  for (const er of file.routes) {
+    const effId = rename.get(er.origId) ?? er.origId
+    existingByEffectiveId.set(effId, er)
+  }
+
+  const updates: { er: ExistingRoute; entry: RoutePlanEntry }[] = []
+  const removals: ExistingRoute[] = []
+  const stale: ExistingRoute[] = []
+
+  for (const er of file.routes) {
+    const effId = rename.get(er.origId) ?? er.origId
+    const planEntry = planById.get(effId)
+    if (planEntry) updates.push({ er, entry: planEntry })
+    else if (ignore.has(er.origId)) stale.push(er)
+    else if (removeStale) removals.push(er)
+    else stale.push(er)
+  }
+
+  const additions: RoutePlanEntry[] = []
+  for (const [id, entry] of planById) {
+    if (!existingByEffectiveId.has(id)) additions.push(entry)
+  }
+
+  // Compute final imported schema names.
+  const finalImports = new Set<string>()
+  for (const { entry } of updates) finalImports.add(entry.schemaName)
+  for (const er of stale) finalImports.add(er.schemaArg.text)
+  for (const entry of additions) finalImports.add(entry.schemaName)
+
+  const edits: Edit[] = []
+
+  for (const { er, entry } of updates) {
+    if (er.path !== entry.path) {
+      edits.push({ pos: er.pathArg.getStart(sf), end: er.pathArg.end, text: JSON.stringify(entry.path) })
+    }
+    if (er.schemaArg.text !== entry.schemaName) {
+      edits.push({ pos: er.schemaArg.getStart(sf), end: er.schemaArg.end, text: entry.schemaName })
+    }
+    if (er.jsdoc) {
+      edits.push({ pos: er.jsdoc.pos, end: er.jsdoc.end, text: entry.meta })
+    } else if (entry.meta) {
+      const stmtStart = er.stmt.getStart(sf)
+      edits.push({ pos: stmtStart, end: stmtStart, text: `${entry.meta}\n  ` })
+    }
+  }
+
+  for (const er of removals) {
+    edits.push({ pos: er.stmt.pos, end: er.stmt.end, text: '' })
+  }
+
+  if (file.schemaImport) {
+    const sortedImports = [...finalImports].sort()
+    if (sortedImports.length === 0) {
+      edits.push({ pos: file.schemaImport.pos, end: file.schemaImport.end, text: '' })
+    } else {
+      const importPath = importPathForScope(scope.scopeKey)
+      const newText = `import { ${sortedImports.join(', ')} } from '${importPath}'`
+      edits.push({
+        pos: file.schemaImport.getStart(sf),
+        end: file.schemaImport.end,
+        text: newText,
+      })
+    }
+  }
+
+  if (additions.length > 0 && file.bodyCloseBracePos !== null) {
+    const block = additions.map(a => `\n  ${a.meta}\n  ${`g.${a.call}`.replaceAll('\n', '\n  ')}\n`).join('')
+    edits.push({ pos: file.bodyCloseBracePos, end: file.bodyCloseBracePos, text: block })
+  }
+
+  return {
+    content: applyEdits(existing, edits),
+    added: additions.map(a => routeId(a.method, a.path)),
+    updated: updates.map(u => routeId(u.entry.method, u.entry.path)),
+    removed: removals.map(r => r.origId),
+    stale: stale.map(s => s.origId),
+  }
+}
+

package/bin/commands/generate/code.ts

@@ -2,14 +2,45 @@ import { $ } from 'bun'
 import { devNull } from 'os'
 import { Command, Option } from 'commander'
 import { resolve, relative, extname } from 'path'
-import { rm, exists } from 'fs/promises'
+import { exists, readFile } from 'fs/promises'
 
 import { CWD, fmtList, fmtVal } from '../../util'
-import { generateFromOapi } from './code/openapi.parser'
+import { applyPlan, planFromOapi, type GenerationPlan } from './code/openapi.parser'
+import { mergeRouteFile, type MergeOptions, type RouteId } from './code/route-merge'
 
 const srcTargets = ['ts', 'js']
 const inputFormats = ['openapi:3.0:yaml', 'openapi:3.0:json']
 
+const collectFlag = (value: string, prev: string[] = []) => [...prev, value]
+
+const parseRename = (raw: string): [RouteId, RouteId] => {
+  const eq = raw.indexOf('=')
+  if (eq < 0) throw new Error(`invalid --rename value ${fmtVal(raw)} (expected "OLD=NEW")`)
+  const from = raw.slice(0, eq).trim()
+  const to = raw.slice(eq + 1).trim()
+  if (!from || !to) throw new Error(`invalid --rename value ${fmtVal(raw)}`)
+  return [from, to]
+}
+
+type ScopedDiff = { scope: string; id: RouteId }
+
+const printDiff = (diff: {
+  added: ScopedDiff[]
+  updated: ScopedDiff[]
+  removed: ScopedDiff[]
+  stale: ScopedDiff[]
+}) => {
+  const out = (label: string, prefix: string, items: ScopedDiff[]) => {
+    if (!items.length) return
+    console.log(`${label} (${items.length}):`)
+    for (const x of items) console.log(`  ${prefix} ${x.id}  \x1b[2m(scope: ${x.scope})\x1b[0m`)
+  }
+  out('Added', '\x1b[32m+\x1b[0m', diff.added)
+  out('Updated', '\x1b[33m~\x1b[0m', diff.updated)
+  out('Removed', '\x1b[31m-\x1b[0m', diff.removed)
+  out('Stale (kept in code)', '\x1b[2m·\x1b[0m', diff.stale)
+}
+
 export default (cmd: Command) => {
   cmd
     .description('generate \x1b[1;30m\x1b[36mGalbe\x1b[0m sources')
@@ -33,9 +64,20 @@ export default (cmd: Command) => {
         .default('ts', fmtVal('ts'))
     )
     .addOption(new Option('-o, --out <dir>', 'output dir').default('src', fmtVal('src')))
-    .addOption(new Option('-F, --force', 'force overriding output'))
+    .addOption(new Option('-n, --dry-run', 'show planned changes without writing'))
+    .addOption(new Option('--remove-stale', 'delete routes present in code but absent from spec'))
+    .addOption(
+      new Option('--rename <pair>', '"OLD=NEW" preserve handler when route id changes (repeatable)')
+        .argParser(collectFlag)
+        .default([])
+    )
+    .addOption(
+      new Option('--ignore-route <route>', '"METHOD /path" leave alone if absent from spec (repeatable)')
+        .argParser(collectFlag)
+        .default([])
+    )
     .action(async (input, props) => {
-      let { format, target, out, force } = props
+      let { format, target, out, dryRun, removeStale, rename, ignoreRoute } = props
 
       let inputExt = extname(input)
       if (inputExt === '.yml') inputExt = '.yaml'
@@ -43,34 +85,79 @@ export default (cmd: Command) => {
 
       if (!format) format = `openapi:3.0:${inputExt.slice(1)}`
 
-      if (await exists(resolve(CWD, out))) {
-        if(!force){
-          console.log(
-            `error: output directory ${fmtVal(
-              out
-            )} already exists. If you're sure you want to override its content, please remove it before or use the ${fmtVal(
-              '-F --force'
-            )} option`
-          )
-          process.exit(1)
-        }
-        await rm(resolve(CWD, out), { recursive: true })
+      let renameMap: Map<RouteId, RouteId>
+      try {
+        renameMap = new Map<RouteId, RouteId>((rename as string[]).map(parseRename))
+      } catch (err) {
+        console.log(`error: ${(err as Error).message}`)
+        process.exit(1)
+      }
+      const ignoreSet = new Set<RouteId>((ignoreRoute as string[]).map(s => s.trim()))
+      const mergeOpts: MergeOptions = {
+        removeStale: !!removeStale,
+        rename: renameMap,
+        ignore: ignoreSet,
       }
 
-      Bun.write(Bun.stdout, '💻 \x1b[1;30mGenerating \x1b[36mGalbe\x1b[0m\x1b[1;30m sources\x1b[0m')
+      let plan: GenerationPlan
       try {
         let match = format.match(/^([^:]*):([^:]*):(.*)$/)
-        if (!match) throw new Error(`error: invalid format ${format}`)
+        if (!match) throw new Error(`invalid format ${format}`)
         let [_, kind, version, ext] = match
-        if (kind === 'openapi') {
-          await generateFromOapi(relative(CWD, input), resolve(CWD, out), { version, ext, target })
-        } else throw new Error('error: unknown format')
+        if (kind !== 'openapi') throw new Error('unknown format')
+        plan = await planFromOapi(relative(CWD, input), { version, ext, target })
+      } catch (err) {
+        console.log(`error: ${(err as Error).message}`)
+        process.exit(1)
+      }
+
+      const outDir = resolve(CWD, out)
+
+      // Compute per-scope merge result.
+      const mergeResults: { scopeKey: string; content: string; added: RouteId[]; updated: RouteId[]; removed: RouteId[]; stale: RouteId[] }[] = []
+      for (const scope of plan.scopes) {
+        const routePath = resolve(outDir, `${scope.routeFile}.${target}`)
+        const existing = (await exists(routePath)) ? await readFile(routePath, 'utf-8') : null
+        const r = mergeRouteFile(existing, scope, mergeOpts)
+        mergeResults.push({ scopeKey: scope.scopeKey, ...r })
+      }
+
+      const diff = {
+        added: mergeResults.flatMap(r => r.added.map(id => ({ scope: r.scopeKey, id }))),
+        updated: mergeResults.flatMap(r => r.updated.map(id => ({ scope: r.scopeKey, id }))),
+        removed: mergeResults.flatMap(r => r.removed.map(id => ({ scope: r.scopeKey, id }))),
+        stale: mergeResults.flatMap(r => r.stale.map(id => ({ scope: r.scopeKey, id }))),
+      }
 
-        await $`bunx prettier --write "${resolve(CWD, out)}/**/*.{js,ts}" > ${devNull} && printf "\u200B"`
+      // Block when stale routes need an explicit decision (ignored ones are already resolved).
+      const unresolved = diff.stale.filter(s => !ignoreSet.has(s.id))
+      if (unresolved.length > 0 && !removeStale && !dryRun) {
+        console.log('The following routes exist in code but are not in the spec:')
+        for (const s of unresolved) console.log(`  - ${s.id}  \x1b[2m(scope: ${s.scope})\x1b[0m`)
+        console.log()
+        console.log('Re-run with one of:')
+        console.log(`  ${fmtVal('--rename "OLD=NEW"')}          treat as a rename, preserve handler`)
+        console.log(`  ${fmtVal('--ignore-route "ROUTE"')}      leave alone, keep as user-managed`)
+        console.log(`  ${fmtVal('--remove-stale')}              confirm deletion of stale routes`)
+        process.exit(1)
+      }
+
+      if (dryRun) {
+        console.log('\x1b[1;30mDry run — no files will be written.\x1b[0m')
+        printDiff(diff)
+        return
+      }
+
+      Bun.write(Bun.stdout, '💻 \x1b[1;30mGenerating \x1b[36mGalbe\x1b[0m\x1b[1;30m sources\x1b[0m')
+      try {
+        const routeContents = new Map(mergeResults.map(r => [r.scopeKey, r.content]))
+        await applyPlan(plan, outDir, { routeContents })
+        await $`bunx prettier --write "${outDir}/**/*.{js,ts}" > ${devNull} && printf "​"`
       } catch (err) {
-        console.log(`error: ${err.message}`)
+        console.log(`error: ${(err as Error).message}`)
         process.exit(1)
       }
       Bun.write(Bun.stdout, ' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')
+      printDiff(diff)
     })
 }

package/bin/commands/generate/index.ts

@@ -4,6 +4,7 @@ import client from './client'
 import spec from './spec'
 import code from './code'
 import model from './model'
+import cli from './cli/index'
 
 export default (cmd: Command) => {
   cmd.description('generate util')
@@ -11,4 +12,5 @@ export default (cmd: Command) => {
   client(cmd.command('client'))
   code(cmd.command('code'))
   model(cmd.command('model'))
+  cli(cmd.command('cli'))
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",
@@ -61,6 +61,9 @@
     "github": {
       "requireBranch": "main",
       "release": "true"
+    },
+    "npm": {
+      "publish": false
     }
   }
 }

package/src/cookies.ts

@@ -0,0 +1,87 @@
+export type CookieOptions = {
+  path?: string
+  maxAge?: number
+  httpOnly?: boolean
+  sameSite?: true | false | 'lax' | 'strict' | 'none'
+  secure?: boolean
+  domain?: string
+  expires?: Date
+}
+export const parseCookie = (str: string) => {
+  type Cookie = {
+    name: string
+    value: string
+  } & CookieOptions
+  let cookie: Cookie = { name: '', value: '', path: '/' }
+  const entries = str.match(/([^=;\s]+)(?:=([^;]*))?/g)
+  if (entries) {
+    for (const [idx, entry] of entries.entries()) {
+      const [_, key, val] = [...(entry.match(/([^=]+)(?:=(.*))?/) || [])]
+      if (idx === 0) {
+        cookie.name = key
+        cookie.value = val
+      } else {
+        switch (key) {
+          case 'Path':
+            cookie.path = val
+            break
+          case 'Max-Age':
+            cookie.maxAge = parseInt(val)
+            break
+          case 'HttpOnly':
+            cookie.httpOnly = true
+            break
+          case 'SameSite':
+            cookie.sameSite =
+              ({ true: true, false: false, lax: 'lax', strict: 'strict', none: 'none' } as const)[
+              val?.toLowerCase() || 'true'
+              ] || true
+            break
+          case 'Secure':
+            cookie.secure = true
+            break
+          case 'Domain':
+            cookie.domain = val
+            break
+          case 'Expires':
+            cookie.expires = new Date(val)
+            break
+        }
+      }
+    }
+  }
+  return cookie
+}
+export const stringifyCookie = (name: string, value: string, opt: CookieOptions = { path: '/' }) => {
+  const sameSite =
+    typeof opt.sameSite === 'string'
+      ? ` SameSite=${capitalize(opt.sameSite)};`
+      : opt.sameSite === true
+        ? ' SameSite=Lax;'
+        : ''
+  return (
+    `${name}=${value};` +
+    ` path=${opt.path || '/'};` +
+    (opt.domain ? ` Domain=${opt.domain};` : '') +
+    (typeof opt.maxAge === 'number' ? ` Max-Age=${Math.floor(opt.maxAge)};` : '') +
+    (opt.expires ? ` Expires=${opt.expires.toUTCString()};` : '') +
+    (opt.secure ? ' Secure;' : '') +
+    sameSite +
+    (opt.httpOnly ? ' HttpOnly;' : '')
+  )
+}
+
+function capitalize(str?: string) {
+  if (!str) return ''
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+export const readCookies = (cookies?: string | null) => {
+  if (!cookies) return {}
+  return Object.fromEntries(
+    cookies.split(';').map(c => {
+      const [name, ...value] = c.split('=')
+      return [name.trim(), value.join('=').trim()]
+    })
+  )
+}