@soapjs/soap-auth 0.4.0 → 1.0.0

package/build/strategies/oauth2/__tests__/oauth2.strategy.test.js

@@ -1,239 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const oauth2_strategy_1 = require("../oauth2.strategy");
-const oauth2_errors_1 = require("../oauth2.errors");
-const errors_1 = require("../../../errors");
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockFetchOk(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        statusText: "OK",
-        json: async () => body,
-    });
-}
-function mockFetchFail(status = 400) {
-    mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status,
-        statusText: "Bad Request",
-        json: async () => ({}),
-    });
-}
-class TestOAuth2Strategy extends oauth2_strategy_1.OAuth2Strategy {
-    name = "test-oauth2";
-    async extractAccessToken(ctx) {
-        return ctx.tokens.access;
-    }
-    async extractRefreshToken(ctx) {
-        return ctx.tokens.refresh;
-    }
-    async storeAccessToken(token, ctx) {
-        ctx.tokens.access = token;
-    }
-    async storeRefreshToken(token, ctx) {
-        ctx.tokens.refresh = token;
-    }
-    embedAccessToken(token, ctx) {
-        ctx.tokens.access = token;
-    }
-    embedRefreshToken(token, ctx) {
-        ctx.tokens.refresh = token;
-    }
-    extractAuthorizationCode(ctx) {
-        return ctx.query.code ?? null;
-    }
-    redirectUser(ctx, url) {
-        ctx.redirectTo = url;
-    }
-}
-const baseConfig = {
-    clientId: "client-id",
-    clientSecret: "client-secret",
-    redirectUri: "https://example.com/callback",
-    grantType: "authorization_code",
-    scope: ["openid", "email"],
-    endpoints: {
-        authorizationUrl: "https://provider.example/auth",
-        tokenUrl: "https://provider.example/token",
-        userInfoUrl: "https://provider.example/userinfo",
-    },
-    routes: {
-        login: { path: "/login", method: "GET" },
-        callback: { path: "/callback", method: "GET" },
-    },
-    user: {
-        fetchUser: jest.fn(),
-        validateUser: jest.fn(async (p) => ({ id: p.sub ?? p.id, email: p.email })),
-    },
-};
-function makeCtx(overrides = {}) {
-    return { tokens: {}, query: {}, ...overrides };
-}
-describe("OAuth2Strategy — state / CSRF", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("validateState passes when stored === returned state", async () => {
-        let stored = "csrf-abc";
-        const config = {
-            ...baseConfig,
-            state: {
-                persistence: {
-                    store: jest.fn(async (s) => { stored = s; }),
-                    read: jest.fn(async () => stored),
-                    remove: jest.fn(async () => { stored = null; }),
-                },
-            },
-        };
-        const strategy = new TestOAuth2Strategy(config);
-        const ctx = makeCtx({ query: { code: "auth-code", state: "csrf-abc" } });
-        await expect(strategy.validateState(ctx)).resolves.toBeUndefined();
-        expect(config.state.persistence.remove).toHaveBeenCalled();
-    });
-    it("validateState throws InvalidStateError on mismatch", async () => {
-        const config = {
-            ...baseConfig,
-            state: {
-                persistence: {
-                    read: jest.fn(async () => "stored-state"),
-                    remove: jest.fn(),
-                },
-            },
-        };
-        const strategy = new TestOAuth2Strategy(config);
-        const ctx = makeCtx({ query: { state: "wrong-state" } });
-        await expect(strategy.validateState(ctx)).rejects.toThrow(oauth2_errors_1.InvalidStateError);
-    });
-    it("validateState is a no-op when config.state is absent", async () => {
-        const strategy = new TestOAuth2Strategy({ ...baseConfig, state: undefined });
-        await expect(strategy.validateState(makeCtx())).resolves.toBeUndefined();
-    });
-    it("startAuthorizationFlow generates state, stores it, and redirects", async () => {
-        const stored = [];
-        const config = {
-            ...baseConfig,
-            state: {
-                generateState: jest.fn(async () => "gen-state"),
-                persistence: {
-                    store: jest.fn(async (s) => stored.push(s)),
-                },
-            },
-        };
-        const strategy = new TestOAuth2Strategy(config);
-        const ctx = makeCtx();
-        await strategy.startAuthorizationFlow(ctx);
-        expect(stored).toContain("gen-state");
-        expect(ctx.redirectTo).toContain("https://provider.example/auth");
-        expect(ctx.redirectTo).toContain("state=gen-state");
-    });
-});
-describe("OAuth2Strategy — buildAuthorizationUrl", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("includes client_id, redirect_uri, response_type, scope", async () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const url = await strategy.buildAuthorizationUrl(makeCtx());
-        expect(url).toContain("client_id=client-id");
-        expect(url).toContain("redirect_uri=");
-        expect(url).toContain("response_type=code");
-        expect(url).toContain("scope=openid+email");
-    });
-    it("embeds state when provided", async () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const url = await strategy.buildAuthorizationUrl(makeCtx(), "my-state");
-        expect(url).toContain("state=my-state");
-    });
-    it("embeds nonce when provided", async () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const url = await strategy.buildAuthorizationUrl(makeCtx(), undefined, "my-nonce");
-        expect(url).toContain("nonce=my-nonce");
-    });
-});
-describe("OAuth2Strategy — verifyAuthorizationCode", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("does nothing when code is present", async () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const ctx = makeCtx();
-        await expect(strategy.verifyAuthorizationCode(ctx, "valid-code")).resolves.toBeUndefined();
-    });
-    it("redirects and throws MissingAuthorizationCodeError when code is absent", async () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const ctx = makeCtx();
-        await expect(strategy.verifyAuthorizationCode(ctx, null)).rejects.toThrow(errors_1.MissingAuthorizationCodeError);
-        expect(ctx.redirectTo).toBeDefined();
-    });
-});
-describe("OAuth2Strategy — exchangeCodeForToken", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("sends correct POST body and returns tokens", async () => {
-        mockFetchOk({ access_token: "at-123", refresh_token: "rt-456" });
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const result = await strategy.exchangeCodeForToken(makeCtx(), "auth-code");
-        expect(result.accessToken).toBe("at-123");
-        expect(result.refreshToken).toBe("rt-456");
-        expect(mockFetch).toHaveBeenCalledWith("https://provider.example/token", expect.objectContaining({ method: "POST" }));
-    });
-    it("throws when token endpoint returns non-ok status", async () => {
-        mockFetchFail(401);
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        await expect(strategy.exchangeCodeForToken(makeCtx(), "bad-code")).rejects.toThrow();
-    });
-});
-describe("OAuth2Strategy — isTokenExpired", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("returns false for non-JWT tokens", () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        expect(strategy.isTokenExpired("opaque-token")).toBe(false);
-    });
-    it("returns true for an expired JWT", () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const pastExp = Math.floor(Date.now() / 1000) - 3600;
-        const payload = Buffer.from(JSON.stringify({ exp: pastExp })).toString("base64");
-        const jwt = `header.${payload}.sig`;
-        expect(strategy.isTokenExpired(jwt)).toBe(true);
-    });
-    it("returns false for a non-expired JWT", () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const futureExp = Math.floor(Date.now() / 1000) + 3600;
-        const payload = Buffer.from(JSON.stringify({ exp: futureExp })).toString("base64");
-        const jwt = `header.${payload}.sig`;
-        expect(strategy.isTokenExpired(jwt)).toBe(false);
-    });
-    it("returns false when JWT payload has no exp", () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const payload = Buffer.from(JSON.stringify({ sub: "user" })).toString("base64");
-        const jwt = `header.${payload}.sig`;
-        expect(strategy.isTokenExpired(jwt)).toBe(false);
-    });
-});
-describe("OAuth2Strategy — authenticate", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("exchanges code and returns AuthResult when no token in context", async () => {
-        let stored = "state-xyz";
-        const config = {
-            ...baseConfig,
-            state: {
-                persistence: {
-                    read: jest.fn(async () => stored),
-                    remove: jest.fn(async () => { stored = null; }),
-                },
-            },
-        };
-        const strategy = new TestOAuth2Strategy(config);
-        mockFetchOk({ access_token: "at-new", refresh_token: "rt-new" });
-        mockFetchOk({ sub: "u1", email: "user@example.com" });
-        const ctx = makeCtx({ query: { code: "auth-code", state: "state-xyz" } });
-        const result = await strategy.authenticate(ctx);
-        expect(result?.user).toMatchObject({ id: "u1", email: "user@example.com" });
-        expect(result?.tokens?.accessToken).toBe("at-new");
-    });
-    it("fetches user when valid access token already in context", async () => {
-        const strategy = new TestOAuth2Strategy(baseConfig);
-        const futureExp = Math.floor(Date.now() / 1000) + 3600;
-        const payload = Buffer.from(JSON.stringify({ exp: futureExp })).toString("base64");
-        const validJwt = `h.${payload}.s`;
-        mockFetchOk({ sub: "u2", email: "other@example.com" });
-        const ctx = makeCtx({ tokens: { access: validJwt } });
-        const result = await strategy.authenticate(ctx);
-        expect(result?.user).toMatchObject({ id: "u2" });
-    });
-});

