starlight-server 0.0.1

package/dist/validators/object.js

@@ -0,0 +1,36 @@
+import { success, failed } from '@anjianshi/utils';
+import isPlainObject from 'lodash/isPlainObject.js';
+import { Validator } from './common.js';
+export class ObjectValidator extends Validator {
+    validate(fieldName, value) {
+        const superResult = super.validate(fieldName, value);
+        if (!superResult.success)
+            return superResult;
+        value = superResult.data;
+        if (value === null || value === undefined)
+            return superResult;
+        const opt = this.options;
+        if (!isPlainObject(value))
+            return failed(`${fieldName} should be a plain object`);
+        const formatted = {};
+        if ('struct' in opt) {
+            for (const [key, itemValidator] of Object.entries(opt.struct)) {
+                const itemResult = itemValidator.validate(`${fieldName}["${key}"]`, value[key]);
+                if (itemResult.success)
+                    formatted[key] = itemResult.data;
+                else
+                    return itemResult;
+            }
+        }
+        else {
+            for (const [key, itemValue] of Object.entries(value)) {
+                const itemResult = opt.value.validate(`${fieldName}["${key}"]`, itemValue);
+                if (itemResult.success)
+                    formatted[key] = itemResult.data;
+                else
+                    return itemResult;
+            }
+        }
+        return success(formatted);
+    }
+}

package/dist/validators/string.d.ts

@@ -0,0 +1,11 @@
+import { Validator, type CommonOptions } from './common.js';
+export interface StringOptions {
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+    trim: boolean;
+}
+export declare class StringValidator extends Validator<StringOptions> {
+    constructor(options?: Partial<StringOptions> & Partial<CommonOptions>);
+    validate(fieldName: string, value: unknown): import("@anjianshi/utils").Success<unknown> | import("@anjianshi/utils").Failed<string>;
+}

package/dist/validators/string.js

@@ -0,0 +1,29 @@
+import { success, failed } from '@anjianshi/utils';
+import { Validator } from './common.js';
+export class StringValidator extends Validator {
+    constructor(options) {
+        super({
+            trim: true,
+            ...(options ?? {}),
+        });
+    }
+    validate(fieldName, value) {
+        const superResult = super.validate(fieldName, value);
+        if (!superResult.success)
+            return superResult;
+        value = superResult.data;
+        if (value === null || value === undefined)
+            return superResult;
+        const opt = this.options;
+        if (typeof value !== 'string')
+            return failed(`${fieldName} should be a string`);
+        const formatted = opt.trim ? value.trim() : value;
+        if (typeof opt.min === 'number' && formatted.length < opt.min)
+            return failed(`${fieldName}'s length must >= ${opt.min}`);
+        if (typeof opt.max === 'number' && formatted.length > opt.max)
+            return failed(`${fieldName}'s length must <= ${opt.max}`);
+        if (opt.pattern && !opt.pattern.exec(formatted))
+            return failed(`${fieldName} does not match the pattern.`);
+        return success(formatted);
+    }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "starlight-server",
+  "version": "0.0.1",
+  "description": "Simple But Powerful Node.js HTTP Server",
+  "type": "module",
+  "scripts": {
+    "watch": "rimraf dist && tsc && (concurrently \"tsc -w\" \"tsc-alias -w\")",
+    "build": "rimraf dist && tsc && tsc-alias",
+    "demo": "node dist/demo/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "web",
+    "app",
+    "http",
+    "framework"
+  ],
+  "homepage": "https://github.com/anjianshi/starlight-server",
+  "bugs": {
+    "url": "https://github.com/anjianshi/starlight-server/issues",
+    "email": "anjianshi@gmail.com"
+  },
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "license": "MIT",
+  "author": "anjianshi <anjianshi@gmail.com>",
+  "repository": "github:anjianshi/starlight-server",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@anjianshi/utils": "^1.0.9",
+    "chalk": "^5.3.0",
+    "debug": "^4.3.4",
+    "lodash": "^4.17.21",
+    "swagger-ui-dist": "^5.10.3"
+  },
+  "devDependencies": {
+    "@anjianshi/presets": "^1.4.0",
+    "@types/debug": "^4.1.9",
+    "@types/lodash": "^4.14.199",
+    "@types/node": "^20.8.6",
+    "@types/swagger-ui-dist": "^3.30.4",
+    "concurrently": "^8.2.1",
+    "eslint": "^8.54.0",
+    "rimraf": "^4.3.0",
+    "tsc-alias": "^1.8.8",
+    "typescript": "^5.3.2"
+  },
+  "eslintIgnore": [],
+  "prettier": "@anjianshi/presets/prettierrc"
+}

