@yopdev/dev-server 1.1.0

package/dist/lambda-http-proxy.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newLambdaHttpProxy = void 0;
+var logging_1 = require("@yopdev/logging");
+var http_server_1 = require("./http-server");
+var mappers_1 = require("./mappers");
+var responses_1 = require("./responses");
+var services_1 = require("./services");
+var newLambdaHttpProxy = function (name, config, service) { return new services_1.Service(new LambdaHttpProxy(name, config.settings, config.handler), service); };
+exports.newLambdaHttpProxy = newLambdaHttpProxy;
+var LambdaHttpProxy = /** @class */ (function () {
+    function LambdaHttpProxy(name, settings, handler) {
+        var _this = this;
+        this.name = name;
+        this.start = function () { return _this.server.start(); };
+        this.stop = function () { return _this.server.stop()
+            .then(function () { return _this.LOGGER.info('stopped'); }); };
+        this.handler = function (lambdaHandler) {
+            return function (request, body, response) {
+                return lambdaHandler((0, mappers_1.mapToLambdaEvent)(request, body))
+                    .then(function (lambda) {
+                    var _a, _b, _c, _d, _e, _f;
+                    return (0, responses_1.writeResponse)(response, lambda.statusCode, lambda.body, (_c = (_b = (_a = lambda.headers) === null || _a === void 0 ? void 0 : _a['Content-Type']) === null || _b === void 0 ? void 0 : _b.toString()) !== null && _c !== void 0 ? _c : undefined, (_f = (_e = (_d = lambda.headers) === null || _d === void 0 ? void 0 : _d['Location']) === null || _e === void 0 ? void 0 : _e.toString()) !== null && _f !== void 0 ? _f : undefined);
+                })
+                    .catch(function (e) {
+                    _this.LOGGER.error(e, 'request failed to execute');
+                    (0, responses_1.internalServerError)(response, e.body);
+                });
+            };
+        };
+        this.server = new http_server_1.HttpServer(name, settings, this.handler(handler));
+        this.LOGGER = logging_1.LoggerFactory.create("HTTP->LAMBDA[".concat(this.name, "]"));
+    }
+    return LambdaHttpProxy;
+}());

package/dist/localstack.d.ts

@@ -0,0 +1,10 @@
+import { StartedNetwork } from "testcontainers";
+import { AwsConfig, Config } from "./config";
+import { Stoppable } from "./services";
+export declare class LocalStack implements Stoppable {
+    private readonly _start;
+    private started;
+    constructor(config: Config, network: StartedNetwork);
+    start: () => Promise<AwsConfig>;
+    stop: () => Promise<void>;
+}

package/dist/localstack.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStack = void 0;
+var logging_1 = require("@yopdev/logging");
+var testcontainers_1 = require("testcontainers");
+var LOGGER = logging_1.LoggerFactory.create('LOCALSTACK');
+var NETWORK_ALIAS = 'localstack';
+var PROTOCOL = 'http';
+var DEFAULT_DOCKER_IMAGE = 'localstack/localstack:stable';
+var LocalStack = /** @class */ (function () {
+    function LocalStack(config, network) {
+        var _this = this;
+        this.start = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this._start()
+                        .then(function (endpoint) { return ({
+                        region: 'us-east-1',
+                        endpoint: endpoint,
+                        credentials: {
+                            accessKeyId: 'dummy',
+                            secretAccessKey: 'dummy'
+                        }
+                    }); })];
+            });
+        }); };
+        this.stop = function () { return Promise.resolve(_this.started)
+            .then(function (container) { return container ? container.stop().then(function () { return 'stopped'; }) : 'not started'; })
+            .then(function (status) { return LOGGER.info(status); }); };
+        var container = new testcontainers_1.GenericContainer(config.localStackDockerImage || DEFAULT_DOCKER_IMAGE);
+        var localStatePath = config.localStateBindMount;
+        var withLocalState = localStatePath !== undefined ?
+            container
+                .withEnvironment({ PERSISTENCE: '1' })
+                .withBindMounts([{
+                    source: localStatePath,
+                    target: '/var/lib/localstack',
+                    mode: 'rw',
+                }])
+            : container;
+        var ready = withLocalState
+            .withExposedPorts(config.useRandomPorts ?
+            config.servicesPort :
+            {
+                container: config.servicesPort,
+                host: config.servicesPort
+            })
+            .withNetwork(network)
+            .withNetworkAliases(NETWORK_ALIAS);
+        this._start = function () { return ready
+            .start()
+            .then(function (container) { return _this.started = container; })
+            .then(function (container) { return "".concat(PROTOCOL, "://").concat(container.getHost(), ":").concat(container.getMappedPort(config.servicesPort)); }); };
+        LOGGER.debug('initialized');
+    }
+    return LocalStack;
+}());
+exports.LocalStack = LocalStack;

