@shuttl-io/core 0.2.0

package/dist/tests/outcomes.test.d.ts

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

package/dist/tests/outcomes.test.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IOutcomes_1 = require("../src/outcomes/IOutcomes");
+const StreamingOutcome_1 = require("../src/outcomes/StreamingOutcome");
+// Helper to create a properly typed mock streamer
+function createMockStreamer() {
+    let called = false;
+    return {
+        async next() {
+            if (called) {
+                return { value: undefined, done: true };
+            }
+            called = true;
+            return {
+                value: {
+                    eventName: "test",
+                    data: {
+                        typeName: "output_text",
+                        outputText: { outputType: "output_text", text: "test" }
+                    }
+                },
+                done: false
+            };
+        }
+    };
+}
+describe("IOutcome interface", () => {
+    it("should define send method that returns Promise<void>", () => {
+        const outcome = {
+            send: jest.fn().mockResolvedValue(undefined),
+            bindToRequest: jest.fn().mockResolvedValue(undefined),
+        };
+        expect(typeof outcome.send).toBe("function");
+    });
+    it("should define bindToRequest method that returns Promise<void>", () => {
+        const outcome = {
+            send: jest.fn().mockResolvedValue(undefined),
+            bindToRequest: jest.fn().mockResolvedValue(undefined),
+        };
+        expect(typeof outcome.bindToRequest).toBe("function");
+    });
+    it("should allow custom IOutcome implementations", async () => {
+        class CustomOutcome {
+            constructor() {
+                this.sentMessages = [];
+                this.boundRequests = [];
+            }
+            async send(message) {
+                this.sentMessages.push(message);
+            }
+            async bindToRequest(request) {
+                this.boundRequests.push(request);
+            }
+        }
+        const outcome = new CustomOutcome();
+        await outcome.send({ test: "message" });
+        await outcome.bindToRequest({ requestId: "123" });
+        expect(outcome.sentMessages).toHaveLength(1);
+        expect(outcome.sentMessages[0]).toEqual({ test: "message" });
+        expect(outcome.boundRequests).toHaveLength(1);
+        expect(outcome.boundRequests[0]).toEqual({ requestId: "123" });
+    });
+});
+describe("SlackOutcome", () => {
+    let consoleSpy;
+    beforeEach(() => {
+        consoleSpy = jest.spyOn(console, "log").mockImplementation();
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    describe("constructor", () => {
+        it("should create a SlackOutcome instance", () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            expect(outcome).toBeInstanceOf(IOutcomes_1.SlackOutcome);
+        });
+    });
+    describe("send()", () => {
+        it("should log the message to console", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            const message = { text: "Hello, Slack!" };
+            await outcome.send(message);
+            expect(consoleSpy).toHaveBeenCalledWith("Sending message to Slack:", message);
+        });
+        it("should return a resolved promise", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            const result = outcome.send({ text: "Test" });
+            expect(result).toBeInstanceOf(Promise);
+            await expect(result).resolves.toBeUndefined();
+        });
+        it("should handle async generator messages", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            await outcome.send(createMockStreamer());
+            expect(consoleSpy).toHaveBeenCalled();
+        });
+    });
+    describe("bindToRequest()", () => {
+        it("should log the request to console", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            const request = { requestId: "123" };
+            await outcome.bindToRequest(request);
+            expect(consoleSpy).toHaveBeenCalledWith("Binding request to Slack:", request);
+        });
+        it("should return a resolved promise", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            const result = outcome.bindToRequest({ test: "data" });
+            expect(result).toBeInstanceOf(Promise);
+            await expect(result).resolves.toBeUndefined();
+        });
+    });
+    describe("implements IOutcome", () => {
+        it("should satisfy IOutcome interface", () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            expect(typeof outcome.send).toBe("function");
+            expect(typeof outcome.bindToRequest).toBe("function");
+        });
+        it("should be usable as IOutcome", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            await expect(outcome.send({ test: "data" })).resolves.toBeUndefined();
+            await expect(outcome.bindToRequest({ test: "data" })).resolves.toBeUndefined();
+        });
+    });
+    describe("multiple sends", () => {
+        it("should handle multiple sequential sends", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            await outcome.send("First message");
+            await outcome.send("Second message");
+            await outcome.send("Third message");
+            expect(consoleSpy).toHaveBeenCalledTimes(3);
+            expect(consoleSpy).toHaveBeenNthCalledWith(1, "Sending message to Slack:", "First message");
+            expect(consoleSpy).toHaveBeenNthCalledWith(2, "Sending message to Slack:", "Second message");
+            expect(consoleSpy).toHaveBeenNthCalledWith(3, "Sending message to Slack:", "Third message");
+        });
+        it("should handle concurrent sends", async () => {
+            const outcome = new IOutcomes_1.SlackOutcome();
+            await Promise.all([
+                outcome.send("Message 1"),
+                outcome.send("Message 2"),
+                outcome.send("Message 3"),
+            ]);
+            expect(consoleSpy).toHaveBeenCalledTimes(3);
+        });
+    });
+});
+describe("StreamingOutcome", () => {
+    let consoleSpy;
+    beforeEach(() => {
+        consoleSpy = jest.spyOn(console, "log").mockImplementation();
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    describe("constructor", () => {
+        it("should create a StreamingOutcome instance", () => {
+            const outcome = new StreamingOutcome_1.StreamingOutcome();
+            expect(outcome).toBeInstanceOf(StreamingOutcome_1.StreamingOutcome);
+        });
+    });
+    describe("send()", () => {
+        it("should log the message to console", async () => {
+            const outcome = new StreamingOutcome_1.StreamingOutcome();
+            await outcome.send(createMockStreamer());
+            expect(consoleSpy).toHaveBeenCalled();
+        });
+        it("should return a resolved promise", async () => {
+            const outcome = new StreamingOutcome_1.StreamingOutcome();
+            const result = outcome.send(createMockStreamer());
+            expect(result).toBeInstanceOf(Promise);
+            await expect(result).resolves.toBeUndefined();
+        });
+    });
+    describe("bindToRequest()", () => {
+        it("should log the request to console", async () => {
+            const outcome = new StreamingOutcome_1.StreamingOutcome();
+            const request = { requestId: "123" };
+            await outcome.bindToRequest(request);
+            expect(consoleSpy).toHaveBeenCalledWith("Binding request to Slack:", request);
+        });
+        it("should return a resolved promise", async () => {
+            const outcome = new StreamingOutcome_1.StreamingOutcome();
+            const result = outcome.bindToRequest({ test: "data" });
+            expect(result).toBeInstanceOf(Promise);
+            await expect(result).resolves.toBeUndefined();
+        });
+    });
+    describe("implements IOutcome", () => {
+        it("should satisfy IOutcome interface", () => {
+            const outcome = new StreamingOutcome_1.StreamingOutcome();
+            expect(typeof outcome.send).toBe("function");
+            expect(typeof outcome.bindToRequest).toBe("function");
+        });
+        it("should be usable as IOutcome", async () => {
+            const outcome = new StreamingOutcome_1.StreamingOutcome();
+            await expect(outcome.send(createMockStreamer())).resolves.toBeUndefined();
+            await expect(outcome.bindToRequest({ test: "data" })).resolves.toBeUndefined();
+        });
+    });
+});
+describe("IOutcome usage patterns", () => {
+    it("should work with multiple outcome types", async () => {
+        class EmailOutcome {
+            constructor() {
+                this.sent = [];
+            }
+            async send(message) {
+                this.sent.push({ type: "email", message });
+            }
+            async bindToRequest(_request) { }
+        }
+        class WebhookOutcome {
+            constructor() {
+                this.sent = [];
+            }
+            async send(message) {
+                this.sent.push({ type: "webhook", message });
+            }
+            async bindToRequest(_request) { }
+        }
+        const outcomes = [
+            new IOutcomes_1.SlackOutcome(),
+            new EmailOutcome(),
+            new WebhookOutcome(),
+        ];
+        const message = { content: "Test notification" };
+        for (const outcome of outcomes) {
+            await outcome.send(message);
+        }
+        expect(outcomes.length).toBe(3);
+    });
+    it("should allow async operations in custom outcomes", async () => {
+        class AsyncOutcome {
+            constructor() {
+                this.completed = false;
+            }
+            async send(_message) {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                this.completed = true;
+            }
+            async bindToRequest(_request) { }
+        }
+        const outcome = new AsyncOutcome();
+        expect(outcome.completed).toBe(false);
+        await outcome.send("async message");
+        expect(outcome.completed).toBe(true);
+    });
+    it("should allow throwing outcomes for error handling", async () => {
+        class FailingOutcome {
+            async send(_message) {
+                throw new Error("Send failed");
+            }
+            async bindToRequest(_request) { }
+        }
+        const outcome = new FailingOutcome();
+        await expect(outcome.send("test")).rejects.toThrow("Send failed");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"outcomes.test.js","sourceRoot":"","sources":["../../tests/outcomes.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { IOutcome, SlackOutcome } from \"../src/outcomes/IOutcomes\";\nimport { StreamingOutcome } from \"../src/outcomes/StreamingOutcome\";\nimport { IModelResponseStream, ModelResponseStreamValue } from \"../src/models/types\";\n\n// Helper to create a properly typed mock streamer\nfunction createMockStreamer(): IModelResponseStream {\n    let called = false;\n    return {\n        async next(): Promise<ModelResponseStreamValue> {\n            if (called) {\n                return { value: undefined, done: true };\n            }\n            called = true;\n            return { \n                value: { \n                    eventName: \"test\", \n                    data: { \n                        typeName: \"output_text\" as const,\n                        outputText: { outputType: \"output_text\" as const, text: \"test\" }\n                    } \n                },\n                done: false\n            };\n        }\n    };\n}\n\ndescribe(\"IOutcome interface\", () => {\n    it(\"should define send method that returns Promise<void>\", () => {\n        const outcome: IOutcome = {\n            send: jest.fn().mockResolvedValue(undefined),\n            bindToRequest: jest.fn().mockResolvedValue(undefined),\n        };\n\n        expect(typeof outcome.send).toBe(\"function\");\n    });\n\n    it(\"should define bindToRequest method that returns Promise<void>\", () => {\n        const outcome: IOutcome = {\n            send: jest.fn().mockResolvedValue(undefined),\n            bindToRequest: jest.fn().mockResolvedValue(undefined),\n        };\n\n        expect(typeof outcome.bindToRequest).toBe(\"function\");\n    });\n\n    it(\"should allow custom IOutcome implementations\", async () => {\n        class CustomOutcome implements IOutcome {\n            public sentMessages: any[] = [];\n            public boundRequests: any[] = [];\n\n            async send(message: any): Promise<void> {\n                this.sentMessages.push(message);\n            }\n\n            async bindToRequest(request: any): Promise<void> {\n                this.boundRequests.push(request);\n            }\n        }\n\n        const outcome = new CustomOutcome();\n        await outcome.send({ test: \"message\" });\n        await outcome.bindToRequest({ requestId: \"123\" });\n\n        expect(outcome.sentMessages).toHaveLength(1);\n        expect(outcome.sentMessages[0]).toEqual({ test: \"message\" });\n        expect(outcome.boundRequests).toHaveLength(1);\n        expect(outcome.boundRequests[0]).toEqual({ requestId: \"123\" });\n    });\n});\n\ndescribe(\"SlackOutcome\", () => {\n    let consoleSpy: jest.SpyInstance;\n\n    beforeEach(() => {\n        consoleSpy = jest.spyOn(console, \"log\").mockImplementation();\n    });\n\n    afterEach(() => {\n        consoleSpy.mockRestore();\n    });\n\n    describe(\"constructor\", () => {\n        it(\"should create a SlackOutcome instance\", () => {\n            const outcome = new SlackOutcome();\n\n            expect(outcome).toBeInstanceOf(SlackOutcome);\n        });\n    });\n\n    describe(\"send()\", () => {\n        it(\"should log the message to console\", async () => {\n            const outcome = new SlackOutcome();\n            const message = { text: \"Hello, Slack!\" };\n\n            await outcome.send(message as any);\n\n            expect(consoleSpy).toHaveBeenCalledWith(\n                \"Sending message to Slack:\",\n                message\n            );\n        });\n\n        it(\"should return a resolved promise\", async () => {\n            const outcome = new SlackOutcome();\n\n            const result = outcome.send({ text: \"Test\" } as any);\n\n            expect(result).toBeInstanceOf(Promise);\n            await expect(result).resolves.toBeUndefined();\n        });\n\n        it(\"should handle async generator messages\", async () => {\n            const outcome = new SlackOutcome();\n\n            await outcome.send(createMockStreamer());\n\n            expect(consoleSpy).toHaveBeenCalled();\n        });\n    });\n\n    describe(\"bindToRequest()\", () => {\n        it(\"should log the request to console\", async () => {\n            const outcome = new SlackOutcome();\n            const request = { requestId: \"123\" };\n\n            await outcome.bindToRequest(request);\n\n            expect(consoleSpy).toHaveBeenCalledWith(\n                \"Binding request to Slack:\",\n                request\n            );\n        });\n\n        it(\"should return a resolved promise\", async () => {\n            const outcome = new SlackOutcome();\n\n            const result = outcome.bindToRequest({ test: \"data\" });\n\n            expect(result).toBeInstanceOf(Promise);\n            await expect(result).resolves.toBeUndefined();\n        });\n    });\n\n    describe(\"implements IOutcome\", () => {\n        it(\"should satisfy IOutcome interface\", () => {\n            const outcome: IOutcome = new SlackOutcome();\n\n            expect(typeof outcome.send).toBe(\"function\");\n            expect(typeof outcome.bindToRequest).toBe(\"function\");\n        });\n\n        it(\"should be usable as IOutcome\", async () => {\n            const outcome: IOutcome = new SlackOutcome();\n\n            await expect(outcome.send({ test: \"data\" } as any)).resolves.toBeUndefined();\n            await expect(outcome.bindToRequest({ test: \"data\" })).resolves.toBeUndefined();\n        });\n    });\n\n    describe(\"multiple sends\", () => {\n        it(\"should handle multiple sequential sends\", async () => {\n            const outcome = new SlackOutcome();\n\n            await outcome.send(\"First message\" as any);\n            await outcome.send(\"Second message\" as any);\n            await outcome.send(\"Third message\" as any);\n\n            expect(consoleSpy).toHaveBeenCalledTimes(3);\n            expect(consoleSpy).toHaveBeenNthCalledWith(\n                1,\n                \"Sending message to Slack:\",\n                \"First message\"\n            );\n            expect(consoleSpy).toHaveBeenNthCalledWith(\n                2,\n                \"Sending message to Slack:\",\n                \"Second message\"\n            );\n            expect(consoleSpy).toHaveBeenNthCalledWith(\n                3,\n                \"Sending message to Slack:\",\n                \"Third message\"\n            );\n        });\n\n        it(\"should handle concurrent sends\", async () => {\n            const outcome = new SlackOutcome();\n\n            await Promise.all([\n                outcome.send(\"Message 1\" as any),\n                outcome.send(\"Message 2\" as any),\n                outcome.send(\"Message 3\" as any),\n            ]);\n\n            expect(consoleSpy).toHaveBeenCalledTimes(3);\n        });\n    });\n});\n\ndescribe(\"StreamingOutcome\", () => {\n    let consoleSpy: jest.SpyInstance;\n\n    beforeEach(() => {\n        consoleSpy = jest.spyOn(console, \"log\").mockImplementation();\n    });\n\n    afterEach(() => {\n        consoleSpy.mockRestore();\n    });\n\n    describe(\"constructor\", () => {\n        it(\"should create a StreamingOutcome instance\", () => {\n            const outcome = new StreamingOutcome();\n\n            expect(outcome).toBeInstanceOf(StreamingOutcome);\n        });\n    });\n\n    describe(\"send()\", () => {\n        it(\"should log the message to console\", async () => {\n            const outcome = new StreamingOutcome();\n\n            await outcome.send(createMockStreamer());\n\n            expect(consoleSpy).toHaveBeenCalled();\n        });\n\n        it(\"should return a resolved promise\", async () => {\n            const outcome = new StreamingOutcome();\n\n            const result = outcome.send(createMockStreamer());\n\n            expect(result).toBeInstanceOf(Promise);\n            await expect(result).resolves.toBeUndefined();\n        });\n    });\n\n    describe(\"bindToRequest()\", () => {\n        it(\"should log the request to console\", async () => {\n            const outcome = new StreamingOutcome();\n            const request = { requestId: \"123\" };\n\n            await outcome.bindToRequest(request);\n\n            expect(consoleSpy).toHaveBeenCalledWith(\n                \"Binding request to Slack:\",\n                request\n            );\n        });\n\n        it(\"should return a resolved promise\", async () => {\n            const outcome = new StreamingOutcome();\n\n            const result = outcome.bindToRequest({ test: \"data\" });\n\n            expect(result).toBeInstanceOf(Promise);\n            await expect(result).resolves.toBeUndefined();\n        });\n    });\n\n    describe(\"implements IOutcome\", () => {\n        it(\"should satisfy IOutcome interface\", () => {\n            const outcome: IOutcome = new StreamingOutcome();\n\n            expect(typeof outcome.send).toBe(\"function\");\n            expect(typeof outcome.bindToRequest).toBe(\"function\");\n        });\n\n        it(\"should be usable as IOutcome\", async () => {\n            const outcome: IOutcome = new StreamingOutcome();\n\n            await expect(outcome.send(createMockStreamer())).resolves.toBeUndefined();\n            await expect(outcome.bindToRequest({ test: \"data\" })).resolves.toBeUndefined();\n        });\n    });\n});\n\ndescribe(\"IOutcome usage patterns\", () => {\n    it(\"should work with multiple outcome types\", async () => {\n        class EmailOutcome implements IOutcome {\n            public sent: any[] = [];\n            async send(message: any): Promise<void> {\n                this.sent.push({ type: \"email\", message });\n            }\n            async bindToRequest(_request: any): Promise<void> {}\n        }\n\n        class WebhookOutcome implements IOutcome {\n            public sent: any[] = [];\n            async send(message: any): Promise<void> {\n                this.sent.push({ type: \"webhook\", message });\n            }\n            async bindToRequest(_request: any): Promise<void> {}\n        }\n\n        const outcomes: IOutcome[] = [\n            new SlackOutcome(),\n            new EmailOutcome(),\n            new WebhookOutcome(),\n        ];\n\n        const message = { content: \"Test notification\" };\n\n        for (const outcome of outcomes) {\n            await outcome.send(message as any);\n        }\n\n        expect(outcomes.length).toBe(3);\n    });\n\n    it(\"should allow async operations in custom outcomes\", async () => {\n        class AsyncOutcome implements IOutcome {\n            public completed = false;\n\n            async send(_message: any): Promise<void> {\n                await new Promise((resolve) => setTimeout(resolve, 10));\n                this.completed = true;\n            }\n\n            async bindToRequest(_request: any): Promise<void> {}\n        }\n\n        const outcome = new AsyncOutcome();\n\n        expect(outcome.completed).toBe(false);\n        await outcome.send(\"async message\");\n        expect(outcome.completed).toBe(true);\n    });\n\n    it(\"should allow throwing outcomes for error handling\", async () => {\n        class FailingOutcome implements IOutcome {\n            async send(_message: any): Promise<void> {\n                throw new Error(\"Send failed\");\n            }\n            async bindToRequest(_request: any): Promise<void> {}\n        }\n\n        const outcome = new FailingOutcome();\n\n        await expect(outcome.send(\"test\")).rejects.toThrow(\"Send failed\");\n    });\n});\n\n"]}

package/dist/tests/secrets.test.d.ts

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

package/dist/tests/secrets.test.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const secrets_1 = require("../src/secrets");
+describe("ISecret interface", () => {
+    it("should define resolveSecret method that returns Promise<string>", () => {
+        const secret = {
+            resolveSecret: jest.fn().mockResolvedValue("secret-value"),
+        };
+        expect(typeof secret.resolveSecret).toBe("function");
+    });
+    it("should allow custom ISecret implementations", async () => {
+        class CustomSecret {
+            constructor(value) {
+                this.value = value;
+            }
+            async resolveSecret() {
+                return this.value;
+            }
+        }
+        const secret = new CustomSecret("my-custom-secret");
+        const resolved = await secret.resolveSecret();
+        expect(resolved).toBe("my-custom-secret");
+    });
+});
+describe("EnvSecret", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    describe("constructor", () => {
+        it("should create an EnvSecret with environment variable name", () => {
+            const secret = new secrets_1.EnvSecret("MY_API_KEY");
+            expect(secret.envVarName).toBe("MY_API_KEY");
+        });
+        it("should store the env var name as readonly", () => {
+            const secret = new secrets_1.EnvSecret("SECRET_KEY");
+            expect(secret.envVarName).toBe("SECRET_KEY");
+        });
+    });
+    describe("resolveSecret()", () => {
+        it("should return the value of the environment variable", async () => {
+            process.env.TEST_SECRET = "my-secret-value";
+            const secret = new secrets_1.EnvSecret("TEST_SECRET");
+            const result = await secret.resolveSecret();
+            expect(result).toBe("my-secret-value");
+        });
+        it("should return empty string if env var is not set", async () => {
+            delete process.env.NON_EXISTENT_VAR;
+            const secret = new secrets_1.EnvSecret("NON_EXISTENT_VAR");
+            const result = await secret.resolveSecret();
+            expect(result).toBe("");
+        });
+        it("should return empty string if env var is undefined", async () => {
+            process.env.UNDEFINED_VAR = undefined;
+            const secret = new secrets_1.EnvSecret("UNDEFINED_VAR");
+            const result = await secret.resolveSecret();
+            expect(result).toBe("");
+        });
+        it("should return actual empty string if env var is set to empty", async () => {
+            process.env.EMPTY_VAR = "";
+            const secret = new secrets_1.EnvSecret("EMPTY_VAR");
+            const result = await secret.resolveSecret();
+            expect(result).toBe("");
+        });
+        it("should handle special characters in env var values", async () => {
+            process.env.SPECIAL_CHARS = "secret!@#$%^&*()_+-=[]{}|;':\",./<>?";
+            const secret = new secrets_1.EnvSecret("SPECIAL_CHARS");
+            const result = await secret.resolveSecret();
+            expect(result).toBe("secret!@#$%^&*()_+-=[]{}|;':\",./<>?");
+        });
+        it("should handle long env var values", async () => {
+            const longValue = "a".repeat(10000);
+            process.env.LONG_VAR = longValue;
+            const secret = new secrets_1.EnvSecret("LONG_VAR");
+            const result = await secret.resolveSecret();
+            expect(result).toBe(longValue);
+        });
+        it("should resolve multiple times from the same instance", async () => {
+            process.env.REUSE_VAR = "initial-value";
+            const secret = new secrets_1.EnvSecret("REUSE_VAR");
+            const result1 = await secret.resolveSecret();
+            process.env.REUSE_VAR = "updated-value";
+            const result2 = await secret.resolveSecret();
+            expect(result1).toBe("initial-value");
+            expect(result2).toBe("updated-value");
+        });
+        it("should be async", () => {
+            process.env.ASYNC_TEST = "value";
+            const secret = new secrets_1.EnvSecret("ASYNC_TEST");
+            const result = secret.resolveSecret();
+            expect(result).toBeInstanceOf(Promise);
+        });
+    });
+    describe("implements ISecret", () => {
+        it("should satisfy ISecret interface", () => {
+            const secret = new secrets_1.EnvSecret("MY_VAR");
+            expect(typeof secret.resolveSecret).toBe("function");
+        });
+        it("should be usable as ISecret", async () => {
+            process.env.INTERFACE_VAR = "interface-value";
+            const secret = new secrets_1.EnvSecret("INTERFACE_VAR");
+            const result = await secret.resolveSecret();
+            expect(result).toBe("interface-value");
+        });
+    });
+});
+describe("Secret", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    describe("fromEnv()", () => {
+        it("should create an ISecret from environment variable name", () => {
+            const secret = secrets_1.Secret.fromEnv("MY_API_KEY");
+            expect(secret).toBeDefined();
+            expect(typeof secret.resolveSecret).toBe("function");
+        });
+        it("should return an EnvSecret instance", () => {
+            const secret = secrets_1.Secret.fromEnv("TEST_KEY");
+            expect(secret).toBeInstanceOf(secrets_1.EnvSecret);
+        });
+        it("should create a working secret that resolves env vars", async () => {
+            process.env.FROM_ENV_TEST = "test-secret-value";
+            const secret = secrets_1.Secret.fromEnv("FROM_ENV_TEST");
+            const result = await secret.resolveSecret();
+            expect(result).toBe("test-secret-value");
+        });
+        it("should create independent secret instances", () => {
+            const secret1 = secrets_1.Secret.fromEnv("VAR_1");
+            const secret2 = secrets_1.Secret.fromEnv("VAR_2");
+            expect(secret1).not.toBe(secret2);
+        });
+        it("should handle different env var names", async () => {
+            process.env.API_KEY = "api-key-value";
+            process.env.DB_PASSWORD = "db-password-value";
+            const apiSecret = secrets_1.Secret.fromEnv("API_KEY");
+            const dbSecret = secrets_1.Secret.fromEnv("DB_PASSWORD");
+            expect(await apiSecret.resolveSecret()).toBe("api-key-value");
+            expect(await dbSecret.resolveSecret()).toBe("db-password-value");
+        });
+        it("should return ISecret interface type", () => {
+            const secret = secrets_1.Secret.fromEnv("ANY_VAR");
+            expect(secret.resolveSecret).toBeDefined();
+        });
+    });
+    describe("integration patterns", () => {
+        it("should work with async/await pattern", async () => {
+            process.env.ASYNC_SECRET = "async-value";
+            const secret = secrets_1.Secret.fromEnv("ASYNC_SECRET");
+            const value = await secret.resolveSecret();
+            expect(value).toBe("async-value");
+        });
+        it("should work with Promise.then pattern", (done) => {
+            process.env.PROMISE_SECRET = "promise-value";
+            const secret = secrets_1.Secret.fromEnv("PROMISE_SECRET");
+            secret.resolveSecret().then((value) => {
+                expect(value).toBe("promise-value");
+                done();
+            });
+        });
+        it("should work with multiple concurrent resolutions", async () => {
+            process.env.CONCURRENT_1 = "value-1";
+            process.env.CONCURRENT_2 = "value-2";
+            process.env.CONCURRENT_3 = "value-3";
+            const secrets = [
+                secrets_1.Secret.fromEnv("CONCURRENT_1"),
+                secrets_1.Secret.fromEnv("CONCURRENT_2"),
+                secrets_1.Secret.fromEnv("CONCURRENT_3"),
+            ];
+            const results = await Promise.all(secrets.map((s) => s.resolveSecret()));
+            expect(results).toEqual(["value-1", "value-2", "value-3"]);
+        });
+    });
+});
+describe("ISecret custom implementations", () => {
+    it("should support file-based secrets", async () => {
+        class FileSecret {
+            constructor(content) {
+                this.content = content;
+            }
+            async resolveSecret() {
+                // Simulate file read
+                return this.content;
+            }
+        }
+        const secret = new FileSecret("file-based-secret");
+        const result = await secret.resolveSecret();
+        expect(result).toBe("file-based-secret");
+    });
+    it("should support vault-style secrets", async () => {
+        class VaultSecret {
+            constructor(path) {
+                this.path = path;
+                this.cached = null;
+            }
+            async resolveSecret() {
+                if (this.cached) {
+                    return this.cached;
+                }
+                // Simulate vault fetch
+                this.cached = `vault-secret-from-${this.path}`;
+                return this.cached;
+            }
+        }
+        const secret = new VaultSecret("secret/my-app/api-key");
+        const result = await secret.resolveSecret();
+        expect(result).toBe("vault-secret-from-secret/my-app/api-key");
+    });
+    it("should support caching secrets", async () => {
+        let fetchCount = 0;
+        class CachingSecret {
+            constructor() {
+                this.cached = null;
+            }
+            async resolveSecret() {
+                if (!this.cached) {
+                    fetchCount++;
+                    this.cached = "cached-value";
+                }
+                return this.cached;
+            }
+        }
+        const secret = new CachingSecret();
+        await secret.resolveSecret();
+        await secret.resolveSecret();
+        await secret.resolveSecret();
+        expect(fetchCount).toBe(1);
+    });
+    it("should support rotating secrets", async () => {
+        class RotatingSecret {
+            constructor() {
+                this.counter = 0;
+            }
+            async resolveSecret() {
+                return `rotating-secret-${this.counter++}`;
+            }
+        }
+        const secret = new RotatingSecret();
+        expect(await secret.resolveSecret()).toBe("rotating-secret-0");
+        expect(await secret.resolveSecret()).toBe("rotating-secret-1");
+        expect(await secret.resolveSecret()).toBe("rotating-secret-2");
+    });
+    it("should support async secrets with delays", async () => {
+        class DelayedSecret {
+            async resolveSecret() {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                return "delayed-secret";
+            }
+        }
+        const secret = new DelayedSecret();
+        const result = await secret.resolveSecret();
+        expect(result).toBe("delayed-secret");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secrets.test.js","sourceRoot":"","sources":["../../tests/secrets.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Secret, EnvSecret, ISecret } from \"../src/secrets\";\n\ndescribe(\"ISecret interface\", () => {\n    it(\"should define resolveSecret method that returns Promise<string>\", () => {\n        const secret: ISecret = {\n            resolveSecret: jest.fn().mockResolvedValue(\"secret-value\"),\n        };\n\n        expect(typeof secret.resolveSecret).toBe(\"function\");\n    });\n\n    it(\"should allow custom ISecret implementations\", async () => {\n        class CustomSecret implements ISecret {\n            constructor(private value: string) {}\n\n            async resolveSecret(): Promise<string> {\n                return this.value;\n            }\n        }\n\n        const secret = new CustomSecret(\"my-custom-secret\");\n        const resolved = await secret.resolveSecret();\n\n        expect(resolved).toBe(\"my-custom-secret\");\n    });\n});\n\ndescribe(\"EnvSecret\", () => {\n    const originalEnv = process.env;\n\n    beforeEach(() => {\n        jest.resetModules();\n        process.env = { ...originalEnv };\n    });\n\n    afterAll(() => {\n        process.env = originalEnv;\n    });\n\n    describe(\"constructor\", () => {\n        it(\"should create an EnvSecret with environment variable name\", () => {\n            const secret = new EnvSecret(\"MY_API_KEY\");\n\n            expect(secret.envVarName).toBe(\"MY_API_KEY\");\n        });\n\n        it(\"should store the env var name as readonly\", () => {\n            const secret = new EnvSecret(\"SECRET_KEY\");\n\n            expect(secret.envVarName).toBe(\"SECRET_KEY\");\n        });\n    });\n\n    describe(\"resolveSecret()\", () => {\n        it(\"should return the value of the environment variable\", async () => {\n            process.env.TEST_SECRET = \"my-secret-value\";\n            const secret = new EnvSecret(\"TEST_SECRET\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(\"my-secret-value\");\n        });\n\n        it(\"should return empty string if env var is not set\", async () => {\n            delete process.env.NON_EXISTENT_VAR;\n            const secret = new EnvSecret(\"NON_EXISTENT_VAR\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(\"\");\n        });\n\n        it(\"should return empty string if env var is undefined\", async () => {\n            process.env.UNDEFINED_VAR = undefined as any;\n            const secret = new EnvSecret(\"UNDEFINED_VAR\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(\"\");\n        });\n\n        it(\"should return actual empty string if env var is set to empty\", async () => {\n            process.env.EMPTY_VAR = \"\";\n            const secret = new EnvSecret(\"EMPTY_VAR\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(\"\");\n        });\n\n        it(\"should handle special characters in env var values\", async () => {\n            process.env.SPECIAL_CHARS = \"secret!@#$%^&*()_+-=[]{}|;':\\\",./<>?\";\n            const secret = new EnvSecret(\"SPECIAL_CHARS\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(\"secret!@#$%^&*()_+-=[]{}|;':\\\",./<>?\");\n        });\n\n        it(\"should handle long env var values\", async () => {\n            const longValue = \"a\".repeat(10000);\n            process.env.LONG_VAR = longValue;\n            const secret = new EnvSecret(\"LONG_VAR\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(longValue);\n        });\n\n        it(\"should resolve multiple times from the same instance\", async () => {\n            process.env.REUSE_VAR = \"initial-value\";\n            const secret = new EnvSecret(\"REUSE_VAR\");\n\n            const result1 = await secret.resolveSecret();\n            process.env.REUSE_VAR = \"updated-value\";\n            const result2 = await secret.resolveSecret();\n\n            expect(result1).toBe(\"initial-value\");\n            expect(result2).toBe(\"updated-value\");\n        });\n\n        it(\"should be async\", () => {\n            process.env.ASYNC_TEST = \"value\";\n            const secret = new EnvSecret(\"ASYNC_TEST\");\n\n            const result = secret.resolveSecret();\n\n            expect(result).toBeInstanceOf(Promise);\n        });\n    });\n\n    describe(\"implements ISecret\", () => {\n        it(\"should satisfy ISecret interface\", () => {\n            const secret: ISecret = new EnvSecret(\"MY_VAR\");\n\n            expect(typeof secret.resolveSecret).toBe(\"function\");\n        });\n\n        it(\"should be usable as ISecret\", async () => {\n            process.env.INTERFACE_VAR = \"interface-value\";\n            const secret: ISecret = new EnvSecret(\"INTERFACE_VAR\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(\"interface-value\");\n        });\n    });\n});\n\ndescribe(\"Secret\", () => {\n    const originalEnv = process.env;\n\n    beforeEach(() => {\n        jest.resetModules();\n        process.env = { ...originalEnv };\n    });\n\n    afterAll(() => {\n        process.env = originalEnv;\n    });\n\n    describe(\"fromEnv()\", () => {\n        it(\"should create an ISecret from environment variable name\", () => {\n            const secret = Secret.fromEnv(\"MY_API_KEY\");\n\n            expect(secret).toBeDefined();\n            expect(typeof secret.resolveSecret).toBe(\"function\");\n        });\n\n        it(\"should return an EnvSecret instance\", () => {\n            const secret = Secret.fromEnv(\"TEST_KEY\");\n\n            expect(secret).toBeInstanceOf(EnvSecret);\n        });\n\n        it(\"should create a working secret that resolves env vars\", async () => {\n            process.env.FROM_ENV_TEST = \"test-secret-value\";\n            const secret = Secret.fromEnv(\"FROM_ENV_TEST\");\n\n            const result = await secret.resolveSecret();\n\n            expect(result).toBe(\"test-secret-value\");\n        });\n\n        it(\"should create independent secret instances\", () => {\n            const secret1 = Secret.fromEnv(\"VAR_1\");\n            const secret2 = Secret.fromEnv(\"VAR_2\");\n\n            expect(secret1).not.toBe(secret2);\n        });\n\n        it(\"should handle different env var names\", async () => {\n            process.env.API_KEY = \"api-key-value\";\n            process.env.DB_PASSWORD = \"db-password-value\";\n\n            const apiSecret = Secret.fromEnv(\"API_KEY\");\n            const dbSecret = Secret.fromEnv(\"DB_PASSWORD\");\n\n            expect(await apiSecret.resolveSecret()).toBe(\"api-key-value\");\n            expect(await dbSecret.resolveSecret()).toBe(\"db-password-value\");\n        });\n\n        it(\"should return ISecret interface type\", () => {\n            const secret: ISecret = Secret.fromEnv(\"ANY_VAR\");\n\n            expect(secret.resolveSecret).toBeDefined();\n        });\n    });\n\n    describe(\"integration patterns\", () => {\n        it(\"should work with async/await pattern\", async () => {\n            process.env.ASYNC_SECRET = \"async-value\";\n            const secret = Secret.fromEnv(\"ASYNC_SECRET\");\n\n            const value = await secret.resolveSecret();\n\n            expect(value).toBe(\"async-value\");\n        });\n\n        it(\"should work with Promise.then pattern\", (done) => {\n            process.env.PROMISE_SECRET = \"promise-value\";\n            const secret = Secret.fromEnv(\"PROMISE_SECRET\");\n\n            secret.resolveSecret().then((value) => {\n                expect(value).toBe(\"promise-value\");\n                done();\n            });\n        });\n\n        it(\"should work with multiple concurrent resolutions\", async () => {\n            process.env.CONCURRENT_1 = \"value-1\";\n            process.env.CONCURRENT_2 = \"value-2\";\n            process.env.CONCURRENT_3 = \"value-3\";\n\n            const secrets = [\n                Secret.fromEnv(\"CONCURRENT_1\"),\n                Secret.fromEnv(\"CONCURRENT_2\"),\n                Secret.fromEnv(\"CONCURRENT_3\"),\n            ];\n\n            const results = await Promise.all(\n                secrets.map((s) => s.resolveSecret())\n            );\n\n            expect(results).toEqual([\"value-1\", \"value-2\", \"value-3\"]);\n        });\n    });\n});\n\ndescribe(\"ISecret custom implementations\", () => {\n    it(\"should support file-based secrets\", async () => {\n        class FileSecret implements ISecret {\n            constructor(private content: string) {}\n\n            async resolveSecret(): Promise<string> {\n                // Simulate file read\n                return this.content;\n            }\n        }\n\n        const secret: ISecret = new FileSecret(\"file-based-secret\");\n        const result = await secret.resolveSecret();\n\n        expect(result).toBe(\"file-based-secret\");\n    });\n\n    it(\"should support vault-style secrets\", async () => {\n        class VaultSecret implements ISecret {\n            private cached: string | null = null;\n\n            constructor(private path: string) {}\n\n            async resolveSecret(): Promise<string> {\n                if (this.cached) {\n                    return this.cached;\n                }\n                // Simulate vault fetch\n                this.cached = `vault-secret-from-${this.path}`;\n                return this.cached;\n            }\n        }\n\n        const secret: ISecret = new VaultSecret(\"secret/my-app/api-key\");\n        const result = await secret.resolveSecret();\n\n        expect(result).toBe(\"vault-secret-from-secret/my-app/api-key\");\n    });\n\n    it(\"should support caching secrets\", async () => {\n        let fetchCount = 0;\n\n        class CachingSecret implements ISecret {\n            private cached: string | null = null;\n\n            async resolveSecret(): Promise<string> {\n                if (!this.cached) {\n                    fetchCount++;\n                    this.cached = \"cached-value\";\n                }\n                return this.cached;\n            }\n        }\n\n        const secret: ISecret = new CachingSecret();\n\n        await secret.resolveSecret();\n        await secret.resolveSecret();\n        await secret.resolveSecret();\n\n        expect(fetchCount).toBe(1);\n    });\n\n    it(\"should support rotating secrets\", async () => {\n        class RotatingSecret implements ISecret {\n            private counter = 0;\n\n            async resolveSecret(): Promise<string> {\n                return `rotating-secret-${this.counter++}`;\n            }\n        }\n\n        const secret: ISecret = new RotatingSecret();\n\n        expect(await secret.resolveSecret()).toBe(\"rotating-secret-0\");\n        expect(await secret.resolveSecret()).toBe(\"rotating-secret-1\");\n        expect(await secret.resolveSecret()).toBe(\"rotating-secret-2\");\n    });\n\n    it(\"should support async secrets with delays\", async () => {\n        class DelayedSecret implements ISecret {\n            async resolveSecret(): Promise<string> {\n                await new Promise((resolve) => setTimeout(resolve, 10));\n                return \"delayed-secret\";\n            }\n        }\n\n        const secret: ISecret = new DelayedSecret();\n        const result = await secret.resolveSecret();\n\n        expect(result).toBe(\"delayed-secret\");\n    });\n});\n\n\n\n\n"]}

package/dist/tests/server/http.test.d.ts

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