package/build/strategies/oauth2/providers/__tests__/social-providers.test.d.ts

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

package/build/strategies/oauth2/providers/__tests__/social-providers.test.js

@@ -1,201 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const google_strategy_1 = require("../google.strategy");
-const github_strategy_1 = require("../github.strategy");
-const facebook_strategy_1 = require("../facebook.strategy");
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-const baseConfig = {
-    clientId: "client-id",
-    clientSecret: "client-secret",
-    redirectUri: "https://example.com/callback",
-};
-function makeMockCtx() {
-    return {
-        req: {
-            method: "GET",
-            path: "/callback",
-            headers: { authorization: "Bearer test-token" },
-            query: { code: "auth-code", state: "csrf-state" },
-            cookies: {},
-        },
-        res: {
-            status: jest.fn().mockReturnThis(),
-            json: jest.fn().mockReturnThis(),
-            setHeader: jest.fn().mockReturnThis(),
-            cookie: jest.fn().mockReturnThis(),
-            redirect: jest.fn(),
-        },
-        next: jest.fn(),
-    };
-}
-function mockFetchOk(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => body,
-    });
-}
-describe("GoogleStrategy", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("has name 'google'", () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        expect(strategy.name).toBe("google");
-    });
-    it("maps Google profile to AuthUser", async () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const googleProfile = {
-            sub: "google-sub-123",
-            email: "user@gmail.com",
-            name: "Test User",
-            picture: "https://example.com/pic.jpg",
-            email_verified: true,
-        };
-        mockFetchOk(googleProfile);
-        const user = await strategy.fetchUser("test-access-token");
-        expect(user).toMatchObject({
-            id: "google-sub-123",
-            email: "user@gmail.com",
-            username: "Test User",
-            picture: "https://example.com/pic.jpg",
-            emailVerified: true,
-        });
-    });
-    it("calls validateUser when provided", async () => {
-        const validateUser = jest.fn().mockResolvedValue({ id: "custom-id", email: "x@x.com" });
-        const strategy = new google_strategy_1.GoogleStrategy({ ...baseConfig, user: { fetchUser: jest.fn(), validateUser } });
-        mockFetchOk({ sub: "sub123", email: "raw@gmail.com" });
-        const user = await strategy.fetchUser("token");
-        expect(validateUser).toHaveBeenCalledWith(expect.objectContaining({ sub: "sub123" }));
-        expect(user).toMatchObject({ id: "custom-id" });
-    });
-    it("returns null when fetch fails", async () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        mockFetch.mockResolvedValueOnce({ ok: false, status: 401 });
-        const user = await strategy.fetchUser("bad-token");
-        expect(user).toBeNull();
-    });
-    it("uses openid+email+profile scope by default", () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        expect(strategy.config.scope).toContain("openid");
-    });
-    it("respects custom scope", () => {
-        const strategy = new google_strategy_1.GoogleStrategy({ ...baseConfig, scope: ["openid"] });
-        expect(strategy.config.scope).toEqual(["openid"]);
-    });
-});
-describe("GitHubStrategy", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("has name 'github'", () => {
-        expect(new github_strategy_1.GitHubStrategy(baseConfig).name).toBe("github");
-    });
-    it("maps GitHub profile to AuthUser", async () => {
-        const strategy = new github_strategy_1.GitHubStrategy(baseConfig);
-        mockFetchOk({
-            id: 12345,
-            login: "octocat",
-            email: "octocat@github.com",
-            name: "The Octocat",
-            avatar_url: "https://github.com/avatar.png",
-        });
-        const user = await strategy.fetchUser("token");
-        expect(user).toMatchObject({
-            id: 12345,
-            email: "octocat@github.com",
-            username: "octocat",
-            name: "The Octocat",
-            avatarUrl: "https://github.com/avatar.png",
-        });
-    });
-    it("returns null when fetch fails", async () => {
-        const strategy = new github_strategy_1.GitHubStrategy(baseConfig);
-        mockFetch.mockResolvedValueOnce({ ok: false, status: 403 });
-        expect(await strategy.fetchUser("bad")).toBeNull();
-    });
-});
-describe("FacebookStrategy", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("has name 'facebook'", () => {
-        expect(new facebook_strategy_1.FacebookStrategy(baseConfig).name).toBe("facebook");
-    });
-    it("maps Facebook profile to AuthUser", async () => {
-        const strategy = new facebook_strategy_1.FacebookStrategy(baseConfig);
-        mockFetchOk({
-            id: "fb-id-456",
-            name: "FB User",
-            email: "fb@facebook.com",
-            picture: { data: { url: "https://fb.com/pic.jpg" } },
-        });
-        const user = await strategy.fetchUser("token");
-        expect(user).toMatchObject({
-            id: "fb-id-456",
-            email: "fb@facebook.com",
-            username: "FB User",
-            picture: "https://fb.com/pic.jpg",
-        });
-    });
-    it("returns null on Facebook API error", async () => {
-        const strategy = new facebook_strategy_1.FacebookStrategy(baseConfig);
-        mockFetchOk({ error: { message: "Invalid token", code: 190 } });
-        expect(await strategy.fetchUser("token")).toBeNull();
-    });
-    it("returns null when fetch fails", async () => {
-        const strategy = new facebook_strategy_1.FacebookStrategy(baseConfig);
-        mockFetch.mockResolvedValueOnce({ ok: false, status: 401 });
-        expect(await strategy.fetchUser("bad")).toBeNull();
-    });
-});
-describe("HttpOAuth2Strategy — HTTP plumbing", () => {
-    afterEach(() => jest.clearAllMocks());
-    it("extracts access token from Authorization header", async () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        const token = await strategy.extractAccessToken(ctx);
-        expect(token).toBe("test-token");
-    });
-    it("extracts access token from cookie when no header", async () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        ctx.req.headers = {};
-        ctx.req.cookies = { access_token: "cookie-token" };
-        const token = await strategy.extractAccessToken(ctx);
-        expect(token).toBe("cookie-token");
-    });
-    it("extracts refresh token from cookie", async () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        ctx.req.cookies = { refresh_token: "rt-abc" };
-        const rt = await strategy.extractRefreshToken(ctx);
-        expect(rt).toBe("rt-abc");
-    });
-    it("extracts authorization code from query", () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        expect(strategy.extractAuthorizationCode(ctx)).toBe("auth-code");
-    });
-    it("embeds access token as Authorization header", () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        strategy.embedAccessToken("new-token", ctx);
-        expect(ctx.res.setHeader).toHaveBeenCalledWith("Authorization", "Bearer new-token");
-    });
-    it("embeds refresh token as httpOnly cookie", () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        strategy.embedRefreshToken("rt-new", ctx);
-        expect(ctx.res.cookie).toHaveBeenCalledWith("refresh_token", "rt-new", expect.objectContaining({ httpOnly: true, secure: true }));
-    });
-    it("redirects via res.redirect when available", () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        strategy.redirectUser(ctx, "https://accounts.google.com/auth");
-        expect(ctx.res.redirect).toHaveBeenCalledWith("https://accounts.google.com/auth");
-    });
-    it("falls back to Location header when res.redirect is missing", () => {
-        const strategy = new google_strategy_1.GoogleStrategy(baseConfig);
-        const ctx = makeMockCtx();
-        delete ctx.res.redirect;
-        strategy.redirectUser(ctx, "https://accounts.google.com/auth");
-        expect(ctx.res.setHeader).toHaveBeenCalledWith("Location", "https://accounts.google.com/auth");
-        expect(ctx.res.status).toHaveBeenCalledWith(302);
-    });
-});