package/dist/mappers.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Message } from "@aws-sdk/client-sqs";
+import { APIGatewayProxyEvent, SQSRecord } from "aws-lambda";
+import { IncomingMessage } from "http";
+export declare const mapToLambdaSqsRecord: (message: Message) => SQSRecord;
+export declare function mapToLambdaEvent(req: IncomingMessage, requestBody: string): APIGatewayProxyEvent;

package/dist/mappers.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToLambdaEvent = exports.mapToLambdaSqsRecord = void 0;
+var logging_1 = require("@yopdev/logging");
+var url_1 = require("url");
+var LOGGER = logging_1.LoggerFactory.create('MAPPERS');
+var mapToLambdaSqsRecord = function (message) {
+    if (!message.Body)
+        throw new Error("message Body must be present: ".concat(message.Body));
+    return {
+        messageId: 'N/A',
+        receiptHandle: 'N/A',
+        body: message.Body,
+        attributes: {
+            ApproximateReceiveCount: 'N/A',
+            SentTimestamp: 'N/A',
+            SenderId: 'N/A',
+            ApproximateFirstReceiveTimestamp: 'N/A',
+        },
+        messageAttributes: {},
+        md5OfBody: 'N/A',
+        eventSource: 'N/A',
+        eventSourceARN: 'N/A',
+        awsRegion: 'N/A',
+    };
+};
+exports.mapToLambdaSqsRecord = mapToLambdaSqsRecord;
+function mapToLambdaEvent(req, requestBody) {
+    if (!req.url || !req.method)
+        throw new Error('url and method are required');
+    var url = new url_1.URL(decodeURIComponent(req.url), "http://".concat(req.headers.host));
+    var qsp = {};
+    url.searchParams.forEach(function (v, k) { return (qsp[k] = v); });
+    var claims = extractClaims(req);
+    var headers = {};
+    if (req.headers['content-type'])
+        headers['Content-Type'] = req.headers['content-type'];
+    if (req.headers['accept'])
+        headers['Accept'] = req.headers['accept'];
+    return {
+        httpMethod: req.method,
+        body: requestBody,
+        headers: headers,
+        path: url.pathname,
+        pathParameters: null,
+        queryStringParameters: qsp,
+        resource: '',
+        multiValueHeaders: {},
+        isBase64Encoded: false,
+        multiValueQueryStringParameters: null,
+        stageVariables: null,
+        requestContext: {
+            accountId: '',
+            apiId: '',
+            authorizer: { claims: claims },
+            httpMethod: '',
+            identity: {
+                accessKey: '',
+                accountId: '',
+                apiKey: '',
+                apiKeyId: '',
+                caller: '',
+                clientCert: {
+                    clientCertPem: '',
+                    issuerDN: '',
+                    serialNumber: '',
+                    subjectDN: '',
+                    validity: { notAfter: '', notBefore: '' },
+                },
+                cognitoAuthenticationProvider: '',
+                cognitoAuthenticationType: '',
+                cognitoIdentityId: '',
+                cognitoIdentityPoolId: '',
+                principalOrgId: '',
+                sourceIp: '',
+                user: '',
+                userAgent: '',
+                userArn: '',
+            },
+            path: '',
+            protocol: '',
+            requestId: '',
+            requestTimeEpoch: 1428582896000,
+            resourceId: '',
+            resourcePath: '',
+            stage: '',
+        },
+    };
+}
+exports.mapToLambdaEvent = mapToLambdaEvent;
+function extractClaims(req) {
+    var _a;
+    var jwt = (_a = req.headers['authorization']) === null || _a === void 0 ? void 0 : _a.replace('Bearer ', '');
+    try {
+        return jwt ? JSON.parse(atob(jwt.split('.')[1])) : null;
+    }
+    catch (e) {
+        LOGGER.warn('Invalid token, claims could not be extracted: %O', jwt);
+        return undefined;
+    }
+}

