galbe 0.6.2 → 0.7.0

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

@@ -108,16 +108,22 @@ const parseOapiSchema = (
     title: os.title,
     description: os.description
   }
+  let resp = ''
   let hasOptions = Object.values(options).some(v => !!v)
   let optArg = hasOptions ? `, ${JSON.stringify(options)}` : ''
   let anyOf = os.oneOf || os.anyOf || os.allOf
+  let required = os.required
+  let nullable = os.nullable
+
   if (anyOf?.length) {
-    return `$T.union([${anyOf.map(s => parseOapiSchema(s as OpenAPIV3.SchemaObject)).join(',')}], ${JSON.stringify(
-      options
-    )})`
-  }
-  if (os.type === 'boolean') return `$T.boolean(${hasOptions ? JSON.stringify(options) : ''})`
-  if (os.type === 'number') {
+    if (anyOf.length === 1) resp = parseOapiSchema(anyOf[0] as OpenAPIV3.SchemaObject, details, extra)
+    else {
+      resp = `$T.union([${anyOf.map(s => parseOapiSchema(s as OpenAPIV3.SchemaObject)).join(',')}], ${JSON.stringify(
+        options
+      )})`
+    }
+  } else if (os.type === 'boolean') resp = `$T.boolean(${hasOptions ? JSON.stringify(options) : ''})`
+  else if (os.type === 'number') {
     let { max, min, exclusiveMax, exclusiveMin } = {
       max: os.maximum !== undefined && !os.exclusiveMaximum ? os.maximum : undefined,
       min: os.minimum !== undefined && !os.exclusiveMinimum ? os.minimum : undefined,
@@ -126,49 +132,52 @@ const parseOapiSchema = (
     }
     options = { ...options, min, max, exclusiveMax, exclusiveMin }
     hasOptions = Object.values(options).some(v => !!v)
-    return `$T.number(${hasOptions ? JSON.stringify(options) : ''})`
-  }
-  if (os.type === 'integer') {
+    resp = `$T.number(${hasOptions ? JSON.stringify(options) : ''})`
+  } else if (os.type === 'integer') {
     let max = os.maximum !== undefined && !os.exclusiveMaximum ? os.maximum : undefined
     let min = os.minimum !== undefined && !os.exclusiveMinimum ? os.minimum : undefined
     let exclusiveMax = os.maximum !== undefined && os.exclusiveMaximum ? os.maximum : undefined
     let exclusiveMin = os.minimum !== undefined && os.exclusiveMinimum ? os.minimum : undefined
     options = { ...options, min, max, exclusiveMax, exclusiveMin }
     hasOptions = Object.values(options).some(v => !!v)
-    return `$T.integer(${hasOptions ? JSON.stringify(options) : ''})`
-  }
-  if (os.type === 'string') {
-    if (os.format === 'binary') return `$T.byteArray(${hasOptions ? JSON.stringify(options) : ''})`
-    let minLength = os.minLength
-    let maxLength = os.maxLength
-    let pattern = os.pattern
-    options = { ...options, minLength, maxLength, pattern }
-    hasOptions = Object.values(options).some(v => !!v)
-    return `$T.string(${hasOptions ? JSON.stringify(options) : ''})`
-  }
-  if (os.type === 'array') {
+    resp = `$T.integer(${hasOptions ? JSON.stringify(options) : ''})`
+  } else if (os.type === 'string') {
+    if (os.format === 'binary') resp = `$T.byteArray(${hasOptions ? JSON.stringify(options) : ''})`
+    else {
+      let minLength = os.minLength
+      let maxLength = os.maxLength
+      let pattern = os.pattern
+      options = { ...options, minLength, maxLength, pattern }
+      hasOptions = Object.values(options).some(v => !!v)
+      resp = `$T.string(${hasOptions ? JSON.stringify(options) : ''})`
+    }
+  } else if (os.type === 'array') {
     let minItems = os.minItems
     let maxItems = os.maxItems
     let unique = os.uniqueItems
     options = { ...options, minItems, maxItems, unique }
-    return `$T.array(${parseOapiSchema(os?.items)}${optArg})`
-  }
-  if (os.type === 'object') {
+    resp = `$T.array(${parseOapiSchema(os?.items)}${optArg})`
+  } else if (os.type === 'object') {
     if (extra?.media === 'multipart/form-data') {
-      return `$T.multipartForm({${Object.entries(os?.properties || {})
+      resp = `$T.multipartForm({${Object.entries(os?.properties || {})
         .map(([k, v]) => `${k}:${parseOapiSchema(v)}`)
         .join(',')}}${optArg})`
-    }
-    if (extra?.media === 'application/x-www-form-urlencoded') {
-      return `$T.urlForm({${Object.entries(os?.properties || {})
+    } else if (extra?.media === 'application/x-www-form-urlencoded') {
+      resp = `$T.urlForm({${Object.entries(os?.properties || {})
+        .map(([k, v]) => `${k}:${parseOapiSchema(v)}`)
+        .join(',')}}${optArg})`
+    } else {
+      resp = `$T.object({${Object.entries(os?.properties || {})
         .map(([k, v]) => `${k}:${parseOapiSchema(v)}`)
         .join(',')}}${optArg})`
     }
-    return `$T.object({${Object.entries(os?.properties || {})
-      .map(([k, v]) => `${k}:${parseOapiSchema(v)}`)
-      .join(',')}}${optArg})`
-  }
-  throw new Error(`Unknown schema type ${os.type}`)
+  } else throw new Error(`Unknown schema type ${os.type}`)
+
+  if (!required && nullable) resp = `$T.nullish(${resp})`
+  else if (!required) resp = `$T.optional(${resp})`
+  else if (nullable) resp = `$T.nullable(${resp})`
+
+  return resp
 }
 
 const buildSchemaIndex = (def: OpenAPIV3.Document) => {
@@ -217,7 +226,7 @@ const parseEndpointDef = (method: string, path: string, def?: OpenAPIV3.Operatio
   let imports = {}
   let p = path.replaceAll(/\{([^\}]*)\}/g, ':$1')
   let description = def.summary || def.description
-  let pathName = path.replaceAll(/\/\{[^\}]*\}/g, 'X').replaceAll(/[^$\w\d-_]([$\w\d-_])/g, (_, $1) => $1.toUpperCase())
+  let pathName = path.replaceAll(/\/\{[^\}]*\}/g, 'X').replaceAll(/[^$\w\d_]+([$\w\d_])/g, (_, $1) => $1.toUpperCase())
   let schemaName = `${method}${pathName}`.replace(/^\w/, c => c.toUpperCase())
 
   let meta = '/**\n'

package/docs/schemas.md

@@ -44,6 +44,14 @@ Schema Type matching integer `number` values.
 const intSchema = $T.integer(options)
 ```
 
+#### Null
+
+Schema Type matching `null` values.
+
+```ts
+const nullSchema = $T.null(options)
+```
+
 #### Any
 
 Schema Type matching `any` of the previous Schema Types.
@@ -68,6 +76,22 @@ Makes any type optional. This allows for `undefined` values.
 const optionalSchema = $T.optional($T.string())
 ```
 
+#### Nullable
+
+Makes any type nullable. This allows for `null` values.
+
+```ts
+const nullableSchema = $T.nullable($T.string())
+```
+
+#### Nullish
+
+Makes any type nullish. This allows for `undefined` and `null` values.
+
+```ts
+const nullishSchema = $T.nullish($T.string())
+```
+
 #### Union
 
 Creates an union of Schema Types.
@@ -155,7 +179,7 @@ const schema = {
 body: STByteArray | STString | STBoolean | STNumber | STInteger | STLiteral | STObject | STArray | STMulripartForm | STUrlForm | STStream
 ```
 
-#### Json
+#### Object
 
 To define an `application/json` request body, use `STObject` Schema Type. Example:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "galbe",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Fast, lightweight and highly customizable JavaScript web framework based on Bun",
   "author": "Pierre Caillaud M (https://github.com/pierre-cm)",
   "type": "module",

package/src/extras/spec/openapi.serializer.ts

@@ -51,8 +51,12 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       //@ts-ignore
       return { schema: { $ref: `#/components/schemas/${schema.id}` } }
     }
-    // TODO add constraints min, max etc.
-    if (kind === 'boolean') s = { type: 'boolean' }
+
+    if (kind === 'null') {
+      s = {
+        anyOf: ['null']
+      }
+    } else if (kind === 'boolean') s = { type: 'boolean' }
     else if (kind === 'byteArray') s = { type: 'string', format: 'byte' }
     else if (kind === 'number')
       s = {
@@ -118,10 +122,23 @@ export const OpenAPISerializer = async (g: Galbe, version = '3.0.3'): Promise<Op
       }
     } else if (kind === 'union') {
       let anyOf = (schema as STUnion).anyOf
-      s = {
-        anyOf: anyOf.map(s => schemaToOpenapi(s).schema)
+      let nullable = anyOf.some(s => s[Kind] === 'null')
+      anyOf = anyOf.filter(s => s[Kind] !== 'null')
+
+      if (anyOf.length === 0) {
+        s = {}
+      } else if (anyOf.length === 1) {
+        s = schemaToOpenapi(anyOf[0]).schema
+      } else if (anyOf.length > 1) {
+        s = {
+          anyOf: anyOf.map(s => schemaToOpenapi(s).schema)
+        }
       }
+
+      //@ts-ignore
+      if (nullable) s.nullable = nullable
     }
+
     s = { title: schema.title, description: schema.description, ...s }
     if (components.schemas && schema.id) {
       components.schemas[schema.id] = s

package/src/parser.ts

@@ -56,7 +56,7 @@ export const requestBodyParser = async (
               }
             })
           } else return new Uint8Array()
