@yopdev/dev-server 2.0.0-alpha.1 → 2.0.0-beta.1

package/dist/src/cloudformation-lambda-http-proxy.d.ts

@@ -1,16 +1,16 @@
-/// <reference types="node" />
 import { CloudFormationSetupConfig } from './cloudformation';
 import { DevServerConfig } from './config';
 import { HttpSettings } from './http-server';
-import { APIGatewayEventRequestContextV2WithGenericAuthorizer, Route } from './lambda-http-proxy';
+import { Authorizer, Route } from './lambda-http-proxy';
 import { Callback, Service, Startable } from './services';
-import { IncomingMessage } from 'http';
-export declare const newLambdaProxyFromCloudFormationTemplate: <C, A>(name: string, settings: HttpSettings, config: CloudFormationLambdaProxyConfig<C, A>, callback: Callback<string>) => Startable<Service<string>>;
-type CloudFormationLambdaProxyConfig<C, A> = {
-    authorizer?: (config: DevServerConfig) => A | undefined;
-    extraRoutes: Route<C, A>[];
+import { LambdaMapperFactory, PathParameterResolver } from './mappers';
+export declare const newLambdaProxyFromCloudFormationTemplate: <Context, AuthorizerContext, Event_1, HandlerResponse>(name: string, settings: HttpSettings, config: CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event_1, HandlerResponse>, callback: Callback<string>) => Startable<Service<string>>;
+type CloudFormationLambdaProxyConfig<Context, AuthorizerContext, Event, HandlerResponse> = {
+    authorizer?: (config: DevServerConfig) => Authorizer<AuthorizerContext> | undefined;
+    extraRoutes: Route<Context, AuthorizerContext, Event, HandlerResponse>[];
+    pathParameterResolver: PathParameterResolver<Event>;
     prepare?: (config: DevServerConfig) => Promise<void>;
-    context?: () => C;
-    mapper?: (request: IncomingMessage, body: string) => Promise<APIGatewayEventRequestContextV2WithGenericAuthorizer<A>>;
+    context?: () => Context;
+    mapper?: LambdaMapperFactory<AuthorizerContext, Event, HandlerResponse>;
 } & CloudFormationSetupConfig;
 export {};

package/dist/src/cloudformation-lambda-http-proxy.js

@@ -31,13 +31,14 @@ class CloudFormationLambdaProxy extends cloudformation_1.CloudFormationSetup {
         this.pathWithCapturingGroups = (source) => [...source.matchAll(PATH_VARIABLE_CAPTURE)].reduce((prev, curr) => prev.replaceAll(curr[0], `(?<${this.normalizeCaptureGroupName(curr[1])}>.*)`), source);
         this.normalizeCaptureGroupName = (original) => (original === 'proxy+' ? PROXY_PATH_PARAM : original);
         this.pathParameterCapture = (pathWithCapturingGroups, handler, context) => async (event) => {
-            const pathParameters = pathWithCapturingGroups.exec(event.rawPath)?.groups;
-            event.pathParameters = Object.fromEntries((Object.entries(pathParameters ?? {}))
-                .map(([k, v]) => [k, decodeURIComponent(v)]));
+            const pathParameters = pathWithCapturingGroups.exec(this.pathParameterResolver.locate(event))?.groups;
+            this.pathParameterResolver.store(event, Object.fromEntries((Object.entries(pathParameters ?? {}))
+                .map(([k, v]) => [k, decodeURIComponent(v)])));
             return handler(event, context?.());
         };
         this.mapper = config?.mapper;
         this.authorizer = config?.authorizer;
+        this.pathParameterResolver = config?.pathParameterResolver;
     }
     logHandler(handler) {
         return `detected handler for ${handler.method} on ${handler.path} with weight ${handler.weight}`;

package/dist/src/container.js

@@ -18,7 +18,7 @@ class Container {
             .then((started) => this.started = started)
             .then(() => this.endpointBuilder(this.started.getFirstMappedPort()))
             .tap((url) => this.LOGGER.debug(url));
-        this.stop = async () => this.started.stop().then(() => undefined);
+        this.stop = async () => (this.started ?? { stop: async () => { this.LOGGER.warn('no container'); } }).stop().then(() => undefined);
         this.LOGGER = logging_1.LoggerFactory.create(`CONTAINER[${name}]`);
         const generic = new testcontainers_1.GenericContainer(image);
         const withEnvironment = environment ? generic.withEnvironment(environment) : generic;

package/dist/src/deferred.js

@@ -32,13 +32,14 @@ class Lazy {
 }
 class Promised {
     constructor(configurable) {
-        this.configurable = configurable;
-        this.start = async (config) => this.configurable(config)
-            .then((service) => this.service = service)
-            .then((service) => this.LOGGER.info('DISCOVERY:%s', service.name))
-            .then(() => this.service.start(config));
-        this.stop = async () => this.service.stop();
         this.name = (0, crypto_1.randomUUID)();
         this.LOGGER = logging_1.LoggerFactory.create(`PROMISED[${this.name}]`);
+        let initialized;
+        this.start = async (config) => configurable(config)
+            .catch((e) => e?.cleanup?.() ?? Promise.reject(e))
+            .then((service) => initialized = service)
+            .tap((service) => this.LOGGER.info('DISCOVERY:%s', service.name))
+            .then((service) => service.start(config));
+        this.stop = async () => (initialized ?? { stop: async () => this.LOGGER.info('not started') }).stop();
     }
 }

package/dist/src/dev-server.d.ts

@@ -10,4 +10,5 @@ export declare class DevServer implements Lifecycle<DevServer> {
     constructor(name: string, service: Service<any>, config?: Config);
     start: () => Promise<this>;
     stop: () => Promise<void>;
+    private shutdown;
 }

package/dist/src/dev-server.js

@@ -42,12 +42,16 @@ class DevServer {
         }))))
             .tap((config) => this.LOGGER.debug('config is %o', config))
             .then((aws) => this.service.start(aws))
