@h4ad/serverless-adapter 4.0.0 → 4.1.0

package/lib/index.d.ts

@@ -0,0 +1,439 @@
+import { B as BinarySettings, H as HandlerContract, S as ServerlessHandler } from './handler.contract-8Cb7qLSi.js';
+export { b as BinarySettingsContentHeaders, a as BinarySettingsFunction } from './handler.contract-8Cb7qLSi.js';
+import { B as BothValueHeaders } from './headers-K2qbcurv.js';
+export { M as MultiValueHeaders, S as SingleValueHeaders } from './headers-K2qbcurv.js';
+export { C as Concrete, S as StripBasePathFn, b as buildStripBasePath, g as getPathWithQueryStringParams, a as getQueryParamsStringFromRecord } from './path-yBwCb8C1.js';
+import { A as AdapterContract, R as ResolverContract } from './adapter.contract-EQE3rlgO.js';
+export { a as AdapterRequest, D as DelegatedResolver, G as GetResponseAdapterProps, O as OnErrorProps, c as Resolver, b as ResolverProps, S as ServerlessResponse, d as ServerlessResponseProps } from './adapter.contract-EQE3rlgO.js';
+import { F as FrameworkContract } from './framework.contract-YnJ-fl1w.js';
+export { B as BaseHandler } from './base-handler-fYEk59Xq.js';
+export { a as DEFAULT_BINARY_CONTENT_TYPES, D as DEFAULT_BINARY_ENCODINGS, E as EmptyResponse, I as IEmptyResponse } from './constants-0cgQlFSV.js';
+import { I as ILogger } from './logger-9me5n48P.js';
+export { L as LogLevels, b as LoggerFN, a as LoggerOptions, c as createDefaultLogger, i as isInternalLogger } from './logger-9me5n48P.js';
+import { Writable, Readable } from 'node:stream';
+export { S as ServerlessRequest, a as ServerlessRequestProps } from './request-sVa4pxmx.js';
+import { ServerResponse } from 'node:http';
+import 'http';
+
+/**
+ * The properties to create a {@link ServerlessStreamResponse}.
+ *
+ * @breadcrumb Network / ServerlessStreamResponse
+ * @public
+ */
+interface ServerlessStreamResponseProps {
+    /**
+     * The HTTP Method from request
+     */
+    method?: string;
+    /**
+     * The callback to receive the headers when they are written to the stream
+     * You need to return a writable stream be able to continue writing the response
+     *
+     * @param statusCode - The status code of the response
+     * @param headers - The headers of the response
+     */
+    onReceiveHeaders: (statusCode: number, headers: BothValueHeaders) => Writable;
+    /**
+     * Instance of the logger
+     */
+    log: ILogger;
+}
+/**
+ * The class that represents a response instance used to send to the framework and wait until the framework finishes processing the request.
+ * This response is specially built to deal with transfer-encoding: chunked
+ *
+ * @breadcrumb Network / ServerlessStreamResponse
+ * @public
+ */
+declare class ServerlessStreamResponse extends ServerResponse {
+    constructor({ method, onReceiveHeaders, log, }: ServerlessStreamResponseProps);
+}
+
+/**
+ * Get the data from a buffer, string, or Uint8Array
+ *
+ * @breadcrumb Network
+ * @param data - The data that was written inside the stream
+ */
+declare function getString(data: Buffer | string | unknown): string;
+
+/**
+ * The type that represents the object that handles the references to the event created by the serverless trigger or context created by the serverless environment.
+ *
+ * @breadcrumb Core / Current Invoke
+ * @public
+ */
+type CurrentInvoke<TEvent, TContext> = {
+    /**
+     * The event created by the serverless trigger
+     *
+     * @remarks It's only null when you call {@link getCurrentInvoke} outside this library's pipeline.
+     */
+    event: TEvent | null;
+    /**
+     * The context created by the serverless environment
+     *
+     * @remarks It's only null when you call {@link getCurrentInvoke} outside this library's pipeline.
+     */
+    context: TContext | null;
+};
+/**
+ * Get the reference to the event created by the serverless trigger or context created by the serverless environment.
+ *
+ * @example
+ * ```typescript
+ * import type { ALBEvent, Context } from 'aws-lambda';
+ *
+ * // inside the method that handles the aws alb request.
+ * const { event, context } = getCurrentInvoke<ALBEvent, Context>();
+ * ```
+ *
+ * @breadcrumb Core / Current Invoke
+ * @public
+ */
+declare function getCurrentInvoke<TEvent = any, TContext = any>(): CurrentInvoke<TEvent, TContext>;
+/**
+ * Method that saves to the event created by the serverless trigger or context created by the serverless environment.
+ *
+ * @remarks This method MUST NOT be called by you, this method MUST only be used internally in this library.
+ *
+ * @param event - The event created by the serverless trigger
+ * @param context - The context created by the serverless environment
+ *
+ * @breadcrumb Core / Current Invoke
+ * @public
+ */
+declare function setCurrentInvoke<TEvent = any, TContext = any>({ event, context, }: CurrentInvoke<TEvent, TContext>): void;
+
+/**
+ * Get the event body as buffer from body string with content length
+ *
+ * @example
+ * ```typescript
+ * const body = '{}';
+ * const [buffer, contentLength] = getEventBodyAsBuffer(body, false);
+ * console.log(buffer);
+ * // <Buffer 7b 7d>
+ * console.log(contentLength);
+ * // 2
+ * ```
+ *
+ * @param body - The body string that can be encoded or not
+ * @param isBase64Encoded - Tells if body string is encoded in base64
+ *
+ * @breadcrumb Core
+ * @public
+ */
+declare function getEventBodyAsBuffer(body: string, isBase64Encoded: boolean): [body: Buffer, contentLength: number];
+
+/**
+ * Transform a header map and make sure the value is not an array
+ *
+ * @example
+ * ```typescript
+ * const headers = { 'accept-encoding': 'gzip', 'accept-language': ['en-US', 'en;q=0.9'] };
+ * const flattenedHeaders = getFlattenedHeadersMap(headers, ',', true);
+ * console.log(flattenedHeaders);
+ * // { 'accept-encoding': 'gzip', 'accept-language': 'en-US,en;q=0.9' }
+ * ```
+ *
+ * @param headersMap - The initial headers
+ * @param separator - The separator used when we join the array of header's value
+ * @param lowerCaseKey - Should put all keys in lowercase
+ *
+ * @breadcrumb Core / Headers
+ * @public
+ */
+declare function getFlattenedHeadersMap(headersMap: BothValueHeaders, separator?: string, lowerCaseKey?: boolean): Record<string, string>;
+/**
+ * Transforms a header map into a multi-value map header.
+ *
+ * @example
+ * ```typescript
+ * const headers = { 'accept-encoding': 'gzip', 'connection': ['keep-alive'] };
+ * const multiValueHeaders = getMultiValueHeadersMap(headers);
+ * console.log(multiValueHeaders);
+ * // { 'accept-encoding': ['gzip'], 'connection': ['keep-alive'] }
+ * ```
+ *
+ * @param headersMap - The initial headers
+ *
+ * @breadcrumb Core / Headers
+ * @public
+ */
+declare function getMultiValueHeadersMap(headersMap: BothValueHeaders): Record<string, string[]>;
+/**
+ * The wrapper that holds the information about single value headers and cookies
+ *
+ * @breadcrumb Core / Headers
+ * @public
+ */
+type FlattenedHeadersAndCookies = {
+    /**
+     * Just the single value headers
+     */
+    headers: Record<string, string>;
+    /**
+     * The list of cookies
+     */
+    cookies: string[];
+};
+/**
+ * Transforms a header map into a single value headers and cookies
+ *
+ * @param headersMap - The initial headers
+ *
+ * @breadcrumb Core / Headers
+ * @public
+ */
+declare function getFlattenedHeadersMapAndCookies(headersMap: BothValueHeaders): FlattenedHeadersAndCookies;
+/**
+ * Parse HTTP Raw Headers
+ * Attribution to {@link https://github.com/kesla/parse-headers/blob/master/parse-headers.js}
+ *
+ * @param headers - The raw headers
+ *
+ * @breadcrumb Core / Headers
+ * @public
+ */
+declare function parseHeaders(headers: string): Record<string, string | string[]>;
+
+/**
+ * The function that determines by the content encoding whether the response should be treated as binary
+ *
+ * @example
+ * ```typescript
+ * const headers = { 'content-encoding': 'gzip' };
+ * const isBinary = isContentEncodingBinary(headers, ['gzip']);
+ * console.log(isBinary);
+ * // true
+ * ```
+ *
+ * @param headers - The headers of the response
+ * @param binaryEncodingTypes - The list of content encodings that will be treated as binary
+ *
+ * @breadcrumb Core / isBinary
+ * @public
+ */
+declare function isContentEncodingBinary(headers: BothValueHeaders, binaryEncodingTypes: string[]): boolean;
+/**
+ * The function that returns the content type of headers
+ *
+ * @example
+ * ```typescript
+ * const headers = { 'content-type': 'application/json' };
+ * const contentType = getContentType(headers);
+ * console.log(contentType);
+ * // application/json
+ * ```
+ *
+ * @param headers - The headers of the response
+ *
+ * @breadcrumb Core / isBinary
+ * @public
+ */
+declare function getContentType(headers: BothValueHeaders): string;
+/**
+ * The function that determines by the content type whether the response should be treated as binary
+ *
+ * @example
+ * ```typescript
+ * const headers = { 'content-type': 'image/png' };
+ * const isBinary = isContentTypeBinary(headers, new Map([['image/png', true]]));
+ * console.log(isBinary);
+ * // true
+ * ```
+ *
+ * @param headers - The headers of the response
+ * @param binaryContentTypes - The list of content types that will be treated as binary
+ *
+ * @breadcrumb Core / isBinary
+ * @public
+ */
+declare function isContentTypeBinary(headers: BothValueHeaders, binaryContentTypes: string[]): boolean;
+/**
+ * The function used to determine from the headers and the binary settings if a response should be encoded or not
+ *
+ * @example
+ * ```typescript
+ * const headers = { 'content-type': 'image/png', 'content-encoding': 'gzip' };
+ * const isContentBinary = isBinary(headers, { contentEncodings: ['gzip'], contentTypes: ['image/png'] });
+ * console.log(isContentBinary);
+ * // true
+ * ```
+ *
+ * @param headers - The headers of the response
+ * @param binarySettings - The settings for the validation
+ *
+ * @breadcrumb Core / isBinary
+ * @public
+ */
+declare function isBinary(headers: BothValueHeaders, binarySettings: BinarySettings): boolean;
+
+/**
+ * No operation function is used when we need to pass a function, but we don't want to specify any behavior.
+ *
+ * @breadcrumb Core
+ * @public
+ */
+declare const NO_OP: (...args: any[]) => any;
+
+/**
+ * Return the defaultValue whether the value is undefined, otherwise, return the value.
+ *
+ * @example
+ * ```typescript
+ * const value1 = getDefaultIfUndefined(undefined, true);
+ * const value2 = getDefaultIfUndefined(false, true);
+ *
+ * console.log(value1);
+ * // true
+ * console.log(value2);
+ * // false
+ * ```
+ *
+ * @param value - The value to be checked
+ * @param defaultValue - The default value when value is undefined
+ *
+ * @breadcrumb Core
+ * @public
+ */
+declare function getDefaultIfUndefined<T>(value: T | undefined, defaultValue: T): T;
+
+/**
+ * Check if stream already ended
+ *
+ * @param stream - The stream
+ *
+ * @breadcrumb Core / Stream
+ * @public
+ */
+declare function isStreamEnded(stream: Readable | Writable): boolean;
+/**
+ * Wait asynchronous the stream to complete
+ *
+ * @param stream - The stream
+ *
+ * @breadcrumb Core / Stream
+ * @public
+ */
+declare function waitForStreamComplete<TStream extends Readable | Writable>(stream: TStream): Promise<TStream>;
+
+/**
+ * The class used to build the serverless handler.
+ *
+ * @example
+ * ```typescript
+ * const app = express();
+ * export const handler = ServerlessAdapter.new(app)
+ *   .setFramework(new ExpressFramework())
+ *   .setHandler(new DefaultHandler())
+ *   .setResolver(new PromiseResolver())
+ *   .setRespondWithErrors(true)
+ *   .addAdapter(new AlbAdapter())
+ *   .addAdapter(new SQSAdapter())
+ *   .addAdapter(new SNSAdapter())
+ *   .build();
+ * ```
+ *
+ * @breadcrumb ServerlessAdapter
+ * @public
+ */
+declare class ServerlessAdapter<TApp, TEvent, TContext, TCallback, TResponse, TReturn> {
+    /**
+     * Default constructor
+     */
+    private constructor();
+    /**
+     * The instance of the app (express, hapi, koa, etc...)
+     */
+    protected app: TApp;
+    /**
+     * Settings for whether the response should be treated as binary or not
+     *
+     * @defaultValue `contentEncodings` and `contentTypes` are set with {@link DEFAULT_BINARY_ENCODINGS} and {@link DEFAULT_BINARY_CONTENT_TYPES}, respectively.
+     */
+    protected binarySettings: BinarySettings;
+    /**
+     * Indicates whether the error stack should be included in the response or not
+     *
+     * @remarks These errors will only be included when an error occurs while forwarding the event to the framework
+     * @defaultValue True when NODE_ENV is equal to `development`
+     */
+    protected respondWithErrors: boolean;
+    /**
+     * The instance of the logger service
+     */
+    protected log: ILogger;
+    /**
+     * The list of adapters used to handle an event's request and response
+     */
+    protected adapters: AdapterContract<TEvent, TContext, TResponse>[];
+    /**
+     * The framework that will process requests
+     */
+    protected framework?: FrameworkContract<TApp>;
+    /**
+     * The resolver that aims to resolve the response to serverless and stop its execution when the request ends
+     */
+    protected resolver?: ResolverContract<TEvent, TContext, TCallback, TResponse, TReturn>;
+    /**
+     * The handler that will get the event, context and callback and pass it to the adapter and framework
+     */
+    protected handler?: HandlerContract<TApp, TEvent, TContext, TCallback, TResponse, TReturn>;
+    /**
+     * Creates a new instance of the builder with app (express, hapi, koa, etc...)
+     *
+     * @param app - The instance of the app
+     */
+    static new<TApp, TEvent, TContext = any, TCallback = any, TResponse = any, TReturn = any>(app: TApp): ServerlessAdapter<TApp, TEvent, TContext, TCallback, TResponse, TReturn>;
+    /**
+     * Defines the handler that will get the event, context and callback and pass it to the adapter and framework
+     *
+     * @param handler - The implementation of the handler contract
+     */
+    setHandler(handler: HandlerContract<TApp, TEvent, TContext, TCallback, TResponse, TReturn>): Omit<this, 'setHandler'>;
+    /**
+     * Defines the resolver that aims to resolve the response to serverless and stop its execution when the request ends
+     *
+     * @param resolver - The implementation of the resolver contract
+     */
+    setResolver(resolver: ResolverContract<TEvent, TContext, TCallback, TResponse, TReturn>): Omit<this, 'setResolver'>;
+    /**
+     * Defines the framework that will process requests
+     *
+     * @param framework - The implementation of the framework contract
+     */
+    setFramework(framework: FrameworkContract<TApp>): Omit<this, 'setFramework'>;
+    /**
+     * Defines the logger service used during the execution of the handler
+     *
+     * @param logger - The implementation of the logger
+     */
+    setLogger(logger: ILogger): Omit<this, 'setLogger'>;
+    /**
+     * Defines the binary settings for whether the response should be treated as binary or not
+     *
+     * @param binarySettings - The binary settings
+     */
+    setBinarySettings(binarySettings: BinarySettings): Omit<this, 'setBinarySettings'>;
+    /**
+     * Defines the responseWithErrors, a property that indicates whether the error stack should be included in the response or not
+     *
+     * @param respondWithErrors - Should include or not the errors in response
+     */
+    setRespondWithErrors(respondWithErrors: boolean): Omit<this, 'setRespondWithErrors'>;
+    /**
+     * Add an adapter to the adapters list to handle the event coming from any serverless event source
+     *
+     * @param adapter - The implementation of the adapter contract
+     */
+    addAdapter(adapter: AdapterContract<TEvent, TContext, TResponse>): Pick<this, 'addAdapter' | 'build'>;
+    /**
+     * The builder method that returns the handler function to be exported for serverless consumption
+     */
+    build(): ServerlessHandler<TReturn>;
+}
+
+export { AdapterContract, BinarySettings, BothValueHeaders, type CurrentInvoke, type FlattenedHeadersAndCookies, FrameworkContract, HandlerContract, ILogger, NO_OP, ResolverContract, ServerlessAdapter, ServerlessHandler, ServerlessStreamResponse, type ServerlessStreamResponseProps, getContentType, getCurrentInvoke, getDefaultIfUndefined, getEventBodyAsBuffer, getFlattenedHeadersMap, getFlattenedHeadersMapAndCookies, getMultiValueHeadersMap, getString, isBinary, isContentEncodingBinary, isContentTypeBinary, isStreamEnded, parseHeaders, setCurrentInvoke, waitForStreamComplete };

