@greatapps/common 1.1.633 → 1.1.634

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

@@ -26,9 +26,16 @@ import {
   SearchPlansApiResponse,
   SessionKeepRequest,
   SessionKeepResponse,
+  SocialGoogleApiResponse,
+  SocialGoogleResponse,
+  SocialOnboardingApiResponse,
+  SocialOnboardingRequest,
+  SocialOnboardingResponse,
   TwoFactorApiResponse,
   TwoFactorRequest,
   TwoFactorResponse,
+  UnlinkGoogleApiResponse,
+  UnlinkGoogleResponse,
   VerifyEmailRequest,
   VerifyEmailResponse,
 } from "../schema";
@@ -151,6 +158,206 @@ class AuthService {
 
     return { status: 1 };
   }
+
+  async socialLoginGoogle(
+    code: string,
+    clientInfo: ClientInfo,
+  ): Promise<SocialGoogleResponse> {
+    const response = await api.apps.post<SocialGoogleApiResponse>(
+      "/auth/social/google",
+      {
+        code,
+        location: clientInfo.location,
+        ip: clientInfo.ip,
+        timezone: clientInfo.timezone,
+        agent: clientInfo.agent,
+        verification: true,
+      },
+    );
+
+    if (response.status === 0) {
+      if (response.code === "link_requires_password") {
+        return {
+          result: "link_requires_password",
+          message:
+            response.message ||
+            "Uma conta com esse e-mail já existe. Faça login com e-mail e senha para vincular sua conta Google.",
+        };
+      }
+      throw new ApiError(
+        response.message || "Falha no login com Google",
+        response.code || "GOOGLE_LOGIN_FAILED",
+        401,
+      );
+    }
+
+    if (response.needs_onboarding) {
+      if (!response.onboarding_token || !response.partial?.email) {
+        throw new ApiError(
+          "Resposta de onboarding inválida",
+          "INVALID_RESPONSE",
+          500,
+        );
+      }
+      return {
+        result: "needs_onboarding",
+        onboardingToken: response.onboarding_token,
+        partial: response.partial,
+      };
+    }
+
+    if (!response.cookie) {
+      throw new ApiError(
+        "Resposta de autenticação inválida",
+        "INVALID_RESPONSE",
+        500,
+      );
+    }
+
+    if (response.two_factor_required) {
+      return {
+        result: "two_factor_required",
+        cookie: response.cookie,
+        twoFactorMode: response.two_factor_required,
+      };
+    }
+
+    await this.setAuthCookie(response.cookie);
+
+    const [{ userService }, { accountService }] = await Promise.all([
+      import("../../users/services/user.service"),
+      import("../../accounts/services/account.service"),
+    ]);
+    const [user, account] = await Promise.all([
+      userService.findById(),
+      accountService.findCurrentAccount(),
+    ]);
+
+    return {
+      result: "success",
+      user,
+      account,
+      accessToken: response.cookie,
+      expiresAt: new Date(Date.now() + COOKIE_MAX_AGE * 1000).toISOString(),
+    };
+  }
+
+  async completeGoogleOnboarding(
+    data: SocialOnboardingRequest,
+    clientInfo: ClientInfo,
+  ): Promise<SocialOnboardingResponse> {
+    const today = new Date();
+    const trialEndDate = new Date(today);
+    const trialDays = Math.min(Math.max(data.trialDays ?? 7, 1), 90);
+    trialEndDate.setDate(today.getDate() + trialDays);
+
+    const idPlan = await this.resolvePlanId(data.idPlan);
+
+    const payload = {
+      onboarding_token: data.onboardingToken,
+      name: data.user.name,
+      bussiness_type: 0,
+      language: "pt-br",
+      timezone: "America/Sao_Paulo",
+      currency: "BRL",
+      location: clientInfo.location,
+      ip: clientInfo.ip,
+      agent: clientInfo.agent,
+      id_affiliate: data.affiliateId || 0,
+      origin: data.origin,
+      user: {
+        id_api: "",
+        name: data.user.name || "",
+        last_name: data.user.last_name || "",
+        rg: data.user.rg || "",
+        cpf: data.user.cpf || "",
+        gender: data.user.gender ?? 1,
+        ddi: data.user.ddi || "55",
+        phone: data.user.phone || "",
+        profile: "owner",
+        language: "pt-br",
+      },
+      subscription:
+        idPlan === -1
+          ? {
+              type: "free",
+              id_coupon: data.couponId || 0,
+              id_plan: 5,
+              id_product: 1,
+            }
+          : {
+              type: "trial",
+              id_coupon: data.couponId || 0,
+              id_plan: idPlan,
+              date_due: trialEndDate.toISOString().split("T")[0],
+              trial_days: trialDays,
+              id_product: 1,
+            },
+    };
+
+    const response = await api.apps.post<SocialOnboardingApiResponse>(
+      "/auth/social/onboarding",
+      payload,
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao finalizar cadastro com Google",
+        "ONBOARDING_FAILED",
+        400,
+      );
+    }
+
+    if (!response.data?.length || !response.cookie) {
+      throw new ApiError(
+        "Resposta de cadastro inválida",
+        "INVALID_RESPONSE",
+        500,
+      );
+    }
+
+    await this.setAuthCookie(response.cookie);
+
+    const [{ userService }, { accountService }] = await Promise.all([
+      import("../../users/services/user.service"),
+      import("../../accounts/services/account.service"),
+    ]);
+    const [user, account] = await Promise.all([
+      userService.findById(),
+      accountService.findCurrentAccount(),
+    ]);
+
+    return {
+      user,
+      account,
+      accessToken: response.cookie,
+      expiresAt: new Date(Date.now() + COOKIE_MAX_AGE * 1000).toISOString(),
+    };
+  }
+
+  async unlinkGoogle(): Promise<UnlinkGoogleResponse> {
+    const { id_account, id_user } = await import(
+      "../utils/get-user-context"
+    ).then((m) => m.getUserContext());
+
+    const response = await api.apps.delete<UnlinkGoogleApiResponse>(
+      `/accounts/${id_account}/users/${id_user}/social/google`,
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao desvincular conta Google",
+        "UNLINK_FAILED",
+        400,
+      );
+    }
+
+    return {
+      success: true,
+      message: response.message,
+    };
+  }
+
   async register(
     data: RegisterRequest,
     clientInfo: ClientInfo,

package/src/modules/users/schema.ts

@@ -24,6 +24,8 @@ export interface User {
 
   // Autenticação e segurança
   two_factor_authentication: boolean;
+  google_sub?: string | null;
+  google_linked_at?: string | null;
 
   // Perfil e permissões
   profile: UserProfile;

package/src/providers/auth.provider.tsx

@@ -16,16 +16,27 @@ import {
 import { useLogin } from "../modules/auth/hooks/login.hook";
 import { useRegister } from "../modules/auth/hooks/register.hook";
 import { useLogout } from "../modules/auth/hooks/logout.hook";
+import { useSocialGoogleLogin } from "../modules/auth/hooks/social-google-login.hook";
+import { useSocialGoogleOnboarding } from "../modules/auth/hooks/social-google-onboarding.hook";
 import {
   AuthState,
   LoginRequest,
   RegisterRequest,
+  SocialGooglePartial,
+  SocialOnboardingRequest,
 } from "../modules/auth/schema";
 
 export type LoginResult =
   | { result: "success" }
   | { result: "two_factor_required"; cookie: string; twoFactorMode: "verify" | "setup" }
   | { result: "error"; message: string };
+
+export type GoogleLoginResult =
+  | { result: "success" }
+  | { result: "two_factor_required"; cookie: string; twoFactorMode: "verify" | "setup" }
+  | { result: "needs_onboarding"; onboardingToken: string; partial: SocialGooglePartial }
+  | { result: "link_requires_password"; message: string }
+  | { result: "error"; message: string };
 import {
   useCurrentAccount,
   ACCOUNT_QUERY_KEY,
@@ -37,6 +48,8 @@ interface AuthContextProps extends AuthState {
   login: (credentials: LoginRequest) => Promise<LoginResult>;
   register: (data: RegisterRequest) => Promise<void>;
   logout: () => Promise<void>;
+  loginWithGoogle: (code: string) => Promise<GoogleLoginResult>;
+  completeGoogleOnboarding: (data: SocialOnboardingRequest) => Promise<void>;
 }
 
 export const AuthContext = createContext<AuthContextProps | undefined>(
@@ -61,12 +74,18 @@ export function AuthProvider({ children }: AuthProviderProps) {
   const { mutateAsync: registerMutate, isPending: isRegistering } =
     useRegister();
   const { mutateAsync: logoutMutate, isPending: isLoggingOut } = useLogout();
+  const { mutateAsync: googleLoginMutate, isPending: isGoogleLogging } =
+    useSocialGoogleLogin();
+  const { mutateAsync: googleOnboardingMutate, isPending: isGoogleOnboarding } =
+    useSocialGoogleOnboarding();
 
   const isAuthenticated = !!user;
   const isLoading =
     isLogging ||
     isRegistering ||
     isLoggingOut ||
+    isGoogleLogging ||
+    isGoogleOnboarding ||
     isQueryLoading ||
     isAccountLoading ||
     isSessionLoading;
@@ -109,6 +128,60 @@ export function AuthProvider({ children }: AuthProviderProps) {
     [queryClient, setUserData, accountKey],
   );
 
+  const loginWithGoogle = useCallback(
+    async (code: string): Promise<GoogleLoginResult> => {
+      try {
+        const data = await googleLoginMutate(code);
+
+        if (data.result === "two_factor_required") {
+          return {
+            result: "two_factor_required",
+            cookie: data.cookie,
+            twoFactorMode: data.twoFactorMode,
+          };
+        }
+
+        if (data.result === "needs_onboarding") {
+          return {
+            result: "needs_onboarding",
+            onboardingToken: data.onboardingToken,
+            partial: data.partial,
+          };
+        }
+
+        if (data.result === "link_requires_password") {
+          return { result: "link_requires_password", message: data.message };
+        }
+
+        queryClient.clear();
+        setUserData(data.user);
+        queryClient.setQueryData(accountKey, data.account);
+
+        return { result: "success" };
+      } catch (error) {
+        const message =
+          error instanceof Error
+            ? error.message
+            : "Ocorreu um erro ao fazer login com Google. Tente novamente.";
+        return { result: "error", message };
+      }
+    },
+    [googleLoginMutate, queryClient, setUserData, accountKey],
+  );
+
+  const completeGoogleOnboarding = useCallback(
+    async (data: SocialOnboardingRequest): Promise<void> => {
+      await googleOnboardingMutate(data, {
+        onSuccess: (data) => {
+          queryClient.clear();
+          setUserData(data.user);
+          queryClient.setQueryData(accountKey, data.account);
+        },
+      });
+    },
+    [googleOnboardingMutate, queryClient, setUserData, accountKey],
+  );
+
   const resolveLogoutRedirect = useCallback(() => {
     try {
       const currentOrigin = window.location.origin;
@@ -144,8 +217,20 @@ export function AuthProvider({ children }: AuthProviderProps) {
       login,
       register,
       logout,
+      loginWithGoogle,
+      completeGoogleOnboarding,
     }),
-    [user, account, isAuthenticated, isLoading, login, register, logout],
+    [
+      user,
+      account,
+      isAuthenticated,
+      isLoading,
+      login,
+      register,
+      logout,
+      loginWithGoogle,
+      completeGoogleOnboarding,
+    ],
   );
 
   return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;

package/src/server.ts

@@ -20,6 +20,9 @@ export { iaCreditsService } from './modules/ia-credits/services/ia-credits.servi
 // Actions
 export { findWhitelabel } from './modules/whitelabel/actions/find-whitelabel.action';
 export { validateSessionAction } from './modules/auth/actions/validate-session.action';
+export { socialGoogleLoginAction } from './modules/auth/actions/social-google-login.action';
+export { socialGoogleOnboardingAction } from './modules/auth/actions/social-google-onboarding.action';
+export { unlinkGoogleAction } from './modules/auth/actions/unlink-google.action';
 export { findUserById } from './modules/users/action/find-user-by-id.action';
 export { findCurrentAccount } from './modules/accounts/actions/find-current-account.action';
 export { getAccountTokenAction } from './modules/accounts/actions/get-account-token.action';