@denodeio/seshat 0.0.21 → 0.0.22

package/build/cjs/dist/mjs/src/index.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+type JwsSignature = {
+    protected: string;
+    header: {
+        kid: string;
+    };
+    signature: string;
+};
+type JwsPayload = {
+    payload: string;
+    signatures: JwsSignature[];
+};
+type Keychain = {
+    algorithm: string;
+    value: Buffer;
+};
+type JwtPayload<T> = {
+    iss: string;
+    exp: number;
+    jti: string;
+    event: {
+        name: string;
+        record: T;
+    };
+    iat: number;
+};
+export * from "./signer";
+export declare const sessionVerifier: (options: any) => (req: any, res: any, next: any) => void;
+export declare const managementSigner: (options: any) => (req: any, res: any, next: any) => void;
+export declare const validateJws: <T>(key: Keychain, input: JwsPayload) => JwtPayload<T> | undefined;

package/build/cjs/dist/mjs/src/signer.d.ts

@@ -0,0 +1,14 @@
+type SignJwsResponse = {
+    payload: string;
+    signatures: {
+        protected: string;
+        header: {
+            kid: string;
+        };
+        signature: string;
+    }[];
+};
+export declare function signJws(payload: string, options: any): SignJwsResponse;
+export declare function signPayload(payload: any, options: any): string;
+export declare function signData(payload: object, options: any): SignJwsResponse;
+export {};

package/build/cjs/index.d.js

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+type SignJwsResponse = {
+    payload: string;
+    signatures: {
+        protected: string;
+        header: {
+            kid: string;
+        };
+        signature: string;
+    }[];
+};
+declare function signJws(payload: string, options: any): SignJwsResponse;
+declare function signPayload(payload: any, options: any): string;
+declare function signData(payload: object, options: any): SignJwsResponse;
+
+type JwsSignature = {
+    protected: string;
+    header: {
+        kid: string;
+    };
+    signature: string;
+};
+type JwsPayload = {
+    payload: string;
+    signatures: JwsSignature[];
+};
+type Keychain = {
+    algorithm: string;
+    value: Buffer;
+};
+type JwtPayload<T> = {
+    iss: string;
+    exp: number;
+    jti: string;
+    event: {
+        name: string;
+        record: T;
+    };
+    iat: number;
+};
+
+declare const sessionVerifier: (options: any) => (req: any, res: any, next: any) => void;
+declare const managementSigner: (options: any) => (req: any, res: any, next: any) => void;
+declare const validateJws: <T>(key: Keychain, input: JwsPayload) => JwtPayload<T> | undefined;
+
+export { managementSigner, sessionVerifier, signData, signJws, signPayload, validateJws };

package/build/{index.js → cjs/index.js}

@@ -5,10 +5,14 @@ var require$$3 = require('stream');
 var require$$5 = require('util');
 var require$$2 = require('crypto');
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
+var src = {};
+
 var jws$3 = {};
 
 var safeBuffer = {exports: {}};
@@ -6459,8 +6463,12 @@ var jsonwebtoken = {
   TokenExpiredError: TokenExpiredError_1,
 };
 
-var jwt = /*@__PURE__*/getDefaultExportFromCjs(jsonwebtoken);
+var signer = {};
 
+Object.defineProperty(signer, "__esModule", { value: true });
+signer.signData = signer.signPayload = signer.signJws = void 0;
+const jsonwebtoken_1 = jsonwebtoken;
+const crypto_1 = require$$2;
 // export type CSignOptions = {
 //   privateKey: Secret
 //   jwtExpirySeconds: number
@@ -6485,6 +6493,7 @@ function signJws(payload, options) {
     };
     return requestParams;
 }
