@greatapps/common 1.1.517 → 1.1.519

package/src/modules/projects/hooks/update-project.hook.ts

@@ -1,86 +1,86 @@
-'use client';
-
-import { useMutation, useQueryClient, InfiniteData, Query } from '@tanstack/react-query';
-import { updateProjectAction } from '../actions/update-project.action';
-import { withAction } from '../../../utils/withAction';
-import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
-import { PROJECTS_BASE_KEY } from './list-projects.hook';
-import { insertSorted, buildCompareFn } from '../../../infra/utils/array';
-import type { Project, ProjectsPage, UpdateProjectRequest } from '../types';
-
-function extractSort(query: Query): string | undefined {
-  const key = query.queryKey;
-  for (let i = key.length - 1; i >= 0; i--) {
-    const segment = key[i];
-    if (segment && typeof segment === 'object' && 'sort' in segment) {
-      return (segment as Record<string, unknown>).sort as string | undefined;
-    }
-  }
-  return undefined;
-}
-
-export function useUpdateProject() {
-  const queryClient = useQueryClient();
-  const projectsKey = useAuthQueryKey([...PROJECTS_BASE_KEY]);
-
-  return useMutation({
-    mutationFn: ({ projectId, data }: { projectId: number; data: UpdateProjectRequest }) =>
-      withAction(updateProjectAction)(projectId, data),
-
-    onSuccess: (updatedProject: Project, { projectId }) => {
-      const cache = queryClient.getQueryCache();
-      const queries = cache.findAll({ queryKey: projectsKey });
-
-      for (const query of queries) {
-        const sort = extractSort(query);
-        const isInfinite = query.queryKey.includes('infinite');
-
-        if (isInfinite) {
-          queryClient.setQueryData<InfiniteData<ProjectsPage>>(
-            query.queryKey,
-            (old) => {
-              if (!old?.pages.length) return old;
-
-              const pageSize = old.pages[0].data.length || 20;
-              const allItems = old.pages.flatMap((page) => page.data);
-              const without = allItems.filter((p) => p.id !== projectId);
-
-              const withUpdated = sort
-                ? insertSorted(without, updatedProject, buildCompareFn<Project>(sort))
-                : [updatedProject, ...without];
-
-              return {
-                ...old,
-                pages: old.pages.map((page, i) => ({
-                  ...page,
-                  data: withUpdated.slice(i * pageSize, (i + 1) * pageSize),
-                })),
-              };
-            },
-          );
-        } else {
-          queryClient.setQueryData<ProjectsPage>(
-            query.queryKey,
-            (old) => {
-              if (!old) return old;
-
-              const pageSize = old.data.length || 20;
-              const without = old.data.filter((p) => p.id !== projectId);
-
-              const withUpdated = sort
-                ? insertSorted(without, updatedProject, buildCompareFn<Project>(sort))
-                : [updatedProject, ...without];
-
-              return {
-                ...old,
-                data: withUpdated.slice(0, pageSize),
-              };
-            },
-          );
-        }
-      }
-
-      queryClient.invalidateQueries({ queryKey: projectsKey });
-    },
-  });
-}
+'use client';
+
+import { useMutation, useQueryClient, InfiniteData, Query } from '@tanstack/react-query';
+import { updateProjectAction } from '../actions/update-project.action';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { PROJECTS_BASE_KEY } from './list-projects.hook';
+import { insertSorted, buildCompareFn } from '../../../infra/utils/array';
+import type { Project, ProjectsPage, UpdateProjectRequest } from '../types';
+
+function extractSort(query: Query): string | undefined {
+  const key = query.queryKey;
+  for (let i = key.length - 1; i >= 0; i--) {
+    const segment = key[i];
+    if (segment && typeof segment === 'object' && 'sort' in segment) {
+      return (segment as Record<string, unknown>).sort as string | undefined;
+    }
+  }
+  return undefined;
+}
+
+export function useUpdateProject() {
+  const queryClient = useQueryClient();
+  const projectsKey = useAuthQueryKey([...PROJECTS_BASE_KEY]);
+
+  return useMutation({
+    mutationFn: ({ projectId, data }: { projectId: number; data: UpdateProjectRequest }) =>
+      withAction(updateProjectAction)(projectId, data),
+
+    onSuccess: (updatedProject: Project, { projectId }) => {
+      const cache = queryClient.getQueryCache();
+      const queries = cache.findAll({ queryKey: projectsKey });
+
+      for (const query of queries) {
+        const sort = extractSort(query);
+        const isInfinite = query.queryKey.includes('infinite');
+
+        if (isInfinite) {
+          queryClient.setQueryData<InfiniteData<ProjectsPage>>(
+            query.queryKey,
+            (old) => {
+              if (!old?.pages.length) return old;
+
+              const pageSize = old.pages[0].data.length || 20;
+              const allItems = old.pages.flatMap((page) => page.data);
+              const without = allItems.filter((p) => p.id !== projectId);
+
+              const withUpdated = sort
+                ? insertSorted(without, updatedProject, buildCompareFn<Project>(sort))
+                : [updatedProject, ...without];
+
+              return {
+                ...old,
+                pages: old.pages.map((page, i) => ({
+                  ...page,
+                  data: withUpdated.slice(i * pageSize, (i + 1) * pageSize),
+                })),
+              };
+            },
+          );
+        } else {
+          queryClient.setQueryData<ProjectsPage>(
+            query.queryKey,
+            (old) => {
+              if (!old) return old;
+
+              const pageSize = old.data.length || 20;
+              const without = old.data.filter((p) => p.id !== projectId);
+
+              const withUpdated = sort
+                ? insertSorted(without, updatedProject, buildCompareFn<Project>(sort))
+                : [updatedProject, ...without];
+
+              return {
+                ...old,
+                data: withUpdated.slice(0, pageSize),
+              };
+            },
+          );
+        }
+      }
+
+      queryClient.invalidateQueries({ queryKey: projectsKey });
+    },
+  });
+}

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

