@yopdev/dev-server 3.0.2-RC → 3.0.2-RC2

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,34 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm run compile
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/__tests__/bootstrap.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from "@jest/globals";
+import { DevServer, allOf } from "../src";
+import { Service } from "../src/services";
+import { fail } from "assert";
+
+describe("dev server", () => {
+    it("bootstraps with defaults and an empty service", async () => {
+        const name = 'bootstrap';
+        const tested = await new DevServer(name, new Service({
+            name: 'service',
+            start: async () => Promise.resolve(),
+            stop: async () => Promise.resolve(),
+        })).start()
+        return expect(tested.name).toEqual(name)
+    })
+
+    it("calls service cleanup when init fails", async () => {
+        let called = false;
+        try {
+            await new DevServer('bootstrap', new Service({
+                name: 'failing-root',
+                start: async () => Promise.reject(new Error('fail!')),
+                stop: async () => Promise.resolve(called = true).then(),
+            })).start()
+            fail('should have failed')
+        } catch (e) {
+            return expect(called)
+                .toStrictEqual(true)
+        }
+    })
+
+    it("calls service cleanups on all components", async () => {
+        let calledOnParent = false;
+        let calledOnSibling = false;
+        let calledOnFailing = false;
+        try {
+            await new DevServer('bootstrap', allOf([
+                new Service({
+                    name: 'parent',
+                    start: async () => Promise.resolve(),
+                    stop: async () => Promise.resolve(calledOnParent = true).then(),
+                }), allOf([
+                    new Service({
+                        name: 'failing-nested',
+                        start: async () => Promise.reject(new Error('fail!')),
+                        stop: async () => Promise.resolve(calledOnFailing = true).then(),
+                    }),
+                    new Service({
+                        name: 'sibling',
+                        start: async () => Promise.resolve(),
+                        stop: async () => Promise.resolve(calledOnSibling = true).then(),
+                    }),
+                ])
+            ])).start()
+            fail('should have failed')
+        } catch (e) {
+            return expect([calledOnParent, calledOnFailing, calledOnSibling])
+                .toStrictEqual([true, true, true])
+        }
+    })
+
+    it("propagates the exception from the failing service", async () => {
+        const error = new Error('fail!')
+        try {
+            await new DevServer('bootstrap', allOf([
+                new Service({
+                    name: 'parent',
+                    start: async () => Promise.resolve(),
+                    stop: async () => Promise.resolve(),
+                }), allOf([
+                    new Service({
+                        name: 'failing-nested',
+                        start: async () => Promise.reject(error),
+                        stop: async () => Promise.resolve(),
+                    }),
+                    new Service({
+                        name: 'sibling',
+                        start: async () => Promise.resolve(),
+                        stop: async () => Promise.resolve(),
+                    }),
+                ])
+            ])).start()
+            fail('should have failed')
+        } catch (e) {
+            return expect(e)
+                .toStrictEqual(error)
+        }
+    })
+})

package/__tests__/deferred.test.ts