+            .catch((e) => this.shutdown()
+            .then(() => this.LOGGER.error('error starting service'))
+            .then(() => Promise.reject(e)))
             .then(() => this.LOGGER.info('started'))
             .then(() => this);
-        this.stop = () => this.service.stop()
-            .then(tunnel_1.terminate)
-            .then(() => this.localStack?.stop())
+        this.stop = () => this.shutdown()
             .then(() => this.LOGGER.info('stopped'));
+        this.shutdown = async () => this.service.stop()
+            .then(tunnel_1.terminate)
+            .then(() => this.localStack?.stop());
         this.LOGGER = logging_1.LoggerFactory.create(`DEVSERVER[${name}]`);
         const encodedName = Buffer.from(name).toString('hex').substring(0, 64);
         this.eventProxyTopic = `EventProxyTopic${encodedName}`;

package/dist/src/index.d.ts

@@ -1,6 +1,7 @@
 export { DevServer } from './dev-server';
 export { newHttpServer as httpServer, HttpSettings } from './http-server';
 export { newLambdaHttpProxy as lambdaHttpProxy, UNAUTHORIZED } from './lambda-http-proxy';
+export { v1 as v1LambdaProxyPayload, v2 as v2LambdaProxyPayload } from './mappers';
 export { newLambdaProxyFromCloudFormationTemplate as cloudFormationLambdaProxy } from './cloudformation-lambda-http-proxy';
 export { newSnsHttpProxy as snsHttpProxy } from './sns-http-proxy';
 export { newInternalQueue as internalQueue } from './internal-queue';

package/dist/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Service = exports.promised = exports.lazy = exports.oneThenOther = exports.allOf = exports.tunnel = exports.container = exports.dynamoDbTable = exports.preTrafficHooks = exports.scheduledTasks = exports.cloudFormationSnsEventHandlers = exports.eventsProxy = exports.internalQueue = exports.snsHttpProxy = exports.cloudFormationLambdaProxy = exports.UNAUTHORIZED = exports.lambdaHttpProxy = exports.httpServer = exports.DevServer = void 0;
+exports.Service = exports.promised = exports.lazy = exports.oneThenOther = exports.allOf = exports.tunnel = exports.container = exports.dynamoDbTable = exports.preTrafficHooks = exports.scheduledTasks = exports.cloudFormationSnsEventHandlers = exports.eventsProxy = exports.internalQueue = exports.snsHttpProxy = exports.cloudFormationLambdaProxy = exports.v2LambdaProxyPayload = exports.v1LambdaProxyPayload = exports.UNAUTHORIZED = exports.lambdaHttpProxy = exports.httpServer = exports.DevServer = void 0;
 var dev_server_1 = require("./dev-server");
 Object.defineProperty(exports, "DevServer", { enumerable: true, get: function () { return dev_server_1.DevServer; } });
 var http_server_1 = require("./http-server");