@@ -1,144 +1,144 @@
-import 'server-only';
-
-import { api } from '../../../infra/api/client';
-import { ApiError } from '../../../infra/api/types';
-import { buildQueryParams } from '../../../infra/utils/params';
-import { getUserContext } from '../../auth/utils/get-user-context';
-import { assertManagementSubscription } from '../../auth/utils/assert-management-subscription';
-import {
-  Project,
-  ProjectSchema,
-  ProjectsPage,
-  CreateProjectRequest,
-  UpdateProjectRequest,
-} from '../types';
-
-interface ApiListResponse<T> {
-  data: T[];
-  total: number;
-  status: number;
-  message?: string;
-}
-
-interface ApiMutationResponse {
-  status: number;
-  message?: string;
-  data?: Project[];
-}
-
-interface ListProjectsParams {
-  page?: number;
-  limit?: number;
-  sort?: string;
-  search?: string;
-  deleted?: number;
-}
-
-class ProjectsService {
-  async list(params: ListProjectsParams = {}): Promise<ProjectsPage> {
-    const { id_account, id_user } = await getUserContext();
-    const query = buildQueryParams(params as Record<string, string | number | boolean | undefined>);
-    const url = `/account/${id_account}/user/${id_user}/projects${query ? `?${query}` : ''}`;
-
-    const response = await api.apps.get<ApiListResponse<Project>>(url);
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao listar projetos',
-        'LIST_PROJECTS_FAILED',
-        400
-      );
-    }
-
-    return {
-      data: (response.data || []).map((item) => ProjectSchema.parse(item)),
-      total: response.total || 0,
-      page: params.page ?? 1,
-    };
-  }
-
-  async findById(projectId: number): Promise<Project> {
-    const { id_account, id_user } = await getUserContext();
-    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}`;
-
-    const response = await api.apps.get<ApiMutationResponse>(url);
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao buscar projeto',
-        'FIND_PROJECT_FAILED',
-        400
-      );
-    }
-
-    if (!response.data || response.data.length === 0) {
-      throw new ApiError('Projeto não encontrado', 'PROJECT_NOT_FOUND', 404);
-    }
-
-    return ProjectSchema.parse(response.data[0]);
-  }
-
-  async create(data: CreateProjectRequest): Promise<Project> {
-    await assertManagementSubscription();
-    const { id_account, id_user } = await getUserContext();
-    const url = `/account/${id_account}/user/${id_user}/projects`;
-
-    const response = await api.apps.post<ApiMutationResponse>(url, data);
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao criar projeto',
-        'CREATE_PROJECT_FAILED',
-        400
-      );
-    }
-
-    if (!response.data || response.data.length === 0) {
-      throw new ApiError('Resposta inválida ao criar projeto', 'INVALID_RESPONSE', 500);
-    }
-
-    return ProjectSchema.parse(response.data[0]);
-  }
-
-  async update(projectId: number, data: UpdateProjectRequest): Promise<Project> {
-    await assertManagementSubscription();
-    const { id_account, id_user } = await getUserContext();
-    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}`;
-
-    const response = await api.apps.put<ApiMutationResponse>(url, data);
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao atualizar projeto',
-        'UPDATE_PROJECT_FAILED',
-        400
-      );
-    }
-
-    if (!response.data || response.data.length === 0) {
-      throw new ApiError('Resposta inválida ao atualizar projeto', 'INVALID_RESPONSE', 500);
-    }
-
-    return ProjectSchema.parse(response.data[0]);
-  }
-
-  async delete(projectId: number, moveToProjectId: number): Promise<void> {
-    await assertManagementSubscription();
-    const { id_account, id_user } = await getUserContext();
-    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}`;
-
-    const response = await api.apps.delete<ApiMutationResponse>(url, {
-      body: JSON.stringify({ id_project_to_move: moveToProjectId }),
-    });
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao deletar projeto',
-        'DELETE_PROJECT_FAILED',
-        400
-      );
-    }
-  }
-}
-
-export const projectsService = new ProjectsService();
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import { ApiError } from '../../../infra/api/types';
+import { buildQueryParams } from '../../../infra/utils/params';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import { assertManagementSubscription } from '../../auth/utils/assert-management-subscription';
+import {
+  Project,
+  ProjectSchema,
+  ProjectsPage,
+  CreateProjectRequest,
+  UpdateProjectRequest,
+} from '../types';
+
+interface ApiListResponse<T> {
+  data: T[];
+  total: number;
+  status: number;
+  message?: string;
+}
+
+interface ApiMutationResponse {
+  status: number;
+  message?: string;
+  data?: Project[];
+}
+
+interface ListProjectsParams {
+  page?: number;
+  limit?: number;
+  sort?: string;
+  search?: string;
+  deleted?: number;
+}
+
+class ProjectsService {
+  async list(params: ListProjectsParams = {}): Promise<ProjectsPage> {
+    const { id_account, id_user } = await getUserContext();
+    const query = buildQueryParams(params as Record<string, string | number | boolean | undefined>);
+    const url = `/account/${id_account}/user/${id_user}/projects${query ? `?${query}` : ''}`;
+
+    const response = await api.apps.get<ApiListResponse<Project>>(url);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao listar projetos',
+        'LIST_PROJECTS_FAILED',
+        400
+      );
+    }
+
+    return {
+      data: (response.data || []).map((item) => ProjectSchema.parse(item)),
+      total: response.total || 0,
+      page: params.page ?? 1,
+    };
+  }
+
+  async findById(projectId: number): Promise<Project> {
+    const { id_account, id_user } = await getUserContext();
+    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}`;
+
+    const response = await api.apps.get<ApiMutationResponse>(url);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao buscar projeto',
+        'FIND_PROJECT_FAILED',
+        400
+      );
+    }
+
+    if (!response.data || response.data.length === 0) {
+      throw new ApiError('Projeto não encontrado', 'PROJECT_NOT_FOUND', 404);
+    }
+
+    return ProjectSchema.parse(response.data[0]);
+  }
+
+  async create(data: CreateProjectRequest): Promise<Project> {
+    await assertManagementSubscription();
+    const { id_account, id_user } = await getUserContext();
+    const url = `/account/${id_account}/user/${id_user}/projects`;
+
+    const response = await api.apps.post<ApiMutationResponse>(url, data);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao criar projeto',
+        'CREATE_PROJECT_FAILED',
+        400
+      );
+    }
+
+    if (!response.data || response.data.length === 0) {
+      throw new ApiError('Resposta inválida ao criar projeto', 'INVALID_RESPONSE', 500);
+    }
+
+    return ProjectSchema.parse(response.data[0]);
+  }
+
+  async update(projectId: number, data: UpdateProjectRequest): Promise<Project> {
+    await assertManagementSubscription();
+    const { id_account, id_user } = await getUserContext();
+    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}`;
+
+    const response = await api.apps.put<ApiMutationResponse>(url, data);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao atualizar projeto',
+        'UPDATE_PROJECT_FAILED',
+        400
+      );
+    }
+
+    if (!response.data || response.data.length === 0) {
+      throw new ApiError('Resposta inválida ao atualizar projeto', 'INVALID_RESPONSE', 500);
+    }
+
+    return ProjectSchema.parse(response.data[0]);
+  }
+
+  async delete(projectId: number, moveToProjectId: number): Promise<void> {
+    await assertManagementSubscription();
+    const { id_account, id_user } = await getUserContext();
+    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}`;
+
+    const response = await api.apps.delete<ApiMutationResponse>(url, {
+      body: JSON.stringify({ id_project_to_move: moveToProjectId }),
+    });
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao deletar projeto',
+        'DELETE_PROJECT_FAILED',
+        400
+      );
+    }
+  }
+}
+
+export const projectsService = new ProjectsService();