@@ -0,0 +1,86 @@
+import { describe, test, expect } from "@jest/globals";
+import { DevServer, DevServerConfig, Service, promised } from "../src";
+import { StartedNetwork } from "testcontainers";
+import { Sqs } from "../src/sqs";
+import { Sns } from "../src/sns";
+import { S3 } from "../src/s3";
+import { DynamoDb } from "../src/dynamodb";
+import { fail } from "assert";
+
+describe("a promised service", () => {
+    test("calls start with devserver config", () => {
+        const aws = {
+            region: 'region',
+            endpoint: 'http://localhost',
+            credentials: {
+                accessKeyId: 'aki',
+                secretAccessKey: 'sak',
+            },
+        }
+        const c: DevServerConfig = {
+            raw: aws,
+            network: new StartedNetwork(undefined, 'network', undefined),
+            sqs: new Sqs(aws),
+            sns: new Sns(aws),
+            s3: new S3(aws),
+            dynamo: new DynamoDb(aws),
+            eventsProxy: {
+                topic: {
+                    arn: 'arn:...',
+                },
+            },
+        }
+        return expect(
+            promised(async (cfg: DevServerConfig) => Promise.resolve(new Service(
+                {
+                    name: 'resolved',
+                    start: (config) => Promise.resolve(cfg === config),
+                    stop: () => Promise.resolve(),
+                }
+            ))
+            ).start(c)
+        )
+            .resolves.toStrictEqual(true)
+    })
+
+    test("calls the stop routine on failure starting promised service", async () => {
+        const error = new Error('failed starting service')
+        let stopped = false;
+        try {
+            await new DevServer('fail-on-start', promised(
+                () => Promise.resolve(
+                    new Service({
+                        name: 'fail-on-start',
+                        start: async () => Promise.reject(error),
+                        stop: async () => { stopped = true },
+                    }))
+            )).start()
+            fail('should have thrown exception')
+        } catch (e) {
+            return expect(stopped)
+                .toStrictEqual(true)
+        }
+    })
+
+    test("calls the cleanup routine on failure constructing promised service", async () => {
+        const error = {
+            cleanup: async () => stopped = true
+        }
+        let stopped = false;
+        try {
+            await new DevServer('fail-on-construct', promised(
+                () => Promise.resolve(
+                    new Service({
+                        name: 'fail-on-construct',
+                        start: async () => Promise.resolve(),
+                        stop: async () => Promise.resolve(),
+                    }))
+                    .then(() => Promise.reject(error)),
+            )).start()
+            fail('should have thrown exception')
+        } catch (e) {
+            return expect(stopped)
+                .toStrictEqual(true)
+        }
+    })
+})

package/__tests__/event-proxy.test.ts

@@ -0,0 +1,42 @@
+import { describe, test, expect } from "@jest/globals";
+import { allOf, DevServer, eventsProxy, Service } from "../src";
+import { EventHandler } from "../src/event-proxy";
+import { Sns } from "../src/sns";
+
+describe("the event proxy", () => {
+    test("handles an implementation error gracefully", async () => {
+        let sns: Sns;
+        let topic: { arn: string; };
+        let invoked = false;
+        const handler: EventHandler = {
+            name: 'fail',
+            handler: async () => {
+                invoked = true;
+                return Promise.reject();
+            },
+            matcher: () => true,
+        }
+        const devServer = await new DevServer(
+            'events-proxy',
+            allOf([
+                new Service({
+                    name: 'config-capture',
+                    start: (config) => {
+                        sns = config.sns;
+                        topic = config.eventsProxy.topic;
+                        return Promise.resolve()
+                    },
+                    stop: () => Promise.resolve(),
+                }),
+                eventsProxy('test', {
+                    handlers: [handler]
+                }),
+            ])
+        ).start();
+        return expect(sns.publish(topic, '{}')
+                .then(() => new Promise(resolve => setTimeout(resolve, 200)))
+                .then(() => invoked)
+                .finally(() => devServer.stop())
+        ).resolves.toStrictEqual(true)
+    })
+})