@@ -8,6 +8,9 @@ Object.defineProperty(exports, "httpServer", { enumerable: true, get: function (
 var lambda_http_proxy_1 = require("./lambda-http-proxy");
 Object.defineProperty(exports, "lambdaHttpProxy", { enumerable: true, get: function () { return lambda_http_proxy_1.newLambdaHttpProxy; } });
 Object.defineProperty(exports, "UNAUTHORIZED", { enumerable: true, get: function () { return lambda_http_proxy_1.UNAUTHORIZED; } });
+var mappers_1 = require("./mappers");
+Object.defineProperty(exports, "v1LambdaProxyPayload", { enumerable: true, get: function () { return mappers_1.v1; } });
+Object.defineProperty(exports, "v2LambdaProxyPayload", { enumerable: true, get: function () { return mappers_1.v2; } });
 var cloudformation_lambda_http_proxy_1 = require("./cloudformation-lambda-http-proxy");
 Object.defineProperty(exports, "cloudFormationLambdaProxy", { enumerable: true, get: function () { return cloudformation_lambda_http_proxy_1.newLambdaProxyFromCloudFormationTemplate; } });
 var sns_http_proxy_1 = require("./sns-http-proxy");

package/dist/src/internal-queue.js

@@ -20,12 +20,13 @@ class InternalQueue {
             .then((queue) => this
             .createConsumer(sqs.client, this.name, queue.url, this.handler(queue), this.visibility)
             .then(() => queue.url));
-        this.createConsumer = async (sqs, name, url, handler, visibility) => Promise.resolve(sqs_consumer_1.Consumer.create({
+        this.createConsumer = async (sqs, name, url, handler, visibility) => Promise.resolve(() => this.consumer = sqs_consumer_1.Consumer.create({
             queueUrl: url,
             waitTimeSeconds: visibility,
             sqs: sqs,
             handleMessage: async (message) => handler({ Records: [this.mapper(message)] }),
         }))
+            .then((factory) => factory())
             .then((consumer) => {
             consumer.on('error', (err) => {
                 this.LOGGER.error(err, 'failed to handle message');
@@ -33,16 +34,13 @@ class InternalQueue {
             consumer.on('processing_error', (err) => {
                 this.LOGGER.error(err, 'failed to process message');
             });
-            consumer.start();
             this.LOGGER.info('consumer for %s initialized', name);
-            this.state = {
-                consumer: consumer,
-                visibility: visibility,
-            };
+            return consumer;
         })
+            .then(async (consumer) => consumer.start())
             .then(() => this.LOGGER.info('started'))
             .then(() => this);
-        this.stop = () => (0, stoppable_1.stopConsumer)(this.state.visibility, this.state.consumer);
+        this.stop = async () => this.consumer !== undefined ? (0, stoppable_1.stopConsumer)(this.visibility, this.consumer) : this.LOGGER.warn('no consumer');
         this.LOGGER = logging_1.LoggerFactory.create(`INTERNALQUEUE[${name}]`);
     }
     async createQueue(sqs, name) {

package/dist/src/lambda-http-proxy.d.ts

@@ -1,21 +1,27 @@
+/// <reference types="node" />
 import { HttpSettings } from "./http-server";
-import { APIGatewayEventRequestContextV2WithAuthorizer, APIGatewayProxyEventV2WithRequestContext, APIGatewayProxyStructuredResultV2 } from "aws-lambda";
-import { IncomingMessage } from "http";
+import { LambdaMapperFactory } from "./mappers";
 import { Service, Callback } from "./services";
 export declare const UNAUTHORIZED: Error;
-export declare const newLambdaHttpProxy: <C, A>(name: string, config: {
+export declare const newLambdaHttpProxy: <Context, AuthorizerContext, Event_1, HandlerResponse>(name: string, config: {
     settings: HttpSettings;
-    routes: Route<C, A>[];
-    mapper?: (request: IncomingMessage, body: string) => Promise<APIGatewayEventRequestContextV2WithGenericAuthorizer<A>>;
-    authorizer?: Authorizer<A>;
-    context?: () => C;
+    routes: Route<Context, AuthorizerContext, Event_1, HandlerResponse>[];
+    mapper: LambdaMapperFactory<AuthorizerContext, Event_1, HandlerResponse>;
+    authorizer?: Authorizer<AuthorizerContext>;
+    context?: () => Context;
 }, callback?: Callback<string>) => Service<string>;
-export type APIGatewayEventRequestContextV2WithGenericAuthorizer<A> = APIGatewayProxyEventV2WithRequestContext<APIGatewayEventRequestContextV2WithAuthorizer<A>>;
-export type Route<C, A> = {
+export declare abstract class Response {
+    readonly statusCode: number;
+    readonly contentType: string | undefined;
+    readonly location: string | undefined;
+    constructor(statusCode: number, contentType: string | undefined, location: string | undefined);
+    body: () => string | Buffer | undefined;
+}
+export type Route<Context, AuthorizerContext, Event, HandlerResponse> = {
     method: RegExp;
     path: RegExp;
     weight: number;
-    authorizer?: Authorizer<A>;
-    handler: (event: APIGatewayEventRequestContextV2WithGenericAuthorizer<A>, context: C) => Promise<APIGatewayProxyStructuredResultV2>;
+    authorizer?: Authorizer<AuthorizerContext>;
+    handler: (event: Event, context: Context) => Promise<HandlerResponse>;
 };
-export type Authorizer<A> = (authorization: string) => Promise<A | undefined>;
+export type Authorizer<Context> = (authorization: string) => Promise<Context | undefined>;

package/dist/src/lambda-http-proxy.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newLambdaHttpProxy = exports.UNAUTHORIZED = void 0;
+exports.Response = exports.newLambdaHttpProxy = exports.UNAUTHORIZED = void 0;
 const logging_1 = require("@yopdev/logging");
 const http_server_1 = require("./http-server");
-const mappers_1 = require("./mappers");
 const responses_1 = require("./responses");
 const services_1 = require("./services");
 exports.UNAUTHORIZED = new Error('UNAUTHORIZED');
-const newLambdaHttpProxy = (name, config, callback) => new services_1.Service(new LambdaHttpProxy(name, config.settings, config.routes, config.mapper ?? mappers_1.mapToLambdaEvent, config.authorizer ?? (() => Promise.resolve(undefined)), config.context), callback);
+const newLambdaHttpProxy = (name, config, callback) => new services_1.Service(new LambdaHttpProxy(name, config.settings, config.routes, config.mapper, config.authorizer ?? (() => Promise.resolve(undefined)), config.context), callback);
 exports.newLambdaHttpProxy = newLambdaHttpProxy;
 class LambdaHttpProxy {
     constructor(name, settings, routes, mapper, defaultAuthorizer, context = () => undefined) {
@@ -18,12 +17,14 @@ class LambdaHttpProxy {
         this.context = context;
         this.start = () => this.server.start();
         this.stop = () => this.server.stop();
-        this.handler = (authorizer, lambdaHandler) => (request, body, response) => this.mapper(request, body)
-            .then(async (proxyEvent) => authorizer(proxyEvent.headers['authorization'])
+        this.handler = (authorizer, lambdaHandler) => (request, body, response) => this.mapper.newInstance(request, body)
+            .then(async (mapper) => authorizer(mapper.authorization())
             .then(async (context) => {
-            proxyEvent.requestContext.authorizer = context;
-            return lambdaHandler(proxyEvent, this.context())
-                .then((lambda) => (0, responses_1.writeResponse)(response, lambda.statusCode, lambda.isBase64Encoded ? Buffer.from(lambda.body, 'base64') : lambda.body, lambda.headers?.['content-type']?.toString() ?? undefined, lambda.headers?.['location']?.toString() ?? undefined))
+            return lambdaHandler(mapper.event(context), this.context())
+                .then((lambda) => {
+                const result = mapper.toResponse(lambda);
+                return (0, responses_1.writeResponse)(response, result.statusCode, result.body(), result.contentType, result.location);
+            })
                 .catch((e) => {
                 this.LOGGER.error(e, 'request failed to execute');
                 (0, responses_1.internalServerError)(response, e.body);
@@ -40,3 +41,11 @@ class LambdaHttpProxy {
         this.LOGGER.info('registered %i routes', routes.length);
     }
 }
+class Response {
+    constructor(statusCode, contentType, location) {
+        this.statusCode = statusCode;
+        this.contentType = contentType;
+        this.location = location;
+    }
+}
+exports.Response = Response;

package/dist/src/mappers.d.ts

@@ -1,7 +1,28 @@
 /// <reference types="node" />
 import { Message } from "@aws-sdk/client-sqs";
-import { SQSRecord } from "aws-lambda";
+import { APIGatewayEventRequestContextV2WithAuthorizer, APIGatewayProxyEvent, APIGatewayProxyEventPathParameters, APIGatewayProxyEventV2, APIGatewayProxyEventV2WithRequestContext, APIGatewayProxyResult, APIGatewayProxyStructuredResultV2, SQSRecord } from "aws-lambda";
 import { IncomingMessage } from "http";
-import { APIGatewayEventRequestContextV2WithGenericAuthorizer } from "./lambda-http-proxy";
+import { Response } from "./lambda-http-proxy";
 export declare const mapToLambdaSqsRecord: (message: Message) => SQSRecord;
-export declare function mapToLambdaEvent<A>(req: IncomingMessage, requestBody: string): Promise<APIGatewayEventRequestContextV2WithGenericAuthorizer<A>>;
+export declare const v1: {
+    mapper: LambdaMapperFactory<unknown, APIGatewayProxyEvent, APIGatewayProxyResult>;
+    resolver: PathParameterResolver<APIGatewayProxyEvent>;
+};
+export declare const v2: {
+    mapper: LambdaMapperFactory<unknown, APIGatewayEventRequestContextV2WithGenericAuthorizer<unknown>, APIGatewayProxyStructuredResultV2>;
+    resolver: PathParameterResolver<APIGatewayProxyEventV2>;
+};
+interface LambdaMapper<AuthorizerContext, Event, HandlerResponse> {
+    event(context: AuthorizerContext): Event;
+    authorization(): string;
+    toResponse: (response: HandlerResponse) => Response;
+}
+export interface LambdaMapperFactory<AuthorizerContext, Event, LambdaResponse> {
+    newInstance(request: IncomingMessage, body: string): Promise<LambdaMapper<AuthorizerContext, Event, LambdaResponse>>;
+}
+type APIGatewayEventRequestContextV2WithGenericAuthorizer<AuthorizerContext> = APIGatewayProxyEventV2WithRequestContext<APIGatewayEventRequestContextV2WithAuthorizer<AuthorizerContext>>;
+export type PathParameterResolver<Event> = {
+    locate: (event: Event) => string;
+    store: (event: Event, params: APIGatewayProxyEventPathParameters) => void;
+};
+export {};

package/dist/src/mappers.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToLambdaEvent = exports.mapToLambdaSqsRecord = void 0;
+exports.v2 = exports.v1 = exports.mapToLambdaSqsRecord = void 0;
 const url_1 = require("url");
+const lambda_http_proxy_1 = require("./lambda-http-proxy");
 const mapToLambdaSqsRecord = (message) => {
     if (!message.Body)
         throw new Error('message Body must be present');
@@ -23,84 +24,127 @@ const mapToLambdaSqsRecord = (message) => {
     };
 };
 exports.mapToLambdaSqsRecord = mapToLambdaSqsRecord;
-function mapToLambdaEvent(req, requestBody) {
-    if (!req.url || !req.method)
-        throw new Error('url and method are required');
-    const url = new url_1.URL(req.url, `http://${req.headers.host}`);
-    const qsp = {};
-    url.searchParams.forEach((v, k) => (qsp[k] = decodeURIComponent(v)));
-    const headers = {};
-    if (req.headers['content-type'])
-        headers['content-type'] = req.headers['content-type'];
-    if (req.headers['accept'])
-        headers['accept'] = req.headers['accept'];
-    if (req.headers['authorization'])
-        headers['authorization'] = req.headers['authorization'];
-    const time = 1428582896000;
-    return Promise.resolve({
-        version: '2.0',
-        rawPath: url.pathname,
-        rawQueryString: url.search,
-        routeKey: '',
-        httpMethod: req.method,
-        body: requestBody,
-        headers: headers,
-        path: url.pathname,
-        pathParameters: null,
-        queryStringParameters: qsp,
-        resource: '',
-        multiValueHeaders: {},
-        isBase64Encoded: false,
-        multiValueQueryStringParameters: null,
-        stageVariables: null,
-        requestContext: {
-            domainName: req.headers.host,
-            domainPrefix: '',
-            http: {
-                method: req.method,
-                path: url.pathname,
-                protocol: 'http',
-                sourceIp: '127.0.0.1',
-                userAgent: req.headers['user-agent'],
-            },
+const payloadV1JwtAuthorizerLambdaMapper = () => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper(request, body))
+});
+const payloadV2LambdaAuthorizerLambdaMapper = () => ({
+    newInstance: (request, body) => Promise.resolve(new DefaultLambdaMapper(request, body))
+});
+const payloadV1PathParameterResolver = {
+    locate: (event) => event.path,
+    store: (event, params) => event.pathParameters = params
+};
+const payloadV2PathParameterResolver = {
+    locate: (event) => event.rawPath,
+    store: (event, params) => event.pathParameters = params
+};
+exports.v1 = {
+    mapper: payloadV1JwtAuthorizerLambdaMapper(),
+    resolver: payloadV1PathParameterResolver,
+};
+exports.v2 = {
+    mapper: payloadV2LambdaAuthorizerLambdaMapper(),
+    resolver: payloadV2PathParameterResolver,
+};
+class DefaultLambdaMapper {
+    constructor(request, body) {
+        this.body = body;
+        this.toResponse = (response) => response.isBase64Encoded ?
+            new Base64EncodedResponse(response.statusCode, response.headers?.['content-type']?.toString(), response.headers?.['location']?.toString(), response.body) :
+            new StringResponse(response.statusCode, response.headers?.['content-type']?.toString(), response.headers?.['location']?.toString(), response.body);
+        this.event = (context) => ({
+            version: '2.0',
+            rawPath: this.url.pathname,
+            rawQueryString: this.url.search,
             routeKey: '',
-            time: new Date(time).toString(),
-            timeEpoch: time,
-            accountId: '',
-            apiId: '',
-            authorizer: undefined,
-            httpMethod: '',
-            identity: {
-                accessKey: '',
+            httpMethod: this.method,
+            body: this.body,
+            headers: this.headers,
+            path: this.url.pathname,
+            pathParameters: null,
+            queryStringParameters: this.queryStringParameters,
+            resource: '',
+            multiValueHeaders: {},
+            isBase64Encoded: false,
+            multiValueQueryStringParameters: null,
+            stageVariables: null,
+            requestContext: {
+                domainName: this.headers.host,
+                domainPrefix: '',
+                http: {
+                    method: this.method,
+                    path: this.url.pathname,
+                    protocol: 'http',
+                    sourceIp: '127.0.0.1',
+                    userAgent: this.headers['user-agent'],
+                },
+                routeKey: '',
+                time: new Date(this.time).toString(),
+                timeEpoch: this.time,
                 accountId: '',
-                apiKey: '',
-                apiKeyId: '',
-                caller: '',
-                clientCert: {
-                    clientCertPem: '',
-                    issuerDN: '',
-                    serialNumber: '',
-                    subjectDN: '',
-                    validity: { notAfter: '', notBefore: '' },
+                apiId: '',
+                authorizer: context,
+                httpMethod: '',
+                identity: {
+                    accessKey: '',
+                    accountId: '',
+                    apiKey: '',
+                    apiKeyId: '',
+                    caller: '',
+                    clientCert: {
+                        clientCertPem: '',
+                        issuerDN: '',
+                        serialNumber: '',
+                        subjectDN: '',
+                        validity: { notAfter: '', notBefore: '' },
+                    },
+                    cognitoAuthenticationProvider: '',
+                    cognitoAuthenticationType: '',
+                    cognitoIdentityId: '',
+                    cognitoIdentityPoolId: '',
+                    principalOrgId: '',
+                    sourceIp: '',
+                    user: '',
+                    userAgent: '',
+                    userArn: '',
                 },
-                cognitoAuthenticationProvider: '',
-                cognitoAuthenticationType: '',
-                cognitoIdentityId: '',
-                cognitoIdentityPoolId: '',
-                principalOrgId: '',
-                sourceIp: '',
-                user: '',
-                userAgent: '',
-                userArn: '',
-            },
-            path: '',
-            protocol: '',
-            requestId: '',
-            requestTimeEpoch: time,
-            resourceId: '',
-            resourcePath: '',
-            stage: '',
-        },
-    });
+                path: '',
+                protocol: '',
+                requestId: '',
+                requestTimeEpoch: this.time,
+                resourceId: '',
+                resourcePath: '',
+                stage: '',
+            }
+        });
+        this.authorization = () => this.authorizationHeaderValue;
+        if (!request.url || !request.method)
+            throw new Error('url and method are required');
+        const url = new url_1.URL(request.url, `http://${request.headers.host}`);
+        const qsp = {};
+        url.searchParams.forEach((v, k) => (qsp[k] = decodeURIComponent(v)));
+        this.queryStringParameters = qsp;
+        const headers = {};
+        if (request.headers['content-type'])
+            headers['content-type'] = request.headers['content-type'];
+        if (request.headers['accept'])
+            headers['accept'] = request.headers['accept'];
+        if (request.headers['authorization'])
+            headers['authorization'] = request.headers['authorization'];
+        this.headers = headers;
+        this.url = url;
+        this.time = 1428582896000;
+    }
+}
+class StringResponse extends lambda_http_proxy_1.Response {
+    constructor(statusCode, contentType, location, body) {
+        super(statusCode, contentType, location);
+        this.body = () => body;
+    }
+}
+class Base64EncodedResponse extends lambda_http_proxy_1.Response {
+    constructor(statusCode, contentType, location, body) {
+        super(statusCode, contentType, location);
+        this.body = () => Buffer.from(body, 'base64');
+    }
 }
-exports.mapToLambdaEvent = mapToLambdaEvent;

package/dist/src/services.d.ts

@@ -15,6 +15,7 @@ export declare class Service<I> implements Lifecycle<I> {
     readonly name: string;
     readonly start: (config: DevServerConfig) => Promise<I>;
     readonly stop: () => Promise<void>;
+    private doStop;
     private readonly LOGGER;
     constructor(service: Lifecycle<I>, callback?: Callback<I>);
     private callbackOrDefault;

package/dist/src/services.js

@@ -9,14 +9,18 @@ class Service {
         this.callbackOrDefault = async (instance) => (this.callback ?? this.DEFAULT_CALLBACK)(instance);
         this.name = service.name;
         this.LOGGER = logging_1.LoggerFactory.create(`SERVICE[${this.name}]`);
+        const stop = async () => service.stop();
         this.start = (config) => service.start(config)
+            .catch((error) => stop()
+            .then(() => this.doStop = () => Promise.resolve(this.LOGGER.error(error, 'failed')))
+            .then(() => Promise.reject(error)))
             .then((started) => this
             .callbackOrDefault(started)
             .then(() => this.LOGGER.info('started'))
             .then(() => started));
-        this.stop = () => service
-            .stop()
+        this.doStop = () => stop()
             .then(() => this.LOGGER.info('stopped'));
+        this.stop = () => this.doStop();
     }
 }
 exports.Service = Service;

package/dist/src/sqs.js

@@ -14,7 +14,7 @@ class Sqs {
             .send(new client_sqs_1.CreateQueueCommand({
             QueueName: fifo ? `${name}.fifo` : name,
             Attributes: {
-                FifoQueue: fifo ? 'true' : 'false',
+                FifoQueue: fifo ? 'true' : undefined,
             }
         }))
             .then((create) => this.client

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yopdev/dev-server",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-beta.1",
   "scripts": {
     "compile": "tsc",
     "pretest": "npm run compile",