@excofy/utils 2.0.0 → 2.1.1

package/.github/workflows/publish.yml

@@ -20,9 +20,6 @@ jobs:
       - name: Install Dependencies
         run: npm ci
 
-      - name: Lint Code
-        run: npm run lint
-
       - name: Build Package
         run: npm run build
 

package/dist/index.cjs

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ExpiredTokenError: () => ExpiredTokenError,
+  InvalidTokenError: () => InvalidTokenError,
   createValidator: () => createValidator,
   cryptoUtils: () => cryptoUtils,
   generateCode: () => generateCode,
@@ -684,6 +686,26 @@ var stringUtils = {
   removeFileExtension: (fileName) => fileName.replace(/\.[^/.]+$/, "")
 };
 
+// src/errors/crypto/CryptoError.ts
+var CryptoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CryptoError";
+  }
+};
+var InvalidTokenError = class extends CryptoError {
+  constructor(message = "Invalid or malformed token") {
+    super(message);
+    this.name = "InvalidTokenError";
+  }
+};
+var ExpiredTokenError = class extends CryptoError {
+  constructor(message = "Token has expired") {
+    super(message);
+    this.name = "ExpiredTokenError";
+  }
+};
+
 // src/helpers/crypto.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -729,9 +751,24 @@ var decryptPayload = async ({
   );
   return decoder.decode(buffer);
 };
+async function generateDeterministicHash(code, secret) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(code));
+  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verifyDeterministicHash(inputCode, storedHash, secret) {
+  const hash = await generateDeterministicHash(inputCode, secret);
+  return hash === storedHash;
+}
 var cryptoUtils = {
   uuidV4: () => crypto.randomUUID(),
-  hash: async (password, salt) => {
+  hash: async (password, salt = 10) => {
     const importedKey = await crypto.subtle.importKey(
       "raw",
       encoder.encode(password),
@@ -794,11 +831,11 @@ var cryptoUtils = {
       );
       if (!valid) throw new Error("Invalid access token");
     } catch (err) {
-      throw new Error("Invalid access token");
+      throw new InvalidTokenError("Invalid or malformed access token");
     }
     const { expiresAt } = JSON.parse(payloadDecrypted);
     if (Date.now() > new Date(expiresAt).getTime()) {
-      throw new Error("Expired access token");
+      throw new ExpiredTokenError("Access token has expired");
     }
     return payloadDecrypted;
   },
@@ -807,7 +844,9 @@ var cryptoUtils = {
     return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
   },
   encryptPayload,
-  decryptPayload
+  decryptPayload,
+  generateDeterministicHash,
+  verifyDeterministicHash
 };
 
 // src/helpers/slug.ts
@@ -849,6 +888,8 @@ var toDecimal = (value) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ExpiredTokenError,
+  InvalidTokenError,
   createValidator,
   cryptoUtils,
   generateCode,

package/dist/index.d.cts

@@ -133,6 +133,8 @@ interface ICrypto {
         AUTH_PAYLOAD_SECRET: string;
         token: string;
     }) => Promise<string>;
+    generateDeterministicHash: (code: string, secret: string) => Promise<string>;
+    verifyDeterministicHash: (inputCode: string, storedHash: string, secret: string) => Promise<boolean>;
 }
 declare const cryptoUtils: ICrypto;
 
@@ -198,4 +200,23 @@ declare namespace number {
   export { number_toCents as toCents, number_toDecimal as toDecimal };
 }
 
-export { createValidator, cryptoUtils, generateCode, htmlEntityDecode, number as numberUtils, slug as slugUtils, stringUtils };
+/**
+ * Classe base para erros de criptografia
+ */
+declare class CryptoError extends Error {
+    constructor(message: string);
+}
+/**
+ * Token inválido, malformado ou corrompido
+ */
+declare class InvalidTokenError extends CryptoError {
+    constructor(message?: string);
+}
+/**
+ * Token válido mas expirado
+ */
+declare class ExpiredTokenError extends CryptoError {
+    constructor(message?: string);
+}
+
+export { ExpiredTokenError, InvalidTokenError, createValidator, cryptoUtils, generateCode, htmlEntityDecode, number as numberUtils, slug as slugUtils, stringUtils };

