@excofy/utils 1.0.0

package/src/helpers/validator.ts

@@ -0,0 +1,427 @@
+import { sanitizeValue, type AllowedTag } from './sanitize';
+import { video } from './video';
+
+type TMessage = { message: string };
+type TValue = string | number | boolean | File | object | null | undefined;
+type TInputValue = TValue;
+type TTypes =
+  | 'string'
+  | 'number'
+  | 'boolean'
+  | 'object'
+  | 'array'
+  | 'file'
+  | 'date';
+
+interface IInputErrors {
+  [key: string]: TMessage[] | IInputErrors[];
+}
+
+/**
+ * Cria um validador de inputs com suporte a validações encadeadas, transformação e sanitização.
+ *
+ * @template TRaw Tipo dos dados recebidos originalmente (geralmente string, vindo do query, body ou params).
+ * @template TParsed Tipo final retornado por `getValidatedInputs()` após transformações.
+ *
+ * @returns Um objeto com métodos para validação, transformação, sanitização e extração dos dados validados.
+ *
+ * @example
+ * type InputRaw = { limit?: string }
+ * type InputParsed = { limit?: number }
+ *
+ * const v = createValidator<InputRaw, InputParsed>()
+ * v.setInputs({ limit: '10' })
+ * v.validate('limit').type('string', 'Invalid').transform(Number)
+ * const inputs = v.getValidatedInputs() // { limit: 10 }
+ */
+export function createValidator<
+  TRaw extends Record<string, TInputValue>,
+  TParsed = TRaw
+>() {
+  const current = {
+    field: '' as keyof TRaw,
+    value: undefined as TInputValue,
+    required: false,
+    inputs: {} as TRaw,
+    errors: {} as IInputErrors,
+    typeValid: false as boolean,
+    setInput(field: keyof TRaw, value?: TInputValue) {
+      this.field = field;
+      this.value = value;
+    },
+    pushError(message: string) {
+      const key = String(this.field);
+      if (!this.errors[key]) this.errors[key] = [];
+      (this.errors[key] as TMessage[]).push({ message });
+    },
+  };
+
+  const validatorRequired = {
+    isRequired(message: string) {
+      current.required = true;
+      if (current.value === undefined || current.value === null) {
+        current.pushError(message);
+      }
+      return validatorType;
+    },
+    isNotRequired() {
+      current.required = false;
+      return validatorType;
+    },
+  };
+
+  const validatorType = {
+    type(type: TTypes, message: string) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      const value = current.value;
+      let isValidType = false;
+
+      if (type === 'array') {
+        isValidType = Array.isArray(value);
+      } else if (type === 'object') {
+        isValidType =
+          typeof value === 'object' && value !== null && !Array.isArray(value);
+      } else if (type === 'file') {
+        isValidType = value instanceof File;
+      } else if (type === 'date') {
+        isValidType =
+          typeof value === 'string' && !Number.isNaN(new Date(value).getTime());
+      } else {
+        isValidType =
+          (type === 'string' && typeof value === 'string') ||
+          (type === 'number' && typeof value === 'number') ||
+          (type === 'boolean' && typeof value === 'boolean');
+      }
+
+      current.typeValid = isValidType;
+
+      if (!isValidType) {
+        current.pushError(message);
+      }
+
+      return validator;
+    },
+  };
+
+  const shouldSkipValidation = () => {
+    return (
+      !current.required &&
+      (current.value === undefined ||
+        current.value === null ||
+        current.value === '')
+    );
+  };
+
+  const validator = {
+    each(
+      callback: <U extends Record<string, TInputValue>>(
+        item: U,
+        index: number,
+        subValidator: ReturnType<typeof createValidator<U>>
+      ) => void
+    ) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (!Array.isArray(current.value)) return validator;
+
+      const fieldName = String(current.field);
+
+      for (let index = 0; index < current.value.length; index++) {
+        const item = current.value[index];
+        const subValidator = createValidator<typeof item>();
+        subValidator.setInputs(item);
+        callback(item, index, subValidator);
+
+        const subErrors = subValidator.getFlatErrors();
+        if (subErrors) {
+          for (const [subField, messages] of Object.entries(subErrors)) {
+            const path = `${fieldName}[${index}].${subField}`;
+            (current.errors as Record<string, TMessage[]>)[path] = messages;
+          }
+        }
+
+        if (Array.isArray(current.value)) {
+          current.value[index] = subValidator.getSanitizedInputs();
+        }
+      }
+
+      current.inputs[current.field] = current.value as TRaw[keyof TRaw];
+      return validator;
+    },
+    email: (message: string) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (typeof current.value === 'string') {
+        const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!regex.test(current.value)) {
+          current.pushError(message);
+        }
+      } else {
+        current.pushError(message);
+      }
+
+      return validator;
+    },
+    fileMaxSize: (maxSize: number, message: string) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      const value = current.value;
+
+      if (!(value instanceof File)) {
+        current.pushError('Arquivo inválido');
+        return validator;
+      }
+
+      if (value.size > maxSize) {
+        current.pushError(message);
+      }
+
+      return validator;
+    },
+    fileType: (validTypes: string[], message: string) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      const value = current.value;
+
+      if (!(value instanceof File)) {
+        current.pushError('Arquivo inválido');
+        return validator;
+      }
+
+      if (!validTypes.includes(value.type)) {
+        current.pushError(message);
+      }
+
+      return validator;
+    },
+    length(length: number, message: string) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      const value = current.value;
+      const isValid =
+        (typeof value === 'string' || Array.isArray(value)) &&
+        value.length === length;
+
+      if (!isValid) {
+        current.pushError(message);
+      }
+
+      return validator;
+    },
+    min(min: number, message: string) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (typeof current.value === 'string' && current.value.length < min)
+        current.pushError(message);
+      else if (typeof current.value === 'number' && current.value < min)
+        current.pushError(message);
+      else if (Array.isArray(current.value) && current.value.length < min)
+        current.pushError(message);
+      return validator;
+    },
+    max(max: number, message: string) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (typeof current.value === 'string' && current.value.length > max)
+        current.pushError(message);
+      else if (typeof current.value === 'number' && current.value > max)
+        current.pushError(message);
+      return validator;
+    },
+    transform<U>(fn: (value: TInputValue) => U) {
+      if (shouldSkipValidation()) return validator;
+
+      const transformed = fn(current.value);
+      current.value = transformed as TInputValue;
+      current.inputs[current.field] = transformed as TRaw[keyof TRaw];
+      return validator;
+    },
+
+    slug(message: string) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (typeof current.value === 'string') {
+        const regex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+        if (!regex.test(current.value)) current.pushError(message);
+      }
+      return validator;
+    },
+    sanitize() {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (typeof current.value === 'string') {
+        const newValue = sanitizeValue(current.value, [])
+          .replace(/\s+/g, ' ')
+          .trim();
+        current.value = newValue;
+        current.inputs[current.field] = newValue as TRaw[keyof TRaw];
+      }
+      return validator;
+    },
+
+    sanitizeHTML(tags?: AllowedTag[]) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (typeof current.value === 'string') {
+        const newValue = sanitizeValue(current.value, tags);
+        current.value = newValue;
+        current.inputs[current.field] = newValue as TRaw[keyof TRaw];
+      }
+      return validator;
+    },
+
+    uuid(message: string) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (typeof current.value === 'string') {
+        const regex =
+          /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        if (!regex.test(current.value)) current.pushError(message);
+      }
+
+      return validator;
+    },
+
+    oneOf: (types: string[], message: string) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+
+      if (types.includes(String(current.value))) {
+        return validator;
+      }
+
+      current.pushError(message);
+      return validator;
+    },
+
+    videoUrl: {
+      youtube(message: string) {
+        if (shouldSkipValidation()) {
+          return validator;
+        }
+
+        if (
+          typeof current.value === 'string' &&
+          !video.youtube.isValid(current.value)
+        ) {
+          current.pushError(message);
+        }
+        return validator;
+      },
+    },
+  };
+
+  return {
+    getErrors(): IInputErrors | undefined {
+      return Object.keys(current.errors).length > 0
+        ? current.errors
+        : undefined;
+    },
+    getFlatErrors(): Record<string, TMessage[]> {
+      const flatErrors: Record<string, TMessage[]> = {};
+
+      function flatten(
+        prefix: string,
+        obj: IInputErrors | TMessage[] | IInputErrors[] | undefined
+      ) {
+        if (!obj) return;
+
+        if (Array.isArray(obj)) {
+          if (
+            obj.length > 0 &&
+            typeof obj[0] === 'object' &&
+            'message' in obj[0]
+          ) {
+            // It's an array of TMessage
+            flatErrors[prefix] = obj as TMessage[];
+          } else if (obj.length > 0 && typeof obj[0] === 'object') {
+            // It's an array of IInputErrors
+            for (let i = 0; i < obj.length; i++) {
+              flatten(`${prefix}[${i}]`, obj[i] as IInputErrors);
+            }
+          }
+        } else {
+          for (const key in obj) {
+            flatten(prefix ? `${prefix}.${key}` : key, obj[key]);
+          }
+        }
+      }
+
+      flatten('', current.errors);
+
+      return Object.keys(flatErrors).length ? flatErrors : {};
+    },
+    getSanitizedInputs(): TParsed {
+      return current.inputs as unknown as TParsed;
+    },
+    hasErrors(): boolean {
+      return Object.keys(current.errors).length > 0;
+    },
+    setInputs(inputs: TRaw) {
+      current.inputs = inputs;
+      current.errors = {};
+    },
+    unflattenErrors(flat: Record<string, TMessage[]>): Record<string, unknown> {
+      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+      const result: any = {};
+
+      for (const flatKey in flat) {
+        const messages = flat[flatKey].map((m) => m.message).join('\n');
+
+        const pathParts = flatKey
+          .replace(/\[(\d+)\]/g, '.$1') // converte products[0].description → products.0.description
+          .split('.'); // divide em ["products", "0", "description"]
+
+        let current = result;
+
+        for (let i = 0; i < pathParts.length; i++) {
+          const part = pathParts[i];
+
+          const nextIsIndex = /^\d+$/.test(pathParts[i + 1] || '');
+
+          if (i === pathParts.length - 1) {
+            current[part] = messages;
+          } else {
+            if (!(part in current)) {
+              current[part] = nextIsIndex ? [] : {};
+            }
+
+            current = current[part];
+          }
+        }
+      }
+
+      return result;
+    },
+    validate<K extends keyof TRaw>(field: K) {
+      current.setInput(field, current.inputs[field]);
+      return validatorRequired;
+    },
+  };
+}

package/src/helpers/video.ts

@@ -0,0 +1,28 @@
+export const video = {
+  youtube: {
+    isValid: (url: string) => {
+      const regex =
+        /^(?:(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11}))/g;
+      return regex.test(url);
+    },
+    getId: (url: string) => {
+      // Regex para identificar os diferentes formatos de URLs do YouTube
+      const regex =
+        /^(?:(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11}))/;
+
+      // Tenta fazer correspondência com a regex
+      const match = url?.match(regex);
+
+      // Se houver uma correspondência, retorna o ID do vídeo
+      if (match && match.length >= 2 && match[1]) {
+        return match[1];
+      }
+
+      // Se não houver correspondência, retorna null
+      return null;
+    },
+    getEmbedUrl: (id: string) => {
+      return `https://www.youtube.com/embed/${id}`;
+    },
+  },
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+import { createValidator } from './helpers/validator';
+import { htmlEntityDecode } from './helpers/sanitize';
+
+export { createValidator, htmlEntityDecode };

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src"],
+  "exclude": ["dist", "node_modules", "**/*.test.ts"]
+}