@nestjs/core 7.4.2 → 7.5.1

package/Readme.md

@@ -89,7 +89,7 @@ Nest is an MIT-licensed open source project. It can grow thanks to the sponsors
 <a href="https://sparkfabrik.com/" target="_blank"><img src="https://nestjs.com/img/sparkfabrik-logo.png" width="120" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://www.thebigphonestore.co.uk/" target="_blank"><img src="https://nestjs.com/img/the-big-phone-store-logo.png" width="65" valign="middle" /></a></td>
   <td align="center" valign="middle">
   <a href="https://genuinebee.com/" target="_blank"><img src="https://nestjs.com/img/genuinebee.svg" width="97" valign="middle" /></a> </td></tr>
-<tr><td align="center" valign="middle"><a href="https://sanyodigital.com/" target="_blank"><img src="https://nestjs.com/img/sanyo-digital.png" width="130" valign="middle" /></a></td>
+<tr><td align="center" valign="middle"><a href="https://sanyodigital.com/" target="_blank"><img src="https://nestjs.com/img/sanyo-digital.png" width="130" valign="middle" /></a></td><td align="center" valign="middle"><a href="https://vpn-review.com/vpn-for-torrenting" target="_blank"><img src="https://nestjs.com/img/vpn-review-logo.png" width="85" valign="middle" /></a></td>
   </tr></table>
 
 ## Backers

package/helpers/handler-metadata-storage.d.ts

@@ -1,7 +1,14 @@
+/// <reference types="node" />
 import { Type } from '@nestjs/common';
+import { IncomingMessage } from 'http';
+import { Observable } from 'rxjs';
 import { ContextId } from '../injector/instance-wrapper';
+import { HeaderStream } from '../router/sse-stream';
 import { ParamProperties } from './context-utils';
 export declare const HANDLER_METADATA_SYMBOL: unique symbol;
