@diia-inhouse/crypto 1.20.20 → 2.0.5

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { Algorithm, Jwt, JwtHeader, JwtPayload, JwtServiceParams, JwtToken, TokenSignOptions, TokenVerifyOptions } from "./interfaces/jwt.js";
+import { AuthConfig } from "./interfaces/auth.js";
+import { AuthService } from "./services/auth.js";
+import { DocumentDecryptedData, DocumentEncryptedDataResult } from "./interfaces/crypto.js";
+import { HashService } from "./services/hash.js";
+import { CryptoService } from "./services/crypto.js";
+import { JweService } from "./services/jwe.js";
+import { JwtService } from "./services/jwt.js";
+import { IdentifierConfig, IdentifierOps } from "./interfaces/identifier.js";
+import { IdentifierService } from "./services/identifier.js";
+import { CryptoDeps } from "./interfaces/deps.js";
+export { Algorithm, AuthConfig, AuthService, CryptoDeps, CryptoService, DocumentDecryptedData, DocumentEncryptedDataResult, HashService, IdentifierConfig, IdentifierOps, IdentifierService, JweService, Jwt, JwtHeader, JwtPayload, JwtService, JwtServiceParams, JwtToken, TokenSignOptions, TokenVerifyOptions };

package/dist/index.js

@@ -1,19 +1,8 @@
-"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("./interfaces"), exports);
-__exportStar(require("./services"), exports);
-//# sourceMappingURL=index.js.map
+import { JweService } from "./services/jwe.js";
+import { JwtService } from "./services/jwt.js";
+import { AuthService } from "./services/auth.js";
+import { CryptoService } from "./services/crypto.js";
+import { IdentifierService } from "./services/identifier.js";
+import { HashService } from "./services/hash.js";
+import "./services/index.js";
+export { AuthService, CryptoService, HashService, IdentifierService, JweService, JwtService };

package/dist/interfaces/auth.d.ts

@@ -0,0 +1,9 @@
+import { JwtServiceParams } from "./jwt.js";
+
+//#region src/interfaces/auth.d.ts
+interface AuthConfig {
+  jwk?: string;
+  jwt?: JwtServiceParams;
+}
+//#endregion
+export { AuthConfig };

package/dist/interfaces/crypto.d.ts

@@ -0,0 +1,10 @@
+//#region src/interfaces/crypto.d.ts
+type DocumentDecryptedData = Record<string, unknown> & {
+  id: string;
+};
+interface DocumentEncryptedDataResult {
+  hashData?: string;
+  encryptedData: string;
+}
+//#endregion
+export { DocumentDecryptedData, DocumentEncryptedDataResult };

package/dist/interfaces/deps.d.ts

@@ -0,0 +1,13 @@
+import { AuthService } from "../services/auth.js";
+import { HashService } from "../services/hash.js";
+import { CryptoService } from "../services/crypto.js";
+import { IdentifierService } from "../services/identifier.js";
+//#region src/interfaces/deps.d.ts
+type CryptoDeps = {
+  auth?: AuthService;
+  crypto?: CryptoService;
+  hash?: HashService;
+  identifier?: IdentifierService;
+};
+//#endregion
+export { CryptoDeps };

package/dist/interfaces/identifier.d.ts

@@ -0,0 +1,10 @@
+//#region src/interfaces/identifier.d.ts
+interface IdentifierConfig {
+  salt: string;
+}
+interface IdentifierOps {
+  customSalt?: string;
+  prefix?: string;
+}
+//#endregion
+export { IdentifierConfig, IdentifierOps };

package/dist/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+import { Algorithm, Jwt, JwtHeader, JwtPayload, JwtServiceParams, JwtToken, TokenSignOptions, TokenVerifyOptions } from "./jwt.js";
+import { AuthConfig } from "./auth.js";
+import { DocumentDecryptedData, DocumentEncryptedDataResult } from "./crypto.js";
+import { IdentifierConfig, IdentifierOps } from "./identifier.js";
+import { CryptoDeps } from "./deps.js";

package/dist/interfaces/jwt.d.ts

