@excofy/utils 1.0.15 → 2.1.0

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

@@ -446,6 +446,15 @@ function createValidator() {
       }
       return validator;
     },
+    sanitizeAlphanumeric() {
+      if (shouldSkipValidation()) return validator;
+      if (typeof current.value === "string") {
+        const cleaned = current.value.replace(/[^A-Za-z0-9]/g, "").trim();
+        current.value = cleaned;
+        current.inputs[current.field] = cleaned;
+      }
+      return validator;
+    },
     sanitizeDigits() {
       if (shouldSkipValidation()) return validator;
       if (typeof current.value === "string") {
@@ -720,9 +729,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),
@@ -798,7 +822,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

package/dist/index.d.cts

@@ -32,6 +32,7 @@ interface ValidatorField {
     slug(message: string): ValidatorField;
     sanitize(): ValidatorField;
     sanitizeAlphaSpaces(): ValidatorField;
+    sanitizeAlphanumeric(): ValidatorField;
     sanitizeDigits(): ValidatorField;
     sanitizePreservingNewlines(): ValidatorField;
     sanitizeHTML(tags?: AllowedTag[]): ValidatorField;
@@ -132,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;
 

package/dist/index.d.ts

@@ -32,6 +32,7 @@ interface ValidatorField {
     slug(message: string): ValidatorField;
     sanitize(): ValidatorField;
     sanitizeAlphaSpaces(): ValidatorField;
+    sanitizeAlphanumeric(): ValidatorField;
     sanitizeDigits(): ValidatorField;
     sanitizePreservingNewlines(): ValidatorField;
     sanitizeHTML(tags?: AllowedTag[]): ValidatorField;
@@ -132,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;
 

package/dist/index.js

@@ -410,6 +410,15 @@ function createValidator() {
       }
       return validator;
     },
+    sanitizeAlphanumeric() {
+      if (shouldSkipValidation()) return validator;
+      if (typeof current.value === "string") {
+        const cleaned = current.value.replace(/[^A-Za-z0-9]/g, "").trim();
+        current.value = cleaned;
+        current.inputs[current.field] = cleaned;
+      }
+      return validator;
+    },
     sanitizeDigits() {
       if (shouldSkipValidation()) return validator;
       if (typeof current.value === "string") {
@@ -684,9 +693,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),
@@ -762,7 +786,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

package/package.json

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

package/src/helpers/crypto.ts

@@ -25,6 +25,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 +100,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),
@@ -199,4 +249,7 @@ export const cryptoUtils: ICrypto = {
 
   encryptPayload,
   decryptPayload,
+
+  generateDeterministicHash,
+  verifyDeterministicHash,
 };

package/src/helpers/validator.ts

@@ -39,6 +39,7 @@ interface ValidatorField {
   slug(message: string): ValidatorField;
   sanitize(): ValidatorField;
   sanitizeAlphaSpaces(): ValidatorField;
+  sanitizeAlphanumeric(): ValidatorField;
   sanitizeDigits(): ValidatorField;
   sanitizePreservingNewlines(): ValidatorField;
   sanitizeHTML(tags?: AllowedTag[]): ValidatorField;
@@ -421,6 +422,20 @@ export function createValidator<
       return validator;
     },
 
+    sanitizeAlphanumeric() {
+      if (shouldSkipValidation()) return validator;
+
+      if (typeof current.value === 'string') {
+        const cleaned = current.value
+          .replace(/[^A-Za-z0-9]/g, '') // remove tudo que não é letra ou número
+          .trim();
+        current.value = cleaned;
+        current.inputs[current.field] = cleaned as TRaw[keyof TRaw];
+      }
+
+      return validator;
+    },
+
     sanitizeDigits() {
       if (shouldSkipValidation()) return validator;