@discover-cloud/shared 1.0.0

package/dist/internal/internal-jwt.service.d.ts

@@ -0,0 +1,13 @@
+import { InternalKeyManager } from "./internal-key-manager";
+import { InternalJwtPayload } from "./internal-jwt.types";
+export declare class InternalJwtService {
+    private readonly keyManager;
+    private readonly serviceName;
+    private jwksCache;
+    constructor(keyManager: InternalKeyManager);
+    sign(payload: {
+        requestId: string;
+    }, targetService: string): Promise<string>;
+    verify(token: string): Promise<InternalJwtPayload>;
+    private getRemoteJWKS;
+}

package/dist/internal/internal-jwt.service.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalJwtService = void 0;
+const jose = __importStar(require("jose"));
+class InternalJwtService {
+    constructor(keyManager) {
+        this.keyManager = keyManager;
+        this.jwksCache = new Map();
+        this.serviceName = process.env.SERVICE_NAME || "unknown-service";
+    }
+    async sign(payload, targetService) {
+        const signer = this.keyManager.getPrivateKey();
+        const kid = this.keyManager.getKid();
+        return new jose.SignJWT({
+            ...payload,
+            typ: "internal"
+        })
+            .setProtectedHeader({ alg: "RS256", kid })
+            .setIssuer(this.serviceName)
+            .setAudience(targetService)
+            .setIssuedAt()
+            .setExpirationTime("1m")
+            .sign(signer);
+    }
+    async verify(token) {
+        const unverified = jose.decodeJwt(token);
+        if (!unverified.iss)
+            throw new Error("Missing issuer");
+        if (unverified.typ !== "internal")
+            throw new Error("Invalid token type");
+        const jwks = this.getRemoteJWKS(unverified.iss);
+        const { payload } = await jose.jwtVerify(token, jwks, {
+            algorithms: ["RS256"],
+            audience: this.serviceName,
+            issuer: unverified.iss
+        });
+        return payload;
+    }
+    getRemoteJWKS(issuer) {
+        const envKey = `${issuer.replace(/-/g, "_").toUpperCase()}_URL`;
+        const baseUrl = process.env[envKey];
+        const url = baseUrl
+            ? `${baseUrl}/internal/jwks`
+            : `http://${issuer}/internal/jwks`;
+        if (!this.jwksCache.has(url)) {
+            console.log(`[InternalJwt] Caching JWKS for ${issuer} at ${url}`);
+            this.jwksCache.set(url, jose.createRemoteJWKSet(new URL(url), {
+                cacheMaxAge: 600000,
+                cooldownDuration: 30000
+            }));
+        }
+        return this.jwksCache.get(url);
+    }
+}
+exports.InternalJwtService = InternalJwtService;

package/dist/internal/internal-jwt.types.d.ts

@@ -0,0 +1,7 @@
+import { JWTPayload } from "jose";
+export interface InternalJwtPayload extends JWTPayload {
+    iss: string;
+    aud: string;
+    typ: "internal";
+    requestId: string;
+}

package/dist/internal/internal-jwt.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/internal-key-manager.d.ts

@@ -0,0 +1,16 @@
+import { JWK } from "jose";
+import { KeyObject } from "crypto";
+export declare class InternalKeyManager {
+    private privateKey;
+    private publicKey;
+    private jwks;
+    private readonly serviceName;
+    private readonly keyPath;
+    constructor();
+    private init;
+    getPrivateKey(): CryptoKey | KeyObject;
+    getPublicJwks(): {
+        keys: JWK[];
+    };
+    getKid(): string;
+}

