Options
All
  • Public
  • Public/Protected
  • All
Menu

The Express.js Response with oidc context added by the auth middleware.

app.use(auth());

app.get('/login', (req, res) => {
  res.oidc.login();
})
deprecated

use the native the Response interface of express instead; it has been extended and now includes a built in oidc param.

Type parameters

  • ResBody

  • Locals: Record<string, any>

  • StatusCode: number

Hierarchy

  • Response
    • OpenidResponse

Implements

  • WritableStream

Index

Constructors

constructor

Properties

app

app: Application

charset

charset: string

chunkedEncoding

chunkedEncoding: boolean

Readonly closed

closed: boolean

Is true after 'close' has been emitted.

since

v8.0.0

Readonly connection

connection: Socket | null

Aliases of outgoingMessage.socket

since

v0.3.0

deprecated

Since v15.12.0,v14.17.1 - Use socket instead.

destroyed

destroyed: boolean

Is true after writable.destroy() has been called.

since

v8.0.0

Readonly errored

errored: Error | null

Returns error if the stream has been destroyed with an error.

since

v18.0.0

finished

finished: boolean
deprecated

Use writableEnded instead.

headersSent

headersSent: boolean

json

json: Send<ResBody, this>

Send JSON response.

Examples:

res.json(null);
res.json({ user: 'tj' });
res.status(500).json('oh noes!');
res.status(404).json('I dont have that');

jsonp

jsonp: Send<ResBody, this>

Send JSON response with JSONP callback support.

Examples:

res.jsonp(null);
res.jsonp({ user: 'tj' });
res.status(500).jsonp('oh noes!');
res.status(404).jsonp('I dont have that');

locals

locals: Locals

oidc

Library namespace for authentication methods and data.

req

req: Request

After middleware.init executed, Response will contain req property See: express/lib/middleware/init.js

send

send: Send<ResBody, this>

Send a response.

Examples:

res.send(new Buffer('wahoo'));
res.send({ some: 'json' });
res.send('<p>some html</p>');
res.status(404).send('Sorry, cant find that');

sendDate

sendDate: boolean

shouldKeepAlive

shouldKeepAlive: boolean

Readonly socket

socket: Socket | null

Reference to the underlying socket. Usually, users will not want to access this property.

After calling outgoingMessage.end(), this property will be nulled.

since

v0.3.0

statusCode

statusCode: number

When using implicit headers (not calling response.writeHead() explicitly), this property controls the status code that will be sent to the client when the headers get flushed.

response.statusCode = 404;

After response header was sent to the client, this property indicates the status code which was sent out.

since

v0.4.0

statusMessage

statusMessage: string

When using implicit headers (not calling response.writeHead() explicitly), this property controls the status message that will be sent to the client when the headers get flushed. If this is left as undefined then the standard message for the status code will be used.

response.statusMessage = 'Not found';

After response header was sent to the client, this property indicates the status message which was sent out.

since

v0.11.8

useChunkedEncodingByDefault

useChunkedEncodingByDefault: boolean

Readonly writable

writable: boolean

Is true if it is safe to call writable.write(), which means the stream has not been destroyed, errored or ended.

since

v11.4.0

Readonly writableCorked

writableCorked: number

Number of times writable.uncork() needs to be called in order to fully uncork the stream.

since

v13.2.0, v12.16.0

Readonly writableEnded

writableEnded: boolean

Is true after writable.end() has been called. This property does not indicate whether the data has been flushed, for this use writable.writableFinished instead.

since

v12.9.0

Readonly writableFinished

writableFinished: boolean

Is set to true immediately before the 'finish' event is emitted.

since

v12.6.0

Readonly writableHighWaterMark

writableHighWaterMark: number

Return the value of highWaterMark passed when creating this Writable.

since

v9.3.0

Readonly writableLength

writableLength: number

This property contains the number of bytes (or objects) in the queue ready to be written. The value provides introspection data regarding the status of the highWaterMark.

since

v9.4.0

Readonly writableNeedDrain

writableNeedDrain: boolean

Is true if the stream's buffer has been full and stream will emit 'drain'.

since

v15.2.0, v14.17.0

Readonly writableObjectMode

writableObjectMode: boolean

Getter for the property objectMode of a given Writable stream.

since

v12.3.0

Methods

Optional _construct

  • _construct(callback: (error?: Error | null) => void): void
  • Parameters

    • callback: (error?: Error | null) => void
        • (error?: Error | null): void
        • Parameters

          • Optional error: Error | null

          Returns void

    Returns void