package/src/demo/index.ts

@@ -0,0 +1,33 @@
+import path from 'node:path'
+import { getFileDir } from '@anjianshi/utils/env-node/index.js'
+import { getLogger, startHTTPServer, DefaultRouter } from '@/index.js'
+// import { registerSwaggerRoute } from '@/swagger/index.js'
+
+const logger = getLogger({
+  level: 'debug',
+  debugLib: '*',
+  file: {
+    dir: path.resolve(getFileDir(import.meta), '../../logs'),
+  },
+})
+
+const router = new DefaultRouter()
+
+router.registerResponseReference('hello', { object: [{ name: 'hello', type: 'string' }] })
+
+router.register({
+  method: 'GET',
+  path: '/hello',
+  response: { ref: 'hello' },
+  handler({ response }) {
+    response.json({ hello: 'world' })
+  },
+})
+
+// registerSwaggerRoute(router)
+
+startHTTPServer({
+  handler: router.handle,
+  logger: logger.getChild('http'),
+  port: 8801,
+})

package/src/http/body/form-data.ts

@@ -0,0 +1,164 @@
+/**
+ * Parsing multipart/form-data
+ *
+ * Referenced this library：https://github.com/nachomazzara/parse-multipart-data
+ * (This library has bugs, so I decided to implement it myself.）
+ *
+ * Introduce for multipart/form-data format：https://www.jianshu.com/p/29e38bcc8a1d
+ */
+import { HTTPError } from '../types.js'
+
+/**
+ * 解析后的 FormData（格式参考浏览器环境中的 FormData 对象）
+ * Parsed FormData (formatted like the FormData object in a browser environment)
+ */
+export interface TextInput {
+  type: 'text'
+  name: string
+  data: string
+}
+export interface FileInput {
+  type: 'file'
+  name: string
+  filename: string
+  mimeType: string
+  data: Buffer
+}
+export type Input = TextInput | FileInput
+
+export class FormData {
+  constructor(readonly inputs: Input[]) {}
+
+  get(name: string) {
+    return this.inputs.find(v => v.name === name)
+  }
+  getAll(name: string) {
+    return this.inputs.filter(v => v.name === name)
+  }
+  getText(name: string) {
+    return this.inputs.find((v): v is TextInput => v.name === name && v.type === 'text')?.data
+  }
+  getFile(name: string) {
+    return this.inputs.find((v): v is FileInput => v.name === name && v.type === 'file')
+  }
+  has(name: string) {
+    return !!this.get(name)
+  }
+  hasText(name: string) {
+    return this.getText(name) !== undefined
+  }
+  hasFile(name: string) {
+    return !!this.getFile(name)
+  }
+}
+
+/**
+ * 从 Content-Type Header 中解析出 form-data boundary
+ * Parse form-data boundary from Content-Type header.
+ */
+export function getBoundary(contentType: string) {
+  const prefix = 'multipart/form-data; boundary='
+  return contentType.startsWith(prefix) ? contentType.slice(prefix.length) : null
+}
+
+/**
+ * parse form-data
+ */
+enum State {
+  Init = 0,
+  ReadingHeaders = 1,
+  ReadingData = 2,
+}
+
+export function parseFormData(body: Buffer, boundary: string): FormData {
+  const inputs: Input[] = []
+
+  let rest = body
+  let state: State = State.Init
+  let partialInput: Input | undefined // 在 ReadingHeaders 状态里会为其赋值 Will be assigned when in the ReadingHeaders state
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    if (!rest.byteLength) throw new HTTPError(400, 'form-data: not complete')
+
+    if (state === State.Init) {
+      const sep = `--${boundary}\r\n`
+      if (!startsWith(rest, sep)) throw new HTTPError(400, 'form-data: part separator invalid')
+      rest = rest.subarray(byteLength(sep))
+      state = State.ReadingHeaders
+    } else if (state === State.ReadingHeaders) {
+      if (!startsWith(rest, 'Content-Disposition: form-data;', true))
+        throw new HTTPError(400, 'form-data: headers or format invalid')
+      const headerEnds = Buffer.from('\r\n\r\n')
+      const headerMax = 10000 // header 部分最多允许这么多字节 Max allowd bytes of header
+      const headersEndIndex = rest.subarray(0, headerMax).indexOf(headerEnds)
+      if (headersEndIndex === -1) throw new HTTPError(400, 'form-data: headers invalid or too long')
+
+      const headers = rest
+        .subarray(0, headersEndIndex)
+        .toString()
+        .split('\r\n')
+        .map(item => {
+          const sepIndex = item.indexOf(':')
+          return sepIndex !== -1
+            ? { name: item.slice(0, sepIndex).trim(), value: item.slice(sepIndex + 2).trim() }
+            : null
+        })
+        .filter((v): v is { name: string; value: string } => !!v)
+
+      const disposition =
+        headers.find(v => v.name.toLowerCase() === 'Content-Disposition'.toLowerCase())?.value ?? ''
+      const name = /(?:;| )name="(.*?)"(?:;|$)/.exec(disposition)?.[1] ?? ''
+      const filename = /(?:;| )filename="(.*?)"(?:;|$)/.exec(disposition)?.[1]
+      const contentType = headers.find(
+        v => v.name.toLowerCase() === 'Content-Type'.toLowerCase()
+      )?.value
+      partialInput =
+        filename === undefined
+          ? { type: 'text', name, data: '' }
+          : { type: 'file', name, filename, mimeType: contentType ?? '', data: Buffer.from('') }
+
+      rest = rest.subarray(headersEndIndex + headerEnds.byteLength)
+      state = State.ReadingData
+    } else {
+      const dataEnds = Buffer.from(`\r\n--${boundary}`)
+      const dataEndIndex = rest.indexOf(dataEnds)
+      if (dataEndIndex === -1) throw new HTTPError(400, 'form-data: data no ends')
+      const data = rest.subarray(0, dataEndIndex)
+      const input = partialInput!
+      if (input.type === 'text') input.data = data.toString()
+      else input.data = data
+      inputs.push(input)
+
+      const afterData = rest.subarray(dataEndIndex + dataEnds.byteLength)
+      if (equals(afterData, '--') || equals(afterData, '--\r\n')) {
+        // 全部解析结束 Parse whole finished
+        break
+      } else if (startsWith(afterData, '\r\n')) {
+        // 开始解析下一部分 Parsing next part
+        rest = rest.subarray(dataEndIndex + byteLength('\r\n'))
+        state = State.Init
+      } else {
+        throw new HTTPError(400, 'form-data: invalid data ends')
+      }
+    }
+  }
+
+  return new FormData(inputs)
+}
+
+function byteLength(string: string) {
+  return Buffer.byteLength(string)
+}
+
+function startsWith(buffer: Buffer, string: string, caseInsensitive = false) {
+  const sliced = buffer.subarray(0, byteLength(string)).toString()
+  return caseInsensitive ? sliced.toLowerCase() === string.toLowerCase() : sliced === string
+}
+
+function equals(buffer: Buffer, string: string) {
+  return (
+    // 先进行长度比较，以避免 buffer 太大时进行 toString() 影响性能
+    // Perform a length comparison first to avoid the performance impact of toString() when the buffer is too large.
+    buffer.byteLength === byteLength(string) && buffer.toString() === string
+  )
+}

