galbe 0.13.0 → 0.14.0

package/src/types.ts

@@ -5,6 +5,7 @@ import type {
   STBoolean,
   STByteArray,
   STInteger,
+  STIntersection,
   STJson,
   STLiteral,
   STMultipartForm,
@@ -20,6 +21,9 @@ import type {
 } from './schema'
 import type { Galbe } from './index'
 import { HttpStatus } from './util'
+import type { CookieOptions } from './cookies'
+
+export type MediaType = `${string}/${string}`
 
 export type STResponseValue =
   | STByteArray
@@ -32,23 +36,54 @@ export type STResponseValue =
   | STJson
   | STArray
   | STUnion
+  | STIntersection<any>
   | STStream
   | STAny
   | STNull
-export type STBody =
+
+export type STBodyValue =
+  | STByteArray
+  | STStream
+  | STString
+  | STLiteral
+  | STBoolean
+  | STNumber
+  | STInteger
+  | STObject
+  | STJson
+  | STArray
+  | STUnion
+  | STIntersection<any>
+  | STMultipartForm
+  | STAny
+
+export type STBodyContent = Partial<Record<MediaType, STBodyValue>>
+export type STBody = STNull | STBodyContent
+export type STBodyType = MediaType
+
+export type STResponseBodyValue =
+  | STByteArray
+  | STStream
+  | STString
+  | STLiteral
+  | STBoolean
+  | STNumber
+  | STInteger
+  | STObject
+  | STJson
+  | STArray
+  | STUnion
+  | STIntersection<any>
+  | STAny
   | STNull
-  | Partial<{
-      byteArray?: STByteArray | STStream
-      text?: STString | STLiteral | STBoolean | STNumber | STInteger | STUnion | STStream
-      json?: STJson | STObject | STBoolean | STInteger | STNumber | STString | STArray | STUnion
-      urlForm?: STObject | STStream | STUnion
-      multipart?: STMultipartForm | STStream | STUnion
-      default?: STString | STByteArray | STStream | STAny
-    }>
-export type STBodyType = keyof STBody
-export type STBodyValue = STBody[STBodyType]
 
-export type STResponse = Partial<Record<number | 'default', STResponseValue>>
+export type STResponseContent = Partial<Record<MediaType, STResponseBodyValue>> & {
+  description?: string
+  responseHeaders?: Record<string, STSchema>
+}
+export type STResponseBodyKey = MediaType
+export type STResponseEntry = STResponseValue | STResponseContent
+export type STResponse = Partial<Record<number | 'default', STResponseEntry>>
 
 export type MaybeArray<T> = T | T[]
 export type MaybeSTArray<T extends STSchema> = T | STArray<T>
@@ -60,10 +95,10 @@ type MaybePromise<T> = T | Promise<T>
 export type ExtractParams<T extends string> = T extends `/:${infer P}/${infer Rest}`
   ? P | ExtractParams<Rest>
   : T extends `${infer _}:${infer P}/${infer Rest}`
-  ? P | ExtractParams<Rest>
-  : T extends `${infer _}:${infer P}`
-  ? P
-  : never
+    ? P | ExtractParams<Rest>
+    : T extends `${infer _}:${infer P}`
+      ? P
+      : never
 
 type STHeadersPrimaryValue = STString | STBoolean | STNumber | STInteger | STLiteral
 type STHeadersValue = MaybeSTUnion<STHeadersPrimaryValue>
@@ -142,7 +177,7 @@ export type RequestSchema<
   P extends Partial<STParams<Path>> = Partial<STParams<Path>>,
   Q extends STQuery = STQuery,
   B extends STBody = STBody,
-  R extends Partial<STResponse> = STResponse
+  R extends Partial<STResponse> = STResponse,
 > = {
   headers?: H
   params?: P
@@ -160,13 +195,21 @@ type OmitNotDefined<S extends RequestSchema> = {
       never]: Static<STObject<Exclude<S['params'], undefined>>>[K]
 }
 type StaticBody<T extends STSchema> = T extends STOptional<STSchema> ? Static<T> | null : Static<T>
+export type ContextSet = {
+  headers: {
+    'set-cookie': string[]
+    [header: string]: string | string[]
+  }
+  status?: number
+  cookie: (name: string, value: string, opt?: CookieOptions) => void
+}
 export type Context<
   M extends Method = Method,
   Path extends string = string,
-  S extends RequestSchema = RequestSchema
-> = {
-  [K in STBodyType]: K extends keyof Exclude<S['body'], undefined>
-    ? {
+  S extends RequestSchema = RequestSchema,
+> = 0 extends 1 & Exclude<S['body'], undefined | STNull>
+  ? {
+      [K in keyof Exclude<S['body'], undefined | STNull>]: {
         headers: Static<STObject<Exclude<S['headers'], undefined>>>
         params: {
           [P in ExtractParams<Path>]: P extends keyof OmitNotDefined<S> ? OmitNotDefined<S>[P] : string
@@ -176,24 +219,51 @@ export type Context<
         body: M extends 'get' | 'options' | 'head'
           ? null
           : Exclude<S['body'], undefined> extends STNull
-          ? null
-          : K extends STBodyType
-          ? StaticBody<Exclude<Exclude<S['body'], undefined>[K], undefined>>
-          : never
+            ? null
+            : StaticBody<Extract<Exclude<Exclude<S['body'], undefined | STNull>[K], undefined>, STSchema>>
         request: Request
         remoteAddress: SocketAddress | null
         route?: Route
         state: Record<string, any>
-        set: {
-          headers: {
-            'set-cookie': string[]
-            [header: string]: string | string[]
-          }
-          status?: number
+        set: ContextSet
+        cookies: Record<string, string>
+      }
+    }[keyof Exclude<S['body'], undefined | STNull>]
+  : [Exclude<S['body'], undefined | STNull>] extends [never]
+    ? {
+        headers: Static<STObject<Exclude<S['headers'], undefined>>>
+        params: {
+          [P in ExtractParams<Path>]: P extends keyof OmitNotDefined<S> ? OmitNotDefined<S>[P] : string
         }
+        query: Static<STObject<Exclude<S['query'], undefined>>>
+        contentType: undefined
+        body: null
+        request: Request
+        remoteAddress: SocketAddress | null
+        route?: Route
+        state: Record<string, any>
+        set: ContextSet
+        cookies: Record<string, string>
       }
-    : never
-}[STBodyType]
+    : {
+        [K in keyof Exclude<S['body'], undefined | STNull>]: {
+          headers: Static<STObject<Exclude<S['headers'], undefined>>>
+          params: {
+            [P in ExtractParams<Path>]: P extends keyof OmitNotDefined<S> ? OmitNotDefined<S>[P] : string
+          }
+          query: Static<STObject<Exclude<S['query'], undefined>>>
+          contentType: M extends 'get' | 'options' | 'head' ? undefined : K
+          body: M extends 'get' | 'options' | 'head'
+            ? null
+            : StaticBody<Extract<Exclude<Exclude<S['body'], undefined | STNull>[K], undefined>, STSchema>>
+          request: Request
+          remoteAddress: SocketAddress | null
+          route?: Route
+          state: Record<string, any>
+          set: ContextSet
+          cookies: Record<string, string>
+        }
+      }[keyof Exclude<S['body'], undefined | STNull>]
 export type Next = () => void | Promise<any>
 export type Hook<M extends Method = Method, Path extends string = string, S extends RequestSchema = RequestSchema> = (
   ctx: Context<M, Path, S>,
@@ -202,7 +272,7 @@ export type Hook<M extends Method = Method, Path extends string = string, S exte
 export type Handler<
   M extends Method = Method,
   Path extends string = string,
-  S extends RequestSchema = RequestSchema
+  S extends RequestSchema = RequestSchema,
 > = (ctx: Context<M, Path, S>) => any
 export type Endpoint<M extends Method> = {
   <
@@ -211,7 +281,7 @@ export type Endpoint<M extends Method> = {
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends STResponse = STResponse,
   >(
     path: Path,
     schema: RequestSchema<M, Path, H, P, Q, B, R>,
@@ -224,7 +294,7 @@ export type Endpoint<M extends Method> = {
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends STResponse = STResponse,
   >(
     path: Path,
     schema: RequestSchema<M, Path, H, P, Q, B, R>,
@@ -236,7 +306,7 @@ export type Endpoint<M extends Method> = {
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends STResponse = STResponse,
   >(
     path: Path,
     hooks: Hook<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>[],
@@ -248,7 +318,7 @@ export type Endpoint<M extends Method> = {
     H extends STHeaders = any,
     Q extends STQuery = any,
     B extends STBody = any,
-    R extends STResponse = STResponse
+    R extends STResponse = STResponse,
   >(
     path: Path,
     handler: Handler<M, Path, RequestSchema<M, Path, H, P, Q, B, R>>
@@ -264,12 +334,19 @@ export type StaticEndpoint<P extends string = string, T extends string = string>
   options?: StaticEndpointOptions
 ) => Route<'get', P, {}, {}, {}, STBody, STResponse, T>
 
-export class RequestError {
+export class RequestError extends Error {
   status: number
   payload?: any
   headers?: Record<string, string>
-  constructor(options: { status?: number; payload?: any; headers?: Record<string, string> }) {
-    this.status = options.status ?? 400
+  constructor(options: { status?: number; payload?: any; headers?: Record<string, string> } = {}) {
+    const status = options.status ?? 400
+    const message =
+      typeof options.payload === 'string'
+        ? options.payload
+        : HttpStatus[status as keyof typeof HttpStatus] ?? 'Request Error'
+    super(message)
+    this.name = new.target?.name ?? 'RequestError'
+    this.status = status
     this.payload = options.payload
     this.headers = options.headers
   }
@@ -292,7 +369,7 @@ export type Route<
   B extends STBody = STBody,
   R extends STResponse = STResponse,
   SP extends string = string,
-  SR extends string = string
+  SR extends string = string,
 > = {
   method: M
   path: Path
@@ -303,29 +380,57 @@ export type Route<
   static?: { path: SP; root: SR }
 }
 
-export class NotFoundError extends RequestError {
-  constructor(message?: any) {
-    super({ status: 404, payload: message ?? HttpStatus[404] })
+const mkErr = (status: number) =>
+  class extends RequestError {
+    constructor(payload?: any, headers?: Record<string, string>) {
+      super({ status, payload: payload ?? HttpStatus[status as keyof typeof HttpStatus], headers })
+    }
   }
-}
 
-export class MethodNotAllowedError extends RequestError {
-  constructor(message?: any) {
-    super({ status: 405, payload: message ?? HttpStatus[405] })
-  }
-}
+// 4xx
+export class BadRequestError extends mkErr(400) {}
+export class UnauthorizedError extends mkErr(401) {}
+export class PaymentRequiredError extends mkErr(402) {}
+export class ForbiddenError extends mkErr(403) {}
+export class NotFoundError extends mkErr(404) {}
+export class MethodNotAllowedError extends mkErr(405) {}
+export class NotAcceptableError extends mkErr(406) {}
+export class ProxyAuthenticationRequiredError extends mkErr(407) {}
+export class RequestTimeoutError extends mkErr(408) {}
+export class ConflictError extends mkErr(409) {}
+export class GoneError extends mkErr(410) {}
+export class LengthRequiredError extends mkErr(411) {}
+export class PreconditionFailedError extends mkErr(412) {}
+export class PayloadTooLargeError extends mkErr(413) {}
+export class URITooLongError extends mkErr(414) {}
+export class UnsupportedMediaTypeError extends mkErr(415) {}
+export class RangeNotSatisfiableError extends mkErr(416) {}
+export class ExpectationFailedError extends mkErr(417) {}
+export class ImATeapotError extends mkErr(418) {}
+export class MisdirectedRequestError extends mkErr(421) {}
+export class UnprocessableEntityError extends mkErr(422) {}
+export class LockedError extends mkErr(423) {}
+export class FailedDependencyError extends mkErr(424) {}
+export class UpgradeRequiredError extends mkErr(426) {}
+export class PreconditionRequiredError extends mkErr(428) {}
+export class TooManyRequestsError extends mkErr(429) {}
+export class RequestHeaderFieldsTooLargeError extends mkErr(431) {}
+export class UnavailableForLegalReasonsError extends mkErr(451) {}
 
-export class InternalError extends RequestError {
-  constructor(message?: any) {
-    super({ status: 500, payload: message ?? HttpStatus[500] })
-  }
-}
+// 5xx
+export class InternalServerError extends mkErr(500) {}
+export class NotImplementedError extends mkErr(501) {}
+export class BadGatewayError extends mkErr(502) {}
+export class ServiceUnavailableError extends mkErr(503) {}
+export class GatewayTimeoutError extends mkErr(504) {}
+export class HTTPVersionNotSupportedError extends mkErr(505) {}
+export class InsufficientStorageError extends mkErr(507) {}
+export class NetworkAuthenticationRequiredError extends mkErr(511) {}
 
-export class NotImplementedError extends RequestError {
-  constructor(message?: any) {
-    super({ status: 501, payload: message ?? HttpStatus[501] })
-  }
-}
+/** @deprecated use {@link InternalServerError} */
+export const InternalError = InternalServerError
+/** @deprecated use {@link InternalServerError} */
+export type InternalError = InternalServerError
 
 /**
  * #### GalbePlugin
@@ -363,7 +468,21 @@ export type GalbeCLICommand = {
   tags: string[]
   description?: string
   route: Route
+  pathT: string
   arguments?: { name: string; type: string; description: string }[]
   options?: { name: string; short: string; type: string; description: string; default: any }[]
   action?: (props: any) => MaybePromise<void>
+  hideOptions?: ('header' | 'query' | 'body' | 'body-file')[]
+}
+
+export type GalbeCLIOptions = {
+  baseUrl?: string | (() => string)
+  headers?: Record<string, string>
+  requestInterceptor?: (
+    req: Request,
+    command: GalbeCLICommand,
+    args: Record<string, string>,
+    options: Record<string, any>
+  ) => MaybePromise<Request>
+  responseFormatter?: (res: Response) => MaybePromise<string>
 }

package/src/util.ts

@@ -1,4 +1,4 @@
-import type { Method, Route, RouteNode, STBodyType } from '.'
+import type { Method, Route, RouteNode } from '.'
 import type { RouteFileMeta, RouteMeta } from './routes'
 
 const METHOD_COLOR: Record<string, string> = {
@@ -138,28 +138,20 @@ export const HttpStatus = {
   511: 'Network Authentication Required',
 }
 
-const BA_HEADER = 'application/octet-stream'
-const JSON_HEADER = 'application/json'
+const BA_HEADER_RX = /^application\/octet-stream\b/
+const JSON_HEADER_RX = /^application\/json\b/
 const TXT_HEADER_RX = /^text\//
-const FORM_HEADER_RX = /^application\/x-www-form-urlencoded/
-const MP_HEADER_RX = /^multipart\/form-data/
+const FORM_HEADER_RX = /^application\/x-www-form-urlencoded\b/
+const MP_HEADER_RX = /^multipart\/form-data\b/
 
-export const inferBodyType = (contentType?: string | null): STBodyType | undefined => {
+export type ParseMode = 'json' | 'text' | 'byteArray' | 'urlForm' | 'multipart' | 'default'
+
+export const inferBodyType = (contentType?: string | null): ParseMode => {
   if (!contentType) return 'default'
-  if (contentType === JSON_HEADER) return 'json'
+  if (JSON_HEADER_RX.test(contentType)) return 'json'
   if (TXT_HEADER_RX.test(contentType)) return 'text'
   if (FORM_HEADER_RX.test(contentType)) return 'urlForm'
   if (MP_HEADER_RX.test(contentType)) return 'multipart'
-  if (contentType === BA_HEADER) return 'byteArray'
-  return 'default'
-}
-
-export const inferContentType = (bodyType?: string | undefined): string => {
-  if (!bodyType) return 'default'
-  if (bodyType === 'json') return JSON_HEADER
-  if (bodyType === 'text') return 'text/plain'
-  if (bodyType === 'urlForm') return 'application/x-www-form-urlencoded'
-  if (bodyType === 'multipart') return 'multipart/form-data'
-  if (bodyType === 'byteArray') return BA_HEADER
+  if (BA_HEADER_RX.test(contentType)) return 'byteArray'
   return 'default'
 }

package/src/validator.ts

@@ -1,5 +1,17 @@
-import { InternalError, type STResponse } from './index'
-import type { STSchema, STProps, STUnion, STIntersection } from './schema'
+import { InternalServerError, type STResponse } from './index'
+import type {
+  STSchema,
+  STProps,
+  STUnion,
+  STIntersection,
+  STJson,
+  STLiteral,
+  STArray,
+  STNumber,
+  STInteger,
+  STString,
+  STObject,
+} from './schema'
 import { Kind, Optional, Stream } from './schema'
 import { isIterator } from './util'
 
@@ -30,7 +42,8 @@ export const validate = (elt: any, schema: STSchema, opt?: { parse?: boolean }):
     if (!(typeof elt === 'string')) throw `Not a valid string`
     schemaValidation(elt, schema)
   } else if (schema[Kind] === 'literal') {
-    if (elt !== schema.value) throw `Not a valid value. Found "${elt}" but expected "${schema.value}"`
+    const lit = schema as STLiteral
+    if (elt !== lit.value) throw `Not a valid value. Found "${elt}" but expected "${lit.value}"`
   } else if (schema[Kind] === 'object') {
     if (opt?.parse && typeof elt === 'string') {
       try {
@@ -42,8 +55,8 @@ export const validate = (elt: any, schema: STSchema, opt?: { parse?: boolean }):
     if (typeof elt !== 'object') throw `Not a valid object`
     if (Array.isArray(elt)) throw `Expected an object, not an array`
     const err: ValidationError = {}
-    Object.entries(schema.props as STProps).forEach(([k, s]) => {
-      if (!(k in elt)) {
+    Object.entries((schema as STObject).props ?? {}).forEach(([k, s]) => {
+      if (elt === null || !(k in elt)) {
         if (!s?.[Optional]) err[k] = 'Required'
         return
       }
@@ -55,7 +68,7 @@ export const validate = (elt: any, schema: STSchema, opt?: { parse?: boolean }):
     })
     if (Object.keys(err).length) errors.push(err)
   } else if (schema[Kind] === 'json') {
-    elt = validate(elt, { ...schema, [Kind]: schema.type }, opt)
+    elt = validate(elt, (schema as STJson).value, opt)
   } else if (schema[Kind] === 'array') {
     if (opt?.parse && typeof elt === 'string') {
       try {
@@ -65,14 +78,14 @@ export const validate = (elt: any, schema: STSchema, opt?: { parse?: boolean }):
       }
     }
     if (!Array.isArray(elt)) throw 'Not a valid array'
-    for (const i of elt) validate(i, schema.items)
+    for (const i of elt) validate(i, (schema as STArray).items)
     schemaValidation(elt, schema)
   } else if (schema[Kind] === 'byteArray') {
     if (opt?.parse && typeof elt === 'string') elt = Uint8Array.from(elt, c => c.charCodeAt(0))
     else if (opt?.parse && Array.isArray(elt)) elt = new Uint8Array(elt)
     if (!(elt instanceof Uint8Array)) throw 'Not a valid byteArray'
-  } else if (schema[Kind] === 'union') {
-    const union = Object.values((schema as STUnion).anyOf)
+  } else if (schema[Kind] === 'anyOf' || schema[Kind] === 'oneOf') {
+    const union = Object.values((schema as STUnion).members)
     let valid = false
     for (const s of union) {
       try {
@@ -86,7 +99,7 @@ export const validate = (elt: any, schema: STSchema, opt?: { parse?: boolean }):
     // @ts-ignore
     if (!valid) throw `Could not be parsed to any of [${union.map(u => u?.value ?? u[Kind]).join(', ')}]`
   } else if (schema[Kind] === 'intersection') {
-    const intersection = Object.values((schema as STIntersection).allOf)
+    const intersection = Object.values((schema as STIntersection<any>).allOf)
     for (const s of intersection) validate(elt, s as STSchema, opt)
   } else if (schema[Kind] === 'any') {
   } else {
@@ -100,18 +113,32 @@ export const validate = (elt: any, schema: STSchema, opt?: { parse?: boolean }):
 }
 
 export const validateResponse = (response: any, schema: STResponse, status: number) => {
-  if (!(status in schema)) return
-  const s = schema?.[status] || schema?.['default']
+  const entry = schema?.[status] ?? schema?.['default']
+  if (!entry) return
+  let s: STSchema | undefined
+  if ((entry as STSchema)[Kind]) {
+    s = entry as STSchema
+  } else {
+    const c = entry as any
+    if (response instanceof Uint8Array)
+      s = c['application/octet-stream'] ?? c['*/*']
+    else if (typeof response === 'string')
+      s = c['text/plain'] ?? c['application/json'] ?? c['*/*']
+    else if (response !== null && typeof response === 'object')
+      s = c['application/json'] ?? c['*/*']
+    else
+      s = c['*/*']
+  }
   if (!s) return
   if (response instanceof ReadableStream) {
-    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got ReadableStream`)
+    if (!s[Stream]) throw new InternalServerError(`Expected ${s[Kind]} response, but got ReadableStream`)
   } else if (isIterator(response)) {
-    if (!s[Stream]) throw new InternalError(`Expected ${s[Kind]} response, but got Iterator`)
+    if (!s[Stream]) throw new InternalServerError(`Expected ${s[Kind]} response, but got Iterator`)
   } else {
     try {
       validate(response, s)
     } catch (error) {
-      throw new InternalError({ ResponseValidationError: error })
+      throw new InternalServerError({ ResponseValidationError: error })
     }
   }
 }
@@ -119,25 +146,28 @@ export const validateResponse = (response: any, schema: STResponse, status: numb
 const schemaValidation = (value: any, schema: STSchema) => {
   const errors = []
   if (schema[Kind] === 'integer' || schema[Kind] === 'number') {
-    if (schema.exclusiveMin !== undefined)
-      if ((value as number) <= schema.exclusiveMin) errors.push(`Is less or equal to ${schema.exclusiveMin}`)
-    if (schema.exclusiveMax !== undefined)
-      if ((value as number) >= schema.exclusiveMax) errors.push(`Is greater or equal to ${schema.exclusiveMax}`)
-    if (schema.min !== undefined) if ((value as number) < schema.min) errors.push(`Is less than ${schema.min}`)
-    if (schema.max !== undefined) if ((value as number) > schema.max) errors.push(`Is greater than ${schema.max}`)
+    const n = schema as STNumber | STInteger
+    if (n.exclusiveMin !== undefined)
+      if ((value as number) <= n.exclusiveMin) errors.push(`Is less or equal to ${n.exclusiveMin}`)
+    if (n.exclusiveMax !== undefined)
+      if ((value as number) >= n.exclusiveMax) errors.push(`Is greater or equal to ${n.exclusiveMax}`)
+    if (n.min !== undefined) if ((value as number) < n.min) errors.push(`Is less than ${n.min}`)
+    if (n.max !== undefined) if ((value as number) > n.max) errors.push(`Is greater than ${n.max}`)
   } else if (schema[Kind] === 'string') {
-    if (schema.minLength !== undefined && (value as string).length < schema.minLength)
-      errors.push(`Length is too small (${schema.minLength} char min)`)
-    if (schema.maxLength !== undefined && (value as string).length > schema.maxLength)
-      errors.push(`Length is too large (${schema.maxLength} char max)`)
-    if (schema.pattern !== undefined && !(value as string).match(schema.pattern))
-      errors.push(`Does not match pattern ${schema.pattern}`)
+    const str = schema as STString
+    if (str.minLength !== undefined && (value as string).length < str.minLength)
+      errors.push(`Length is too small (${str.minLength} char min)`)
+    if (str.maxLength !== undefined && (value as string).length > str.maxLength)
+      errors.push(`Length is too large (${str.maxLength} char max)`)
+    if (str.pattern !== undefined && !(value as string).match(str.pattern))
+      errors.push(`Does not match pattern ${str.pattern}`)
   } else if (schema[Kind] === 'array') {
-    if (schema.minItems !== undefined && (value as any[]).length < schema.minItems)
-      errors.push(`Must contain at least ${schema.minItems} item${schema.minItems > 1 ? 's' : ''}`)
-    if (schema.maxItems !== undefined && (value as any[]).length > schema.maxItems)
-      errors.push(`Must contain at most (${schema.maxItems} item${schema.maxItems > 1 ? 's' : ''}`)
-    if (schema.unique === true && new Set(value as any[]).size !== (value as any[]).length)
+    const arr = schema as STArray
+    if (arr.minLength !== undefined && (value as any[]).length < arr.minLength)
+      errors.push(`Must contain at least ${arr.minLength} item${arr.minLength > 1 ? 's' : ''}`)
+    if (arr.maxLength !== undefined && (value as any[]).length > arr.maxLength)
+      errors.push(`Must contain at most ${arr.maxLength} item${arr.maxLength > 1 ? 's' : ''}`)
+    if (arr.unique === true && new Set(value as any[]).size !== (value as any[]).length)
       errors.push(`Has duplicate values`)
   }
   if (errors.length) throw Array.isArray(errors) && errors.length === 1 ? errors[0] : errors