@seniorsistemas/hcm-clocking-event-rule-nodejs 0.35.0

package/src/utils/dateUtils.ts

@@ -0,0 +1,456 @@
+const MINUTE_IN_MILI = 60000;
+/**
+ * Enumeração para os dias da semana.
+ * @enum
+ */
+export enum WeekDay {
+    /**
+     * Domingo.
+     */
+    SUNDAY = "SUNDAY",
+    /**
+     * Segunda-feira.
+     */
+    MONDAY = "MONDAY",
+    /**
+     * Terça-feira.
+     */
+    TUESDAY = "TUESDAY",
+    /**
+     * Quarta-feira.
+     */
+    WEDNESDAY = "WEDNESDAY",
+    /**
+     * Quinta-feira.
+     */
+    THURSDAY = "THURSDAY",
+    /**
+     * Sexta-feira.
+     */
+    FRIDAY = "FRIDAY",
+    /**
+     * Sábado.
+     */
+    SATURDAY = "SATURDAY"
+}
+
+
+/**
+ * Classe utilitária para trabalhar com datas.
+ */
+export const DateUtils = {
+    /**
+     * Constante para menor data possível.
+     * 
+     * @example
+     * ```javascript
+     * const minDate = DateUtils.MIN_DATE; // 1900-12-31
+     * ```
+     */
+    MIN_DATE: new Date("1900-12-31"),
+    /**
+     * Constante para maior data possível.
+     * 
+     * @example
+     * ```javascript
+     * const maxDate = DateUtils.MAX_DATE; // 2099-12-31
+     * ```
+     * 
+     */
+    MAX_DATE: new Date("2099-12-31"),
+    /**
+     * Compara diferença das datas em minutos.
+     * 
+     * @example
+     * ```javascript
+     * const start = new Date("2024-01-01T00:00:00Z");
+     * const end = new Date("2024-01-01T01:00:00Z");
+     * const minutes = DateUtils.getDateInMinutes(start, end);
+     * console.log(minutes); // 60
+     * ```
+     * 
+     * @param start Data inicial.
+     * @param end Data final.
+     * 
+     * @returns Quantidade de minutos.
+     */
+    getDateInMinutes(start: Date, end: Date): number {
+
+        const diffMs = Math.abs(start.getTime() - end.getTime()); // Diferença em milissegundos.
+        return Math.floor(diffMs / (1000 * 60)); // Converter para minutos.
+
+    },
+    /**
+     * Criar um data conforme os parâmetros informados.
+     * 
+     * @example
+     * ```javascript
+     * const date = DateUtils.of(2024, 1, 1);
+     * console.log(date); // 2024-01-01T00:00:00Z
+     * ```
+     * 
+     * @param year Ano.
+     * @param month Mês.
+     * @param day Dia.
+     * @returns Date.
+     */
+    of(year: number, month: number, day: number): Date {
+        return new Date(`${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}T00:00:00Z`);;
+    },
+    /**
+     * Converte um string para no formato yyyy-MM-dd para um data.
+     * 
+     * @example
+     * ```javascript
+     * const date = DateUtils.strIsoDateToDate("2024-01-01");
+     * console.log(date); // 2024-01-01T00:00:00Z
+     * ```
+     * 
+     * @param date Data no formato yyyy-MM-dd.
+     * @return Data.
+     */
+    strIsoDateToDate(date: string): Date {
+        return new Date(`${date}T00:00:00Z`);
+    },
+    /**
+     * Converte uma data para um string no formato ISODate (yyyy-mm-dd).
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * const isoDateStr = DateUtils.dateToIsoDateStr(date);
+     * console.log(isoDateStr); // 2024-01-01
+     * ```
+     * 
+     * @param date 
+     * @returns 
+     */
+    dateToIsoDateStr(date: Date): string{
+        return date.toISOString().split('T')[0];
+    },
+    /**
+     * Compara se a data oneDate é anterior a data otherDate.
+     * 
+     * @example
+     * ```javascript
+     * const date1 = new Date("2024-01-01T00:00:00Z");
+     * const date2 = new Date("2024-01-02T00:00:00Z");
+     * const isBefore = DateUtils.isBefore(date1, date2);
+     * console.log(isBefore); // true
+     * ```
+     * 
+     * @param oneDate Data 1.
+     * @param otherDate Data 2.
+     * @returns True se oneDate for anterior a otherDate.
+     */
+    isBefore(oneDate: Date, otherDate: Date): boolean {
+        return oneDate.getTime() < otherDate.getTime();
+    },
+    /**
+     * Verificar se a data oneDate é anterior ou igual a data otherDate.
+     * 
+     * @example
+     * ```javascript
+     * const date1 = new Date("2024-01-01T00:00:00Z");
+     * const date2 = new Date("2024-01-01T00:00:00Z");
+     * const isBeforeOrEquals = DateUtils.isBeforeOrEquals(date1, date2);
+     * console.log(isBeforeOrEquals); // true
+     * ```
+     * 
+     * @param oneDate Uma data.
+     * @param otherDate Outra data.
+     * @returns True se oneDate for anterior ou igual a otherDate.
+     */
+    isBeforeOrEquals(oneDate: Date, otherDate: Date): boolean {
+        return oneDate.getTime() <= otherDate.getTime();
+    },
+    /**
+     * Verificar se a data oneDate é posterior a data otherDate.
+     * 
+     * @example
+     * ```javascript
+     * const date1 = new Date("2024-01-02T00:00:00Z");
+     * const date2 = new Date("2024-01-01T00:00:00Z");
+     * const isAfter = DateUtils.isAfter(date1, date2);
+     * console.log(isAfter); // true
+     * ```
+     * 
+     * @param oneDate Uma data.
+     * @param otherDate Outra data.
+     * @returns True se oneDate for posterior a otherDate.
+     */
+    isAfter(oneDate: Date, otherDate: Date): boolean {
+        return oneDate.getTime() > otherDate.getTime();
+    },
+    /**
+     * Verificar se a data oneDate é posterior ou igual a data otherDate.
+     * 
+     * @example
+     * ```javascript
+     * const date1 = new Date("2024-01-01T00:00:00Z");
+     * const date2 = new Date("2024-01-01T00:00:00Z");
+     * const isAfterOrEquals = DateUtils.isAfterOrEquals(date1, date2);
+     * console.log(isAfterOrEquals); // true
+     * ```
+     * 
+     * @param oneDate Uma data.
+     * @param otherDate Outra data.
+     * @returns True se oneDate for posterior ou igual a otherDate.
+     */
+    isAfterOrEquals(oneDate: Date, otherDate: Date): boolean {
+        return oneDate.getTime() >= otherDate.getTime();
+    },
+    /**
+     * Compara a datas, retorna 0 se forem iguais, 1 se oneDate for maior que otherDate e -1 se oneDate for menor que otherDate.
+     * 
+     * @example
+     * ```javascript
+     * const date1 = new Date("2024-01-01T00:00:00Z");
+     * const date2 = new Date("2024-01-02T00:00:00Z");
+     * const comparison = DateUtils.compareTo(date1, date2);
+     * console.log(comparison); // -1 (date1 é menor que date2)
+     * const date3 = new Date("2024-01-01T00:00:00Z");
+     * const comparison2 = DateUtils.compareTo(date1, date3);
+     * console.log(comparison2); // 0 (date1 é igual a date3)
+     * const date4 = new Date("2024-01-03T00:00:00Z");
+     * const comparison3 = DateUtils.compareTo(date1, date4);
+     * console.log(comparison3); // 1 (date1 é menor que date4)
+     * ```
+     * 
+     * 
+     * @param oneDate Uma data.
+     * @param otherDate Outra data.
+     * @returns 0 se forem iguais, 1 se oneDate for maior que otherDate e -1 se oneDate for menor que otherDate.
+     */
+    compareTo(oneDate: Date, otherDate: Date): number {
+        return oneDate.getTime() - otherDate.getTime();
+    },
+    /**
+     * Verifica se a data esta dentro do intervalor, incluindo as datas inicial e final.
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * const start = new Date("2024-01-01T00:00:00Z");
+     * const end = new Date("2024-01-02T00:00:00Z");
+     * const isBetween = DateUtils.between(date, start, end);
+     * console.log(isBetween); // true (date está entre start e end, inclusive).
+     * ```
+     * 
+     * @param date Data a ser verificada.
+     * @param start Data inicial.
+     * @param end Data final.
+     * @returns True se a data esta dentro do intervalo.
+     */
+    between(date: Date, start: Date, end: Date): boolean {
+        return date.getTime() >= start.getTime() && date.getTime() <= end.getTime();
+    },
+    /**
+     * Verificar se as datas são iguais.
+     * 
+     * @example
+     * ```javascript
+     * const date1 = new Date("2024-01-01T00:00:00Z");
+     * const date2 = new Date("2024-01-01T00:00:00Z");
+     * const isEqual = DateUtils.equals(date1, date2);
+     * console.log(isEqual); // true (date1 é igual a date2)
+     * const date3 = new Date("2024-01-02T00:00:00Z");
+     * const isEqual2 = DateUtils.equals(date1, date3);
+     * console.log(isEqual2); // false (date1 é diferente de date3)
+     * ```
+     * 
+     * @param oneDate Uma data.
+     * @param otherDate Outra data.
+     * @returns True se forem iguais.
+     */
+    equals(oneDate: Date, otherDate: Date): boolean {
+        return oneDate.getTime() === otherDate.getTime();
+    },
+    /**
+     * Retorna o dia da semana de uma data.
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * const weekDay = DateUtils.getWeekDay(date);
+     * console.log(weekDay); // "TUESDAY" (dia da semana correspondente a 1 de janeiro de 2024).
+     * ```
+     * 
+     * @param date Data.
+     * @returns Representação do dia da semana.
+     */
+    getWeekDay(date: Date): string  {
+        const days: WeekDay[] = [
+            WeekDay.SUNDAY,
+            WeekDay.MONDAY,
+            WeekDay.TUESDAY,
+            WeekDay.WEDNESDAY,
+            WeekDay.THURSDAY,
+            WeekDay.FRIDAY,
+            WeekDay.SATURDAY
+        
+        ];
+        return days[date.getDay()];
+    },
+    /**
+     * Retorna o dia da data.
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * const day = DateUtils.getDay(date);
+     * console.log(day); // 1 (dia do mês correspondente a 1 de janeiro de 2024).
+     * ```
+     * 
+     * @param date Data.
+     * @returns 
+     */
+    getDay(date: Date): number {
+        return date.getDate();
+    },
+    /**
+     * Retorna o mês da data.
+     * Ex.: Janeiro = 1, Fevereiro = 2, ....
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-02T00:00:00Z");
+     * const month = DateUtils.getMonth(date);
+     * console.log(month); // 1 (mês de janeiro).
+     * ```
+     * 
+     * @param date Data.
+     * @returns 
+     */
+    getMonth(date: Date): number {
+        return date.getMonth() + 1;
+    },
+    /**
+     * Retorna o ano da data.
+     * Ex.: 01/02/2034 = 2034
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * const year = DateUtils.getYear(date);
+     * console.log(year); // 2024 (ano correspondente a 1 de janeiro de 2024).
+     * ```
+     * 
+     * @param date Data.
+     * @returns Ano da data.
+     */
+    getYear(date: Date): number {
+        return date.getFullYear();
+    }, 
+    /**
+     * Numero de dias de um mês. 
+     * ex.: 01/01/2023 = 31, 06/04/2039 = 30
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * const daysInMonth = DateUtils.getNumberOfDaysInMonth(date);
+     * console.log(daysInMonth); // 31 (janeiro tem 31 dias).
+     * ```
+     * 
+     * @param date Data.
+     * @returns Número de dias do mês.
+     */
+    getNumberOfDaysInMonth(date: Date): number {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+    }, 
+    /**
+     * Retorna a últida data do mês.
+     * Ex.: 03/01/2034 = 31/01/2034.
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * const lastDayOfMonth = DateUtils.getLastDayOfMonth(date);
+     * console.log(lastDayOfMonth); // 2024-01-31T00:00:00Z (último dia de janeiro de 2024).
+     * ```
+     * 
+     * @param date Data.
+     * @returns Última data do mês.
+     */
+    getLastDayOfMonth(date: Date): Date {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 0);
+    }, 
+    /**
+     * Soma a quantidade de minutos de uma data.
+     * Ex.: 02/03/2024 08:00:00, somar 30 minutos, é igual a 02/03/2024 08:30:00.
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-03-02T08:00:00Z");
+     * const newDate = DateUtils.addMinutes(date, 30);
+     * console.log(newDate); // 2024-03-02T08:30:00Z (data com 30 minutos adicionados).
+     * ```
+     * 
+     * @param date Data.
+     * @param minutes Quantidade minutos para somar.
+     * @returns Nova data com os minutos somados.
+     */
+    addMinutes(date: Date, minutes: number): Date {
+        return new Date(date.getTime() + minutes * MINUTE_IN_MILI);
+    }, 
+    /**
+     * Substrai a quantidade de minutos de uma data.
+     * Ex.: 02/03/2024 08:00:00, substrair 30 minutos, é igual a 02/03/2024 07:30:00.
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2024-03-02T08:00:00Z");
+     * const newDate = DateUtils.subMinutes(date, 30);
+     * console.log(newDate); // 2024-03-02T07:30:00Z (data com 30 minutos subtraídos).
+     * ```
+     * 
+     * @param date Data.
+     * @param minutes Quantidade minutos para substrair.
+     * @returns Nova data com os minutos subtraídos.
+     */    
+    subMinutes(date: Date, minutes: number): Date {
+        return new Date(date.getTime() - minutes * MINUTE_IN_MILI);
+    },
+    /**
+     * Retornar a quantidade dias entre duas datas.
+     * Ex.: 02/02/2034 -> 12/02/2034 = 10 dias.
+     * 
+     * @example
+     * ```javascript
+     * const dateStart = new Date("2024-02-02T00:00:00Z");
+     * const dateEnd = new Date("2024-02-12T00:00:00Z");
+     * const days = DateUtils.days(dateStart, dateEnd);
+     * console.log(days); // 10 (dias entre 2 de fevereiro de 2024 e 12 de fevereiro de 2024).
+     * ```
+     * 
+     * @param dateStart Data inicial.
+     * @param dateEnd Data final.
+     * @returns 
+     */
+    
+    days(dateStart: Date, dateEnd: Date): number {
+        const diffTime = dateEnd.getTime() - dateStart.getTime();
+        return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+    },
+    /**
+     * Formata uma data no formato dd/MM/yyyy.
+     * Ex.: 2025-04-08 -> 08/04/2025.
+     * 
+     * @example
+     * ```javascript
+     * const date = new Date("2025-04-08T00:00:00Z");
+     * const formattedDate = DateUtils.format(date);
+     * console.log(formattedDate); // "08/04/2025"
+     * ```
+     * 
+     * @param date Data a ser formatada.
+     * @returns Data formatada como string.
+     */
+    format(date: Date): string {
+        const day = String(date.getDate()).padStart(2, '0');
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const year = date.getFullYear();
+        return `${day}/${month}/${year}`;
+    },
+};