package/dist/index.d.ts

@@ -133,6 +133,8 @@ interface ICrypto {
         AUTH_PAYLOAD_SECRET: string;
         token: string;
     }) => Promise<string>;
+    generateDeterministicHash: (code: string, secret: string) => Promise<string>;
+    verifyDeterministicHash: (inputCode: string, storedHash: string, secret: string) => Promise<boolean>;
 }
 declare const cryptoUtils: ICrypto;
 
@@ -198,4 +200,23 @@ declare namespace number {
   export { number_toCents as toCents, number_toDecimal as toDecimal };
 }
 
-export { createValidator, cryptoUtils, generateCode, htmlEntityDecode, number as numberUtils, slug as slugUtils, stringUtils };
+/**
+ * Classe base para erros de criptografia
+ */
+declare class CryptoError extends Error {
+    constructor(message: string);
+}
+/**
+ * Token inválido, malformado ou corrompido
+ */
+declare class InvalidTokenError extends CryptoError {
+    constructor(message?: string);
+}
+/**
+ * Token válido mas expirado
+ */
+declare class ExpiredTokenError extends CryptoError {
+    constructor(message?: string);
+}
+
+export { ExpiredTokenError, InvalidTokenError, createValidator, cryptoUtils, generateCode, htmlEntityDecode, number as numberUtils, slug as slugUtils, stringUtils };

package/dist/index.js

@@ -648,6 +648,26 @@ var stringUtils = {
   removeFileExtension: (fileName) => fileName.replace(/\.[^/.]+$/, "")
 };
 
+// src/errors/crypto/CryptoError.ts
+var CryptoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CryptoError";
+  }
+};
+var InvalidTokenError = class extends CryptoError {
+  constructor(message = "Invalid or malformed token") {
+    super(message);
+    this.name = "InvalidTokenError";
+  }
+};
+var ExpiredTokenError = class extends CryptoError {
+  constructor(message = "Token has expired") {
+    super(message);
+    this.name = "ExpiredTokenError";
+  }
+};
+
 // src/helpers/crypto.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -693,9 +713,24 @@ var decryptPayload = async ({
   );
   return decoder.decode(buffer);
 };
+async function generateDeterministicHash(code, secret) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(code));
+  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verifyDeterministicHash(inputCode, storedHash, secret) {
+  const hash = await generateDeterministicHash(inputCode, secret);
+  return hash === storedHash;
+}
 var cryptoUtils = {
   uuidV4: () => crypto.randomUUID(),
-  hash: async (password, salt) => {
+  hash: async (password, salt = 10) => {
     const importedKey = await crypto.subtle.importKey(
       "raw",
       encoder.encode(password),
@@ -758,11 +793,11 @@ var cryptoUtils = {
       );
       if (!valid) throw new Error("Invalid access token");
     } catch (err) {
-      throw new Error("Invalid access token");
+      throw new InvalidTokenError("Invalid or malformed access token");
     }
     const { expiresAt } = JSON.parse(payloadDecrypted);
     if (Date.now() > new Date(expiresAt).getTime()) {
-      throw new Error("Expired access token");
+      throw new ExpiredTokenError("Access token has expired");
     }
     return payloadDecrypted;
   },
@@ -771,7 +806,9 @@ var cryptoUtils = {
     return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
   },
   encryptPayload,
-  decryptPayload
+  decryptPayload,
+  generateDeterministicHash,
+  verifyDeterministicHash
 };
 
 // src/helpers/slug.ts
@@ -812,6 +849,8 @@ var toDecimal = (value) => {
   return new Big(value).div(100).round(2).toNumber();
 };
 export {
+  ExpiredTokenError,
+  InvalidTokenError,
   createValidator,
   cryptoUtils,
   generateCode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@excofy/utils",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Biblioteca de utilitários para o Excofy",
   "main": "dist/index.js",
   "type": "module",

package/src/errors/crypto/CryptoError.ts

@@ -0,0 +1,29 @@
+/**
+ * Classe base para erros de criptografia
+ */
+export class CryptoError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CryptoError';
+  }
+}
+
+/**
+ * Token inválido, malformado ou corrompido
+ */
+export class InvalidTokenError extends CryptoError {
+  constructor(message: string = 'Invalid or malformed token') {
+    super(message);
+    this.name = 'InvalidTokenError';
+  }
+}
+
+/**
+ * Token válido mas expirado
+ */
+export class ExpiredTokenError extends CryptoError {
+  constructor(message: string = 'Token has expired') {
+    super(message);
+    this.name = 'ExpiredTokenError';
+  }
+}

