@greatapps/common 1.1.700 → 1.1.701

package/src/infra/http/api-fetch.ts

@@ -1,39 +1,39 @@
-import { buildQueryParams } from '../utils/params';
-import type { ActionResult } from '../api/types';
-
-type QueryParams = Parameters<typeof buildQueryParams>[0];
-
-interface ApiFetchOptions {
-  params?: object;
-  signal?: AbortSignal;
-}
-
-export async function apiFetch<T>(path: string, options: ApiFetchOptions = {}): Promise<T> {
-  const { params, signal } = options;
-  const qs = params ? buildQueryParams(params as QueryParams) : '';
-  const url = qs ? `${path}?${qs}` : path;
-
-  const response = await fetch(url, {
-    method: 'GET',
-    credentials: 'same-origin',
-    headers: { Accept: 'application/json' },
-    signal,
-  });
-
-  if (!response.ok) {
-    let message = `Erro ${response.status}`;
-    try {
-      const body = (await response.json()) as ActionResult<unknown>;
-      if (body && !body.success && body.error) message = body.error;
-    } catch {
-      // corpo não-JSON — mantém a mensagem genérica
-    }
-    throw new Error(message);
-  }
-
-  const body = (await response.json()) as ActionResult<T>;
-  if (!body.success) {
-    throw new Error(body.error ?? 'Erro desconhecido');
-  }
-  return body.data as T;
-}
+import { buildQueryParams } from '../utils/params';
+import type { ActionResult } from '../api/types';
+
+type QueryParams = Parameters<typeof buildQueryParams>[0];
+
+interface ApiFetchOptions {
+  params?: object;
+  signal?: AbortSignal;
+}
+
+export async function apiFetch<T>(path: string, options: ApiFetchOptions = {}): Promise<T> {
+  const { params, signal } = options;
+  const qs = params ? buildQueryParams(params as QueryParams) : '';
+  const url = qs ? `${path}?${qs}` : path;
+
+  const response = await fetch(url, {
+    method: 'GET',
+    credentials: 'same-origin',
+    headers: { Accept: 'application/json' },
+    signal,
+  });
+
+  if (!response.ok) {
+    let message = `Erro ${response.status}`;
+    try {
+      const body = (await response.json()) as ActionResult<unknown>;
+      if (body && !body.success && body.error) message = body.error;
+    } catch {
+      // corpo não-JSON — mantém a mensagem genérica
+    }
+    throw new Error(message);
+  }
+
+  const body = (await response.json()) as ActionResult<T>;
+  if (!body.success) {
+    throw new Error(body.error ?? 'Erro desconhecido');
+  }
+  return body.data as T;
+}

package/src/infra/route/parse-id.ts

@@ -1,9 +1,9 @@
-import { ApiError } from '../api/types';
-
-export function parseId(value: string): number {
-  const id = Number(value);
-  if (!Number.isFinite(id) || id <= 0) {
-    throw new ApiError('Identificador inválido', 'INVALID_ID', 400);
-  }
-  return id;
-}
+import { ApiError } from '../api/types';
+
+export function parseId(value: string): number {
+  const id = Number(value);
+  if (!Number.isFinite(id) || id <= 0) {
+    throw new ApiError('Identificador inválido', 'INVALID_ID', 400);
+  }
+  return id;
+}

package/src/infra/route/parse-numeric.ts

@@ -1,16 +1,16 @@
-export function parseNumericFields<T extends object>(
-  params: Partial<T>,
-  fields: readonly (keyof T)[]
-): Partial<T> {
-  const result: Partial<T> = { ...params };
-  for (const field of fields) {
-    const v = result[field] as unknown;
-    if (typeof v === 'string' && v !== '') {
-      const n = Number(v);
-      if (Number.isFinite(n)) {
-        result[field] = n as T[keyof T];
-      }
-    }
-  }
-  return result;
-}
+export function parseNumericFields<T extends object>(
+  params: Partial<T>,
+  fields: readonly (keyof T)[]
+): Partial<T> {
+  const result: Partial<T> = { ...params };
+  for (const field of fields) {
+    const v = result[field] as unknown;
+    if (typeof v === 'string' && v !== '') {
+      const n = Number(v);
+      if (Number.isFinite(n)) {
+        result[field] = n as T[keyof T];
+      }
+    }
+  }
+  return result;
+}

package/src/infra/route/safe-route-handler.ts