package/__tests__/lambda-http-proxy.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "@jest/globals";
+import { DevServer } from "../src";
+import { UNAUTHORIZED, newLambdaHttpProxy } from "../src/lambda-http-proxy";
+import axios from 'axios';
+import { v2 } from "../src/mappers";
+
+describe("the lambda http proxy", () => {
+    const payloadVersionV2Mapper = v2().mapper;
+
+    it("invokes the handler with the heaviest route", async () => {
+        let endpoint: string
+        const tested = await new DevServer('lambda-http-proxy', newLambdaHttpProxy(
+            'service',
+            {
+                settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+                routes: [
+                    { method: /GET/, path: /\/a\/.*\/b\/.*\/c/, weight: 3, handler: () => Promise.resolve({ statusCode: 200, body: '' }) },
+                    { method: /GET/, path: /\/a\/.*\/b\/.*/, weight: 2, handler: () => Promise.resolve({ statusCode: 400, body: '' }) },
+                    { method: /GET/, path: /\/a\/.*/, weight: 2, handler: () => Promise.resolve({ statusCode: 400, body: '' }) },
+                ],
+                mapper: payloadVersionV2Mapper,
+            },
+            async (url) => { endpoint = url; }
+        )).start()
+        return expect(axios.get(`${endpoint}a/1/b/2/c`)
+            .then(r => r.status)
+            .finally(async () => tested.stop())
+        )
+            .resolves
+            .toEqual(200)
+    })
+
+    it("supports a single 'catch all' route", async () => {
+        let endpoint: string
+        const tested = await new DevServer('lambda-http-proxy', newLambdaHttpProxy(
+            'service',
+            {
+                settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+                routes: [
+                    { method: /.*/, path: /.*/, weight: 0, handler: () => Promise.resolve({ statusCode: 200, body: 'handled!' }) },
+                ],
+                mapper: payloadVersionV2Mapper,
+            },
+            async (url) => { endpoint = url; }
+        )).start()
+        return expect(axios.post(`${endpoint}find-me`)
+            .then(r => ({ status: r.status, body: r.data }))
+            .finally(async () => tested.stop())
+        )
+            .resolves
+            .toStrictEqual({ status: 200, body: 'handled!' })
+    })
+
+    it("returns unauthorized when the authorizer rejects", async () => {
+        let endpoint: string
+        const tested = await new DevServer('lambda-http-proxy', newLambdaHttpProxy(
+            'service',
+            {
+                settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+                routes: [
+                    { method: /.*/, path: /.*/, weight: 0, handler: () => Promise.resolve({ statusCode: 200, body: 'handled!' }), authorizer: () => Promise.reject(UNAUTHORIZED) },
+                ],
+                mapper: payloadVersionV2Mapper,
+            },
+            async (url) => { endpoint = url; }
+        )).start()
+        return expect(axios.get(endpoint, { validateStatus: () => true })
+            .then(r => r.status)
+            .finally(async () => tested.stop())
+        )
+            .resolves
+            .toEqual(401)
+    })
+
+    it("triggers the fallback handler when no route matches a request", async () => {
+        let endpoint: string
+        const tested = await new DevServer('lambda-http-proxy', newLambdaHttpProxy(
+            'service',
+            {
+                settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+                routes: [
+                    { method: /.*/, path: /\a/, weight: 0, handler: () => Promise.resolve({ statusCode: 200, body: 'handled!' }) },
+                ],
+                mapper: payloadVersionV2Mapper,
+            },
+            async (url) => { endpoint = url; }
+        )).start()
+        return expect(axios.get(`${endpoint}b`, { validateStatus: () => true })
+            .then(r => ({ status: r.status, body: r.data }))
+            .finally(async () => tested.stop())
+        )
+            .resolves
+            .toStrictEqual({ status: 404, body: 'no route found to handle GET to /b' })
+    })
+
+    it("handler has access to the context", async () => {
+        const expectedContext = 'hello world!'
+        let endpoint: string
+        const tested = await new DevServer('lambda-http-proxy', newLambdaHttpProxy(
+            'service',
+            {
+                settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+                routes: [
+                    {
+                        method: /.*/,
+                        path: /\a/,
+                        weight: 0,
+                        handler: (_: unknown, context: string) => Promise.resolve({ statusCode: 200, body: context })
+                    },
+                ],
+                context: () => expectedContext,
+                mapper: payloadVersionV2Mapper,
+            },
+            async (url) => { endpoint = url; }
+        )).start()
+        return expect(axios.get(`${endpoint}a`)
+            .then(r => r.data)
+            .finally(async () => tested.stop())
+        )
+            .resolves
+            .toStrictEqual(expectedContext)
+    })
+
+    it("can set cookies", async () => {
+        let endpoint: string
+
+        const handler = async (event: object, context: unknown) => {
+            return {
+                statusCode: 200,
+                cookies: ['galletita=criollita'],
+            }
+        };
+
+        const tested = await new DevServer('lambda-http-proxy', newLambdaHttpProxy(
+            'service',
+            {
+                settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+                routes: [
+                    { method: /GET/, path: /\/a/, weight: 0, handler: handler },
+                ],
+                mapper: payloadVersionV2Mapper,
+            },
+            async (url) => { endpoint = url; }
+        )).start();
+
+        return expect(axios.get(`${endpoint}a`)
+            .then(r => r.headers["set-cookie"])
+            .finally(async () => tested.stop())
+        ).resolves.toContain('galletita=criollita')
+    })
+
+    it("can read cookies", async () => {
+        let endpoint: string
+
+        const handler = async (event: object, context: unknown) => {
+            return {
+                statusCode: 200,
+                body: event["headers"].cookie,
+            }
+        };
+
+        const tested = await new DevServer('lambda-http-proxy', newLambdaHttpProxy(
+            'service',
+            {
+                settings: { protocol: 'http:', host: '127.0.0.1', port: undefined },
+                routes: [
+                    { method: /GET/, path: /\/a/, weight: 0, handler: handler },
+                ],
+                mapper: payloadVersionV2Mapper,
+            },
+            async (url) => { endpoint = url; }
+        )).start();
+
+        return expect(axios.get(`${endpoint}a`, { headers: { cookie: ['galletita=criollita'] } })
+            .then(r => r.data)
+            .finally(async () => tested.stop())
+        ).resolves.toContain('galletita=criollita')
+    })
+})