package/lib/index.mjs

@@ -0,0 +1,2 @@
+import"./chunk-22SSVZU5.mjs";import{A as D,B as _,a,b as r,c as o,d as p,e as l,f as T,g as h,h as E,i as d,j as c,k as R,l as u,m as S,n as m,o as A,p as w,q as s,r as b,s as C,t as f,u as g,v,w as k,x,y,z as L}from"./chunk-PQDB5AVF.mjs";import{a as t}from"./chunk-OYOJMOFP.mjs";var n=class i{static{t(this,"ServerlessAdapter")}constructor(e){this.app=e}app;binarySettings={contentEncodings:r,contentTypes:o};respondWithErrors=process.env.NODE_ENV==="development";log=s();adapters=[];framework;resolver;handler;static new(e){return new i(e)}setHandler(e){if(this.handler)throw new Error("SERVERLESS_ADAPTER: The handler should not set twice.");return this.handler=e,this}setResolver(e){if(this.resolver)throw new Error("SERVERLESS_ADAPTER: The resolver should not set twice.");return this.resolver=e,this}setFramework(e){if(this.framework)throw new Error("SERVERLESS_ADAPTER: The framework should not set twice.");return this.framework=e,this}setLogger(e){return this.log=e,this}setBinarySettings(e){return this.binarySettings={...this.binarySettings,...e},this}setRespondWithErrors(e){return this.respondWithErrors=e,this}addAdapter(e){return this.adapters.push(e),this}build(){if(!this.resolver)throw new Error("SERVERLESS_ADAPTER: Is required to set a resolver before build.");if(!this.framework)throw new Error("SERVERLESS_ADAPTER: Is required to set a framework before build.");if(!this.handler)throw new Error("SERVERLESS_ADAPTER: Is required to set a handler before build.");if(this.adapters.length===0)throw new Error("SERVERLESS_ADAPTER: Is required to set at least one adapter.");return this.handler.getHandler(this.app,this.framework,this.adapters,this.resolver,this.binarySettings,this.respondWithErrors,this.log)}};export{a as BaseHandler,o as DEFAULT_BINARY_CONTENT_TYPES,r as DEFAULT_BINARY_ENCODINGS,p as EmptyResponse,w as NO_OP,n as ServerlessAdapter,y as ServerlessRequest,D as ServerlessResponse,_ as ServerlessStreamResponse,v as buildStripBasePath,s as createDefaultLogger,S as getContentType,l as getCurrentInvoke,C as getDefaultIfUndefined,h as getEventBodyAsBuffer,E as getFlattenedHeadersMap,c as getFlattenedHeadersMapAndCookies,d as getMultiValueHeadersMap,f as getPathWithQueryStringParams,g as getQueryParamsStringFromRecord,L as getString,A as isBinary,u as isContentEncodingBinary,m as isContentTypeBinary,b as isInternalLogger,k as isStreamEnded,R as parseHeaders,T as setCurrentInvoke,x as waitForStreamComplete};
+//# sourceMappingURL=index.mjs.map