package/src/modules/subscriptions/actions/calculate-subscription.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import type { CalculateSubscriptionRequest } from '../types/calculate-subscription.type';
-import { subscriptionsService } from '../services/subscriptions.service';
-
-export async function calculateSubscriptionAction(data: CalculateSubscriptionRequest) {
-  return safeServerAction(() => subscriptionsService.calculateSubscription(data));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import type { CalculateSubscriptionRequest } from '../types/calculate-subscription.type';
+import { subscriptionsService } from '../services/subscriptions.service';
+
+export async function calculateSubscriptionAction(data: CalculateSubscriptionRequest) {
+  return safeServerAction(() => subscriptionsService.calculateSubscription(data));
+}

package/src/modules/subscriptions/actions/list-subscriptions.action.ts

@@ -1,9 +1,9 @@
-'use server';
-
-import { safeServerAction } from '../../../utils/safeServerAction';
-import type { FindSubscriptionsParams } from '../types/subscription.type';
-import { subscriptionsService } from '../services/subscriptions.service';
-
-export async function listSubscriptionsAction(params?: Partial<FindSubscriptionsParams>) {
-  return safeServerAction(() => subscriptionsService.listSubscriptions(params));
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import type { FindSubscriptionsParams } from '../types/subscription.type';
+import { subscriptionsService } from '../services/subscriptions.service';
+
+export async function listSubscriptionsAction(params?: Partial<FindSubscriptionsParams>) {
+  return safeServerAction(() => subscriptionsService.listSubscriptions(params));
+}

package/src/modules/subscriptions/actions/update-subscription-plan.action.ts

@@ -1,14 +1,14 @@
-"use server";
-
-import { safeServerAction } from "../../../utils/safeServerAction";
-import type { UpdateSubscriptionPlanRequest } from "../types/calculate-subscription.type";
-import { subscriptionsService } from "../services/subscriptions.service";
-
-export async function updateSubscriptionPlanAction(
-  subscriptionId: number | string,
-  data: UpdateSubscriptionPlanRequest,
-) {
-  return safeServerAction(async () => {
-    return subscriptionsService.updateSubscriptionPlan(subscriptionId, data);
-  });
-}
+"use server";
+
+import { safeServerAction } from "../../../utils/safeServerAction";
+import type { UpdateSubscriptionPlanRequest } from "../types/calculate-subscription.type";
+import { subscriptionsService } from "../services/subscriptions.service";
+
+export async function updateSubscriptionPlanAction(
+  subscriptionId: number | string,
+  data: UpdateSubscriptionPlanRequest,
+) {
+  return safeServerAction(async () => {
+    return subscriptionsService.updateSubscriptionPlan(subscriptionId, data);
+  });
+}

package/src/modules/subscriptions/constants/query-keys.constants.ts

@@ -1,3 +1,3 @@
-export const SUBSCRIPTIONS_QUERY_KEY = ['subscriptions'] as const;
-
-export const CHARGES_QUERY_KEY = ['charges'] as const;
+export const SUBSCRIPTIONS_QUERY_KEY = ['subscriptions'] as const;
+
+export const CHARGES_QUERY_KEY = ['charges'] as const;

package/src/modules/subscriptions/hooks/calculate-subscription.hook.ts

@@ -1,13 +1,13 @@
-'use client';
-
-import { useMutation } from '@tanstack/react-query';
-import { withAction } from '../../../utils/withAction';
-import { calculateSubscriptionAction } from '../actions/calculate-subscription.action';
-import type { CalculateSubscriptionRequest } from '../types/calculate-subscription.type';
-
-export function useCalculateSubscription() {
-  return useMutation({
-    mutationFn: (data: CalculateSubscriptionRequest) =>
-      withAction(calculateSubscriptionAction)(data),
-  });
-}
+'use client';
+
+import { useMutation } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { calculateSubscriptionAction } from '../actions/calculate-subscription.action';
+import type { CalculateSubscriptionRequest } from '../types/calculate-subscription.type';
+
+export function useCalculateSubscription() {
+  return useMutation({
+    mutationFn: (data: CalculateSubscriptionRequest) =>
+      withAction(calculateSubscriptionAction)(data),
+  });
+}

package/src/modules/subscriptions/hooks/find-active-subscription.hook.ts

@@ -1,18 +1,18 @@
-"use client";
-
-import { useQuery } from "@tanstack/react-query";
-import { listSubscriptionsAction } from "../actions/list-subscriptions.action";
-import { SUBSCRIPTIONS_QUERY_KEY } from "../constants/query-keys.constants";
-import { withAction } from "../../../utils/withAction";
-import { useAuthQueryKey } from "../../../hooks/useAuthQueryKey";
-
-export function useActiveSubscription() {
-  const queryKey = useAuthQueryKey([...SUBSCRIPTIONS_QUERY_KEY, "active"]);
-
-  return useQuery({
-    queryKey,
-    queryFn: async () => {
-      return await withAction(listSubscriptionsAction)({ limit: 1 });
-    },
-  });
-}
+"use client";
+
+import { useQuery } from "@tanstack/react-query";
+import { listSubscriptionsAction } from "../actions/list-subscriptions.action";
+import { SUBSCRIPTIONS_QUERY_KEY } from "../constants/query-keys.constants";
+import { withAction } from "../../../utils/withAction";
+import { useAuthQueryKey } from "../../../hooks/useAuthQueryKey";
+
+export function useActiveSubscription() {
+  const queryKey = useAuthQueryKey([...SUBSCRIPTIONS_QUERY_KEY, "active"]);
+
+  return useQuery({
+    queryKey,
+    queryFn: async () => {
+      return await withAction(listSubscriptionsAction)({ limit: 1 });
+    },
+  });
+}

package/src/modules/subscriptions/hooks/list-subscriptions.hook.ts

@@ -1,19 +1,19 @@
-'use client';
-
-import { useQuery } from '@tanstack/react-query';
-import { listSubscriptionsAction } from '../actions/list-subscriptions.action';
-import { parseResult } from '../../../infra/utils/parser';
-import { SubscriptionSchema, type FindSubscriptionsParams } from '../types/subscription.type';
-import { withAction } from '../../../utils/withAction';
-import { SUBSCRIPTIONS_QUERY_KEY } from '../constants/query-keys.constants';
-import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
-
-export function useSubscriptions(params?: Partial<FindSubscriptionsParams>) {
-  const queryKey = useAuthQueryKey([...SUBSCRIPTIONS_QUERY_KEY, params]);
-
-  return useQuery({
-    queryKey,
-    queryFn: async () =>
-      parseResult(SubscriptionSchema, await withAction(() => listSubscriptionsAction(params))()),
-  });
-}
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { listSubscriptionsAction } from '../actions/list-subscriptions.action';
+import { parseResult } from '../../../infra/utils/parser';
+import { SubscriptionSchema, type FindSubscriptionsParams } from '../types/subscription.type';
+import { withAction } from '../../../utils/withAction';
+import { SUBSCRIPTIONS_QUERY_KEY } from '../constants/query-keys.constants';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+
+export function useSubscriptions(params?: Partial<FindSubscriptionsParams>) {
+  const queryKey = useAuthQueryKey([...SUBSCRIPTIONS_QUERY_KEY, params]);
+
+  return useQuery({
+    queryKey,
+    queryFn: async () =>
+      parseResult(SubscriptionSchema, await withAction(() => listSubscriptionsAction(params))()),
+  });
+}