package/src/http/body/index.ts

@@ -0,0 +1,59 @@
+import { HTTPError, type NodeRequest } from '../types.js'
+import { getBoundary, parseFormData } from './form-data.js'
+import { receiveBody } from './receive.js'
+
+export interface BodyOptions {
+  /**
+   * Maximum size of body, unit `M`.
+   * @default 1000
+   */
+  limit?: number
+}
+
+/**
+ * Receive And Parse Request Body
+ * Support JSON And multipart/form-data
+ */
+export class RequestBody {
+  constructor(
+    readonly nodeRequest: NodeRequest,
+    readonly options: BodyOptions,
+  ) {}
+
+  get contentType() {
+    return this.nodeRequest.headers['content-type'] ?? ''
+  }
+
+  protected receiving?: Promise<Buffer | undefined>
+  async buffer() {
+    if (!this.receiving)
+      this.receiving = receiveBody(this.nodeRequest, (this.options.limit ?? 1000) * 1000 * 1000)
+    return this.receiving
+  }
+
+  async json() {
+    if (this.contentType && !this.contentType.startsWith('application/json')) {
+      throw new HTTPError(400, "JSON parse failed, invalid 'Content-Type'.")
+    }
+
+    const buffer = await this.buffer()
+    if (!buffer) return undefined
+
+    try {
+      return JSON.parse(buffer.toString()) as unknown
+    } catch (e) {
+      throw new HTTPError(400, 'Invalid JSON.')
+    }
+  }
+
+  async formData() {
+    const boundary = getBoundary(this.contentType)
+    if (boundary === null)
+      throw new HTTPError(400, "form-data parse failed, invalid 'Content-Type'.")
+
+    const buffer = await this.buffer()
+    if (!buffer) return undefined
+
+    return parseFormData(buffer, boundary)
+  }
+}

