@greatapps/common 1.1.237 → 1.1.239

package/src/index.ts

@@ -43,6 +43,9 @@ export {
 export { useActiveSubscription } from "./modules/subscriptions/hooks/find-active-subscription.hook";
 export { usePlanById } from "./modules/subscriptions/hooks/use-plan-by-id.hook";
 export { useHasPlanAddon } from "./modules/subscriptions/hooks/use-has-plan-addon.hook";
+export { useCalculateSubscription } from "./modules/subscriptions/hooks/calculate-subscription.hook";
+export { useUpdateSubscriptionPlan } from "./modules/subscriptions/hooks/update-subscription-plan.hook";
+export { useCards, CARDS_QUERY_KEY } from "./modules/cards/hooks/cards.hook";
 export { useIaCredits } from "./modules/ia-credits/hooks/ia-credits.hook";
 export type {
   IaCreditsSummary,
@@ -57,10 +60,26 @@ export {
   SubscriptionSchema,
   SubscriptionItemSchema,
 } from "./modules/subscriptions/types";
-export { ADDON_IDS } from "./modules/subscriptions/constants/addons.constants";
-export type { AddonKindEnum } from "./modules/subscriptions/constants/addons.constants";
+export { ADDON_IDS, AI_CREDIT_OPTIONS, AI_CREDIT_VALUES } from "./modules/subscriptions/constants/addons.constants";
+export type { AddonKindEnum, AiCreditOption } from "./modules/subscriptions/constants/addons.constants";
 export type { Plan, PlanItem } from "./modules/subscriptions/types/plan.type";
 export { PlanSchema, PlanItemSchema } from "./modules/subscriptions/types/plan.type";
+export type { BillingPeriod } from "./modules/subscriptions/types/billing-period.type";
+export type {
+  CalculateSubscriptionRequest,
+  CalculateSubscriptionResponse,
+  UpdateSubscriptionPlanRequest,
+} from "./modules/subscriptions/types/calculate-subscription.type";
+export type { Card } from "./modules/cards/types";
+export { CardSchema } from "./modules/cards/types";
+export { buildPlanExtras } from "./modules/subscriptions/utils/build-plan-extras";
+export { getPriceFromCalculatedData, periodicityToBillingPeriod } from "./modules/subscriptions/utils/periodicity";
+export { useBuyCreditsModal } from "./store/useBuyCreditsModal";
+export { default as BuyCreditsModal } from "./components/modals/BuyCreditsModal";
+export { Skeleton } from "./components/ui/feedback/Skeleton";
+export { PaymentInfoCard } from "./components/ui/data-display/PaymentInfoCard";
+export { CardBrandIcon } from "./components/ui/data-display/CardBrandIcons";
+export { CardItem } from "./components/ui/data-display/CardItem";
 
 // Providers
 export { QueryProvider } from "./providers/query.provider";

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

@@ -0,0 +1,8 @@
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { cardsService } from '../services/cards.service';
+
+export async function listCardsAction() {
+  return safeServerAction(() => cardsService.listCards());
+}

package/src/modules/cards/hooks/cards.hook.ts

@@ -0,0 +1,14 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { listCardsAction } from '../actions/list-cards.action';
+
+export const CARDS_QUERY_KEY = ['cards'];
+
+export function useCards() {
+  return useQuery({
+    queryKey: CARDS_QUERY_KEY,
+    queryFn: withAction(listCardsAction),
+  });
+}

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

@@ -0,0 +1,32 @@
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import { ApiError, ApiPaginatedActionResult, PaginatedSuccessResult } from '../../../infra/api/types';
+import { buildQueryParams } from '../../../infra/utils/params';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import { Card, CardSchema } 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 };
+  }
+}
+
+export const cardsService = new CardsService();

package/src/modules/cards/types.ts

@@ -0,0 +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>;

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