_destroy

  • _destroy(error: Error | null, callback: (error?: Error | null) => void): void
  • Parameters

    • error: Error | null
    • callback: (error?: Error | null) => void
        • (error?: Error | null): void
        • Parameters

          • Optional error: Error | null

          Returns void

    Returns void

_final

  • _final(callback: (error?: Error | null) => void): void
  • Parameters

    • callback: (error?: Error | null) => void
        • (error?: Error | null): void
        • Parameters

          • Optional error: Error | null

          Returns void

    Returns void

_write

  • _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void
  • Parameters

    • chunk: any
    • encoding: BufferEncoding
    • callback: (error?: Error | null) => void
        • (error?: Error | null): void
        • Parameters

          • Optional error: Error | null

          Returns void

    Returns void

Optional _writev

  • _writev(chunks: Array<{ chunk: any; encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void
  • Parameters

    • chunks: Array<{ chunk: any; encoding: BufferEncoding }>
    • callback: (error?: Error | null) => void
        • (error?: Error | null): void
        • Parameters

          • Optional error: Error | null

          Returns void

    Returns void

addListener

  • addListener(event: "close", listener: () => void): this
  • addListener(event: "drain", listener: () => void): this
  • addListener(event: "error", listener: (err: Error) => void): this
  • addListener(event: "finish", listener: () => void): this
  • addListener(event: "pipe", listener: (src: Readable) => void): this
  • addListener(event: "unpipe", listener: (src: Readable) => void): this
  • addListener(event: string | symbol, listener: (...args: any[]) => void): this
  • Event emitter The defined events on documents including:

    1. close
    2. drain
    3. error
    4. finish
    5. pipe
    6. unpipe

    Parameters

    • event: "close"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "drain"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "error"
    • listener: (err: Error) => void
        • (err: Error): void
        • Parameters

          • err: Error

          Returns void

    Returns this

  • Parameters

    • event: "finish"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "pipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: "unpipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

addTrailers

  • addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>): void
  • Adds HTTP trailers (headers but at the end of the message) to the message.

    Trailers are only be emitted if the message is chunked encoded. If not, the trailer will be silently discarded.

    HTTP requires the Trailer header to be sent to emit trailers, with a list of header fields in its value, e.g.

    message.writeHead(200, { 'Content-Type': 'text/plain',
                             'Trailer': 'Content-MD5' });
    message.write(fileData);
    message.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' });
    message.end();

    Attempting to set a header field name or value that contains invalid characters will result in a TypeError being thrown.

    since

    v0.3.0

    Parameters

    • headers: OutgoingHttpHeaders | ReadonlyArray<[string, string]>

    Returns void

append

  • append(field: string, value?: string[] | string): this
  • Appends the specified value to the HTTP response header field. If the header is not already set, it creates the header with the specified value. The value parameter can be a string or an array.

    Note: calling res.set() after res.append() will reset the previously-set header value.

    since

    4.11.0

    Parameters

    • field: string
    • Optional value: string[] | string

    Returns this

assignSocket

  • assignSocket(socket: Socket): void
  • Parameters

    • socket: Socket

    Returns void

attachment

  • attachment(filename?: string): this
  • Set Content-Disposition header to attachment with optional filename.

    Parameters

    • Optional filename: string

    Returns this

clearCookie

  • clearCookie(name: string, options?: CookieOptions): this
  • Clear cookie name.

    Parameters

    • name: string
    • Optional options: CookieOptions

    Returns this

contentType

  • contentType(type: string): this
  • Set Content-Type response header with type through mime.lookup() when it does not contain "/", or set the Content-Type to type otherwise.

    Examples:

    res.type('.html');
    res.type('html');
    res.type('json');
    res.type('application/json');
    res.type('png');

    Parameters

    • type: string

    Returns this

cookie

  • cookie(name: string, val: string, options: CookieOptions): this
  • cookie(name: string, val: any, options: CookieOptions): this
  • cookie(name: string, val: any): this
  • Set cookie name to val, with the given options.

    Options:

    • maxAge max-age in milliseconds, converted to expires
    • signed sign the cookie
    • path defaults to "/"

    Examples:

    // "Remember Me" for 15 minutes res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });

    // save as above res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })

    Parameters

    • name: string
    • val: string
    • options: CookieOptions

    Returns this

  • Parameters

    • name: string
    • val: any
    • options: CookieOptions

    Returns this

  • Parameters

    • name: string
    • val: any

    Returns this

cork

  • cork(): void
  • The writable.cork() method forces all written data to be buffered in memory. The buffered data will be flushed when either the uncork or end methods are called.

    The primary intent of writable.cork() is to accommodate a situation in which several small chunks are written to the stream in rapid succession. Instead of immediately forwarding them to the underlying destination, writable.cork()buffers all the chunks until writable.uncork() is called, which will pass them all to writable._writev(), if present. This prevents a head-of-line blocking situation where data is being buffered while waiting for the first small chunk to be processed. However, use of writable.cork() without implementingwritable._writev() may have an adverse effect on throughput.

    See also: writable.uncork(), writable._writev().

    since

    v0.11.2

    Returns void

destroy

  • destroy(error?: Error): this
  • Destroy the stream. Optionally emit an 'error' event, and emit a 'close'event (unless emitClose is set to false). After this call, the writable stream has ended and subsequent calls to write() or end() will result in an ERR_STREAM_DESTROYED error. This is a destructive and immediate way to destroy a stream. Previous calls towrite() may not have drained, and may trigger an ERR_STREAM_DESTROYED error. Use end() instead of destroy if data should flush before close, or wait for the 'drain' event before destroying the stream.

    Once destroy() has been called any further calls will be a no-op and no further errors except from _destroy() may be emitted as 'error'.

    Implementors should not override this method, but instead implement writable._destroy().

    since

    v8.0.0

    Parameters

    • Optional error: Error

      Optional, an error to emit with 'error' event.

    Returns this

detachSocket

  • detachSocket(socket: Socket): void
  • Parameters

    • socket: Socket

    Returns void

download

  • download(path: string, fn?: Errback): void
  • download(path: string, filename: string, fn?: Errback): void
  • download(path: string, filename: string, options: any, fn?: Errback): void
  • Transfer the file at the given path as an attachment.

    Optionally providing an alternate attachment filename, and optional callback fn(err). The callback is invoked when the data transfer is complete, or when an error has ocurred. Be sure to check res.headersSent if you plan to respond.

    The optional options argument passes through to the underlying res.sendFile() call, and takes the exact same parameters.

    This method uses res.sendfile().

    Parameters

    • path: string
    • Optional fn: Errback

    Returns void

  • Parameters

    • path: string
    • filename: string
    • Optional fn: Errback

    Returns void

  • Parameters

    • path: string
    • filename: string
    • options: any
    • Optional fn: Errback

    Returns void

emit

  • emit(event: "close"): boolean
  • emit(event: "drain"): boolean
  • emit(event: "error", err: Error): boolean
  • emit(event: "finish"): boolean
  • emit(event: "pipe", src: Readable): boolean
  • emit(event: "unpipe", src: Readable): boolean
  • emit(event: string | symbol, ...args: any[]): boolean
  • Parameters

    • event: "close"

    Returns boolean

  • Parameters

    • event: "drain"

    Returns boolean

  • Parameters

    • event: "error"
    • err: Error

    Returns boolean

  • Parameters

    • event: "finish"

    Returns boolean

  • Parameters

    • event: "pipe"
    • src: Readable

    Returns boolean

  • Parameters

    • event: "unpipe"
    • src: Readable

    Returns boolean

  • Parameters

    • event: string | symbol
    • Rest ...args: any[]

    Returns boolean

end

  • end(cb?: () => void): this
  • end(chunk: any, cb?: () => void): this
  • end(chunk: any, encoding: BufferEncoding, cb?: () => void): this
  • Calling the writable.end() method signals that no more data will be written to the Writable. The optional chunk and encoding arguments allow one final additional chunk of data to be written immediately before closing the stream.

    Calling the write method after calling end will raise an error.

    // Write 'hello, ' and then end with 'world!'.
    const fs = require('fs');
    const file = fs.createWriteStream('example.txt');
    file.write('hello, ');
    file.end('world!');
    // Writing more now is not allowed!
    since

    v0.9.4

    Parameters

    • Optional cb: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • chunk: any
    • Optional cb: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • chunk: any
    • encoding: BufferEncoding
    • Optional cb: () => void
        • (): void
        • Returns void

    Returns this

eventNames

  • eventNames(): Array<string | symbol>
  • Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or Symbols.

    const EventEmitter = require('events');
    const myEE = new EventEmitter();
    myEE.on('foo', () => {});
    myEE.on('bar', () => {});
    
    const sym = Symbol('symbol');
    myEE.on(sym, () => {});
    
    console.log(myEE.eventNames());
    // Prints: [ 'foo', 'bar', Symbol(symbol) ]
    since

    v6.0.0

    Returns Array<string | symbol>

flushHeaders

  • flushHeaders(): void
  • Compulsorily flushes the message headers

    For efficiency reason, Node.js normally buffers the message headers until outgoingMessage.end() is called or the first chunk of message data is written. It then tries to pack the headers and data into a single TCP packet.

    It is usually desired (it saves a TCP round-trip), but not when the first data is not sent until possibly much later. outgoingMessage.flushHeaders()bypasses the optimization and kickstarts the request.

    since

    v1.6.0

    Returns void

format

  • format(obj: any): this
  • Respond to the Acceptable formats using an obj of mime-type callbacks.

    This method uses req.accepted, an array of acceptable types ordered by their quality values. When "Accept" is not present the first callback is invoked, otherwise the first match is used. When no match is performed the server responds with 406 "Not Acceptable".

    Content-Type is set for you, however if you choose you may alter this within the callback using res.type() or res.set('Content-Type', ...).

    res.format({ 'text/plain': function(){ res.send('hey'); },

     'text/html': function(){
       res.send('<p>hey</p>');
     },
    
     'appliation/json': function(){
       res.send({ message: 'hey' });
     }

    });

    In addition to canonicalized MIME types you may also use extnames mapped to these types:

    res.format({ text: function(){ res.send('hey'); },

     html: function(){
       res.send('<p>hey</p>');
     },
    
     json: function(){
       res.send({ message: 'hey' });
     }

    });

    By default Express passes an Error with a .status of 406 to next(err) if a match is not made. If you provide a .default callback it will be invoked instead.

    Parameters

    • obj: any

    Returns this

get

  • get(field: string): string | undefined
  • Get value for header field.

    Parameters

    • field: string

    Returns string | undefined

getHeader

  • getHeader(name: string): number | string | string[] | undefined
  • Gets the value of HTTP header with the given name. If such a name doesn't exist in message, it will be undefined.

    since

    v0.4.0

    Parameters

    • name: string

      Name of header

    Returns number | string | string[] | undefined

getHeaderNames

  • getHeaderNames(): string[]
  • Returns an array of names of headers of the outgoing outgoingMessage. All names are lowercase.

    since

    v7.7.0

    Returns string[]

getHeaders

  • getHeaders(): OutgoingHttpHeaders
  • Returns a shallow copy of the current outgoing headers. Since a shallow copy is used, array values may be mutated without additional calls to various header-related HTTP module methods. The keys of the returned object are the header names and the values are the respective header values. All header names are lowercase.

    The object returned by the outgoingMessage.getHeaders() method does not prototypically inherit from the JavaScript Object. This means that typical Object methods such as obj.toString(), obj.hasOwnProperty(), and others are not defined and will not work.

    outgoingMessage.setHeader('Foo', 'bar');
    outgoingMessage.setHeader('Set-Cookie', ['foo=bar', 'bar=baz']);
    
    const headers = outgoingMessage.getHeaders();
    // headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }
    since

    v7.7.0

    Returns OutgoingHttpHeaders

getMaxListeners

  • getMaxListeners(): number
  • Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to {@link defaultMaxListeners}.

    since

    v1.0.0

    Returns number

hasHeader

  • hasHeader(name: string): boolean
  • Returns true if the header identified by name is currently set in the outgoing headers. The header name is case-insensitive.

    const hasContentType = outgoingMessage.hasHeader('content-type');
    since

    v7.7.0

    Parameters

    • name: string

    Returns boolean

header

  • header(field: any): this
  • header(field: string, value?: string | string[]): this
  • Parameters

    • field: any

    Returns this

  • Parameters

    • field: string
    • Optional value: string | string[]

    Returns this

links

  • links(links: any): this

listenerCount

  • listenerCount(eventName: string | symbol): number
  • Returns the number of listeners listening to the event named eventName.

    since

    v3.2.0

    Parameters

    • eventName: string | symbol

      The name of the event being listened for

    Returns number

listeners

  • listeners(eventName: string | symbol): Function[]
  • Returns a copy of the array of listeners for the event named eventName.

    server.on('connection', (stream) => {
      console.log('someone connected!');
    });
    console.log(util.inspect(server.listeners('connection')));
    // Prints: [ [Function] ]
    since

    v0.1.26

    Parameters

    • eventName: string | symbol

    Returns Function[]

location

  • location(url: string): this
  • Set the location header to url.

    The given url can also be the name of a mapped url, for example by default express supports "back" which redirects to the Referrer or Referer headers or "/".

    Examples:

    res.location('/foo/bar').; res.location('http://example.com'); res.location('../login'); // /blog/post/1 -> /blog/login

    Mounting:

    When an application is mounted and res.location() is given a path that does not lead with "/" it becomes relative to the mount-point. For example if the application is mounted at "/blog", the following would become "/blog/login".

     res.location('login');

    While the leading slash would result in a location of "/login":

     res.location('/login');

    Parameters

    • url: string

    Returns this

off

  • off(eventName: string | symbol, listener: (...args: any[]) => void): this
  • Alias for emitter.removeListener().

    since

    v10.0.0

    Parameters

    • eventName: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

on

  • on(event: "close", listener: () => void): this
  • on(event: "drain", listener: () => void): this
  • on(event: "error", listener: (err: Error) => void): this
  • on(event: "finish", listener: () => void): this
  • on(event: "pipe", listener: (src: Readable) => void): this
  • on(event: "unpipe", listener: (src: Readable) => void): this
  • on(event: string | symbol, listener: (...args: any[]) => void): this
  • Parameters

    • event: "close"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "drain"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "error"
    • listener: (err: Error) => void
        • (err: Error): void
        • Parameters

          • err: Error

          Returns void

    Returns this

  • Parameters

    • event: "finish"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "pipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: "unpipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

once

  • once(event: "close", listener: () => void): this
  • once(event: "drain", listener: () => void): this
  • once(event: "error", listener: (err: Error) => void): this
  • once(event: "finish", listener: () => void): this
  • once(event: "pipe", listener: (src: Readable) => void): this
  • once(event: "unpipe", listener: (src: Readable) => void): this
  • once(event: string | symbol, listener: (...args: any[]) => void): this
  • Parameters

    • event: "close"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "drain"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "error"
    • listener: (err: Error) => void
        • (err: Error): void
        • Parameters

          • err: Error

          Returns void

    Returns this

  • Parameters

    • event: "finish"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "pipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: "unpipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

pipe

  • pipe<T>(destination: T, options?: { end?: boolean | undefined }): T
  • Type parameters

    • T: WritableStream

    Parameters

    • destination: T
    • Optional options: { end?: boolean | undefined }
      • Optional end?: boolean | undefined

    Returns T

prependListener

  • prependListener(event: "close", listener: () => void): this
  • prependListener(event: "drain", listener: () => void): this
  • prependListener(event: "error", listener: (err: Error) => void): this
  • prependListener(event: "finish", listener: () => void): this
  • prependListener(event: "pipe", listener: (src: Readable) => void): this
  • prependListener(event: "unpipe", listener: (src: Readable) => void): this
  • prependListener(event: string | symbol, listener: (...args: any[]) => void): this
  • Parameters

    • event: "close"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "drain"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "error"
    • listener: (err: Error) => void
        • (err: Error): void
        • Parameters

          • err: Error

          Returns void

    Returns this

  • Parameters

    • event: "finish"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "pipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: "unpipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

prependOnceListener

  • prependOnceListener(event: "close", listener: () => void): this
  • prependOnceListener(event: "drain", listener: () => void): this
  • prependOnceListener(event: "error", listener: (err: Error) => void): this
  • prependOnceListener(event: "finish", listener: () => void): this
  • prependOnceListener(event: "pipe", listener: (src: Readable) => void): this
  • prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this
  • prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this
  • Parameters

    • event: "close"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "drain"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "error"
    • listener: (err: Error) => void
        • (err: Error): void
        • Parameters

          • err: Error

          Returns void

    Returns this

  • Parameters

    • event: "finish"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "pipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: "unpipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

rawListeners

  • rawListeners(eventName: string | symbol): Function[]
  • Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

    const emitter = new EventEmitter();
    emitter.once('log', () => console.log('log once'));
    
    // Returns a new Array with a function `onceWrapper` which has a property
    // `listener` which contains the original listener bound above
    const listeners = emitter.rawListeners('log');
    const logFnWrapper = listeners[0];
    
    // Logs "log once" to the console and does not unbind the `once` event
    logFnWrapper.listener();
    
    // Logs "log once" to the console and removes the listener
    logFnWrapper();
    
    emitter.on('log', () => console.log('log persistently'));
    // Will return a new Array with a single function bound by `.on()` above
    const newListeners = emitter.rawListeners('log');
    
    // Logs "log persistently" twice
    newListeners[0]();
    emitter.emit('log');
    since

    v9.4.0

    Parameters

    • eventName: string | symbol

    Returns Function[]

redirect

  • redirect(url: string): void
  • redirect(status: number, url: string): void
  • redirect(url: string, status: number): void
  • Redirect to the given url with optional response status defaulting to 302.

    The resulting url is determined by res.location(), so it will play nicely with mounted apps, relative paths, "back" etc.

    Examples:

    res.redirect('/foo/bar'); res.redirect('http://example.com'); res.redirect(301, 'http://example.com'); res.redirect('http://example.com', 301); res.redirect('../login'); // /blog/post/1 -> /blog/login

    Parameters

    • url: string

    Returns void

  • Parameters

    • status: number
    • url: string

    Returns void

  • Parameters

    • url: string
    • status: number

    Returns void

removeAllListeners

  • removeAllListeners(event?: string | symbol): this
  • Removes all listeners, or those of the specified eventName.

    It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

    Returns a reference to the EventEmitter, so that calls can be chained.

    since

    v0.1.26

    Parameters

    • Optional event: string | symbol

    Returns this

removeHeader

  • removeHeader(name: string): void
  • Removes a header that is queued for implicit sending.

    outgoingMessage.removeHeader('Content-Encoding');
    since

    v0.4.0

    Parameters

    • name: string

      Header name

    Returns void

removeListener

  • removeListener(event: "close", listener: () => void): this
  • removeListener(event: "drain", listener: () => void): this
  • removeListener(event: "error", listener: (err: Error) => void): this
  • removeListener(event: "finish", listener: () => void): this
  • removeListener(event: "pipe", listener: (src: Readable) => void): this
  • removeListener(event: "unpipe", listener: (src: Readable) => void): this
  • removeListener(event: string | symbol, listener: (...args: any[]) => void): this
  • Parameters

    • event: "close"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "drain"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "error"
    • listener: (err: Error) => void
        • (err: Error): void
        • Parameters

          • err: Error

          Returns void

    Returns this

  • Parameters

    • event: "finish"
    • listener: () => void
        • (): void
        • Returns void

    Returns this

  • Parameters

    • event: "pipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: "unpipe"
    • listener: (src: Readable) => void
        • (src: Readable): void
        • Parameters

          • src: Readable

          Returns void

    Returns this

  • Parameters

    • event: string | symbol
    • listener: (...args: any[]) => void
        • (...args: any[]): void
        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

render

  • render(view: string, options?: object, callback?: (err: Error, html: string) => void): void
  • render(view: string, callback?: (err: Error, html: string) => void): void
  • Render view with the given options and optional callback fn. When a callback function is given a response will not be made automatically, otherwise a response of 200 and text/html is given.

    Options:

    • cache boolean hinting to the engine it should cache
    • filename filename of the view being rendered

    Parameters

    • view: string
    • Optional options: object
    • Optional callback: (err: Error, html: string) => void
        • (err: Error, html: string): void
        • Parameters

          • err: Error
          • html: string

          Returns void

    Returns void

  • Parameters

    • view: string
    • Optional callback: (err: Error, html: string) => void
        • (err: Error, html: string): void
        • Parameters

          • err: Error
          • html: string

          Returns void

    Returns void

sendFile

  • sendFile(path: string, fn?: Errback): void
  • sendFile(path: string, options: any, fn?: Errback): void
  • Transfer the file at the given path.

    Automatically sets the Content-Type response header field. The callback fn(err) is invoked when the transfer is complete or when an error occurs. Be sure to check res.headersSent if you wish to attempt responding, as the header and some data may have already been transferred.

    Options:

    • maxAge defaulting to 0 (can be string converted by ms)
    • root root directory for relative filenames
    • headers object of headers to serve with file
    • dotfiles serve dotfiles, defaulting to false; can be "allow" to send them

    Other options are passed along to send.

    Examples:

    The following example illustrates how res.sendFile() may be used as an alternative for the static() middleware for dynamic situations. The code backing res.sendFile() is actually the same code, so HTTP cache support etc is identical.

    app.get('/user/:uid/photos/:file', function(req, res){
      var uid = req.params.uid
        , file = req.params.file;
    
      req.user.mayViewFilesFrom(uid, function(yes){
        if (yes) {
          res.sendFile('/uploads/' + uid + '/' + file);
        } else {
          res.send(403, 'Sorry! you cant see that.');
        }
      });
    });
    api

    public

    Parameters

    • path: string
    • Optional fn: Errback

    Returns void

  • Parameters

    • path: string
    • options: any
    • Optional fn: Errback

    Returns void

sendStatus

  • sendStatus(code: StatusCode): this
  • Set the response HTTP status code to statusCode and send its string representation as the response body.

    link

    http://expressjs.com/4x/api.html#res.sendStatus

    Examples:

    res.sendStatus(200); // equivalent to res.status(200).send('OK') res.sendStatus(403); // equivalent to res.status(403).send('Forbidden') res.sendStatus(404); // equivalent to res.status(404).send('Not Found') res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')

    Parameters

    • code: StatusCode

    Returns this

sendfile

  • sendfile(path: string): void
  • sendfile(path: string, options: any): void
  • sendfile(path: string, fn: Errback): void
  • sendfile(path: string, options: any, fn: Errback): void
  • deprecated

    Use sendFile instead.

    Parameters

    • path: string

    Returns void

  • deprecated

    Use sendFile instead.

    Parameters

    • path: string
    • options: any

    Returns void

  • deprecated

    Use sendFile instead.

    Parameters

    • path: string
    • fn: Errback

    Returns void

  • deprecated

    Use sendFile instead.

    Parameters

    • path: string
    • options: any
    • fn: Errback

    Returns void

set

  • set(field: any): this
  • set(field: string, value?: string | string[]): this
  • Set header field to val, or pass an object of header fields.

    Examples:

    res.set('Foo', ['bar', 'baz']); res.set('Accept', 'application/json'); res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });

    Aliased as res.header().

    Parameters

    • field: any

    Returns this

  • Parameters

    • field: string
    • Optional value: string | string[]

    Returns this