package/dist/__tests__/bootstrap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bootstrap.test.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+const services_1 = require("../src/services");
+const assert_1 = require("assert");
+(0, globals_1.describe)("dev server", () => {
+    (0, globals_1.it)("bootstraps with defaults and an empty service", async () => {
+        const name = 'bootstrap';
+        const tested = await new src_1.DevServer(name, new services_1.Service({
+            name: 'service',
+            start: async () => Promise.resolve(),
+            stop: async () => Promise.resolve(),
+        })).start();
+        return (0, globals_1.expect)(tested.name).toEqual(name);
+    });
+    (0, globals_1.it)("calls service cleanup when init fails", async () => {
+        let called = false;
+        try {
+            await new src_1.DevServer('bootstrap', new services_1.Service({
+                name: 'failing-root',
+                start: async () => Promise.reject(new Error('fail!')),
+                stop: async () => Promise.resolve(called = true).then(),
+            })).start();
+            (0, assert_1.fail)('should have failed');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(called)
+                .toStrictEqual(true);
+        }
+    });
+    (0, globals_1.it)("calls service cleanups on all components", async () => {
+        let calledOnParent = false;
+        let calledOnSibling = false;
+        let calledOnFailing = false;
+        try {
+            await new src_1.DevServer('bootstrap', (0, src_1.allOf)([
+                new services_1.Service({
+                    name: 'parent',
+                    start: async () => Promise.resolve(),
+                    stop: async () => Promise.resolve(calledOnParent = true).then(),
+                }), (0, src_1.allOf)([
+                    new services_1.Service({
+                        name: 'failing-nested',
+                        start: async () => Promise.reject(new Error('fail!')),
+                        stop: async () => Promise.resolve(calledOnFailing = true).then(),
+                    }),
+                    new services_1.Service({
+                        name: 'sibling',
+                        start: async () => Promise.resolve(),
+                        stop: async () => Promise.resolve(calledOnSibling = true).then(),
+                    }),
+                ])
+            ])).start();
+            (0, assert_1.fail)('should have failed');
+        }
+        catch (e) {
+            return (0, globals_1.expect)([calledOnParent, calledOnFailing, calledOnSibling])
+                .toStrictEqual([true, true, true]);
+        }
+    });
+    (0, globals_1.it)("propagates the exception from the failing service", async () => {
+        const error = new Error('fail!');
+        try {
+            await new src_1.DevServer('bootstrap', (0, src_1.allOf)([
+                new services_1.Service({
+                    name: 'parent',
+                    start: async () => Promise.resolve(),
+                    stop: async () => Promise.resolve(),
+                }), (0, src_1.allOf)([
+                    new services_1.Service({
+                        name: 'failing-nested',
+                        start: async () => Promise.reject(error),
+                        stop: async () => Promise.resolve(),
+                    }),
+                    new services_1.Service({
+                        name: 'sibling',
+                        start: async () => Promise.resolve(),
+                        stop: async () => Promise.resolve(),
+                    }),
+                ])
+            ])).start();
+            (0, assert_1.fail)('should have failed');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(e)
+                .toStrictEqual(error);
+        }
+    });
+});

