@greatapps/common 1.1.372 → 1.1.375

package/src/infra/utils/clsx.ts

@@ -1,6 +1,6 @@
-import { clsx, type ClassValue } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/infra/utils/date.ts

@@ -1,7 +1,7 @@
-export function formatShortDate(date: Date | string | null | undefined): string {
-  if (!date) return '--';
-  const d = new Date(date);
-  const day = String(d.getDate()).padStart(2, '0');
-  const month = String(d.getMonth() + 1).padStart(2, '0');
-  return `${day}/${month}`;
-}
+export function formatShortDate(date: Date | string | null | undefined): string {
+  if (!date) return '--';
+  const d = new Date(date);
+  const day = String(d.getDate()).padStart(2, '0');
+  const month = String(d.getMonth() + 1).padStart(2, '0');
+  return `${day}/${month}`;
+}

package/src/infra/utils/parser.ts

@@ -1,53 +1,53 @@
-import z, { ZodTypeAny } from "zod";
-import { PaginatedSuccessResult, SuccessResult } from "../api/types";
-
-/* Overloads */
-export function parseSchema<T extends ZodTypeAny>(
-    schema: T,
-    data: unknown[]
-): z.infer<T>[];
-
-export function parseSchema<T extends ZodTypeAny>(
-    schema: T,
-    data: unknown
-): z.infer<T>;
-
-export function parseSchema<T extends ZodTypeAny>(
-    schema: T,
-    data: unknown | unknown[]
-) {
-    if (Array.isArray(data)) {
-        return data.map(item => schema.parse(item));
-    }
-
-    return schema.parse(data);
-}
-
-export function parseResult<T extends ZodTypeAny>(
-    schema: T,
-    result: PaginatedSuccessResult<unknown>
-): PaginatedSuccessResult<z.infer<T>>;
-
-export function parseResult<T extends ZodTypeAny>(
-    schema: T,
-    result: SuccessResult<unknown>
-): SuccessResult<z.infer<T>>;
-
-export function parseResult<T extends ZodTypeAny>(
-    schema: T,
-    result: SuccessResult<unknown> | PaginatedSuccessResult<unknown>
-) {
-    if (!result.data) return result;
-
-    if (Array.isArray(result.data)) {
-        return {
-            ...result,
-            data: result.data.map(item => schema.parse(item)),
-        };
-    }
-
-    return {
-        ...result,
-        data: schema.parse(result.data),
-    };
+import z, { ZodTypeAny } from "zod";
+import { PaginatedSuccessResult, SuccessResult } from "../api/types";
+
+/* Overloads */
+export function parseSchema<T extends ZodTypeAny>(
+    schema: T,
+    data: unknown[]
+): z.infer<T>[];
+
+export function parseSchema<T extends ZodTypeAny>(
+    schema: T,
+    data: unknown
+): z.infer<T>;
+
+export function parseSchema<T extends ZodTypeAny>(
+    schema: T,
+    data: unknown | unknown[]
+) {
+    if (Array.isArray(data)) {
+        return data.map(item => schema.parse(item));
+    }
+
+    return schema.parse(data);
+}
+
+export function parseResult<T extends ZodTypeAny>(
+    schema: T,
+    result: PaginatedSuccessResult<unknown>
+): PaginatedSuccessResult<z.infer<T>>;
+
+export function parseResult<T extends ZodTypeAny>(
+    schema: T,
+    result: SuccessResult<unknown>
+): SuccessResult<z.infer<T>>;
+
+export function parseResult<T extends ZodTypeAny>(
+    schema: T,
+    result: SuccessResult<unknown> | PaginatedSuccessResult<unknown>
+) {
+    if (!result.data) return result;
+
+    if (Array.isArray(result.data)) {
+        return {
+            ...result,
+            data: result.data.map(item => schema.parse(item)),
+        };
+    }
+
+    return {
+        ...result,
+        data: schema.parse(result.data),
+    };
 }

package/src/infra/utils/percentage.ts

@@ -1,42 +1,42 @@
-/**
- * Calcula percentual de um valor em relação ao total
- * @param current - Valor atual
- * @param total - Valor total
- * @returns Percentual (0-100)
- */
-export const calculatePercentage = (current: number, total: number): number => {
-  if (total === 0) return 0;
-  return (current / total) * 100;
-};
-
-/**
- * Calcula a circunferência de um círculo
- * @param radius - Raio do círculo
- * @returns Circunferência
- */
-export const calculateCircumference = (radius: number): number => {
-  return 2 * Math.PI * radius;
-};
-
-/**
- * Calcula o offset para circular progress
- * @param percentage - Percentual de progresso (0-100)
- * @param circumference - Circunferência do círculo
- * @returns Valor do offset
- */
-export const calculateCircularProgressOffset = (
-  percentage: number,
-  circumference: number
-): number => {
-  return circumference - (percentage / 100) * circumference;
-};
-
-/**
- * Calcula raio de círculo baseado no tamanho e stroke
- * @param size - Tamanho total
- * @param strokeWidth - Largura do stroke
- * @returns Raio calculado
- */
-export const calculateRadius = (size: number, strokeWidth: number): number => {
-  return (size - strokeWidth) / 2;
-};
+/**
+ * Calcula percentual de um valor em relação ao total
+ * @param current - Valor atual
+ * @param total - Valor total
+ * @returns Percentual (0-100)
+ */
+export const calculatePercentage = (current: number, total: number): number => {
+  if (total === 0) return 0;
+  return (current / total) * 100;
+};
+
+/**
+ * Calcula a circunferência de um círculo
+ * @param radius - Raio do círculo
+ * @returns Circunferência
+ */
+export const calculateCircumference = (radius: number): number => {
+  return 2 * Math.PI * radius;
+};
+
+/**
+ * Calcula o offset para circular progress
+ * @param percentage - Percentual de progresso (0-100)
+ * @param circumference - Circunferência do círculo
+ * @returns Valor do offset
+ */
+export const calculateCircularProgressOffset = (
+  percentage: number,
+  circumference: number
+): number => {
+  return circumference - (percentage / 100) * circumference;
+};
+
+/**
+ * Calcula raio de círculo baseado no tamanho e stroke
+ * @param size - Tamanho total
+ * @param strokeWidth - Largura do stroke
+ * @returns Raio calculado
+ */
+export const calculateRadius = (size: number, strokeWidth: number): number => {
+  return (size - strokeWidth) / 2;
+};

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';

package/src/modules/accounts/actions/account-management.action.ts

@@ -1,107 +1,107 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { accountService } from '../services/account.service';
-import type {
-  AccountUsersPaginationParams,
-  ChangePasswordRequest,
-  CreateAccountUserRequest,
-  UpdateAccountRequest,
-  UpdateAccountUserRequest,
-} from '../types';
-import { twoFactorService } from '../services/two-factor.service';
-import { findUserById } from '../../users/action/find-user-by-id.action';
-import { UserProfile } from '../../users/schema';
-import { ApiError } from '../../../infra/api/types';
-
-export async function listAccountUsersAction(params?: AccountUsersPaginationParams) {
-  return safeServerAction(async () => {
-    const { users, total } = await accountService.listAccountUsers(params);
-    return { data: users, total };
-  });
-}
-
-export async function updateUserAction(user: UpdateAccountUserRequest) {
-  return safeServerAction(() => accountService.updateAccountUser(user));
-}
-
-export async function updateAccountUserByIdAction(
-  userId: number,
-  user: UpdateAccountUserRequest
-) {
-  return safeServerAction(() => accountService.updateAccountUserById(userId, user));
-}
-
-export async function updateAccountAction(data: UpdateAccountRequest) {
-  return safeServerAction(async () => {
-    if (data.name !== undefined) {
-      const userResult = await findUserById();
-      if (!userResult.success || userResult.data?.profile !== UserProfile.owner) {
-        throw new ApiError(
-          'Apenas o proprietário da conta pode alterar o nome da empresa',
-          'FORBIDDEN',
-          403
-        );
-      }
-    }
-
-    return accountService.updateAccount(data);
-  });
-}
-
-export async function deleteAccountUserAction(userId: number) {
-  return safeServerAction(() => accountService.deleteAccountUser(userId));
-}
-
-export async function deleteAccountAction() {
-  return safeServerAction(() => accountService.deleteAccount());
-}
-
-export async function createAccountUserAction(user: CreateAccountUserRequest) {
-  return safeServerAction(() => accountService.createAccountUser(user));
-}
-
-export async function changePasswordAction(data: ChangePasswordRequest) {
-  return safeServerAction(() => accountService.changePassword(data));
-}
-
-export async function requestEmailChangeAction(newEmail: string) {
-  return safeServerAction(() => accountService.requestContactReset('email', newEmail));
-}
-
-export async function confirmEmailChangeAction(token: string, newEmail: string) {
-  return safeServerAction(() => accountService.confirmContactReset('email', token, newEmail));
-}
-
-export async function requestPhoneChangeAction(newPhone: string, ddi?: string) {
-  return safeServerAction(() => accountService.requestContactReset('phone', newPhone, ddi));
-}
-
-export async function confirmPhoneChangeAction(token: string, newPhone: string, ddi?: string) {
-  return safeServerAction(() => accountService.confirmContactReset('phone', token, newPhone, ddi));
-}
-
-export async function generateTwoFactorAction() {
-  return safeServerAction(async () => {
-    const result = await twoFactorService.generate();
-    return {
-      qrcode: result.data.qrcode,
-      backupCodes: result.data.backup_codes,
-    };
-  });
-}
-
-export async function confirmTwoFactorAction(code: string) {
-  return safeServerAction(async () => {
-    await twoFactorService.confirm(code);
-    await accountService.updateAccountUser({ two_factor_authentication: true });
-  });
-}
-
-export async function disableTwoFactorAction(code: string) {
-  return safeServerAction(async () => {
-    await twoFactorService.verify(code);
-    await twoFactorService.disable();
-    await accountService.updateAccountUser({ two_factor_authentication: false });
-  });
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { accountService } from '../services/account.service';
+import type {
+  AccountUsersPaginationParams,
+  ChangePasswordRequest,
+  CreateAccountUserRequest,
+  UpdateAccountRequest,
+  UpdateAccountUserRequest,
+} from '../types';
+import { twoFactorService } from '../services/two-factor.service';
+import { findUserById } from '../../users/action/find-user-by-id.action';
+import { UserProfile } from '../../users/schema';
+import { ApiError } from '../../../infra/api/types';
+
+export async function listAccountUsersAction(params?: AccountUsersPaginationParams) {
+  return safeServerAction(async () => {
+    const { users, total } = await accountService.listAccountUsers(params);
+    return { data: users, total };
+  });
+}
+
+export async function updateUserAction(user: UpdateAccountUserRequest) {
+  return safeServerAction(() => accountService.updateAccountUser(user));
+}
+
+export async function updateAccountUserByIdAction(
+  userId: number,
+  user: UpdateAccountUserRequest
+) {
+  return safeServerAction(() => accountService.updateAccountUserById(userId, user));
+}
+
+export async function updateAccountAction(data: UpdateAccountRequest) {
+  return safeServerAction(async () => {
+    if (data.name !== undefined) {
+      const userResult = await findUserById();
+      if (!userResult.success || userResult.data?.profile !== UserProfile.owner) {
+        throw new ApiError(
+          'Apenas o proprietário da conta pode alterar o nome da empresa',
+          'FORBIDDEN',
+          403
+        );
+      }
+    }
+
+    return accountService.updateAccount(data);
+  });
+}
+
+export async function deleteAccountUserAction(userId: number) {
+  return safeServerAction(() => accountService.deleteAccountUser(userId));
+}
+
+export async function deleteAccountAction() {
+  return safeServerAction(() => accountService.deleteAccount());
+}
+
+export async function createAccountUserAction(user: CreateAccountUserRequest) {
+  return safeServerAction(() => accountService.createAccountUser(user));
+}
+
+export async function changePasswordAction(data: ChangePasswordRequest) {
+  return safeServerAction(() => accountService.changePassword(data));
+}
+
+export async function requestEmailChangeAction(newEmail: string) {
+  return safeServerAction(() => accountService.requestContactReset('email', newEmail));
+}
+
+export async function confirmEmailChangeAction(token: string, newEmail: string) {
+  return safeServerAction(() => accountService.confirmContactReset('email', token, newEmail));
+}
+
+export async function requestPhoneChangeAction(newPhone: string, ddi?: string) {
+  return safeServerAction(() => accountService.requestContactReset('phone', newPhone, ddi));
+}
+
+export async function confirmPhoneChangeAction(token: string, newPhone: string, ddi?: string) {
+  return safeServerAction(() => accountService.confirmContactReset('phone', token, newPhone, ddi));
+}
+
+export async function generateTwoFactorAction() {
+  return safeServerAction(async () => {
+    const result = await twoFactorService.generate();
+    return {
+      qrcode: result.data.qrcode,
+      backupCodes: result.data.backup_codes,
+    };
+  });
+}
+
+export async function confirmTwoFactorAction(code: string) {
+  return safeServerAction(async () => {
+    await twoFactorService.confirm(code);
+    await accountService.updateAccountUser({ two_factor_authentication: true });
+  });
+}
+
+export async function disableTwoFactorAction(code: string) {
+  return safeServerAction(async () => {
+    await twoFactorService.verify(code);
+    await twoFactorService.disable();
+    await accountService.updateAccountUser({ two_factor_authentication: false });
+  });
+}

package/src/modules/accounts/actions/find-current-account.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { accountService } from '../services/account.service';
-import type { Account } from '../types';
-
-export async function findCurrentAccount() {
-  return safeServerAction<Account>(() => accountService.findCurrentAccount());
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { accountService } from '../services/account.service';
+import type { Account } from '../types';
+
+export async function findCurrentAccount() {
+  return safeServerAction<Account>(() => accountService.findCurrentAccount());
+}

package/src/modules/accounts/actions/list-currencies.action.ts

@@ -1,8 +1,8 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { currencyService } from '../services/currency.service';
-
-export async function listCurrenciesAction() {
-  return safeServerAction(() => currencyService.fetchOptions());
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { currencyService } from '../services/currency.service';
+
+export async function listCurrenciesAction() {
+  return safeServerAction(() => currencyService.fetchOptions());
+}

package/src/modules/accounts/actions/list-timezones.action.ts

@@ -1,8 +1,8 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { timezoneService } from '../services/timezone.service';
-
-export async function listTimezonesAction() {
-  return safeServerAction(() => timezoneService.fetchOptions());
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { timezoneService } from '../services/timezone.service';
+
+export async function listTimezonesAction() {
+  return safeServerAction(() => timezoneService.fetchOptions());
+}

package/src/modules/accounts/hooks/current-account.hook.tsx

@@ -1,22 +1,22 @@
-'use client';
-
-import { useQuery, useQueryClient } from '@tanstack/react-query';
-import { findCurrentAccount } from '../actions/find-current-account.action';
-import { withAction } from '../../../utils/withAction';
-
-export const ACCOUNT_QUERY_KEY = ['account'];
-
-export function useCurrentAccount() {
-  return useQuery({
-    queryKey: ACCOUNT_QUERY_KEY,
-    queryFn: withAction(findCurrentAccount),
-    staleTime: 0,
-    gcTime: 10 * 60 * 1000,
-    retry: false,
-  });
-}
-
-export function useInvalidateAccount() {
-  const queryClient = useQueryClient();
-  return () => queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
-}
+'use client';
+
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { findCurrentAccount } from '../actions/find-current-account.action';
+import { withAction } from '../../../utils/withAction';
+
+export const ACCOUNT_QUERY_KEY = ['account'];
+
+export function useCurrentAccount() {
+  return useQuery({
+    queryKey: ACCOUNT_QUERY_KEY,
+    queryFn: withAction(findCurrentAccount),
+    staleTime: 0,
+    gcTime: 10 * 60 * 1000,
+    retry: false,
+  });
+}
+
+export function useInvalidateAccount() {
+  const queryClient = useQueryClient();
+  return () => queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
+}