@greatapps/common 1.1.430 → 1.1.432

package/src/modules/cards/services/cards.service.ts

@@ -1,51 +1,51 @@
-import 'server-only';
-
-import { api } from '../../../infra/api/client';
-import { ApiError, ApiPaginatedActionResult, PaginatedSuccessResult, SuccessResult } from '../../../infra/api/types';
-import { buildQueryParams } from '../../../infra/utils/params';
-import { getUserContext } from '../../auth/utils/get-user-context';
-import { Card, CardSchema, CreateCardRequest } from '../types';
-
-class CardsService {
-  async listCards(): Promise<PaginatedSuccessResult<Card>> {
-    const { id_account } = await getUserContext();
-
-    const query = buildQueryParams({ id_account });
-    const response = await api.apps.get<ApiPaginatedActionResult<Card>>(
-      `/accounts/${id_account}/cards?${query}`
-    );
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao listar cartões',
-        'LIST_CARDS_FAILED',
-        400
-      );
-    }
-
-    const data = response.data.map((item) => CardSchema.parse(item));
-
-    return { data, total: response.total, success: true };
-  }
-  async createCard(data: CreateCardRequest): Promise<SuccessResult<Card>> {
-    const { id_account } = await getUserContext();
-
-    const response = await api.apps.post<ApiPaginatedActionResult<Card>>(
-      `/accounts/${id_account}/cards`,
-      data
-    );
-
-    if (response.status === 0) {
-      throw new ApiError(response.message || 'Erro ao criar cartão', 'CREATE_CARD_FAILED', 400);
-    }
-
-    const cardData = CardSchema.parse(response.data[0]);
-
-    return {
-      success: true,
-      data: cardData,
-    } satisfies SuccessResult<Card>;
-  }
-}
-
-export const cardsService = new CardsService();
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import { ApiError, ApiPaginatedActionResult, PaginatedSuccessResult, SuccessResult } from '../../../infra/api/types';
+import { buildQueryParams } from '../../../infra/utils/params';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import { Card, CardSchema, CreateCardRequest } from '../types';
+
+class CardsService {
+  async listCards(): Promise<PaginatedSuccessResult<Card>> {
+    const { id_account } = await getUserContext();
+
+    const query = buildQueryParams({ id_account });
+    const response = await api.apps.get<ApiPaginatedActionResult<Card>>(
+      `/accounts/${id_account}/cards?${query}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao listar cartões',
+        'LIST_CARDS_FAILED',
+        400
+      );
+    }
+
+    const data = response.data.map((item) => CardSchema.parse(item));
+
+    return { data, total: response.total, success: true };
+  }
+  async createCard(data: CreateCardRequest): Promise<SuccessResult<Card>> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.post<ApiPaginatedActionResult<Card>>(
+      `/accounts/${id_account}/cards`,
+      data
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Erro ao criar cartão', 'CREATE_CARD_FAILED', 400);
+    }
+
+    const cardData = CardSchema.parse(response.data[0]);
+
+    return {
+      success: true,
+      data: cardData,
+    } satisfies SuccessResult<Card>;
+  }
+}
+
+export const cardsService = new CardsService();

package/src/modules/cards/types.ts

@@ -1,32 +1,32 @@
-import z from 'zod';
-
-export const CardSchema = z.object({
-  id: z.union([z.number(), z.string()]),
-  id_wl: z.number().optional(),
-  id_account: z.union([z.number(), z.string()]).optional(),
-  id_gateway: z.union([z.number(), z.string()]).optional(),
-  gateway_account: z.string().optional(),
-  gateway_card: z.string().optional(),
-  brand: z.string(),
-  name: z.string(),
-  number: z.string(),
-  date: z.string().optional(),
-  deleted: z
-    .number()
-    .transform((val) => val === 1)
-    .optional()
-    .default(false),
-  is_default: z.boolean().optional().default(false),
-  datetime_add: z.union([z.date(), z.coerce.date()]).nullable().optional(),
-  datetime_alt: z.union([z.date(), z.coerce.date()]).nullable().optional(),
-  datetime_del: z.union([z.date(), z.coerce.date()]).nullable().optional(),
-});
-
-export type Card = z.infer<typeof CardSchema>;
-
-export const CreateCardRequestSchema = z.object({
-  payment_method_id: z.string().min(1, 'payment_method_id é obrigatório'),
-  set_default: z.boolean().optional(),
-});
-
-export type CreateCardRequest = z.infer<typeof CreateCardRequestSchema>;
+import z from 'zod';
+
+export const CardSchema = z.object({
+  id: z.union([z.number(), z.string()]),
+  id_wl: z.number().optional(),
+  id_account: z.union([z.number(), z.string()]).optional(),
+  id_gateway: z.union([z.number(), z.string()]).optional(),
+  gateway_account: z.string().optional(),
+  gateway_card: z.string().optional(),
+  brand: z.string(),
+  name: z.string(),
+  number: z.string(),
+  date: z.string().optional(),
+  deleted: z
+    .number()
+    .transform((val) => val === 1)
+    .optional()
+    .default(false),
+  is_default: z.boolean().optional().default(false),
+  datetime_add: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  datetime_alt: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  datetime_del: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+});
+
+export type Card = z.infer<typeof CardSchema>;
+
+export const CreateCardRequestSchema = z.object({
+  payment_method_id: z.string().min(1, 'payment_method_id é obrigatório'),
+  set_default: z.boolean().optional(),
+});
+
+export type CreateCardRequest = z.infer<typeof CreateCardRequestSchema>;

package/src/modules/ia-credits/actions/list-ia-credits.action.ts

@@ -1,8 +1,8 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { iaCreditsService } from '../services/ia-credits.service';
-
-export async function listIaCreditsAction(subscriptionId: number | string) {
-  return safeServerAction(() => iaCreditsService.listOperations(subscriptionId));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { iaCreditsService } from '../services/ia-credits.service';
+
+export async function listIaCreditsAction(subscriptionId: number | string) {
+  return safeServerAction(() => iaCreditsService.listOperations(subscriptionId));
+}

package/src/modules/plans/actions/find-plan-by-id.action.ts

@@ -1,8 +1,8 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { plansService } from '../services/plans.service';
-
-export async function findPlanByIdAction(idPlan: number | string) {
-  return safeServerAction(() => plansService.findById(idPlan));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { plansService } from '../services/plans.service';
+
+export async function findPlanByIdAction(idPlan: number | string) {
+  return safeServerAction(() => plansService.findById(idPlan));
+}

package/src/modules/plans/hooks/use-has-plan-addon.hook.ts

@@ -1,14 +1,14 @@
-'use client';
-
-import type { AddonKindEnum } from '../../subscriptions/constants/addons.constants';
-import { useActiveSubscription } from '../../subscriptions/hooks/find-active-subscription.hook';
-
-export function useHasPlanAddon(addonId: AddonKindEnum) {
-  const { data: subscriptionData, isLoading: isLoadingSubscription } = useActiveSubscription();
-  const activeSubscription = subscriptionData?.data?.[0] ?? null;
-
-  const hasAddon = !!activeSubscription?.items?.find((i) => i.id_addon === addonId);
-  const isLoading = isLoadingSubscription;
-
-  return { hasAddon, isLoading };
-}
+'use client';
+
+import type { AddonKindEnum } from '../../subscriptions/constants/addons.constants';
+import { useActiveSubscription } from '../../subscriptions/hooks/find-active-subscription.hook';
+
+export function useHasPlanAddon(addonId: AddonKindEnum) {
+  const { data: subscriptionData, isLoading: isLoadingSubscription } = useActiveSubscription();
+  const activeSubscription = subscriptionData?.data?.[0] ?? null;
+
+  const hasAddon = !!activeSubscription?.items?.find((i) => i.id_addon === addonId);
+  const isLoading = isLoadingSubscription;
+
+  return { hasAddon, isLoading };
+}

package/src/modules/plans/hooks/use-plan-by-id.hook.ts

@@ -1,13 +1,13 @@
-'use client';
-
-import { useQuery } from '@tanstack/react-query';
-import { withAction } from '../../../utils/withAction';
-import { findPlanByIdAction } from '../actions/find-plan-by-id.action';
-
-export function usePlanById(idPlan: number | string | undefined) {
-  return useQuery({
-    queryKey: ['plan', idPlan],
-    queryFn: withAction(() => findPlanByIdAction(idPlan!)),
-    enabled: !!idPlan,
-  });
-}
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { findPlanByIdAction } from '../actions/find-plan-by-id.action';
+
+export function usePlanById(idPlan: number | string | undefined) {
+  return useQuery({
+    queryKey: ['plan', idPlan],
+    queryFn: withAction(() => findPlanByIdAction(idPlan!)),
+    enabled: !!idPlan,
+  });
+}

package/src/modules/plans/services/plans.service.ts

@@ -1,36 +1,36 @@
-import 'server-only';
-
-import { api } from '../../../infra/api/client';
-import { ApiError, ApiPaginatedActionResult, SuccessResult } from '../../../infra/api/types';
-import { Plan, PlanSchema } from '../types/plan.type';
-
-class PlansService {
-  async findById(idPlan: number | string): Promise<SuccessResult<Plan>> {
-    const response = await api.apps.get<ApiPaginatedActionResult<Plan>>(
-      `/plans/${idPlan}?type=client`
-    );
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao buscar plano',
-        'FIND_PLAN_FAILED',
-        400
-      );
-    }
-
-    if (!response.data?.length) {
-      throw new ApiError(
-        'Plano não encontrado',
-        'PLAN_NOT_FOUND',
-        404
-      );
-    }
-
-    return {
-      success: true,
-      data: PlanSchema.parse(response.data[0]),
-    };
-  }
-}
-
-export const plansService = new PlansService();
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import { ApiError, ApiPaginatedActionResult, SuccessResult } from '../../../infra/api/types';
+import { Plan, PlanSchema } from '../types/plan.type';
+
+class PlansService {
+  async findById(idPlan: number | string): Promise<SuccessResult<Plan>> {
+    const response = await api.apps.get<ApiPaginatedActionResult<Plan>>(
+      `/plans/${idPlan}?type=client`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao buscar plano',
+        'FIND_PLAN_FAILED',
+        400
+      );
+    }
+
+    if (!response.data?.length) {
+      throw new ApiError(
+        'Plano não encontrado',
+        'PLAN_NOT_FOUND',
+        404
+      );
+    }
+
+    return {
+      success: true,
+      data: PlanSchema.parse(response.data[0]),
+    };
+  }
+}
+
+export const plansService = new PlansService();

package/src/modules/plans/types/plan.type.ts

@@ -1,21 +1,21 @@
-import z from 'zod';
-
-export const PlanItemSchema = z.object({
-  id_addon: z.number(),
-  quantity: z.number(),
-  value: z.number(),
-});
-
-export type PlanItem = z.infer<typeof PlanItemSchema>;
-
-export const PlanSchema = z.object({
-  id: z.number(),
-  name: z.string(),
-  value: z.number().default(0),
-  type: z.string().optional(),
-  discount_semester: z.number().default(0),
-  discount_annual: z.number().default(0),
-  items: z.array(PlanItemSchema).optional().default([]),
-});
-
-export type Plan = z.infer<typeof PlanSchema>;
+import z from 'zod';
+
+export const PlanItemSchema = z.object({
+  id_addon: z.number(),
+  quantity: z.number(),
+  value: z.number(),
+});
+
+export type PlanItem = z.infer<typeof PlanItemSchema>;
+
+export const PlanSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  value: z.number().default(0),
+  type: z.string().optional(),
+  discount_semester: z.number().default(0),
+  discount_annual: z.number().default(0),
+  items: z.array(PlanItemSchema).optional().default([]),
+});
+
+export type Plan = z.infer<typeof PlanSchema>;

package/src/modules/projects/actions/add-project-user.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { projectUsersService } from '../services/project-users.service';
-import type { AddRemoveProjectUsersParams } from '../types';
-
-export async function addProjectUserAction(params: AddRemoveProjectUsersParams) {
-  return safeServerAction(() => projectUsersService.addToProject(params));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { projectUsersService } from '../services/project-users.service';
+import type { AddRemoveProjectUsersParams } from '../types';
+
+export async function addProjectUserAction(params: AddRemoveProjectUsersParams) {
+  return safeServerAction(() => projectUsersService.addToProject(params));
+}

package/src/modules/projects/actions/list-all-account-users.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { projectUsersService } from '../services/project-users.service';
-import type { ListUsersParams } from '../types';
-
-export async function listAllAccountUsersAction(params: ListUsersParams = {}) {
-  return safeServerAction(() => projectUsersService.listAllAccountUsers(params));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { projectUsersService } from '../services/project-users.service';
+import type { ListUsersParams } from '../types';
+
+export async function listAllAccountUsersAction(params: ListUsersParams = {}) {
+  return safeServerAction(() => projectUsersService.listAllAccountUsers(params));
+}

package/src/modules/projects/actions/list-available-users.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { projectUsersService } from '../services/project-users.service';
-import type { ListUsersParams } from '../types';
-
-export async function listAvailableUsersAction(projectId: number, params: ListUsersParams = {}) {
-  return safeServerAction(() => projectUsersService.listNotInProject(projectId, params));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { projectUsersService } from '../services/project-users.service';
+import type { ListUsersParams } from '../types';
+
+export async function listAvailableUsersAction(projectId: number, params: ListUsersParams = {}) {
+  return safeServerAction(() => projectUsersService.listNotInProject(projectId, params));
+}

package/src/modules/projects/actions/list-project-users.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { projectUsersService } from '../services/project-users.service';
-import type { ListUsersParams } from '../types';
-
-export async function listProjectUsersAction(projectId: number, params: ListUsersParams = {}) {
-  return safeServerAction(() => projectUsersService.listInProject(projectId, params));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { projectUsersService } from '../services/project-users.service';
+import type { ListUsersParams } from '../types';
+
+export async function listProjectUsersAction(projectId: number, params: ListUsersParams = {}) {
+  return safeServerAction(() => projectUsersService.listInProject(projectId, params));
+}

package/src/modules/projects/actions/remove-project-user.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import { projectUsersService } from '../services/project-users.service';
-import type { AddRemoveProjectUsersParams } from '../types';
-
-export async function removeProjectUserAction(params: AddRemoveProjectUsersParams) {
-  return safeServerAction(() => projectUsersService.removeFromProject(params));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { projectUsersService } from '../services/project-users.service';
+import type { AddRemoveProjectUsersParams } from '../types';
+
+export async function removeProjectUserAction(params: AddRemoveProjectUsersParams) {
+  return safeServerAction(() => projectUsersService.removeFromProject(params));
+}

package/src/modules/projects/hooks/add-project-user.hook.ts

@@ -1,69 +1,69 @@
-'use client';
-
-import { useQueryClient, useMutation, InfiniteData } from '@tanstack/react-query';
-import { addProjectUserAction } from '../actions/add-project-user.action';
-import { LIST_PROJECT_USERS_BASE_KEY } from './list-project-users.hook';
-import { LIST_ALL_ACCOUNT_USERS_BASE_KEY } from './list-all-account-users.hook';
-import type { UsersPage, AccountUser, ProjectUser } from '../types';
-
-export function useAddProjectUser(projectId: number) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (userId: number) =>
-      addProjectUserAction({ projectId, users: [userId] }),
-
-    onMutate: async (userId) => {
-      await queryClient.cancelQueries({ queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY() });
-      await queryClient.cancelQueries({ queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId) });
-
-      const prevAccountUsers = queryClient.getQueriesData<InfiniteData<UsersPage<AccountUser>>>({
-        queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY(),
-      });
-      const prevProjectUsers = queryClient.getQueriesData<InfiniteData<UsersPage<ProjectUser>>>({
-        queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId),
-      });
-
-      queryClient.setQueriesData<InfiniteData<UsersPage<AccountUser>>>(
-        { queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY(), exact: false },
-        (old) => {
-          if (!old) return old;
-          return {
-            ...old,
-            pages: old.pages.map((page) => ({
-              ...page,
-              data: page.data.map((u) =>
-                u.id === userId ? { ...u, in_project: true } : u
-              ),
-            })),
-          };
-        }
-      );
-
-      queryClient.setQueriesData<InfiniteData<UsersPage<ProjectUser>>>(
-        { queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId), exact: false },
-        (old) => {
-          if (!old?.pages.length) return old;
-          return {
-            ...old,
-            pages: old.pages.map((page, i) =>
-              i === 0 ? { ...page, total: page.total + 1 } : page
-            ),
-          };
-        }
-      );
-
-      return { prevAccountUsers, prevProjectUsers };
-    },
-
-    onError: (_err, _userId, ctx) => {
-      ctx?.prevAccountUsers.forEach(([key, data]) => queryClient.setQueryData(key, data));
-      ctx?.prevProjectUsers.forEach(([key, data]) => queryClient.setQueryData(key, data));
-    },
-
-    onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId) });
-      queryClient.invalidateQueries({ queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY() });
-    },
-  });
-}
+'use client';
+
+import { useQueryClient, useMutation, InfiniteData } from '@tanstack/react-query';
+import { addProjectUserAction } from '../actions/add-project-user.action';
+import { LIST_PROJECT_USERS_BASE_KEY } from './list-project-users.hook';
+import { LIST_ALL_ACCOUNT_USERS_BASE_KEY } from './list-all-account-users.hook';
+import type { UsersPage, AccountUser, ProjectUser } from '../types';
+
+export function useAddProjectUser(projectId: number) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (userId: number) =>
+      addProjectUserAction({ projectId, users: [userId] }),
+
+    onMutate: async (userId) => {
+      await queryClient.cancelQueries({ queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY() });
+      await queryClient.cancelQueries({ queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId) });
+
+      const prevAccountUsers = queryClient.getQueriesData<InfiniteData<UsersPage<AccountUser>>>({
+        queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY(),
+      });
+      const prevProjectUsers = queryClient.getQueriesData<InfiniteData<UsersPage<ProjectUser>>>({
+        queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId),
+      });
+
+      queryClient.setQueriesData<InfiniteData<UsersPage<AccountUser>>>(
+        { queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY(), exact: false },
+        (old) => {
+          if (!old) return old;
+          return {
+            ...old,
+            pages: old.pages.map((page) => ({
+              ...page,
+              data: page.data.map((u) =>
+                u.id === userId ? { ...u, in_project: true } : u
+              ),
+            })),
+          };
+        }
+      );
+
+      queryClient.setQueriesData<InfiniteData<UsersPage<ProjectUser>>>(
+        { queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId), exact: false },
+        (old) => {
+          if (!old?.pages.length) return old;
+          return {
+            ...old,
+            pages: old.pages.map((page, i) =>
+              i === 0 ? { ...page, total: page.total + 1 } : page
+            ),
+          };
+        }
+      );
+
+      return { prevAccountUsers, prevProjectUsers };
+    },
+
+    onError: (_err, _userId, ctx) => {
+      ctx?.prevAccountUsers.forEach(([key, data]) => queryClient.setQueryData(key, data));
+      ctx?.prevProjectUsers.forEach(([key, data]) => queryClient.setQueryData(key, data));
+    },
+
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: LIST_PROJECT_USERS_BASE_KEY(projectId) });
+      queryClient.invalidateQueries({ queryKey: LIST_ALL_ACCOUNT_USERS_BASE_KEY() });
+    },
+  });
+}