galbe 0.13.1 → 0.15.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/bin/commands/generate/model.ts

@@ -125,7 +125,7 @@ export default (cmd: Command) => {
           FROM information_schema.tables
           WHERE table_schema = '${schema}'
           AND table_type = 'BASE TABLE'`)
-        tables = r.map(r => r.table_name)
+        tables = r.map((r: Record<string, string>) => r.table_name)
       }
 
       for (const tableName of tables) {
@@ -133,7 +133,7 @@ export default (cmd: Command) => {
           FROM information_schema.columns
           WHERE table_schema = '${schema}' AND table_name = '${tableName}'`)
         types[tableName] = `type ${toPascalCase(tableName)} = {\n${t
-          .map(r => `  ${r.column_name}: ${TYPE_MAP?.[r.data_type] ?? 'any'}${r.is_nullable ? ' | null' : ''}`)
+          .map((r: Record<string, string>) => `  ${r.column_name}: ${TYPE_MAP?.[r.data_type] ?? 'any'}${r.is_nullable ? ' | null' : ''}`)
           .join(';\n')}\n}`
       }
 

package/bin/res/client.runtime.ts

@@ -0,0 +1,185 @@
+// Inlined into the generated client — no exports
+
+type GalbeClientConfig = {
+  server?: { url?: string }
+  headers?: Record<string, string>
+  fetch?: (req: Request) => Promise<Response>
+}
+
+class GalbeClientError extends Error {
+  readonly status: number
+  readonly headers: Headers
+  readonly body: string
+  constructor(status: number, headers: Headers, body: string) {
+    super(`HTTP ${status}`)
+    this.name = 'GalbeClientError'
+    this.status = status
+    this.headers = headers
+    this.body = body
+  }
+}
+
+const _parseResponse = async (res: Response): Promise<any> => {
+  const ct = res.headers.get('content-type') ?? ''
+  if (ct.includes('application/json')) return res.json()
+  if (ct.includes('application/octet-stream')) return new Uint8Array(await res.arrayBuffer())
+  return res.text()
+}
+
+const _buildUrl = (base: string | undefined, path: string, query?: Record<string, any>): string => {
+  let url = `${base ?? ''}${path}`
+  if (query) {
+    const params = new URLSearchParams()
+    for (const [k, v] of Object.entries(query)) {
+      if (v === undefined || v === null) continue
+      if (Array.isArray(v)) for (const item of v) params.append(k, String(item))
+      else params.set(k, String(v))
+    }
+    const qs = params.toString()
+    if (qs) url += `?${qs}`
+  }
+  return url
+}
+
+const _formdata = (data: Record<string, string | string[] | Blob>): FormData => {
+  const form = new FormData()
+  for (const [k, v] of Object.entries(data)) {
+    if (Array.isArray(v)) for (const item of v) form.append(k, String(item))
+    else form.append(k, v instanceof Blob ? v : String(v))
+  }
+  return form
+}
+
+type _RequestOptions = {
+  query?: Record<string, any>
+  headers?: Record<string, string>
+  contentType?: string
+}
+
+const _doFetch = (
+  config: GalbeClientConfig,
+  method: string,
+  path: string,
+  body?: any,
+  options?: _RequestOptions
+): Promise<Response> => {
+  const url = _buildUrl(config.server?.url, path, options?.query)
+  let bodyInit: BodyInit | undefined
+  const bodyHeaders: Record<string, string> = {}
+
+  if (body !== undefined && body !== null) {
+    const ct = options?.contentType
+    if (ct === 'urlForm') {
+      bodyInit = new URLSearchParams(body).toString()
+      bodyHeaders['content-type'] = 'application/x-www-form-urlencoded'
+    } else if (ct === 'multipart') {
+      bodyInit = _formdata(body)
+    } else if (ct === 'byteArray' || body instanceof Uint8Array) {
+      bodyInit = body
+      bodyHeaders['content-type'] = 'application/octet-stream'
+    } else if (ct === 'text') {
+      bodyInit = String(body)
+      bodyHeaders['content-type'] = 'text/plain'
+    } else {
+      bodyInit = JSON.stringify(body)
+      bodyHeaders['content-type'] = 'application/json'
+    }
+  }
+
+  const req = new Request(url, {
+    method,
+    headers: { ...config.headers, ...bodyHeaders, ...options?.headers },
+    ...(bodyInit !== undefined ? { body: bodyInit } : {}),
+  })
+
+  return (config.fetch ?? fetch)(req)
+}
+
+class GalbeRequest<T, E = any> {
+  #promise: Promise<[Response, Response]>
+  #main?: Promise<T>
+
+  constructor(fetchPromise: Promise<Response>) {
+    this.#promise = fetchPromise.then(res => [res, res.clone()] as [Response, Response])
+  }
+
+  #getMain(): Promise<T> {
+    if (!this.#main) {
+      this.#main = this.#promise.then(async ([res]) => {
+        if (!res.ok) throw new GalbeClientError(res.status, res.headers, await res.text())
+        return _parseResponse(res) as T
+      })
+    }
+    return this.#main
+  }
+
+  then<R1 = T, R2 = never>(
+    onfulfilled?: ((value: T) => R1 | PromiseLike<R1>) | null,
+    onrejected?: ((reason: any) => R2 | PromiseLike<R2>) | null
+  ): Promise<R1 | R2> {
+    return this.#getMain().then(onfulfilled, onrejected)
+  }
+
+  catch<R = never>(
+    onrejected?: ((reason: any) => R | PromiseLike<R>) | null
+  ): Promise<T | R> {
+    return this.#getMain().then(undefined, onrejected)
+  }
+
+  finally(onfinally?: (() => void) | null): Promise<T> {
+    return this.#getMain().finally(onfinally)
+  }
+
+  async safe(): Promise<{ ok: true; data: T } | { ok: false; error: E }> {
+    const [mainRes, cloneRes] = await this.#promise
+    if (mainRes.ok) {
+      return { ok: true, data: (await _parseResponse(cloneRes)) as T }
+    } else {
+      const body = await _parseResponse(cloneRes)
+      return { ok: false, error: { status: mainRes.status, headers: mainRes.headers, body } as E }
+    }
+  }
+}
+
+const _createRequest = <T, E = any>(
+  config: GalbeClientConfig,
+  method: string,
+  path: string,
+  body?: any,
+  options?: _RequestOptions
+): GalbeRequest<T, E> => new GalbeRequest<T, E>(_doFetch(config, method, path, body, options))
+
+const _createRawRequest = async (
+  config: GalbeClientConfig,
+  method: string,
+  path: string,
+  body?: any,
+  options?: _RequestOptions
+): Promise<any> => {
+  const res = await _doFetch(config, method, path, body, options)
+  return {
+    status: res.status,
+    ok: res.ok,
+    redirected: res.redirected,
+    statusText: res.statusText,
+    type: res.type,
+    url: res.url,
+    headers: res.headers,
+    body: {
+      json: () => res.json(),
+      text: () => res.text(),
+      byteArray: () => res.arrayBuffer().then((b: ArrayBuffer) => new Uint8Array(b)),
+      stream: (): AsyncGenerator<Uint8Array, void, unknown> => {
+        const reader = res.body?.getReader()
+        return (async function* () {
+          if (!reader) return
+          while (true) {
+            const { value, done } = await reader.read()
+            if (done) break
+            yield value!
+          }
+        })()
+      },
+    },
+  }
+}

package/bin/res/client.template.ts

@@ -110,7 +110,7 @@ export default class GalbeClient {
                 text: 'text/plain',
                 json: 'application/json',
                 urlForm: 'application/x-www-form-urlencoded',
-              }[options.contentType],
+              }[options.contentType as 'byteArray' | 'text' | 'json' | 'urlForm'],
             }
           : {}),
         ...(options?.headers || {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.13.1",
+  "version": "0.15.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
     }
   }
 }