starlight-server 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 安坚实
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# Starlight Server: Simple But Powerful Node.js HTTP Server

package/dist/demo/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/demo/index.js

@@ -0,0 +1,27 @@
+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/dist/http/body/form-data.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * 解析后的 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 declare class FormData {
+    readonly inputs: Input[];
+    constructor(inputs: Input[]);
+    get(name: string): Input | undefined;
+    getAll(name: string): Input[];
+    getText(name: string): string | undefined;
+    getFile(name: string): FileInput | undefined;
+    has(name: string): boolean;
+    hasText(name: string): boolean;
+    hasFile(name: string): boolean;
+}
+/**
+ * 从 Content-Type Header 中解析出 form-data boundary
+ * Parse form-data boundary from Content-Type header.
+ */
+export declare function getBoundary(contentType: string): string | null;
+export declare function parseFormData(body: Buffer, boundary: string): FormData;

package/dist/http/body/form-data.js

@@ -0,0 +1,141 @@
+/**
+ * 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';
+export class FormData {
+    inputs;
+    constructor(inputs) {
+        this.inputs = inputs;
+    }
+    get(name) {
+        return this.inputs.find(v => v.name === name);
+    }
+    getAll(name) {
+        return this.inputs.filter(v => v.name === name);
+    }
+    getText(name) {
+        return this.inputs.find((v) => v.name === name && v.type === 'text')?.data;
+    }
+    getFile(name) {
+        return this.inputs.find((v) => v.name === name && v.type === 'file');
+    }
+    has(name) {
+        return !!this.get(name);
+    }
+    hasText(name) {
+        return this.getText(name) !== undefined;
+    }
+    hasFile(name) {
+        return !!this.getFile(name);
+    }
+}
+/**
+ * 从 Content-Type Header 中解析出 form-data boundary
+ * Parse form-data boundary from Content-Type header.
+ */
+export function getBoundary(contentType) {
+    const prefix = 'multipart/form-data; boundary=';
+    return contentType.startsWith(prefix) ? contentType.slice(prefix.length) : null;
+}
+/**
+ * parse form-data
+ */
+var State;
+(function (State) {
+    State[State["Init"] = 0] = "Init";
+    State[State["ReadingHeaders"] = 1] = "ReadingHeaders";
+    State[State["ReadingData"] = 2] = "ReadingData";
+})(State || (State = {}));
+export function parseFormData(body, boundary) {
+    const inputs = [];
+    let rest = body;
+    let state = State.Init;
+    let partialInput; // 在 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);
+            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) {
+    return Buffer.byteLength(string);
+}
+function startsWith(buffer, string, caseInsensitive = false) {
+    const sliced = buffer.subarray(0, byteLength(string)).toString();
+    return caseInsensitive ? sliced.toLowerCase() === string.toLowerCase() : sliced === string;
+}
+function equals(buffer, 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/dist/http/body/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type NodeRequest } from '../types.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 declare class RequestBody {
+    readonly nodeRequest: NodeRequest;
+    readonly options: BodyOptions;
+    constructor(nodeRequest: NodeRequest, options: BodyOptions);
+    get contentType(): string;
+    protected receiving?: Promise<Buffer | undefined>;
+    buffer(): Promise<Buffer | undefined>;
+    json(): Promise<unknown>;
+    formData(): Promise<import("./form-data.js").FormData | undefined>;
+}

package/dist/http/body/index.js

@@ -0,0 +1,47 @@
+import { HTTPError } from '../types.js';
+import { getBoundary, parseFormData } from './form-data.js';
+import { receiveBody } from './receive.js';
+/**
+ * Receive And Parse Request Body
+ * Support JSON And multipart/form-data
+ */
+export class RequestBody {
+    nodeRequest;
+    options;
+    constructor(nodeRequest, options) {
+        this.nodeRequest = nodeRequest;
+        this.options = options;
+    }
+    get contentType() {
+        return this.nodeRequest.headers['content-type'] ?? '';
+    }
+    receiving;
+    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());
+        }
+        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/dist/http/body/receive.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" resolution-mode="require"/>
+import { type NodeRequest } from '../types.js';
+export declare function receiveBody(nodeRequest: NodeRequest, 
+/**
+ * Maximum size of body, unit `byte`
+ */
+limit: number): Promise<Buffer | undefined>;

package/dist/http/body/receive.js

@@ -0,0 +1,39 @@
+import { HTTPError } from '../types.js';
+export async function receiveBody(nodeRequest, 
+/**
+ * Maximum size of body, unit `byte`
+ */
+limit) {
+    return new Promise(callback.bind(null, nodeRequest, limit));
+}
+function callback(nodeRequest, limit, resolve, reject) {
+    // 若客户端提供了 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;
+    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 = [];
+    let recvLength = 0;
+    const handleData = (part) => {
+        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/dist/http/http-status.d.ts

@@ -0,0 +1,9 @@
+/**
+ * HTTP Status
+ * From：https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+ */
+export declare const HTTPStatus: string[];
+/**
+ * Map(400 => '400 Bad Request')
+ */
+export declare const HTTPStatusMap: Map<number, string>;

package/dist/http/http-status.js

@@ -0,0 +1,64 @@
+/**
+ * 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/dist/http/index.d.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';

package/dist/http/index.js

@@ -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';

package/dist/http/mime-types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 传入文件路径，返回此文件的 MIME Type。路径不含扩展名或找不到对应类型的，返回 null。
+ * Given a file path, return the MIME Type of the file.
+ * If the path does not contain an extension or if the type cannot be found, return null.
+ */
+export declare function path2MIMEType(path: string): string | null;
+export declare const MIMETypes: {
+    type: string;
+    extensions: string[];
+}[];
+/**
+ * Map(.ext => 'MIME-Type')
+ */
+export declare const MIMETypesMap: Map<string, string>;