package/dist/pre-traffic-hooks.d.ts

@@ -0,0 +1,11 @@
+import { Lifecycle, Service, ServiceConfig } from './services';
+export declare const newPreTrafficHooks: (name: string, hooks: () => Promise<void>[], service: ServiceConfig<PreTrafficHooks>) => Service<PreTrafficHooks>;
+declare class PreTrafficHooks implements Lifecycle<PreTrafficHooks> {
+    readonly name: string;
+    private readonly hooks;
+    private LOGGER;
+    constructor(name: string, hooks: () => Promise<void>[]);
+    start: () => Promise<this>;
+    stop: () => Promise<void>;
+}
+export {};

package/dist/pre-traffic-hooks.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newPreTrafficHooks = void 0;
+var logging_1 = require("@yopdev/logging");
+var services_1 = require("./services");
+var newPreTrafficHooks = function (name, hooks, service) { return new services_1.Service(new PreTrafficHooks(name, hooks), service); };
+exports.newPreTrafficHooks = newPreTrafficHooks;
+var PreTrafficHooks = /** @class */ (function () {
+    function PreTrafficHooks(name, hooks) {
+        var _this = this;
+        this.name = name;
+        this.hooks = hooks;
+        this.start = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise
+                        .all(this.hooks())
+                        .then(function () { return _this.LOGGER.info('started'); })
+                        .then(function () { return _this; })];
+            });
+        }); };
+        this.stop = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.resolve()
+                        .then(function () { return _this.LOGGER.info('stopped'); })];
+            });
+        }); };
+        this.LOGGER = logging_1.LoggerFactory.create("PRETRAFFIC[".concat(name, "]"));
+    }
+    return PreTrafficHooks;
+}());

package/dist/responses.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { ServerResponse } from 'http';
+export declare function internalServerError(res: ServerResponse, body: string): void;
+export declare function writeResponse(res: ServerResponse, statusCode: number, body: string, contentType?: string, location?: string): void;

package/dist/responses.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeResponse = exports.internalServerError = void 0;
+function internalServerError(res, body) {
+    return writeResponse(res, 500, body);
+}
+exports.internalServerError = internalServerError;
+function writeResponse(res, statusCode, body, contentType, location) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', '*');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+    if (contentType)
+        res.setHeader('Content-Type', contentType);
+    if (location)
+        res.setHeader('Location', location);
+    res.statusCode = statusCode;
+    res.end(body);
+}
+exports.writeResponse = writeResponse;

package/dist/scheduled-tasks.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { Lifecycle, Service, ServiceConfig } from './services';
+export declare const newScheduledTasks: (name: string, schedules: Rate[], service: ServiceConfig<ScheduledTasks>) => Service<ScheduledTasks>;
+declare class ScheduledTasks implements Lifecycle<ScheduledTasks> {
+    readonly name: string;
+    private readonly schedules;
+    private LOGGER;
+    constructor(name: string, schedules: Rate[]);
+    intervals: NodeJS.Timeout[];
+    start: () => Promise<this>;
+    stop: () => Promise<void>;
+}
+export type Rate = {
+    frequency: number;
+    task: () => Promise<unknown>;
+};
+export {};