@@ -0,0 +1,32 @@
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import type { CalculateSubscriptionRequest } from '../types/calculate-subscription.type';
+import type { SubscriptionItem } from '../types';
+import { subscriptionsService } from '../services/subscriptions.service';
+import { resolvePlanExtrasPrices } from '../utils/resolve-plan-extras-prices';
+
+export async function calculateSubscriptionAction(data: CalculateSubscriptionRequest) {
+  return safeServerAction(async () => {
+    if (data.plan_extras?.length) {
+      let subscriptionItems: SubscriptionItem[] = [];
+
+      if (data.id_subscription) {
+        const { data: subscriptions } = await subscriptionsService.listSubscriptions({
+          active: true,
+        });
+        const subscription =
+          subscriptions.find((s) => String(s.id) === String(data.id_subscription)) ??
+          subscriptions[0];
+        subscriptionItems = subscription?.items ?? [];
+      }
+
+      data = {
+        ...data,
+        plan_extras: resolvePlanExtrasPrices(data.plan_extras, subscriptionItems),
+      };
+    }
+
+    return subscriptionsService.calculateSubscription(data);
+  });
+}

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

@@ -0,0 +1,26 @@
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import type { UpdateSubscriptionPlanRequest } from '../types/calculate-subscription.type';
+import { subscriptionsService } from '../services/subscriptions.service';
+import { resolvePlanExtrasPrices } from '../utils/resolve-plan-extras-prices';
+
+export async function updateSubscriptionPlanAction(
+  subscriptionId: number | string,
+  data: UpdateSubscriptionPlanRequest
+) {
+  return safeServerAction(async () => {
+    if (data.plan_extras?.length) {
+      const { data: subscriptions } = await subscriptionsService.listSubscriptions({ active: true });
+      const subscription =
+        subscriptions.find((s) => String(s.id) === String(subscriptionId)) ?? subscriptions[0];
+
+      data = {
+        ...data,
+        plan_extras: resolvePlanExtrasPrices(data.plan_extras, subscription?.items ?? []),
+      };
+    }
+
+    return subscriptionsService.updateSubscriptionPlan(subscriptionId, data);
+  });
+}

package/src/modules/subscriptions/constants/addons.constants.ts

@@ -8,3 +8,21 @@ export const ADDON_IDS = {
 } as const;
 
 export type AddonKindEnum = (typeof ADDON_IDS)[keyof typeof ADDON_IDS];
+
+export interface AiCreditOption {
+  credits: number;
+  price: number;
+  priceLabel: string;
+}
+
+export const AI_CREDIT_OPTIONS: AiCreditOption[] = [
+  { credits: 0, price: 0, priceLabel: 'R$ 0,00' },
+  { credits: 250, price: 9.99, priceLabel: 'R$ 9,99' },
+  { credits: 500, price: 19.98, priceLabel: 'R$ 19,98' },
+  { credits: 1000, price: 39.96, priceLabel: 'R$ 39,96' },
+  { credits: 2500, price: 99.90, priceLabel: 'R$ 99,90' },
+  { credits: 5000, price: 199.80, priceLabel: 'R$ 199,80' },
+  { credits: 10000, price: 399.60, priceLabel: 'R$ 399,60' },
+];
+
+export const AI_CREDIT_VALUES = new Set(AI_CREDIT_OPTIONS.map((opt) => opt.credits));

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

@@ -0,0 +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),
+  });
+}

package/src/modules/subscriptions/hooks/update-subscription-plan.hook.ts

@@ -0,0 +1,25 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { updateSubscriptionPlanAction } from '../actions/update-subscription-plan.action';
+import { SUBSCRIPTIONS_QUERY_KEY } from './list-subscriptions.hook';
+import type { UpdateSubscriptionPlanRequest } from '../types/calculate-subscription.type';
+
+export function useUpdateSubscriptionPlan() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      subscriptionId,
+      data,
+    }: {
+      subscriptionId: number | string;
+      data: UpdateSubscriptionPlanRequest;
+    }) => withAction(updateSubscriptionPlanAction)(subscriptionId, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: SUBSCRIPTIONS_QUERY_KEY });
+      queryClient.invalidateQueries({ queryKey: ['charges'] });
+    },
+  });
+}

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

@@ -1,10 +1,16 @@
 import 'server-only';
 
 import { api } from '../../../infra/api/client';