package/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/serverless-adapter.ts"],"sourcesContent":["//#region Imports\n\nimport type { BinarySettings } from './@types';\nimport type {\n  AdapterContract,\n  FrameworkContract,\n  HandlerContract,\n  ResolverContract,\n  ServerlessHandler,\n} from './contracts';\nimport {\n  DEFAULT_BINARY_CONTENT_TYPES,\n  DEFAULT_BINARY_ENCODINGS,\n  type ILogger,\n  createDefaultLogger,\n} from './core';\n\n//#endregion\n\n/**\n * The class used to build the serverless handler.\n *\n * @example\n * ```typescript\n * const app = express();\n * export const handler = ServerlessAdapter.new(app)\n *   .setFramework(new ExpressFramework())\n *   .setHandler(new DefaultHandler())\n *   .setResolver(new PromiseResolver())\n *   .setRespondWithErrors(true)\n *   .addAdapter(new AlbAdapter())\n *   .addAdapter(new SQSAdapter())\n *   .addAdapter(new SNSAdapter())\n *   .build();\n * ```\n *\n * @breadcrumb ServerlessAdapter\n * @public\n */\nexport class ServerlessAdapter<\n  TApp,\n  TEvent,\n  TContext,\n  TCallback,\n  TResponse,\n  TReturn,\n> {\n  //#region Constructor\n\n  /**\n   * Default constructor\n   */\n  private constructor(app: TApp) {\n    this.app = app;\n  }\n\n  //#endregion\n\n  //#region Protected Properties\n\n  /**\n   * The instance of the app (express, hapi, koa, etc...)\n   */\n  protected app: TApp;\n\n  //#endregion\n\n  //#region Protected Properties\n\n  /**\n   * Settings for whether the response should be treated as binary or not\n   *\n   * @defaultValue `contentEncodings` and `contentTypes` are set with {@link DEFAULT_BINARY_ENCODINGS} and {@link DEFAULT_BINARY_CONTENT_TYPES}, respectively.\n   */\n  protected binarySettings: BinarySettings = {\n    contentEncodings: DEFAULT_BINARY_ENCODINGS,\n    contentTypes: DEFAULT_BINARY_CONTENT_TYPES,\n  };\n\n  /**\n   * Indicates whether the error stack should be included in the response or not\n   *\n   * @remarks These errors will only be included when an error occurs while forwarding the event to the framework\n   * @defaultValue True when NODE_ENV is equal to `development`\n   */\n  protected respondWithErrors: boolean = process.env.NODE_ENV === 'development';\n\n  /**\n   * The instance of the logger service\n   */\n  protected log: ILogger = createDefaultLogger();\n\n  /**\n   * The list of adapters used to handle an event's request and response\n   */\n  protected adapters: AdapterContract<TEvent, TContext, TResponse>[] = [];\n\n  /**\n   * The framework that will process requests\n   */\n  protected framework?: FrameworkContract<TApp>;\n\n  /**\n   * The resolver that aims to resolve the response to serverless and stop its execution when the request ends\n   */\n  protected resolver?: ResolverContract<\n    TEvent,\n    TContext,\n    TCallback,\n    TResponse,\n    TReturn\n  >;\n\n  /**\n   * The handler that will get the event, context and callback and pass it to the adapter and framework\n   */\n  protected handler?: HandlerContract<\n    TApp,\n    TEvent,\n    TContext,\n    TCallback,\n    TResponse,\n    TReturn\n  >;\n\n  //#endregion\n\n  //#region Static Methods\n\n  /**\n   * Creates a new instance of the builder with app (express, hapi, koa, etc...)\n   *\n   * @param app - The instance of the app\n   */\n  public static new<\n    TApp,\n    TEvent,\n    TContext = any,\n    TCallback = any,\n    TResponse = any,\n    TReturn = any,\n  >(\n    app: TApp,\n  ): ServerlessAdapter<TApp, TEvent, TContext, TCallback, TResponse, TReturn> {\n    return new ServerlessAdapter(app);\n  }\n\n  //#endregion\n\n  //#region Builder Methods\n\n  /**\n   * Defines the handler that will get the event, context and callback and pass it to the adapter and framework\n   *\n   * @param handler - The implementation of the handler contract\n   */\n  public setHandler(\n    handler: HandlerContract<\n      TApp,\n      TEvent,\n      TContext,\n      TCallback,\n      TResponse,\n      TReturn\n    >,\n  ): Omit<this, 'setHandler'> {\n    if (this.handler)\n      throw new Error('SERVERLESS_ADAPTER: The handler should not set twice.');\n\n    this.handler = handler;\n\n    return this;\n  }\n\n  /**\n   * Defines the resolver that aims to resolve the response to serverless and stop its execution when the request ends\n   *\n   * @param resolver - The implementation of the resolver contract\n   */\n  public setResolver(\n    resolver: ResolverContract<TEvent, TContext, TCallback, TResponse, TReturn>,\n  ): Omit<this, 'setResolver'> {\n    if (this.resolver)\n      throw new Error('SERVERLESS_ADAPTER: The resolver should not set twice.');\n\n    this.resolver = resolver;\n\n    return this;\n  }\n\n  /**\n   * Defines the framework that will process requests\n   *\n   * @param framework - The implementation of the framework contract\n   */\n  public setFramework(\n    framework: FrameworkContract<TApp>,\n  ): Omit<this, 'setFramework'> {\n    if (this.framework) {\n      throw new Error(\n        'SERVERLESS_ADAPTER: The framework should not set twice.',\n      );\n    }\n\n    this.framework = framework;\n\n    return this;\n  }\n\n  /**\n   * Defines the logger service used during the execution of the handler\n   *\n   * @param logger - The implementation of the logger\n   */\n  public setLogger(logger: ILogger): Omit<this, 'setLogger'> {\n    this.log = logger;\n\n    return this;\n  }\n\n  /**\n   * Defines the binary settings for whether the response should be treated as binary or not\n   *\n   * @param binarySettings - The binary settings\n   */\n  public setBinarySettings(\n    binarySettings: BinarySettings,\n  ): Omit<this, 'setBinarySettings'> {\n    this.binarySettings = {\n      ...this.binarySettings,\n      ...binarySettings,\n    };\n\n    return this;\n  }\n\n  /**\n   * Defines the responseWithErrors, a property that indicates whether the error stack should be included in the response or not\n   *\n   * @param respondWithErrors - Should include or not the errors in response\n   */\n  public setRespondWithErrors(\n    respondWithErrors: boolean,\n  ): Omit<this, 'setRespondWithErrors'> {\n    this.respondWithErrors = respondWithErrors;\n\n    return this;\n  }\n\n  /**\n   * Add an adapter to the adapters list to handle the event coming from any serverless event source\n   *\n   * @param adapter - The implementation of the adapter contract\n   */\n  public addAdapter(\n    adapter: AdapterContract<TEvent, TContext, TResponse>,\n  ): Pick<this, 'addAdapter' | 'build'> {\n    this.adapters.push(adapter);\n\n    return this;\n  }\n\n  /**\n   * The builder method that returns the handler function to be exported for serverless consumption\n   */\n  public build(): ServerlessHandler<TReturn> {\n    if (!this.resolver) {\n      throw new Error(\n        'SERVERLESS_ADAPTER: Is required to set a resolver before build.',\n      );\n    }\n\n    if (!this.framework) {\n      throw new Error(\n        'SERVERLESS_ADAPTER: Is required to set a framework before build.',\n      );\n    }\n\n    if (!this.handler) {\n      throw new Error(\n        'SERVERLESS_ADAPTER: Is required to set a handler before build.',\n      );\n    }\n\n    if (this.adapters.length === 0) {\n      throw new Error(\n        'SERVERLESS_ADAPTER: Is required to set at least one adapter.',\n      );\n    }\n\n    return this.handler.getHandler(\n      this.app,\n      this.framework,\n      this.adapters,\n      this.resolver,\n      this.binarySettings,\n      this.respondWithErrors,\n      this.log,\n    );\n  }\n\n  //#endregion\n}\n"],"mappings":"wRAuCO,IAAMA,EAAN,MAAMC,CAOX,CA9CF,MA8CE,CAAAC,EAAA,0BAMQ,YAAYC,EAAW,CAC7B,KAAK,IAAMA,CACb,CASU,IAWA,eAAiC,CACzC,iBAAkBC,EAClB,aAAcC,CAChB,EAQU,kBAA6B,QAAQ,IAAI,WAAa,cAKtD,IAAeC,EAAoB,EAKnC,SAA2D,CAAC,EAK5D,UAKA,SAWA,QAkBV,OAAc,IAQZH,EAC0E,CAC1E,OAAO,IAAIF,EAAkBE,CAAG,CAClC,CAWO,WACLI,EAQ0B,CAC1B,GAAI,KAAK,QACP,MAAM,IAAI,MAAM,uDAAuD,EAEzE,YAAK,QAAUA,EAER,IACT,CAOO,YACLC,EAC2B,CAC3B,GAAI,KAAK,SACP,MAAM,IAAI,MAAM,wDAAwD,EAE1E,YAAK,SAAWA,EAET,IACT,CAOO,aACLC,EAC4B,CAC5B,GAAI,KAAK,UACP,MAAM,IAAI,MACR,yDACF,EAGF,YAAK,UAAYA,EAEV,IACT,CAOO,UAAUC,EAA0C,CACzD,YAAK,IAAMA,EAEJ,IACT,CAOO,kBACLC,EACiC,CACjC,YAAK,eAAiB,CACpB,GAAG,KAAK,eACR,GAAGA,CACL,EAEO,IACT,CAOO,qBACLC,EACoC,CACpC,YAAK,kBAAoBA,EAElB,IACT,CAOO,WACLC,EACoC,CACpC,YAAK,SAAS,KAAKA,CAAO,EAEnB,IACT,CAKO,OAAoC,CACzC,GAAI,CAAC,KAAK,SACR,MAAM,IAAI,MACR,iEACF,EAGF,GAAI,CAAC,KAAK,UACR,MAAM,IAAI,MACR,kEACF,EAGF,GAAI,CAAC,KAAK,QACR,MAAM,IAAI,MACR,gEACF,EAGF,GAAI,KAAK,SAAS,SAAW,EAC3B,MAAM,IAAI,MACR,8DACF,EAGF,OAAO,KAAK,QAAQ,WAClB,KAAK,IACL,KAAK,UACL,KAAK,SACL,KAAK,SACL,KAAK,eACL,KAAK,kBACL,KAAK,GACP,CACF,CAGF","names":["ServerlessAdapter","_ServerlessAdapter","__name","app","DEFAULT_BINARY_ENCODINGS","DEFAULT_BINARY_CONTENT_TYPES","createDefaultLogger","handler","resolver","framework","logger","binarySettings","respondWithErrors","adapter"]}

