@greatapps/common 1.1.439 → 1.1.441

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

@@ -1,11 +1,90 @@
 import 'server-only';
 
-import { api } from '../../../infra/api/client';
-import { ApiError, ApiPaginatedActionResult, SuccessResult } from '../../../infra/api/types';
-import { Plan, PlanSchema } from '../types/plan.type';
+import { api, apiClient } from '@greatapps/common/server';
+import { ApiError, buildQueryParams, PlanSchema } from '@greatapps/common';
+import type { ApiPaginatedActionResult, PaginatedSuccessResult, Plan, SuccessResult } from '@greatapps/common';
+import greatCache from '@greatapps/cache';
+
+export type ListPlansParams = {
+  sort?: string;
+  active?: boolean;
+  search?: string;
+};
+
+const PLANS_CACHE_TTL = 604800;
 
 class PlansService {
+  private cache = new greatCache({
+    service: 'plans-service',
+    version: '1.0.1',
+    domain: 'whitelabel-cache.greatapps.com.br',
+    ambient: process.env.NODE_ENV || 'development',
+  });
+
+  private buildCacheKey(key: string, params?: ListPlansParams): string {
+    const sort = params?.sort ?? 'id:ASC';
+    const active = params?.active ?? '';
+    const search = params?.search ?? '';
+    return `${key}-${sort}-${active}-${search}`;
+  }
+
+  /**
+   * Lista planos do whitelabel.
+   * Exemplo:
+   * GET /{id_wl}/plans?active=true&search=client&sort=id:ASC
+   */
+  async listPlans(params?: ListPlansParams): Promise<PaginatedSuccessResult<Plan>> {
+    const cacheKey = this.buildCacheKey('plans', params);
+
+    const cachedData = await this.cache.select(cacheKey);
+
+    if (cachedData.status == 1 && 'data' in cachedData && cachedData.data) {
+      const data = JSON.parse(cachedData.data) as Plan[];
+      return { data, total: data.length, success: true };
+    }
+
+    const query = buildQueryParams({
+      sort: params?.sort ?? 'id:ASC',
+      active: params?.active,
+      search: params?.search,
+    });
+    const url = `/plans${query ? `?${query}` : ''}`;
+
+    const response = await apiClient.get<ApiPaginatedActionResult<Plan[]>>(url);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        (response as { message?: string }).message || 'Erro ao listar planos',
+        'LIST_PLANS_FAILED',
+        400
+      );
+    }
+
+    const rawData = (response as { data?: unknown }).data;
+    const data = Array.isArray(rawData)
+      ? rawData.map((item) => PlanSchema.parse(item))
+      : [];
+
+    await this.cache.insert(cacheKey, JSON.stringify(data), PLANS_CACHE_TTL);
+
+    return {
+      data,
+      total: response.total,
+      success: true,
+    } satisfies PaginatedSuccessResult<Plan>;
+  }
+
+
   async findById(idPlan: number | string): Promise<SuccessResult<Plan>> {
+    const cacheKey = this.buildCacheKey(`plan-${idPlan}`);
+
+    const cachedData = await this.cache.select(cacheKey);
+    
+    if (cachedData.status == 1 && 'data' in cachedData && cachedData.data) {
+      const data = JSON.parse(cachedData.data) as Plan;
+      return { data, success: true };
+    }
+
     const response = await api.apps.get<ApiPaginatedActionResult<Plan>>(
       `/plans/${idPlan}?type=client`
     );
@@ -26,9 +105,13 @@ class PlansService {
       );
     }
 
+    const plan = PlanSchema.parse(response.data[0]);
+
+    await this.cache.insert(cacheKey, JSON.stringify(plan), PLANS_CACHE_TTL);
+
     return {
       success: true,
-      data: PlanSchema.parse(response.data[0]),
+      data: plan,
     };
   }
 }

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

@@ -1,4 +1,5 @@
 import z from 'zod';