-import { ApiError, ApiPaginatedActionResult, PaginatedSuccessResult } from '../../../infra/api/types';
+import { ApiError, ApiActionResult, ApiPaginatedActionResult, PaginatedSuccessResult, SuccessResult } from '../../../infra/api/types';
 import { buildQueryParams } from '../../../infra/utils/params';
 import { getUserContext } from '../../auth/utils/get-user-context';
 import { Subscription, SubscriptionSchema, FindSubscriptionsParams } from '../types';
+import {
+  type CalculateSubscriptionRequest,
+  type CalculateSubscriptionResponse,
+  type UpdateSubscriptionPlanRequest,
+  CalculateSubscriptionResponseSchema,
+} from '../types/calculate-subscription.type';
 
 class SubscriptionsService {
   async listSubscriptions(
@@ -33,6 +39,51 @@ class SubscriptionsService {
       success: true,
     } satisfies PaginatedSuccessResult<Subscription>;
   }
+  async calculateSubscription(
+    data: CalculateSubscriptionRequest
+  ): Promise<SuccessResult<CalculateSubscriptionResponse>> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.post<ApiActionResult<CalculateSubscriptionResponse>>(
+      `/accounts/${id_account}/subscriptions/action/calculate`,
+      data
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao calcular assinatura',
+        'CALCULATE_SUBSCRIPTION_FAILED',
+        400
+      );
+    }
+
+    return {
+      success: true,
+      data: CalculateSubscriptionResponseSchema.parse(response.data),
+    };
+  }
+
+  async updateSubscriptionPlan(
+    subscriptionId: number | string,
+    data: UpdateSubscriptionPlanRequest
+  ): Promise<SuccessResult<void>> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.put<ApiActionResult<void>>(
+      `/accounts/${id_account}/subscriptions/${subscriptionId}/action/plan`,
+      data
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao atualizar plano',
+        'UPDATE_SUBSCRIPTION_PLAN_FAILED',
+        400
+      );
+    }
+
+    return { success: true };
+  }
 }
 
 export const subscriptionsService = new SubscriptionsService();

package/src/modules/subscriptions/types/billing-period.type.ts

@@ -0,0 +1 @@
+export type BillingPeriod = 'monthly' | 'semiannual' | 'annual';

package/src/modules/subscriptions/types/calculate-subscription.type.ts

@@ -0,0 +1,75 @@
+import z from 'zod';
+
+export const CalculateSubscriptionPlanExtraRequestSchema = z.object({
+  id_addon: z.number(),
+  value: z.number(),
+  quantity: z.number(),
+  currency: z.string(),
+});
+
+export const CalculateSubscriptionRequestSchema = z.object({
+  id_product: z.number(),
+  id_plan: z.number().optional(),
+  id_subscription: z.union([z.number(), z.string()]).optional(),
+  id_coupon: z.number().optional(),
+  plan_extras: z.array(CalculateSubscriptionPlanExtraRequestSchema.partial({ value: true })).optional(),
+});
+
+export type CalculateSubscriptionRequest = z.infer<typeof CalculateSubscriptionRequestSchema>;
+
+export const CalculateSubscriptionPlanExtraResponseSchema = z.object({
+  id_addon: z.number(),
+  value: z.number(),
+  value_original: z.number().optional().default(0),
+  value_discount: z.number().optional().default(0),
+  quantity: z.number(),
+  currency: z.string(),
+});
+
+export const CalculateSubscriptionResponseSchema = z.object({
+  name: z.string(),
+  month: z.number(),
+  month_discount: z.number(),
+  month_discount_coupom: z.number().optional().default(0),
+  month_original: z.number(),
+  month_original_discount: z.number().optional().default(0),
+  month_original_discount_cupom: z.number().optional().default(0),
+  semmester: z.number(),
+  semmester_price: z.number().optional().default(0),
+  semmester_discount: z.number(),
+  semmester_discount_coupom: z.number().optional().default(0),
+  semmester_original: z.number(),
+  semmester_original_discount: z.number().optional().default(0),
+  semmester_original_discount_cupom: z.number().optional().default(0),
+  year: z.number(),
+  year_discount: z.number(),
+  year_discount_coupom: z.number().optional().default(0),
+  year_original: z.number(),
+  year_original_discount: z.number().optional().default(0),
+  year_original_discount_cupom: z.number().optional().default(0),
+  plan_extras: z.array(CalculateSubscriptionPlanExtraResponseSchema),
+});
+
+export type CalculateSubscriptionResponse = z.infer<typeof CalculateSubscriptionResponseSchema>;
+
+export const UpdateSubscriptionPlanExtraSchema = z.object({
+  id_addon: z.number(),
+  value: z.number().optional(),
+  quantity: z.number(),
+  price: z.string().optional(),
+  trial: z.boolean().optional(),
+  trial_days: z.number().optional(),
+});
+
+export const UpdateSubscriptionPlanRequestSchema = z.object({
+  id_plan: z.number().optional(),
+  id_coupon: z.union([z.number(), z.null()]).optional(),
+  date_due: z.string().optional(),
+  type: z.string().optional(),
+  active: z.boolean().optional(),
+  periodicity: z.number().optional(),
+  plan_extras: z.array(UpdateSubscriptionPlanExtraSchema).optional(),
+  enable_charge: z.boolean().optional(),
+});
+
+export type UpdateSubscriptionPlanRequest = z.infer<typeof UpdateSubscriptionPlanRequestSchema>;