setDefaultEncoding

  • setDefaultEncoding(encoding: BufferEncoding): this
  • The writable.setDefaultEncoding() method sets the default encoding for a Writable stream.

    since

    v0.11.15

    Parameters

    • encoding: BufferEncoding

      The new default encoding

    Returns this

setHeader

  • setHeader(name: string, value: number | string | ReadonlyArray<string>): this
  • Sets a single header value for the header object.

    since

    v0.4.0

    Parameters

    • name: string

      Header name

    • value: number | string | ReadonlyArray<string>

      Header value

    Returns this

setMaxListeners

  • setMaxListeners(n: number): this
  • By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set toInfinity (or 0) to indicate an unlimited number of listeners.

    Returns a reference to the EventEmitter, so that calls can be chained.

    since

    v0.3.5

    Parameters

    • n: number

    Returns this

setTimeout

  • setTimeout(msecs: number, callback?: () => void): this
  • Once a socket is associated with the message and is connected,socket.setTimeout() will be called with msecs as the first parameter.

    since

    v0.9.12

    Parameters

    • msecs: number
    • Optional callback: () => void

      Optional function to be called when a timeout occurs. Same as binding to the timeout event.

        • (): void
        • Returns void

    Returns this

status

  • status(code: StatusCode): this
  • Set status code.

    Parameters

    • code: StatusCode

    Returns this

