Initial commit - Event Planner application
This commit is contained in:
mberlin
63
node_modules/@nestjs/platform-express/adapters/express-adapter.d.ts
generated
vendored
Normal file
63
node_modules/@nestjs/platform-express/adapters/express-adapter.d.ts
generated
vendored
Normal file
@@ -0,0 +1,63 @@
|
||||
import { RequestMethod, VersioningOptions } from '@nestjs/common';
|
||||
import { VersionValue } from '@nestjs/common/interfaces';
|
||||
import { CorsOptions, CorsOptionsDelegate } from '@nestjs/common/interfaces/external/cors-options.interface';
|
||||
import { NestApplicationOptions } from '@nestjs/common/interfaces/nest-application-options.interface';
|
||||
import { AbstractHttpAdapter } from '@nestjs/core/adapters/http-adapter';
|
||||
import * as express from 'express';
|
||||
import type { Server } from 'http';
|
||||
import * as http from 'http';
|
||||
import * as https from 'https';
|
||||
import { NestExpressBodyParserOptions } from '../interfaces/nest-express-body-parser-options.interface';
|
||||
import { NestExpressBodyParserType } from '../interfaces/nest-express-body-parser.interface';
|
||||
import { ServeStaticOptions } from '../interfaces/serve-static-options.interface';
|
||||
type VersionedRoute = <TRequest extends Record<string, any> = any, TResponse = any>(req: TRequest, res: TResponse, next: () => void) => any;
|
||||
/**
|
||||
* @publicApi
|
||||
*/
|
||||
export declare class ExpressAdapter extends AbstractHttpAdapter<http.Server | https.Server> {
|
||||
private readonly routerMethodFactory;
|
||||
private readonly logger;
|
||||
private readonly openConnections;
|
||||
private onRequestHook?;
|
||||
private onResponseHook?;
|
||||
constructor(instance?: any);
|
||||
setOnRequestHook(onRequestHook: (req: express.Request, res: express.Response, done: () => void) => Promise<void> | void): void;
|
||||
setOnResponseHook(onResponseHook: (req: express.Request, res: express.Response) => Promise<void> | void): void;
|
||||
reply(response: any, body: any, statusCode?: number): any;
|
||||
status(response: any, statusCode: number): any;
|
||||
end(response: any, message?: string): any;
|
||||
render(response: any, view: string, options: any): any;
|
||||
redirect(response: any, statusCode: number, url: string): any;
|
||||
setErrorHandler(handler: Function, prefix?: string): any;
|
||||
setNotFoundHandler(handler: Function, prefix?: string): any;
|
||||
isHeadersSent(response: any): boolean;
|
||||
getHeader(response: any, name: string): any;
|
||||
setHeader(response: any, name: string, value: string): any;
|
||||
appendHeader(response: any, name: string, value: string): any;
|
||||
normalizePath(path: string): string;
|
||||
listen(port: string | number, callback?: () => void): Server;
|
||||
listen(port: string | number, hostname: string, callback?: () => void): Server;
|
||||
close(): Promise<unknown> | undefined;
|
||||
set(...args: any[]): any;
|
||||
enable(...args: any[]): any;
|
||||
disable(...args: any[]): any;
|
||||
engine(...args: any[]): any;
|
||||
useStaticAssets(path: string, options: ServeStaticOptions): any;
|
||||
setBaseViewsDir(path: string | string[]): any;
|
||||
setViewEngine(engine: string): any;
|
||||
getRequestHostname(request: any): string;
|
||||
getRequestMethod(request: any): string;
|
||||
getRequestUrl(request: any): string;
|
||||
enableCors(options: CorsOptions | CorsOptionsDelegate<any>): any;
|
||||
createMiddlewareFactory(requestMethod: RequestMethod): (path: string, callback: Function) => any;
|
||||
initHttpServer(options: NestApplicationOptions): void;
|
||||
registerParserMiddleware(prefix?: string, rawBody?: boolean): void;
|
||||
useBodyParser<Options extends NestExpressBodyParserOptions = NestExpressBodyParserOptions>(type: NestExpressBodyParserType, rawBody: boolean, options?: Omit<Options, 'verify'>): this;
|
||||
setLocal(key: string, value: any): this;
|
||||
getType(): string;
|
||||
applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): VersionedRoute;
|
||||
private trackOpenConnections;
|
||||
private closeOpenConnections;
|
||||
private isMiddlewareApplied;
|
||||
}
|
||||
export {};
|
||||
355
node_modules/@nestjs/platform-express/adapters/express-adapter.js
generated
vendored
Normal file
355
node_modules/@nestjs/platform-express/adapters/express-adapter.js
generated
vendored
Normal file
@@ -0,0 +1,355 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ExpressAdapter = void 0;
|
||||
const common_1 = require("@nestjs/common");
|
||||
const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
|
||||
const http_adapter_1 = require("@nestjs/core/adapters/http-adapter");
|
||||
const router_method_factory_1 = require("@nestjs/core/helpers/router-method-factory");
|
||||
const legacy_route_converter_1 = require("@nestjs/core/router/legacy-route-converter");
|
||||
const cors = require("cors");
|
||||
const express = require("express");
|
||||
const http = require("http");
|
||||
const https = require("https");
|
||||
const path_to_regexp_1 = require("path-to-regexp");
|
||||
const get_body_parser_options_util_1 = require("./utils/get-body-parser-options.util");
|
||||
/**
|
||||
* @publicApi
|
||||
*/
|
||||
class ExpressAdapter extends http_adapter_1.AbstractHttpAdapter {
|
||||
constructor(instance) {
|
||||
super(instance || express());
|
||||
this.routerMethodFactory = new router_method_factory_1.RouterMethodFactory();
|
||||
this.logger = new common_1.Logger(ExpressAdapter.name);
|
||||
this.openConnections = new Set();
|
||||
this.instance.use((req, res, next) => {
|
||||
if (this.onResponseHook) {
|
||||
res.on('finish', () => {
|
||||
void this.onResponseHook.apply(this, [req, res]);
|
||||
});
|
||||
}
|
||||
if (this.onRequestHook) {
|
||||
void this.onRequestHook.apply(this, [req, res, next]);
|
||||
}
|
||||
else {
|
||||
next();
|
||||
}
|
||||
});
|
||||
}
|
||||
setOnRequestHook(onRequestHook) {
|
||||
this.onRequestHook = onRequestHook;
|
||||
}
|
||||
setOnResponseHook(onResponseHook) {
|
||||
this.onResponseHook = onResponseHook;
|
||||
}
|
||||
reply(response, body, statusCode) {
|
||||
if (statusCode) {
|
||||
response.status(statusCode);
|
||||
}
|
||||
if ((0, shared_utils_1.isNil)(body)) {
|
||||
return response.send();
|
||||
}
|
||||
if (body instanceof common_1.StreamableFile) {
|
||||
const streamHeaders = body.getHeaders();
|
||||
if (response.getHeader('Content-Type') === undefined &&
|
||||
streamHeaders.type !== undefined) {
|
||||
response.setHeader('Content-Type', streamHeaders.type);
|
||||
}
|
||||
if (response.getHeader('Content-Disposition') === undefined &&
|
||||
streamHeaders.disposition !== undefined) {
|
||||
response.setHeader('Content-Disposition', streamHeaders.disposition);
|
||||
}
|
||||
if (response.getHeader('Content-Length') === undefined &&
|
||||
streamHeaders.length !== undefined) {
|
||||
response.setHeader('Content-Length', streamHeaders.length);
|
||||
}
|
||||
const stream = body.getStream();
|
||||
stream.once('error', err => {
|
||||
body.errorHandler(err, response);
|
||||
});
|
||||
return stream
|
||||
.pipe(response)
|
||||
.on('error', (err) => body.errorLogger(err));
|
||||
}
|
||||
const responseContentType = response.getHeader('Content-Type');
|
||||
if (typeof responseContentType === 'string' &&
|
||||
!responseContentType.startsWith('application/json') &&
|
||||
body?.statusCode >= common_1.HttpStatus.BAD_REQUEST) {
|
||||
this.logger.warn("Content-Type doesn't match Reply body, you might need a custom ExceptionFilter for non-JSON responses");
|
||||
response.setHeader('Content-Type', 'application/json');
|
||||
}
|
||||
return (0, shared_utils_1.isObject)(body) ? response.json(body) : response.send(String(body));
|
||||
}
|
||||
status(response, statusCode) {
|
||||
return response.status(statusCode);
|
||||
}
|
||||
end(response, message) {
|
||||
return response.end(message);
|
||||
}
|
||||
render(response, view, options) {
|
||||
return response.render(view, options);
|
||||
}
|
||||
redirect(response, statusCode, url) {
|
||||
return response.redirect(statusCode, url);
|
||||
}
|
||||
setErrorHandler(handler, prefix) {
|
||||
return this.use(handler);
|
||||
}
|
||||
setNotFoundHandler(handler, prefix) {
|
||||
return this.use(handler);
|
||||
}
|
||||
isHeadersSent(response) {
|
||||
return response.headersSent;
|
||||
}
|
||||
getHeader(response, name) {
|
||||
return response.get(name);
|
||||
}
|
||||
setHeader(response, name, value) {
|
||||
return response.set(name, value);
|
||||
}
|
||||
appendHeader(response, name, value) {
|
||||
return response.append(name, value);
|
||||
}
|
||||
normalizePath(path) {
|
||||
try {
|
||||
const convertedPath = legacy_route_converter_1.LegacyRouteConverter.tryConvert(path);
|
||||
// Call "pathToRegexp" to trigger a TypeError if the path is invalid
|
||||
(0, path_to_regexp_1.pathToRegexp)(convertedPath);
|
||||
return convertedPath;
|
||||
}
|
||||
catch (e) {
|
||||
if (e instanceof TypeError) {
|
||||
legacy_route_converter_1.LegacyRouteConverter.printError(path);
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
listen(port, ...args) {
|
||||
return this.httpServer.listen(port, ...args);
|
||||
}
|
||||
close() {
|
||||
this.closeOpenConnections();
|
||||
if (!this.httpServer) {
|
||||
return undefined;
|
||||
}
|
||||
return new Promise(resolve => this.httpServer.close(resolve));
|
||||
}
|
||||
set(...args) {
|
||||
return this.instance.set(...args);
|
||||
}
|
||||
enable(...args) {
|
||||
return this.instance.enable(...args);
|
||||
}
|
||||
disable(...args) {
|
||||
return this.instance.disable(...args);
|
||||
}
|
||||
engine(...args) {
|
||||
return this.instance.engine(...args);
|
||||
}
|
||||
useStaticAssets(path, options) {
|
||||
if (options && options.prefix) {
|
||||
return this.use(options.prefix, express.static(path, options));
|
||||
}
|
||||
return this.use(express.static(path, options));
|
||||
}
|
||||
setBaseViewsDir(path) {
|
||||
return this.set('views', path);
|
||||
}
|
||||
setViewEngine(engine) {
|
||||
return this.set('view engine', engine);
|
||||
}
|
||||
getRequestHostname(request) {
|
||||
return request.hostname;
|
||||
}
|
||||
getRequestMethod(request) {
|
||||
return request.method;
|
||||
}
|
||||
getRequestUrl(request) {
|
||||
return request.originalUrl;
|
||||
}
|
||||
enableCors(options) {
|
||||
return this.use(cors(options));
|
||||
}
|
||||
createMiddlewareFactory(requestMethod) {
|
||||
return (path, callback) => {
|
||||
try {
|
||||
const convertedPath = legacy_route_converter_1.LegacyRouteConverter.tryConvert(path);
|
||||
return this.routerMethodFactory
|
||||
.get(this.instance, requestMethod)
|
||||
.call(this.instance, convertedPath, callback);
|
||||
}
|
||||
catch (e) {
|
||||
if (e instanceof TypeError) {
|
||||
legacy_route_converter_1.LegacyRouteConverter.printError(path);
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
};
|
||||
}
|
||||
initHttpServer(options) {
|
||||
const isHttpsEnabled = options && options.httpsOptions;
|
||||
if (isHttpsEnabled) {
|
||||
this.httpServer = https.createServer(options.httpsOptions, this.getInstance());
|
||||
}
|
||||
else {
|
||||
this.httpServer = http.createServer(this.getInstance());
|
||||
}
|
||||
if (options?.forceCloseConnections) {
|
||||
this.trackOpenConnections();
|
||||
}
|
||||
}
|
||||
registerParserMiddleware(prefix, rawBody) {
|
||||
const bodyParserJsonOptions = (0, get_body_parser_options_util_1.getBodyParserOptions)(rawBody);
|
||||
const bodyParserUrlencodedOptions = (0, get_body_parser_options_util_1.getBodyParserOptions)(rawBody, {
|
||||
extended: true,
|
||||
});
|
||||
const parserMiddleware = {
|
||||
jsonParser: express.json(bodyParserJsonOptions),
|
||||
urlencodedParser: express.urlencoded(bodyParserUrlencodedOptions),
|
||||
};
|
||||
Object.keys(parserMiddleware)
|
||||
.filter(parser => !this.isMiddlewareApplied(parser))
|
||||
.forEach(parserKey => this.use(parserMiddleware[parserKey]));
|
||||
}
|
||||
useBodyParser(type, rawBody, options) {
|
||||
const parserOptions = (0, get_body_parser_options_util_1.getBodyParserOptions)(rawBody, options);
|
||||
const parser = express[type](parserOptions);
|
||||
this.use(parser);
|
||||
return this;
|
||||
}
|
||||
setLocal(key, value) {
|
||||
this.instance.locals[key] = value;
|
||||
return this;
|
||||
}
|
||||
getType() {
|
||||
return 'express';
|
||||
}
|
||||
applyVersionFilter(handler, version, versioningOptions) {
|
||||
const callNextHandler = (req, res, next) => {
|
||||
if (!next) {
|
||||
throw new common_1.InternalServerErrorException('HTTP adapter does not support filtering on version');
|
||||
}
|
||||
return next();
|
||||
};
|
||||
if (version === common_1.VERSION_NEUTRAL ||
|
||||
// URL Versioning is done via the path, so the filter continues forward
|
||||
versioningOptions.type === common_1.VersioningType.URI) {
|
||||
const handlerForNoVersioning = (req, res, next) => handler(req, res, next);
|
||||
return handlerForNoVersioning;
|
||||
}
|
||||
// Custom Extractor Versioning Handler
|
||||
if (versioningOptions.type === common_1.VersioningType.CUSTOM) {
|
||||
const handlerForCustomVersioning = (req, res, next) => {
|
||||
const extractedVersion = versioningOptions.extractor(req);
|
||||
if (Array.isArray(version)) {
|
||||
if (Array.isArray(extractedVersion) &&
|
||||
version.filter(v => extractedVersion.includes(v)).length) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
if ((0, shared_utils_1.isString)(extractedVersion) &&
|
||||
version.includes(extractedVersion)) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
else if ((0, shared_utils_1.isString)(version)) {
|
||||
// Known bug here - if there are multiple versions supported across separate
|
||||
// handlers/controllers, we can't select the highest matching handler.
|
||||
// Since this code is evaluated per-handler, then we can't see if the highest
|
||||
// specified version exists in a different handler.
|
||||
if (Array.isArray(extractedVersion) &&
|
||||
extractedVersion.includes(version)) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
if ((0, shared_utils_1.isString)(extractedVersion) && version === extractedVersion) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
return callNextHandler(req, res, next);
|
||||
};
|
||||
return handlerForCustomVersioning;
|
||||
}
|
||||
// Media Type (Accept Header) Versioning Handler
|
||||
if (versioningOptions.type === common_1.VersioningType.MEDIA_TYPE) {
|
||||
const handlerForMediaTypeVersioning = (req, res, next) => {
|
||||
const MEDIA_TYPE_HEADER = 'Accept';
|
||||
const acceptHeaderValue = req.headers?.[MEDIA_TYPE_HEADER] ||
|
||||
req.headers?.[MEDIA_TYPE_HEADER.toLowerCase()];
|
||||
const acceptHeaderVersionParameter = acceptHeaderValue
|
||||
? acceptHeaderValue.split(';')[1]
|
||||
: undefined;
|
||||
// No version was supplied
|
||||
if ((0, shared_utils_1.isUndefined)(acceptHeaderVersionParameter)) {
|
||||
if (Array.isArray(version)) {
|
||||
if (version.includes(common_1.VERSION_NEUTRAL)) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
const headerVersion = acceptHeaderVersionParameter.split(versioningOptions.key)[1];
|
||||
if (Array.isArray(version)) {
|
||||
if (version.includes(headerVersion)) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
else if ((0, shared_utils_1.isString)(version)) {
|
||||
if (version === headerVersion) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
}
|
||||
return callNextHandler(req, res, next);
|
||||
};
|
||||
return handlerForMediaTypeVersioning;
|
||||
}
|
||||
// Header Versioning Handler
|
||||
if (versioningOptions.type === common_1.VersioningType.HEADER) {
|
||||
const handlerForHeaderVersioning = (req, res, next) => {
|
||||
const customHeaderVersionParameter = req.headers?.[versioningOptions.header] ||
|
||||
req.headers?.[versioningOptions.header.toLowerCase()];
|
||||
// No version was supplied
|
||||
if ((0, shared_utils_1.isUndefined)(customHeaderVersionParameter)) {
|
||||
if (Array.isArray(version)) {
|
||||
if (version.includes(common_1.VERSION_NEUTRAL)) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (Array.isArray(version)) {
|
||||
if (version.includes(customHeaderVersionParameter)) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
else if ((0, shared_utils_1.isString)(version)) {
|
||||
if (version === customHeaderVersionParameter) {
|
||||
return handler(req, res, next);
|
||||
}
|
||||
}
|
||||
}
|
||||
return callNextHandler(req, res, next);
|
||||
};
|
||||
return handlerForHeaderVersioning;
|
||||
}
|
||||
throw new Error('Unsupported versioning options');
|
||||
}
|
||||
trackOpenConnections() {
|
||||
this.httpServer.on('connection', (socket) => {
|
||||
this.openConnections.add(socket);
|
||||
socket.on('close', () => this.openConnections.delete(socket));
|
||||
});
|
||||
}
|
||||
closeOpenConnections() {
|
||||
for (const socket of this.openConnections) {
|
||||
socket.destroy();
|
||||
this.openConnections.delete(socket);
|
||||
}
|
||||
}
|
||||
isMiddlewareApplied(name) {
|
||||
const app = this.getInstance();
|
||||
return (!!app.router &&
|
||||
!!app.router.stack &&
|
||||
(0, shared_utils_1.isFunction)(app.router.stack.filter) &&
|
||||
app.router.stack.some((layer) => layer && layer.handle && layer.handle.name === name));
|
||||
}
|
||||
}
|
||||
exports.ExpressAdapter = ExpressAdapter;
|
||||
1
node_modules/@nestjs/platform-express/adapters/index.d.ts
generated
vendored
Normal file
1
node_modules/@nestjs/platform-express/adapters/index.d.ts
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export * from './express-adapter';
|
||||
4
node_modules/@nestjs/platform-express/adapters/index.js
generated
vendored
Normal file
4
node_modules/@nestjs/platform-express/adapters/index.js
generated
vendored
Normal file
@@ -0,0 +1,4 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const tslib_1 = require("tslib");
|
||||
tslib_1.__exportStar(require("./express-adapter"), exports);
|
||||
2
node_modules/@nestjs/platform-express/adapters/utils/get-body-parser-options.util.d.ts
generated
vendored
Normal file
2
node_modules/@nestjs/platform-express/adapters/utils/get-body-parser-options.util.d.ts
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
import type { NestExpressBodyParserOptions } from '../../interfaces';
|
||||
export declare function getBodyParserOptions<Options = NestExpressBodyParserOptions>(rawBody: boolean, options?: Omit<Options, 'verify'>): Options;
|
||||
19
node_modules/@nestjs/platform-express/adapters/utils/get-body-parser-options.util.js
generated
vendored
Normal file
19
node_modules/@nestjs/platform-express/adapters/utils/get-body-parser-options.util.js
generated
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getBodyParserOptions = getBodyParserOptions;
|
||||
const rawBodyParser = (req, _res, buffer) => {
|
||||
if (Buffer.isBuffer(buffer)) {
|
||||
req.rawBody = buffer;
|
||||
}
|
||||
return true;
|
||||
};
|
||||
function getBodyParserOptions(rawBody, options) {
|
||||
let parserOptions = (options || {});
|
||||
if (rawBody === true) {
|
||||
parserOptions = {
|
||||
...parserOptions,
|
||||
verify: rawBodyParser,
|
||||
};
|
||||
}
|
||||
return parserOptions;
|
||||
}
|
||||
Reference in New Issue
Block a user