package/dist/internal/internal-key-manager.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalKeyManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const jose_1 = require("jose");
+class InternalKeyManager {
+    constructor() {
+        this.jwks = [];
+        this.serviceName = process.env.SERVICE_NAME || "unknown-service";
+        this.keyPath = (() => {
+            const envPath = process.env.INTERNAL_KEYS_PATH;
+            if (!envPath) {
+                console.warn("[InternalKeyManager] INTERNAL_KEYS_PATH not set. Using default: src/keys/internal");
+                return path_1.default.join(process.cwd(), "src/keys/internal");
+            }
+            return path_1.default.isAbsolute(envPath) ? envPath : path_1.default.join(process.cwd(), envPath);
+        })();
+        this.init();
+    }
+    async init() {
+        try {
+            if (!fs_1.default.existsSync(this.keyPath)) {
+                console.error(`[InternalKeyManager] Missing keys directory: ${this.keyPath}`);
+                return;
+            }
+            const privPath = path_1.default.join(this.keyPath, "/private/private.pem");
+            if (fs_1.default.existsSync(privPath)) {
+                const privPem = fs_1.default.readFileSync(privPath, "utf8");
+                this.privateKey = await (0, jose_1.importPKCS8)(privPem, "RS256");
+            }
+            const pubPath = path_1.default.join(this.keyPath, "/public/public.pem");
+            if (fs_1.default.existsSync(pubPath)) {
+                const pubPem = fs_1.default.readFileSync(pubPath, "utf8");
+                this.publicKey = await (0, jose_1.importSPKI)(pubPem, "RS256");
+                const jwk = await (0, jose_1.exportJWK)(this.publicKey);
+                this.jwks = [{
+                        ...jwk,
+                        kid: `${this.serviceName}-internal`,
+                        use: "sig",
+                        alg: "RS256"
+                    }];
+            }
+            console.log(`[InternalKeyManager] Loaded keys for: ${this.serviceName}`);
+        }
+        catch (error) {
+            console.error("[InternalKeyManager] Failed to load keys.", error);
+            if (process.env.NODE_ENV === "production")
+                process.exit(1);
+        }
+    }
+    getPrivateKey() {
+        if (!this.privateKey)
+            throw new Error("Private key not loaded");
+        return this.privateKey;
+    }
+    getPublicJwks() {
+        return { keys: this.jwks };
+    }
+    getKid() {
+        return `${this.serviceName}-internal`;
+    }
+}
+exports.InternalKeyManager = InternalKeyManager;

package/dist/internal/registry.d.ts

@@ -0,0 +1,8 @@
+export declare const SERVICE_REGISTRY: {
+    readonly auth: "auth-service";
+    readonly user: "user-service";
+    readonly billing: "billing-service";
+    readonly notifications: "notification-service";
+};
+export type ServiceName = typeof SERVICE_REGISTRY[keyof typeof SERVICE_REGISTRY];
+export declare const extractServiceName: (url?: string) => ServiceName | null;

