galbe 0.3.0 → 0.5.0

package/bin/res/cli.template.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env bun
+
+import { program, Option } from 'commander'
+import { resolve } from 'path'
+
+const DEFAULT_HEADERS = {
+  'user-agent': 'Galbe//*%(()=>version)()%*//cli'
+}
+const ansi = (p, c, str) => (p ? `\x1b[${c}m${str}\x1b[0m` : str)
+
+const fmtObject = (o, p = false, idt = 2, iidt = 0) => {
+  let _ = ' '.repeat(iidt)
+  let __ = ' '.repeat(iidt + idt)
+  let lr = idt === 0 ? '' : '\n'
+  if (o === null) return ansi(p, '38;2;255;128;0', 'null')
+  if (typeof o === 'boolean') return o ? ansi(p, '38;2;255;128;0', 'true') : ansi(p, '38;2;255;128;0', 'false')
+  if (typeof o === 'number') return ansi(p, '38;2;10;180;220', o)
+  if (typeof o === 'string') return ansi(p, '38;2;125;170;0', `"${o}"`)
+  if (typeof o === 'object') {
+    if (Array.isArray(o))
+      return `[${lr}${o.map(e => `${__}${fmtObject(e, p, idt, iidt + idt)}`).join(`,${lr}`)}${lr}${_}]`
+    return `{${lr}${Object.entries(o)
+      .map(([k, v]) =>
+        v === undefined ? '' : `${__}${ansi(p, '38;2;170;120;200', `"${k}"`)}: ${fmtObject(v, p, idt, iidt + idt)}`
+      )
+      .filter(l => l)
+      .join(`,${lr}`)}${lr}${_}}`
+  }
+}
+const fmtRes = (r, p = false) => {
+  if (typeof r === 'object') {
+    try {
+      let resp = fmtObject(r, p, 2)
+      return process.stdout.write(`${resp}\n`)
+    } catch (err) {
+      console.error(err)
+      return process.stdout.write(`${r}\n`)
+    }
+  }
+  if (!p) return process.stdout.write(`${r}\n`)
+  if (typeof r === 'boolean') return process.stdout.write(`${ansi(p, '38;2;255;128;0', r)}\n`)
+  if (typeof r === 'number') return process.stdout.write(`${ansi(p, '38;2;10;180;220', r)}\n`)
+  if (typeof r === 'string') return process.stdout.write(`${ansi(p, '38;2;125;170;0', r)}\n`)
+  return process.stdout.write(`${r}\n`)
+}
+
+const fetchApi = async (method, path, props) => {
+  let headers = Object.fromEntries(props?.['%header'].map(s => s.split('=')))
+  let queryParam = Object.fromEntries(props?.['%query'].map(s => s.split('=')))
+  let body = props?.['%body']
+  let bodyFile = props?.['%bodyFile']
+  let format = new Set(props?.['%format'])
+
+  delete props?.['%header']
+  delete props?.['%query']
+  delete props?.['%body']
+  delete props?.['%bodyFile']
+  delete props?.['%format']
+
+  const queryString = Object.entries({ ...queryParam, ...props })
+    .map(([k, v]) => encodeURIComponent(k) + '=' + encodeURIComponent(v))
+    .join('&')
+
+  if (!Bun.env.GCLI_SERVER_URL) {
+    console.error('error: Missing GCLI_SERVER_URL env')
+    return process.exit(1)
+  }
+  let url = `${Bun.env.GCLI_SERVER_URL}${path}?${queryString}`
+  if (bodyFile) body = await Bun.file(resolve(process.cwd(), bodyFile)).arrayBuffer()
+  let startTime = Bun.nanoseconds()
+  let res = await fetch(url, {
+    method,
+    headers: {
+      ...DEFAULT_HEADERS,
+      ...(bodyFile ? { 'content-type': 'application/octet-stream' } : {}),
+      ...(headers || {})
+    },
+    ...(body ? { body } : {})
+  })
+  let endTime = Bun.nanoseconds() - startTime
+  if (format.has('s')) fmtRes(res.status, format.has('p'))
+  if (format.has('h')) fmtRes(Object.fromEntries(res.headers.entries()), format.has('p'))
+  if (format.has('b')) {
+    let isJson = res.headers.get('content-type') === 'application/json'
+    if (isJson) fmtRes(await res.json(), format.has('p'))
+    else if (res.headers.get('content-type')?.match(/^text\//)) fmtRes(await res.text(), format.has('p'))
+    else process.stdout.write(await res.arrayBuffer())
+  }
+  if (format.has('t')) process.stdout.write(`${(endTime / 1_000_000).toFixed(2)}ms\n`)
+  process.exit(res.ok ? 0 : 1)
+}
+
+program.name('/*%(()=>name)()%*/').description('/*%(()=>description)()%*/').version('/*%(()=>version)()%*/')
+/*%
+const formatDefault = def =>
+  typeof def === 'string'
+    ? `\`${def}\``
+    : Array.isArray(def)
+    ? `[${def.map(d => formatDefault(d)).join(',')}]`
+    : def ?? 'undefined';
+
+result = commands.map(c=>{
+  let args = c.arguments.map(a=>`.argument("${a.type}", "${a.description}")`)
+  let optionsBase = [
+    {name: '%format', short:'%f', type: '[string]', description: 'response format [\'s\',\'h\',\'b\',\'t\',\'p\']', default:["s","b","p"]},
+    {name: '%header', short:'%h', type: '<string...>', description: 'request header formated as headerName=headerValue', default:[]},
+    {name: '%query', short:'%q', type: '<string...>', description: 'query param formated as paramName=paramValue', default:[]},
+    {name: '%body', short:'%b', type: '<string>', description: 'request body', default:''},
+    {name: '%bodyFile', short:'%bf', type: '<path>', description: 'request body file', default:''}
+  ]
+  let options = [...optionsBase,...(c.options||[])].map(o=>`.addOption(new Option("-${o.short}, --${o.name} ${o.type}", "${o.description}").default(${formatDefault(o.default)}))`)
+  let action = `.action(async (${c.arguments.map(a=>`${a.name},`)} props) => {
+    ${c.action ? ';('+c.action.toString()+')(props)' : ''}
+    return await fetchApi("${c.route.method.toUpperCase()}",\`${c.route.pathT}\`, props)
+  })`
+  return `program.command("${c.name}").description("${c.description}")${args.join('')}${options.join('')}${action}`
+})
+%*/
+
+program.parse()

package/bin/res/client.template.ts

@@ -0,0 +1,161 @@
+export type GalbeClientMode = 'response' | 'direct'
+export type GalbeClientConfig = {
+  server?: { url?: string }
+}
+
+export const Kind = Symbol.for('json.string')
+type Json<T> = { T: T }
+
+interface GR<S extends number = number, B = any, OKS extends number = OKStatusCode> {
+  status: S
+  ok: S extends OKS ? true : false
+  redirected: boolean
+  statusText: string
+  type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect'
+  url: string
+  headers: Headers
+  body: <ST extends boolean = false>(
+    stream?: ST
+  ) => B extends Uint8Array
+    ? ST extends true
+      ? Promise<AsyncGenerator<Uint8Array, void, unknown>>
+      : B extends Json<infer T>
+      ? Promise<T>
+      : Promise<B>
+    : B extends string
+    ? ST extends true
+      ? Promise<AsyncGenerator<string, void, unknown>>
+      : B extends Json<infer T>
+      ? Promise<T>
+      : Promise<B>
+    : B extends Json<infer T>
+    ? Promise<T>
+    : Promise<B>
+}
+
+export type OKStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226
+// prettier-ignore
+export type HttpStatusCode = 100|101|102|103|OKStatusCode|300|301|302|303|304|305|307|308|400|401|402|403|404|405|406|407|408|409|410|411|412|413|414|415|416|417|418|421|422|423|424|426|428|429|431|451|500|501|502|503|504|505|506|507|508|510|511
+type PGR<
+  S extends number = number,
+  B = any,
+  O extends number = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226
+> = Promise<GR<S, B, O>>
+
+type RequestOptions<H = any, B = any> = {
+  headers?: H
+  body?: B
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD'
+}
+
+const decoder = new TextDecoder()
+const DEFAULT_HEADERS = {
+  'user-agent': 'Galbe//*%(()=>version)()%*/'
+}
+
+export default class GalbeClient {
+  config?: GalbeClientConfig
+
+  /*%
+  Object.entries(routes).map(([method, list])=>{
+    return`${method} = {\n${list.map( r => {
+      let p = Object.entries(r.params)
+      let schemas = Object.keys(r.schemas).length ?
+        `<${r.schemas.headers??'any'},${r.schemas.body??'any'}>`: 
+        ''
+      let oks = Object.keys(r.schemas?.response||{}).filter(s=>s>=200&&s<300)
+      let responses = Object.keys(r.schemas?.response||{}).length ?
+        `${Object.entries(r.schemas.response).map(([k,v])=>`PGR<${k},${v}${oks?.length?`,${oks.join('|')}`:''}>`).join('|')}|PGR<Exclude<HttpStatusCode,${Object.keys(r.schemas.response).join('|')}>,any${oks?.length?`,${oks.join('|')}`:''}>`: 
+        `PGR<HttpStatusCode,any${oks?.length?`,${oks.join('|')}`:',any'}>`
+      return `  '${r.path}':(${p.length?p.map(([k,v])=>`${k}:${v.type}`).join(',')+', ':''}options:RequestOptions${schemas}={})=>this.fetch(\`${r.pathT}\`,{...options,method:'${r.method.toUpperCase()}'}) as ${responses}`
+    }).join(',\n')}\n}`
+  }).join('\n')
+  %*/
+
+  constructor(config?: GalbeClientConfig) {
+    //@ts-ignore
+    this.config = { mode: 'response', ...config }
+  }
+
+  async fetch(path: string, options: RequestOptions) {
+    let url = `${this?.config?.server?.url ?? ''}${path}`
+    let res = await fetch(url, {
+      method: options?.method || 'GET',
+      headers: { ...DEFAULT_HEADERS, ...(options?.headers || {}) },
+      ...(options?.body ? { body: JSON.stringify(options.body) } : {})
+    })
+    return {
+      headers: res.headers,
+      ok: res.ok,
+      redirected: res.redirected,
+      status: res.status,
+      statusText: res.statusText,
+      type: res.type,
+      url: res.url,
+      body: async (stream = false) => {
+        if (res.headers.get('content-type') === 'application/json') return res.json()
+        else if (res.headers.get('content-type') === 'text/event-stream') {
+          const reader = res.body?.getReader()
+          return async function* () {
+            while (reader) {
+              const { value, done } = await reader.read()
+              if (done) break
+              yield decoder.decode(value)
+            }
+          }
+        } else if (res.headers.get('content-type')?.match(/^text\//)) {
+          if (stream) {
+            const reader = res.body?.getReader()
+            return (async function* () {
+              while (reader) {
+                const { value, done } = await reader.read()
+                if (done) break
+                yield decoder.decode(value)
+              }
+            })()
+          } else return res.text()
+        } else if (res.headers.get('content-type') === 'application/octet-stream') {
+          const reader = res.body?.getReader()
+          if (stream) {
+            return (async function* () {
+              while (reader) {
+                const { value, done } = await reader.read()
+                if (done) break
+                yield value
+              }
+            })()
+          } else {
+            let body = new Uint8Array()
+            while (reader) {
+              const { value, done } = await reader.read()
+              if (done) break
+              let buff = new Uint8Array(body.length + value.length)
+              buff.set(body)
+              buff.set(value, body.length)
+              body = buff
+            }
+            return body
+          }
+        }
+        return res.body
+      }
+    }
+  }
+
+  // Aliases
+  /*%
+  Object.entries(routes).map(([method, list])=>{
+    return list.filter(r=>r.alias).map(r => {
+      let p = Object.entries(r.params)
+      let schemas = Object.keys(r.schemas).length ?
+        `<${r.schemas.headers??'any'},${r.schemas.body??'any'}>`: 
+        ''
+      let oks = Object.keys(r.schemas?.response||{}).filter(s=>s>=200&&s<300)
+      let responses = Object.keys(r.schemas?.response||{}).length ?
+        `${Object.entries(r.schemas.response).map(([k,v])=>`PGR<${k},${v}${oks?.length?`,${oks.join('|')}`:''}>`).join('|')}|PGR<Exclude<HttpStatusCode,${Object.keys(r.schemas.response).join('|')}>,any${oks?.length?`,${oks.join('|')}`:''}>`: 
+        `PGR<HttpStatusCode,any${oks?.length?`,${oks.join('|')}`:',any'}>`
+      return `${r.alias}(${p.length ? p.map(([k,v])=>`${k}: ${v.type}`).join(', ')+', ':''}options: RequestOptions${schemas} = {}){return this.fetch(\`${r.pathT}\`, {...options, method: '${r.method.toUpperCase()}'}) as ${responses}}\n`
+    }).join('  ')
+  })
+  %*/
+}

package/bin/util.ts

@@ -0,0 +1,164 @@
+import { relative } from 'path'
+import { watch } from 'chokidar'
+import { Galbe, Route } from '../src'
+import { logRoute, walkRoutes } from '../src/util'
+import { RouteMeta, defineRoutes } from '../src/routes'
+
+export { default as pckg } from '../package.json'
+
+export const CWD = process.cwd()
+export const WATCH_IGNORE = /\.galbe/
+
+export const fmtVal = (v: any) => {
+  if (typeof v === 'boolean') return `\x1b[3${v ? '2' : '1'}m${v}\x1b[0m`
+  if (typeof v === 'string') return `\x1b[33m${v}\x1b[0m`
+  if (typeof v === 'number') return `\x1b[36m${v}\x1b[0m`
+  return v
+}
+export const fmtList = (l: any) => `[${l.map(v => fmtVal(v)).join(', ')}]`
+export const fmtInterval = (a: any, b: any) => `[${fmtVal(a)}-${fmtVal(b)}]`
+
+export const silentExec = async (fn: () => any) => {
+  let consoleMock = Object.fromEntries(
+    Object.entries(console)
+      .filter(([_, v]) => typeof v === 'function')
+      .map(([k, _]) => [k, () => {}])
+  )
+  const _console = console
+  const _processStdoutWrite = process.stdout.write
+  const _processStderrWrite = process.stderr.write
+  //@ts-ignore
+  global.console = consoleMock
+  //@ts-ignore
+  process.stdout.write = function () {}
+  //@ts-ignore
+  process.stderr.write = function () {}
+  const r = await fn()
+  global.console = _console
+  process.stdout.write = _processStdoutWrite
+  process.stderr.write = _processStderrWrite
+  return r
+}
+export const watchDir = async (
+  path: string,
+  callback: (event: {
+    path: string | null
+    eventType: 'change' | 'add' | 'addDir' | 'unlink' | 'unlinkDir'
+  }) => any | Promise<any>,
+  options?: { ignore?: RegExp }
+) => {
+  let watcher = watch(path, {
+    persistent: false,
+    ignored: options?.ignore,
+    ignoreInitial: true
+  })
+  watcher.on('all', async (eventType, filename) => {
+    if (filename.match(WATCH_IGNORE)) return
+    await callback({ path: filename.toString(), eventType })
+  })
+}
+export const instanciateRoutes = async (g: Galbe) => {
+  console.log('🏗️  \x1b[1;30mConstructing routes\x1b[0m\n')
+  // Main thread routes definitions
+  let hasMainRoutes = false
+  walkRoutes(g.router.routes, r => {
+    hasMainRoutes = true
+    logRoute(r)
+  })
+  if (hasMainRoutes) process.stdout.write('\n')
+  // Route Files Analysis
+  let routes: Record<string, { route?: Route; meta?: RouteMeta; error?: any }[]> = {}
+  let errors: Record<string, any> = {}
+  await defineRoutes({ routes: g?.config?.routes }, g, ({ type, route, error, filepath, meta }) => {
+    if (!filepath) return
+    if (!(filepath in routes)) routes[filepath] = []
+    if (type === 'add' && route && filepath) routes[filepath].push({ route, meta })
+    if (type === 'error') errors[filepath] = error
+  })
+  for (let [fp, e] of Object.entries(routes)) {
+    console.log(`\x1b\[0;36m    ${relative(CWD, fp)}\x1b[0m`)
+    let maxPathLength = e.reduce((p, c) => {
+      return Math.max(p, c.route?.path.length || 0)
+    }, 0)
+    for (let r of e) {
+      if (r.route) logRoute(r.route, r.meta, { maxPathLength })
+    }
+    if (errors?.[fp]) {
+      console.log(`\x1b\[0;31m    Error:\x1b[0m`)
+      console.log(errors?.[fp])
+    }
+    process.stdout.write('\n')
+  }
+  console.log('\x1b[1;30m\x1b[32mdone\x1b[0m\n')
+}
+
+export const softMerge = (base, override) => {
+  for (const key in override) {
+    if (override[key] instanceof Object && !(override[key] instanceof Array)) {
+      if (!base[key]) Object.assign(base, { [key]: {} })
+      softMerge(base[key], override[key])
+    } else Object.assign(base, { [key]: override[key] })
+  }
+  return base
+}
+
+export const HttpStatus = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Moved Temporarily',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Request Entity Too Large',
+  414: 'Request-URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Requested Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a teapot",
+  419: 'Insufficient Space on Resource',
+  420: 'Method Failure',
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  507: 'Insufficient Storage',
+  511: 'Network Authentication Required'
+}

package/docs/plugins.md

@@ -17,7 +17,7 @@ type GalbePlugin = {
 
 **name**
 
-The name should be a Unique Plugin Identifier. It should be chosen to be unique to avoid conflicts with other potential plugins. For example, Galbe's official plugins names will always start with `dev.galbe.*`.
+The name should be a Unique Plugin Identifier. It should be chosen to be unique to avoid conflicts with other potential plugins. Ideally, it will have the form of `com.example.myplugin`.
 
 **init**
 
@@ -62,44 +62,44 @@ Here is an example of a plugin implementation that handles routes tagged with `@
 
 ```ts
 // myPlugin.ts
-
-import { Galbe, type Context, type Route } from 'galbe'
-
-class MyPlugin {
-  name = 'dev.galbe.example'
-  deprecated: Record<string, string[]> = {}
-  // Retrieve and store all route with a @deprecated flag metadata
-  init(config: any, galbe: Galbe) {
-    if (config?.enabled && galbe.meta) {
-      for (const f of galbe.meta) {
-        for (const [path, methods] of Object.entries(f.routes)) {
-          for (const [method, meta] of Object.entries(methods)) {
-            if (meta.deprecated) {
-              if (!this.deprecated?.[method]) this.deprecated[method] = []
-              this.deprecated[method].push(path)
-            }
-          }
-        }
+import type { GalbePlugin } from 'galbe'
+import { walkMetaRoutes } from 'galbe/utils'
+
+const PLUGIN_ID = 'dev.galbe.deprecated'
+
+export default () => {
+  let deprecateds = new Set<string>()
+  return {
+    name: PLUGIN_ID,
+    // Init the plugin, check for deprecated metadata tags
+    init(_config, galbe) {
+      if (galbe.meta) {
+        walkMetaRoutes(galbe.meta, (method, path, meta) => {
+          if (meta.deprecated) deprecateds.add(JSON.stringify({ method, path }))
+        })
+      }
+    },
+    // Check if the current route is deprecated; if so, flag it as such and log it
+    onRoute(context) {
+      let r = context.route
+      if (!r) return
+      if (deprecateds.has(JSON.stringify({ method: r.method, path: r.path }))) {
+        context.state[PLUGIN_ID] = { deprecated: true }
+        console.warn(`Call to deprecated route "${r.method} ${r.path}"`)
+      }
+    },
+    // Add a header to the response if the route has been flagged as deprecated
+    afterHandle(response, context) {
+      let r = context.route
+      if (!r) return
+      console.log('yooo', r.method, r.path)
+      if (deprecateds.has(JSON.stringify({ method: r.method, path: r.path }))) {
+        console.log('OK...')
+        response.headers.set('x-deprecated', 'true')
       }
     }
-  }
-  // Check if the current route is deprecated; if so, flag it as such and log it
-  onRoute(context: Context) {
-    let route = context.route
-    if (this.deprecated?.[route.method]?.includes(route.path)) {
-      context.state[this.name] = { deprecated: true }
-      console.warn(`Call to deprecated route [${route.method}]${route.path}`)
-    }
-  }
-  // Add a header if the request has previously been flagged as deprecated
-  afterHandle(response: Response, context: Context) {
-    if (context.state?.[this.name]?.deprecated) {
-      response.headers.set('x-deprecated', 'true')
-    }
-  }
+  } as GalbePlugin
 }
-
-export default new MyPlugin()
 ```
 
 ```ts

package/docs/routes.md

@@ -10,7 +10,7 @@ Here is how to define routes in Galbe.
 galbe.[method](path: string, schema?: Schema, hooks?: Hooks[], handler: Handler)
 ```
 
-**method** ( get | post | put | delete | patch | options )
+**method** ( get | post | put | delete | patch | options | head )
 
 The [HTTP Request Method](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) for the defined route.
 
@@ -114,8 +114,8 @@ export default g => {
   /**
    * This is a route head comment
    * @deprecated
-   * @tag tag1
-   * @tag tag2
+   * @operationId fooBar
+   * @tags tag1 tag2
    */
   g.get('/foo/:bar', ctx => ctx.params.bar)
 }

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "galbe",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",
   "bin": "./bin/cli.ts",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./src/index.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./*": "./dist/*.js"
+    ".": "./src/index.ts",
+    "./schema": "./src/schema.ts",
+    "./extras": "./src/extras.ts",
+    "./utils": "./src/util.ts"
   },
   "repository": {
     "type": "git",
@@ -27,14 +28,13 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "bun ./scripts/build.ts",
-    "clean": "rm -rf dist",
     "test": "bun test",
     "postinstall": "bun run ./scripts/postinstall.ts",
     "release": "release-it"
   },
   "devDependencies": {
     "@types/bun": "^1.0.4",
+    "openapi-types": "^12.1.3",
     "release-it": "^17.1.1"
   },
   "peerDependencies": {
@@ -45,7 +45,9 @@
     "@swc/wasm": "^1.4.0",
     "acorn": "^8.11.2",
     "acorn-walk": "^8.3.0",
-    "commander": "^11.1.0"
+    "chokidar": "^3.6.0",
+    "commander": "^11.1.0",
+    "js-yaml": "^4.1.0"
   },
   "release-it": {
     "git": {

package/scripts/postinstall.ts

@@ -1,5 +1,5 @@
 import { $ } from 'bun'
-import { existsSync } from 'node:fs'
+import { existsSync } from 'fs'
 
 if (existsSync('.git')) {
   console.log('Setting up dev environment')
@@ -7,5 +7,3 @@ if (existsSync('.git')) {
   await $`chmod +x .git/hooks/prepare-commit-msg`
   console.log('done')
 }
-
-await $`bun run build`