+signer.signJws = signJws;
 function signPayload(payload, options) {
     const defaultOptions = {
         jwtAlgorithm: "RS256",
@@ -6494,111 +6503,137 @@ function signPayload(payload, options) {
         ...defaultOptions,
         ...options
     };
-    const token = jwt.sign({
+    const token = (0, jsonwebtoken_1.sign)({
         iss: options.issuer,
         exp: Math.round(Date.now() / 1000) + mergedOptions.jwtExpireSeconds,
-        jti: require$$2.randomUUID(),
+        jti: (0, crypto_1.randomUUID)(),
         ...payload
     }, mergedOptions.privateKey, {
         algorithm: mergedOptions.jwtAlgorithm
     });
     return token;
 }
+signer.signPayload = signPayload;
 function signData(payload, options) {
     const signedPayload = signPayload(payload, options);
     return signJws(signedPayload, options);
 }
+signer.signData = signData;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__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 = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.validateJws = exports.managementSigner = exports.sessionVerifier = void 0;
+	const jsonwebtoken_1 = __importDefault(jsonwebtoken);
+	const signer_1 = signer;
+	__exportStar(signer, exports);
+	const sessionVerifier = function (options) {
+	    if (!options || !options.barongJwtPublicKey) {
+	        throw new Error("Barong JWT Public key should be set");
+	    }
+	    const barongJwtPublicKey = options.barongJwtPublicKey;
+	    const defaultOptions = {
+	        algorithms: ["RS256"],
+	        issuer: "auth"
+	    };
+	    const verificationOptions = { ...defaultOptions, ...options };
+	    const middleware = function (req, res, next) {
+	        let authHeader;
+	        try {
+	            authHeader = req.headers.authorization.split("Bearer ")[1];
+	        }
+	        catch (error) {
+	            res.status(401);
+	            res.send("Signature verification raised: Authorization header is missing or malformed");
+	            return;
+	        }
+	        try {
+	            req.session = jsonwebtoken_1.default.verify(authHeader, barongJwtPublicKey, verificationOptions);
+	        }
+	        catch (error) {
+	            res.status(403);
+	            res.send(`Signature verification raised: ${error}`);
+	            return;
+	        }
+	        next();
+	    };
+	    return middleware;
+	};
+	exports.sessionVerifier = sessionVerifier;
+	const managementSigner = function (options) {
+	    if (!options.privateKey)
+	        throw new Error("Application's private key should be set");
+	    const middleware = function (req, res, next) {
+	        if (!req.management.payload)
+	            console.error("No payload to be signed");
+	        const payload = req.management.payload;
+	        let signedPayload;
+	        try {
+	            signedPayload = (0, signer_1.signPayload)(payload, options);
+	        }
+	        catch (error) {
+	            res.status(403);
+	            res.send(`Unable to sign payload: ${error}`);
+	            return;
+	        }
+	        try {
+	            req.body = (0, signer_1.signJws)(signedPayload, options);
+	        }
+	        catch (error) {
+	            res.status(403);
+	            res.send(`Unable to correctly format signed payload: ${error}`);
+	        }
+	        next();
+	    };
+	    return middleware;
+	};
+	exports.managementSigner = managementSigner;
+	const base64Decode = (base64) => {
+	    return Buffer.from(base64, "base64").toString("utf8");
+	};
+	const parseProtectedHeader = (protectedHeader) => {
+	    return JSON.parse(base64Decode(protectedHeader));
+	};
+	const validateJws = (key, input) => {
+	    for (const signature of input.signatures) {
+	        const decodedProtectedHeader = parseProtectedHeader(signature.protected);
+	        if (key === undefined) {
+	            throw new Error("Invalid key");
+	        }
+	        if (key.algorithm !== decodedProtectedHeader.alg) {
+	            throw new Error("Algorithm mismatch");
+	        }
+	        try {
+	            const verified = jsonwebtoken_1.default.verify(`${signature.protected}.${input.payload}.${signature.signature}`, key.value, 
+	            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+	            { algorithms: [key.algorithm] });
+	            return verified;
+	        }
+	        catch (error) {
+	            return undefined;
+	        }
+	    }
+	};
+	exports.validateJws = validateJws; 
+} (src));
 
-const sessionVerifier = function (options) {
-    if (!options || !options.barongJwtPublicKey) {
-        throw new Error("Barong JWT Public key should be set");
-    }
-    const barongJwtPublicKey = options.barongJwtPublicKey;
-    const defaultOptions = {
-        algorithms: ["RS256"],
-        issuer: "auth"
-    };
-    const verificationOptions = { ...defaultOptions, ...options };
-    const middleware = function (req, res, next) {
-        let authHeader;
-        try {
-            authHeader = req.headers.authorization.split("Bearer ")[1];
-        }
-        catch (error) {
-            res.status(401);
-            res.send("Signature verification raised: Authorization header is missing or malformed");
-            return;
-        }
-        try {
-            req.session = jwt.verify(authHeader, barongJwtPublicKey, verificationOptions);
-        }
-        catch (error) {
-            res.status(403);
-            res.send(`Signature verification raised: ${error}`);
-            return;
-        }
-        next();
-    };
-    return middleware;
-};
-const managementSigner = function (options) {
-    if (!options.privateKey)
-        throw new Error("Application's private key should be set");
-    const middleware = function (req, res, next) {
-        if (!req.management.payload)
-            console.error("No payload to be signed");
-        const payload = req.management.payload;
-        let signedPayload;
-        try {
-            signedPayload = signPayload(payload, options);
-        }
-        catch (error) {
-            res.status(403);
-            res.send(`Unable to sign payload: ${error}`);
-            return;
-        }
-        try {
-            req.body = signJws(signedPayload, options);
-        }
-        catch (error) {
-            res.status(403);
-            res.send(`Unable to correctly format signed payload: ${error}`);
-        }
-        next();
-    };
-    return middleware;
-};
-const base64Decode = (base64) => {
-    return Buffer.from(base64, "base64").toString("utf8");
-};
-const parseProtectedHeader = (protectedHeader) => {
-    return JSON.parse(base64Decode(protectedHeader));
-};
-const validateJws = (key, input) => {
-    for (const signature of input.signatures) {
-        const decodedProtectedHeader = parseProtectedHeader(signature.protected);
-        if (key === undefined) {
-            throw new Error("Invalid key");
-        }
-        if (key.algorithm !== decodedProtectedHeader.alg) {
-            throw new Error("Algorithm mismatch");
-        }
-        try {
-            const verified = jwt.verify(`${signature.protected}.${input.payload}.${signature.signature}`, key.value, 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            { algorithms: [key.algorithm] });
-            return verified;
-        }
-        catch (error) {
-            return undefined;
-        }
-    }
-};
+var index = /*@__PURE__*/getDefaultExportFromCjs(src);
 
-exports.managementSigner = managementSigner;
-exports.sessionVerifier = sessionVerifier;
-exports.signData = signData;
-exports.signJws = signJws;
-exports.signPayload = signPayload;
-exports.validateJws = validateJws;
+module.exports = index;
 //# sourceMappingURL=index.js.map