package/src/modules/subscriptions/utils/build-plan-extras.ts

@@ -0,0 +1,53 @@
+import type { SubscriptionItem } from '../types';
+
+export interface PlanExtraOverride {
+  id_addon: number;
+  quantity: number;
+  currency: string;
+}
+
+export interface PlanExtra {
+  id_addon: number;
+  value: number;
+  quantity: number;
+  currency: string;
+}
+
+export function buildPlanExtras(
+  items: SubscriptionItem[],
+  overrides: PlanExtraOverride[]
+): PlanExtra[] {
+  const overrideMap = new Map(overrides.map((o) => [o.id_addon, o]));
+
+  const extras: PlanExtra[] = items
+    .filter((item) => item.id_addon != null)
+    .map((item) => {
+      const override = overrideMap.get(item.id_addon!);
+      if (override) {
+        overrideMap.delete(item.id_addon!);
+        return {
+          id_addon: override.id_addon,
+          value: 0,
+          quantity: override.quantity,
+          currency: override.currency,
+        };
+      }
+      return {
+        id_addon: item.id_addon!,
+        value: item.value,
+        quantity: item.quantity,
+        currency: item.currency,
+      };
+    });
+
+  for (const override of overrideMap.values()) {
+    extras.push({
+      id_addon: override.id_addon,
+      value: 0,
+      quantity: override.quantity,
+      currency: override.currency,
+    });
+  }
+
+  return extras;
+}

package/src/modules/subscriptions/utils/periodicity.ts

@@ -0,0 +1,52 @@
+import type { BillingPeriod } from '../types/billing-period.type';
+import type { CalculateSubscriptionResponse } from '../types/calculate-subscription.type';
+
+export function periodicityToBillingPeriod(
+  periodicity: number | string | null | undefined
+): BillingPeriod | null {
+  if (periodicity === 30 || periodicity === 1 || periodicity === 'monthly') return 'monthly';
+  if (periodicity === 180 || periodicity === 3 || periodicity === 'semiannual') return 'semiannual';
+  if (periodicity === 365 || periodicity === 2 || periodicity === 'annual') return 'annual';
+  return null;
+}
+
+export function billingPeriodToNumeric(billingPeriod: BillingPeriod): 30 | 180 | 365 {
+  if (billingPeriod === 'semiannual') return 180;
+  if (billingPeriod === 'annual') return 365;
+  return 30;
+}
+
+export function getPeriodicityLabel(periodicity: number | string | null | undefined): string {
+  const period = periodicityToBillingPeriod(periodicity);
+  if (period === 'semiannual') return 'Semestral';
+  if (period === 'annual') return 'Anual';
+  return 'Mensal';
+}
+
+export function getBillingPeriodSuffix(billingPeriod: BillingPeriod): string {
+  if (billingPeriod === 'semiannual') return '/semestre';
+  if (billingPeriod === 'annual') return '/ano';
+  return '/mês';
+}
+
+export function getBillingPeriodLabel(billingPeriod: BillingPeriod): string {
+  if (billingPeriod === 'semiannual') return 'semestral';
+  if (billingPeriod === 'annual') return 'anual';
+  return 'mensal';
+}
+
+export function getBillingPeriodMonths(billingPeriod: BillingPeriod): number {
+  if (billingPeriod === 'semiannual') return 6;
+  if (billingPeriod === 'annual') return 12;
+  return 1;
+}
+
+export function getPriceFromCalculatedData(
+  data: CalculateSubscriptionResponse,
+  periodicity: number | string | null | undefined
+): number {
+  const period = periodicityToBillingPeriod(periodicity);
+  if (period === 'annual') return data.year;
+  if (period === 'semiannual') return data.semmester;
+  return data.month;
+}