type

  • type(type: string): this
  • Set Content-Type response header with type through mime.lookup() when it does not contain "/", or set the Content-Type to type otherwise.

    Examples:

    res.type('.html');
    res.type('html');
    res.type('json');
    res.type('application/json');
    res.type('png');

    Parameters

    • type: string

    Returns this

uncork

  • uncork(): void
  • The writable.uncork() method flushes all data buffered since cork was called.

    When using writable.cork() and writable.uncork() to manage the buffering of writes to a stream, defer calls to writable.uncork() usingprocess.nextTick(). Doing so allows batching of allwritable.write() calls that occur within a given Node.js event loop phase.

    stream.cork();
    stream.write('some ');
    stream.write('data ');
    process.nextTick(() => stream.uncork());

    If the writable.cork() method is called multiple times on a stream, the same number of calls to writable.uncork() must be called to flush the buffered data.

    stream.cork();
    stream.write('some ');
    stream.cork();
    stream.write('data ');
    process.nextTick(() => {
      stream.uncork();
      // The data will not be flushed until uncork() is called a second time.
      stream.uncork();
    });

    See also: writable.cork().

    since

    v0.11.2

    Returns void

vary

  • vary(field: string): this
  • Adds the field to the Vary response header, if it is not there already. Examples:

    res.vary('User-Agent').render('docs');

    Parameters

    • field: string

    Returns this