+export declare type HandleResponseFn = HandlerResponseBasicFn | HandleSseResponseFn;
+export declare type HandlerResponseBasicFn = <TResult, TResponse>(result: TResult, res: TResponse, req?: any) => any;
+export declare type HandleSseResponseFn = <TResult extends Observable<unknown> = any, TResponse extends HeaderStream = any, TRequest extends IncomingMessage = any>(result: TResult, res: TResponse, req: TRequest) => any;
 export interface HandlerMetadata {
     argsLength: number;
     paramtypes: any[];
@@ -11,7 +18,7 @@ export interface HandlerMetadata {
     getParamsMetadata: (moduleKey: string, contextId?: ContextId, inquirerId?: string) => (ParamProperties & {
         metatype?: any;
     })[];
-    fnHandleResponse: <TResult, TResponse>(result: TResult, res: TResponse) => any;
+    fnHandleResponse: HandleResponseFn;
 }
 export declare class HandlerMetadataStorage<TValue = HandlerMetadata, TKey extends Type<unknown> = any> {
     private readonly [HANDLER_METADATA_SYMBOL];

package/helpers/rethrow.d.ts

@@ -0,0 +1 @@
+export declare const rethrow: (err: unknown) => never;

package/helpers/rethrow.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rethrow = void 0;
+exports.rethrow = (err) => {
+    throw err;
+};

package/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestFactory = exports.APP_PIPE = exports.APP_INTERCEPTOR = exports.APP_GUARD = exports.APP_FILTER = void 0;
 const tslib_1 = require("tslib");
 /*
  * Nest @core

package/injector/container.d.ts

@@ -20,8 +20,8 @@ export declare class NestContainer {
     setHttpAdapter(httpAdapter: any): void;
     getHttpAdapterRef(): import("..").AbstractHttpAdapter<any, any, any>;
     addModule(metatype: Type<any> | DynamicModule | Promise<DynamicModule>, scope: Type<any>[]): Promise<Module>;
-    addDynamicMetadata(token: string, dynamicModuleMetadata: Partial<DynamicModule>, scope: Type<any>[]): void;
-    addDynamicModules(modules: any[], scope: Type<any>[]): void;
+    addDynamicMetadata(token: string, dynamicModuleMetadata: Partial<DynamicModule>, scope: Type<any>[]): Promise<void>;
+    addDynamicModules(modules: any[], scope: Type<any>[]): Promise<void>;
     isGlobalModule(metatype: Type<any>, dynamicMetadata?: Partial<DynamicModule>): boolean;
     addGlobalModule(module: Module): void;
     getModules(): ModulesContainer;

package/injector/container.js

@@ -50,25 +50,25 @@ class NestContainer {
         }
         const moduleRef = new module_1.Module(type, this);
         this.modules.set(token, moduleRef);
-        this.addDynamicMetadata(token, dynamicMetadata, [].concat(scope, type));
+        await this.addDynamicMetadata(token, dynamicMetadata, [].concat(scope, type));
         if (this.isGlobalModule(type, dynamicMetadata)) {
             this.addGlobalModule(moduleRef);
         }
         return moduleRef;
     }
-    addDynamicMetadata(token, dynamicModuleMetadata, scope) {
+    async addDynamicMetadata(token, dynamicModuleMetadata, scope) {
         if (!dynamicModuleMetadata) {
             return;
         }
         this.dynamicModulesMetadata.set(token, dynamicModuleMetadata);
         const { imports } = dynamicModuleMetadata;
-        this.addDynamicModules(imports, scope);
+        await this.addDynamicModules(imports, scope);
     }
-    addDynamicModules(modules, scope) {
+    async addDynamicModules(modules, scope) {
         if (!modules) {
             return;
         }
-        modules.forEach(module => this.addModule(module, scope));
+        await Promise.all(modules.map(module => this.addModule(module, scope)));
     }
     isGlobalModule(metatype, dynamicMetadata) {
         if (dynamicMetadata && dynamicMetadata.global) {

package/injector/module-token-factory.js

@@ -39,7 +39,11 @@ class ModuleTokenFactory {
     }
     replacer(key, value) {
         if (typeof value === 'function') {
-            return value.name;
+            const isClass = /^class\s/.test(Function.prototype.toString.call(value));
+            if (isClass) {
+                return value.name;
+            }
+            return hash(value.toString(), { ignoreUnknown: true });
         }
         return value;
     }

package/middleware/middleware-module.js

@@ -53,36 +53,36 @@ class MiddlewareModule {
     }
     async registerMiddleware(middlewareContainer, applicationRef) {
         const configs = middlewareContainer.getConfigurations();
-        const registerAllConfigs = (moduleKey, middlewareConfig) => middlewareConfig.map(async (config) => {
-            await this.registerMiddlewareConfig(middlewareContainer, config, moduleKey, applicationRef);
-        });
+        const registerAllConfigs = async (moduleKey, middlewareConfig) => {
+            for (const config of middlewareConfig) {
+                await this.registerMiddlewareConfig(middlewareContainer, config, moduleKey, applicationRef);
+            }
+        };
         const entriesSortedByDistance = [...configs.entries()].sort(([moduleA], [moduleB]) => {
             return (this.container.getModuleByKey(moduleA).distance -
                 this.container.getModuleByKey(moduleB).distance);
         });
-        const registerModuleConfigs = async ([module, moduleConfigs]) => {
-            await Promise.all(registerAllConfigs(module, [...moduleConfigs]));
-        };
-        await Promise.all(entriesSortedByDistance.map(registerModuleConfigs));
+        for (const [moduleRef, moduleConfigurations] of entriesSortedByDistance) {
+            await registerAllConfigs(moduleRef, [...moduleConfigurations]);
+        }
     }
     async registerMiddlewareConfig(middlewareContainer, config, moduleKey, applicationRef) {
         const { forRoutes } = config;
-        const registerRouteMiddleware = async (routeInfo) => {
+        for (const routeInfo of forRoutes) {
             await this.registerRouteMiddleware(middlewareContainer, routeInfo, config, moduleKey, applicationRef);
-        };
-        await Promise.all(forRoutes.map(registerRouteMiddleware));
+        }
     }
     async registerRouteMiddleware(middlewareContainer, routeInfo, config, moduleKey, applicationRef) {
         const middlewareCollection = [].concat(config.middleware);
         const moduleRef = this.container.getModuleByKey(moduleKey);
-        await Promise.all(middlewareCollection.map(async (metatype) => {
+        for (const metatype of middlewareCollection) {
             const collection = middlewareContainer.getMiddlewareCollection(moduleKey);
             const instanceWrapper = collection.get(metatype.name);
             if (shared_utils_1.isUndefined(instanceWrapper)) {
                 throw new runtime_exception_1.RuntimeException();
             }
             await this.bindHandler(instanceWrapper, applicationRef, routeInfo.method, routeInfo.path, moduleRef, collection);
-        }));
+        }
     }
     async bindHandler(wrapper, applicationRef, method, path, moduleRef, collection) {
         const { instance, metatype } = wrapper;

package/nest-application-context.d.ts

@@ -1,4 +1,4 @@
-import { INestApplicationContext, LoggerService, ShutdownSignal } from '@nestjs/common';
+import { INestApplicationContext, LoggerService, LogLevel, ShutdownSignal } from '@nestjs/common';
 import { Abstract } from '@nestjs/common/interfaces';
 import { Type } from '@nestjs/common/interfaces/type.interface';
 import { ContextId } from './injector';
@@ -36,7 +36,7 @@ export declare class NestApplicationContext implements INestApplicationContext {
      */
     init(): Promise<this>;
     close(): Promise<void>;
-    useLogger(logger: LoggerService): void;
+    useLogger(logger: LoggerService | LogLevel[] | false): void;
     /**
      * Enables the usage of shutdown hooks. Will call the
      * `onApplicationShutdown` function of a provider if the

package/nest-factory.d.ts

@@ -8,6 +8,7 @@ import { AbstractHttpAdapter } from './adapters/http-adapter';
  */
 export declare class NestFactoryStatic {
     private readonly logger;
+    private abortOnError;
     /**
      * Creates an instance of NestApplication.
      *
@@ -52,12 +53,14 @@ export declare class NestFactoryStatic {
     createApplicationContext(module: any, options?: NestApplicationContextOptions): Promise<INestApplicationContext>;
     private createNestInstance;
     private initialize;
+    private handleInitializationError;
     private createProxy;
     private createExceptionProxy;
     private createExceptionZone;
     private applyLogger;
     private createHttpAdapter;
     private isHttpServer;
+    private setAbortOnError;
     private createAdapterProxy;
 }
 /**

package/nest-factory.js

@@ -8,6 +8,7 @@ const application_config_1 = require("./application-config");
 const constants_1 = require("./constants");
 const exceptions_zone_1 = require("./errors/exceptions-zone");
 const load_adapter_1 = require("./helpers/load-adapter");
+const rethrow_1 = require("./helpers/rethrow");
 const container_1 = require("./injector/container");
 const instance_loader_1 = require("./injector/instance-loader");
 const metadata_scanner_1 = require("./metadata-scanner");
@@ -20,6 +21,7 @@ const scanner_1 = require("./scanner");
 class NestFactoryStatic {
     constructor() {
         this.logger = new logger_service_1.Logger('NestFactory', true);
+        this.abortOnError = true;
     }
     async create(module, serverOrOptions, options) {
         const [httpServer, appOptions] = this.isHttpServer(serverOrOptions)
@@ -27,6 +29,7 @@ class NestFactoryStatic {
             : [this.createHttpAdapter(), serverOrOptions];
         const applicationConfig = new application_config_1.ApplicationConfig();
         const container = new container_1.NestContainer(applicationConfig);
+        this.setAbortOnError(serverOrOptions, options);
         this.applyLogger(appOptions);
         await this.initialize(module, container, applicationConfig, httpServer);
         const instance = new nest_application_1.NestApplication(container, httpServer, applicationConfig, appOptions);
@@ -46,6 +49,7 @@ class NestFactoryStatic {
         const { NestMicroservice } = load_package_util_1.loadPackage('@nestjs/microservices', 'NestFactory', () => require('@nestjs/microservices'));
         const applicationConfig = new application_config_1.ApplicationConfig();
         const container = new container_1.NestContainer(applicationConfig);
+        this.setAbortOnError(options);
         this.applyLogger(options);
         await this.initialize(module, container, applicationConfig);
         return this.createNestInstance(new NestMicroservice(container, options, applicationConfig));
@@ -61,6 +65,7 @@ class NestFactoryStatic {
      */
     async createApplicationContext(module, options) {
         const container = new container_1.NestContainer();
+        this.setAbortOnError(options);
         this.applyLogger(options);
         await this.initialize(module, container);
         const modules = container.getModules().values();
@@ -76,6 +81,7 @@ class NestFactoryStatic {
         const metadataScanner = new metadata_scanner_1.MetadataScanner();
         const dependenciesScanner = new scanner_1.DependenciesScanner(container, metadataScanner, config);
         container.setHttpAdapter(httpServer);
+        const teardown = this.abortOnError === false ? rethrow_1.rethrow : undefined;
         await (httpServer === null || httpServer === void 0 ? void 0 : httpServer.init());
         try {
             this.logger.log(constants_1.MESSAGES.APPLICATION_START);
@@ -83,11 +89,17 @@ class NestFactoryStatic {
                 await dependenciesScanner.scan(module);
                 await instanceLoader.createInstancesOfDependencies();
                 dependenciesScanner.applyApplicationProviders();
-            });
+            }, teardown);
         }
         catch (e) {
+            this.handleInitializationError(e);
+        }
+    }
+    handleInitializationError(err) {
+        if (this.abortOnError) {
             process.abort();
         }
+        rethrow_1.rethrow(err);
     }
     createProxy(target) {
         const proxy = this.createExceptionProxy();
@@ -108,11 +120,12 @@ class NestFactoryStatic {
         };
     }
     createExceptionZone(receiver, prop) {
+        const teardown = this.abortOnError === false ? rethrow_1.rethrow : undefined;
         return (...args) => {
             let result;
             exceptions_zone_1.ExceptionsZone.run(() => {
                 result = receiver[prop](...args);
-            });
+            }, teardown);
             return result;
         };
     }