package/src/modules/subscriptions/utils/resolve-plan-extras-prices.ts

@@ -0,0 +1,23 @@
+import 'server-only';
+
+import type { SubscriptionItem } from '../types';
+
+interface PlanExtraInput {
+  id_addon: number;
+  value?: number;
+  quantity: number;
+  [key: string]: unknown;
+}
+
+export function resolvePlanExtrasPrices<T extends PlanExtraInput>(
+  extras: T[],
+  subscriptionItems: SubscriptionItem[]
+): T[] {
+  return extras.map((extra) => {
+    const item = subscriptionItems.find((i) => i.id_addon === extra.id_addon);
+    if (item) {
+      return { ...extra, value: item.value };
+    }
+    return { ...extra, value: extra.value ?? 0 };
+  });
+}

package/src/server.ts

@@ -10,6 +10,7 @@ export { whitelabelStylesService } from './modules/whitelabel/services/whitelabe
 export { findWhitelabelStyles } from './modules/whitelabel/actions/find-whitelabel-styles.action';
 export { subscriptionsService } from './modules/subscriptions/services/subscriptions.service';
 export { plansService } from './modules/subscriptions/services/plans.service';
+export { cardsService } from './modules/cards/services/cards.service';
 export { iaCreditsService } from './modules/ia-credits/services/ia-credits.service';
 
 // Actions
@@ -19,6 +20,10 @@ export { findUserById } from './modules/users/action/find-user-by-id.action';
 export { findCurrentAccount } from './modules/accounts/actions/find-current-account.action';
 export { listSubscriptionsAction } from './modules/subscriptions/actions/list-subscriptions.action';
 export { findPlanByIdAction } from './modules/subscriptions/actions/find-plan-by-id.action';
+export { calculateSubscriptionAction } from './modules/subscriptions/actions/calculate-subscription.action';
+export { updateSubscriptionPlanAction } from './modules/subscriptions/actions/update-subscription-plan.action';
+export { listCardsAction } from './modules/cards/actions/list-cards.action';
+export { resolvePlanExtrasPrices } from './modules/subscriptions/utils/resolve-plan-extras-prices';
 export { listIaCreditsAction } from './modules/ia-credits/actions/list-ia-credits.action';
 
 // Project Users Services & Actions (server-only)

package/src/store/useBuyCreditsModal.ts

@@ -0,0 +1,25 @@
+import { useModalManager } from './useModalManager';
+
+interface BuyCreditsModalData {
+  onConfirm?: (creditAmount: number, price: number) => void;
+  initialActiveCardId?: string;
+  initialSelectedValue?: number;
+}
+
+export const useBuyCreditsModal = () => {
+  const { activeModal, modalData, openModal, closeModal } = useModalManager();
+
+  const isOpen = activeModal === 'buyCreditsModal';
+  const data = modalData as BuyCreditsModalData;
+
+  return {
+    open: isOpen,
+    onConfirm: data?.onConfirm,
+    initialActiveCardId: data?.initialActiveCardId,
+    initialSelectedValue: data?.initialSelectedValue,
+
+    openModal: (onConfirm?: (creditAmount: number, price: number) => void) =>
+      openModal('buyCreditsModal', { onConfirm }),
+    closeModal,
+  };
+};