@midwayjs/faas
Version:
469 lines • 13.8 kB
TypeScript
/// <reference types="node" />
import { MidwayRequestContainer, IMidwayApplication, IConfigurationOptions, IMidwayContext, NextFunction as BaseNextFunction, CommonMiddlewareUnion, ContextMiddlewareManager, IMidwayBootstrapOptions, ObjectIdentifier, ILogger } from '@midwayjs/core';
import { Application as ServerlessHttpApplication, HttpResponseOptions } from '@midwayjs/serverless-http-parser';
import { Cookies } from '@midwayjs/cookies';
import { Writable } from 'stream';
interface ContextDelegatedRequest {
/**
* Check if the given `type(s)` is acceptable, returning
* the best match when true, otherwise `undefined`, in which
* case you should respond with 406 "Not Acceptable".
*
* The `type` value may be a single mime type string
* such as "application/json", the extension name
* such as "json" or an array `["json", "html", "text/plain"]`. When a list
* or array is given the _best_ match, if any is returned.
*
* Examples:
*
* // Accept: text/html
* this.accepts('html');
* // => "html"
*
* // Accept: text/*, application/json
* this.accepts('html');
* // => "html"
* this.accepts('text/html');
* // => "text/html"
* this.accepts('json', 'text');
* // => "json"
* this.accepts('application/json');
* // => "application/json"
*
* // Accept: text/*, application/json
* this.accepts('image/png');
* this.accepts('png');
* // => undefined
*
* // Accept: text/*;q=.5, application/json
* this.accepts(['html', 'json']);
* this.accepts('html', 'json');
* // => "json"
*/
accepts(): string[] | boolean;
accepts(...types: string[]): string | boolean;
accepts(types: string[]): string | boolean;
/**
* Return accepted encodings or best fit based on `encodings`.
*
* Given `Accept-Encoding: gzip, deflate`
* an array sorted by quality is returned:
*
* ['gzip', 'deflate']
*/
acceptsEncodings(): string[] | boolean;
acceptsEncodings(...encodings: string[]): string | boolean;
acceptsEncodings(encodings: string[]): string | boolean;
/**
* Return accepted charsets or best fit based on `charsets`.
*
* Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
* an array sorted by quality is returned:
*
* ['utf-8', 'utf-7', 'iso-8859-1']
*/
acceptsCharsets(): string[] | boolean;
acceptsCharsets(...charsets: string[]): string | boolean;
acceptsCharsets(charsets: string[]): string | boolean;
/**
* Return accepted languages or best fit based on `langs`.
*
* Given `Accept-Language: en;q=0.8, es, pt`
* an array sorted by quality is returned:
*
* ['es', 'pt', 'en']
*/
acceptsLanguages(): string[] | boolean;
acceptsLanguages(...langs: string[]): string | boolean;
acceptsLanguages(langs: string[]): string | boolean;
/**
* Check if the incoming request contains the "Content-Type"
* header field, and it contains any of the give mime `type`s.
* If there is no request body, `null` is returned.
* If there is no content type, `false` is returned.
* Otherwise, it returns the first `type` that matches.
*
* Examples:
*
* // With Content-Type: text/html; charset=utf-8
* this.is('html'); // => 'html'
* this.is('text/html'); // => 'text/html'
* this.is('text/*', 'application/json'); // => 'text/html'
*
* // When Content-Type is application/json
* this.is('json', 'urlencoded'); // => 'json'
* this.is('application/json'); // => 'application/json'
* this.is('html', 'application/*'); // => 'application/json'
*
* this.is('html'); // => false
*/
is(...types: string[]): string | boolean;
is(types: string[]): string | boolean;
/**
* Return request header. If the header is not set, will return an empty
* string.
*
* The `Referrer` header field is special-cased, both `Referrer` and
* `Referer` are interchangeable.
*
* Examples:
*
* this.get('Content-Type');
* // => "text/plain"
*
* this.get('content-type');
* // => "text/plain"
*
* this.get('Something');
* // => ''
*/
get(field: string): string;
/**
* Get parsed host from event
*/
host: string;
/**
* Get parsed host from event
*/
hostname: string;
/**
* Request remote address.
*/
ip: string;
/**
* Get/Set request URL.
*/
url: string;
originalUrl: string;
accept: any;
/**
* Get request pathname.
*/
path: string;
/**
* Get request method.
*/
method: string;
/**
* Return request header.
*/
header: {
[key: string]: string;
};
/**
* Return request header, alias as request.header
*/
headers: {
[key: string]: string;
};
/**
* Get parsed query-string.
*/
query: {
[key: string]: any;
};
/**
* Get parsed params
*/
params: {
[key: string]: string;
};
}
export interface FaaSHTTPRequest extends ContextDelegatedRequest {
/**
* Get parsed request body from event
*/
body: any;
/**
* Get Parsed path parameters from event
*/
pathParameters: any;
}
interface ContextDelegatedResponse {
/**
* Get/Set response status code.
*/
status: number;
/**
* Get/Set response body.
*/
body: any;
/**
* Return parsed response Content-Length when present.
* Set Content-Length field to `n`.
*/
length: number;
/**
* Return the response mime type void of
* parameters such as "charset".
*
* Set Content-Type response header with `type` through `mime.lookup()`
* when it does not contain a charset.
*
* Examples:
*
* this.type = '.html';
* this.type = 'html';
* this.type = 'json';
* this.type = 'application/json';
* this.type = 'png';
*/
type: string;
/**
* Get the Last-Modified date in Date form, if it exists.
* Set the Last-Modified date using a string or a Date.
*
* this.response.lastModified = new Date();
* this.response.lastModified = '2013-09-13';
*/
lastModified: Date;
/**
* Get/Set the ETag of a response.
* This will normalize the quotes if necessary.
*
* this.response.etag = 'md5hashsum';
* this.response.etag = '"md5hashsum"';
* this.response.etag = 'W/"123456789"';
*
* @param {String} etag
* @api public
*/
etag: string;
/**
* Set header `field` to `val`, or pass
* an object of header fields.
*
* Examples:
*
* this.set('Foo', ['bar', 'baz']);
* this.set('Accept', 'application/json');
* this.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
*/
set(field: {
[key: string]: string;
}): void;
set(field: string, val: string | string[]): void;
/**
* Append additional header `field` with value `val`.
*
* Examples:
*
* ```
* this.append('Link', ['<http://localhost/>', '<http://localhost:3000/>']);
* this.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly');
* this.append('Warning', '199 Miscellaneous warning');
* ```
*/
append(field: string, val: string | string[]): void;
/**
* Remove header `field`.
*/
remove(field: string): void;
/**
* Perform a 302 redirect to `url`.
*
* The string "back" is special-cased
* to provide Referrer support, when Referrer
* is not present `alt` or "/" is used.
*
* Examples:
*
* this.redirect('back');
* this.redirect('back', '/index.html');
* this.redirect('/login');
* this.redirect('http://google.com');
*/
redirect(url: string, alt?: string): void;
/**
* Get/Set streaming response.
*
* this.streaming = true;
*
* @api public
*/
streaming: boolean;
}
export interface FaaSHTTPResponse extends ContextDelegatedResponse, Pick<Writable, 'write' | 'end'> {
/**
* Return response header.
*/
header: {
[key: string]: any;
};
/**
* Return response header, alias as response.header
*/
headers: {
[key: string]: any;
};
/**
* Check whether the response is one of the listed types.
* Pretty much the same as `this.request.is()`.
*
* @param {String|Array} types...
* @return {String|false}
* @api public
*/
is(...types: string[]): string;
is(types: string[]): string;
/**
* Return response header. If the header is not set, will return an empty
* string.
*
* The `Referrer` header field is special-cased, both `Referrer` and
* `Referer` are interchangeable.
*
* Examples:
*
* this.get('Content-Type');
* // => "text/plain"
*
* this.get('content-type');
* // => "text/plain"
*
* this.get('Something');
* // => ''
*/
get(field: string): string;
}
export interface FaaSHTTPContext extends ContextDelegatedRequest, ContextDelegatedResponse {
/**
* It's a http request mock object, please don't use it directly.
*/
req: any;
/**
* It's a http response mock object, please don't use it directly.
*/
res: any;
/**
* FaaS http request object
*/
request: FaaSHTTPRequest;
/**
* FaaS http response object
*/
response: FaaSHTTPResponse;
/**
* FaaS original event object.
*/
originEvent: Record<string, any>;
/**
* FaaS Cookies Object
*/
cookies: Cookies;
/**
* FaaS Context State
*/
state: State;
/**
* Throw an error with `msg` and optional `status`
* defaulting to 500. Note that these are user-level
* errors, and the message may be exposed to the client.
*
* this.throw(403)
* this.throw('name required', 400)
* this.throw(400, 'name required')
* this.throw('something exploded')
* this.throw(new Error('invalid'), 400);
* this.throw(400, new Error('invalid'));
*
* See: https://github.com/jshttp/http-errors
*/
throw(message: string, code?: number, properties?: Record<string, unknown>): never;
throw(status: number): never;
throw(...properties: Array<number | string | Record<string, unknown>>): never;
}
export interface FaaSContext extends IMidwayContext<FaaSHTTPContext> {
logger: ILogger;
env: string;
requestContext: MidwayRequestContainer;
originContext: any;
}
/**
* @deprecated
*/
export type FaaSMiddleware = ((context: Context, next: () => Promise<any>) => any) | string;
export interface FormatResponseOptions {
supportBufferResponse?: boolean;
}
export interface HandlerOptions extends FormatResponseOptions {
isHttpFunction?: boolean;
isCustomHttpResponse?: boolean;
}
export type IMidwayFaaSApplication = IMidwayApplication<Context, {
getInitializeContext(): any;
/**
* @deprecated use useMiddleware instead
*/
use(middleware: FaaSMiddleware): any;
/**
* @deprecated
* @param middlewareId
*/
generateMiddleware(middlewareId: any): Promise<FaaSMiddleware>;
/**
* Get function name in serverless environment
*/
getFunctionName(): string;
/**
* Get function service name in serverless environment
*/
getFunctionServiceName(): string;
useEventMiddleware(middleware: CommonMiddlewareUnion<Context, NextFunction, undefined>): void;
getEventMiddleware(): ContextMiddlewareManager<Context, NextFunction, undefined>;
invokeTriggerFunction(context: any, handler: string, options: HandlerOptions): Promise<any>;
getServerlessInstance<T>(serviceClass: ObjectIdentifier | {
new (...args: any[]): T;
}, customContext?: Record<string, any>): Promise<T>;
}> & ServerlessHttpApplication;
export interface Application extends IMidwayFaaSApplication {
}
export interface Context extends FaaSContext {
}
export type NextFunction = BaseNextFunction;
export interface IFaaSConfigurationOptions extends IConfigurationOptions {
config?: object;
initializeContext?: object;
applicationAdapter?: {
/**
* @deprecated
*/
getApplication(): Application;
getFunctionName(): string;
getFunctionServiceName(): string;
runAppHook?(app: Application): void;
runContextHook?(ctx: Context): void;
};
}
/**
* @deprecated
*/
export interface IWebMiddleware {
resolve(): FaaSMiddleware;
}
export interface ServerlessStarterOptions extends IMidwayBootstrapOptions {
initializeMethodName?: string;
handlerName?: string;
aggregationHandlerName?: string;
handlerNameMapping?: (handlerName: string, ...args: unknown[]) => [string, ...unknown[]];
createAdapter?: () => Promise<{
close(): any;
createAppHook(app?: any): any;
}>;
performance?: {
mark(label: string): any;
end(): any;
};
}
export interface HttpResponseFormat<T = unknown> {
isBase64Encoded: boolean;
statusCode: number;
headers: Record<string, string>;
body: T;
}
export interface wrapHttpRequestOptions extends HttpResponseOptions {
}
export interface State {
}
export {};
//# sourceMappingURL=interface.d.ts.map