package/lib/logger-9me5n48P.d.cts

@@ -0,0 +1,65 @@
+/**
+ * The type representing the possible log levels to choose from.
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type LogLevels = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'none';
+/**
+ * The options to customize {@link ILogger}
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type LoggerOptions = {
+    /**
+     * Select the log level, {@link LogLevels | see more}.
+     *
+     * @defaultValue error
+     */
+    level: LogLevels;
+};
+/**
+ * The log function used in any level.
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type LoggerFN = (message: any, ...additional: any[]) => void;
+/**
+ * The interface representing the logger, you can provide a custom logger by implementing this interface.
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type ILogger = Record<Exclude<LogLevels, 'none'>, LoggerFN>;
+/**
+ * The method used to create a simple logger instance to use in this library.
+ *
+ * @remarks Behind the scenes, this simple logger sends the message to the `console` methods.
+ *
+ * @example
+ * ```typescript
+ * const logger = createDefaultLogger();
+ *
+ * logger.error('An error happens.');
+ * // An error happens.
+ * ```
+ *
+ * @param level - Select the level of the log
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+declare function createDefaultLogger({ level }?: LoggerOptions): ILogger;
+/**
+ * The method used to chck if logger was created by this library, or it was defined by the user.
+ *
+ * @param logger - The instance of the logger to check
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+declare function isInternalLogger(logger: ILogger): boolean;
+
+export { type ILogger as I, type LogLevels as L, type LoggerOptions as a, type LoggerFN as b, createDefaultLogger as c, isInternalLogger as i };

package/lib/logger-9me5n48P.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The type representing the possible log levels to choose from.
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type LogLevels = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'none';
+/**
+ * The options to customize {@link ILogger}
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type LoggerOptions = {
+    /**
+     * Select the log level, {@link LogLevels | see more}.
+     *
+     * @defaultValue error
+     */
+    level: LogLevels;
+};
+/**
+ * The log function used in any level.
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type LoggerFN = (message: any, ...additional: any[]) => void;
+/**
+ * The interface representing the logger, you can provide a custom logger by implementing this interface.
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+type ILogger = Record<Exclude<LogLevels, 'none'>, LoggerFN>;
+/**
+ * The method used to create a simple logger instance to use in this library.
+ *
+ * @remarks Behind the scenes, this simple logger sends the message to the `console` methods.
+ *
+ * @example
+ * ```typescript
+ * const logger = createDefaultLogger();
+ *
+ * logger.error('An error happens.');
+ * // An error happens.
+ * ```
+ *
+ * @param level - Select the level of the log
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+declare function createDefaultLogger({ level }?: LoggerOptions): ILogger;
+/**
+ * The method used to chck if logger was created by this library, or it was defined by the user.
+ *
+ * @param logger - The instance of the logger to check
+ *
+ * @breadcrumb Core / Logger
+ * @public
+ */
+declare function isInternalLogger(logger: ILogger): boolean;
+
+export { type ILogger as I, type LogLevels as L, type LoggerOptions as a, type LoggerFN as b, createDefaultLogger as c, isInternalLogger as i };