@@ -1,16 +1,16 @@
-import 'server-only';
-
-import { ApiError } from '../api/types';
-
-export async function safeRouteHandler<T>(fn: () => Promise<T>): Promise<Response> {
-  try {
-    const data = await fn();
-    return Response.json({ success: true, data });
-  } catch (error) {
-    if (error instanceof ApiError) {
-      return Response.json({ success: false, error: error.message }, { status: error.statusCode });
-    }
-    console.error('[safeRouteHandler] erro inesperado', error);
-    return Response.json({ success: false, error: 'Erro interno do servidor' }, { status: 500 });
-  }
-}
+import 'server-only';
+
+import { ApiError } from '../api/types';
+
+export async function safeRouteHandler<T>(fn: () => Promise<T>): Promise<Response> {
+  try {
+    const data = await fn();
+    return Response.json({ success: true, data });
+  } catch (error) {
+    if (error instanceof ApiError) {
+      return Response.json({ success: false, error: error.message }, { status: error.statusCode });
+    }
+    console.error('[safeRouteHandler] erro inesperado', error);
+    return Response.json({ success: false, error: 'Erro interno do servidor' }, { status: 500 });
+  }
+}

package/src/infra/route/search-params.ts

@@ -1,9 +1,9 @@
-export function searchParamsToParams<T extends object>(
-  searchParams: URLSearchParams
-): Partial<T> {
-  const params = Object.create(null) as Partial<Record<keyof T, string>>;
-  for (const [key, value] of searchParams.entries()) {
-    params[key as keyof T] = value;
-  }
-  return params as Partial<T>;
-}
+export function searchParamsToParams<T extends object>(
+  searchParams: URLSearchParams
+): Partial<T> {
+  const params = Object.create(null) as Partial<Record<keyof T, string>>;
+  for (const [key, value] of searchParams.entries()) {
+    params[key as keyof T] = value;
+  }
+  return params as Partial<T>;
+}

package/src/infra/utils/array.ts

