galbe 0.12.2 → 0.13.1

package/bin/commands/generate/code/openapi.parser.ts

@@ -1,7 +1,6 @@
 import { semver } from 'bun'
 import { transformSync } from '@swc/core'
 import { resolve, relative, dirname } from 'path'
-import { load as ymlLoad } from 'js-yaml'
 import { OpenAPIV3 } from 'openapi-types'
 import { inferBodyType } from '../../../../src/util'
 
@@ -125,8 +124,6 @@ const parseOapiSchema = (
   let optArg = hasOptions ? serialize(options) : ''
   let anyOf = os.oneOf || os.anyOf
   let allOf = os.allOf
-  let required = os.required
-  let nullable = os.nullable
 
   if (os.discriminator) {
     const propName = os.discriminator.propertyName
@@ -176,7 +173,11 @@ const parseOapiSchema = (
     resp = `$T.integer(${hasOptions ? serialize(options) : ''})`
   } else if (os.type === 'string') {
     if (os.format === 'binary') resp = `$T.byteArray(${hasOptions ? serialize(options) : ''})`
-    else {
+    else if (os.enum?.length === 1) {
+      resp = `$T.literal("${os.enum[0]}")`
+    } else if (os.enum?.length) {
+      resp = `$T.union([${os.enum.map(v => `$T.literal("${v}")`).join(', ')}])`
+    } else {
       let minLength = os.minLength
       let maxLength = os.maxLength
       let pattern = os.pattern
@@ -192,7 +193,16 @@ const parseOapiSchema = (
     resp = `$T.array(${parseOapiSchema(os?.items)}, ${optArg})`
   } else if (os.type === 'object') {
     let props = Object.entries(os?.properties || {})
-      .map(([k, v]) => `"${k}":${parseOapiSchema(v)}`)
+      .map(([k, v]) => {
+        v = v as OpenAPIV3.SchemaObject
+        const w = (s: string) => {
+          if (!v.required && v.nullable) return `$T.nullish(${s})`
+          else if (!v.required) return `$T.optional(${s})`
+          else if (v.nullable) return `$T.nullable(${s})`
+          return s
+        }
+        return `"${k}":${w(parseOapiSchema(v))}`
+      })
       .join(',')
     if (extra?.media === 'multipart/form-data') {
       resp = `$T.multipartForm({${props}}${optArg ? `, ${optArg}` : ''})`
@@ -203,10 +213,6 @@ const parseOapiSchema = (
     }
   } else throw new Error(`Unknown schema type ${JSON.stringify(os)}`)
 
-  if (!required && nullable) resp = `$T.nullish(${resp})`
-  else if (!required) resp = `$T.optional(${resp})`
-  else if (nullable) resp = `$T.nullable(${resp})`
-
   return resp
 }
 
@@ -452,7 +458,7 @@ const writeFiles = async (
           imports[depOrig].push(depName)
         }
       }
-      decl.push(`export const ${s.key} = ${s.schema}\nexport type T${s.key} = Static<typeof ${s.key}>\n`)
+      decl.push(`export const ${s.key} = ${s.schema}\nexport type ${s.key} = Static<typeof ${s.key}>\n`)
     })
     if (decl.length === 0) return ''
     return `import type { Static } from 'galbe/schema'\nimport { $T } from 'galbe'\n${Object.entries(imports)
@@ -539,7 +545,8 @@ export const generateFromOapi = async (
   out: string,
   { version, ext, target }: { version: string; ext: 'json' | 'yaml'; target: 'js' | 'ts' }
 ) => {
-  let def: OpenAPIV3.Document = ext === 'json' ? await Bun.file(input).json() : ymlLoad(await Bun.file(input).text())
+  let def: OpenAPIV3.Document =
+    ext === 'json' ? await Bun.file(input).json() : Bun.YAML.parse(await Bun.file(input).text())
 
   let v = def?.openapi
   if (!v || !semver.satisfies(v, version)) throw new Error('Invalid openapi version')

package/bin/commands/generate/index.ts

@@ -3,10 +3,12 @@ import { Command } from 'commander'
 import client from './client'
 import spec from './spec'
 import code from './code'
+import model from './model'
 
 export default (cmd: Command) => {
   cmd.description('generate util')
-  client(cmd.command('client'))
   spec(cmd.command('spec'))
+  client(cmd.command('client'))
   code(cmd.command('code'))
+  model(cmd.command('model'))
 }

package/bin/commands/generate/model.ts

@@ -0,0 +1,153 @@
+import { Command, Option } from 'commander'
+import { fmtVal, toPascalCase } from '../../util'
+import { SQL } from 'bun'
+import { mkdirSync } from 'fs'
+import path from 'path'
+
+const TYPE_MAP: Record<string, string> = {
+  // --- Postgres + MySQL numerics ---
+  smallint: 'number',
+  integer: 'number',
+  int: 'number',
+  int2: 'number',
+  int4: 'number',
+  int8: 'number',
+  bigint: 'bigint', // or 'number' ?
+  decimal: 'number',
+  numeric: 'number',
+  real: 'number',
+  float: 'number',
+  float4: 'number',
+  float8: 'number',
+  double: 'number',
+  'double precision': 'number',
+  serial: 'number',
+  bigserial: 'number',
+  smallserial: 'number',
+  tinyint: 'number',
+  mediumint: 'number',
+  bit: 'number',
+
+  // --- Strings ---
+  text: 'string',
+  'character varying': 'string',
+  varchar: 'string',
+  character: 'string',
+  char: 'string',
+  citext: 'string',
+  enum: 'string',
+  set: 'string',
+  tinytext: 'string',
+  mediumtext: 'string',
+  longtext: 'string',
+
+  // --- Binary ---
+  bytea: 'Buffer',
+  blob: 'Buffer',
+  tinyblob: 'Buffer',
+  mediumblob: 'Buffer',
+  longblob: 'Buffer',
+  binary: 'Buffer',
+  varbinary: 'Buffer',
+
+  // --- Booleans ---
+  boolean: 'boolean',
+
+  // --- Date/Time ---
+  date: 'Date | string',
+  datetime: 'Date | string',
+  timestamp: 'Date | string',
+  'timestamp without time zone': 'Date | string',
+  'timestamp with time zone': 'Date | string',
+  time: 'string',
+  'time without time zone': 'string',
+  'time with time zone': 'string',
+  interval: 'string',
+  year: 'number',
+
+  // --- JSON ---
+  json: 'any',
+  jsonb: 'any',
+
+  // --- UUID ---
+  uuid: 'string',
+
+  // --- Spatial / geometric ---
+  point: 'any',
+  line: 'any',
+  lseg: 'any',
+  box: 'any',
+  path: 'any',
+  polygon: 'any',
+  circle: 'any',
+  geometry: 'any',
+  linestring: 'any',
+  multipoint: 'any',
+  multilinestring: 'any',
+  multipolygon: 'any',
+  geometrycollection: 'any',
+
+  // --- Other ---
+  xml: 'string',
+  money: 'string',
+  tsvector: 'string',
+  tsquery: 'string',
+  inet: 'string',
+  cidr: 'string',
+  macaddr: 'string',
+  macaddr8: 'string',
+  array: 'any[]',
+}
+
+export default (cmd: Command) => {
+  cmd
+    .description('generate TypeScript types from a database')
+    .addOption(
+      new Option(
+        '-u, --url <connection_url>',
+        `database connection url (ex. ${fmtVal('postgres://postgres:secret@localhost:5432')})`
+      ).makeOptionMandatory()
+    )
+    .addOption(new Option('-t, --table <table_name>', `table name (ex. users or public.users)`))
+    .addOption(new Option('-s, --schema <schema_name>', `schema name (ex. public)`).default('public', fmtVal('public')))
+    .addOption(new Option('-o, --out <dir|file>', 'output dir or file').default('.', fmtVal('.')))
+    .addOption(new Option('-F, --force', 'force overriding output'))
+    .action(async props => {
+      const { url, table, schema, out, force } = props
+
+      const db = new SQL({ url })
+      let tables: string[] = []
+      let types: Record<string, string> = {}
+
+      if (table) tables = [table]
+      else {
+        const r = await db.unsafe(`SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema = '${schema}'
+          AND table_type = 'BASE TABLE'`)
+        tables = r.map(r => r.table_name)
+      }
+
+      for (const tableName of tables) {
+        const t = await db.unsafe(`SELECT column_name, data_type, is_nullable
+          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' : ''}`)
+          .join(';\n')}\n}`
+      }
+
+      mkdirSync(path.dirname(out), { recursive: true })
+
+      if (path.extname(out) === '.ts') {
+        await Bun.write(
+          out,
+          Object.values(types).map(type => `export ${type}\n`)
+        )
+      } else {
+        for (const [tableName, type] of Object.entries(types)) {
+          await Bun.write(`${out}/${tableName}.ts`, `export ${type}\n`)
+        }
+      }
+    })
+}

package/bin/commands/generate/spec.ts

@@ -1,6 +1,5 @@
 import { Command, Option } from 'commander'
 import { resolve, relative, extname } from 'path'
-import { dump as ymlDump, load as ymlLoad } from 'js-yaml'
 import { CWD, fmtList, instanciateRoutes, silentExec } from '../../util'
 import { Galbe } from '../../../src'
 import { OpenAPISerializer } from '../../../src/extras'
@@ -47,7 +46,7 @@ export default (cmd: Command) => {
       if (base) {
         let ext = extname(base)
         let rd = (str: string) =>
-          ext === '.json' ? JSON.parse(str) : ['.yml', '.yaml'].includes(ext) ? ymlLoad(str) : null
+          ext === '.json' ? JSON.parse(str) : ['.yml', '.yaml'].includes(ext) ? Bun.YAML.parse(str) : null
         baseSpec = rd(await Bun.file(relative(CWD, base)).text())
       }
 
@@ -84,11 +83,14 @@ export default (cmd: Command) => {
             description: pckg?.description,
             contact: parseAuthor(pckg.author),
             //license: TODO
-            version: pckg?.version || '0.1.0'
-          }
+            version: pckg?.version || '0.1.0',
+          },
         }
         openapiSpec = softMerge(openapiSpec, baseSpec) as OpenAPIV3.Document
-        Bun.write(resolve(CWD, out), tFormat === 'json' ? JSON.stringify(openapiSpec, null, 2) : ymlDump(openapiSpec))
+        Bun.write(
+          resolve(CWD, out),
+          tFormat === 'json' ? JSON.stringify(openapiSpec, null, 2) : Bun.YAML.stringify(openapiSpec, null, 2)
+        )
       }
 
       Bun.write(Bun.stdout, ' : \x1b[1;30m\x1b[32mdone\x1b[0m\n')

package/bin/util.ts

@@ -194,3 +194,12 @@ export const HttpStatus = {
   507: 'Insufficient Storage',
   511: 'Network Authentication Required',
 }
+
+export const toPascalCase = (input: string) =>
+  input
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[^a-zA-Z0-9]+/g, ' ')
+    .trim()
+    .split(/\s+/)
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",
@@ -39,7 +39,7 @@
     "release": "release-it"
   },
   "devDependencies": {
-    "@types/bun": "^1.0.4",
+    "@types/bun": "^1.2.22",
     "openapi-types": "^12.1.3",
     "release-it": "^17.1.1"
   },
@@ -52,8 +52,7 @@
     "acorn": "^8.11.2",
     "acorn-walk": "^8.3.0",
     "chokidar": "^3.6.0",
-    "commander": "^11.1.0",
-    "js-yaml": "^4.1.0"
+    "commander": "^11.1.0"
   },
   "release-it": {
     "git": {

package/src/parser.ts

@@ -12,6 +12,7 @@ import type {
   STNull,
   STPropsValue,
   STUnion,
+  STIntersection,
 } from './schema'
 
 import { readableStreamToArrayBuffer } from 'bun'
@@ -112,13 +113,20 @@ export const requestBodyParser = async (
         }
         return await streamToString(body, schema as STBodyValue)
       } else if (contentType === 'json') {
-        if (!['object', 'json', 'boolean', 'number', 'integer', 'string', 'array', 'union'].includes(kind))
+        if (
+          !['object', 'json', 'boolean', 'number', 'integer', 'string', 'array', 'union', 'intersection'].includes(kind)
+        )
           throw new RequestError({ status: 400, payload: { body: `Not a valid body` } })
         if (kind === 'union') {
           let str = body === null ? 'null' : await streamToString(body)
           let json = JSON.parse(str)
           return unionize(json, schema)
         }
+        if (kind === 'intersection') {
+          let str = body === null ? 'null' : await streamToString(body)
+          let json = JSON.parse(str)
+          return intersectionize(json, schema)
+        }
         const str = body === null ? 'null' : await streamToString(body)
         let json
         try {
@@ -753,3 +761,13 @@ const unionize = (b: any, schema: STUnion) => {
   else if (error) throw new RequestError({ status: 400, payload: { body: error } })
   else throw new RequestError({ status: 400, payload: { body: `No matching body schema found` } })
 }
+
+const intersectionize = (b: any, schema: STIntersection) => {
+  let res
+  try {
+    for (let s of schema.allOf) res = validate(b, s, { parse: true })
+    return res
+  } catch (e) {
+    throw new RequestError({ status: 400, payload: { body: `No matching body schema found` } })
+  }
+}

package/src/types.ts

@@ -5,6 +5,7 @@ import type {
   STBoolean,
   STByteArray,
   STInteger,
+  STIntersection,
   STJson,
   STLiteral,
   STMultipartForm,
@@ -40,7 +41,7 @@ export type STBody =
   | Partial<{
       byteArray?: STByteArray | STStream
       text?: STString | STLiteral | STBoolean | STNumber | STInteger | STUnion | STStream
-      json?: STJson | STObject | STBoolean | STInteger | STNumber | STString | STArray | STUnion
+      json?: STJson | STObject | STBoolean | STInteger | STNumber | STString | STArray | STUnion | STIntersection
       urlForm?: STObject | STStream | STUnion
       multipart?: STMultipartForm | STStream | STUnion
       default?: STString | STByteArray | STStream | STAny
@@ -269,7 +270,7 @@ export class RequestError {
   payload?: any
   headers?: Record<string, string>
   constructor(options: { status?: number; payload?: any; headers?: Record<string, string> }) {
-    this.status = options.status ?? 500
+    this.status = options.status ?? 400
     this.payload = options.payload
     this.headers = options.headers
   }