@eggjs/koa 2.20.1 → 2.20.3

package/src/application.ts

@@ -11,7 +11,7 @@ import onFinished from 'on-finished';
 import statuses from 'statuses';
 import compose from 'koa-compose';
 import { HttpError } from 'http-errors';
-import { Context, type ContextDelegation } from './context.js';
+import { Context } from './context.js';
 import { Request } from './request.js';
 import { Response } from './response.js';
 import type { CustomError, AnyProto } from './types.js';
@@ -21,13 +21,13 @@ const debug = debuglog('@eggjs/koa/application');
 export type ProtoImplClass<T = object> = new(...args: any[]) => T;
 export type Next = () => Promise<void>;
 type _MiddlewareFunc<T> = (ctx: T, next: Next) => Promise<void> | void;
-export type MiddlewareFunc<T = ContextDelegation> = _MiddlewareFunc<T> & { _name?: string };
+export type MiddlewareFunc<T extends Context = Context> = _MiddlewareFunc<T> & { _name?: string };
 
 /**
  * Expose `Application` class.
  * Inherits from `Emitter.prototype`.
  */
-export class Application extends Emitter {
+export class Application<T extends Context = Context> extends Emitter {
   [key: symbol]: unknown;
   /**
    * Make HttpError available to consumers of the library so that consumers don't
@@ -41,14 +41,14 @@ export class Application extends Emitter {
   proxyIpHeader: string;
   maxIpsCount: number;
   protected _keys?: string[];
-  middleware: MiddlewareFunc[];
-  ctxStorage: AsyncLocalStorage<ContextDelegation>;
+  middleware: MiddlewareFunc<T>[];
+  ctxStorage: AsyncLocalStorage<T>;
   silent: boolean;
-  ContextClass: ProtoImplClass<ContextDelegation>;
+  ContextClass: ProtoImplClass<T>;
   context: AnyProto;
-  RequestClass: ProtoImplClass<Request>;
+  RequestClass: ProtoImplClass<Request<T>>;
   request: AnyProto;
-  ResponseClass: ProtoImplClass<Response>;
+  ResponseClass: ProtoImplClass<Response<T>>;
   response: AnyProto;
 
   /**
@@ -84,11 +84,11 @@ export class Application extends Emitter {
     this.middleware = [];
     this.ctxStorage = getAsyncLocalStorage();
     this.silent = false;
-    this.ContextClass = class ApplicationContext extends Context {} as any;
+    this.ContextClass = class ApplicationContext extends Context {} as ProtoImplClass<T>;
     this.context = this.ContextClass.prototype;
-    this.RequestClass = class ApplicationRequest extends Request {};
+    this.RequestClass = class ApplicationRequest extends Request {} as ProtoImplClass<Request<T>>;
     this.request = this.RequestClass.prototype;
-    this.ResponseClass = class ApplicationResponse extends Response {};
+    this.ResponseClass = class ApplicationResponse extends Response {} as ProtoImplClass<Response<T>>;
     this.response = this.ResponseClass.prototype;
   }
 
@@ -151,7 +151,7 @@ export class Application extends Emitter {
   /**
    * Use the given middleware `fn`.
    */
-  use(fn: MiddlewareFunc) {
+  use(fn: MiddlewareFunc<T>) {
     if (typeof fn !== 'function') throw new TypeError('middleware must be a function!');
     const name = fn._name || fn.name || '-';
     if (isGeneratorFunction(fn)) {
@@ -196,7 +196,7 @@ export class Application extends Emitter {
    * Handle request in callback.
    * @private
    */
-  protected async handleRequest(ctx: ContextDelegation, fnMiddleware: (ctx: ContextDelegation) => Promise<void>) {
+  protected async handleRequest(ctx: T, fnMiddleware: (ctx: T) => Promise<void>) {
     this.emit('request', ctx);
     const res = ctx.res;
     res.statusCode = 404;
@@ -219,7 +219,7 @@ export class Application extends Emitter {
    * Initialize a new context.
    * @private
    */
-  protected createContext(req: IncomingMessage, res: ServerResponse) {
+  createContext(req: IncomingMessage, res: ServerResponse) {
     const context = new this.ContextClass(this, req, res);
     return context;
   }
@@ -246,7 +246,7 @@ export class Application extends Emitter {
   /**
    * Response helper.
    */
-  protected _respond(ctx: ContextDelegation) {
+  protected _respond(ctx: T) {
     // allow bypassing koa
     if (ctx.respond === false) return;
 
@@ -303,5 +303,3 @@ export class Application extends Emitter {
     res.end(body);
   }
 }
-
-export default Application;

package/src/context.ts

@@ -1,10 +1,11 @@
 import util from 'node:util';
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ParsedUrlQuery } from 'node:querystring';
 import createError from 'http-errors';
 import httpAssert from 'http-assert';
-import delegate from 'delegates';
 import statuses from 'statuses';
 import Cookies from 'cookies';
+import { type Accepts } from 'accepts';
 import type { Application } from './application.js';
 import type { Request } from './request.js';
 import type { Response } from './response.js';
@@ -17,15 +18,14 @@ export class Context {
   res: ServerResponse;
   request: Request & AnyProto;
   response: Response & AnyProto;
-  state: Record<string, any>;
   originalUrl: string;
   respond?: boolean;
+  #state: Record<string, any> = {};
 
   constructor(app: Application, req: IncomingMessage, res: ServerResponse) {
     this.app = app;
     this.req = req;
     this.res = res;
-    this.state = {};
     this.request = new app.RequestClass(app, this, req, res);
     this.response = new app.ResponseClass(app, this as any, req, res);
     this.request.response = this.response;
@@ -219,69 +219,265 @@ export class Context {
   set cookies(cookies: Cookies) {
     this._cookies = cookies;
   }
-}
 
-/**
- * Request delegation.
- */
-
-delegate(Context.prototype, 'request')
-  .method('acceptsLanguages')
-  .method('acceptsEncodings')
-  .method('acceptsCharsets')
-  .method('accepts')
-  .method('get')
-  .method('is')
-  .access('querystring')
-  .access('idempotent')
-  .access('socket')
-  .access('search')
-  .access('method')
-  .access('query')
-  .access('path')
-  .access('url')
-  .access('accept')
-  .getter('origin')
-  .getter('href')
-  .getter('subdomains')
-  .getter('protocol')
-  .getter('host')
-  .getter('hostname')
-  .getter('URL')
-  .getter('header')
-  .getter('headers')
-  .getter('secure')
-  .getter('stale')
-  .getter('fresh')
-  .getter('ips')
-  .getter('ip');
-
-/**
- * Response delegation.
- */
-
-delegate(Context.prototype, 'response')
-  .method('attachment')
-  .method('redirect')
-  .method('remove')
-  .method('vary')
-  .method('has')
-  .method('set')
-  .method('append')
-  .method('flushHeaders')
-  .access('status')
-  .access('message')
-  .access('body')
-  .access('length')
-  .access('type')
-  .access('lastModified')
-  .access('etag')
-  .getter('headerSent')
-  .getter('writable');
-
-export type ContextDelegation = Context & Pick<Request, 'acceptsLanguages' | 'acceptsEncodings' | 'acceptsCharsets'
-| 'accepts' | 'get' | 'is' | 'querystring' | 'idempotent' | 'socket' | 'search' | 'method' | 'query'
-| 'path' | 'url' | 'accept' | 'origin' | 'href' | 'subdomains' | 'protocol' | 'host' | 'hostname'
-| 'URL' | 'header' | 'headers' | 'secure' | 'stale' | 'fresh' | 'ips' | 'ip'>
-& Pick<Response, 'attachment' | 'redirect' | 'remove' | 'vary' | 'has' | 'set' | 'append' | 'flushHeaders'
-| 'status' | 'message' | 'body' | 'length' | 'type' | 'lastModified' | 'etag' | 'headerSent' | 'writable'>;
+  get state() {
+    return this.#state;
+  }
+
+  /**
+   * Request delegation.
+   */
+
+  acceptsLanguages(): string[];
+  acceptsLanguages(languages: string[]): string | false;
+  acceptsLanguages(...languages: string[]): string | false;
+  acceptsLanguages(languages?: string | string[], ...others: string[]): string | string[] | false {
+    return this.request.acceptsLanguages(languages as any, ...others);
+  }
+
+  acceptsEncodings(): string[];
+  acceptsEncodings(encodings: string[]): string | false;
+  acceptsEncodings(...encodings: string[]): string | false;
+  acceptsEncodings(encodings?: string | string[], ...others: string[]): string[] | string | false {
+    return this.request.acceptsEncodings(encodings as any, ...others);
+  }
+
+  acceptsCharsets(): string[];
+  acceptsCharsets(charsets: string[]): string | false;
+  acceptsCharsets(...charsets: string[]): string | false;
+  acceptsCharsets(charsets?: string | string[], ...others: string[]): string[] | string | false {
+    return this.request.acceptsCharsets(charsets as any, ...others);
+  }
+
+  accepts(...args: Parameters<Request['accepts']>): string | string[] | false {
+    return this.request.accepts(...args);
+  }
+
+  get<T = string | string []>(field: string): T {
+    return this.request.get(field);
+  }
+
+  is(type?: string | string[], ...types: string[]): string | false | null {
+    return this.request.is(type, ...types);
+  }
+
+  get querystring(): string {
+    return this.request.querystring;
+  }
+
+  set querystring(str: string) {
+    this.request.querystring = str;
+  }
+
+  get idempotent(): boolean {
+    return this.request.idempotent;
+  }
+
+  get socket() {
+    return this.request.socket;
+  }
+
+  get search(): string {
+    return this.request.search;
+  }
+
+  set search(str: string) {
+    this.request.search = str;
+  }
+
+  get method(): string {
+    return this.request.method;
+  }
+
+  set method(method: string) {
+    this.request.method = method;
+  }
+
+  get query(): ParsedUrlQuery {
+    return this.request.query;
+  }
+
+  set query(obj: ParsedUrlQuery) {
+    this.request.query = obj;
+  }
+
+  get path(): string {
+    return this.request.path;
+  }
+
+  set path(path: string) {
+    this.request.path = path;
+  }
+
+  get url(): string {
+    return this.request.url;
+  }
+
+  set url(url: string) {
+    this.request.url = url;
+  }
+
+  get accept(): Accepts {
+    return this.request.accept;
+  }
+
+  set accept(accept: Accepts) {
+    this.request.accept = accept;
+  }
+
+  get origin(): string {
+    return this.request.origin;
+  }
+
+  get href(): string {
+    return this.request.href;
+  }
+
+  get subdomains(): string[] {
+    return this.request.subdomains;
+  }
+
+  get protocol(): string {
+    return this.request.protocol;
+  }
+
+  get host(): string {
+    return this.request.host;
+  }
+
+  get hostname(): string {
+    return this.request.hostname;
+  }
+
+  get URL(): URL {
+    return this.request.URL;
+  }
+
+  get header() {
+    return this.request.header;
+  }
+
+  get headers() {
+    return this.request.headers;
+  }
+
+  get secure(): boolean {
+    return this.request.secure;
+  }
+
+  get stale(): boolean {
+    return this.request.stale;
+  }
+
+  get fresh(): boolean {
+    return this.request.fresh;
+  }
+
+  get ips(): string[] {
+    return this.request.ips;
+  }
+
+  get ip(): string {
+    return this.request.ip;
+  }
+
+  /**
+   * Response delegation.
+   */
+
+  attachment(...args: Parameters<Response['attachment']>) {
+    return this.response.attachment(...args);
+  }
+
+  redirect(...args: Parameters<Response['redirect']>) {
+    return this.response.redirect(...args);
+  }
+
+  remove(...args: Parameters<Response['remove']>) {
+    return this.response.remove(...args);
+  }
+
+  vary(...args: Parameters<Response['vary']>) {
+    return this.response.vary(...args);
+  }
+
+  has(...args: Parameters<Response['has']>) {
+    return this.response.has(...args);
+  }
+
+  set(...args: Parameters<Response['set']>) {
+    return this.response.set(...args);
+  }
+
+  append(...args: Parameters<Response['append']>) {
+    return this.response.append(...args);
+  }
+
+  flushHeaders(...args: Parameters<Response['flushHeaders']>) {
+    return this.response.flushHeaders(...args);
+  }
+
+  get status() {
+    return this.response.status;
+  }
+
+  set status(status: number) {
+    this.response.status = status;
+  }
+
+  get message() {
+    return this.response.message;
+  }
+
+  set message(msg: string) {
+    this.response.message = msg;
+  }
+
+  get body(): any {
+    return this.response.body;
+  }
+
+  set body(val: any) {
+    this.response.body = val;
+  }
+
+  get length(): number | undefined {
+    return this.response.length;
+  }
+
+  set length(n: number | string | undefined) {
+    this.response.length = n;
+  }
+
+  get type(): string {
+    return this.response.type;
+  }
+
+  set type(type: string | null | undefined) {
+    this.response.type = type;
+  }
+
+  get lastModified() {
+    return this.response.lastModified;
+  }
+
+  set lastModified(val: string | Date | undefined) {
+    this.response.lastModified = val;
+  }
+
+  get etag() {
+    return this.response.etag;
+  }
+
+  set etag(val: string) {
+    this.response.etag = val;
+  }
+
+  get headerSent() {
+    return this.response.headerSent;
+  }
+
+  get writable() {
+    return this.response.writable;
+  }
+}

package/src/request.ts

@@ -9,19 +9,23 @@ import parse from 'parseurl';
 import typeis from 'type-is';
 import fresh from 'fresh';
 import type { Application } from './application.js';
-import type { ContextDelegation } from './context.js';
+import type { Context } from './context.js';
 import type { Response } from './response.js';
 
-export class Request {
+export interface RequestSocket extends Socket {
+  encrypted: boolean;
+}
+
+export class Request<T extends Context = Context> {
   [key: symbol]: unknown;
   app: Application;
   req: IncomingMessage;
   res: ServerResponse;
-  ctx: ContextDelegation;
+  ctx: T;
   response: Response;
   originalUrl: string;
 
-  constructor(app: Application, ctx: ContextDelegation, req: IncomingMessage, res: ServerResponse) {
+  constructor(app: Application, ctx: T, req: IncomingMessage, res: ServerResponse) {
     this.app = app;
     this.req = req;
     this.res = res;
@@ -138,7 +142,7 @@ export class Request {
   /**
    * Get parsed query string.
    */
-  get query() {
+  get query(): ParsedUrlQuery {
     const str = this.querystring;
     if (!this._parsedUrlQueryCache) {
       this._parsedUrlQueryCache = {};
@@ -154,7 +158,7 @@ export class Request {
    * Set query string as an object.
    */
 
-  set query(obj) {
+  set query(obj: ParsedUrlQuery) {
     this.querystring = qs.stringify(obj);
   }
 
@@ -299,7 +303,7 @@ export class Request {
    * Return the request socket.
    */
   get socket() {
-    return this.req.socket as (Socket & { encrypted: boolean; });
+    return this.req.socket as RequestSocket;
   }
 
   /**

package/src/response.ts

@@ -13,18 +13,18 @@ import destroy from 'destroy';
 import vary from 'vary';
 import encodeUrl from 'encodeurl';
 import type { Application } from './application.js';
-import type { ContextDelegation } from './context.js';
+import type { Context } from './context.js';
 import type { Request } from './request.js';
 
-export class Response {
+export class Response<T extends Context = Context> {
   [key: symbol]: unknown;
   app: Application;
   req: IncomingMessage;
   res: ServerResponse;
-  ctx: ContextDelegation;
+  ctx: T;
   request: Request;
 
-  constructor(app: Application, ctx: ContextDelegation, req: IncomingMessage, res: ServerResponse) {
+  constructor(app: Application, ctx: T, req: IncomingMessage, res: ServerResponse) {
     this.app = app;
     this.req = req;
     this.res = res;
@@ -168,16 +168,24 @@ export class Response {
 
   /**
    * Return parsed response Content-Length when present.
+   *
+   * When Content-Length is not defined it will return `undefined`.
    */
-  get length() {
+  get length(): number | undefined {
     if (this.has('Content-Length')) {
       return parseInt(this.get('Content-Length'), 10) || 0;
     }
 
     const { body } = this;
-    if (!body || body instanceof Stream) return undefined;
-    if (typeof body === 'string') return Buffer.byteLength(body);
-    if (Buffer.isBuffer(body)) return body.length;
+    if (!body || body instanceof Stream) {
+      return undefined;
+    }
+    if (typeof body === 'string') {
+      return Buffer.byteLength(body);
+    }
+    if (Buffer.isBuffer(body)) {
+      return body.length;
+    }
     return Buffer.byteLength(JSON.stringify(body));
   }
 
@@ -270,7 +278,7 @@ export class Response {
    * Return the response mime type void of
    * parameters such as "charset".
    */
-  get type() {
+  get type(): string {
     const type = this.get<string>('Content-Type');
     if (!type) return '';
     return type.split(';', 1)[0];