@@ -129,6 +142,11 @@ class NestFactoryStatic {
     isHttpServer(serverOrOptions) {
         return !!(serverOrOptions && serverOrOptions.patch);
     }
+    setAbortOnError(serverOrOptions, options) {
+        this.abortOnError = this.isHttpServer(serverOrOptions)
+            ? !(options && options.abortOnError === false)
+            : !(serverOrOptions && serverOrOptions.abortOnError === false);
+    }
     createAdapterProxy(app, adapter) {
         return new Proxy(app, {
             get: (receiver, prop) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/core",
-  "version": "7.4.2",
+  "version": "7.5.1",
   "description": "Nest - modern, fast, powerful node.js web framework (@core)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -32,11 +32,11 @@
     "iterare": "1.2.1",
     "object-hash": "2.0.3",
     "path-to-regexp": "3.2.0",
-    "tslib": "2.0.0",
-    "uuid": "8.3.0"
+    "tslib": "2.0.3",
+    "uuid": "8.3.1"
   },
   "devDependencies": {
-    "@nestjs/common": "7.4.2"
+    "@nestjs/common": "7.5.1"
   },
   "peerDependencies": {
     "@nestjs/common": "^7.0.0",

package/router/request/index.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST = void 0;
 var request_constants_1 = require("./request-constants");
 Object.defineProperty(exports, "REQUEST", { enumerable: true, get: function () { return request_constants_1.REQUEST; } });

package/router/router-execution-context.d.ts

@@ -5,7 +5,7 @@ import { ContextType, Controller } from '@nestjs/common/interfaces';
 import { GuardsConsumer } from '../guards/guards-consumer';
 import { GuardsContextCreator } from '../guards/guards-context-creator';
 import { ExecutionContextHost } from '../helpers/execution-context-host';
-import { HandlerMetadata } from '../helpers/handler-metadata-storage';
+import { HandleResponseFn, HandlerMetadata } from '../helpers/handler-metadata-storage';
 import { InterceptorsConsumer } from '../interceptors/interceptors-consumer';
 import { InterceptorsContextCreator } from '../interceptors/interceptors-context-creator';
 import { PipesConsumer } from '../pipes/pipes-consumer';
@@ -38,6 +38,7 @@ export declare class RouterExecutionContext {
     reflectHttpStatusCode(callback: (...args: unknown[]) => unknown): number;
     reflectRenderTemplate(callback: (...args: unknown[]) => unknown): string;
     reflectResponseHeaders(callback: (...args: unknown[]) => unknown): CustomHeader[];
+    reflectSse(callback: (...args: unknown[]) => unknown): string;
     exchangeKeysForValues(keys: string[], metadata: Record<number, RouteParamMetadata>, moduleContext: string, contextId?: import("..").ContextId, inquirerId?: string, contextFactory?: (args: unknown[]) => ExecutionContextHost): ParamProperties[];
     getParamValue<T>(value: T, { metatype, type, data, }: {
         metatype: unknown;
@@ -49,5 +50,5 @@ export declare class RouterExecutionContext {
     createPipesFn(pipes: PipeTransform[], paramsOptions: (ParamProperties & {
         metatype?: any;
     })[]): <TRequest, TResponse>(args: any[], req: TRequest, res: TResponse, next: Function) => Promise<void>;
-    createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): <TResult, TResponse>(result: TResult, res: TResponse) => Promise<void>;
+    createHandleResponseFn(callback: (...args: unknown[]) => unknown, isResponseHandled: boolean, redirectResponse?: RedirectResponse, httpStatusCode?: number): HandleResponseFn;
 }

package/router/router-execution-context.js

@@ -44,7 +44,7 @@ class RouterExecutionContext {
             hasCustomHeaders &&
                 this.responseController.setHeaders(res, responseHeaders);
             const result = await this.interceptorsConsumer.intercept(interceptors, [req, res, next], instance, callback, handler(args, req, res, next), contextType);
-            await fnHandleResponse(result, res);
+            await fnHandleResponse(result, res, req);
         };
     }
     getMetadata(instance, callback, methodName, moduleKey, requestMethod, contextType) {
@@ -92,6 +92,9 @@ class RouterExecutionContext {
     reflectResponseHeaders(callback) {
         return Reflect.getMetadata(constants_1.HEADERS_METADATA, callback) || [];
     }
+    reflectSse(callback) {
+        return Reflect.getMetadata(constants_1.SSE_METADATA, callback);
+    }
     exchangeKeysForValues(keys, metadata, moduleContext, contextId = constants_3.STATIC_CONTEXT, inquirerId, contextFactory) {
         this.pipesContextCreator.setModuleContext(moduleContext);
         return keys.map(key => {
@@ -158,6 +161,12 @@ class RouterExecutionContext {
                 await this.responseController.redirect(result, res, redirectResponse);
             };
         }
+        const isSseHandler = !!this.reflectSse(callback);
+        if (isSseHandler) {
+            return async (result, res, req) => {
+                await this.responseController.sse(result, res, req);
+            };
+        }
         return async (result, res) => {
             result = await this.responseController.transformToResult(result);
             !isResponseHandled &&

package/router/router-response-controller.d.ts

@@ -1,4 +1,8 @@
+/// <reference types="node" />
 import { HttpServer, RequestMethod } from '@nestjs/common';
+import { IncomingMessage } from 'http';
+import { Observable } from 'rxjs';
+import { HeaderStream } from './sse-stream';
 export interface CustomHeader {
     name: string;
     value: string;
@@ -17,4 +21,6 @@ export declare class RouterResponseController {
     getStatusByMethod(requestMethod: RequestMethod): number;
     setHeaders<TResponse = unknown>(response: TResponse, headers: CustomHeader[]): void;
     setStatus<TResponse = unknown>(response: TResponse, statusCode: number): void;
+    sse<TInput extends Observable<unknown> = any, TResponse extends HeaderStream = any, TRequest extends IncomingMessage = any>(result: TInput, response: TResponse, request: TRequest): Promise<void>;
+    private assertObservable;
 }

package/router/router-response-controller.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterResponseController = void 0;
 const common_1 = require("@nestjs/common");
 const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const operators_1 = require("rxjs/operators");
+const sse_stream_1 = require("./sse-stream");
 class RouterResponseController {
     constructor(applicationRef) {
         this.applicationRef = applicationRef;
@@ -44,5 +46,27 @@ class RouterResponseController {
     setStatus(response, statusCode) {
         this.applicationRef.status(response, statusCode);
     }
+    async sse(result, response, request) {
+        this.assertObservable(result);
+        const stream = new sse_stream_1.SseStream(request);
+        stream.pipe(response);
+        const subscription = result
+            .pipe(operators_1.debounce((message) => new Promise(resolve => {
+            if (!shared_utils_1.isObject(message)) {
+                message = { data: message };
+            }
+            stream.writeMessage(message, resolve);
+        })))
+            .subscribe();
+        request.on('close', () => {
+            response.end();
+            subscription.unsubscribe();
+        });
+    }
+    assertObservable(result) {
+        if (!shared_utils_1.isFunction(result.subscribe)) {
+            throw new ReferenceError('You must return an Observable stream to use Server-Sent Events (SSE).');
+        }
+    }
 }
 exports.RouterResponseController = RouterResponseController;

package/router/sse-stream.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="vinyl-fs" />
+import { MessageEvent } from '@nestjs/common/interfaces';
+import { IncomingMessage, OutgoingHttpHeaders } from 'http';
+import { Transform } from 'stream';
+interface WriteHeaders {
+    writeHead?(statusCode: number, reasonPhrase?: string, headers?: OutgoingHttpHeaders): void;
+    writeHead?(statusCode: number, headers?: OutgoingHttpHeaders): void;
+    flushHeaders?(): void;
+}
+export declare type HeaderStream = NodeJS.WritableStream & WriteHeaders;
+/**
+ * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
+ * Transforms "messages" to W3C event stream content.
+ * See https://html.spec.whatwg.org/multipage/server-sent-events.html
+ * A message is an object with one or more of the following properties:
+ * - data (String or object, which gets turned into JSON)
+ * - type
+ * - id
+ * - retry
+ *
+ * If constructed with a HTTP Request, it will optimise the socket for streaming.
+ * If this stream is piped to an HTTP Response, it will set appropriate headers.
+ */
+export declare class SseStream extends Transform {
+    private lastEventId;
+    constructor(req?: IncomingMessage);
+    pipe<T extends HeaderStream>(destination: T, options?: {
+        end?: boolean;
+    }): T;
+    _transform(message: MessageEvent, encoding: string, callback: (error?: Error | null, data?: any) => void): void;
+    /**
+     * Calls `.write` but handles the drain if needed
+     */
+    writeMessage(message: MessageEvent, cb: (error: Error | null | undefined) => void): void;
+}
+export {};

package/router/sse-stream.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SseStream = void 0;
+const stream_1 = require("stream");
+function toDataString(data) {
+    if (typeof data === 'object') {
+        return toDataString(JSON.stringify(data));
+    }
+    return data
+        .split(/\r\n|\r|\n/)
+        .map(line => `data: ${line}\n`)
+        .join('');
+}
+/**
+ * Adapted from https://raw.githubusercontent.com/EventSource/node-ssestream
+ * Transforms "messages" to W3C event stream content.
+ * See https://html.spec.whatwg.org/multipage/server-sent-events.html
+ * A message is an object with one or more of the following properties:
+ * - data (String or object, which gets turned into JSON)
+ * - type
+ * - id
+ * - retry
+ *
+ * If constructed with a HTTP Request, it will optimise the socket for streaming.
+ * If this stream is piped to an HTTP Response, it will set appropriate headers.
+ */
+class SseStream extends stream_1.Transform {
+    constructor(req) {
+        super({ objectMode: true });
+        this.lastEventId = null;
+        if (req && req.socket) {
+            req.socket.setKeepAlive(true);
+            req.socket.setNoDelay(true);
+            req.socket.setTimeout(0);
+        }
+    }
+    pipe(destination, options) {
+        if (destination.writeHead) {
+            destination.writeHead(200, {
+                // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
+                'Content-Type': 'text/event-stream',
+                Connection: 'keep-alive',
+                // Disable cache, even for old browsers and proxies
+                'Cache-Control': 'private, no-cache, no-store, must-revalidate, max-age=0',
+                'Transfer-Encoding': 'identity',
+                Pragma: 'no-cache',
+                Expire: '0',
+                // NGINX support https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
+                'X-Accel-Buffering': 'no',
+            });
+            destination.flushHeaders();
+        }
+        destination.write(':\n');
+        return super.pipe(destination, options);
+    }
+    _transform(message, encoding, callback) {
+        let data = message.type ? `event: ${message.type}\n` : '';
+        data += message.id ? `id: ${message.id}\n` : '';
+        data += message.retry ? `retry: ${message.retry}\n` : '';
+        data += message.data ? toDataString(message.data) : '';
+        data += '\n';
+        this.push(data);
+        callback();
+    }
+    /**
+     * Calls `.write` but handles the drain if needed
+     */
+    writeMessage(message, cb) {
+        if (!message.id) {
+            this.lastEventId++;
+            message.id = this.lastEventId.toString();
+        }
+        if (!this.write(message, 'utf-8', cb)) {
+            this.once('drain', cb);
+        }
+        else {
+            process.nextTick(cb);
+        }
+    }
+}
+exports.SseStream = SseStream;