@excofy/utils 2.1.2 → 2.3.0

package/dist/index.cjs

@@ -234,6 +234,8 @@ function createValidator() {
         isValidType = typeof value === "object" && value !== null && !Array.isArray(value);
       } else if (type === "file") {
         isValidType = value instanceof File;
+      } else if (type === "base64") {
+        isValidType = typeof value === "string" && !!value.match(/^data:([A-Za-z-+\/]+);base64,([A-Za-z0-9+/=]+)$/);
       } else if (type === "date") {
         isValidType = typeof value === "string" && !Number.isNaN(new Date(value).getTime());
       } else {
@@ -250,6 +252,42 @@ function createValidator() {
     return !current.required && (current.value === void 0 || current.value === null || current.value === "");
   };
   const validator = {
+    base64Type(validTypes, message) {
+      if (shouldSkipValidation()) return validator;
+      const value = current.value;
+      if (typeof value !== "string") {
+        current.pushError(message);
+        return validator;
+      }
+      const match = value.match(/^data:([A-Za-z-+\/]+);base64,/);
+      if (!match) {
+        current.pushError(message);
+        return validator;
+      }
+      const mimeType = match[1];
+      if (!validTypes.includes(mimeType)) {
+        current.pushError(message);
+      }
+      return validator;
+    },
+    base64MaxSize(maxSize, message) {
+      if (shouldSkipValidation()) return validator;
+      const value = current.value;
+      if (typeof value !== "string") {
+        current.pushError(message);
+        return validator;
+      }
+      const base64Content = value.split(",")[1];
+      if (!base64Content) {
+        current.pushError(message);
+        return validator;
+      }
+      const sizeInBytes = Math.ceil(base64Content.length * 3 / 4);
+      if (sizeInBytes > maxSize) {
+        current.pushError(message);
+      }
+      return validator;
+    },
     cnpj: (message) => {
       if (shouldSkipValidation()) {
         return validator;

package/dist/index.d.cts

@@ -13,11 +13,13 @@ type TMessage = {
 };
 type TValue = string | number | boolean | File | object | null | undefined;
 type TInputValue = TValue;
-type TTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'file' | 'date';
+type TTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'file' | 'base64' | 'date';
 interface IInputErrors {
     [key: string]: TMessage[] | IInputErrors[];
 }
 interface ValidatorField {
+    base64Type(validTypes: string[], message: string): ValidatorField;
+    base64MaxSize(maxSize: number, message: string): ValidatorField;
     cnpj(message: string): ValidatorField;
     cpf(message: string): ValidatorField;
     each(callback: <U extends Record<string, TInputValue>>(item: U, index: number, subValidator: ReturnType<typeof createValidator<U>>) => void): ValidatorField;

package/dist/index.d.ts

@@ -13,11 +13,13 @@ type TMessage = {
 };
 type TValue = string | number | boolean | File | object | null | undefined;
 type TInputValue = TValue;
-type TTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'file' | 'date';
+type TTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'file' | 'base64' | 'date';
 interface IInputErrors {
     [key: string]: TMessage[] | IInputErrors[];
 }
 interface ValidatorField {
+    base64Type(validTypes: string[], message: string): ValidatorField;
+    base64MaxSize(maxSize: number, message: string): ValidatorField;
     cnpj(message: string): ValidatorField;
     cpf(message: string): ValidatorField;
     each(callback: <U extends Record<string, TInputValue>>(item: U, index: number, subValidator: ReturnType<typeof createValidator<U>>) => void): ValidatorField;

package/dist/index.js

@@ -196,6 +196,8 @@ function createValidator() {
         isValidType = typeof value === "object" && value !== null && !Array.isArray(value);
       } else if (type === "file") {
         isValidType = value instanceof File;
+      } else if (type === "base64") {
+        isValidType = typeof value === "string" && !!value.match(/^data:([A-Za-z-+\/]+);base64,([A-Za-z0-9+/=]+)$/);
       } else if (type === "date") {
         isValidType = typeof value === "string" && !Number.isNaN(new Date(value).getTime());
       } else {
@@ -212,6 +214,42 @@ function createValidator() {
     return !current.required && (current.value === void 0 || current.value === null || current.value === "");
   };
   const validator = {
+    base64Type(validTypes, message) {
+      if (shouldSkipValidation()) return validator;
+      const value = current.value;
+      if (typeof value !== "string") {
+        current.pushError(message);
+        return validator;
+      }
+      const match = value.match(/^data:([A-Za-z-+\/]+);base64,/);
+      if (!match) {
+        current.pushError(message);
+        return validator;
+      }
+      const mimeType = match[1];
+      if (!validTypes.includes(mimeType)) {
+        current.pushError(message);
+      }
+      return validator;
+    },
+    base64MaxSize(maxSize, message) {
+      if (shouldSkipValidation()) return validator;
+      const value = current.value;
+      if (typeof value !== "string") {
+        current.pushError(message);
+        return validator;
+      }
+      const base64Content = value.split(",")[1];
+      if (!base64Content) {
+        current.pushError(message);
+        return validator;
+      }
+      const sizeInBytes = Math.ceil(base64Content.length * 3 / 4);
+      if (sizeInBytes > maxSize) {
+        current.pushError(message);
+      }
+      return validator;
+    },
     cnpj: (message) => {
       if (shouldSkipValidation()) {
         return validator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@excofy/utils",
-  "version": "2.1.2",
+  "version": "2.3.0",
   "description": "Biblioteca de utilitários para o Excofy",
   "main": "dist/index.js",
   "type": "module",
@@ -16,7 +16,7 @@
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
     "deploy": "act",
-    "test": "tsx --test 'tests/**/*.spec.ts' --testTimeout=10000"
+    "test": "tsx --test 'tests/helpers/crypto.spec.ts' --testTimeout=10000"
   },
   "repository": {
     "type": "git",

package/src/helpers/crypto.ts

@@ -153,7 +153,7 @@ export async function verifyDeterministicHash(
 export const cryptoUtils: ICrypto = {
   uuidV4: (): string => crypto.randomUUID(),
 
-  hash: async (password: string, salt: number = 10): Promise<string> => {
+  hash: async (password: string, salt = 10): Promise<string> => {
     const importedKey = await crypto.subtle.importKey(
       'raw',
       encoder.encode(password),

package/src/helpers/file.ts

@@ -0,0 +1,28 @@
+export const fileUtils = {
+  base64ToFile: (base64: string | null, filename: string): File | null => {
+    if (!base64 || base64 === '') {
+      return null;
+    }
+
+    const arr = base64.split(',');
+    if (arr.length !== 2) {
+      return null;
+    }
+
+    const mime = arr[0].match(/:(.*?);/)?.[1];
+
+    if (!mime) {
+      return null;
+    }
+
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+
+    while (n--) {
+      u8arr[n] = bstr.charCodeAt(n);
+    }
+
+    return new File([u8arr], filename, { type: mime });
+  },
+};

package/src/helpers/validator.ts

@@ -1,4 +1,5 @@
 import { isValidCNPJ, isValidCPF } from './document';
+import { fileUtils } from './file';
 import { sanitizeValue, type AllowedTag } from './sanitize';
 import { video } from './video';
 
@@ -12,6 +13,7 @@ type TTypes =
   | 'object'
   | 'array'
   | 'file'
+  | 'base64'
   | 'date';
 
 interface IInputErrors {
@@ -19,6 +21,8 @@ interface IInputErrors {
 }
 
 interface ValidatorField {
+  base64Type(validTypes: string[], message: string): ValidatorField;
+  base64MaxSize(maxSize: number, message: string): ValidatorField;
   cnpj(message: string): ValidatorField;
   cpf(message: string): ValidatorField;
   each(
@@ -139,6 +143,10 @@ export function createValidator<
           typeof value === 'object' && value !== null && !Array.isArray(value);
       } else if (type === 'file') {
         isValidType = value instanceof File;
+      } else if (type === 'base64') {
+        isValidType =
+          typeof value === 'string' &&
+          !!value.match(/^data:([A-Za-z-+\/]+);base64,([A-Za-z0-9+/=]+)$/);
       } else if (type === 'date') {
         isValidType =
           typeof value === 'string' && !Number.isNaN(new Date(value).getTime());
@@ -169,6 +177,55 @@ export function createValidator<
   };
 
   const validator: ValidatorField = {
+    base64Type(validTypes: string[], message: string) {
+      if (shouldSkipValidation()) return validator;
+
+      const value = current.value;
+
+      if (typeof value !== 'string') {
+        current.pushError(message);
+        return validator;
+      }
+
+      const match = value.match(/^data:([A-Za-z-+\/]+);base64,/);
+      if (!match) {
+        current.pushError(message);
+        return validator;
+      }
+
+      const mimeType = match[1];
+      if (!validTypes.includes(mimeType)) {
+        current.pushError(message);
+      }
+
+      return validator;
+    },
+
+    base64MaxSize(maxSize: number, message: string) {
+      if (shouldSkipValidation()) return validator;
+
+      const value = current.value;
+
+      if (typeof value !== 'string') {
+        current.pushError(message);
+        return validator;
+      }
+
+      const base64Content = value.split(',')[1];
+      if (!base64Content) {
+        current.pushError(message);
+        return validator;
+      }
+
+      // Calcula o tamanho do arquivo em bytes
+      const sizeInBytes = Math.ceil((base64Content.length * 3) / 4);
+      if (sizeInBytes > maxSize) {
+        current.pushError(message);
+      }
+
+      return validator;
+    },
+
     cnpj: (message: string) => {
       if (shouldSkipValidation()) {
         return validator;

package/tests/helpers/crypto.spec.ts

@@ -0,0 +1,22 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { cryptoUtils } from '../../src/helpers/crypto';
+
+const AUTH_PAYLOAD_SECRET = '98c026b8-80d7-43ac-80d0-5118cb9c0102';
+const code = 'N3HDL5';
+
+describe('cryptoUtils', () => {
+  it('uuidV4 deve gerar um UUID válido', async () => {
+    const encrypted = await cryptoUtils.encryptPayload({
+      AUTH_PAYLOAD_SECRET,
+      payload: code,
+    });
+
+    const hash = await cryptoUtils.generateDeterministicHash(
+      code,
+      AUTH_PAYLOAD_SECRET
+    );
+
+    console.log({ encrypted, hash });
+  });
+});