Method getMe

apps/api/src/api/users/users.service.ts:52–119

(userId: string, accountId: string)

  }

  async getMe(userId: string, accountId: string): Promise<IMeResponse> {
    const [user, account, activeMembership, allMemberships] = await Promise.all(
      [
        this.getById(userId),
        db.query.accounts.findFirst({
          where: and(eq(accounts.id, accountId), isNull(accounts.deletedAt)),
        }),
        accountsService.getActiveMembership(userId, accountId),
        accountsService.getMembershipsForUser(userId),
      ]
    );

    if (!user) {
      throw ApiErrors.notFound("User");
    }

    if (!account) {
      throw ApiErrors.notFound("Account");
    }

    if (!activeMembership) {
      throw ApiErrors.forbidden("No active membership for the JWT account");
    }

    const features = await resolveAccountFeatures(accountId);
    const [authProviders, hasPasswordLogin] = await Promise.all([
      oauthAuthService.getLinkedProviders(userId),
      oauthAuthService.hasPasswordLogin(userId),
    ]);

    const accountIds = allMemberships.map((membership) => membership.accountId);
    const accountRows =
      accountIds.length === 0
        ? []
        : await db.query.accounts.findMany({
            where: (table, { and: andOp, inArray, isNull: isNullOp }) =>
              andOp(inArray(table.id, accountIds), isNullOp(table.deletedAt)),
          });
    const accountNameMap = new Map(
      accountRows.map((row) => [row.id, row.name])
    );

    const memberships: IMembershipSummary[] = allMemberships.map(
      (membership) => ({
        accountId: membership.accountId,
        accountName: accountNameMap.get(membership.accountId) ?? "",
        role: membership.role,
      })
    );

    return {
      user: toPublicUserProfile(user),
      account: { id: account.id, name: account.name },
      role: activeMembership.role,
      memberships,
      features,
      capabilities: {
        billing: env.BILLING_ENABLED,