write

  • write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean
  • write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean
  • The writable.write() method writes some data to the stream, and calls the supplied callback once the data has been fully handled. If an error occurs, the callback will be called with the error as its first argument. The callback is called asynchronously and before 'error' is emitted.

    The return value is true if the internal buffer is less than thehighWaterMark configured when the stream was created after admitting chunk. If false is returned, further attempts to write data to the stream should stop until the 'drain' event is emitted.

    While a stream is not draining, calls to write() will buffer chunk, and return false. Once all currently buffered chunks are drained (accepted for delivery by the operating system), the 'drain' event will be emitted. Once write() returns false, do not write more chunks until the 'drain' event is emitted. While calling write() on a stream that is not draining is allowed, Node.js will buffer all written chunks until maximum memory usage occurs, at which point it will abort unconditionally. Even before it aborts, high memory usage will cause poor garbage collector performance and high RSS (which is not typically released back to the system, even after the memory is no longer required). Since TCP sockets may never drain if the remote peer does not read the data, writing a socket that is not draining may lead to a remotely exploitable vulnerability.

    Writing data while the stream is not draining is particularly problematic for a Transform, because the Transform streams are paused by default until they are piped or a 'data' or 'readable' event handler is added.

    If the data to be written can be generated or fetched on demand, it is recommended to encapsulate the logic into a Readable and use pipe. However, if calling write() is preferred, it is possible to respect backpressure and avoid memory issues using the 'drain' event:

    function write(data, cb) {
      if (!stream.write(data)) {
        stream.once('drain', cb);
      } else {
        process.nextTick(cb);
      }
    }
    
    // Wait for cb to be called before doing any other write.
    write('hello', () => {
      console.log('Write completed, do more writes now.');
    });

    A Writable stream in object mode will always ignore the encoding argument.

    since

    v0.9.4

    Parameters

    • chunk: any

      Optional data to write. For streams not operating in object mode, chunk must be a string, Buffer or Uint8Array. For object mode streams, chunk may be any JavaScript value other than null.

    • Optional callback: (error: Error | null | undefined) => void

      Callback for when this chunk of data is flushed.

        • (error: Error | null | undefined): void
        • Parameters

          • error: Error | null | undefined

          Returns void

    Returns boolean

    false if the stream wishes for the calling code to wait for the 'drain' event to be emitted before continuing to write additional data; otherwise true.

  • Parameters

    • chunk: any
    • encoding: BufferEncoding
    • Optional callback: (error: Error | null | undefined) => void
        • (error: Error | null | undefined): void
        • Parameters

          • error: Error | null | undefined

          Returns void

    Returns boolean