@@ -1,167 +1,167 @@
-/**
- * Insere um item em um array já ordenado, mantendo a ordenação
- * com base na função de comparação fornecida.
- */
-export function insertSorted<T>(
-  data: T[],
-  newItem: T,
-  compareFn: (a: T, b: T) => number
-): T[] {
-  const index = data.findIndex((item) => compareFn(newItem, item) < 0);
-  if (index === -1) return [...data, newItem];
-  return [...data.slice(0, index), newItem, ...data.slice(index)];
-}
-
-export interface PaginatedPageCache<T> {
-  data: T[];
-  total: number;
-}
-
-export interface InsertIntoPaginatedCacheParams<T> {
-  /** Páginas atuais do cache, ordenadas por número de página (1..N). */
-  pages: PaginatedPageCache<T>[];
-  /** Números das páginas correspondentes (mesmo tamanho de `pages`). */
-  pageNumbers: number[];
-  /** Novo item a inserir. */
-  newItem: T;
-  /** Tamanho fixo de cada página. */
-  pageSize: number;
-  /**
-   * Função de comparação que mantém a ordem.
-   * Se não fornecida, insere no topo da página 1 (sem reordenar).
-   */
-  compareFn?: (a: T, b: T) => number;
-}
-
-/**
- * Insere um item em um conjunto de páginas paginadas mantendo ordenação.
- *
- * Quando `compareFn` é fornecida, descobre em qual página o item deveria
- * cair (comparando com o último item de cada página). Insere na posição
- * correta e empurra o último item da página para a próxima, propagando
- * o overflow até a última página disponível.
- *
- * Páginas não-afetadas retornam a mesma referência.
- */
-export function insertIntoPaginatedCache<T>({
-  pages,
-  pageNumbers,
-  newItem,
-  pageSize,
-  compareFn,
-}: InsertIntoPaginatedCacheParams<T>): PaginatedPageCache<T>[] {
-  if (!pages.length) return pages;
-
-  // Sem sort: insere no topo da página 1 e propaga overflow
-  if (!compareFn) {
-    // Só atualiza se a página 1 estiver no cache
-    const firstIdx = pageNumbers.indexOf(1);
-    if (firstIdx === -1) return pages;
-
-    const result: PaginatedPageCache<T>[] = pages.slice();
-    let carry: T | null = newItem;
-    for (let i = firstIdx; i < result.length && carry !== null; i++) {
-      const current = result[i];
-      const nextData: T[] = [carry, ...current.data];
-      const overflow: T | null =
-        nextData.length > pageSize ? nextData[nextData.length - 1] : null;
-      result[i] = {
-        ...current,
-        data: overflow !== null ? nextData.slice(0, pageSize) : nextData,
-        total: current.total + 1,
-      };
-      carry = overflow;
-    }
-    return result;
-  }
-
-  // Descobre em qual página o item cai
-  let targetIdx = -1;
-  for (let i = 0; i < pages.length; i++) {
-    const page = pages[i];
-    if (!page.data.length) continue;
-    const last = page.data[page.data.length - 1];
-    // Se newItem vem antes (ou igual) ao último item desta página, cai aqui
-    if (compareFn(newItem, last) <= 0) {
-      targetIdx = i;
-      break;
-    }
-  }
-
-  // Não coube em nenhuma página com itens — tenta a última página se for incompleta
-  if (targetIdx === -1) {
-    const lastIdx = pages.length - 1;
-    const lastPage = pages[lastIdx];
-    if (lastPage.data.length < pageSize) {
-      targetIdx = lastIdx;
-    } else {
-      // Não cai em nenhuma página carregada — apenas incrementa total
-      return pages.map((p) => ({ ...p, total: p.total + 1 }));
-    }
-  }
-
-  // Insere no target e propaga overflow para as páginas seguintes
-  const result: PaginatedPageCache<T>[] = pages.slice();
-  let carry: T | null = newItem;
-
-  for (let i = targetIdx; i < result.length && carry !== null; i++) {
-    const current = result[i];
-    const withInserted: T[] = insertSorted(current.data, carry, compareFn);
-    const overflow: T | null =
-      withInserted.length > pageSize ? withInserted[withInserted.length - 1] : null;
-    result[i] = {
-      ...current,
-      data: overflow !== null ? withInserted.slice(0, pageSize) : withInserted,
-      total: current.total + 1,
-    };
-    carry = overflow;
-  }
-
-  // Incrementa o total nas páginas anteriores ao target (não mudaram mas o total global cresceu)
-  for (let i = 0; i < targetIdx; i++) {
-    result[i] = { ...result[i], total: result[i].total + 1 };
-  }
-
-  return result;
-}
-
-/**
- * Cria uma função de comparação a partir de uma string de sort da API.
- * Suporta múltiplos campos separados por vírgula e prefixo `-` para desc.
- *
- * Exemplos:
- * - "title" → ascendente por title
- * - "-title" → descendente por title
- * - "title,-datetime_add" → ascendente por title, depois descendente por datetime_add
- */
-export function buildCompareFn<T extends Record<string, unknown>>(
-  sort: string
-): (a: T, b: T) => number {
-  const fields = sort.split(',').map((f) => f.trim()).filter(Boolean);
-
-  const parsedFields = fields.map((field) => {
-    const desc = field.startsWith('-');
-    const key = desc ? field.slice(1) : field;
-    return { key, desc };
-  });
-
-  return (a: T, b: T) => {
-    for (const { key, desc } of parsedFields) {
-      const aVal = a[key];
-      const bVal = b[key];
-
-      let result: number;
-
-      if (typeof aVal === 'string' && typeof bVal === 'string') {
-        result = aVal.localeCompare(bVal);
-      } else if (typeof aVal === 'number' && typeof bVal === 'number') {
-        result = aVal - bVal;
-      } else {
-        result = String(aVal ?? '').localeCompare(String(bVal ?? ''));
-      }
-
-      if (result !== 0) return desc ? -result : result;
-    }
-    return 0;
-  };
-}
+/**
+ * Insere um item em um array já ordenado, mantendo a ordenação
+ * com base na função de comparação fornecida.
+ */
+export function insertSorted<T>(
+  data: T[],
+  newItem: T,
+  compareFn: (a: T, b: T) => number
+): T[] {
+  const index = data.findIndex((item) => compareFn(newItem, item) < 0);
+  if (index === -1) return [...data, newItem];
+  return [...data.slice(0, index), newItem, ...data.slice(index)];
+}
+
+export interface PaginatedPageCache<T> {
+  data: T[];
+  total: number;
+}
+
+export interface InsertIntoPaginatedCacheParams<T> {
+  /** Páginas atuais do cache, ordenadas por número de página (1..N). */
+  pages: PaginatedPageCache<T>[];
+  /** Números das páginas correspondentes (mesmo tamanho de `pages`). */
+  pageNumbers: number[];
+  /** Novo item a inserir. */
+  newItem: T;
+  /** Tamanho fixo de cada página. */
+  pageSize: number;
+  /**
+   * Função de comparação que mantém a ordem.
+   * Se não fornecida, insere no topo da página 1 (sem reordenar).
+   */
+  compareFn?: (a: T, b: T) => number;
+}
+
+/**
+ * Insere um item em um conjunto de páginas paginadas mantendo ordenação.
+ *
+ * Quando `compareFn` é fornecida, descobre em qual página o item deveria
+ * cair (comparando com o último item de cada página). Insere na posição
+ * correta e empurra o último item da página para a próxima, propagando
+ * o overflow até a última página disponível.
+ *
+ * Páginas não-afetadas retornam a mesma referência.
+ */
+export function insertIntoPaginatedCache<T>({
+  pages,
+  pageNumbers,
+  newItem,
+  pageSize,
+  compareFn,
+}: InsertIntoPaginatedCacheParams<T>): PaginatedPageCache<T>[] {
+  if (!pages.length) return pages;
+
+  // Sem sort: insere no topo da página 1 e propaga overflow
+  if (!compareFn) {
+    // Só atualiza se a página 1 estiver no cache
+    const firstIdx = pageNumbers.indexOf(1);
+    if (firstIdx === -1) return pages;
+
+    const result: PaginatedPageCache<T>[] = pages.slice();
+    let carry: T | null = newItem;
+    for (let i = firstIdx; i < result.length && carry !== null; i++) {
+      const current = result[i];
+      const nextData: T[] = [carry, ...current.data];
+      const overflow: T | null =
+        nextData.length > pageSize ? nextData[nextData.length - 1] : null;
+      result[i] = {
+        ...current,
+        data: overflow !== null ? nextData.slice(0, pageSize) : nextData,
+        total: current.total + 1,
+      };
+      carry = overflow;
+    }
+    return result;
+  }
+
+  // Descobre em qual página o item cai
+  let targetIdx = -1;
+  for (let i = 0; i < pages.length; i++) {
+    const page = pages[i];
+    if (!page.data.length) continue;
+    const last = page.data[page.data.length - 1];
+    // Se newItem vem antes (ou igual) ao último item desta página, cai aqui
+    if (compareFn(newItem, last) <= 0) {
+      targetIdx = i;
+      break;
+    }
+  }
+
+  // Não coube em nenhuma página com itens — tenta a última página se for incompleta
+  if (targetIdx === -1) {
+    const lastIdx = pages.length - 1;
+    const lastPage = pages[lastIdx];
+    if (lastPage.data.length < pageSize) {
+      targetIdx = lastIdx;
+    } else {
+      // Não cai em nenhuma página carregada — apenas incrementa total
+      return pages.map((p) => ({ ...p, total: p.total + 1 }));
+    }
+  }
+
+  // Insere no target e propaga overflow para as páginas seguintes
+  const result: PaginatedPageCache<T>[] = pages.slice();
+  let carry: T | null = newItem;
+
+  for (let i = targetIdx; i < result.length && carry !== null; i++) {
+    const current = result[i];
+    const withInserted: T[] = insertSorted(current.data, carry, compareFn);
+    const overflow: T | null =
+      withInserted.length > pageSize ? withInserted[withInserted.length - 1] : null;
+    result[i] = {
+      ...current,
+      data: overflow !== null ? withInserted.slice(0, pageSize) : withInserted,
+      total: current.total + 1,
+    };
+    carry = overflow;
+  }
+
+  // Incrementa o total nas páginas anteriores ao target (não mudaram mas o total global cresceu)
+  for (let i = 0; i < targetIdx; i++) {
+    result[i] = { ...result[i], total: result[i].total + 1 };
+  }
+
+  return result;
+}
+
+/**
+ * Cria uma função de comparação a partir de uma string de sort da API.
+ * Suporta múltiplos campos separados por vírgula e prefixo `-` para desc.
+ *
+ * Exemplos:
+ * - "title" → ascendente por title
+ * - "-title" → descendente por title
+ * - "title,-datetime_add" → ascendente por title, depois descendente por datetime_add
+ */
+export function buildCompareFn<T extends Record<string, unknown>>(
+  sort: string
+): (a: T, b: T) => number {
+  const fields = sort.split(',').map((f) => f.trim()).filter(Boolean);
+
+  const parsedFields = fields.map((field) => {
+    const desc = field.startsWith('-');
+    const key = desc ? field.slice(1) : field;
+    return { key, desc };
+  });
+
+  return (a: T, b: T) => {
+    for (const { key, desc } of parsedFields) {
+      const aVal = a[key];
+      const bVal = b[key];
+
+      let result: number;
+
+      if (typeof aVal === 'string' && typeof bVal === 'string') {
+        result = aVal.localeCompare(bVal);
+      } else if (typeof aVal === 'number' && typeof bVal === 'number') {
+        result = aVal - bVal;
+      } else {
+        result = String(aVal ?? '').localeCompare(String(bVal ?? ''));
+      }
+
+      if (result !== 0) return desc ? -result : result;
+    }
+    return 0;
+  };
+}

