@greatapps/common 1.1.139 → 1.1.141

package/dist/server.mjs

@@ -1,1449 +1,44 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/infra/api/types.ts
-import z from "zod";
-var PaginationParamsSchema, SearchParamsSchema, SortParamsSchema, ApiError;
-var init_types = __esm({
-  "src/infra/api/types.ts"() {
-    "use strict";
-    PaginationParamsSchema = z.object({
-      page: z.number().min(1).optional().default(20),
-      limit: z.number().optional().default(20)
-    });
-    SearchParamsSchema = z.object({
-      search: z.string().optional()
-    });
-    SortParamsSchema = z.object({
-      sort: z.string().optional()
-    });
-    ApiError = class _ApiError extends Error {
-      code;
-      statusCode;
-      constructor(message, code = "UNKNOWN_ERROR", statusCode = 500) {
-        super(message);
-        this.name = "ApiError";
-        this.code = code;
-        this.statusCode = statusCode;
-      }
-      static isApiError(error) {
-        return error instanceof _ApiError;
-      }
-    };
-  }
-});
-
-// src/modules/whitelabel/services/whitelabel.service.ts
-import greatCache from "@greatapps/cache";
-var WhitelabelService, whitelabelService;
-var init_whitelabel_service = __esm({
-  "src/modules/whitelabel/services/whitelabel.service.ts"() {
-    "use strict";
-    init_types();
-    WhitelabelService = class {
-      getApiUrl() {
-        const apiUrl = process.env.GAPPS_R3_API_URL;
-        if (!apiUrl) {
-          throw new ApiError("GAPPS_R3_API_URL not configured", "CONFIG_ERROR", 500);
-        }
-        return apiUrl;
-      }
-      getToken() {
-        const token = process.env.WHITELABEL_TOKEN_MASTER;
-        if (!token) {
-          throw new ApiError("WHITELABEL_TOKEN_MASTER not configured", "CONFIG_ERROR", 500);
-        }
-        return token;
-      }
-      async getTokenByDomain(hostname) {
-        hostname = "greatapps.com.br";
-        const apiUrl = this.getApiUrl();
-        const whitelabelMasterToken = this.getToken();
-        const url = `${apiUrl}/v1/pt-br/1/whitelabel/${hostname}/token`;
-        console.log("[WhitelabelService] Fetching token for domain", { url });
-        const cache3 = new greatCache({
-          service: "whitelabel-service",
-          version: "1.0",
-          domain: "whitelabel-cache.greatapps.com.br",
-          ambient: process.env.NODE_ENV || "development"
-        });
-        const cachedData = await cache3.select(`whitelabel-token-${hostname}`);
-        if (cachedData.status == 1 && "data" in cachedData && cachedData.data) {
-          console.log("[WhitelabelService] Cache hit for domain", { hostname });
-          return JSON.parse(cachedData.data);
-        }
-        const response = await fetch(url, {
-          method: "GET",
-          headers: {
-            authorization: whitelabelMasterToken
-          }
-        });
-        if (!response.ok) {
-          console.error("[WhitelabelService] Failed to fetch whitelabel token", { response });
-          throw new ApiError(
-            `Failed to fetch whitelabel token: ${response.status}`,
-            "FETCH_ERROR",
-            response.status
-          );
-        }
-        const result = await response.json();
-        if (result.status !== 1 || !result.data?.length) {
-          throw new ApiError("Whitelabel token not found", "TOKEN_NOT_FOUND", 404);
-        }
-        await cache3.insert(`whitelabel-token-${hostname}`, JSON.stringify(result.data[0]), 604800);
-        return result.data[0];
-      }
-    };
-    whitelabelService = new WhitelabelService();
-  }
-});
-
-// src/modules/whitelabel/actions/find-whitelabel.action.ts
-import { headers } from "next/headers";
-import { cache } from "react";
-var findWhitelabel;
-var init_find_whitelabel_action = __esm({
-  "src/modules/whitelabel/actions/find-whitelabel.action.ts"() {
-    "use strict";
-    "use server";
-    init_whitelabel_service();
-    init_types();
-    findWhitelabel = cache(async () => {
-      const headersList = await headers();
-      const host = headersList.get("host");
-      if (!host) {
-        throw new ApiError("Host header not found", "HOST_NOT_FOUND", 400);
-      }
-      const whitelabel = await whitelabelService.getTokenByDomain(host);
-      if (!whitelabel) {
-        throw new ApiError("Whitelabel not found", "WL_NOT_FOUND", 404);
-      }
-      return whitelabel;
-    });
-  }
-});
-
-// src/infra/api/client.ts
-var ApiClient, api, apiClient;
-var init_client = __esm({
-  "src/infra/api/client.ts"() {
-    "use strict";
-    init_types();
-    init_find_whitelabel_action();
-    ApiClient = class {
-      baseUrl;
-      apiVersion = "v1";
-      apiLocale = "pt-br";
-      omitApiVersion;
-      constructor(baseUrl, options) {
-        this.baseUrl = baseUrl.replace(/\/$/, "");
-        this.omitApiVersion = options?.omitApiVersion ?? false;
-      }
-      async buildUrl(endpoint, whiteLabelId) {
-        const wlPath = this.omitApiVersion ? `/${this.apiLocale}/${whiteLabelId}` : `/${this.apiVersion}/${this.apiLocale}/${whiteLabelId}`;
-        const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
-        const url = `${this.baseUrl}${wlPath}${path}`;
-        console.log("[ApiClient] buildUrl", {
-          baseURL: this.baseUrl,
-          whiteLabelId,
-          endpoint,
-          fullUrl: url
-        });
-        return url;
-      }
-      async getDefaultHeaders(token, isFormData = false) {
-        console.log("[ApiClient] getDefaultHeaders", {
-          token: token.substring(0, 20) + "..."
-        });
-        const headers4 = {
-          authorization: token
-        };
-        if (!isFormData) {
-          headers4["Content-Type"] = "application/json";
-        }
-        return headers4;
-      }
-      async request(endpoint, config = {}) {
-        console.log("[ApiClient] request called", { endpoint, method: config.method });
-        const { timeout = 3e4, responseType = "json", ...fetchConfig } = config;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-          console.log("[ApiClient] Building URL and headers...");
-          const { id, token } = await findWhitelabel();
-          const [url, defaultHeaders] = await Promise.all([
-            this.buildUrl(endpoint, id),
-            this.getDefaultHeaders(token, fetchConfig.body instanceof FormData)
-          ]);
-          console.log("[ApiClient] Fetching", {
-            url,
-            method: fetchConfig.method,
-            headers: defaultHeaders
-          });
-          const response = await fetch(url, {
-            ...fetchConfig,
-            headers: {
-              ...defaultHeaders,
-              ...fetchConfig.headers
-            },
-            signal: controller.signal
-          });
-          console.log("[ApiClient] Response received", { status: response.status, ok: response.ok });
-          if (!response.ok) {
-            const errBody = await response.text();
-            let message = `HTTP error ${response.status}`;
-            let code = "HTTP_ERROR";
-            try {
-              const errorData = JSON.parse(errBody);
-              if (typeof errorData.message === "string") message = errorData.message;
-              if (typeof errorData.code === "string") code = errorData.code;
-            } catch {
-              if (errBody.trim()) message = errBody.trim();
-            }
-            console.error("[ApiClient] Request failed", { status: response.status, message });
-            throw new ApiError(message, code, response.status);
-          }
-          if (responseType === "text") {
-            return await response.text();
-          }
-          const data = await response.json();
-          console.log("[ApiClient] Request successful", { hasData: !!data });
-          return data;
-        } catch (error) {
-          console.error("[ApiClient] Request error", { error });
-          if (error instanceof ApiError) {
-            throw error;
-          }
-          if (error instanceof Error) {
-            if (error.name === "AbortError") {
-              throw new ApiError("Tempo de requisi\xE7\xE3o excedido", "TIMEOUT", 408);
-            }
-            throw new ApiError(error.message, "NETWORK_ERROR", 0);
-          }
-          throw new ApiError("Erro desconhecido", "UNKNOWN_ERROR", 500);
-        } finally {
-          clearTimeout(timeoutId);
-        }
-      }
-      async get(endpoint, config) {
-        return this.request(endpoint, { ...config, method: "GET" });
-      }
-      async post(endpoint, data, config) {
-        return this.request(endpoint, {
-          ...config,
-          method: "POST",
-          body: data instanceof FormData ? data : data ? JSON.stringify(data) : void 0
-        });
-      }
-      async put(endpoint, data, config) {
-        return this.request(endpoint, {
-          ...config,
-          method: "PUT",
-          body: data instanceof FormData ? data : data ? JSON.stringify(data) : void 0
-        });
-      }
-      async patch(endpoint, data, config) {
-        return this.request(endpoint, {
-          ...config,
-          method: "PATCH",
-          body: data instanceof FormData ? data : data ? JSON.stringify(data) : void 0
-        });
-      }
-      async delete(endpoint, config) {
-        return this.request(endpoint, { ...config, method: "DELETE" });
-      }
-    };
-    api = {
-      apps: new ApiClient(process.env.GAPPS_R3_API_URL || "https://r3-api.greatapps.dev.br"),
-      pages: new ApiClient(process.env.GPAGES_R3_API_URL || "https://r3-api.greatpages.dev.br")
-    };
-    apiClient = api.apps;
-  }
-});
-
-// src/modules/users/services/user.service.ts
-var user_service_exports = {};
-__export(user_service_exports, {
-  userService: () => userService
-});
-import { cookies } from "next/headers";
-var AUTH_COOKIE_NAME, API_BASE_URL, UserService, userService;
-var init_user_service = __esm({
-  "src/modules/users/services/user.service.ts"() {
-    "use strict";
-    init_types();
-    init_find_whitelabel_action();
-    AUTH_COOKIE_NAME = "greatapps";
-    API_BASE_URL = process.env.GAPPS_R3_API_URL || "https://r3-api.greatapps.dev.br";
-    UserService = class {
-      async getAuthToken() {
-        if (process.env.DUMMY_AUTH_TOKEN) return process.env.DUMMY_AUTH_TOKEN;
-        const cookieStore = await cookies();
-        const token = cookieStore.get(AUTH_COOKIE_NAME)?.value;
-        if (!token) {
-          throw new ApiError("N\xE3o autenticado", "NOT_AUTHENTICATED_GAT", 401);
-        }
-        return token;
-      }
-      decodeJWT(token) {
-        try {
-          return JSON.parse(atob(token.split(".")[1]));
-        } catch {
-          throw new ApiError("Token inv\xE1lido", "INVALID_TOKEN", 401);
-        }
-      }
-      async findById() {
-        const token = await this.getAuthToken();
-        const payload = this.decodeJWT(token);
-        const { id_wl, id_account, id_user } = payload;
-        const { token: wlToken } = await findWhitelabel();
-        const url = `${API_BASE_URL}/v1/pt-br/${id_wl}/accounts/${id_account}/users/${id_user}`;
-        const response = await fetch(url, {
-          method: "GET",
-          headers: {
-            "Content-Type": "application/json",
-            authorization: wlToken
-          }
-        });
-        if (!response.ok) {
-          throw new ApiError("Erro ao buscar dados do usu\xE1rio", "FETCH_ERROR", response.status);
-        }
-        const data = await response.json();
-        if (data.status === 0 || !data.data || data.data.length === 0) {
-          throw new ApiError("Dados do usu\xE1rio n\xE3o encontrados", "USER_NOT_FOUND", 404);
-        }
-        return data.data[0];
-      }
-    };
-    userService = new UserService();
-  }
-});
-
-// src/infra/utils/params.ts
-function buildQueryParams(params) {
-  if (!params) {
-    return "";
-  }
-  const queryParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === null || value === void 0 || value === "") {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      queryParams.set(key, value.join(","));
-    } else {
-      queryParams.set(key, value.toString());
-    }
-  }
-  return queryParams.toString();
-}
-var init_params = __esm({
-  "src/infra/utils/params.ts"() {
-    "use strict";
-  }
-});
-
-// src/modules/auth/utils/get-user-context.ts
-import "server-only";
-import { cookies as cookies2 } from "next/headers";
-async function getUserContext() {
-  const cookieStore = await cookies2();
-  const token = process.env.DUMMY_AUTH_TOKEN || cookieStore.get(AUTH_COOKIE_NAME2)?.value;
-  if (!token) {
-    throw new ApiError("Usu\xE1rio n\xE3o autenticado", "NOT_AUTHENTICATED_GUC", 401);
-  }
-  try {
-    const payload = JSON.parse(atob(token.split(".")[1]));
-    return {
-      id_account: payload.id_account,
-      id_user: payload.id_user
-    };
-  } catch {
-    throw new ApiError("Token inv\xE1lido", "INVALID_TOKEN", 401);
-  }
-}
-var AUTH_COOKIE_NAME2;
-var init_get_user_context = __esm({
-  "src/modules/auth/utils/get-user-context.ts"() {
-    "use strict";
-    init_types();
-    AUTH_COOKIE_NAME2 = "greatapps";
-  }
-});
-
-// src/utils/file/index.ts
-var fileToBase64;
-var init_file = __esm({
-  "src/utils/file/index.ts"() {
-    "use strict";
-    fileToBase64 = async (file) => {
-      const buffer = Buffer.from(await file.arrayBuffer());
-      const mimeType = file.type || "application/octet-stream";
-      return `data:${mimeType};base64,${buffer.toString("base64")}`;
-    };
-  }
-});
-
-// src/modules/accounts/services/account.service.ts
-var account_service_exports = {};
-__export(account_service_exports, {
-  accountService: () => accountService
-});
-import "server-only";
-var AccountService, accountService;
-var init_account_service = __esm({
-  "src/modules/accounts/services/account.service.ts"() {
-    "use strict";
-    init_client();
-    init_types();
-    init_params();
-    init_get_user_context();
-    init_file();
-    AccountService = class {
-      async findCurrentAccount() {
-        const { id_account } = await getUserContext();
-        const response = await api.apps.get(`/accounts/${id_account}`);
-        if (response.status === 0 || !response.data?.[0]) {
-          throw new ApiError(
-            response.message || "Erro ao buscar dados da conta",
-            "GET_ACCOUNT_FAILED",
-            400
-          );
-        }
-        return response.data[0];
-      }
-      async listAccountUsers(params) {
-        const { id_account } = await getUserContext();
-        const queryParams = buildQueryParams(params);
-        const endpoint = `/accounts/${id_account}/users?${queryParams}`;
-        const response = await api.apps.get(endpoint);
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "Erro ao listar usu\xE1rios",
-            "LIST_ACCOUNT_USERS_FAILED",
-            400
-          );
-        }
-        return {
-          users: response.data || [],
-          total: response.total || 0
-        };
-      }
-      async changeUserPhoto(userId, photo) {
-        const { id_account } = await getUserContext();
-        const base64 = await fileToBase64(photo);
-        const response = await api.apps.put(
-          `/accounts/${id_account}/users/${userId}/file/photo`,
-          { file: base64 }
-        );
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "Erro ao mudar foto do usu\xE1rio",
-            "CHANGE_USER_PHOTO_FAILED",
-            400
-          );
-        }
-        return response;
-      }
-      async deleteAccountUser(userId) {
-        const { id_account } = await getUserContext();
-        const response = await api.apps.delete(
-          `/accounts/${id_account}/users/${userId}`
-        );
-        if (response.status === 0) {
-          throw new ApiError(response.message || "Erro ao deletar usu\xE1rio", "DELETE_USER_FAILED", 400);
-        }
-        return response;
-      }
-      async deleteAccount() {
-        const { id_account } = await getUserContext();
-        const response = await api.apps.delete(`/accounts/${id_account}`);
-        if (response.status === 0) {
-          throw new ApiError(response.message || "Erro ao deletar conta", "DELETE_ACCOUNT_FAILED", 400);
-        }
-        return response;
-      }
-      async createAccountUser(user) {
-        const { id_account } = await getUserContext();
-        const response = await api.apps.post(
-          `/accounts/${id_account}/users`,
-          {
-            ...user,
-            photo: user.photo ? await fileToBase64(user.photo) : null
-          }
-        );
-        if (response.status === 0) {
-          throw new ApiError(response.message || "Erro ao criar usu\xE1rio", "CREATE_USER_FAILED", 400);
-        }
-        return response;
-      }
-      async resolvePhotoField(user) {
-        if (user.photo === void 0) return {};
-        const photo = user.photo != null && typeof user.photo !== "string" ? await fileToBase64(user.photo) : user.photo;
-        return { photo };
-      }
-      async updateAccountUser(user) {
-        const { id_account, id_user } = await getUserContext();
-        const response = await api.apps.put(
-          `/accounts/${id_account}/users/${id_user}`,
-          { ...user, ...await this.resolvePhotoField(user) }
-        );
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "Erro ao atualizar usu\xE1rio",
-            "UPDATE_USER_FAILED",
-            400
-          );
-        }
-        return response;
-      }
-      async updateAccountUserById(userId, user) {
-        const { id_account } = await getUserContext();
-        const response = await api.apps.put(
-          `/accounts/${id_account}/users/${userId}`,
-          { ...user, ...await this.resolvePhotoField(user) }
-        );
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "Erro ao atualizar usu\xE1rio",
-            "UPDATE_USER_FAILED",
-            400
-          );
-        }
-        return response;
-      }
-      async updateAccount(data) {
-        const { id_account } = await getUserContext();
-        const response = await api.apps.put(`/accounts/${id_account}`, data);
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "Erro ao atualizar conta",
-            "UPDATE_ACCOUNT_FAILED",
-            400
-          );
-        }
-        return response;
-      }
-      async requestContactReset(type, newContact) {
-        const { id_account, id_user } = await getUserContext();
-        const response = await api.apps.post(
-          `/accounts/${id_account}/users/${id_user}/resetContact/request`,
-          { type, newContact }
-        );
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "Erro ao solicitar altera\xE7\xE3o",
-            "REQUEST_CONTACT_RESET_FAILED",
-            400
-          );
-        }
-      }
-      async confirmContactReset(type, token, newContact) {
-        const { id_account, id_user } = await getUserContext();
-        const response = await api.apps.post(
-          `/accounts/${id_account}/users/${id_user}/resetContact/confirm`,
-          { type, token, newContact }
-        );
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "C\xF3digo inv\xE1lido ou expirado",
-            "CONFIRM_CONTACT_RESET_FAILED",
-            400
-          );
-        }
-      }
-      async changePassword(data) {
-        const { id_account, id_user } = await getUserContext();
-        const response = await api.apps.put(
-          `/accounts/${id_account}/users/${id_user}/action/changePassword`,
-          data
-        );
-        if (response.status === 0) {
-          throw new ApiError(
-            response.message || "Erro ao alterar senha",
-            "CHANGE_PASSWORD_FAILED",
-            400
-          );
-        }
-        return response;
-      }
-    };
-    accountService = new AccountService();
-  }
-});
-
-// src/server.ts
-init_client();
-import "server-only";
-
-// src/modules/auth/services/auth.service.ts
-init_client();
-init_types();
-import { cookies as cookies3 } from "next/headers";
-var AUTH_COOKIE_NAME3 = "greatapps";
-var COOKIE_MAX_AGE = 60 * 60 * 24 * 30;
-var COOKIE_OPTIONS = {
-  httpOnly: true,
-  secure: process.env.NODE_ENV === "production",
-  sameSite: "lax",
-  path: "/",
-  domain: process.env.DOMAIN_COOKIE
-};
-var AuthService = class {
-  async login(credentials, clientInfo) {
-    const response = await api.apps.post("/auth/login", {
-      email: credentials.email,
-      password: credentials.password,
-      location: clientInfo.location,
-      ip: clientInfo.ip,
-      timezone: clientInfo.timezone,
-      agent: clientInfo.agent
-    });
-    console.log("[AuthService.login] response", JSON.stringify(response));
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "E-mail ou senha incorretos",
-        response.code || "LOGIN_FAILED",
-        401
-      );
-    }
-    if (!response.cookie) {
-      throw new ApiError(
-        "Resposta de autentica\xE7\xE3o inv\xE1lida",
-        "INVALID_RESPONSE",
-        500
-      );
-    }
-    if (response.two_factor_required) {
-      return { result: "two_factor_required", cookie: response.cookie };
-    }
-    await this.setAuthCookie(response.cookie);
-    const [{ userService: userService2 }, { accountService: accountService2 }] = await Promise.all([
-      Promise.resolve().then(() => (init_user_service(), user_service_exports)),
-      Promise.resolve().then(() => (init_account_service(), account_service_exports))
-    ]);
-    const [user, account] = await Promise.all([
-      userService2.findById(),
-      accountService2.findCurrentAccount()
-    ]);
-    return {
-      result: "success",
-      user,
-      account,
-      accessToken: response.cookie,
-      refreshToken: "",
-      expiresAt: new Date(Date.now() + COOKIE_MAX_AGE * 1e3).toISOString()
-    };
-  }
-  async verifyTwoFactor(cookie, code, clientInfo) {
-    const payload = {
-      location: clientInfo.location,
-      ip: clientInfo.ip,
-      timezone: clientInfo.timezone,
-      agent: clientInfo.agent,
-      cookie,
-      code
-    };
-    const response = await api.apps.post(
-      "/auth/code",
-      payload
-    );
-    if (response.status === 0) {
-      throw new ApiError("C\xF3digo 2FA inv\xE1lido", "TWO_FACTOR_FAILED", 401);
-    }
-    if (!response?.data?.cookie) {
-      throw new ApiError(
-        "Resposta de autentica\xE7\xE3o inv\xE1lida ap\xF3s 2FA",
-        "INVALID_RESPONSE",
-        500
-      );
-    }
-    await this.setAuthCookie(response.data.cookie);
-    return { status: 1 };
-  }
-  async register(data, _clientInfo) {
-    const today = /* @__PURE__ */ new Date();
-    const trialEndDate = new Date(today);
-    trialEndDate.setDate(today.getDate() + 7);
-    const payload = {
-      name: data.accountName,
-      bussiness_type: data.businessType,
-      language: "pt-br",
-      timezone: "America/Sao_Paulo",
-      currency: "BRL",
-      user: {
-        id_api: "",
-        name: data.name,
-        last_name: data.lastName || "",
-        rg: data.rg || "",
-        cpf: data.cpf || "",
-        gender: data.gender,
-        email: data.email,
-        phone: data.phone,
-        password: data.password,
-        profile: "owner",
-        language: "pt-br"
-      },
-      subscription: {
-        type: "trial",
-        id_cupom: data.couponCode || "",
-        id_plan: data.idPlan || 1,
-        due_date: trialEndDate.toISOString().split("T")[0],
-        id_product: 1
-      }
-    };
-    const response = await api.apps.post(
-      "/accounts",
-      payload
-    );
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao criar conta",
-        "REGISTER_FAILED",
-        400
-      );
-    }
-    if (!response.data || response.data.length === 0) {
-      throw new ApiError(
-        "Resposta de registro inv\xE1lida",
-        "INVALID_RESPONSE",
-        500
-      );
-    }
-    if (!response.cookie) {
-      throw new ApiError(
-        "Resposta de autentica\xE7\xE3o inv\xE1lida",
-        "INVALID_RESPONSE",
-        500
-      );
-    }
-    const accountData = response.data[0];
-    await this.setAuthCookie(response.cookie);
-    const [{ userService: userService2 }, { accountService: accountService2 }] = await Promise.all([
-      Promise.resolve().then(() => (init_user_service(), user_service_exports)),
-      Promise.resolve().then(() => (init_account_service(), account_service_exports))
-    ]);
-    const [user, account] = await Promise.all([
-      userService2.findById(),
-      accountService2.findCurrentAccount()
-    ]);
-    return {
-      user,
-      account,
-      accessToken: response.cookie,
-      refreshToken: "",
-      expiresAt: new Date(Date.now() + COOKIE_MAX_AGE * 1e3).toISOString(),
-      requiresEmailVerification: !accountData.verified
-    };
-  }
-  async logout(clientInfo) {
-    const cookie = await this.getToken();
-    if (!cookie) {
-      throw new ApiError(
-        "Usu\xE1rio n\xE3o autenticado",
-        "NOT_AUTHENTICATED_LOGOUT",
-        401
-      );
-    }
-    const payload = {
-      location: clientInfo.location,
-      ip: clientInfo.ip,
-      timezone: clientInfo.timezone,
-      agent: clientInfo.agent,
-      cookie
-    };
-    try {
-      const response = await api.apps.post(
-        "/auth/logout",
-        payload
-      );
-      if (response.status === 0) {
-        throw new ApiError(
-          response.message || "Erro ao realizar logout",
-          response.code || "LOGOUT_FAILED",
-          400
-        );
-      }
-    } finally {
-      await this.removeAuthCookie();
-    }
-    return {
-      success: true
-    };
-  }
-  async forgotPassword(_data) {
-    throw new ApiError(
-      "Recupera\xE7\xE3o de senha n\xE3o implementada",
-      "NOT_IMPLEMENTED",
-      501
-    );
-  }
-  async resetPassword(_data) {
-    throw new ApiError(
-      "Redefini\xE7\xE3o de senha n\xE3o implementada",
-      "NOT_IMPLEMENTED",
-      501
-    );
-  }
-  async verifyEmail(_data) {
-    throw new ApiError(
-      "Verifica\xE7\xE3o de email n\xE3o implementada",
-      "NOT_IMPLEMENTED",
-      501
-    );
-  }
-  async resendVerification(_data) {
-    throw new ApiError(
-      "Reenvio de verifica\xE7\xE3o n\xE3o implementado",
-      "NOT_IMPLEMENTED",
-      501
-    );
-  }
-  async validateSession(clientInfo) {
-    const cookie = await this.getToken();
-    if (!cookie) {
-      return false;
-    }
-    try {
-      const payload = {
-        location: clientInfo.location,
-        ip: clientInfo.ip,
-        timezone: clientInfo.timezone,
-        agent: clientInfo.agent,
-        cookie
-      };
-      const response = await api.apps.post(
-        "/auth/keep",
-        payload
-      );
-      return response.status === 1;
-    } catch (error) {
-      console.error("[AuthService] validateSession error", error);
-      return false;
-    }
-  }
-  async isAuthenticated() {
-    const token = await this.getToken();
-    return !!token;
-  }
-  async getToken() {
-    if (process.env.DUMMY_AUTH_TOKEN) return process.env.DUMMY_AUTH_TOKEN;
-    const cookieStore = await cookies3();
-    return cookieStore.get(AUTH_COOKIE_NAME3)?.value;
-  }
-  async setAuthCookie(token) {
-    const cookieStore = await cookies3();
-    cookieStore.set(AUTH_COOKIE_NAME3, token, {
-      ...COOKIE_OPTIONS,
-      maxAge: COOKIE_MAX_AGE
-    });
-  }
-  async removeAuthCookie() {
-    const cookieStore = await cookies3();
-    cookieStore.delete({
-      name: AUTH_COOKIE_NAME3,
-      ...COOKIE_OPTIONS
-    });
-  }
-};
-var authService = new AuthService();
-
-// src/server.ts
-init_whitelabel_service();
-
-// src/modules/whitelabel/services/whitelabel-styles.service.ts
-init_types();
-import greatCache2 from "@greatapps/cache";
-function parseStyleField(value) {
-  if (typeof value === "string") {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return null;
-    }
-  }
-  if (value && typeof value === "object") return value;
-  return null;
-}
-function mapWithStyleResponse(row) {
-  return {
-    id: row["style_id"],
-    id_wl: row["style_id_wl"],
-    general: parseStyleField(row["style_general"]),
-    signin_page: parseStyleField(row["style_signin_page"]),
-    signup_page: parseStyleField(row["style_signup_page"]),
-    dashboard: parseStyleField(row["style_dashboard"])
-  };
-}
-var WhitelabelStylesService = class {
-  getApiUrl() {
-    const apiUrl = process.env.GAPPS_R3_API_URL;
-    if (!apiUrl) throw new ApiError("GAPPS_R3_API_URL not configured", "CONFIG_ERROR", 500);
-    return apiUrl;
-  }
-  getToken() {
-    const token = process.env.WHITELABEL_TOKEN_MASTER;
-    if (!token) throw new ApiError("WHITELABEL_TOKEN_MASTER not configured", "CONFIG_ERROR", 500);
-    return token;
-  }
-  async getByWlId(id_wl) {
-    const apiUrl = this.getApiUrl();
-    const token = this.getToken();
-    const url = `${apiUrl}/v1/pt-br/1/whitelabels/${id_wl}/with-style`;
-    console.log("[WhitelabelStylesService] Fetching with-style for id_wl", { id_wl, url });
-    const cache3 = new greatCache2({
-      service: "whitelabel-styles-service",
-      version: "1.0",
-      domain: "whitelabel-cache.greatapps.com.br",
-      ambient: process.env.NODE_ENV || "development"
-    });
-    const cacheKey = `whitelabel-styles-${id_wl}`;
-    const cachedData = await cache3.select(cacheKey);
-    if (cachedData.status == 1 && "data" in cachedData && cachedData.data) {
-      console.log("[WhitelabelStylesService] Cache hit for id_wl", { id_wl });
-      return JSON.parse(cachedData.data);
-    }
-    const response = await fetch(url, {
-      method: "GET",
-      headers: { authorization: token }
-    });
-    if (!response.ok) {
-      console.error("[WhitelabelStylesService] Failed to fetch with-style", { status: response.status });
-      return null;
-    }
-    const result = await response.json();
-    if (result.status !== 1 || !result.data?.length) {
-      console.warn("[WhitelabelStylesService] No data in with-style for id_wl", { id_wl });
-      return null;
-    }
-    const parsed = mapWithStyleResponse(result.data[0]);
-    if (parsed.id) {
-      await cache3.insert(cacheKey, JSON.stringify(parsed), 300);
-    }
-    return parsed;
-  }
-};
-var whitelabelStylesService = new WhitelabelStylesService();
-
-// src/modules/whitelabel/actions/find-whitelabel-styles.action.ts
-import { cache as cache2 } from "react";
-var findWhitelabelStyles = cache2(async (id_wl) => {
-  try {
-    return await whitelabelStylesService.getByWlId(id_wl);
-  } catch (error) {
-    console.error("[findWhitelabelStyles] Error fetching styles:", error);
-    return null;
-  }
-});
-
-// src/modules/subscriptions/services/subscriptions.service.ts
-init_client();
-init_types();
-init_params();
-init_get_user_context();
 import "server-only";
