@deepkit/http 1.0.1-alpha.155 → 1.0.1-alpha.158

package/src/model.ts

@@ -12,8 +12,8 @@ import { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerRespons
 import { UploadedFile } from './router.js';
 import * as querystring from 'querystring';
 import { Writable } from 'stream';
-import { metaAnnotation, ReflectionKind, Type, TypeAnnotation, ValidationErrorItem } from '@deepkit/type';
-import { asyncOperation, isArray } from '@deepkit/core';
+import { ReflectionKind, Type, typeAnnotation, ValidationErrorItem } from '@deepkit/type';
+import { asyncOperation, isArray, TypeAnnotation } from '@deepkit/core';
 
 export class HttpResponse extends ServerResponse {
     status(code: number) {
@@ -276,13 +276,13 @@ export type HttpQueries<T, Options extends { name?: string } = {}> = T & TypeAnn
  * }
  * ```
  */
-export type HttpRegExp<T, Pattern extends string | RegExp> = T & { __meta?: never & ['httpRegExp', Pattern] };
+export type HttpRegExp<T, Pattern extends string | RegExp> = T & TypeAnnotation<'httpRegExp', Pattern>;
 
 export function getRegExp(type: Type): string | RegExp | undefined {
-    const options = metaAnnotation.getForName(type, 'httpRegExp');
-    if (!options || !options[0]) return;
-    if (options[0].kind === ReflectionKind.literal && 'string' === typeof options[0].literal) return options[0].literal;
-    if (options[0].kind === ReflectionKind.literal && options[0].literal instanceof RegExp) return options[0].literal;
+    const options = typeAnnotation.getType(type, 'httpRegExp');
+    if (!options) return;
+    if (options.kind === ReflectionKind.literal && 'string' === typeof options.literal) return options.literal;
+    if (options.kind === ReflectionKind.literal && options.literal instanceof RegExp) return options.literal;
     return;
 }
 
@@ -383,6 +383,8 @@ export class HttpRequest extends IncomingMessage {
 
     public uploadedFiles: { [name: string]: UploadedFile } = {};
 
+    public throwErrorOnNotFound: boolean = false;
+
     /**
      * The router sets the body when it was read.
      */
@@ -442,6 +444,20 @@ export class HttpRequest extends IncomingMessage {
     }
 }
 
+export function incomingMessageToHttpRequest(request: IncomingMessage): HttpRequest {
+    if (request instanceof HttpRequest) return request;
+    Object.setPrototypeOf(request, HttpRequest.prototype);
+    HttpRequest.constructor.call(request);
+    return request as HttpRequest;
+}
+
+export function serverResponseToHttpResponse(response: ServerResponse): HttpResponse {
+    if (response instanceof HttpResponse) return response;
+    Object.setPrototypeOf(response, HttpResponse.prototype);
+    MemoryHttpResponse.constructor.call(response);
+    return response as HttpResponse;
+}
+
 export class MemoryHttpResponse extends HttpResponse {
     public body: Buffer = Buffer.alloc(0);
     public headers: { [name: string]: number | string | string[] | undefined } = Object.create(null);

package/src/module.config.ts

@@ -4,7 +4,7 @@ export interface HttpParserOptions {
      *
      * @default 'utf-8'
      */
-    encoding?: BufferEncoding | undefined;
+    encoding?: string | undefined;
 
     /**
      * the directory for placing file uploads in. You can move them later by using fs.rename()

package/src/module.ts

@@ -1,6 +1,6 @@
 import { HttpListener, HttpResultFormatter, httpWorkflow } from './http.js';
 import { HttpConfig } from './module.config.js';
-import { AddedListener, AppModule, ControllerConfig, createModule, stringifyListener } from '@deepkit/app';
+import { AddedListener, AppModule, ControllerConfig, createModuleClass, stringifyListener } from '@deepkit/app';
 import { HttpRouter, HttpRouterRegistry, RouteConfig } from './router.js';
 import { HttpKernel } from './kernel.js';
 import { HttpRouterFilterResolver } from './filter.js';
@@ -10,20 +10,21 @@ import { HttpRequest, HttpResponse } from './model.js';
 import '@deepkit/type';
 import { httpClass } from './decorator.js';
 import { EventToken } from '@deepkit/event';
-import { metaAnnotation, ReflectionKind, ReflectionParameter, Type } from '@deepkit/type';
+import { ReflectionKind, ReflectionParameter, Type, typeAnnotation } from '@deepkit/type';
 import { buildRequestParser } from './request-parser.js';
 import { InjectorContext } from '@deepkit/injector';
 
 function parameterRequiresRequest(parameter: ReflectionParameter): boolean {
-    return Boolean(metaAnnotation.getForName(parameter.type, 'httpQueries')
-        || metaAnnotation.getForName(parameter.type, 'httpQuery')
-        || metaAnnotation.getForName(parameter.type, 'httpBody')
-        || metaAnnotation.getForName(parameter.type, 'httpRequestParser')
-        || metaAnnotation.getForName(parameter.type, 'httpPath')
-        || metaAnnotation.getForName(parameter.type, 'httpHeader'));
+    return Boolean(typeAnnotation.getType(parameter.type, 'httpQueries')
+        || typeAnnotation.getType(parameter.type, 'httpQuery')
+        || typeAnnotation.getType(parameter.type, 'httpBody')
+        || typeAnnotation.getType(parameter.type, 'httpRequestParser')
+        || typeAnnotation.getType(parameter.type, 'httpPath')
+        || typeAnnotation.getType(parameter.type, 'httpHeader'));
 }
 
-export class HttpModule extends createModule({
+
+export class HttpModule extends createModuleClass({
     config: HttpConfig,
     providers: [
         HttpRouter,
@@ -71,7 +72,7 @@ export class HttpModule extends createModule({
         const params = listener.reflection.getParameters().slice(1);
 
         for (const parameter of params) {
-            if (metaAnnotation.getForName(parameter.type, 'httpBody')) needsAsync = true;
+            if (typeAnnotation.getType(parameter.type, 'httpBody')) needsAsync = true;
             if (parameterRequiresRequest(parameter)) requiresHttpRequest = true;
         }
 
@@ -89,7 +90,7 @@ export class HttpModule extends createModule({
             //change the reflection type so that we create a unique injection token for that type.
             const unique = Symbol('event.parameter:' + parameter.name);
             const uniqueType: Type = { kind: ReflectionKind.literal, literal: unique };
-            metaAnnotation.registerType(parameter.type, { name: 'inject', options: [uniqueType] });
+            typeAnnotation.registerType(parameter.type, { name: 'inject', options: uniqueType });
             let i = index;
 
             this.addProvider({

package/src/request-parser.ts

@@ -7,67 +7,61 @@ import {
     getValidatorFunction,
     hasDefaultValue,
     isOptional,
-    metaAnnotation,
     ReflectionKind,
     ReflectionParameter,
     resolveReceiveType,
     serializer,
     stringifyType,
     Type,
+    typeAnnotation,
     typeToObject,
     ValidationError,
 } from '@deepkit/type';
 import { BodyValidationError, createRequestWithCachedBody, getRegExp, HttpRequest, ValidatedBody } from './model.js';
 import { getRouteActionLabel, RouteConfig, UploadedFile, UploadedFileSymbol } from './router.js';
-
-//@ts-ignore
 import qs from 'qs';
-
-// @ts-ignore
-import formidable from 'formidable';
+import formidable, { Fields, Files, Options } from 'formidable';
 import { HttpParserOptions } from './module.config.js';
 
-
 function parseBody(
     options: HttpParserOptions,
     req: HttpRequest, foundFiles: { [name: string]: UploadedFile }) {
-    const form = formidable(Object.assign(options, {
+
+    const form = formidable(Object.assign(options as Options, {
         multiples: true,
     }));
-    return asyncOperation((resolve, reject) => {
-        function parseData(err: any, fields: any, files: any) {
-            if (err) {
-                reject(err);
-            } else {
-                const fileEntries = Object.entries(files);
+    return asyncOperation(async (resolve, reject) => {
+        function parseData(fields: Fields, files: Files) {
+            const fileEntries = Object.entries(files);
 
-                // formidable turns JSON arrays into numerically keyed objects, so we convert them back
-                if ('0' in fields && fileEntries.length === 0 && Object.keys(fields).every((key, idx) => parseInt(key) === idx)) {
-                    return resolve(Object.values(fields));
-                }
+            // formidable turns JSON arrays into numerically keyed objects, so we convert them back
+            if ('0' in fields && fileEntries.length === 0 && Object.keys(fields).every((key, idx) => parseInt(key) === idx)) {
+                return resolve(Object.values(fields));
+            }
 
-                for (const [name, file] of fileEntries as any) {
-                    if (!file.filepath || 'string' !== typeof file.filepath) continue;
-                    if (!file.size || 'number' !== typeof file.size) continue;
-                    if (file.lastModifiedDate && !(file.lastModifiedDate instanceof Date)) continue;
-
-                    foundFiles[name] = {
-                        validator: UploadedFileSymbol,
-                        size: file.size,
-                        path: file.filepath,
-                        name: file.originalFilename || null,
-                        type: file.mimetype || null,
-                        lastModifiedDate: file.lastModifiedDate || null,
-                    };
-                }
-                const body = { ...fields, ...foundFiles };
-                resolve(body);
+            for (const [name, files] of fileEntries) {
+                if (!files) continue;
+                const file = files[0];
+                if (!file) continue;
+                if (!file.filepath || 'string' !== typeof file.filepath) continue;
+                if (!file.size || 'number' !== typeof file.size) continue;
+
+                foundFiles[name] = {
+                    validator: UploadedFileSymbol,
+                    size: file.size,
+                    path: file.filepath,
+                    name: file.originalFilename || null,
+                    type: file.mimetype || null,
+                    lastModifiedDate: null,
+                };
             }
+            const body = { ...fields, ...foundFiles };
+            resolve(body);
         }
 
         if (req.body) {
-            form.parse(createRequestWithCachedBody(req, req.body), parseData);
-            return;
+            const [fields, files] = await form.parse(createRequestWithCachedBody(req, req.body));
+            parseData(fields, files);
         }
 
         const chunks: Buffer[] = [];
@@ -83,7 +77,8 @@ function parseBody(
         });
         req.once('error', () => req.off('data', read));
 
-        form.parse(req, parseData);
+        const [fields, files] = await form.parse(req);
+        parseData(fields, files);
     });
 }
 
@@ -96,21 +91,21 @@ export class ParameterForRequestParser {
     }
 
     get body() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpBody') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpBody') !== undefined;
     }
 
     get requestParser() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpRequestParser') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpRequestParser') !== undefined;
     }
 
     get bodyValidation() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpBodyValidation') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpBodyValidation') !== undefined;
     }
 
     getType(): Type {
-        const parser = metaAnnotation.getForName(this.parameter.type, 'httpRequestParser');
-        if (parser && parser[0]) {
-            return parser[0];
+        const parser = typeAnnotation.getType(this.parameter.type, 'httpRequestParser');
+        if (parser) {
+            return parser;
         }
 
         if (this.bodyValidation) {
@@ -123,22 +118,22 @@ export class ParameterForRequestParser {
     }
 
     get header() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpHeader') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpHeader') !== undefined;
     }
 
     get query() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpQuery') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpQuery') !== undefined;
     }
 
     get queries() {
-        return metaAnnotation.getForName(this.parameter.type, 'httpQueries') !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpQueries') !== undefined;
     }
 
     get typePath(): string | undefined {
-        const typeOptions = metaAnnotation.getForName(this.parameter.type, 'httpQueries') || metaAnnotation.getForName(this.parameter.type, 'httpQuery')
-            || metaAnnotation.getForName(this.parameter.type, 'httpPath') || metaAnnotation.getForName(this.parameter.type, 'httpHeader');
+        const typeOptions = typeAnnotation.getType(this.parameter.type, 'httpQueries') || typeAnnotation.getType(this.parameter.type, 'httpQuery')
+            || typeAnnotation.getType(this.parameter.type, 'httpPath') || typeAnnotation.getType(this.parameter.type, 'httpHeader');
         if (!typeOptions) return;
-        const options = typeToObject(typeOptions[0]);
+        const options = typeToObject(typeOptions);
         if (isObject(options)) return options.name;
         return;
     }
@@ -148,7 +143,7 @@ export class ParameterForRequestParser {
     }
 
     isPartOfPath(): boolean {
-        return metaAnnotation.getForName(this.parameter.type, 'httpPath') !== undefined || this.regexPosition !== undefined;
+        return typeAnnotation.getType(this.parameter.type, 'httpPath') !== undefined || this.regexPosition !== undefined;
     }
 }
 

package/src/static-serving.ts

@@ -20,42 +20,53 @@ import send from 'send';
 import { eventDispatcher } from '@deepkit/event';
 import { HttpRouter, RouteConfig } from './router.js';
 
+export function staticServe(
+    localPath: string,
+    path: string,
+    request: HttpRequest,
+    response: HttpResponse,
+) {
+    return new Promise((resolve, reject) => {
+        const res = send(request, path, { root: localPath });
+        res.pipe(response);
+        res.on('end', resolve);
+    });
+}
+
+export async function staticOnRoute(
+    event: typeof httpWorkflow.onRoute.event,
+    path: string,
+    localPath: string,
+) {
+    if (event.sent) return;
+    if (event.route) return;
+
+    if (!event.request.url?.startsWith(path)) return;
+
+    const relativePath = urlJoin('/', event.url.substr(path.length));
+    const finalLocalPath = join(localPath, relativePath);
+
+    return new Promise(resolve => {
+        stat(finalLocalPath, (err, stat) => {
+            if (stat && stat.isFile()) {
+                event.routeFound(
+                    new RouteConfig('static', ['GET'], event.url, {
+                        type: 'function',
+                        fn: staticServe,
+                    }),
+                    () => ({ arguments: [localPath, relativePath, event.request, event.response], parameters: {} }),
+                );
+            }
+            resolve(undefined);
+        });
+    });
+}
+
 export function serveStaticListener(module: AppModule<any>, path: string, localPath: string = path): ClassType {
     class HttpRequestStaticServingListener {
-        serve(path: string, request: HttpRequest, response: HttpResponse) {
-            return new Promise((resolve, reject) => {
-                const res = send(request, path, { root: localPath });
-                res.pipe(response);
-                res.on('end', resolve);
-            });
-        }
-
         @eventDispatcher.listen(httpWorkflow.onRoute, 101) //after default route listener at 100
         onRoute(event: typeof httpWorkflow.onRoute.event) {
-            if (event.sent) return;
-            if (event.route) return;
-
-            if (!event.request.url?.startsWith(path)) return;
-
-            const relativePath = urlJoin('/', event.url.substr(path.length));
-            const finalLocalPath = join(localPath, relativePath);
-
-            return new Promise(resolve => {
-                stat(finalLocalPath, (err, stat) => {
-                    if (stat && stat.isFile()) {
-                        event.routeFound(
-                            new RouteConfig('static', ['GET'], event.url, {
-                                type: 'controller',
-                                controller: HttpRequestStaticServingListener,
-                                module,
-                                methodName: 'serve',
-                            }),
-                            () => ({ arguments: [relativePath, event.request, event.response], parameters: {} }),
-                        );
-                    }
-                    resolve(undefined);
-                });
-            });
+            return staticOnRoute(event, path, localPath);
         }
     }
 
@@ -108,7 +119,7 @@ export function registerStaticHttpController(module: AppModule<any>, options: St
     const groups = options.groups || [];
 
     class StaticController {
-        @http.GET().group(...groups)
+        @(http.GET().group(...groups))
         serveIndex(request: HttpRequest, response: HttpResponse) {
             if (!indexHtml) {
                 indexHtml = loadHtml(options.localPath, normalizeDirectory(options.path));

package/tsconfig.json

@@ -8,7 +8,7 @@
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "moduleResolution": "node",
-    "target": "es2018",
+    "target": "es2020",
     "module": "CommonJS",
     "esModuleInterop": true,
     "outDir": "./dist/cjs",