Victor JackandRotimi Best
a83e172e6d
* fixed error of not showing the org name API response error * Fixed the error also for organization settings page * modified * Keep field-specific mapping in OrgApi --------- Co-authored-by: Rotimi Best <[email protected]>
1278 lines
41 KiB
TypeScript
1278 lines
41 KiB
TypeScript
import * as schema from '@db/schema';
|
|
|
|
import type { OrganizationPlan, OrganizationWithMemberAndPlans, OrganizationWithPlans } from './types';
|
|
import type {
|
|
TNewOrganization,
|
|
TNewOrganizationPlan,
|
|
TNewOrganizationmember,
|
|
TOrganization,
|
|
TOrganizationPlan
|
|
} from '@db/types';
|
|
import {
|
|
and,
|
|
asc,
|
|
count,
|
|
desc,
|
|
eq,
|
|
getTableColumns,
|
|
gt,
|
|
ilike,
|
|
inArray,
|
|
isNotNull,
|
|
ne,
|
|
not,
|
|
notInArray,
|
|
or,
|
|
sql
|
|
} from 'drizzle-orm';
|
|
|
|
import { PLAN } from '@cio/utils/plans';
|
|
import { ROLE } from '@cio/utils/constants';
|
|
import { db, type DbOrTxClient } from '@db/drizzle';
|
|
import type { TAudienceSortBy, TAudienceSortOrder } from '@cio/utils/validation/organization';
|
|
|
|
export function getOrgIdBySiteName(siteName: string) {
|
|
return db.select().from(schema.organization).where(eq(schema.organization.siteName, siteName)).limit(1);
|
|
}
|
|
|
|
/**
|
|
* Hostnames (lowercase) for organizations with a verified custom domain.
|
|
* Used by the API to warm an in-memory CORS / trusted-origin registry at startup.
|
|
*/
|
|
export async function getVerifiedCustomDomainHostnames(): Promise<string[]> {
|
|
try {
|
|
const rows = await db
|
|
.select({ customDomain: schema.organization.customDomain })
|
|
.from(schema.organization)
|
|
.where(and(eq(schema.organization.isCustomDomainVerified, true), isNotNull(schema.organization.customDomain)));
|
|
|
|
return [...new Set(rows.map((row) => row.customDomain?.trim().toLowerCase()).filter(Boolean) as string[])];
|
|
} catch (error) {
|
|
console.error('getVerifiedCustomDomainHostnames error:', error);
|
|
throw new Error(
|
|
`Failed to load verified custom domains: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
}
|
|
|
|
export const getOrganizationByProfileId = async (profileId: string): Promise<OrganizationWithMemberAndPlans[]> => {
|
|
const result = await db
|
|
.select({
|
|
organization: schema.organization,
|
|
memberId: schema.organizationmember.id,
|
|
roleId: schema.organizationmember.roleId,
|
|
plan: {
|
|
planName: schema.organizationPlan.planName,
|
|
isActive: schema.organizationPlan.isActive,
|
|
provider: schema.organizationPlan.provider,
|
|
subscriptionId: schema.organizationPlan.subscriptionId,
|
|
customerId: sql`organization_plan.payload->>'customerId'`.as('customerId')
|
|
}
|
|
})
|
|
.from(schema.organization)
|
|
.leftJoin(schema.organizationmember, eq(schema.organization.id, schema.organizationmember.organizationId))
|
|
.leftJoin(schema.organizationPlan, eq(schema.organization.id, schema.organizationPlan.orgId))
|
|
.where(eq(schema.organizationmember.profileId, profileId));
|
|
|
|
// Group by organization and collect plans into an array
|
|
const organizationMap = new Map<
|
|
string,
|
|
{
|
|
organization: typeof schema.organization.$inferSelect;
|
|
memberId: number | undefined;
|
|
roleId: number | undefined;
|
|
plans: Array<OrganizationPlan>;
|
|
}
|
|
>();
|
|
|
|
for (const row of result) {
|
|
const orgId = row.organization.id;
|
|
|
|
if (!organizationMap.has(orgId)) {
|
|
organizationMap.set(orgId, {
|
|
organization: row.organization,
|
|
memberId: row.memberId ?? undefined,
|
|
roleId: row.roleId ?? undefined,
|
|
plans: []
|
|
});
|
|
}
|
|
|
|
const orgData = organizationMap.get(orgId)!;
|
|
|
|
// Add plan to array if it exists (not null)
|
|
if (
|
|
row.plan &&
|
|
(row.plan.planName !== null ||
|
|
row.plan.isActive !== null ||
|
|
row.plan.provider !== null ||
|
|
row.plan.subscriptionId !== null)
|
|
) {
|
|
orgData.plans.push({
|
|
planName: row.plan.planName,
|
|
isActive: row.plan.isActive,
|
|
provider: row.plan.provider,
|
|
subscriptionId: row.plan.subscriptionId,
|
|
customerId: row.plan.customerId as string | null
|
|
});
|
|
}
|
|
}
|
|
|
|
return Array.from(organizationMap.values()).map(({ organization, ...rest }) => ({
|
|
...(organization as TOrganization),
|
|
...rest
|
|
}));
|
|
};
|
|
|
|
export const createOrganization = async (data: TNewOrganization, dbClient: DbOrTxClient = db) => {
|
|
const [organization] = await dbClient.insert(schema.organization).values(data).returning();
|
|
|
|
return organization;
|
|
};
|
|
|
|
export const createOrganizationMember = async (data: TNewOrganizationmember, dbClient: DbOrTxClient = db) => {
|
|
const [member] = await dbClient.insert(schema.organizationmember).values(data).returning();
|
|
|
|
return member;
|
|
};
|
|
|
|
export async function getOrganizationMemberByIdAndOrg(
|
|
memberId: number,
|
|
organizationId: string,
|
|
dbClient: DbOrTxClient = db
|
|
): Promise<{ id: number; profileId: string | null } | null> {
|
|
try {
|
|
const [row] = await dbClient
|
|
.select({
|
|
id: schema.organizationmember.id,
|
|
profileId: schema.organizationmember.profileId
|
|
})
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(eq(schema.organizationmember.id, memberId), eq(schema.organizationmember.organizationId, organizationId))
|
|
)
|
|
.limit(1);
|
|
|
|
return row ?? null;
|
|
} catch (error) {
|
|
console.error('getOrganizationMemberByIdAndOrg error:', error);
|
|
throw new Error(
|
|
`Failed to resolve organization membership: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
}
|
|
|
|
export async function getOrganizationMemberIdByOrgAndProfile(
|
|
organizationId: string,
|
|
profileId: string,
|
|
dbClient: DbOrTxClient = db
|
|
): Promise<number | null> {
|
|
try {
|
|
const [row] = await dbClient
|
|
.select({ id: schema.organizationmember.id })
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, organizationId),
|
|
eq(schema.organizationmember.profileId, profileId)
|
|
)
|
|
)
|
|
.limit(1);
|
|
|
|
return row?.id ?? null;
|
|
} catch (error) {
|
|
console.error('getOrganizationMemberIdByOrgAndProfile error:', error);
|
|
throw new Error(
|
|
`Failed to resolve organization membership: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates multiple organization members in a single query
|
|
* @param data Array of organization member creation data
|
|
* @returns Array of created members
|
|
*/
|
|
export const createOrganizationMembers = async (data: TNewOrganizationmember[]) => {
|
|
const members = await db.insert(schema.organizationmember).values(data).onConflictDoNothing().returning();
|
|
|
|
return members;
|
|
};
|
|
|
|
export async function insertOrganizationMembersOnConflictDoNothing(
|
|
data: TNewOrganizationmember[],
|
|
dbClient: DbOrTxClient = db
|
|
): Promise<void> {
|
|
if (data.length === 0) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await dbClient.insert(schema.organizationmember).values(data).onConflictDoNothing();
|
|
} catch (error) {
|
|
console.error('insertOrganizationMembersOnConflictDoNothing error:', error);
|
|
throw new Error(
|
|
`Failed to insert organization members: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
}
|
|
|
|
export const checkSiteNameExists = async (siteName: string, excludeOrgId?: string): Promise<boolean> => {
|
|
const conditions = [eq(schema.organization.siteName, siteName)];
|
|
|
|
if (excludeOrgId) {
|
|
conditions.push(ne(schema.organization.id, excludeOrgId));
|
|
}
|
|
|
|
const result = await db
|
|
.select({ id: schema.organization.id })
|
|
.from(schema.organization)
|
|
.where(and(...conditions))
|
|
.limit(1);
|
|
|
|
return result.length > 0;
|
|
};
|
|
|
|
/**
|
|
* Gets an organization by siteName
|
|
* @param siteName Organization site name
|
|
* @returns Organization or null if not found
|
|
*/
|
|
export const getOrganizationBySiteName = async (siteName: string): Promise<TOrganization | null> => {
|
|
const [organization] = await db
|
|
.select()
|
|
.from(schema.organization)
|
|
.where(eq(schema.organization.siteName, siteName))
|
|
.limit(1);
|
|
|
|
return organization || null;
|
|
};
|
|
|
|
/**
|
|
* Gets an organization by its verified custom domain.
|
|
* Only matches rows where isCustomDomainVerified is true so we never auto-enroll
|
|
* a signup into an org just because someone pointed DNS at us.
|
|
*/
|
|
export const getOrganizationByCustomDomain = async (customDomain: string): Promise<TOrganization | null> => {
|
|
const [organization] = await db
|
|
.select()
|
|
.from(schema.organization)
|
|
.where(
|
|
and(
|
|
eq(schema.organization.customDomain, customDomain.toLowerCase()),
|
|
eq(schema.organization.isCustomDomainVerified, true)
|
|
)
|
|
)
|
|
.limit(1);
|
|
|
|
return organization || null;
|
|
};
|
|
|
|
/**
|
|
* Gets an organization by ID
|
|
* @param id Organization ID
|
|
* @returns Organization or null if not found
|
|
*/
|
|
export const getOrganizationById = async (id: string): Promise<TOrganization | null> => {
|
|
const [organization] = await db.select().from(schema.organization).where(eq(schema.organization.id, id)).limit(1);
|
|
|
|
return organization || null;
|
|
};
|
|
|
|
export const deleteOrganizationById = async (id: string) => {
|
|
await db.delete(schema.organization).where(eq(schema.organization.id, id));
|
|
};
|
|
|
|
/**
|
|
* Checks if an email already exists as a team member in an organization
|
|
* @param orgId Organization ID
|
|
* @param email Email address to check
|
|
* @returns True if email exists, false otherwise
|
|
*/
|
|
export const checkEmailExistsInOrg = async (orgId: string, email: string): Promise<boolean> => {
|
|
const result = await db
|
|
.select({ id: schema.organizationmember.id })
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(eq(schema.organizationmember.organizationId, orgId), eq(schema.organizationmember.email, email.toLowerCase()))
|
|
)
|
|
.limit(1);
|
|
|
|
return result.length > 0;
|
|
};
|
|
|
|
/**
|
|
* Checks if an org has a member matching the given profileId or email.
|
|
* Used to avoid creating duplicate members (e.g. when user has a pending invite).
|
|
*/
|
|
export const hasOrgMemberByProfileIdOrEmail = async (
|
|
orgId: string,
|
|
profileId: string,
|
|
email: string | null | undefined
|
|
): Promise<boolean> => {
|
|
const conditions = [eq(schema.organizationmember.organizationId, orgId)];
|
|
|
|
const profileOrEmailMatch = or(
|
|
eq(schema.organizationmember.profileId, profileId),
|
|
...(email ? [eq(schema.organizationmember.email, email.toLowerCase().trim())] : [])
|
|
);
|
|
|
|
const result = await db
|
|
.select({ id: schema.organizationmember.id })
|
|
.from(schema.organizationmember)
|
|
.where(and(...conditions, profileOrEmailMatch))
|
|
.limit(1);
|
|
|
|
return result.length > 0;
|
|
};
|
|
|
|
/**
|
|
* Checks which emails already exist as team members in an organization (bulk check)
|
|
* Checks both organizationmember.email and profile.email (via organizationmember.profileId)
|
|
* @param orgId Organization ID
|
|
* @param emails Array of email addresses to check (should already be normalized)
|
|
* @returns Array of emails that already exist in the organization
|
|
*/
|
|
export const checkEmailsExistInOrg = async (orgId: string, emails: string[]): Promise<string[]> => {
|
|
if (emails.length === 0) {
|
|
return [];
|
|
}
|
|
|
|
const [orgMemberEmails, profileEmails] = await Promise.all([
|
|
db
|
|
.select({ email: schema.organizationmember.email })
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(eq(schema.organizationmember.organizationId, orgId), inArray(schema.organizationmember.email, emails))
|
|
),
|
|
db
|
|
.select({ email: schema.profile.email })
|
|
.from(schema.organizationmember)
|
|
.innerJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(and(eq(schema.organizationmember.organizationId, orgId), inArray(schema.profile.email, emails)))
|
|
]);
|
|
|
|
const existingEmails = new Set<string>();
|
|
orgMemberEmails.forEach((r) => {
|
|
if (r.email) {
|
|
existingEmails.add(r.email.toLowerCase());
|
|
}
|
|
});
|
|
profileEmails.forEach((r) => {
|
|
if (r.email) {
|
|
existingEmails.add(r.email.toLowerCase());
|
|
}
|
|
});
|
|
|
|
return Array.from(existingEmails);
|
|
};
|
|
|
|
/**
|
|
* Deletes an organization member by ID
|
|
* @param orgId Organization ID
|
|
* @param memberId Member ID to delete
|
|
* @returns Deleted member or null if not found
|
|
*/
|
|
export const deleteOrganizationMember = async (orgId: string, memberId: number) => {
|
|
const [deleted] = await db
|
|
.delete(schema.organizationmember)
|
|
.where(and(eq(schema.organizationmember.organizationId, orgId), eq(schema.organizationmember.id, memberId)))
|
|
.returning();
|
|
|
|
return deleted || null;
|
|
};
|
|
|
|
/**
|
|
* Deletes a student organization member by ID
|
|
* @param orgId Organization ID
|
|
* @param memberId Member ID to delete
|
|
* @returns Deleted member or null if not found
|
|
*/
|
|
export const deleteOrganizationAudienceMember = async (orgId: string, memberId: number) => {
|
|
const [deleted] = await db
|
|
.delete(schema.organizationmember)
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.id, memberId),
|
|
eq(schema.organizationmember.roleId, ROLE.STUDENT)
|
|
)
|
|
)
|
|
.returning();
|
|
|
|
return deleted || null;
|
|
};
|
|
|
|
export const getOrganizationAudienceMember = async (orgId: string, memberId: number) => {
|
|
const [row] = await db
|
|
.select({
|
|
memberId: schema.organizationmember.id,
|
|
profileId: schema.organizationmember.profileId,
|
|
fullname: schema.profile.fullname,
|
|
email: sql<string>`coalesce(${schema.profile.email}, ${schema.organizationmember.email})`.as('email'),
|
|
avatarUrl: schema.profile.avatarUrl,
|
|
profileCreatedAt: schema.profile.createdAt,
|
|
memberCreatedAt: schema.organizationmember.createdAt
|
|
})
|
|
.from(schema.organizationmember)
|
|
.leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.id, memberId),
|
|
eq(schema.organizationmember.roleId, ROLE.STUDENT)
|
|
)
|
|
)
|
|
.limit(1);
|
|
|
|
if (!row) {
|
|
return null;
|
|
}
|
|
|
|
const email = row.email?.trim() ?? '';
|
|
const name = row.fullname?.trim() || (email.includes('@') ? email.split('@')[0] : email) || '';
|
|
const createdAtRaw = row.profileId ? row.profileCreatedAt : row.memberCreatedAt;
|
|
const createdAt = createdAtRaw ? new Date(createdAtRaw).toDateString() : '';
|
|
|
|
return {
|
|
id: row.memberId,
|
|
profileId: row.profileId ?? null,
|
|
name,
|
|
email,
|
|
avatarUrl: row.avatarUrl || '',
|
|
createdAt
|
|
};
|
|
};
|
|
|
|
export const updateOrganizationAudienceMember = async (
|
|
orgId: string,
|
|
memberId: number,
|
|
data: Partial<Pick<TNewOrganizationmember, 'email' | 'verified'>>
|
|
) => {
|
|
const [updated] = await db
|
|
.update(schema.organizationmember)
|
|
.set(data)
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.id, memberId),
|
|
eq(schema.organizationmember.roleId, ROLE.STUDENT)
|
|
)
|
|
)
|
|
.returning();
|
|
|
|
return updated || null;
|
|
};
|
|
|
|
/**
|
|
* Checks if a user is an admin of an organization
|
|
* @param orgId Organization ID
|
|
* @param profileId Profile ID to check
|
|
* @returns True if user is admin, false otherwise
|
|
*/
|
|
export const isUserOrgAdmin = async (orgId: string, profileId: string): Promise<boolean> => {
|
|
const result = await db
|
|
.select({ roleId: schema.organizationmember.roleId })
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.profileId, profileId),
|
|
eq(schema.organizationmember.roleId, ROLE.ADMIN)
|
|
)
|
|
)
|
|
.limit(1);
|
|
|
|
return result.length > 0;
|
|
};
|
|
|
|
/**
|
|
* Gets a user's role in an organization
|
|
* @param orgId Organization ID
|
|
* @param profileId Profile ID to check
|
|
* @returns Role ID if user is a member, null otherwise
|
|
*/
|
|
export const getUserOrgRole = async (orgId: string, profileId: string): Promise<number | null> => {
|
|
const result = await db
|
|
.select({ roleId: schema.organizationmember.roleId })
|
|
.from(schema.organizationmember)
|
|
.where(and(eq(schema.organizationmember.organizationId, orgId), eq(schema.organizationmember.profileId, profileId)))
|
|
.limit(1);
|
|
|
|
return result.length > 0 ? Number(result[0].roleId) : null;
|
|
};
|
|
|
|
/**
|
|
* Gets all org memberships for a user as { [orgId]: roleId }.
|
|
* Used to attach org roles to the Better Auth session so middleware can
|
|
* read membership/role from the session cookie cache instead of hitting the DB.
|
|
*/
|
|
export const getUserOrgRolesMap = async (profileId: string): Promise<Record<string, number>> => {
|
|
try {
|
|
const rows = await db
|
|
.select({
|
|
organizationId: schema.organizationmember.organizationId,
|
|
roleId: schema.organizationmember.roleId
|
|
})
|
|
.from(schema.organizationmember)
|
|
.where(eq(schema.organizationmember.profileId, profileId));
|
|
|
|
const map: Record<string, number> = {};
|
|
for (const row of rows) {
|
|
map[row.organizationId] = Number(row.roleId);
|
|
}
|
|
|
|
return map;
|
|
} catch (error) {
|
|
console.error('getUserOrgRolesMap error:', error);
|
|
throw new Error('Failed to fetch user org roles map');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Checks if a user is a team member (ADMIN or TUTOR) of an organization
|
|
* @param orgId Organization ID
|
|
* @param profileId Profile ID to check
|
|
* @returns True if user is ADMIN or TUTOR, false otherwise
|
|
*/
|
|
export const isUserOrgTeamMember = async (orgId: string, profileId: string): Promise<boolean> => {
|
|
const result = await db
|
|
.select({ roleId: schema.organizationmember.roleId })
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.profileId, profileId),
|
|
or(eq(schema.organizationmember.roleId, ROLE.ADMIN), eq(schema.organizationmember.roleId, ROLE.TUTOR))
|
|
)
|
|
)
|
|
.limit(1);
|
|
|
|
return result.length > 0;
|
|
};
|
|
|
|
/**
|
|
* Gets organization team members (non-students)
|
|
* @param orgId Organization ID
|
|
* @returns Array of team members with profile information
|
|
*/
|
|
export const getOrganizationTeam = async (orgId: string) => {
|
|
const result = await db
|
|
.select({
|
|
id: schema.organizationmember.id,
|
|
email: schema.organizationmember.email,
|
|
verified: schema.organizationmember.verified,
|
|
roleId: schema.organizationmember.roleId,
|
|
profile: {
|
|
id: schema.profile.id,
|
|
fullname: schema.profile.fullname,
|
|
email: schema.profile.email
|
|
}
|
|
})
|
|
.from(schema.organizationmember)
|
|
.leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
sql`${schema.organizationmember.roleId} != ${ROLE.STUDENT}`
|
|
)
|
|
)
|
|
.orderBy(sql`${schema.organizationmember.id} DESC`);
|
|
|
|
return result.map((member) => ({
|
|
id: member.id,
|
|
email: member.profile?.email || member.email || '',
|
|
verified: member.verified,
|
|
roleId: member.roleId,
|
|
profileId: member.profile?.id,
|
|
fullname: member.profile?.fullname || ''
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Counts active organization members with the student role. Used to enforce per-plan student caps.
|
|
*/
|
|
export async function countActiveStudents(orgId: string): Promise<number> {
|
|
try {
|
|
const [row] = await db
|
|
.select({ count: count(schema.organizationmember.id) })
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(eq(schema.organizationmember.organizationId, orgId), eq(schema.organizationmember.roleId, ROLE.STUDENT))
|
|
);
|
|
|
|
return Number(row?.count ?? 0);
|
|
} catch (error) {
|
|
console.error('countActiveStudents error:', error);
|
|
throw new Error('Failed to count active students');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets verified admin emails for an organization. Used to notify admins about plan-limit events.
|
|
*/
|
|
export async function getOrganizationAdminEmails(orgId: string): Promise<Array<{ email: string; fullname: string }>> {
|
|
try {
|
|
const result = await db
|
|
.select({
|
|
email: schema.organizationmember.email,
|
|
profileEmail: schema.profile.email,
|
|
fullname: schema.profile.fullname
|
|
})
|
|
.from(schema.organizationmember)
|
|
.leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.roleId, ROLE.ADMIN),
|
|
eq(schema.organizationmember.verified, true)
|
|
)
|
|
);
|
|
|
|
return result
|
|
.map((member) => ({
|
|
email: member.profileEmail || member.email || '',
|
|
fullname: member.fullname || ''
|
|
}))
|
|
.filter((member) => member.email);
|
|
} catch (error) {
|
|
console.error('getOrganizationAdminEmails error:', error);
|
|
throw new Error('Failed to get organization admin emails');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets organization audience (all organization members with student role).
|
|
* Includes invited members without a profile (LEFT JOIN profile).
|
|
* Row id is organizationmember.id; use profileId for profile-backed actions when present.
|
|
*/
|
|
type GetOrganizationAudienceOptions = {
|
|
page?: number;
|
|
limit?: number;
|
|
search?: string;
|
|
sortBy?: TAudienceSortBy;
|
|
sortOrder?: TAudienceSortOrder;
|
|
};
|
|
|
|
export const getOrganizationAudience = async (orgId: string, options: GetOrganizationAudienceOptions = {}) => {
|
|
const page = options.page && options.page > 0 ? options.page : 1;
|
|
const limit = options.limit && options.limit > 0 ? Math.min(options.limit, 100) : 20;
|
|
const offset = (page - 1) * limit;
|
|
const search = options.search?.trim();
|
|
const sortBy = options.sortBy ?? 'createdAt';
|
|
const sortOrder = options.sortOrder ?? 'desc';
|
|
|
|
const audienceNameSql = sql<string>`COALESCE(NULLIF(${schema.profile.fullname}, ''), ${schema.profile.email}, ${schema.organizationmember.email})`;
|
|
const audienceEmailSql = sql<string>`COALESCE(${schema.profile.email}, ${schema.organizationmember.email})`;
|
|
const audienceCreatedAtSql = sql<string>`COALESCE(${schema.profile.createdAt}, ${schema.organizationmember.createdAt})`;
|
|
|
|
const conditions = [
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.roleId, ROLE.STUDENT)
|
|
];
|
|
|
|
if (search) {
|
|
const searchValue = `%${search}%`;
|
|
conditions.push(
|
|
or(
|
|
ilike(schema.profile.fullname, searchValue),
|
|
ilike(schema.profile.email, searchValue),
|
|
ilike(schema.organizationmember.email, searchValue)
|
|
)!
|
|
);
|
|
}
|
|
|
|
const whereClause = and(...conditions);
|
|
const [totalRow] = await db
|
|
.select({ count: count(schema.organizationmember.id) })
|
|
.from(schema.organizationmember)
|
|
.leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(whereClause);
|
|
|
|
const total = Number(totalRow?.count ?? 0);
|
|
|
|
const orderByExpression =
|
|
sortBy === 'name' ? audienceNameSql : sortBy === 'email' ? audienceEmailSql : audienceCreatedAtSql;
|
|
const orderedExpression = sortOrder === 'asc' ? asc(orderByExpression) : desc(orderByExpression);
|
|
|
|
const result = await db
|
|
.select({
|
|
memberId: schema.organizationmember.id,
|
|
profileId: schema.profile.id,
|
|
fullname: schema.profile.fullname,
|
|
email: audienceEmailSql.as('email'),
|
|
avatarUrl: schema.profile.avatarUrl,
|
|
profileCreatedAt: schema.profile.createdAt,
|
|
memberCreatedAt: schema.organizationmember.createdAt
|
|
})
|
|
.from(schema.organizationmember)
|
|
.leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(whereClause)
|
|
.orderBy(orderedExpression, desc(schema.organizationmember.id))
|
|
.limit(limit)
|
|
.offset(offset);
|
|
|
|
return {
|
|
items: result.map((row) => {
|
|
const email = row.email?.trim() ?? '';
|
|
const name = row.fullname?.trim() || (email.includes('@') ? email.split('@')[0] : email) || '';
|
|
const createdAtRaw = row.profileId ? row.profileCreatedAt : row.memberCreatedAt;
|
|
const createdAt = createdAtRaw ? new Date(createdAtRaw).toDateString() : '';
|
|
|
|
return {
|
|
id: row.memberId,
|
|
profileId: row.profileId ?? null,
|
|
name,
|
|
email,
|
|
avatarUrl: row.avatarUrl || '',
|
|
createdAt
|
|
};
|
|
}),
|
|
page,
|
|
limit,
|
|
total,
|
|
totalPages: Math.max(1, Math.ceil(total / limit))
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Student org member matched by profile email or organizationmember.email (for audience invite actions).
|
|
*/
|
|
export async function getStudentOrganizationMemberByOrgAndEmail(
|
|
orgId: string,
|
|
email: string
|
|
): Promise<{ id: number; profileId: string | null; email: string } | null> {
|
|
const normalized = email.toLowerCase().trim();
|
|
if (!normalized) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const [row] = await db
|
|
.select({
|
|
id: schema.organizationmember.id,
|
|
profileId: schema.organizationmember.profileId,
|
|
displayEmail: sql<string>`COALESCE(${schema.profile.email}, ${schema.organizationmember.email})`.as(
|
|
'displayEmail'
|
|
)
|
|
})
|
|
.from(schema.organizationmember)
|
|
.leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
eq(schema.organizationmember.roleId, ROLE.STUDENT),
|
|
or(eq(schema.organizationmember.email, normalized), eq(schema.profile.email, normalized))
|
|
)
|
|
)
|
|
.limit(1);
|
|
|
|
if (!row) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
id: row.id,
|
|
profileId: row.profileId,
|
|
email: (row.displayEmail ?? normalized).trim()
|
|
};
|
|
} catch (error) {
|
|
console.error('getStudentOrganizationMemberByOrgAndEmail error:', error);
|
|
throw new Error(
|
|
`Failed to get organization student member: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets organizations with optional filters
|
|
* @param filters Filter options (siteName, customDomain, isCustomDomainVerified)
|
|
* @returns Array of organizations with plans
|
|
*/
|
|
export const getOrganizations = async (filters?: {
|
|
siteName?: string;
|
|
customDomain?: string;
|
|
isCustomDomainVerified?: boolean;
|
|
}): Promise<OrganizationWithPlans[]> => {
|
|
const conditions: Parameters<typeof and>[0][] = [];
|
|
|
|
if (filters?.siteName) {
|
|
conditions.push(eq(schema.organization.siteName, filters.siteName));
|
|
}
|
|
|
|
if (filters?.customDomain) {
|
|
const customDomainConditions: Parameters<typeof and>[0][] = [
|
|
eq(schema.organization.customDomain, filters.customDomain)
|
|
];
|
|
if (filters.isCustomDomainVerified !== undefined) {
|
|
customDomainConditions.push(eq(schema.organization.isCustomDomainVerified, filters.isCustomDomainVerified));
|
|
}
|
|
conditions.push(and(...customDomainConditions));
|
|
}
|
|
|
|
const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
|
|
|
|
const result = await db
|
|
.select({
|
|
organization: schema.organization,
|
|
plan: {
|
|
planName: schema.organizationPlan.planName,
|
|
isActive: schema.organizationPlan.isActive,
|
|
provider: schema.organizationPlan.provider,
|
|
subscriptionId: schema.organizationPlan.subscriptionId,
|
|
customerId: sql`organization_plan.payload->>'customerId'`.as('customerId')
|
|
}
|
|
})
|
|
.from(schema.organization)
|
|
.leftJoin(schema.organizationPlan, eq(schema.organization.id, schema.organizationPlan.orgId))
|
|
.where(whereClause);
|
|
|
|
// Group by organization and collect plans into an array
|
|
const organizationMap = new Map<
|
|
string,
|
|
{
|
|
organization: typeof schema.organization.$inferSelect;
|
|
plans: Array<OrganizationPlan>;
|
|
}
|
|
>();
|
|
|
|
for (const row of result) {
|
|
const orgId = row.organization.id;
|
|
|
|
if (!organizationMap.has(orgId)) {
|
|
organizationMap.set(orgId, {
|
|
organization: row.organization,
|
|
plans: []
|
|
});
|
|
}
|
|
|
|
const orgData = organizationMap.get(orgId)!;
|
|
|
|
// Add plan to array if it exists (not null)
|
|
if (
|
|
row.plan &&
|
|
(row.plan.planName !== null ||
|
|
row.plan.isActive !== null ||
|
|
row.plan.provider !== null ||
|
|
row.plan.subscriptionId !== null)
|
|
) {
|
|
orgData.plans.push({
|
|
planName: row.plan.planName,
|
|
isActive: row.plan.isActive,
|
|
provider: row.plan.provider,
|
|
subscriptionId: row.plan.subscriptionId,
|
|
customerId: row.plan.customerId as string | null
|
|
});
|
|
}
|
|
}
|
|
|
|
return Array.from(organizationMap.values()).map(({ organization, plans }) => ({
|
|
...(organization as TOrganization),
|
|
plans
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Gets free (BASIC) plan organizations whose active student count exceeds
|
|
* `limit`, in a single query. Free = no active paid plan. Used by maintenance
|
|
* jobs so they don't load every org (or every org's count) and filter in memory.
|
|
*/
|
|
export const getFreePlanOrganizationsOverStudentLimit = async (
|
|
limit: number
|
|
): Promise<Array<TOrganization & { studentCount: number }>> => {
|
|
try {
|
|
const paidPlans = [PLAN.EARLY_ADOPTER, PLAN.ENTERPRISE] as ('EARLY_ADOPTER' | 'ENTERPRISE')[];
|
|
const paidOrgIds = db
|
|
.select({ orgId: schema.organizationPlan.orgId })
|
|
.from(schema.organizationPlan)
|
|
.where(and(eq(schema.organizationPlan.isActive, true), inArray(schema.organizationPlan.planName, paidPlans)));
|
|
|
|
const studentCount = count(schema.organizationmember.id);
|
|
const rows = await db
|
|
.select({ organization: schema.organization, studentCount })
|
|
.from(schema.organization)
|
|
.innerJoin(
|
|
schema.organizationmember,
|
|
and(
|
|
eq(schema.organizationmember.organizationId, schema.organization.id),
|
|
eq(schema.organizationmember.roleId, ROLE.STUDENT)
|
|
)
|
|
)
|
|
.where(notInArray(schema.organization.id, paidOrgIds))
|
|
.groupBy(schema.organization.id)
|
|
.having(gt(studentCount, limit));
|
|
|
|
return rows.map((row) => ({ ...(row.organization as TOrganization), studentCount: Number(row.studentCount) }));
|
|
} catch (error) {
|
|
console.error('getFreePlanOrganizationsOverStudentLimit error:', error);
|
|
throw new Error('Failed to load free-plan organizations over the student limit');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Gets the first (and typically only) organization - used for self-hosted single-org mode
|
|
* @returns First organization by createdAt, or null if none exist
|
|
*/
|
|
export const getFirstOrganization = async (): Promise<TOrganization | null> => {
|
|
const [organization] = await db.select().from(schema.organization).orderBy(schema.organization.createdAt).limit(1);
|
|
|
|
return organization || null;
|
|
};
|
|
|
|
/**
|
|
* Gets the first organization with plans - for self-hosted single-org mode
|
|
* @returns First organization with plans (by createdAt), or null if none exist
|
|
*/
|
|
export const getFirstOrganizationWithPlans = async (): Promise<
|
|
(TOrganization & { plans: Array<OrganizationPlan> }) | null
|
|
> => {
|
|
// Get the first organization ID (by createdAt) - avoid limit(1) on joined result
|
|
// which would discard plan rows when an org has multiple plans
|
|
const [firstOrg] = await db
|
|
.select({ id: schema.organization.id })
|
|
.from(schema.organization)
|
|
.orderBy(schema.organization.createdAt)
|
|
.limit(1);
|
|
|
|
if (!firstOrg) return null;
|
|
|
|
const result = await db
|
|
.select({
|
|
organization: schema.organization,
|
|
plan: {
|
|
planName: schema.organizationPlan.planName,
|
|
isActive: schema.organizationPlan.isActive,
|
|
provider: schema.organizationPlan.provider,
|
|
subscriptionId: schema.organizationPlan.subscriptionId,
|
|
customerId: sql`organization_plan.payload->>'customerId'`.as('customerId')
|
|
}
|
|
})
|
|
.from(schema.organization)
|
|
.leftJoin(schema.organizationPlan, eq(schema.organization.id, schema.organizationPlan.orgId))
|
|
.where(eq(schema.organization.id, firstOrg.id));
|
|
|
|
const organizationMap = new Map<
|
|
string,
|
|
{
|
|
organization: typeof schema.organization.$inferSelect;
|
|
plans: Array<OrganizationPlan>;
|
|
}
|
|
>();
|
|
|
|
for (const row of result) {
|
|
const orgId = row.organization.id;
|
|
if (!organizationMap.has(orgId)) {
|
|
organizationMap.set(orgId, {
|
|
organization: row.organization,
|
|
plans: []
|
|
});
|
|
}
|
|
const orgData = organizationMap.get(orgId)!;
|
|
if (
|
|
row.plan &&
|
|
(row.plan.planName !== null ||
|
|
row.plan.isActive !== null ||
|
|
row.plan.provider !== null ||
|
|
row.plan.subscriptionId !== null)
|
|
) {
|
|
orgData.plans.push({
|
|
planName: row.plan.planName,
|
|
isActive: row.plan.isActive,
|
|
provider: row.plan.provider,
|
|
subscriptionId: row.plan.subscriptionId,
|
|
customerId: row.plan.customerId as string | null
|
|
});
|
|
}
|
|
}
|
|
|
|
const first = Array.from(organizationMap.values())[0];
|
|
return first
|
|
? ({
|
|
...(first.organization as TOrganization),
|
|
plans: first.plans
|
|
} as TOrganization & { plans: Array<OrganizationPlan> })
|
|
: null;
|
|
};
|
|
|
|
/**
|
|
* Gets the number of organizations - used for self-hosted to block org creation when org exists
|
|
* @returns Count of organizations
|
|
*/
|
|
export const getOrganizationCount = async (): Promise<number> => {
|
|
const [result] = await db.select({ count: sql<number>`count(*)::int`.as('count') }).from(schema.organization);
|
|
|
|
return result?.count ?? 0;
|
|
};
|
|
|
|
/**
|
|
* Creates a new organization plan
|
|
* @param data Organization plan creation data
|
|
* @param dbClient Optional DB or transaction client for use within transactions
|
|
* @returns Created organization plan record
|
|
*/
|
|
export const getOrganizationPlanBySubscriptionId = async (
|
|
subscriptionId: string,
|
|
dbClient: DbOrTxClient = db
|
|
): Promise<TOrganizationPlan | null> => {
|
|
try {
|
|
const [plan] = await dbClient
|
|
.select()
|
|
.from(schema.organizationPlan)
|
|
.where(eq(schema.organizationPlan.subscriptionId, subscriptionId))
|
|
.limit(1);
|
|
|
|
return plan ?? null;
|
|
} catch (error) {
|
|
console.error('getOrganizationPlanBySubscriptionId error:', error);
|
|
throw new Error(`Failed to fetch organization plan: ${error instanceof Error ? error.message : 'Unknown error'}`);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Gets every active organization plan that has a Polar subscription ID attached.
|
|
* Used by one-off backfills that need to re-verify subscription status against Polar.
|
|
* @param dbClient Optional DB or transaction client for use within transactions
|
|
* @returns Active organization plans with org name/siteName for readable logging
|
|
*/
|
|
export const getActiveOrganizationPlansWithSubscription = async (
|
|
dbClient: DbOrTxClient = db
|
|
): Promise<Array<TOrganizationPlan & { orgName: string; orgSiteName: string | null }>> => {
|
|
try {
|
|
return await dbClient
|
|
.select({
|
|
...getTableColumns(schema.organizationPlan),
|
|
orgName: schema.organization.name,
|
|
orgSiteName: schema.organization.siteName
|
|
})
|
|
.from(schema.organizationPlan)
|
|
.innerJoin(schema.organization, eq(schema.organization.id, schema.organizationPlan.orgId))
|
|
.where(and(eq(schema.organizationPlan.isActive, true), isNotNull(schema.organizationPlan.subscriptionId)));
|
|
} catch (error) {
|
|
console.error('getActiveOrganizationPlansWithSubscription error:', error);
|
|
throw new Error(
|
|
`Failed to fetch active organization plans: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
};
|
|
|
|
export const createOrganizationPlan = async (
|
|
data: TNewOrganizationPlan,
|
|
dbClient: DbOrTxClient = db
|
|
): Promise<TOrganizationPlan> => {
|
|
const [plan] = await dbClient.insert(schema.organizationPlan).values(data).returning();
|
|
return plan;
|
|
};
|
|
|
|
/**
|
|
* Updates an organization plan by subscription ID
|
|
* @param subscriptionId Subscription ID
|
|
* @param payload Payload data to update
|
|
* @returns Updated organization plan record
|
|
*/
|
|
export const updateOrganizationPlan = async (
|
|
subscriptionId: string,
|
|
payload: TOrganizationPlan['payload']
|
|
): Promise<TOrganizationPlan> => {
|
|
const [plan] = await db
|
|
.update(schema.organizationPlan)
|
|
.set({ payload, updatedAt: sql`timezone('utc'::text, now())` })
|
|
.where(eq(schema.organizationPlan.subscriptionId, subscriptionId))
|
|
.returning();
|
|
return plan;
|
|
};
|
|
|
|
/**
|
|
* Cancels an organization plan by subscription ID
|
|
* @param subscriptionId Subscription ID
|
|
* @param payload Payload data to update
|
|
* @returns Updated organization plan record
|
|
*/
|
|
export const cancelOrganizationPlan = async (
|
|
subscriptionId: string,
|
|
payload: TOrganizationPlan['payload']
|
|
): Promise<TOrganizationPlan> => {
|
|
const [plan] = await db
|
|
.update(schema.organizationPlan)
|
|
.set({
|
|
isActive: false,
|
|
deactivatedAt: sql`timezone('utc'::text, now())`,
|
|
payload,
|
|
updatedAt: sql`timezone('utc'::text, now())`
|
|
})
|
|
.where(eq(schema.organizationPlan.subscriptionId, subscriptionId))
|
|
.returning();
|
|
|
|
return plan;
|
|
};
|
|
|
|
/**
|
|
* Updates an organization
|
|
* @param id Organization ID
|
|
* @param data Partial organization data to update. When `settings` is provided, it is deep-merged with existing settings.
|
|
* @returns Updated organization record
|
|
*/
|
|
export const updateOrganization = async (id: string, data: Partial<TOrganization>): Promise<TOrganization> => {
|
|
let setData = { ...data };
|
|
|
|
if (data.settings !== undefined) {
|
|
const [existing] = await db
|
|
.select({ settings: schema.organization.settings })
|
|
.from(schema.organization)
|
|
.where(eq(schema.organization.id, id))
|
|
.limit(1);
|
|
|
|
const existingSettings = (existing?.settings as Record<string, unknown>) ?? {};
|
|
const newSettings = data.settings as Record<string, unknown>;
|
|
const mergedSettings: Record<string, unknown> = { ...existingSettings };
|
|
for (const key of Object.keys(newSettings ?? {})) {
|
|
const existingVal = existingSettings[key];
|
|
const newVal = newSettings[key];
|
|
if (newVal !== undefined) {
|
|
if (
|
|
existingVal &&
|
|
typeof existingVal === 'object' &&
|
|
!Array.isArray(existingVal) &&
|
|
newVal &&
|
|
typeof newVal === 'object' &&
|
|
!Array.isArray(newVal)
|
|
) {
|
|
mergedSettings[key] = { ...(existingVal as Record<string, unknown>), ...(newVal as Record<string, unknown>) };
|
|
} else {
|
|
mergedSettings[key] = newVal;
|
|
}
|
|
}
|
|
}
|
|
setData = { ...setData, settings: mergedSettings as TOrganization['settings'] };
|
|
}
|
|
|
|
const [organization] = await db
|
|
.update(schema.organization)
|
|
.set(setData)
|
|
.where(eq(schema.organization.id, id))
|
|
.returning();
|
|
|
|
return organization;
|
|
};
|
|
|
|
/**
|
|
* Get organization plan status for SSO entitlement check
|
|
* @param orgId Organization ID
|
|
* @returns Array of plan records
|
|
*/
|
|
export const getOrganizationPlanStatus = async (orgId: string) => {
|
|
const result = await db
|
|
.select({
|
|
planName: schema.organizationPlan.planName,
|
|
isActive: schema.organizationPlan.isActive
|
|
})
|
|
.from(schema.organizationPlan)
|
|
.where(eq(schema.organizationPlan.orgId, orgId));
|
|
|
|
return result;
|
|
};
|
|
|
|
export const getActiveOrganizationPlan = async (orgId: string) => {
|
|
const [plan] = await db
|
|
.select()
|
|
.from(schema.organizationPlan)
|
|
.where(and(eq(schema.organizationPlan.orgId, orgId), eq(schema.organizationPlan.isActive, true)))
|
|
.limit(1);
|
|
|
|
if (plan) return plan;
|
|
|
|
// Secondary workspaces inherit their primary's plan.
|
|
const [org] = await db
|
|
.select({ parentOrganizationId: schema.organization.parentOrganizationId })
|
|
.from(schema.organization)
|
|
.where(eq(schema.organization.id, orgId))
|
|
.limit(1);
|
|
|
|
if (!org?.parentOrganizationId) return null;
|
|
|
|
const [parentPlan] = await db
|
|
.select()
|
|
.from(schema.organizationPlan)
|
|
.where(and(eq(schema.organizationPlan.orgId, org.parentOrganizationId), eq(schema.organizationPlan.isActive, true)))
|
|
.limit(1);
|
|
|
|
return parentPlan ?? null;
|
|
};
|
|
|
|
/**
|
|
* Gets organization members by profile IDs
|
|
* @param orgId Organization ID
|
|
* @param profileIds Array of profile IDs to look up
|
|
* @returns Array of { profileId, email } for matching members
|
|
*/
|
|
export async function getOrgMembersByProfileIds(orgId: string, profileIds: string[]) {
|
|
try {
|
|
if (profileIds.length === 0) return [];
|
|
|
|
return db
|
|
.select({
|
|
profileId: schema.organizationmember.profileId,
|
|
email: schema.organizationmember.email,
|
|
roleId: schema.organizationmember.roleId
|
|
})
|
|
.from(schema.organizationmember)
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
inArray(schema.organizationmember.profileId, profileIds)
|
|
)
|
|
);
|
|
} catch (error) {
|
|
console.error('getOrgMembersByProfileIds error:', error);
|
|
throw new Error(
|
|
`Failed to get org members by profile IDs: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
}
|
|
|
|
export type TOrganizationMemberByEmail = {
|
|
normalizedEmail: string;
|
|
profileId: string | null;
|
|
roleId: number;
|
|
};
|
|
|
|
/**
|
|
* Resolves organization members matching normalized emails (profile email or organizationmember.email).
|
|
*/
|
|
export async function getOrganizationMembersByNormalizedEmails(
|
|
orgId: string,
|
|
emails: string[]
|
|
): Promise<TOrganizationMemberByEmail[]> {
|
|
try {
|
|
if (emails.length === 0) return [];
|
|
|
|
const normalized = [...new Set(emails.map((e) => e.toLowerCase().trim()).filter(Boolean))];
|
|
|
|
const rows = await db
|
|
.select({
|
|
roleId: schema.organizationmember.roleId,
|
|
profileId: schema.organizationmember.profileId,
|
|
matchEmail: sql<string>`lower(trim(coalesce(${schema.profile.email}, ${schema.organizationmember.email})))`.as(
|
|
'matchEmail'
|
|
)
|
|
})
|
|
.from(schema.organizationmember)
|
|
.leftJoin(schema.profile, eq(schema.organizationmember.profileId, schema.profile.id))
|
|
.where(
|
|
and(
|
|
eq(schema.organizationmember.organizationId, orgId),
|
|
inArray(sql`lower(trim(coalesce(${schema.profile.email}, ${schema.organizationmember.email})))`, normalized)
|
|
)
|
|
);
|
|
|
|
return rows.map((row) => ({
|
|
normalizedEmail: row.matchEmail,
|
|
profileId: row.profileId,
|
|
roleId: row.roleId
|
|
}));
|
|
} catch (error) {
|
|
console.error('getOrganizationMembersByNormalizedEmails error:', error);
|
|
throw new Error(
|
|
`Failed to get organization members by emails: ${error instanceof Error ? error.message : 'Unknown error'}`
|
|
);
|
|
}
|
|
}
|