package/src/http/body/receive.ts

@@ -0,0 +1,49 @@
+import { type NodeRequest, HTTPError } from '../types.js'
+
+export async function receiveBody(
+  nodeRequest: NodeRequest,
+
+  /**
+   * Maximum size of body, unit `byte`
+   */
+  limit: number,
+) {
+  return new Promise<Buffer | undefined>(callback.bind(null, nodeRequest, limit))
+}
+
+function callback(
+  nodeRequest: NodeRequest,
+  limit: number,
+  resolve: (result: Buffer | undefined) => void,
+  reject: (error: HTTPError) => void,
+) {
+  // 若客户端提供了 Content-Length，确认其小于限额（若不符合要求，直接跳过接收）
+  // If the client provides a Content-Length header, confirm that it is less than the maximum allowed size (if not, skip receiving it).
+  let contentLength: number | undefined
+  if ('content-length' in nodeRequest.headers) {
+    contentLength = parseInt(nodeRequest.headers['content-length'] ?? '', 10)
+    if (!isFinite(contentLength)) return void reject(new HTTPError(400, 'Invalid Content-Length'))
+    if (contentLength > limit) return void reject(new HTTPError(413))
+  }
+
+  const parts: Buffer[] = []
+  let recvLength = 0
+  const handleData = (part: Buffer) => {
+    parts.push(part)
+    recvLength += part.byteLength
+
+    if (recvLength > limit) {
+      nodeRequest.off('data', handleData)
+      nodeRequest.off('end', handleEnd)
+      reject(new HTTPError(413))
+    }
+  }
+  const handleEnd = () => {
+    if (contentLength !== undefined && recvLength !== contentLength)
+      reject(new HTTPError(400, 'Content-Length mismatch.'))
+    else resolve(parts.length ? Buffer.concat(parts) : undefined)
+  }
+
+  nodeRequest.on('data', handleData)
+  nodeRequest.on('end', handleEnd)
+}

package/src/http/http-status.ts

@@ -0,0 +1,65 @@
+/**
+ * HTTP Status
+ * From：https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+ */
+export const HTTPStatus = [
+  '100 Continue',
+  '101 Switching Protocols',
+  '103 Early Hints',
+  '200 OK',
+  '201 Created',
+  '202 Accepted',
+  '203 Non-Authoritative Information',
+  '204 No Content',
+  '205 Reset Content',
+  '206 Partial Content',
+  '300 Multiple Choices',
+  '301 Moved Permanently',
+  '302 Found',
+  '303 See Other',
+  '304 Not Modified',
+  '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 Payload Too Large',
+  '414 URI Too Long',
+  '415 Unsupported Media Type',
+  '416 Range Not Satisfiable',
+  '417 Expectation Failed',
+  "418 I'm a teapot",
+  '422 Unprocessable Entity',
+  '425 Too Early',
+  '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',
+  '506 Variant Also Negotiates',
+  '507 Insufficient Storage',
+  '508 Loop Detected',
+  '510 Not Extended',
+  '511 Network Authentication Required',
+]
+
+/**
+ * Map(400 => '400 Bad Request')
+ */
+export const HTTPStatusMap = new Map(HTTPStatus.map(item => [parseInt(item.slice(0, 3), 10), item]))

package/src/http/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 在协议层面，实现对 HTTP 请求的处理
+ */
+export * from './types.js'
+export * from './request.js'
+export * from './response.js'
+export * from './server.js'
+export * from './http-status.js'
+export * from './mime-types.js'