package/lib/path-yBwCb8C1.d.cts

@@ -0,0 +1,64 @@
+/**
+ * Removes 'optional' attributes from a type's properties
+ *
+ * @breadcrumb Types
+ * @public
+ */
+type Concrete<Type> = {
+    [Property in keyof Type]-?: Type[Property];
+};
+
+/**
+ * Transform the path and a map of query params to a string with formatted query params
+ *
+ * @example
+ * ```typescript
+ * const path = '/pets/search';
+ * const queryParams = { batata: undefined, petType: [ 'dog', 'fish' ] };
+ * const result = getPathWithQueryStringParams(path, queryParams);
+ * console.log(result);
+ * // /pets/search?batata=&petType=dog&petType=fish
+ * ```
+ *
+ * @param path - The path
+ * @param queryParams - The query params
+ *
+ * @breadcrumb Core / Path
+ * @public
+ */
+declare function getPathWithQueryStringParams(path: string, queryParams: string | Record<string, string | string[] | undefined> | undefined | null): string;
+/**
+ * Map query params to a string with formatted query params
+ *
+ * @example
+ * ```typescript
+ * const queryParams = { batata: undefined, petType: [ 'dog', 'fish' ] };
+ * const result = getQueryParamsStringFromRecord(queryParams);
+ * console.log(result);
+ * // batata=&petType=dog&petType=fish
+ * ```
+ *
+ * @param queryParamsRecord - The query params record
+ *
+ * @breadcrumb Core / Path
+ * @public
+ */
+declare function getQueryParamsStringFromRecord(queryParamsRecord: Record<string, string | string[] | undefined> | undefined | null): string;
+/**
+ * Type of the function to strip base path
+ *
+ * @breadcrumb Core / Path
+ * @public
+ */
+type StripBasePathFn = (path: string) => string;
+/**
+ * Get the strip base path function
+ *
+ * @param basePath - The base path
+ *
+ * @breadcrumb Core / Path
+ * @public
+ */
+declare function buildStripBasePath(basePath: string | undefined): StripBasePathFn;
+
+export { type Concrete as C, type StripBasePathFn as S, getQueryParamsStringFromRecord as a, buildStripBasePath as b, getPathWithQueryStringParams as g };