package/dist/__tests__/deferred.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/deferred.test.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+const testcontainers_1 = require("testcontainers");
+const sqs_1 = require("../src/sqs");
+const sns_1 = require("../src/sns");
+const s3_1 = require("../src/s3");
+const dynamodb_1 = require("../src/dynamodb");
+const assert_1 = require("assert");
+(0, globals_1.describe)("a promised service", () => {
+    (0, globals_1.test)("calls start with devserver config", () => {
+        const aws = {
+            region: 'region',
+            endpoint: 'http://localhost',
+            credentials: {
+                accessKeyId: 'aki',
+                secretAccessKey: 'sak',
+            },
+        };
+        const c = {
+            raw: aws,
+            network: new testcontainers_1.StartedNetwork(undefined, 'network', undefined),
+            sqs: new sqs_1.Sqs(aws),
+            sns: new sns_1.Sns(aws),
+            s3: new s3_1.S3(aws),
+            dynamo: new dynamodb_1.DynamoDb(aws),
+            eventsProxy: {
+                topic: {
+                    arn: 'arn:...',
+                },
+            },
+        };
+        return (0, globals_1.expect)((0, src_1.promised)(async (cfg) => Promise.resolve(new src_1.Service({
+            name: 'resolved',
+            start: (config) => Promise.resolve(cfg === config),
+            stop: () => Promise.resolve(),
+        }))).start(c))
+            .resolves.toStrictEqual(true);
+    });
+    (0, globals_1.test)("calls the stop routine on failure starting promised service", async () => {
+        const error = new Error('failed starting service');
+        let stopped = false;
+        try {
+            await new src_1.DevServer('fail-on-start', (0, src_1.promised)(() => Promise.resolve(new src_1.Service({
+                name: 'fail-on-start',
+                start: async () => Promise.reject(error),
+                stop: async () => { stopped = true; },
+            })))).start();
+            (0, assert_1.fail)('should have thrown exception');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(stopped)
+                .toStrictEqual(true);
+        }
+    });
+    (0, globals_1.test)("calls the cleanup routine on failure constructing promised service", async () => {
+        const error = {
+            cleanup: async () => stopped = true
+        };
+        let stopped = false;
+        try {
+            await new src_1.DevServer('fail-on-construct', (0, src_1.promised)(() => Promise.resolve(new src_1.Service({
+                name: 'fail-on-construct',
+                start: async () => Promise.resolve(),
+                stop: async () => Promise.resolve(),
+            }))
+                .then(() => Promise.reject(error)))).start();
+            (0, assert_1.fail)('should have thrown exception');
+        }
+        catch (e) {
+            return (0, globals_1.expect)(stopped)
+                .toStrictEqual(true);
+        }
+    });
+});

package/dist/__tests__/event-proxy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/event-proxy.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = require("../src");
+(0, globals_1.describe)("the event proxy", () => {
+    (0, globals_1.test)("handles an implementation error gracefully", async () => {
+        let sns;
+        let topic;
+        let invoked = false;
+        const handler = {
+            name: 'fail',
+            handler: async () => {
+                invoked = true;
+                return Promise.reject();
+            },
+            matcher: () => true,
+        };
+        const devServer = await new src_1.DevServer('events-proxy', (0, src_1.allOf)([
+            new src_1.Service({
+                name: 'config-capture',
+                start: (config) => {
+                    sns = config.sns;
+                    topic = config.eventsProxy.topic;
+                    return Promise.resolve();
+                },
+                stop: () => Promise.resolve(),
+            }),
+            (0, src_1.eventsProxy)('test', {
+                handlers: [handler]
+            }),
+        ])).start();
+        return (0, globals_1.expect)(sns.publish(topic, '{}')
+            .then(() => new Promise(resolve => setTimeout(resolve, 200)))
+            .then(() => invoked)
+            .finally(() => devServer.stop())).resolves.toStrictEqual(true);
+    });
+});

package/dist/__tests__/lambda-http-proxy.test.d.ts

@@ -0,0 +1 @@
+export {};