-        } else if (schema?.[Optional]) {
+        } else if (schema?.[Optional] || kind === 'null') {
           return null
         } else {
           throw new RequestError({ status: 400, payload: { body: `Not a valid ${kind}` } })
@@ -75,7 +75,8 @@ export const requestBodyParser = async (
         } else return null
       }
     } else {
-      if (kind === 'byteArray') {
+      if (kind === 'null') throw new RequestError({ status: 400, payload: { body: `Expected null body` } })
+      else if (kind === 'byteArray') {
         if (isStream) return rsToAsyncIterator(body)
         const bytes = await readableStreamToArrayBuffer(body)
         return new Uint8Array(bytes)
@@ -435,7 +436,7 @@ const parseMultipartContent = (
       } else {
         throw new RequestError({
           status: 400,
-          payload: { body: { [headers.name]: `Expect ${schema?.props[headers.name][Kind]} found json` } }
+          payload: { body: { [headers.name]: `Expected ${schema?.props[headers.name][Kind]} found json` } }
         })
       }
     }

package/src/router.ts

@@ -1,7 +1,7 @@
 import type { Method, Route, RouteNode } from './types'
 import { MethodNotAllowedError, NotFoundError } from './types'
 
-const ROUTE_REGEX = /^(\/(\*|:?\d+|:?\w+|:?[\w\d][\w-]+[\w\d]))*\/?$/
+const ROUTE_REGEX = /^(\/(\*|:?\d+|:?\w+|:?[\w\d.][\w-.]+[\w\d]))*\/?$/
 
 const walk = (path: string[], node: RouteNode, alts: RouteNode[] = []): RouteNode => {
   if (path.length < 1) throw new NotFoundError()

package/src/routes.ts

@@ -231,7 +231,7 @@ export const defineRoutes = async (
   if (!routes) return
   const root = process.cwd()
   if (typeof routes === 'string') {
-    for await (const path of new Glob(routes).scan({ cwd: root, absolute: true, onlyFiles: false })) {
+    for await (const path of new Glob(routes).scan({ cwd: root, absolute: true, onlyFiles: false, dot: true })) {
       const isDir = (await lstat(path)).isDirectory()
 
       let files: string[] = []

package/src/schema.ts

@@ -31,6 +31,7 @@ export interface ArrayOptions extends Options {
 }
 export interface STSchema extends Options {
   [Kind]:
+    | 'null'
     | 'boolean'
     | 'byteArray'
     | 'number'
@@ -61,6 +62,7 @@ export type STPropsValue =
   | STObject
   | STUnion
   | STAny
+  | STNull
 export type STProps = Record<string | number, STPropsValue>
 
 type Evaluate<T> = T extends infer O ? { [K in keyof O]: O[K] } : never
@@ -84,6 +86,17 @@ export type STStream<T extends STSchema = STSchema> = T & {
   [Stream]: true
 }
 
+// Null
+export interface STNull extends STSchema, Options {
+  [Kind]: 'null'
+  static: null
+}
+export function _Null(options: Options = {}): STNull {
+  return {
+    ...options,
+    [Kind]: 'null'
+  } as unknown as STNull
+}
 // ByteArray
 export interface STByteArray extends STSchema, ByteArrayOptions {
   [Kind]: 'byteArray'
@@ -310,12 +323,28 @@ export function _Stream<T extends STStreamable>(schema: T): STStream<T> {
     [Stream]: true
   } as unknown as STStream<T>
 }
+// Nullable
+type STNullable<T extends STSchema> = STUnion<[T, STNull]>
+// Nullish
+type STNullish<T extends STSchema> = STOptional<STNullable<T>>
 
 export class SchemaType {
   /** Creates an Optional Schema Type Wrapper*/
   public optional<T extends STSchema>(schema: T): STOptional<T> {
     return { ...schema, [Optional]: true }
   }
+  /** Creates an Nullable Schema Type Wrapper*/
+  public nullable<T extends STSchema>(schema: T): STNullable<T> {
+    return { ..._Union([schema, _Null()], {}) }
+  }
+  /** Creates an Nullish Schema Type Wrapper*/
+  public nullish<T extends STSchema>(schema: T): STNullish<T> {
+    return { ..._Union([schema, _Null()], {}), [Optional]: true }
+  }
+  /** Creates a Null Schema Type */
+  public null(options: Options = {}): STNull {
+    return _Null(options)
+  }
   /** Creates a ByteArray Schema Type */
   public byteArray(options: ByteArrayOptions = {}): STByteArray {
     return _ByteArray(options)
@@ -419,7 +448,8 @@ export const schemaToTypeStr = (schema: STSchema): string => {
   let type = 'unknown'
   let kind = schema[Kind]
 
-  if (kind === 'boolean') type = 'boolean'
+  if (kind === 'null') type = 'null'
+  else if (kind === 'boolean') type = 'boolean'
   else if (kind === 'byteArray') type = 'Uint8Array'
   else if (kind === 'number') type = 'number'
   else if (kind === 'integer') type = 'number'

package/src/server.ts

@@ -4,7 +4,6 @@ import { InternalError, RequestError } from './types'
 import { parseEntry, requestBodyParser, requestPathParser, responseParser } from './parser'
 import { Galbe } from './index'
 import { validateResponse } from './validator'
-import { logger } from 'girok'
 
 type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
 
@@ -140,7 +139,7 @@ export default async (galbe: Galbe, port?: number, hostname?: string) => {
         callChain.push({
           call: async () => {
             response = await handlerWrapper(context as Context)
-            context.set.status = response instanceof Response ? response.status : 200
+            context.set.status = response instanceof Response ? response.status : context.set.status || 200
           }
         })
         if (callChain.length > 1) {

package/src/validator.ts

@@ -8,7 +8,9 @@ export const validate = (elt: any, schema: STSchema, parse = false): any => {
   const errors: ValidationError[] = []
   const iElt = elt
 
-  if (schema[Kind] === 'boolean') {
+  if (schema[Kind] === 'null') {
+    if (elt !== null) throw `Expected null value got ${iElt}`
+  } else if (schema[Kind] === 'boolean') {
     if (typeof elt === 'string') {
       if (parse) elt = elt === 'true' ? true : elt === 'false' ? false : null
       else throw `Expected boolean, got string.`

package/test/parser.test.ts

@@ -324,14 +324,28 @@ describe('parser', () => {
           bool: false,
           object: {},
           array: [],
-          any: false
+          any: false,
+          null: null,
+          nullable: null,
+          nullish: 42
         }),
         type,
         schema,
         expected: {
           status: 200,
           type: 'object',
-          resp: { ba: '', string: '', number: 0, bool: false, object: {}, array: [], any: false }
+          resp: {
+            ba: '',
+            string: '',
+            number: 0,
+            bool: false,
+            object: {},
+            array: [],
+            any: false,
+            null: null,
+            nullable: null,
+            nullish: 42
+          }
         }
       },
       {
@@ -343,7 +357,10 @@ describe('parser', () => {
           object: { foo: 'bar' },
           array: [false, 'one', 2],
           any: '36',
-          optional: 'optional'
+          optional: 'optional',
+          null: null,
+          nullable: 'test',
+          nullish: null
         }),
         type,
         schema,
@@ -358,7 +375,10 @@ describe('parser', () => {
             object: { foo: 'bar' },
             array: [false, 'one', 2],
             any: '36',
-            optional: 'optional'
+            optional: 'optional',
+            null: null,
+            nullable: 'test',
+            nullish: null
           }
         }
       },
@@ -370,7 +390,8 @@ describe('parser', () => {
           bool: 'x',
           object: [],
           array: {},
-          any: {}
+          any: {},
+          null: ''
         }),
         type,
         schema,
@@ -383,7 +404,9 @@ describe('parser', () => {
               number: 'a is not a valid number',
               bool: "x is not a valid boolean. Should be 'true' or 'false'",
               object: 'Expected an object, not an array',
-              array: 'Not a valid array'
+              array: 'Not a valid array',
+              null: 'Expected null value got ',
+              nullable: 'Required'
             }
           }
         }

package/test/router.test.ts

@@ -13,18 +13,7 @@ describe('router', () => {
   test('routes, bad syntax', async () => {
     const galbe = new Galbe()
 
-    const invalidPaths = [
-      '.',
-      '/@',
-      '/-ta',
-      '/test/-ta',
-      '/test/my.path',
-      '/hell@/w0rld',
-      '/last-',
-      '../',
-      './x',
-      '/hello?'
-    ]
+    const invalidPaths = ['.', '/@', '/-ta', '/test/-ta', '/hell@/w0rld', '/last-', '../', './x', '/hello?']
 
     for (const p of invalidPaths) {
       try {

package/test/test.utils.ts

@@ -32,7 +32,10 @@ export const schema_objectBase = {
 export const schema_object = {
   ...schema_objectBase,
   object: $T.object($T.any()),
-  array: $T.array()
+  array: $T.array(),
+  null: $T.null(),
+  nullable: $T.nullable($T.string()),
+  nullish: $T.nullish($T.number())
 }
 
 export const isAsyncIterator = (obj: any) => {