-
-// src/modules/subscriptions/types.ts
-import z2 from "zod";
-var SubscriptionItemSchema = z2.object({
-  id: z2.union([z2.number(), z2.string()]),
-  deleted: z2.number(),
-  datetime_alt: z2.coerce.date().nullable().optional(),
-  datetime_del: z2.coerce.date().nullable().optional(),
-  datetime_add: z2.coerce.date(),
-  id_wl: z2.number(),
-  id_subscription: z2.union([z2.number(), z2.string()]),
-  id_addon: z2.number().nullable(),
-  addon_name: z2.string().optional(),
-  value: z2.number(),
-  currency: z2.string(),
-  quantity: z2.number(),
-  payment_status: z2.number(),
-  id_charge: z2.union([z2.number(), z2.string()]).nullable(),
-  trial: z2.boolean(),
-  trial_ends_at: z2.coerce.date().nullable().optional()
-});
-var SubscriptionSchema = z2.object({
-  id: z2.union([z2.number(), z2.string()]),
-  deleted: z2.number(),
-  datetime_alt: z2.coerce.date().nullable().optional(),
-  datetime_del: z2.coerce.date().nullable().optional(),
-  datetime_add: z2.coerce.date(),
-  id_wl: z2.number(),
-  id_account: z2.union([z2.number(), z2.string()]),
-  id_card: z2.union([z2.number(), z2.string()]).nullable(),
-  id_coupon: z2.union([z2.number(), z2.string()]).nullable(),
-  type: z2.string(),
-  payment_method: z2.number().nullable(),
-  periodicity: z2.union([z2.number(), z2.string()]).nullable(),
-  value: z2.number().nullable(),
-  id_product: z2.number(),
-  id_plan: z2.number(),
-  plan_name: z2.string().nullable().optional(),
-  id_gateway: z2.union([z2.number(), z2.string()]).nullable(),
-  gateway_account: z2.string().nullable(),
-  date_hiring: z2.coerce.date().nullable(),
-  date_due: z2.coerce.date(),
-  date_cancellation: z2.coerce.date().nullable(),
-  date_verification: z2.coerce.date().nullable(),
-  cancellation_reason: z2.string().nullable(),
-  cancellation_description: z2.string().nullable(),
-  active: z2.boolean(),
-  charged: z2.boolean(),
-  datetime_last_update_periodicity: z2.coerce.date().nullable().optional(),
-  card_name: z2.string().nullable().optional(),
-  card_brand: z2.string().nullable().optional(),
-  card_number: z2.string().nullable().optional(),
-  items: z2.array(SubscriptionItemSchema)
-});
-
-// src/modules/subscriptions/services/subscriptions.service.ts
-var SubscriptionsService = class {
-  async listSubscriptions(params) {
-    const { id_account } = await getUserContext();
-    const query = buildQueryParams(params);
-    const url = `/accounts/${id_account}/subscriptions${query ? `?${query}` : ""}`;
-    const response = await api.apps.get(url);
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao listar assinaturas",
-        "LIST_SUBSCRIPTIONS_FAILED",
-        400
-      );
-    }
-    const data = response.data.map((item) => SubscriptionSchema.parse(item));
-    return {
-      data,
-      total: response.total,
-      success: true
-    };
-  }
-};
-var subscriptionsService = new SubscriptionsService();
-
-// src/modules/ia-credits/services/ia-credits.service.ts
-init_client();
-init_types();
-init_get_user_context();
-import "server-only";
-
-// src/modules/ia-credits/types.ts
-import z3 from "zod";
-var IaCreditOperationSchema = z3.object({
-  id: z3.union([z3.number(), z3.string()]),
-  deleted: z3.number(),
-  datetime_add: z3.coerce.date().nullable(),
-  id_wl: z3.number(),
-  id_subscription: z3.union([z3.number(), z3.string()]),
-  id_addon: z3.number(),
-  operation: z3.string(),
-  // 'add' | 'subtract'
-  operation_value: z3.union([z3.number(), z3.string()]).transform((v) => Number(v)),
-  balance_after_operation: z3.union([z3.number(), z3.string()]).optional(),
-  balance_before_operation: z3.union([z3.number(), z3.string()]).optional(),
-  operation_ref: z3.string().nullable().optional(),
-  operation_origin: z3.string().nullable().optional(),
-  expiration_time: z3.string().nullable(),
-  has_expired: z3.boolean(),
-  consumed_from_add_id: z3.union([z3.number(), z3.string()]).nullable(),
-  id_user_add: z3.union([z3.number(), z3.string()]).nullable(),
-  user_name: z3.string().nullable().optional()
-}).passthrough();
-
-// src/modules/ia-credits/services/ia-credits.service.ts
-var IaCreditsService = class {
-  async listOperations(subscriptionId) {
-    const { id_account } = await getUserContext();
-    const endpoint = `/accounts/${id_account}/subscriptions/${subscriptionId}/items/balance/list?page=1&limit=20&sort=id:DESC`;
-    const response = await api.apps.get(endpoint);
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao listar cr\xE9ditos de IA",
-        "LIST_IA_CREDITS_FAILED",
-        400
-      );
-    }
-    const raw = response.data ?? [];
-    const data = raw.map((item) => IaCreditOperationSchema.parse(item));
-    return {
-      data,
-      total: response.total ?? data.length,
-      success: true
-    };
-  }
-};
-var iaCreditsService = new IaCreditsService();
-
-// src/server.ts
-init_find_whitelabel_action();
-
-// src/modules/auth/actions/validate-session.action.ts
-import { redirect } from "next/navigation";
-import { cookies as cookies4, headers as headers3 } from "next/headers";
-
-// src/infra/utils/client-info.ts
-import { headers as headers2 } from "next/headers";
-async function getClientInfoFromRequest(request) {
-  let headerStore;
-  if (request) {
-    headerStore = request.headers;
-  } else {
-    const nextHeaders = await headers2();
-    headerStore = nextHeaders;
-  }
-  return {
-    location: {
-      continent: headerStore.get("cf-ipcountry") || headerStore.get("x-vercel-ip-country") || "Unknown",
-      country: headerStore.get("x-vercel-ip-country") || "Unknown",
-      region: headerStore.get("x-vercel-ip-country-region") || "Unknown",
-      city: headerStore.get("x-vercel-ip-city") || "Unknown",
-      latitude: headerStore.get("x-vercel-ip-latitude") || "0",
-      longitude: headerStore.get("x-vercel-ip-longitude") || "0"
-    },
-    ip: headerStore.get("cf-connecting-ip") || headerStore.get("x-forwarded-for") || headerStore.get("x-real-ip") || "Unknown",
-    timezone: headerStore.get("cf-timezone") || "America/Sao_Paulo",
-    agent: headerStore.get("user-agent") || "Unknown"
-  };
-}
-
-// src/modules/auth/actions/validate-session.action.ts
-async function redirectToLogin() {
-  const h = await headers3();
-  const referer = h.get("referer") || "/";
-  if (!referer) {
-    redirect("/login");
-    return;
-  }
-  const url = new URL(referer);
-  if (["/login", "/register", "/forgot-password"].includes(url.pathname)) {
-    return;
-  }
-  redirect("/login");
-}
-async function validateSessionAction() {
-  if (process.env.DUMMY_AUTH_TOKEN) return true;
-  const cookieStore = await cookies4();
-  const cookie = cookieStore.get("greatapps")?.value;
-  if (!cookie) {
-    await redirectToLogin();
-    return false;
-  }
-  try {
-    const clientInfo = await getClientInfoFromRequest();
-    const isValid = await authService.validateSession(clientInfo);
-    if (!isValid) {
-      await authService.removeAuthCookie();
-      await redirectToLogin();
-      return false;
-    }
-    return true;
-  } catch (error) {
-    console.error("[validateSessionAction] Error:", error);
-    await authService.removeAuthCookie();
-    await redirectToLogin();
-    return false;
-  }
-}
-
-// src/utils/safeServerAction.ts
-init_types();
-import { isRedirectError } from "next/dist/client/components/redirect-error";
-async function safeServerAction(fn) {
-  try {
-    const data = await fn();
-    return { success: true, data };
-  } catch (error) {
-    if (isRedirectError(error)) throw error;
-    const message = error instanceof ApiError ? error.message : error instanceof Error ? error.message : "Erro desconhecido";
-    return { success: false, error: message };
-  }
-}
-
-// src/modules/users/action/find-user-by-id.action.ts
-init_user_service();
-async function findUserById() {
-  return safeServerAction(() => userService.findById());
-}
-
-// src/modules/accounts/actions/find-current-account.action.ts
-init_account_service();
-async function findCurrentAccount() {
-  return safeServerAction(() => accountService.findCurrentAccount());
-}
-
-// src/modules/subscriptions/actions/list-subscriptions.action.ts
-async function listSubscriptionsAction(params) {
-  return safeServerAction(() => subscriptionsService.listSubscriptions(params));
-}
-
-// src/modules/ia-credits/actions/list-ia-credits.action.ts
-async function listIaCreditsAction(subscriptionId) {
-  return safeServerAction(() => iaCreditsService.listOperations(subscriptionId));
-}
-
-// src/modules/projects/services/project-users.service.ts
-init_client();
-init_types();
-init_params();
-init_get_user_context();
-import "server-only";
-
-// src/modules/projects/types.ts
-import { z as z4 } from "zod";
-var ProjectUserSchema = z4.object({
-  id_user: z4.union([z4.number(), z4.string()]).transform(Number),
-  id_account: z4.union([z4.number(), z4.string()]).transform(Number),
-  id_project: z4.union([z4.number(), z4.string()]).transform(Number),
-  name: z4.string().nullable(),
-  email: z4.string().nullable(),
-  profile: z4.string().nullable().optional().default("viewer"),
-  photo: z4.string().nullable().optional()
-});
-var AccountUserSchema = z4.object({
-  id: z4.union([z4.number(), z4.string()]).transform(Number),
-  name: z4.string().nullable(),
-  email: z4.string().nullable(),
-  profile: z4.string().nullable().optional().default("viewer"),
-  photo: z4.string().nullable().optional()
-});
-
-// src/modules/projects/services/project-users.service.ts
-var ProjectUsersService = class {
-  async listInProject(projectId, params = {}) {
-    const { id_account, id_user } = await getUserContext();
-    const query = buildQueryParams(params);
-    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}/users${query ? `?${query}` : ""}`;
-    const response = await api.apps.get(url);
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao listar usu\xE1rios do projeto",
-        "LIST_PROJECT_USERS_FAILED",
-        400
-      );
-    }
-    return {
-      data: response.data.map((item) => ProjectUserSchema.parse(item)),
-      total: response.total,
-      page: params.page ?? 1
-    };
-  }
-  async listNotInProject(projectId, params = {}) {
-    const { id_account } = await getUserContext();
-    const query = buildQueryParams({ notInProject: projectId, ...params });
-    const url = `/accounts/${id_account}/users${query ? `?${query}` : ""}`;
-    const response = await api.apps.get(url);
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao listar usu\xE1rios dispon\xEDveis",
-        "LIST_AVAILABLE_USERS_FAILED",
-        400
-      );
-    }
-    return {
-      data: response.data.map((item) => AccountUserSchema.parse(item)),
-      total: response.total,
-      page: params.page ?? 1
-    };
-  }
-  async addToProject({ projectId, users }) {
-    const { id_account, id_user } = await getUserContext();
-    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}/users`;
-    const response = await api.apps.post(url, { users });
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao adicionar usu\xE1rio ao projeto",
-        "ADD_PROJECT_USER_FAILED",
-        400
-      );
-    }
-  }
-  async removeFromProject({ projectId, users }) {
-    const { id_account, id_user } = await getUserContext();
-    const url = `/account/${id_account}/user/${id_user}/projects/${projectId}/users`;
-    const response = await api.apps.delete(url, {
-      body: JSON.stringify({ users })
-    });
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao remover usu\xE1rio do projeto",
-        "REMOVE_PROJECT_USER_FAILED",
-        400
-      );
-    }
-  }
-};
-var projectUsersService = new ProjectUsersService();
-
-// src/modules/projects/actions/list-project-users.action.ts
-async function listProjectUsersAction(projectId, params = {}) {
-  return safeServerAction(() => projectUsersService.listInProject(projectId, params));
-}
-
-// src/modules/projects/actions/list-available-users.action.ts
-async function listAvailableUsersAction(projectId, params = {}) {
-  return safeServerAction(() => projectUsersService.listNotInProject(projectId, params));
-}
-
-// src/modules/projects/actions/add-project-user.action.ts
-async function addProjectUserAction(params) {
-  return safeServerAction(() => projectUsersService.addToProject(params));
-}
-
-// src/modules/projects/actions/remove-project-user.action.ts
-async function removeProjectUserAction(params) {
-  return safeServerAction(() => projectUsersService.removeFromProject(params));
-}
-
-// src/server.ts
-init_account_service();
-
-// src/modules/accounts/services/two-factor.service.ts
-init_types();
-init_get_user_context();
-init_find_whitelabel_action();
-import "server-only";
-var TWO_FA_BASE_URL = process.env.R2_2FA_URL || "https://r2-2fa.greatapps.dev.br";
-var TwoFactorService = class {
-  async request(path, body) {
-    const { id, token } = await findWhitelabel();
-    const { id_account, id_user } = await getUserContext();
-    const url = `${TWO_FA_BASE_URL}/v1/${id}/account/${id_account}/users/${id_user}/2fa/${path}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        authorization: token
-      },
-      body: body ? JSON.stringify(body) : void 0
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new ApiError(
-        errorData.message || `HTTP error ${response.status}`,
-        "HTTP_ERROR",
-        response.status
-      );
-    }
-    return response.json();
-  }
-  async generate() {
-    const response = await this.request("generate");
-    if (response.status === 0) {
-      throw new ApiError(response.message || "Erro ao gerar QR Code", "GENERATE_2FA_FAILED", 400);
-    }
-    return response;
-  }
-  async confirm(code) {
-    const response = await this.request("confirm", { code });
-    if (response.status === 0) {
-      throw new ApiError(response.message || "C\xF3digo inv\xE1lido", "CONFIRM_2FA_FAILED", 400);
-    }
-    return response;
-  }
-  async verify(code) {
-    const response = await this.request("verify", { code });
-    if (response.status === 0) {
-      throw new ApiError(response.message || "C\xF3digo inv\xE1lido", "VERIFY_2FA_FAILED", 400);
-    }
-    return response;
-  }
-  async disable() {
-    const { id, token } = await findWhitelabel();
-    const { id_account, id_user } = await getUserContext();
-    const url = `${TWO_FA_BASE_URL}/v1/${id}/account/${id_account}/users/${id_user}/2fa`;
-    const response = await fetch(url, {
-      method: "DELETE",
-      headers: { authorization: token }
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new ApiError(
-        errorData.message || `HTTP error ${response.status}`,
-        "HTTP_ERROR",
-        response.status
-      );
-    }
-    const data = await response.json();
-    if (data.status === 0) {
-      throw new ApiError(data.message || "Erro ao desabilitar 2FA", "DISABLE_2FA_FAILED", 400);
-    }
-    return data;
-  }
-};
-var twoFactorService = new TwoFactorService();
-
-// src/modules/accounts/actions/account-management.action.ts
-init_account_service();
-async function listAccountUsersAction(params) {
-  return safeServerAction(async () => {
-    const { users, total } = await accountService.listAccountUsers(params);
-    return { data: users, total };
-  });
-}
-async function updateUserAction(user) {
-  return safeServerAction(() => accountService.updateAccountUser(user));
-}
-async function updateAccountUserByIdAction(userId, user) {
-  return safeServerAction(() => accountService.updateAccountUserById(userId, user));
-}
-async function updateAccountAction(data) {
-  return safeServerAction(() => accountService.updateAccount(data));
-}
-async function deleteAccountUserAction(userId) {
-  return safeServerAction(() => accountService.deleteAccountUser(userId));
-}
-async function deleteAccountAction() {
-  return safeServerAction(() => accountService.deleteAccount());
-}
-async function createAccountUserAction(user) {
-  return safeServerAction(() => accountService.createAccountUser(user));
-}
-async function changePasswordAction(data) {
-  return safeServerAction(() => accountService.changePassword(data));
-}
-async function requestEmailChangeAction(newEmail) {
-  return safeServerAction(() => accountService.requestContactReset("email", newEmail));
-}
-async function confirmEmailChangeAction(token, newEmail) {
-  return safeServerAction(() => accountService.confirmContactReset("email", token, newEmail));
-}
-async function requestPhoneChangeAction(newPhone) {
-  return safeServerAction(() => accountService.requestContactReset("phone", newPhone));
-}
-async function confirmPhoneChangeAction(token, newPhone) {
-  return safeServerAction(() => accountService.confirmContactReset("phone", token, newPhone));
-}
-async function generateTwoFactorAction() {
-  return safeServerAction(async () => {
-    const result = await twoFactorService.generate();
-    return {
-      qrcode: result.data.qrcode,
-      backupCodes: result.data.backup_codes
-    };
-  });
-}
-async function confirmTwoFactorAction(code) {
-  return safeServerAction(async () => {
-    await twoFactorService.confirm(code);
-    await accountService.updateAccountUser({ two_factor_authentication: true });
-  });
-}
-async function disableTwoFactorAction(code) {
-  return safeServerAction(async () => {
-    await twoFactorService.verify(code);
-    await twoFactorService.disable();
-  });
-}
-
-// src/server.ts
-init_get_user_context();
+import { ApiClient, api, apiClient } from "./infra/api/client";
+import { authService } from "./modules/auth/services/auth.service";
+import { whitelabelService } from "./modules/whitelabel/services/whitelabel.service";
+import { whitelabelStylesService } from "./modules/whitelabel/services/whitelabel-styles.service";
+import { findWhitelabelStyles } from "./modules/whitelabel/actions/find-whitelabel-styles.action";
+import { subscriptionsService } from "./modules/subscriptions/services/subscriptions.service";
+import { iaCreditsService } from "./modules/ia-credits/services/ia-credits.service";
+import { findWhitelabel } from "./modules/whitelabel/actions/find-whitelabel.action";
+import { validateSessionAction } from "./modules/auth/actions/validate-session.action";
+import { findUserById } from "./modules/users/action/find-user-by-id.action";
+import { findCurrentAccount } from "./modules/accounts/actions/find-current-account.action";
+import { listSubscriptionsAction } from "./modules/subscriptions/actions/list-subscriptions.action";
+import { listIaCreditsAction } from "./modules/ia-credits/actions/list-ia-credits.action";
+import { projectUsersService } from "./modules/projects/services/project-users.service";
+import { listProjectUsersAction } from "./modules/projects/actions/list-project-users.action";
+import { listAvailableUsersAction } from "./modules/projects/actions/list-available-users.action";
+import { addProjectUserAction } from "./modules/projects/actions/add-project-user.action";
+import { removeProjectUserAction } from "./modules/projects/actions/remove-project-user.action";
+import { accountService } from "./modules/accounts/services/account.service";
+import { twoFactorService } from "./modules/accounts/services/two-factor.service";
+import {
+  listAccountUsersAction,
+  updateUserAction,
+  updateAccountAction,
+  updateAccountUserByIdAction,
+  deleteAccountUserAction,
+  deleteAccountAction,
+  createAccountUserAction,
+  changePasswordAction,
+  requestEmailChangeAction,
+  confirmEmailChangeAction,
+  requestPhoneChangeAction,
+  confirmPhoneChangeAction,
+  generateTwoFactorAction,
+  confirmTwoFactorAction,
+  disableTwoFactorAction
+} from "./modules/accounts/actions/account-management.action";
+import { getClientInfoFromRequest } from "./infra/utils/client-info";
+import { getUserContext } from "./modules/auth/utils/get-user-context";
+import { safeServerAction } from "./utils/safeServerAction";
 export {
   ApiClient,
   accountService,