starlight-server 1.7.0 → 1.7.2

package/dist/router/helpers.d.ts

@@ -1,8 +1,11 @@
 import { type Definition as ValidatorDefinition } from '@anjianshi/utils/validators/index.js';
-import { type BasicContext } from './index.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;
@@ -54,7 +57,16 @@ export declare class Helpers {
     } : T_1 extends import("@anjianshi/utils/validators/factory.js").RecordDefinition ? Omit<T_1, "record"> & {
         record: import("@anjianshi/utils/validators/factory.js").ValidatorForDefinition<T_1["record"]>;
     } : T_1 : never : never>>;
+}
+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;
 }
+export type ResponseUtilsWithHelpers = ResponseUtils & ResponseUtilsHelpers;
+export declare function getResponseUtilsWithHelpers(response: ResponseUtils): ResponseUtilsWithHelpers;
+export {};

package/dist/router/helpers.js

@@ -1,25 +1,27 @@
 import { success, failed } from '@anjianshi/utils';
 import { getValidator, } from '@anjianshi/utils/validators/index.js';
 import { HTTPError } from '../index.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);
@@ -27,10 +29,37 @@ export class Helpers {
             return result.data;
         throw new HTTPError(400, result.message);
     }
+}
+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) {
+        this.response = response;
+    }
     success(data) {
-        this.context.response.json(success(data));
+        this.response.json(success(data));
     }
     failed(message, code, data) {
-        this.context.response.json(failed(message, code, data));
+        this.response.json(failed(message, code, data));
     }
 }
+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,18 +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 } from './helpers.js';
+import { type RequestWithHelpers, type ResponseUtilsWithHelpers } from './helpers.js';
 import { type PathParameters } from './match-path.js';
-type HelpersInst = InstanceType<typeof Helpers>;
 export interface BasicContext {
-    request: Request;
-    response: ResponseUtils;
     pathParameters: PathParameters;
-    validatePathParameters: HelpersInst['validatePathParameters'];
-    validateQuery: HelpersInst['validateQuery'];
-    validateBody: HelpersInst['validateBody'];
-    success: HelpersInst['success'];
-    failed: HelpersInst['failed'];
+    request: RequestWithHelpers;
+    response: ResponseUtilsWithHelpers;
 }
 /** 使用者可自行补充 Context 定义  */
 export interface Context extends BasicContext {
@@ -69,4 +63,3 @@ export declare class Router {
      */
     readonly handle: (request: Request, response: ResponseUtils) => Promise<void>;
 }
-export {};

package/dist/router/index.js

@@ -2,7 +2,7 @@ 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 } from './helpers.js';
+import { getRequestWithHelpers, getResponseUtilsWithHelpers, } from './helpers.js';
 import { matchPath } from './match-path.js';
 export class Router {
     /**
@@ -99,17 +99,12 @@ 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),
-            success: helpers.success.bind(helpers),
-            failed: helpers.failed.bind(helpers),
+            request: requestWithHelpers,
+            response: responseWithHelpers,
         });
         const result = await this.executor(basicContext, matched.route);
         if (result !== undefined)

package/package.json

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

package/src/router/helpers.ts

@@ -4,30 +4,35 @@ import {
   type Definition as ValidatorDefinition,
 } from '@anjianshi/utils/validators/index.js'
 import { HTTPError } from '@/index.js'
-import { type BasicContext } from './index.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.')
 
@@ -35,14 +40,44 @@ export class Helpers {
     if (result.success) return result.data
     throw new HTTPError(400, result.message)
   }
+}
+
+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
+}
+
+// -----------------------------
+
+class ResponseUtilsHelpers {
+  constructor(readonly response: ResponseUtils) {}
 
   success(data?: unknown) {
-    this.context.response.json(success(data))
+    this.response.json(success(data))
   }
 
   failed(message: string, code?: string | number): void
   failed<T>(message: string, code: string | number | undefined, data: T): void
   failed<T>(message: string, code?: string | number, data?: T) {
-    this.context.response.json(failed(message, code, data))
+    this.response.json(failed(message, code, data))
   }
 }
+
+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,19 +2,18 @@ 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 } from './helpers.js'
+import {
+  getRequestWithHelpers,
+  getResponseUtilsWithHelpers,
+  type RequestWithHelpers,
+  type ResponseUtilsWithHelpers,
+} from './helpers.js'
 import { matchPath, type PathParameters } from './match-path.js'
 
-type HelpersInst = InstanceType<typeof Helpers>
 export interface BasicContext {
-  request: Request
-  response: ResponseUtils
   pathParameters: PathParameters
-  validatePathParameters: HelpersInst['validatePathParameters']
-  validateQuery: HelpersInst['validateQuery']
-  validateBody: HelpersInst['validateBody']
-  success: HelpersInst['success']
-  failed: HelpersInst['failed']
+  request: RequestWithHelpers
+  response: ResponseUtilsWithHelpers
 }
 
 /** 使用者可自行补充 Context 定义  */
@@ -135,17 +134,13 @@ 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),
-      success: helpers.success.bind(helpers),
-      failed: helpers.failed.bind(helpers),
+      request: requestWithHelpers,
+      response: responseWithHelpers,
     })
 
     const result = await (this.executor(basicContext, matched.route) as Promise<unknown>)