package/src/utils/decompressGzipLambda.ts

@@ -0,0 +1,15 @@
+import { gunzipSync, gzipSync } from 'zlib';
+
+/**
+ * Função síncrona para descompactar dados GZIP.
+ * @param compressedPayload Buffer contendo dados comprimidos.
+ * @returns String com conteúdo descomprimido.
+ */
+export function decompressGzipSync(compressedPayload: Buffer): string {
+    const decompressedBuffer = gunzipSync(compressedPayload);
+    return decompressedBuffer.toString('utf-8');
+}
+
+export function compressGzipSync(payload: string): Buffer {
+    return gzipSync(payload);
+}

package/src/utils/object.utils.ts

@@ -0,0 +1,156 @@
+/**
+ * Classe utilitária para trabalhar com objetos.
+ */
+export const ObjectUtils = {
+    /**
+     * Compara se o objeto existe e não é vazio.
+     * 
+     * @example
+     * ```typescript
+     * import { ObjectUtils } from './object.utils';
+     * const obj = { key: 'value' };
+     * console.log(ObjectUtils.isObjectNotEmpty(obj)); // true
+     * const emptyObj = {};
+     * console.log(ObjectUtils.isObjectNotEmpty(emptyObj)); // false
+     * const nullObj = null;
+     * console.log(ObjectUtils.isObjectNotEmpty(nullObj)); // false
+     * const undefinedObj = undefined;
+     * console.log(ObjectUtils.isObjectNotEmpty(undefinedObj)); // false
+     * const str = "Hello";
+     * console.log(ObjectUtils.isObjectNotEmpty(str)); // false
+     * const num = 42;
+     * console.log(ObjectUtils.isObjectNotEmpty(num)); // false
+     * const arr = [1, 2, 3];
+     * console.log(ObjectUtils.isObjectNotEmpty(arr)); // true
+     * const emptyArr: any[] = [];
+     * console.log(ObjectUtils.isObjectNotEmpty(emptyArr)); // false
+     * const date = new Date();
+     * console.log(ObjectUtils.isObjectNotEmpty(date)); // true
+     * const emptyDate = new Date("");
+     * console.log(ObjectUtils.isObjectNotEmpty(emptyDate)); // false
+     * ```
+     * 
+     * @param obj Objeto.
+     */
+    isObjectEmpty: (obj: any): boolean => {
+        return obj && typeof obj === "object" && Object.keys(obj).length === 0;
+    },
+    /**
+     * Verificar se é tipo Date.
+     * 
+     * @example 
+     * ```typescript
+     * import { ObjectUtils } from './object.utils';
+     * const date = new Date();
+     * console.log(ObjectUtils.isDateInstance(date)); // true
+     * const notDate = "2024-01-01";
+     * console.log(ObjectUtils.isDateInstance(notDate)); // false
+     * const nullDate = null;
+     * console.log(ObjectUtils.isDateInstance(nullDate)); // false
+     * const undefinedDate = undefined;
+     * console.log(ObjectUtils.isDateInstance(undefinedDate)); // false
+     * const emptyObj = {};
+     * console.log(ObjectUtils.isDateInstance(emptyObj)); // false
+     * const emptyDate = new Date("");
+     * console.log(ObjectUtils.isDateInstance(emptyDate)); // false
+     * const arr = [1, 2, 3];
+     * console.log(ObjectUtils.isDateInstance(arr)); // false
+     * const emptyArr: any[] = [];
+     * console.log(ObjectUtils.isDateInstance(emptyArr)); // false
+     * const str = "Hello";
+     * console.log(ObjectUtils.isDateInstance(str)); // false
+     * const num = 42;
+     * console.log(ObjectUtils.isDateInstance(num)); // false
+     * const validDate = new Date("2024-01-01T00:00:00Z");
+     * console.log(ObjectUtils.isDateInstance(validDate)); // true
+     * const invalidDate = new Date("invalid date");
+     * console.log(ObjectUtils.isDateInstance(invalidDate)); // false
+     * ```
+     * 
+     * @param obj Objeto.
+     * @returns 
+     */
+    isDateInstance: (obj: any): boolean => {
+        return obj instanceof Date && !isNaN(obj.getTime());
+    },
+
+    /**
+     * Confirmar que o objeto recebido é uma Data, se o parâmetro for uma String deve converter para um tipo Date, caso for null, deve gerar um erro.
+     * 
+     * @example
+     * ```typescript
+     * import { ObjectUtils } from './object.utils';
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * console.log(ObjectUtils.toDateOrThrow(date)); // 2024-01-01T00:00:00Z
+     * const strDate = "2024-01-01";
+     * console.log(ObjectUtils.toDateOrThrow(strDate)); // 2024-01-01T00:00:00Z
+     * const invalidDate = "invalid date";
+     * console.log(ObjectUtils.toDateOrThrow(invalidDate)); // Error: O campo "date" não é uma data válida: invalid date
+     * const nullDate = null;
+     * console.log(ObjectUtils.toDateOrThrow(nullDate)); // Error: O campo "date" não é uma data válida: null
+     * const undefinedDate = undefined;
+     * console.log(ObjectUtils.toDateOrThrow(undefinedDate)); // Error: O campo "date" não é uma data válida: undefined
+     * ```
+     * 
+     * @param value Objeto.
+     * @returns 
+     */
+    toDateOrThrow: (value: unknown, fieldName = 'date'): Date => {
+        const dateOrNull = ObjectUtils.toDateOrNull(value);
+        if (dateOrNull !== null) {
+            return dateOrNull;
+        }
+        throw new Error(`O campo "${fieldName}" não é uma data válida: ${value}`);
+    },
+
+    /**
+     * Retorna um tipo Data se o tipo passado for data, caso for um string converte para data caso contrário retorna null.
+     * 
+     * @example
+     * ```typescript
+     * import { ObjectUtils } from './object.utils';
+     * const date = new Date("2024-01-01T00:00:00Z");
+     * console.log(ObjectUtils.toDateOrNull(date)); // 2024-01-01T00:00:00Z
+     * const strDate = "2024-01-01";
+     * console.log(ObjectUtils.toDateOrNull(strDate)); // 2024-01-01T00:00:00Z
+     * const invalidDate = "invalid date";
+     * console.log(ObjectUtils.toDateOrNull(invalidDate)); // null
+     * const nullDate = null;
+     * console.log(ObjectUtils.toDateOrNull(nullDate)); // null
+     * const undefinedDate = undefined;
+     * console.log(ObjectUtils.toDateOrNull(undefinedDate)); // null
+     * ```
+     * @param value Valor.
+     * @returns 
+     */
+    toDateOrNull: (value: unknown): Date | null => {
+        if (value instanceof Date && !isNaN(value.getTime())) {
+            //return value;
+            return new Date(value.toISOString());
+        }
+
+        if (typeof value === 'string') {
+            // Regex para detectar data apenas (YYYY-MM-DD).
+            const dateOnlyRegex = /^\d{4}-\d{2}-\d{2}$/;
+
+            let utcValue: string;
+
+            if (dateOnlyRegex.test(value)) {
+                // Se for só data, adiciona hora e Z.
+                utcValue = `${value}T00:00:00Z`;
+            } else {
+                // Se já tiver offset ou Z, mantém.
+                const offsetOrZRegex = /(Z|[+-]\d{2}:\d{2})$/;
+                utcValue = offsetOrZRegex.exec(value) ? value : `${value}Z`;
+            }
+
+            const parsedDate = new Date(utcValue);
+
+            if (!isNaN(parsedDate.getTime())) {
+                return parsedDate;
+            }
+        }
+
+        return null;
+    }
+};