starlight-server 1.7.1 → 1.7.3

package/dist/router/helpers.d.ts

@@ -1,9 +1,12 @@
+import { type MaySuccess } from '@anjianshi/utils';
 import { type Definition as ValidatorDefinition } from '@anjianshi/utils/validators/index.js';
-import { type BasicContext } from './index.js';
-import { ResponseUtils } from '../http/response.js';
-export declare class Helpers {
-    readonly context: BasicContext;
-    constructor(context: BasicContext);
+import { type Request } from '../http/request.js';
+import { type ResponseUtils } from '../http/response.js';
+import { type PathParameters } from './match-path.js';
+declare class RequestHelpers {
+    readonly request: Request;
+    readonly pathParameters: PathParameters;
+    constructor(request: Request, pathParameters: PathParameters);
     validatePathParameters<Definition extends Record<string, ValidatorDefinition>>(struct: Definition): import("@anjianshi/utils/validators/base.js").Validated<{
         readonly type: "struct";
         readonly struct: Definition;
@@ -56,9 +59,18 @@ export declare class Helpers {
         record: import("@anjianshi/utils/validators/factory.js").ValidatorForDefinition<T_1["record"]>;
     } : T_1 : never : never>>;
 }
-export declare class ResponseUtilsWithHelpers extends ResponseUtils {
+export type RequestWithHelpers = Request & RequestHelpers;
+export declare function getRequestWithHelpers(request: Request, pathParameters: PathParameters): RequestWithHelpers;
+declare class ResponseUtilsHelpers {
+    readonly response: ResponseUtils;
     constructor(response: ResponseUtils);
-    success(data?: unknown): void;
-    failed(message: string, code?: string | number): void;
-    failed<T>(message: string, code: string | number | undefined, data: T): void;
+    success(data?: unknown): never;
+    failed(message: string, code?: string | number): never;
+    failed<T>(message: string, code: string | number | undefined, data: T): never;
+    maySuccess(result: MaySuccess<unknown, unknown>): never;
 }
+export declare class ResponseFinish {
+}
+export type ResponseUtilsWithHelpers = ResponseUtils & ResponseUtilsHelpers;
+export declare function getResponseUtilsWithHelpers(response: ResponseUtils): ResponseUtilsWithHelpers;
+export {};

package/dist/router/helpers.js

@@ -1,26 +1,27 @@
 import { success, failed } from '@anjianshi/utils';
 import { getValidator, } from '@anjianshi/utils/validators/index.js';
 import { HTTPError } from '../index.js';
-import { ResponseUtils } from '../http/response.js';
-export class Helpers {
-    context;
-    constructor(context) {
-        this.context = context;
+class RequestHelpers {
+    request;
+    pathParameters;
+    constructor(request, pathParameters) {
+        this.request = request;
+        this.pathParameters = pathParameters;
     }
     validatePathParameters(struct) {
-        const result = getValidator({ type: 'struct', struct })('path', this.context.pathParameters);
+        const result = getValidator({ type: 'struct', struct })('path', this.pathParameters);
         if (result.success)
             return result.data;
         throw new HTTPError(400, result.message);
     }
     validateQuery(struct) {
-        const result = getValidator({ type: 'struct', struct })('query', this.context.request.query);
+        const result = getValidator({ type: 'struct', struct })('query', this.request.query);
         if (result.success)
             return result.data;
         throw new HTTPError(400, result.message);
     }
     async validateBody(struct) {
-        const body = await this.context.request.body.json();
+        const body = await this.request.body.json();
         if (typeof body !== 'object' || body === null || Array.isArray(body))
             throw new HTTPError(400, 'Invalid JSON body, should be an object.');
         const result = getValidator({ type: 'struct', struct })('body', body);
@@ -29,14 +30,46 @@ export class Helpers {
         throw new HTTPError(400, result.message);
     }
 }
-export class ResponseUtilsWithHelpers extends ResponseUtils {
+export function getRequestWithHelpers(request, pathParameters) {
+    const helpers = new RequestHelpers(request, pathParameters);
+    return new Proxy(request, {
+        get(target, prop) {
+            if (prop in helpers)
+                return helpers[prop];
+            return request[prop];
+        },
+    });
+}
+// -----------------------------
+class ResponseUtilsHelpers {
+    response;
     constructor(response) {
-        super(response.nodeResponse, response.logger, response.jsonReplacer);
+        this.response = response;
     }
+    // 输出成功结果，并结束响应处理
     success(data) {
-        this.json(success(data));
+        this.maySuccess(success(data));
     }
     failed(message, code, data) {
-        this.json(failed(message, code, data));
+        this.maySuccess(failed(message, code, data));
+    }
+    // 输出 MaySuccess 对象，并结束响应处理
+    maySuccess(result) {
+        this.response.json(result);
+        throw new ResponseFinish();
     }
 }
+// 通过捕获此对象实现提前结束响应处理
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class ResponseFinish {
+}
+export function getResponseUtilsWithHelpers(response) {
+    const helpers = new ResponseUtilsHelpers(response);
+    return new Proxy(response, {
+        get(target, prop) {
+            if (prop in helpers)
+                return helpers[prop];
+            return response[prop];
+        },
+    });
+}

package/dist/router/index.d.ts

@@ -2,16 +2,12 @@ import { type OptionalFields } from '@anjianshi/utils';
 import { type CORSRule } from '../http/cors.js';
 import { type Request, type ResponseUtils } from '../http/index.js';
 import { Swagger, type Method } from '../swagger/index.js';
-import { Helpers, ResponseUtilsWithHelpers } from './helpers.js';
+import { type RequestWithHelpers, type ResponseUtilsWithHelpers, ResponseFinish } from './helpers.js';
 import { type PathParameters } from './match-path.js';
-type HelpersInst = InstanceType<typeof Helpers>;
 export interface BasicContext {
-    request: Request;
-    response: ResponseUtilsWithHelpers;
     pathParameters: PathParameters;
-    validatePathParameters: HelpersInst['validatePathParameters'];
-    validateQuery: HelpersInst['validateQuery'];
-    validateBody: HelpersInst['validateBody'];
+    request: RequestWithHelpers;
+    response: ResponseUtilsWithHelpers;
 }
 /** 使用者可自行补充 Context 定义  */
 export interface Context extends BasicContext {
@@ -25,6 +21,8 @@ export interface Route {
     /** 此接口的 CORS 规则 */
     cors?: CORSRule;
 }
+/** handler 里抛出此异常可提前结束请求处理 */
+export { ResponseFinish };
 export declare class Router {
     /**
      * ----------------------
@@ -65,6 +63,5 @@ export declare class Router {
      * 请求处理
      * ----------------------
      */
-    readonly handle: (request: Request, originResponse: ResponseUtils) => Promise<void>;
+    readonly handle: (request: Request, response: ResponseUtils) => Promise<void>;
 }
-export {};

package/dist/router/index.js

@@ -2,8 +2,10 @@ import { joinPath } from '@anjianshi/utils';
 import { getPreflightRequestMethod, handleCORS } from '../http/cors.js';
 import { HTTPError } from '../http/index.js';
 import { Swagger } from '../swagger/index.js';
-import { Helpers, ResponseUtilsWithHelpers } from './helpers.js';
+import { getRequestWithHelpers, getResponseUtilsWithHelpers, ResponseFinish, } from './helpers.js';
 import { matchPath } from './match-path.js';
+/** handler 里抛出此异常可提前结束请求处理 */
+export { ResponseFinish };
 export class Router {
     /**
      * ----------------------
@@ -78,8 +80,7 @@ export class Router {
      * 请求处理
      * ----------------------
      */
-    handle = async (request, originResponse) => {
-        const response = new ResponseUtilsWithHelpers(originResponse);
+    handle = async (request, response) => {
         const pathMatchedRoutes = matchPath(this.routes.map(route => route.path), request.path).map(result => ({ route: this.routes[result.index], parameters: result.parameters }));
         if (!pathMatchedRoutes.length)
             throw new HTTPError(404); // 没有路径匹配的路由
@@ -100,18 +101,21 @@ export class Router {
             const corsRule = matched.route.cors ?? this.cors;
             handleCORS(request, response, typeof corsRule === 'function' ? corsRule(request) : corsRule);
         }
+        const requestWithHelpers = getRequestWithHelpers(request, matched.parameters);
+        const responseWithHelpers = getResponseUtilsWithHelpers(response);
         const basicContext = {};
-        const helpers = new Helpers(basicContext);
         Object.assign(basicContext, {
-            request,
-            response,
-            pathParameters: matched.parameters,
-            validatePathParameters: helpers.validatePathParameters.bind(helpers),
-            validateQuery: helpers.validateQuery.bind(helpers),
-            validateBody: helpers.validateBody.bind(helpers),
+            request: requestWithHelpers,
+            response: responseWithHelpers,
         });
-        const result = await this.executor(basicContext, matched.route);
-        if (result !== undefined)
-            throw new Error('route handler 不应该有返回值');
+        try {
+            const result = await this.executor(basicContext, matched.route);
+            if (result !== undefined)
+                throw new Error('route handler 不应该有返回值');
+        }
+        catch (error) {
+            if (!(error instanceof ResponseFinish))
+                throw error;
+        }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-server",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "description": "Simple But Powerful Node.js HTTP Server",
   "type": "module",
   "keywords": [

package/src/router/helpers.ts

@@ -1,34 +1,38 @@
-import { success, failed } from '@anjianshi/utils'
+import { type MaySuccess, success, failed } from '@anjianshi/utils'
 import {
   getValidator,
   type Definition as ValidatorDefinition,
 } from '@anjianshi/utils/validators/index.js'
 import { HTTPError } from '@/index.js'
-import { type BasicContext } from './index.js'
-import { ResponseUtils } from '@/http/response.js'
+import { type Request } from '@/http/request.js'
+import { type ResponseUtils } from '@/http/response.js'
+import { type PathParameters } from './match-path.js'
 
-export class Helpers {
-  constructor(readonly context: BasicContext) {}
+class RequestHelpers {
+  constructor(
+    readonly request: Request,
+    readonly pathParameters: PathParameters,
+  ) {}
 
   validatePathParameters<Definition extends Record<string, ValidatorDefinition>>(
     struct: Definition,
   ) {
     const result = getValidator({ type: 'struct', struct })(
       'path',
-      this.context.pathParameters as Record<string, string>,
+      this.pathParameters as Record<string, string>,
     )
     if (result.success) return result.data
     throw new HTTPError(400, result.message)
   }
 
   validateQuery<Definition extends Record<string, ValidatorDefinition>>(struct: Definition) {
-    const result = getValidator({ type: 'struct', struct })('query', this.context.request.query)
+    const result = getValidator({ type: 'struct', struct })('query', this.request.query)
     if (result.success) return result.data
     throw new HTTPError(400, result.message)
   }
 
   async validateBody<Definition extends Record<string, ValidatorDefinition>>(struct: Definition) {
-    const body = await this.context.request.body.json()
+    const body = await this.request.body.json()
     if (typeof body !== 'object' || body === null || Array.isArray(body))
       throw new HTTPError(400, 'Invalid JSON body, should be an object.')
 
@@ -38,18 +42,54 @@ export class Helpers {
   }
 }
 
-export class ResponseUtilsWithHelpers extends ResponseUtils {
-  constructor(response: ResponseUtils) {
-    super(response.nodeResponse, response.logger, response.jsonReplacer)
-  }
+export type RequestWithHelpers = Request & RequestHelpers
+
+export function getRequestWithHelpers(request: Request, pathParameters: PathParameters) {
+  const helpers = new RequestHelpers(request, pathParameters)
+  return new Proxy(request, {
+    get(target, prop): unknown {
+      if (prop in helpers) return helpers[prop as keyof RequestHelpers]
+      return request[prop as keyof Request]
+    },
+  }) as RequestWithHelpers
+}
 
-  success(data?: unknown) {
-    this.json(success(data))
+// -----------------------------
+
+class ResponseUtilsHelpers {
+  constructor(readonly response: ResponseUtils) {}
+
+  // 输出成功结果，并结束响应处理
+  success(data?: unknown): never {
+    this.maySuccess(success(data))
   }
 
-  failed(message: string, code?: string | number): void
-  failed<T>(message: string, code: string | number | undefined, data: T): void
+  // 输出失败结果，并结束响应处理
+  failed(message: string, code?: string | number): never
+  failed<T>(message: string, code: string | number | undefined, data: T): never
   failed<T>(message: string, code?: string | number, data?: T) {
-    this.json(failed(message, code, data))
+    this.maySuccess(failed(message, code, data))
   }
+
+  // 输出 MaySuccess 对象，并结束响应处理
+  maySuccess(result: MaySuccess<unknown, unknown>): never {
+    this.response.json(result)
+    throw new ResponseFinish()
+  }
+}
+
+// 通过捕获此对象实现提前结束响应处理
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class ResponseFinish {}
+
+export type ResponseUtilsWithHelpers = ResponseUtils & ResponseUtilsHelpers
+
+export function getResponseUtilsWithHelpers(response: ResponseUtils) {
+  const helpers = new ResponseUtilsHelpers(response)
+  return new Proxy(response, {
+    get(target, prop) {
+      if (prop in helpers) return helpers[prop as keyof ResponseUtilsHelpers]
+      return response[prop as keyof ResponseUtils]
+    },
+  }) as ResponseUtilsWithHelpers
 }

package/src/router/index.ts

@@ -2,17 +2,19 @@ import { type OptionalFields, joinPath } from '@anjianshi/utils'
 import { getPreflightRequestMethod, handleCORS, type CORSRule } from '@/http/cors.js'
 import { HTTPError, type Request, type ResponseUtils } from '@/http/index.js'
 import { Swagger, type Method } from '@/swagger/index.js'
-import { Helpers, ResponseUtilsWithHelpers } from './helpers.js'
+import {
+  getRequestWithHelpers,
+  getResponseUtilsWithHelpers,
+  type RequestWithHelpers,
+  type ResponseUtilsWithHelpers,
+  ResponseFinish,
+} from './helpers.js'
 import { matchPath, type PathParameters } from './match-path.js'
 
-type HelpersInst = InstanceType<typeof Helpers>
 export interface BasicContext {
-  request: Request
-  response: ResponseUtilsWithHelpers
   pathParameters: PathParameters
-  validatePathParameters: HelpersInst['validatePathParameters']
-  validateQuery: HelpersInst['validateQuery']
-  validateBody: HelpersInst['validateBody']
+  request: RequestWithHelpers
+  response: ResponseUtilsWithHelpers
 }
 
 /** 使用者可自行补充 Context 定义  */
@@ -28,6 +30,9 @@ export interface Route {
   cors?: CORSRule
 }
 
+/** handler 里抛出此异常可提前结束请求处理 */
+export { ResponseFinish }
+
 export class Router {
   /**
    * ----------------------
@@ -107,9 +112,7 @@ export class Router {
    * 请求处理
    * ----------------------
    */
-  readonly handle = async (request: Request, originResponse: ResponseUtils) => {
-    const response = new ResponseUtilsWithHelpers(originResponse)
-
+  readonly handle = async (request: Request, response: ResponseUtils) => {
     const pathMatchedRoutes = matchPath(
       this.routes.map(route => route.path),
       request.path,
@@ -135,18 +138,20 @@ export class Router {
       handleCORS(request, response, typeof corsRule === 'function' ? corsRule(request) : corsRule)
     }
 
+    const requestWithHelpers = getRequestWithHelpers(request, matched.parameters)
+    const responseWithHelpers = getResponseUtilsWithHelpers(response)
+
     const basicContext = {} as BasicContext
-    const helpers = new Helpers(basicContext)
     Object.assign(basicContext, {
-      request,
-      response,
-      pathParameters: matched.parameters,
-      validatePathParameters: helpers.validatePathParameters.bind(helpers),
-      validateQuery: helpers.validateQuery.bind(helpers),
-      validateBody: helpers.validateBody.bind(helpers),
+      request: requestWithHelpers,
+      response: responseWithHelpers,
     })
 
-    const result = await (this.executor(basicContext, matched.route) as Promise<unknown>)
-    if (result !== undefined) throw new Error('route handler 不应该有返回值')
+    try {
+      const result = await (this.executor(basicContext, matched.route) as Promise<unknown>)
+      if (result !== undefined) throw new Error('route handler 不应该有返回值')
+    } catch (error) {
+      if (!(error instanceof ResponseFinish)) throw error
+    }
   }
 }