@excofy/utils 2.4.0 → 2.5.0

package/dist/index.cjs

@@ -809,6 +809,19 @@ async function verifyDeterministicHash(inputCode, storedHash, secret) {
 }
 var cryptoUtils = {
   uuidV4: () => crypto.randomUUID(),
+  ulid: () => {
+    function randomChar() {
+      const chars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+      return chars[Math.floor(Math.random() * chars.length)];
+    }
+    const timestamp = Date.now();
+    const timestampStr = timestamp.toString(36).toUpperCase().padStart(10, "0");
+    let randomPart = "";
+    for (let i = 0; i < 16; i++) {
+      randomPart += randomChar();
+    }
+    return timestampStr + randomPart;
+  },
   hash: async (password, salt = 10) => {
     const importedKey = await crypto.subtle.importKey(
       "raw",

package/dist/index.d.cts

@@ -122,6 +122,7 @@ interface IValidateAccessToken {
 }
 interface ICrypto {
     uuidV4: () => string;
+    ulid: () => string;
     hash: (password: string, salt: number) => Promise<string>;
     isMatch: (password: string, hash: string, salt?: number) => Promise<boolean>;
     generateAccessToken: (data: IGenerateAccessToken) => Promise<string>;

package/dist/index.d.ts

@@ -122,6 +122,7 @@ interface IValidateAccessToken {
 }
 interface ICrypto {
     uuidV4: () => string;
+    ulid: () => string;
     hash: (password: string, salt: number) => Promise<string>;
     isMatch: (password: string, hash: string, salt?: number) => Promise<boolean>;
     generateAccessToken: (data: IGenerateAccessToken) => Promise<string>;

package/dist/index.js

@@ -771,6 +771,19 @@ async function verifyDeterministicHash(inputCode, storedHash, secret) {
 }
 var cryptoUtils = {
   uuidV4: () => crypto.randomUUID(),
+  ulid: () => {
+    function randomChar() {
+      const chars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+      return chars[Math.floor(Math.random() * chars.length)];
+    }
+    const timestamp = Date.now();
+    const timestampStr = timestamp.toString(36).toUpperCase().padStart(10, "0");
+    let randomPart = "";
+    for (let i = 0; i < 16; i++) {
+      randomPart += randomChar();
+    }
+    return timestampStr + randomPart;
+  },
   hash: async (password, salt = 10) => {
     const importedKey = await crypto.subtle.importKey(
       "raw",

package/package.json

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

package/src/helpers/crypto.ts

@@ -17,6 +17,7 @@ interface IValidateAccessToken {
 
 interface ICrypto {
   uuidV4: () => string;
+  ulid: () => string;
   hash: (password: string, salt: number) => Promise<string>;
   isMatch: (password: string, hash: string, salt?: number) => Promise<boolean>;
   generateAccessToken: (data: IGenerateAccessToken) => Promise<string>;
@@ -34,7 +35,7 @@ interface ICrypto {
   verifyDeterministicHash: (
     inputCode: string,
     storedHash: string,
-    secret: string
+    secret: string,
   ) => Promise<boolean>;
 }
 
@@ -54,7 +55,7 @@ const signatureKey = async (AUTH_SIGN_SECRET: string) =>
     encoder.encode(AUTH_SIGN_SECRET),
     { name: 'HMAC', hash: 'SHA-256' },
     false,
-    ['sign', 'verify']
+    ['sign', 'verify'],
   );
 
 const payloadKey = async (AUTH_PAYLOAD_SECRET: string) =>
@@ -63,7 +64,7 @@ const payloadKey = async (AUTH_PAYLOAD_SECRET: string) =>
     encoder.encode(AUTH_PAYLOAD_SECRET.substring(0, 32)),
     { name: 'AES-GCM', length: 256 },
     true,
-    ['encrypt', 'decrypt']
+    ['encrypt', 'decrypt'],
   );
 
 /* --------------------- Payload (encrypt/decrypt) --------------------- */
@@ -80,7 +81,7 @@ const encryptPayload = async ({
   const buffer = await crypto.subtle.encrypt(
     { name: 'AES-GCM', iv },
     key,
-    encoder.encode(payload)
+    encoder.encode(payload),
   );
 
   return `${toBase64(iv)}.${toBase64(buffer)}`;
@@ -99,7 +100,7 @@ const decryptPayload = async ({
   const buffer = await crypto.subtle.decrypt(
     { name: 'AES-GCM', iv: fromBase64(header).buffer as ArrayBuffer },
     key,
-    fromBase64(payload).buffer as ArrayBuffer
+    fromBase64(payload).buffer as ArrayBuffer,
   );
 
   return decoder.decode(buffer);
@@ -115,14 +116,14 @@ const decryptPayload = async ({
  */
 export async function generateDeterministicHash(
   code: string,
-  secret: string
+  secret: string,
 ): Promise<string> {
   const key = await crypto.subtle.importKey(
     'raw',
     encoder.encode(secret),
     { name: 'HMAC', hash: 'SHA-256' },
     false,
-    ['sign']
+    ['sign'],
   );
 
   const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(code));
@@ -143,7 +144,7 @@ export async function generateDeterministicHash(
 export async function verifyDeterministicHash(
   inputCode: string,
   storedHash: string,
-  secret: string
+  secret: string,
 ): Promise<boolean> {
   const hash = await generateDeterministicHash(inputCode, secret);
   return hash === storedHash;
@@ -153,13 +154,30 @@ export async function verifyDeterministicHash(
 export const cryptoUtils: ICrypto = {
   uuidV4: (): string => crypto.randomUUID(),
 
+  ulid: (): string => {
+    function randomChar() {
+      const chars = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; // Crockford's Base32
+      return chars[Math.floor(Math.random() * chars.length)];
+    }
+
+    const timestamp = Date.now();
+    const timestampStr = timestamp.toString(36).toUpperCase().padStart(10, '0');
+
+    let randomPart = '';
+    for (let i = 0; i < 16; i++) {
+      randomPart += randomChar();
+    }
+
+    return timestampStr + randomPart;
+  },
+
   hash: async (password: string, salt = 10): Promise<string> => {
     const importedKey = await crypto.subtle.importKey(
       'raw',
       encoder.encode(password),
       { name: 'PBKDF2' },
       false,
-      ['deriveBits']
+      ['deriveBits'],
     );
 
     const derivedKey = await crypto.subtle.deriveBits(
@@ -170,7 +188,7 @@ export const cryptoUtils: ICrypto = {
         hash: 'SHA-256',
       },
       importedKey,
-      256
+      256,
     );
 
     return Array.from(new Uint8Array(derivedKey))
@@ -200,7 +218,7 @@ export const cryptoUtils: ICrypto = {
     const signatureBuffer = await crypto.subtle.sign(
       'HMAC',
       key,
-      encoder.encode(payload)
+      encoder.encode(payload),
     );
     const signature = toBase64(signatureBuffer);
 
@@ -227,7 +245,7 @@ export const cryptoUtils: ICrypto = {
         'HMAC',
         key,
         fromBase64(signature).buffer as ArrayBuffer,
-        encoder.encode(payloadDecrypted)
+        encoder.encode(payloadDecrypted),
       );
 
       if (!valid) throw new Error('Invalid access token');