+import type { BillingPeriod } from '../../subscriptions/types/billing-period.type';
 
 export const PlanItemSchema = z.object({
   id_addon: z.number(),
@@ -10,6 +11,7 @@ export type PlanItem = z.infer<typeof PlanItemSchema>;
 
 export const PlanSchema = z.object({
   id: z.number(),
+  id_plan: z.number().optional(),
   name: z.string(),
   value: z.number().default(0),
   type: z.string().optional(),
@@ -19,3 +21,47 @@ export const PlanSchema = z.object({
 });
 
 export type Plan = z.infer<typeof PlanSchema>;
+
+// ── UI Plan types (used by list-plans action and consumers) ──
+
+export type PlanFeature = {
+  icon: 'check' | 'x';
+  text: string;
+  disabled?: boolean;
+  tooltip?: keyof PlanTooltips;
+};
+
+export type PlanMainFeatures = {
+  pages: string;
+  domains: string;
+  users: string;
+};
+
+/** Preços mensais equivalentes por período de cobrança (já com desconto aplicado). */
+export type PlanPricingByPeriod = {
+  monthly: number;
+  semiannual: number;
+  annual: number;
+};
+
+export type UiPlan = {
+  idPlan: number;
+  name: string;
+  isPopular?: boolean;
+  isCurrentPlan?: boolean;
+  currentPeriodicity?: BillingPeriod | null;
+  mainFeatures: PlanMainFeatures;
+  features: PlanFeature[];
+  originalPrice: string;
+  price: string;
+  pricingByPeriod?: PlanPricingByPeriod;
+  buttonVariant?: 'brand' | 'default';
+  items: PlanItem[];
+};
+
+export type PlanTooltips = {
+  domains: string;
+  users: string;
+  sharePages: string;
+  projectManagement: string;
+};

package/src/modules/plans/utils/map-api-plan-to-ui.ts

@@ -0,0 +1,89 @@
+import type { Plan, PlanFeature, PlanMainFeatures, PlanPricingByPeriod, UiPlan } from '../types/plan.type';
+import { ADDON_IDS } from '../../subscriptions/constants/addons.constants';
+import { formatCurrencyNumber } from '../../../utils/format/currency';
+
+export type PlanBillingPeriod = 'monthly' | 'semiannual' | 'annual';
+
+const BASE_FEATURES: PlanFeature[] = [
+  { icon: 'check', text: 'Visitas ilimitadas' },
+  { icon: 'check', text: 'Leads ilimitadas' },
+  { icon: 'check', text: 'Compartilhar páginas', tooltip: 'sharePages' },
+  { icon: 'check', text: 'Hospedagem inclusa' },
+  { icon: 'check', text: 'SSL (HTTPS) + CDN' },
+  { icon: 'check', text: 'Templates Free' },
+];
+
+function buildMainFeaturesFromItems(items: Plan['items']): PlanMainFeatures {
+  const pagesItem = items.find((i) => i.id_addon === ADDON_IDS.PAGES);
+  const domainsItem = items.find((i) => i.id_addon === ADDON_IDS.DOMAINS);
+
+  const pagesQty = pagesItem?.quantity ?? 0;
+  const domainsQty = domainsItem?.quantity ?? 1;
+
+  return {
+    pages:
+      pagesQty === 0
+        ? 'Páginas ilimitadas'
+        : pagesQty === 1
+          ? '1 página'
+          : `${pagesQty} páginas`,
+    domains:
+      domainsQty >= 999
+        ? 'Domínios ilimitados'
+        : domainsQty === 1
+          ? '1 domínio externo'
+          : `${domainsQty} domínios externos`,
+    users: 'Usuários ilimitados',
+  };
+}
+
+function computePricingByPeriod(apiPlan: Plan): PlanPricingByPeriod {
+  const monthly = apiPlan.value;
+  const round2 = (n: number) => Math.round(n * 100) / 100;
+  return {
+    monthly,
+    semiannual: round2(monthly * (1 - apiPlan.discount_semester / 100)),
+    annual: round2(monthly * (1 - apiPlan.discount_annual / 100)),
+  };
+}
+
+export function mapApiPlanToUiPlan(
+  apiPlan: Plan,
+  options: {
+    planId: number;
+    isPopular?: boolean;
+    buttonVariant?: 'brand' | 'default';
+  }
+): UiPlan {
+  const { planId, isPopular, buttonVariant } = options;
+
+  const pricingByPeriod = computePricingByPeriod(apiPlan);
+  const monthlyFinal = pricingByPeriod.monthly;
+
+  const lowerName = apiPlan.name.toLowerCase();
+  const hasProjectAndOnboarding =
+    lowerName.includes('agência') || lowerName.includes('agencia');
+
+  const features: PlanFeature[] = [
+    ...BASE_FEATURES,
+    hasProjectAndOnboarding
+      ? { icon: 'check', text: 'Reunião de Onboarding' }
+      : { icon: 'x', text: 'Reunião de Onboarding', disabled: true },
+    hasProjectAndOnboarding
+      ? { icon: 'check', text: 'Gestão de projetos', tooltip: 'projectManagement' }
+      : { icon: 'x', text: 'Gestão de projetos', disabled: true, tooltip: 'projectManagement' },
+  ];
+
+  return {
+    idPlan: planId,
+    name: apiPlan.name,
+    isPopular,
+    buttonVariant,
+    mainFeatures: buildMainFeaturesFromItems(apiPlan.items),
+    features,
+    originalPrice: formatCurrencyNumber(monthlyFinal),
+    price: formatCurrencyNumber(monthlyFinal),
+    pricingByPeriod,
+    items: apiPlan.items,
+  };
+}

package/src/server.ts

@@ -23,6 +23,7 @@ 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/plans/actions/find-plan-by-id.action';
+export { listPlansAction } from './modules/plans/actions/list-plans.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';

package/src/utils/format/currency.ts

@@ -0,0 +1,15 @@
+/**
+ * Formata um número (opcional) para moeda BRL
+ * @param value - Número a ser formatado (pode ser undefined ou null)
+ * @param decimals - Casas decimais (padrão: 2)
+ * @returns String formatada como "R$ X.XXX,XX"
+ */
+export const formatCurrencyNumber = (value?: number | null, decimals = 2): string => {
+  const safeValue = value ?? 0;
+  return safeValue.toLocaleString('pt-BR', {
+    style: 'currency',
+    currency: 'BRL',
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+  });
+};