package/dist/scheduled-tasks.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newScheduledTasks = void 0;
+var logging_1 = require("@yopdev/logging");
+var timers_1 = require("timers");
+var services_1 = require("./services");
+var newScheduledTasks = function (name, schedules, service) { return new services_1.Service(new ScheduledTasks(name, schedules), service); };
+exports.newScheduledTasks = newScheduledTasks;
+var ScheduledTasks = /** @class */ (function () {
+    function ScheduledTasks(name, schedules) {
+        var _this = this;
+        this.name = name;
+        this.schedules = schedules;
+        this.intervals = [];
+        this.start = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.resolve(this.schedules.forEach(function (schedule) { return _this.intervals.push(setInterval(schedule.task, schedule.frequency * 1000)); }))
+                        .then(function () { return _this.LOGGER.info('started'); })
+                        .then(function () { return _this; })];
+            });
+        }); };
+        this.stop = function () { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.resolve(this.intervals.forEach(function (interval) { return (0, timers_1.clearInterval)(interval); }))
+                        .then(function () { return _this.LOGGER.info('stopped'); })];
+            });
+        }); };
+        this.LOGGER = logging_1.LoggerFactory.create("SCHEDULER[".concat(name, "]"));
+    }
+    return ScheduledTasks;
+}());

package/dist/services.d.ts

@@ -0,0 +1,24 @@
+import { DevServerConfig } from "./config";
+export interface Lifecycle<I> extends Stoppable {
+    name: string;
+    start: (config: DevServerConfig) => Promise<I>;
+}
+export interface Stoppable {
+    stop(): Promise<void>;
+}
+export interface Callbackable<I> {
+    callback?: ((instance: I) => Promise<void>);
+}
+export declare class Service<I> implements Lifecycle<I> {
+    private readonly config;
+    readonly name: string;
+    readonly start: (config: DevServerConfig) => Promise<I>;
+    readonly stop: () => Promise<void>;
+    private LOGGER;
+    constructor(service: Lifecycle<I>, config: ServiceConfig<I>);
+    private callback;
+    private dependsOnOrNothing;
+}
+export type ServiceConfig<I> = {
+    dependsOn?: Lifecycle<any>;
+} & Callbackable<I>;

package/dist/services.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+var logging_1 = require("@yopdev/logging");
+var Service = /** @class */ (function () {
+    function Service(service, config) {
+        var _this = this;
+        this.config = config;
+        this.callback = function (instance) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (this.config.callback || (function () { return _this.LOGGER.debug('no callback', _this.name); }))(instance)];
+            });
+        }); };
+        this.dependsOnOrNothing = function () {
+            var _a;
+            return (_a = _this.config.dependsOn) !== null && _a !== void 0 ? _a : {
+                name: _this.name,
+                start: function () { return Promise.resolve(_this.LOGGER.trace('no start dependency for %s', _this.name)); },
+                stop: function () { return Promise.resolve(_this.LOGGER.trace('no stop dependency for %s', _this.name)); }
+            };
+        };
+        this.name = service.name;
+        this.LOGGER = logging_1.LoggerFactory.create("SERVICE[".concat(this.name, "]"));
+        this.start = function (config) { return _this.dependsOnOrNothing()
+            .start(config)
+            .then(function () { return service.start(config); })
+            .then(function (started) { return _this
+            .callback(started)
+            .then(function () { return _this.LOGGER.info('started'); })
+            .then(function () { return started; }); }); };
+        this.stop = function () { return service
+            .stop()
+            .then(function () { return _this.dependsOnOrNothing().stop(); })
+            .then(function () { return _this.LOGGER.info('stopped'); }); };
+    }
+    return Service;
+}());
+exports.Service = Service;

package/dist/sns-http-proxy.d.ts