package/dist/internal/registry.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractServiceName = exports.SERVICE_REGISTRY = void 0;
+exports.SERVICE_REGISTRY = {
+    auth: "auth-service",
+    user: "user-service",
+    billing: "billing-service",
+    notifications: "notification-service"
+};
+const extractServiceName = (url) => {
+    if (!url)
+        return null;
+    try {
+        const u = new URL(url);
+        // If localhost, infer by port
+        switch (u.port) {
+            case "3001": return "auth-service";
+            case "3002": return "user-service";
+            case "3003": return "billing-service";
+            case "3004": return "notification-service";
+            default: break;
+        }
+        // Docker/K8s case: hostname is service name
+        const host = u.hostname.split(".")[0];
+        if (Object.values(exports.SERVICE_REGISTRY).includes(host)) {
+            return host;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+exports.extractServiceName = extractServiceName;

package/dist/internal/service-client.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance } from "axios";
+import { InternalJwtService } from "./internal-jwt.service";
+export declare class ServiceClient {
+    private readonly internalJwt;
+    readonly http: AxiosInstance;
+    constructor(internalJwt: InternalJwtService);
+    private setupRetry;
+    private setupInterceptors;
+}

package/dist/internal/service-client.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceClient = void 0;
+const axios_1 = __importStar(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const registry_1 = require("./registry");
+class ServiceClient {
+    constructor(internalJwt) {
+        this.internalJwt = internalJwt;
+        this.http = axios_1.default.create({
+            timeout: 8000,
+            validateStatus: () => true
+        });
+        this.setupRetry();
+        this.setupInterceptors();
+    }
+    setupRetry() {
+        (0, axios_retry_1.default)(this.http, {
+            retries: 3,
+            retryDelay: axios_retry_1.default.exponentialDelay,
+            retryCondition: (err) => {
+                if (axios_retry_1.default.isNetworkError(err))
+                    return true;
+                return (err.response?.status ?? 0) >= 500;
+            }
+        });
+    }
+    setupInterceptors() {
+        this.http.interceptors.request.use(async (config) => {
+            if (!config.headers)
+                config.headers = new axios_1.AxiosHeaders();
+            const reqId = config.headers["x-request-id"] ||
+                `req_${Math.random().toString(36).slice(2)}`;
+            config.headers["x-request-id"] = reqId;
+            const fullUrl = config.url?.startsWith("http")
+                ? config.url
+                : config.baseURL;
+            if (!fullUrl)
+                throw new Error("Missing baseURL or absolute URL for internal service request");
+            const target = (0, registry_1.extractServiceName)(fullUrl);
+            if (!target)
+                throw new Error(`Cannot extract serviceName from ${fullUrl}`);
+            const token = await this.internalJwt.sign({ requestId: reqId }, target);
+            config.headers["x-internal-jwt"] = token;
+            return config;
+        });
+        this.http.interceptors.response.use((res) => {
+            if (res.status >= 200 && res.status < 300)
+                return res;
+            throw {
+                status: res.status,
+                message: res.data?.error?.message ?? "Service Error",
+                details: res.data
+            };
+        });
+    }
+}
+exports.ServiceClient = ServiceClient;

package/dist/jwt/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./jwt-verifier";
+export * from "./service-client";

package/dist/jwt/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./jwt-verifier"), exports);
+__exportStar(require("./service-client"), exports);

package/dist/jwt/jwt-verifier.d.ts

@@ -0,0 +1,9 @@
+import { InternalJwtPayload } from "../types";
+export declare class JwtVerifier {
+    private remoteJWKS;
+    private getJWKS;
+    /**
+     * Verifies the Internal JWT sent by the Gateway.
+     */
+    verifyAccessToken(token: string): Promise<InternalJwtPayload>;
+}

package/dist/jwt/jwt-verifier.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtVerifier = void 0;
+const jose_1 = require("jose");
+const errors_1 = require("../errors");
+class JwtVerifier {
+    constructor() {
+        this.remoteJWKS = null;
+    }
+    async getJWKS() {
+        if (!this.remoteJWKS) {
+            const base = process.env.API_GATEWAY_URL;
+            this.remoteJWKS = (0, jose_1.createRemoteJWKSet)(new URL(`${base}/.well-known/jwks.json`));
+        }
+        return this.remoteJWKS;
+    }
+    /**
+     * Verifies the Internal JWT sent by the Gateway.
+     */
+    async verifyAccessToken(token) {
+        try {
+            const JWKS = await this.getJWKS();
+            const { payload } = await (0, jose_1.jwtVerify)(token, JWKS, {
+                issuer: process.env.INTERNAL_JWT_ISSUER,
+                audience: process.env.INTERNAL_JWT_AUDIENCE,
+            });
+            // Cast to our internal payload which includes the jti
+            return payload;
+        }
+        catch (err) {
+            console.error("[JwtVerifier] Internal Token Validation Failed:", err);
+            throw new errors_1.UnauthorizedError("Invalid or expired internal token");
+        }
+    }
+}
+exports.JwtVerifier = JwtVerifier;

package/dist/jwt/service-client.d.ts

@@ -0,0 +1,7 @@
+import { AxiosInstance } from "axios";
+export declare class ServiceClient {
+    readonly http: AxiosInstance;
+    constructor();
+    private setupRetry;
+    private setupInterceptors;
+}

package/dist/jwt/service-client.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceClient = void 0;
+const axios_1 = __importStar(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+class ServiceClient {
+    constructor() {
+        this.http = axios_1.default.create({
+            timeout: 8000,
+            validateStatus: () => true
+        });
+        this.setupRetry();
+        this.setupInterceptors();
+    }
+    setupRetry() {
+        (0, axios_retry_1.default)(this.http, {
+            retries: 3,
+            retryDelay: axios_retry_1.default.exponentialDelay,
+            retryCondition: (err) => {
+                if (axios_retry_1.default.isNetworkError(err))
+                    return true;
+                return (err.response?.status ?? 0) >= 500;
+            }
+        });
+    }
+    setupInterceptors() {
+        this.http.interceptors.request.use(async (config) => {
+            if (!config.headers)
+                config.headers = new axios_1.AxiosHeaders();
+            // Ensure every request has a tracing ID.
+            // If the caller passed one down from the incoming Express request, use it.
+            // Otherwise, generate a new one.
+            const reqId = config.headers["x-request-id"] ||
+                `req_${Math.random().toString(36).slice(2)}`;
+            config.headers["x-request-id"] = reqId;
+            return config;
+        });
+        this.http.interceptors.response.use((res) => {
+            // Pass through successful responses cleanly
+            if (res.status >= 200 && res.status < 300)
+                return res;
+            // Standardize error throwing for downstream microservice failures
+            throw {
+                status: res.status,
+                message: res.data?.error?.message ?? "Downstream Service Error",
+                details: res.data
+            };
+        });
+    }
+}
+exports.ServiceClient = ServiceClient;

package/dist/middleware/authorize.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response, NextFunction } from "express";
+import { GlobalPermission } from "../enums";
+export declare const authorize: (permission: GlobalPermission) => (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/dist/middleware/authorize.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authorize = void 0;
+const security_1 = require("../security");
+const authorize = (permission) => {
+    return (req, res, next) => {
+        // 1. Ensure the RequireAuthMiddleware has already run
+        if (!req.accessContext) {
+            return res.status(401).json({
+                success: false,
+                error: { message: "Unauthorized: No access context", code: "UNAUTHORIZED" }
+            });
+        }
+        // 2. Check if the Role in the accessContext has the required Permission
+        if (!(0, security_1.isAllowed)(req.accessContext, permission)) {
+            return res.status(403).json({
+                success: false,
+                error: { message: `Forbidden: Missing permission ${permission}`, code: "FORBIDDEN" }
+            });
+        }
+        next();
+    };
+};
+exports.authorize = authorize;

package/dist/middleware/error-handler.d.ts

@@ -0,0 +1,4 @@
+import { Request, Response, NextFunction } from "express";
+export declare class GlobalErrorHandler {
+    static handle(err: unknown, req: Request, res: Response, _next: NextFunction): Response<any, Record<string, any>>;
+}

package/dist/middleware/error-handler.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalErrorHandler = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils");
+class GlobalErrorHandler {
+    static handle(err, req, res, _next) {
+        // Standardized logging using req.id from your requestId middleware
+        console.error(`[req ${req.id}]`, err);
+        // 1. Zod Validation Errors
+        if (err instanceof zod_1.ZodError) {
+            return (0, utils_1.failure)(res, "Validation failed", 400, err.flatten());
+        }
+        // 2. Custom App Errors (instanceof checks for BadRequestError, etc.)
+        const custom = err;
+        if (custom.statusCode) {
+            return (0, utils_1.failure)(res, custom.message ?? "Error", custom.statusCode, custom.details);
+        }
+        // 3. Fallback: Internal Server Error
+        return (0, utils_1.failure)(res, "Internal Server Error", 500);
+    }
+}
+exports.GlobalErrorHandler = GlobalErrorHandler;

package/dist/middleware/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./error-handler";
+export * from "./validate";
+export * from "./request-id";
+export * from "./require-auth";
+export * from "./authorize";

package/dist/middleware/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./error-handler"), exports);
+__exportStar(require("./validate"), exports);
+__exportStar(require("./request-id"), exports);
+__exportStar(require("./require-auth"), exports);
+__exportStar(require("./authorize"), exports);

package/dist/middleware/request-id.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from "express";
+export declare const requestId: (req: Request, _res: Response, next: NextFunction) => void;

package/dist/middleware/request-id.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestId = void 0;
+const crypto_1 = require("crypto");
+const requestId = (req, _res, next) => {
+    req.id = (0, crypto_1.randomUUID)();
+    next();
+};
+exports.requestId = requestId;

package/dist/middleware/require-auth.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response, NextFunction } from "express";
+import { InternalJwtPayload } from "../types";
+export interface IJwtVerifier {
+    verifyAccessToken(token: string): Promise<InternalJwtPayload>;
+}
+export declare class RequireAuthMiddleware {
+    private readonly verifier;
+    constructor(verifier: IJwtVerifier);
+    handle: (req: Request, _res: Response, next: NextFunction) => Promise<void>;
+}