writeContinue

  • writeContinue(callback?: () => void): void
  • Sends a HTTP/1.1 100 Continue message to the client, indicating that the request body should be sent. See the 'checkContinue' event onServer.

    since

    v0.3.0

    Parameters

    • Optional callback: () => void
        • (): void
        • Returns void

    Returns void

writeHead

  • writeHead(statusCode: number, statusMessage?: string, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this
  • writeHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this
  • Sends a response header to the request. The status code is a 3-digit HTTP status code, like 404. The last argument, headers, are the response headers. Optionally one can give a human-readable statusMessage as the second argument.

    headers may be an Array where the keys and values are in the same list. It is not a list of tuples. So, the even-numbered offsets are key values, and the odd-numbered offsets are the associated values. The array is in the same format as request.rawHeaders.

    Returns a reference to the ServerResponse, so that calls can be chained.

    const body = 'hello world';
    response
      .writeHead(200, {
        'Content-Length': Buffer.byteLength(body),
        'Content-Type': 'text/plain'
      })
      .end(body);

    This method must only be called once on a message and it must be called before response.end() is called.

    If response.write() or response.end() are called before calling this, the implicit/mutable headers will be calculated and call this function.

    When headers have been set with response.setHeader(), they will be merged with any headers passed to response.writeHead(), with the headers passed to response.writeHead() given precedence.

    If this method is called and response.setHeader() has not been called, it will directly write the supplied header values onto the network channel without caching internally, and the response.getHeader() on the header will not yield the expected result. If progressive population of headers is desired with potential future retrieval and modification, use response.setHeader() instead.

    // Returns content-type = text/plain
    const server = http.createServer((req, res) => {
      res.setHeader('Content-Type', 'text/html');
      res.setHeader('X-Foo', 'bar');
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      res.end('ok');
    });

    Content-Length is given in bytes, not characters. Use Buffer.byteLength() to determine the length of the body in bytes. Node.js does not check whether Content-Length and the length of the body which has been transmitted are equal or not.

    Attempting to set a header field name or value that contains invalid characters will result in a TypeError being thrown.

    since

    v0.1.30

    Parameters

    • statusCode: number
    • Optional statusMessage: string
    • Optional headers: OutgoingHttpHeaders | OutgoingHttpHeader[]

    Returns this

  • Parameters

    • statusCode: number
    • Optional headers: OutgoingHttpHeaders | OutgoingHttpHeader[]

    Returns this

writeProcessing

  • writeProcessing(): void
  • Sends a HTTP/1.1 102 Processing message to the client, indicating that the request body should be sent.

    since

    v10.0.0

    Returns void