package/src/errors/index.ts

@@ -0,0 +1 @@
+export { InvalidTokenError, ExpiredTokenError } from './crypto/CryptoError';

package/src/helpers/crypto.ts

@@ -1,3 +1,8 @@
+import {
+  ExpiredTokenError,
+  InvalidTokenError,
+} from '../errors/crypto/CryptoError';
+
 interface IGenerateAccessToken {
   AUTH_SIGN_SECRET: string;
   AUTH_PAYLOAD_SECRET: string;
@@ -25,6 +30,12 @@ interface ICrypto {
     AUTH_PAYLOAD_SECRET: string;
     token: string;
   }) => Promise<string>;
+  generateDeterministicHash: (code: string, secret: string) => Promise<string>;
+  verifyDeterministicHash: (
+    inputCode: string,
+    storedHash: string,
+    secret: string
+  ) => Promise<boolean>;
 }
 
 /* --------------------- Helpers básicos --------------------- */
@@ -94,11 +105,55 @@ const decryptPayload = async ({
   return decoder.decode(buffer);
 };
 
+/* --------------------- Hash (generate/verify) --------------------- */
+/**
+ * Gera um hash determinístico (HMAC) a partir de um código e um segredo.
+ *
+ * @param code
+ * @param secret
+ * @returns
+ */
+export async function generateDeterministicHash(
+  code: string,
+  secret: string
+): Promise<string> {
+  const key = await crypto.subtle.importKey(
+    'raw',
+    encoder.encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign']
+  );
+
+  const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(code));
+
+  return Array.from(new Uint8Array(signature))
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+/**
+ * Verifica se o hash gerado a partir do código e segredo bate com o hash armazenado.
+ *
+ * @param inputCode
+ * @param storedHash
+ * @param secret
+ * @returns
+ */
+export async function verifyDeterministicHash(
+  inputCode: string,
+  storedHash: string,
+  secret: string
+): Promise<boolean> {
+  const hash = await generateDeterministicHash(inputCode, secret);
+  return hash === storedHash;
+}
+
 /* --------------------- Main API --------------------- */
 export const cryptoUtils: ICrypto = {
   uuidV4: (): string => crypto.randomUUID(),
 
-  hash: async (password: string, salt: number): Promise<string> => {
+  hash: async (password: string, salt: number = 10): Promise<string> => {
     const importedKey = await crypto.subtle.importKey(
       'raw',
       encoder.encode(password),
@@ -178,13 +233,13 @@ export const cryptoUtils: ICrypto = {
       if (!valid) throw new Error('Invalid access token');
     } catch (err) {
       // qualquer falha na decriptação ou verificação -> token inválido
-      throw new Error('Invalid access token');
+      throw new InvalidTokenError('Invalid or malformed access token');
     }
 
     // verifica expiração **fora do try/catch**, para não ser capturada como token inválido
     const { expiresAt } = JSON.parse(payloadDecrypted);
     if (Date.now() > new Date(expiresAt).getTime()) {
-      throw new Error('Expired access token');
+      throw new ExpiredTokenError('Access token has expired');
     }
 
     return payloadDecrypted;
@@ -199,4 +254,7 @@ export const cryptoUtils: ICrypto = {
 
   encryptPayload,
   decryptPayload,
+
+  generateDeterministicHash,
+  verifyDeterministicHash,
 };

package/src/index.ts

@@ -15,3 +15,6 @@ export {
   cryptoUtils,
   generateCode,
 };
+
+// 🚀 Classes de erro para autenticação
+export { InvalidTokenError, ExpiredTokenError } from './errors';