package/build/utils/__tests__/validation.test.d.ts

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

package/build/utils/__tests__/validation.test.js

@@ -1,181 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validation_1 = require("../validation");
-describe("ValidationUtils", () => {
-    describe("required", () => {
-        it("should not throw for valid values", () => {
-            expect(() => validation_1.ValidationUtils.required("test", "field")).not.toThrow();
-            expect(() => validation_1.ValidationUtils.required(0, "field")).not.toThrow();
-            expect(() => validation_1.ValidationUtils.required(false, "field")).not.toThrow();
-            expect(() => validation_1.ValidationUtils.required([], "field")).not.toThrow();
-            expect(() => validation_1.ValidationUtils.required({}, "field")).not.toThrow();
-        });
-        it("should throw ValidationError for null or undefined", () => {
-            expect(() => validation_1.ValidationUtils.required(null, "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.required(undefined, "field")).toThrow(validation_1.ValidationError);
-        });
-        it("should include field name in error message", () => {
-            expect(() => validation_1.ValidationUtils.required(null, "testField")).toThrow("testField is required");
-        });
-    });
-    describe("nonEmptyString", () => {
-        it("should return trimmed string for valid input", () => {
-            expect(validation_1.ValidationUtils.nonEmptyString("  test  ", "field")).toBe("test");
-        });
-        it("should throw for non-string input", () => {
-            expect(() => validation_1.ValidationUtils.nonEmptyString(123, "field")).toThrow(validation_1.ValidationError);
-        });
-        it("should throw for empty string", () => {
-            expect(() => validation_1.ValidationUtils.nonEmptyString("", "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.nonEmptyString("   ", "field")).toThrow(validation_1.ValidationError);
-        });
-        it("should throw for null or undefined", () => {
-            expect(() => validation_1.ValidationUtils.nonEmptyString(null, "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.nonEmptyString(undefined, "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("email", () => {
-        it("should return email for valid input", () => {
-            expect(validation_1.ValidationUtils.email("test@example.com", "field")).toBe("test@example.com");
-        });
-        it("should throw for invalid email format", () => {
-            expect(() => validation_1.ValidationUtils.email("invalid-email", "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.email("@example.com", "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.email("test@", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("password", () => {
-        it("should return password for valid input", () => {
-            expect(validation_1.ValidationUtils.password("password123", "field")).toBe("password123");
-        });
-        it("should throw for short password", () => {
-            expect(() => validation_1.ValidationUtils.password("short", "field", 8)).toThrow(validation_1.ValidationError);
-        });
-        it("should use default minimum length", () => {
-            expect(() => validation_1.ValidationUtils.password("short", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("positiveNumber", () => {
-        it("should return number for valid input", () => {
-            expect(validation_1.ValidationUtils.positiveNumber(5, "field")).toBe(5);
-            expect(validation_1.ValidationUtils.positiveNumber("10", "field")).toBe(10);
-        });
-        it("should throw for non-positive numbers", () => {
-            expect(() => validation_1.ValidationUtils.positiveNumber(0, "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.positiveNumber(-1, "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.positiveNumber("abc", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("range", () => {
-        it("should return number within range", () => {
-            expect(validation_1.ValidationUtils.range(5, "field", 1, 10)).toBe(5);
-        });
-        it("should throw for numbers outside range", () => {
-            expect(() => validation_1.ValidationUtils.range(0, "field", 1, 10)).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.range(11, "field", 1, 10)).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("oneOf", () => {
-        it("should return value if it's in allowed values", () => {
-            expect(validation_1.ValidationUtils.oneOf("test", "field", ["test", "other"])).toBe("test");
-        });
-        it("should throw if value is not in allowed values", () => {
-            expect(() => validation_1.ValidationUtils.oneOf("invalid", "field", ["test", "other"])).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("url", () => {
-        it("should return URL for valid input", () => {
-            expect(validation_1.ValidationUtils.url("https://example.com", "field")).toBe("https://example.com");
-        });
-        it("should throw for invalid URL", () => {
-            expect(() => validation_1.ValidationUtils.url("not-a-url", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("jwtToken", () => {
-        it("should return token for valid JWT format", () => {
-            const token = "header.payload.signature";
-            expect(validation_1.ValidationUtils.jwtToken(token, "field")).toBe(token);
-        });
-        it("should throw for invalid JWT format", () => {
-            expect(() => validation_1.ValidationUtils.jwtToken("invalid", "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.jwtToken("header.payload", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("uuid", () => {
-        it("should return UUID for valid input", () => {
-            const uuid = "123e4567-e89b-12d3-a456-426614174000";
-            expect(validation_1.ValidationUtils.uuid(uuid, "field")).toBe(uuid);
-        });
-        it("should throw for invalid UUID", () => {
-            expect(() => validation_1.ValidationUtils.uuid("not-a-uuid", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("object", () => {
-        it("should return object for valid input", () => {
-            const obj = { test: "value" };
-            expect(validation_1.ValidationUtils.object(obj, "field")).toBe(obj);
-        });
-        it("should throw for non-object input", () => {
-            expect(() => validation_1.ValidationUtils.object("string", "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.object([], "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("array", () => {
-        it("should return array for valid input", () => {
-            const arr = [1, 2, 3];
-            expect(validation_1.ValidationUtils.array(arr, "field")).toBe(arr);
-        });
-        it("should throw for non-array input", () => {
-            expect(() => validation_1.ValidationUtils.array("string", "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.array({}, "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("function", () => {
-        it("should return function for valid input", () => {
-            const fn = () => { };
-            expect(validation_1.ValidationUtils.function(fn, "field")).toBe(fn);
-        });
-        it("should throw for non-function input", () => {
-            expect(() => validation_1.ValidationUtils.function("string", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("validateConfig", () => {
-        it("should not throw for valid config", () => {
-            const config = { field1: "value1", field2: "value2" };
-            expect(() => validation_1.ValidationUtils.validateConfig(config, ["field1", "field2"])).not.toThrow();
-        });
-        it("should throw for missing required fields", () => {
-            const config = { field1: "value1" };
-            expect(() => validation_1.ValidationUtils.validateConfig(config, ["field1", "field2"])).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("pattern", () => {
-        it("should return string for matching pattern", () => {
-            const regex = /^[a-z]+$/;
-            expect(validation_1.ValidationUtils.pattern("test", "field", regex)).toBe("test");
-        });
-        it("should throw for non-matching pattern", () => {
-            const regex = /^[a-z]+$/;
-            expect(() => validation_1.ValidationUtils.pattern("TEST", "field", regex)).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("date", () => {
-        it("should return Date for valid input", () => {
-            const date = validation_1.ValidationUtils.date("2023-01-01", "field");
-            expect(date).toBeInstanceOf(Date);
-        });
-        it("should throw for invalid date", () => {
-            expect(() => validation_1.ValidationUtils.date("invalid-date", "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-    describe("boolean", () => {
-        it("should return boolean for valid input", () => {
-            expect(validation_1.ValidationUtils.boolean(true, "field")).toBe(true);
-            expect(validation_1.ValidationUtils.boolean(false, "field")).toBe(false);
-        });
-        it("should throw for non-boolean input", () => {
-            expect(() => validation_1.ValidationUtils.boolean("true", "field")).toThrow(validation_1.ValidationError);
-            expect(() => validation_1.ValidationUtils.boolean(1, "field")).toThrow(validation_1.ValidationError);
-        });
-    });
-});

package/jest.config.unit.json

@@ -1,10 +0,0 @@
-{
-  "preset": "ts-jest",
-  "testEnvironment": "node",
-  "clearMocks": true,
-  "collectCoverage": true,
-  "coverageDirectory": "coverage",
-  "coverageProvider": "v8",
-  "testMatch": ["**/__tests__/**/*.test.ts"],
-  "testTimeout": 10000
-}