package/src/infra/utils/date.ts

@@ -1,59 +1,59 @@
-import z from 'zod';
-
-function parseCalendarDate(val: unknown): Date | unknown {
-  if (val == null) return val;
-  if (val instanceof Date) {
-    return new Date(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate());
-  }
-  if (typeof val === 'string') {
-    const match = val.match(/^(\d{4})-(\d{2})-(\d{2})/);
-    if (match) {
-      return new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
-    }
-    const fallback = new Date(val);
-    if (!Number.isNaN(fallback.getTime())) {
-      return new Date(fallback.getUTCFullYear(), fallback.getUTCMonth(), fallback.getUTCDate());
-    }
-  }
-  return val;
-}
-
-export const calendarDateSchema = () => z.preprocess(parseCalendarDate, z.date());
-
-export function toCalendarDate(date: Date | string | null | undefined): Date | null {
-  if (!date) return null;
-  const parsed = parseCalendarDate(date);
-  return parsed instanceof Date ? parsed : null;
-}
-
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-
-/**
- * Diferença em dias entre duas datas. O caller é responsável por passar
- * datas normalizadas (via toCalendarDate) pra evitar off-by-one por fuso.
- */
-export function daysBetween(a: Date, b: Date): number {
-  return Math.round((b.getTime() - a.getTime()) / MS_PER_DAY);
-}
-
-export function formatShortDate(date: Date | string | null | undefined): string {
-  if (!date) return '--';
-  const d = toCalendarDate(date) ?? new Date(date);
-  const day = String(d.getDate()).padStart(2, '0');
-  const month = String(d.getMonth() + 1).padStart(2, '0');
-  if (d.getFullYear() !== new Date().getFullYear()) {
-    return `${day}/${month}/${d.getFullYear()}`;
-  }
-  return `${day}/${month}`;
-}
-
-export function formatDateTime(date: Date | string | null | undefined): string | null {
-  if (!date) return null;
-  return new Date(date).toLocaleString('pt-BR', {
-    day: '2-digit',
-    month: '2-digit',
-    year: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-  });
-}
+import z from 'zod';
+
+function parseCalendarDate(val: unknown): Date | unknown {
+  if (val == null) return val;
+  if (val instanceof Date) {
+    return new Date(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate());
+  }
+  if (typeof val === 'string') {
+    const match = val.match(/^(\d{4})-(\d{2})-(\d{2})/);
+    if (match) {
+      return new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+    }
+    const fallback = new Date(val);
+    if (!Number.isNaN(fallback.getTime())) {
+      return new Date(fallback.getUTCFullYear(), fallback.getUTCMonth(), fallback.getUTCDate());
+    }
+  }
+  return val;
+}
+
+export const calendarDateSchema = () => z.preprocess(parseCalendarDate, z.date());
+
+export function toCalendarDate(date: Date | string | null | undefined): Date | null {
+  if (!date) return null;
+  const parsed = parseCalendarDate(date);
+  return parsed instanceof Date ? parsed : null;
+}
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+/**
+ * Diferença em dias entre duas datas. O caller é responsável por passar
+ * datas normalizadas (via toCalendarDate) pra evitar off-by-one por fuso.
+ */
+export function daysBetween(a: Date, b: Date): number {
+  return Math.round((b.getTime() - a.getTime()) / MS_PER_DAY);
+}
+
+export function formatShortDate(date: Date | string | null | undefined): string {
+  if (!date) return '--';
+  const d = toCalendarDate(date) ?? new Date(date);
+  const day = String(d.getDate()).padStart(2, '0');
+  const month = String(d.getMonth() + 1).padStart(2, '0');
+  if (d.getFullYear() !== new Date().getFullYear()) {
+    return `${day}/${month}/${d.getFullYear()}`;
+  }
+  return `${day}/${month}`;
+}
+
+export function formatDateTime(date: Date | string | null | undefined): string | null {
+  if (!date) return null;
+  return new Date(date).toLocaleString('pt-BR', {
+    day: '2-digit',
+    month: '2-digit',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}

package/src/middleware.ts

@@ -1,4 +1,4 @@
-export { createAuthMiddleware } from './middlewares/create-auth-middleware';
-export { createMiddlewareChain } from './middlewares/chain';
-export type { MiddlewareConfig, MiddlewareFunction, MiddlewareResult } from './middlewares/types';
-export { continueChain, stopChain } from './middlewares/types';
+export { createAuthMiddleware } from './middlewares/create-auth-middleware';
+export { createMiddlewareChain } from './middlewares/chain';
+export type { MiddlewareConfig, MiddlewareFunction, MiddlewareResult } from './middlewares/types';
+export { continueChain, stopChain } from './middlewares/types';