@@ -0,0 +1,26 @@
+import { HttpSettings } from "./http-server";
+import { IncomingMessage, ServerResponse } from "http";
+import { Lifecycle, Service, ServiceConfig } from "./services";
+import { DevServerConfig } from "./config";
+export declare const newSnsHttpProxy: (name: string, config: {
+    settings: HttpSettings;
+    method: string;
+    subject: string | undefined;
+}, service: ServiceConfig<string>) => Service<string>;
+export declare class SnsHttpProxy implements Lifecycle<string> {
+    readonly name: string;
+    private readonly settings;
+    private readonly method;
+    private readonly subject?;
+    private LOGGER;
+    private server;
+    private config;
+    constructor(name: string, settings: HttpSettings, method: string, subject?: string);
+    start: (config: DevServerConfig) => Promise<string>;
+    stop: () => Promise<void>;
+    handler: (method: string, subject?: string) => (request: IncomingMessage, body: string, response: ServerResponse) => Promise<void>;
+    extractMessage: (method: string, request: IncomingMessage, body: string) => string;
+    private onlyWhenStarted;
+    private extractQueryString;
+    private extractMessageAttributes;
+}

package/dist/sns-http-proxy.js

@@ -0,0 +1,82 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnsHttpProxy = exports.newSnsHttpProxy = void 0;
+var logging_1 = require("@yopdev/logging");
+var http_server_1 = require("./http-server");
+var responses_1 = require("./responses");
+var services_1 = require("./services");
+var assert_1 = require("./assert");
+var newSnsHttpProxy = function (name, config, service) { return new services_1.Service(new SnsHttpProxy(name, config.settings, config.method, config.subject), service); };
+exports.newSnsHttpProxy = newSnsHttpProxy;
+var SnsHttpProxy = /** @class */ (function () {
+    function SnsHttpProxy(name, settings, method, subject) {
+        var _this = this;
+        this.name = name;
+        this.settings = settings;
+        this.method = method;
+        this.subject = subject;
+        this.start = function (config) { return Promise.resolve(_this.server)
+            .then(function (server) { return server.start(); })
+            .then(function (endpoint) {
+            _this.config = {
+                topic: config.topic.arn,
+                sns: config.sns
+            };
+            return endpoint;
+        })
+            .then(function (endpoint) { return endpoint; }); };
+        this.stop = function () { return _this.onlyWhenStarted(_this.server).stop()
+            .then(function () { return _this.LOGGER.info('stopped'); }); };
+        this.handler = function (method, subject) {
+            return function (request, body, response) {
+                return Promise.resolve(((0, assert_1.assertNotUndefined)(_this.config)))
+                    .then(function (config) {
+                    return config.sns
+                        .publish({ arn: config.topic }, _this.extractMessage(method, request, body), subject, _this.extractMessageAttributes(request))
+                        .then(function () { return (0, responses_1.writeResponse)(response, 200, ''); })
+                        .catch(function (e) {
+                        _this.LOGGER.error(e, 'request failed to execute');
+                        (0, responses_1.internalServerError)(response, e.body);
+                    });
+                });
+            };
+        };
+        this.extractMessage = function (method, request, body) {
+            switch (method) {
+                case 'GET':
+                    return _this.extractQueryString(request) || '';
+                case 'POST':
+                    return body;
+                default:
+                    throw new Error();
+            }
+        };
+        this.onlyWhenStarted = function (server) { return (0, assert_1.assertNotUndefined)(server, 'not started'); };
+        this.extractQueryString = function (request) { var _a, _b; return (_a = request.url) === null || _a === void 0 ? void 0 : _a.substring(((_b = request.url) === null || _b === void 0 ? void 0 : _b.indexOf('?')) + 1); };
+        this.extractMessageAttributes = function (request) {
+            var initialValue = {};
+            return Object.keys(request.headers).reduce(function (obj, item) {
+                var _a;
+                return __assign(__assign({}, obj), (_a = {}, _a[item] = {
+                    DataType: 'String',
+                    StringValue: request.headers[item],
+                }, _a));
+            }, initialValue);
+        };
+        this.server = new http_server_1.HttpServer(this.name, this.settings, this.handler(this.method, this.subject));
+        this.LOGGER = logging_1.LoggerFactory.create("HTTP->SNS[".concat(name, "]"));
+    }
+    return SnsHttpProxy;
+}());
+exports.SnsHttpProxy = SnsHttpProxy;