@@ -0,0 +1,25 @@
+import { Jwt as Jwt$1, JwtHeader, JwtPayload as JwtPayload$1 } from "jsonwebtoken";
+
+//#region src/interfaces/jwt.d.ts
+interface JwtServiceParams {
+  tokenVerifyOptions: TokenVerifyOptions;
+  tokenSignOptions?: TokenSignOptions;
+  privateKey?: string;
+  publicKey?: string;
+}
+interface TokenSignOptions {
+  algorithm: string;
+  expiresIn: string;
+}
+type Algorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "none";
+interface TokenVerifyOptions {
+  algorithms: Algorithm[];
+  ignoreExpiration: boolean;
+}
+interface JwtToken {
+  data: string;
+  exp?: number;
+  iat?: number;
+}
+//#endregion
+export { Algorithm, type Jwt$1 as Jwt, type JwtHeader, type JwtPayload$1 as JwtPayload, JwtServiceParams, JwtToken, TokenSignOptions, TokenVerifyOptions };

package/dist/services/auth.d.ts

@@ -0,0 +1,41 @@
+import { AuthConfig } from "../interfaces/auth.js";
+import { Jwt, VerifyOptions } from "jsonwebtoken";
+import { KeyObject } from "node:crypto";
+import { AcquirerTokenData, EResidentApplicantTokenData, EResidentTokenData, Logger, OnInit, PartnerTokenData, PortalUserTokenData, ServiceEntranceTokenData, ServiceUserTokenData, SessionType, TemporaryTokenData, TokenData, UserTokenData, VerifiedBaseTokenData } from "@diia-inhouse/types";
+
+//#region src/services/auth.d.ts
+declare class AuthService implements OnInit {
+  private readonly authConfig;
+  private readonly logger;
+  private jwe;
+  private jwt;
+  constructor(authConfig: AuthConfig, logger: Logger);
+  onInit(): Promise<void>;
+  newInstance(authConfig: AuthConfig, logger: Logger): AuthService;
+  /** Decodes JWT token and decrypts JWE payload */
+  decodeToken<T = TokenData>(token: string, shouldDecrypt?: boolean): Promise<T | null>;
+  /** Only decodes JWT token returning complete token data (header, payload, signature) */
+  decodeTokenComplete(token: string): Jwt | null;
+  verifyToken<T>(token: string, publicKey: KeyObject, options?: VerifyOptions & {
+    complete?: false;
+  }): T;
+  getJweInJwt(data: unknown, expiresIn?: string): Promise<string>;
+  getJWT(enc: string, expiresIn?: string): Promise<string>;
+  getJWTPayload(payload: string | Buffer | object, expiresIn?: string): Promise<string>;
+  encryptJWE(data: unknown): Promise<string>;
+  decryptJWE<T = TokenData>(data: string): Promise<T>;
+  validate(authToken: string | null, tokenSessionType: SessionType.Acquirer, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<AcquirerTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.ServiceUser, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<ServiceUserTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.ServiceEntrance, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<ServiceEntranceTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.Temporary, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<TemporaryTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.EResident, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<EResidentTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.EResidentApplicant, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<EResidentApplicantTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.PortalUser, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<PortalUserTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.Partner, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<PartnerTokenData>>;
+  validate(authToken: string | null, tokenSessionType: SessionType.User, mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<UserTokenData>>;
+  validate<T extends TokenData = TokenData>(authToken: string | null, allowedSessionTypes: SessionType | SessionType[], mobileUid?: string, skipJwtVerification?: boolean): Promise<VerifiedBaseTokenData<T>>;
+  private getJwtService;
+  private getJweService;
+}
+//#endregion
+export { AuthService };

package/dist/services/auth.js

@@ -1,113 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthService = void 0;
-const errors_1 = require("@diia-inhouse/errors");
-const utils_1 = require("@diia-inhouse/utils");
-const jwe_1 = require("./jwe");
-const jwt_1 = require("./jwt");
-class AuthService {
-    authConfig;
-    logger;
-    jwe = null;
-    jwt = null;
-    constructor(authConfig, logger) {
-        this.authConfig = authConfig;
-        this.logger = logger;
-        const { jwk, jwt } = this.authConfig;
-        if (jwk) {
-            this.jwe = new jwe_1.JweService(jwk, logger);
-        }
-        if (jwt) {
-            this.jwt = new jwt_1.JwtService(jwt);
-        }
-    }
-    async onInit() {
-        if (this.jwe) {
-            await this.jwe.onInit();
-        }
-    }
-    newInstance(authConfig, logger) {
-        return new AuthService(authConfig, logger);
-    }
-    /** Decodes JWT token and decrypts JWE payload */
-    async decodeToken(token, shouldDecrypt = true) {
-        const payload = this.getJwtService().decode(token);
-        if (!shouldDecrypt) {
-            return payload;
-        }
-        if (payload) {
-            return await this.decryptJWE(payload.data);
-        }
-        return null;
-    }
-    /** Only decodes JWT token returning complete token data (header, payload, signature) */
-    decodeTokenComplete(token) {
-        return this.getJwtService().decodeWithOptions(token, { complete: true });
-    }
-    verifyToken(token, publicKey, options) {
-        const service = this.getJwtService();
-        const tokenData = service.verifyWithOptions(token, publicKey, options);
-        return tokenData;
-    }
-    async getJweInJwt(data, expiresIn) {
-        const enc = await this.encryptJWE(data);
-        return await this.getJWT(enc, expiresIn);
-    }
-    async getJWT(enc, expiresIn) {
-        return this.getJwtService().sign(enc, expiresIn);
-    }
-    async getJWTPayload(payload, expiresIn) {
-        return this.getJwtService().signPayload(payload, expiresIn);
-    }
-    async encryptJWE(data) {
-        return await this.getJweService().encryptJWE(data);
-    }
-    async decryptJWE(data) {
-        return await this.getJweService().decryptJWE(data);
-    }
-    async validate(authToken, allowedSessionTypes, mobileUid, skipJwtVerification) {
-        try {
-            if (!authToken) {
-                throw new errors_1.UnauthorizedError();
-            }
-            const { data, exp, iat } = skipJwtVerification ? this.getJwtService().decode(authToken) : this.getJwtService().verify(authToken);
-            if (!data) {
-                throw new errors_1.UnauthorizedError();
-            }
-            const tokenData = await this.decryptJWE(data);
-            const { sessionType: tokenSessionType } = tokenData;
-            const sessionTypes = Array.isArray(allowedSessionTypes) ? allowedSessionTypes : [allowedSessionTypes];
-            if (!sessionTypes.includes(tokenSessionType)) {
-                this.logger.log(`Invalid session type: actual - ${tokenSessionType}, expected - ${JSON.stringify(sessionTypes)}`);
-                throw new errors_1.UnauthorizedError(`Invalid session type`);
-            }
-            if (mobileUid && 'mobileUid' in tokenData && tokenData.mobileUid !== mobileUid) {
-                throw new errors_1.UnauthorizedError(`Mobile uid does not match: actual - ${tokenData.mobileUid}, expected - ${mobileUid}`);
-            }
-            utils_1.asserts.isRefreshTokenExists(tokenData);
-            return { ...tokenData, exp, iat };
-        }
-        catch (err) {
-            this.logger.error('Failed to validate verified JWT', { err });
-            let errMessage = '';
-            if (err instanceof Error && err.message === 'jwt malformed') {
-                errMessage = 'Invalid token';
-            }
-            throw new errors_1.UnauthorizedError(errMessage);
-        }
-    }
-    getJwtService() {
-        if (!this.jwt) {
-            throw new Error('Jwt config is not provided');
-        }
-        return this.jwt;
-    }
-    getJweService() {
-        if (!this.jwe) {
-            throw new Error('JWK is not provided');
-        }
-        return this.jwe;
-    }
-}
-exports.AuthService = AuthService;
-//# sourceMappingURL=auth.js.map
+import { JweService } from "./jwe.js";
+import { JwtService } from "./jwt.js";
+import { UnauthorizedError } from "@diia-inhouse/errors";
+import { asserts } from "@diia-inhouse/utils";
+//#region src/services/auth.ts
+var AuthService = class AuthService {
+	authConfig;
+	logger;
+	jwe = null;
+	jwt = null;
+	constructor(authConfig, logger) {
+		this.authConfig = authConfig;
+		this.logger = logger;
+		const { jwk, jwt } = this.authConfig;
+		if (jwk) this.jwe = new JweService(jwk, logger);
+		if (jwt) this.jwt = new JwtService(jwt);
+	}
+	async onInit() {
+		if (this.jwe) await this.jwe.onInit();
+	}
+	newInstance(authConfig, logger) {
+		return new AuthService(authConfig, logger);
+	}
+	/** Decodes JWT token and decrypts JWE payload */
+	async decodeToken(token, shouldDecrypt = true) {
+		const payload = this.getJwtService().decode(token);
+		if (!shouldDecrypt) return payload;
+		if (payload) return await this.decryptJWE(payload.data);
+		return null;
+	}
+	/** Only decodes JWT token returning complete token data (header, payload, signature) */
+	decodeTokenComplete(token) {
+		return this.getJwtService().decodeWithOptions(token, { complete: true });
+	}
+	verifyToken(token, publicKey, options) {
+		return this.getJwtService().verifyWithOptions(token, publicKey, options);
+	}
+	async getJweInJwt(data, expiresIn) {
+		const enc = await this.encryptJWE(data);
+		return await this.getJWT(enc, expiresIn);
+	}
+	async getJWT(enc, expiresIn) {
+		return this.getJwtService().sign(enc, expiresIn);
+	}
+	async getJWTPayload(payload, expiresIn) {
+		return this.getJwtService().signPayload(payload, expiresIn);
+	}
+	async encryptJWE(data) {
+		return await this.getJweService().encryptJWE(data);
+	}
+	async decryptJWE(data) {
+		return await this.getJweService().decryptJWE(data);
+	}
+	async validate(authToken, allowedSessionTypes, mobileUid, skipJwtVerification) {
+		try {
+			if (!authToken) throw new UnauthorizedError();
+			const { data, exp, iat } = skipJwtVerification ? this.getJwtService().decode(authToken) : this.getJwtService().verify(authToken);
+			if (!data) throw new UnauthorizedError();
+			const tokenData = await this.decryptJWE(data);
+			const { sessionType: tokenSessionType } = tokenData;
+			const sessionTypes = Array.isArray(allowedSessionTypes) ? allowedSessionTypes : [allowedSessionTypes];
+			if (!sessionTypes.includes(tokenSessionType)) {
+				this.logger.log(`Invalid session type: actual - ${tokenSessionType}, expected - ${JSON.stringify(sessionTypes)}`);
+				throw new UnauthorizedError(`Invalid session type`);
+			}
+			if (mobileUid && "mobileUid" in tokenData && tokenData.mobileUid !== mobileUid) throw new UnauthorizedError(`Mobile uid does not match: actual - ${tokenData.mobileUid}, expected - ${mobileUid}`);
+			asserts.isRefreshTokenExists(tokenData);
+			return {
+				...tokenData,
+				exp,
+				iat
+			};
+		} catch (err) {
+			this.logger.error("Failed to validate verified JWT", { err });
+			let errMessage = "";
+			if (err instanceof Error && err.message === "jwt malformed") errMessage = "Invalid token";
+			throw new UnauthorizedError(errMessage);
+		}
+	}
+	getJwtService() {
+		if (!this.jwt) throw new Error("Jwt config is not provided");
+		return this.jwt;
+	}
+	getJweService() {
+		if (!this.jwe) throw new Error("JWK is not provided");
+		return this.jwe;
+	}
+};
+//#endregion
+export { AuthService };

package/dist/services/crypto.d.ts

@@ -0,0 +1,15 @@
+import { AuthService } from "./auth.js";
+import { DocumentDecryptedData, DocumentEncryptedDataResult } from "../interfaces/crypto.js";
+import { HashService } from "./hash.js";
+
+//#region src/services/crypto.d.ts
+declare class CryptoService {
+  private readonly auth;
+  private readonly hash;
+  constructor(auth: AuthService, hash: HashService);
+  encryptData(dataToEncrypt: DocumentDecryptedData | string): Promise<DocumentEncryptedDataResult>;
+  generateHashData(dataToEncrypt: DocumentDecryptedData): string;
+  decryptData<T>(encryptedData: string): Promise<T>;
+}
+//#endregion
+export { CryptoService };

package/dist/services/crypto.js

@@ -1,24 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CryptoService = void 0;
-class CryptoService {
-    auth;
-    hash;
-    constructor(auth, hash) {
-        this.auth = auth;
-        this.hash = hash;
-    }
-    async encryptData(dataToEncrypt) {
-        const hashData = typeof dataToEncrypt === 'object' ? this.generateHashData(dataToEncrypt) : undefined;
-        const encryptedData = await this.auth.encryptJWE(dataToEncrypt);
-        return { hashData, encryptedData };
-    }
-    generateHashData(dataToEncrypt) {
-        return this.hash.hmac(JSON.stringify(dataToEncrypt), dataToEncrypt.id);
-    }
-    async decryptData(encryptedData) {
-        return this.auth.decryptJWE(encryptedData);
-    }
-}
-exports.CryptoService = CryptoService;
-//# sourceMappingURL=crypto.js.map
+//#region src/services/crypto.ts
+var CryptoService = class {
+	auth;
+	hash;
+	constructor(auth, hash) {
+		this.auth = auth;
+		this.hash = hash;
+	}
+	async encryptData(dataToEncrypt) {
+		return {
+			hashData: typeof dataToEncrypt === "object" ? this.generateHashData(dataToEncrypt) : void 0,
+			encryptedData: await this.auth.encryptJWE(dataToEncrypt)
+		};
+	}
+	generateHashData(dataToEncrypt) {
+		return this.hash.hmac(JSON.stringify(dataToEncrypt), dataToEncrypt.id);
+	}
+	async decryptData(encryptedData) {
+		return this.auth.decryptJWE(encryptedData);
+	}
+};
+//#endregion
+export { CryptoService };

package/dist/services/hash.d.ts

@@ -0,0 +1,9 @@
+import { BinaryToTextEncoding } from "node:crypto";
+
+//#region src/services/hash.d.ts
+declare class HashService {
+  hmac(data: string, secret: string, algorithm?: string, encodeTo?: BinaryToTextEncoding): string;
+  hash(data: string, algorithm?: string, encodeTo?: BinaryToTextEncoding): string;
+}
+//#endregion
+export { HashService };

package/dist/services/hash.js

@@ -1,18 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashService = void 0;
-const node_crypto_1 = require("node:crypto");
-class HashService {
-    hmac(data, secret, algorithm = 'sha512', encodeTo = 'hex') {
-        const hash = (0, node_crypto_1.createHmac)(algorithm, secret);
-        hash.update(data);
-        return hash.digest(encodeTo);
-    }
-    hash(data, algorithm = 'sha512', encodeTo = 'hex') {
-        const hash = (0, node_crypto_1.createHash)(algorithm);
-        hash.update(data);
-        return hash.digest(encodeTo);
-    }
-}
-exports.HashService = HashService;
-//# sourceMappingURL=hash.js.map
+import { createHash, createHmac } from "node:crypto";
+//#region src/services/hash.ts
+var HashService = class {
+	hmac(data, secret, algorithm = "sha512", encodeTo = "hex") {
+		const hash = createHmac(algorithm, secret);
+		hash.update(data);
+		return hash.digest(encodeTo);
+	}
+	hash(data, algorithm = "sha512", encodeTo = "hex") {
+		const hash = createHash(algorithm);
+		hash.update(data);
+		return hash.digest(encodeTo);
+	}
+};
+//#endregion
+export { HashService };

package/dist/services/identifier.d.ts

@@ -0,0 +1,12 @@
+import { IdentifierConfig, IdentifierOps } from "../interfaces/identifier.js";
+import { SessionType } from "@diia-inhouse/types";
+
+//#region src/services/identifier.d.ts
+declare class IdentifierService {
+  private readonly salt;
+  constructor(identifierConfig: IdentifierConfig);
+  createIdentifier(itn: string, ops?: IdentifierOps): string;
+  getSessionTypeFromIdentifier(userIdentifier: string): SessionType;
+}
+//#endregion
+export { IdentifierService };

package/dist/services/identifier.js

@@ -1,29 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdentifierService = void 0;
-const node_crypto_1 = require("node:crypto");
-const types_1 = require("@diia-inhouse/types");
-class IdentifierService {
-    salt;
-    constructor(identifierConfig) {
-        this.salt = identifierConfig.salt;
-    }
-    createIdentifier(itn, ops = {}) {
-        const { customSalt, prefix = '' } = ops;
-        const hmac = (0, node_crypto_1.createHmac)('sha512', customSalt || this.salt);
-        hmac.update(itn);
-        const hash = hmac.digest('hex');
-        return `${prefix}${hash}`;
-    }
-    getSessionTypeFromIdentifier(userIdentifier) {
-        if (userIdentifier.startsWith(types_1.IdentifierPrefix.EResidentApplicant)) {
-            return types_1.SessionType.EResidentApplicant;
-        }
-        if (userIdentifier.startsWith(types_1.IdentifierPrefix.EResident)) {
-            return types_1.SessionType.EResident;
-        }
-        return types_1.SessionType.User;
-    }
-}
-exports.IdentifierService = IdentifierService;
-//# sourceMappingURL=identifier.js.map
+import { createHmac } from "node:crypto";
+import { IdentifierPrefix, SessionType } from "@diia-inhouse/types";
+//#region src/services/identifier.ts
+var IdentifierService = class {
+	salt;
+	constructor(identifierConfig) {
+		this.salt = identifierConfig.salt;
+	}
+	createIdentifier(itn, ops = {}) {
+		const { customSalt, prefix = "" } = ops;
+		const hmac = createHmac("sha512", customSalt || this.salt);
+		hmac.update(itn);
+		return `${prefix}${hmac.digest("hex")}`;
+	}
+	getSessionTypeFromIdentifier(userIdentifier) {
+		if (userIdentifier.startsWith(IdentifierPrefix.EResidentApplicant)) return SessionType.EResidentApplicant;
+		if (userIdentifier.startsWith(IdentifierPrefix.EResident)) return SessionType.EResident;
+		return SessionType.User;
+	}
+};
+//#endregion
+export { IdentifierService };

package/dist/services/index.d.ts

@@ -0,0 +1,6 @@
+import { AuthService } from "./auth.js";
+import { HashService } from "./hash.js";
+import { CryptoService } from "./crypto.js";
+import { JweService } from "./jwe.js";
+import { JwtService } from "./jwt.js";
+import { IdentifierService } from "./identifier.js";

package/dist/services/index.js

@@ -1,23 +1,7 @@
-"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("./auth"), exports);
-__exportStar(require("./crypto"), exports);
-__exportStar(require("./jwe"), exports);
-__exportStar(require("./jwt"), exports);
-__exportStar(require("./identifier"), exports);
-__exportStar(require("./hash"), exports);
-//# sourceMappingURL=index.js.map
+import "./jwe.js";
+import "./jwt.js";
+import "./auth.js";
+import "./crypto.js";
+import "./identifier.js";
+import "./hash.js";
+export {};

package/dist/services/jwe.d.ts

@@ -0,0 +1,17 @@
+import { JwtToken } from "../interfaces/jwt.js";
+import { Logger, OnInit, TokenData } from "@diia-inhouse/types";
+
+//#region src/services/jwe.d.ts
+declare class JweService implements OnInit {
+  private jwkSecretData;
+  private logger;
+  private key?;
+  constructor(jwkSecretData: string, logger: Logger);
+  onInit(): Promise<void>;
+  encryptJWE(tokenData: unknown): Promise<string>;
+  decryptJWE<T = TokenData>(data: JwtToken["data"]): Promise<T>;
+  private handleUriData;
+  private getKey;
+}
+//#endregion
+export { JweService };