devpush 0.0.0-stage → 1.0.0-beta.4

package/src/server/teams/functions.ts

@@ -0,0 +1,324 @@
+import { listBackupStorage } from '#devpush/server/backups/storage'
+import {
+  getAuthSession,
+  requireAuthSession,
+} from '#devpush/server/auth/session.server'
+import { getAgentBinaryStatus } from '#devpush/server/install/agent-binary'
+import { listTeamDeployments } from '#devpush/server/projects/context'
+import {
+  getUserContext,
+  getTeamDeletionStatus,
+  requireTeam,
+  acceptTeamInvite,
+  acceptUserTeamInvite,
+  declineUserTeamInvite,
+  declineTeamInvite,
+  createTeam,
+  createTeamInvites,
+  deleteTeam,
+  removeTeamMember,
+  resendTeamInvite,
+  revokeTeamInvite,
+  transferTeamOwnership,
+  updateTeamGeneral,
+  updateTeamMemberRole,
+} from '#devpush/server/teams/service'
+import {
+  listTeamInvites,
+  listTeamMembers,
+  listTeamProjects,
+  listTeamServers,
+} from '#devpush/server/teams/queries'
+import { teamContextSectionSchema } from '#devpush/lib/team-context-schema'
+import { PublicError } from '#devpush/lib/public-error'
+import { publicErrorsMiddleware } from '#devpush/server/http/public-errors'
+import {
+  createTeamSchema,
+  bulkInviteSchema,
+  parseInviteEmails,
+} from '#devpush/lib/team-forms-schema'
+import { createServerFn } from '@tanstack/react-start'
+import { z } from 'zod'
+
+import {
+  teamGeneralSchema,
+  teamSettingsErrors,
+} from '#devpush/lib/team-settings-schema'
+import { formErrors } from '#devpush/lib/form-errors'
+
+const teamRouteSchema = z.object({
+  teamSlug: z.string().min(1),
+})
+
+const deleteTeamSchema = teamRouteSchema.extend({
+  confirmationName: z.string().trim().min(1),
+})
+
+const inviteIdSchema = teamRouteSchema.extend({
+  inviteId: z.string().min(1),
+})
+
+const userInviteIdSchema = z.object({
+  inviteId: z.string().min(1),
+})
+
+const memberRoleSchema = teamRouteSchema.extend({
+  memberUserId: z.string().min(1),
+  role: z.enum(['owner', 'admin', 'member']),
+})
+
+const memberSchema = teamRouteSchema.extend({
+  memberUserId: z.string().min(1),
+})
+
+export const updateTeamGeneralAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: z.input<typeof teamGeneralSchema>) => data)
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    const parsed = teamGeneralSchema.safeParse(data)
+    if (!parsed.success)
+      return { fieldErrors: formErrors(parsed.error.issues), team: null }
+    try {
+      const team = await updateTeamGeneral({
+        userId: session.user.id,
+        ...parsed.data,
+      })
+      return { fieldErrors: null, team }
+    } catch (error) {
+      const fieldErrors = teamSettingsErrors(error)
+      if (fieldErrors) return { fieldErrors, team: null }
+      throw error
+    }
+  })
+
+export const createTeamAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => createTeamSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return createTeam({
+      userId: session.user.id,
+      name: data.name,
+    })
+  })
+
+export const createTeamInvitesAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => {
+    const parsed = bulkInviteSchema.parse(data)
+    return {
+      teamSlug: parsed.teamSlug,
+      emails: parseInviteEmails(parsed.emails),
+      role: parsed.role,
+    }
+  })
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return createTeamInvites({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const resendTeamInviteAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => inviteIdSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return resendTeamInvite({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const revokeTeamInviteAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => inviteIdSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return revokeTeamInvite({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const updateTeamMemberRoleAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => memberRoleSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return updateTeamMemberRole({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const removeTeamMemberAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => memberSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return removeTeamMember({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const transferTeamOwnershipAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => memberSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return transferTeamOwnership({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const deleteTeamAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => deleteTeamSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return deleteTeam({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const acceptTeamInviteAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) =>
+    z.object({ token: z.string().min(1) }).parse(data),
+  )
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return acceptTeamInvite({
+      userId: session.user.id,
+      token: data.token,
+    })
+  })
+
+export const acceptUserTeamInviteAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => userInviteIdSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return acceptUserTeamInvite({
+      userId: session.user.id,
+      inviteId: data.inviteId,
+    })
+  })
+
+export const declineUserTeamInviteAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => userInviteIdSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    return declineUserTeamInvite({
+      userId: session.user.id,
+      inviteId: data.inviteId,
+    })
+  })
+
+export const declineTeamInviteAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) =>
+    z.object({ token: z.string().min(1) }).parse(data),
+  )
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    return declineTeamInvite({ userId: session.user.id, token: data.token })
+  })
+
+const teamSectionRequestSchema = teamRouteSchema.extend({
+  section: teamContextSectionSchema,
+})
+
+export const getTeamShellContext = createServerFn({ method: 'GET' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: z.input<typeof teamRouteSchema>) =>
+    teamRouteSchema.parse(data),
+  )
+  .handler(async ({ data }) => {
+    const session = await getAuthSession()
+
+    if (!session) {
+      return null
+    }
+
+    const userContext = await getUserContext(session.user.id)
+    const team = userContext.teams.find((item) => item.slug === data.teamSlug)
+
+    if (!team) {
+      throw new PublicError('TEAM_NOT_FOUND')
+    }
+
+    const [projects, servers] = await Promise.all([
+      listTeamProjects(team.id),
+      listTeamServers(team.id, { includeMonitoring: false }),
+    ])
+
+    return {
+      userContext,
+      team,
+      projects,
+      servers,
+    }
+  })
+
+export const getTeamSectionContext = createServerFn({ method: 'GET' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: z.input<typeof teamSectionRequestSchema>) =>
+    teamSectionRequestSchema.parse(data),
+  )
+  .handler(async ({ data }) => {
+    const session = await getAuthSession()
+
+    if (!session) {
+      return null
+    }
+
+    const team = await requireTeam(session.user.id, data.teamSlug)
+
+    if (data.section === 'overview') {
+      return {
+        section: data.section,
+        deployments: await listTeamDeployments({ teamId: team.id, limit: 5 }),
+      } as const
+    }
+
+    if (data.section === 'servers') {
+      const [servers, serverInstall] = await Promise.all([
+        listTeamServers(team.id, { includeMonitoring: true }),
+        getAgentBinaryStatus(),
+      ])
+
+      return { section: data.section, servers, serverInstall } as const
+    }
+
+    const [members, invites, deletionStatus, backupStorage] = await Promise.all(
+      [
+        listTeamMembers(team.id),
+        listTeamInvites(team.id),
+        getTeamDeletionStatus({ teamId: team.id }),
+        listBackupStorage(team.id, team.role !== 'member'),
+      ],
+    )
+
+    return {
+      section: data.section,
+      settings: { deletionStatus, invites, members, backupStorage },
+    } as const
+  })

package/src/server/teams/invitations.ts

@@ -0,0 +1,38 @@
+import { sql } from 'drizzle-orm'
+import type { AtomicStore } from '#devpush/server/db/atomic'
+import {
+  teamInvites,
+  teamMembers,
+  teams,
+  user,
+} from '#devpush/server/db/schema'
+
+export async function acceptInvitation(
+  store: AtomicStore,
+  input: { userId: string; inviteId: string; tokenHash: string; now: Date },
+) {
+  const eligible = sql`invitation.id = ${input.inviteId}
+    and invitation.token_hash = ${input.tokenHash}
+    and invitation.status = 'pending' and invitation.expires_at > ${input.now.getTime()}
+    and invitee.id = ${input.userId} and invitee.status = 'active'
+    and invitee.email_verified = 1 and lower(trim(invitee.email)) = invitation.email
+    and invited_team.status = 'active'`
+  const [, accepted] = await store.batch([
+    store.run(sql`insert into ${teamMembers} (id, team_id, user_id, role, created_at)
+      select ${crypto.randomUUID()}, invitation.team_id, invitee.id, invitation.role, ${input.now.getTime()}
+      from ${teamInvites} as invitation
+      join ${teams} as invited_team on invited_team.id = invitation.team_id
+      join ${user} as invitee on invitee.id = ${input.userId}
+      where ${eligible}
+      on conflict(team_id, user_id) do nothing`),
+    store.all(sql`update ${teamInvites} set status = 'accepted', updated_at = ${input.now.getTime()}
+      where id in (
+        select invitation.id from ${teamInvites} as invitation
+        join ${teams} as invited_team on invited_team.id = invitation.team_id
+        join ${user} as invitee on invitee.id = ${input.userId}
+        join ${teamMembers} as membership on membership.team_id = invitation.team_id and membership.user_id = invitee.id
+        where ${eligible}
+      ) returning id`),
+  ])
+  return accepted.length === 1
+}

package/src/server/teams/membership.ts

@@ -0,0 +1,86 @@
+import { sql } from 'drizzle-orm'
+import type { SQL } from 'drizzle-orm'
+import type { TeamRole } from '#devpush/lib/team-role'
+import { teamMembers, user, teams } from '#devpush/server/db/schema'
+
+type Store = { all: <T = unknown>(query: SQL) => Promise<T[]> }
+type Change = {
+  teamId: string
+  actorId: string
+  memberId: string
+} & ({ action: 'remove' } | { action: 'role'; role: TeamRole })
+
+// Permission, target role and remaining ownership are checked inside the same
+// mutation. This protects both D1 and local SQLite against competing requests.
+export async function mutateTeamMembership(store: Store, change: Change) {
+  const ownerRequired =
+    change.action === 'role' && change.role === 'owner'
+      ? sql`1`
+      : sql`${teamMembers.role} = 'owner'`
+  const mayManage = sql`exists (
+    select 1 from ${teamMembers} as actor
+    join ${user} as actor_user on actor_user.id = actor.user_id
+    join ${teams} as actor_team on actor_team.id = actor.team_id
+    where actor.team_id = ${change.teamId} and actor.user_id = ${change.actorId}
+      and actor_user.status = 'active' and actor_team.status = 'active'
+      and (actor.role = 'owner' or (actor.role = 'admin' and not (${ownerRequired})))
+  )`
+  const keepsOwner =
+    change.action === 'role' && change.role === 'owner'
+      ? sql`1`
+      : sql`(${teamMembers.role} <> 'owner' or exists (
+      select 1 from ${teamMembers} as other join ${user} as other_user on other_user.id = other.user_id
+      where other_user.status = 'active' and other.team_id = ${change.teamId} and other.user_id <> ${change.memberId}
+        and other.role = 'owner'
+    ))`
+  const scope = sql`${teamMembers.teamId} = ${change.teamId} and ${teamMembers.userId} = ${change.memberId}
+    and ${mayManage} and ${keepsOwner}`
+  const statement =
+    change.action === 'role'
+      ? sql`update ${teamMembers} set role = ${change.role} where ${scope} returning id`
+      : sql`delete from ${teamMembers} where ${scope} returning id`
+  return (await store.all<{ id: string }>(statement)).length > 0
+}
+
+export async function mutateTeamOwnership(
+  store: Store,
+  change: {
+    teamId: string
+    actorId: string
+    memberId: string
+  },
+) {
+  if (change.actorId === change.memberId) return false
+  // Materialize both eligible memberships before either role changes. An
+  // UPDATE subquery must not recheck the actor after demoting its first row.
+  const statement = sql`with authorized as materialized (
+    select actor.id as actor_id, target.id as target_id
+    from ${teamMembers} as actor
+    join ${teamMembers} as target on target.team_id = actor.team_id
+    join ${user} as actor_user on actor_user.id = actor.user_id
+    join ${user} as target_user on target_user.id = target.user_id
+    join ${teams} as actor_team on actor_team.id = actor.team_id
+    where actor.team_id = ${change.teamId} and actor.user_id = ${change.actorId}
+      and actor.role = 'owner' and target.user_id = ${change.memberId} and target.role <> 'owner'
+      and actor_user.status = 'active' and target_user.status = 'active' and actor_team.status = 'active'
+  ) update ${teamMembers}
+    set role = case when user_id = ${change.memberId} then 'owner' else 'admin' end
+    where id in (select actor_id from authorized union all select target_id from authorized)
+    returning id`
+  return (await store.all(statement)).length === 2
+}
+
+export async function leaveMembership(
+  store: Store,
+  input: { userId: string; teamId: string },
+) {
+  const statement = sql`delete from ${teamMembers}
+    where team_id = ${input.teamId} and user_id = ${input.userId}
+      and exists(select 1 from ${user} as member_user
+        where member_user.id = ${input.userId} and member_user.status = 'active'
+        and (member_user.default_team_id is null or member_user.default_team_id <> ${input.teamId}))
+      and (role <> 'owner' or exists(select 1 from ${teamMembers} as other join ${user} as other_user on other_user.id = other.user_id
+        where other_user.status = 'active' and other.team_id = ${input.teamId} and other.user_id <> ${input.userId} and other.role = 'owner'))
+    returning id`
+  return (await store.all(statement)).length === 1
+}

package/src/server/teams/queries.ts

@@ -0,0 +1,261 @@
+import { and, desc, eq, gt, ne, sql } from 'drizzle-orm'
+import { alias } from 'drizzle-orm/sqlite-core'
+
+import { getAgentUpdate } from '#devpush/server/agents/compatibility'
+import { config, currentAgentVersion } from '#devpush/server/config'
+import { db } from '#devpush/server/db'
+import {
+  aliases,
+  environments,
+  projects,
+  servers,
+  teamInvites,
+  teamMembers,
+  teams,
+  user,
+} from '#devpush/server/db/schema'
+import { getResourceColor } from '#devpush/server/resources/color'
+import { listServerMonitoringSummaries } from '#devpush/server/servers/monitoring'
+import type { ServerMonitoringSummary } from '#devpush/server/servers/monitoring'
+import { getEffectiveServerStatus } from '#devpush/server/servers/status'
+import type {
+  ProjectSummary,
+  ServerSummary,
+  TeamInviteSummary,
+  TeamMemberSummary,
+  UserTeamInviteSummary,
+} from './types'
+
+export async function listTeamProjects(
+  teamId: string,
+): Promise<Array<ProjectSummary>> {
+  const rows = await db
+    .select({
+      id: projects.id,
+      name: projects.name,
+      avatarUrl: projects.avatarPath,
+      githubRepo: projects.githubRepo,
+      defaultHost: aliases.hostname,
+      defaultRouteHttps: aliases.https,
+    })
+    .from(projects)
+    .leftJoin(
+      environments,
+      and(
+        eq(environments.projectId, projects.id),
+        eq(environments.isProduction, true),
+      ),
+    )
+    .leftJoin(
+      aliases,
+      and(
+        eq(aliases.environmentId, environments.id),
+        eq(aliases.type, 'environment'),
+      ),
+    )
+    .where(and(eq(projects.teamId, teamId), eq(projects.status, 'active')))
+    .orderBy(desc(projects.updatedAt))
+
+  return rows.map((project) => ({
+    id: project.id,
+    name: project.name,
+    avatarUrl: project.avatarUrl,
+    githubRepo: project.githubRepo,
+    defaultHost: project.defaultHost,
+    defaultRouteHttps: project.defaultRouteHttps ?? false,
+    color: getResourceColor(project.id),
+  }))
+}
+
+export async function listTeamServers(
+  teamId: string,
+  { includeMonitoring = true }: { includeMonitoring?: boolean } = {},
+): Promise<Array<ServerSummary>> {
+  const now = new Date()
+  const rows = await db
+    .select({
+      id: servers.id,
+      name: servers.name,
+      publicAddress: servers.publicAddress,
+      publicIpv4: servers.publicIpv4,
+      publicIpv6: servers.publicIpv6,
+      status: servers.status,
+      agentVersion: servers.agentVersion,
+      agentProtocolVersion: servers.agentProtocolVersion,
+      agentCapabilities: servers.agentCapabilities,
+      lastSeenAt: servers.lastSeenAt,
+      createdAt: servers.createdAt,
+    })
+    .from(servers)
+    .where(and(eq(servers.teamId, teamId), ne(servers.status, 'deleted')))
+    .orderBy(desc(servers.updatedAt))
+
+  const monitoring = includeMonitoring
+    ? await listServerMonitoringSummaries(rows, now)
+    : new Map<string, ServerMonitoringSummary>()
+
+  return rows.map((server) => ({
+    id: server.id,
+    name: server.name,
+    publicAddress: server.publicAddress,
+    publicIpv4: server.publicIpv4,
+    publicIpv6: server.publicIpv6,
+    status: getEffectiveServerStatus({
+      status: server.status,
+      lastSeenAt: server.lastSeenAt,
+      now,
+    }),
+    agentVersion: server.agentVersion,
+    agentUpdate: server.lastSeenAt
+      ? getAgentUpdate({
+          agentVersion: server.agentVersion,
+          protocolVersion: server.agentProtocolVersion,
+          capabilities: server.agentCapabilities,
+          latestVersion: currentAgentVersion,
+          recommendedVersion: config.DEVPUSH_RECOMMENDED_AGENT_VERSION ?? null,
+        })
+      : { status: 'current', latestVersion: null, reason: null },
+    lastSeenAt: server.lastSeenAt?.toISOString() ?? null,
+    monitoring: monitoring.get(server.id) ?? {
+      availabilityPercent: null,
+      availabilityWindowMs: 0,
+      latestMetrics: null,
+    },
+  }))
+}
+
+export async function listTeamMembers(
+  teamId: string,
+): Promise<Array<TeamMemberSummary>> {
+  const rows = await db
+    .select({
+      id: teamMembers.id,
+      role: teamMembers.role,
+      userId: user.id,
+      userName: user.name,
+      userUsername: user.username,
+      userEmail: user.email,
+      userImage: user.image,
+    })
+    .from(teamMembers)
+    .innerJoin(user, eq(user.id, teamMembers.userId))
+    .where(and(eq(teamMembers.teamId, teamId), eq(user.status, 'active')))
+    .orderBy(desc(teamMembers.createdAt))
+
+  return rows.map((member) => ({
+    id: member.id,
+    role: member.role,
+    user: {
+      id: member.userId,
+      name: member.userName,
+      username: member.userUsername,
+      email: member.userEmail,
+      image: member.userImage,
+    },
+  }))
+}
+
+export async function listTeamInvites(
+  teamId: string,
+): Promise<Array<TeamInviteSummary>> {
+  const rows = await db
+    .select({
+      id: teamInvites.id,
+      email: teamInvites.email,
+      role: teamInvites.role,
+      expiresAt: teamInvites.expiresAt,
+      createdAt: teamInvites.createdAt,
+      inviterId: user.id,
+      inviterName: user.name,
+      inviterEmail: user.email,
+      inviterImage: user.image,
+    })
+    .from(teamInvites)
+    .leftJoin(user, eq(user.id, teamInvites.inviterId))
+    .where(
+      and(
+        eq(teamInvites.teamId, teamId),
+        eq(teamInvites.status, 'pending'),
+        gt(teamInvites.expiresAt, new Date()),
+      ),
+    )
+    .orderBy(desc(teamInvites.createdAt))
+
+  return rows.map((invite) => ({
+    id: invite.id,
+    email: invite.email,
+    role: invite.role === 'admin' ? 'admin' : 'member',
+    expiresAt: invite.expiresAt.toISOString(),
+    createdAt: invite.createdAt.toISOString(),
+    inviter: invite.inviterId
+      ? {
+          id: invite.inviterId,
+          name: invite.inviterName ?? '',
+          email: invite.inviterEmail ?? '',
+          image: invite.inviterImage,
+        }
+      : null,
+  }))
+}
+
+export async function listUserPendingTeamInvites(
+  userId: string,
+): Promise<Array<UserTeamInviteSummary>> {
+  const invitee = alias(user, 'invitee')
+  const rows = await db
+    .select({
+      id: teamInvites.id,
+      role: teamInvites.role,
+      expiresAt: teamInvites.expiresAt,
+      createdAt: teamInvites.createdAt,
+      teamId: teams.id,
+      teamSlug: teams.slug,
+      teamName: teams.name,
+      teamImage: teams.avatarPath,
+      inviterId: user.id,
+      inviterName: user.name,
+      inviterEmail: user.email,
+      inviterImage: user.image,
+    })
+    .from(teamInvites)
+    .innerJoin(teams, eq(teams.id, teamInvites.teamId))
+    .innerJoin(
+      invitee,
+      and(
+        eq(invitee.id, userId),
+        eq(invitee.status, 'active'),
+        sql`lower(${teamInvites.email}) = lower(${invitee.email})`,
+      ),
+    )
+    .leftJoin(user, eq(user.id, teamInvites.inviterId))
+    .where(
+      and(
+        eq(teamInvites.status, 'pending'),
+        gt(teamInvites.expiresAt, new Date()),
+        eq(teams.status, 'active'),
+      ),
+    )
+    .orderBy(desc(teamInvites.createdAt))
+
+  return rows.map((invite) => ({
+    id: invite.id,
+    role: invite.role === 'admin' ? 'admin' : 'member',
+    expiresAt: invite.expiresAt.toISOString(),
+    createdAt: invite.createdAt.toISOString(),
+    team: {
+      id: invite.teamId,
+      slug: invite.teamSlug,
+      name: invite.teamName,
+      image: invite.teamImage,
+      color: getResourceColor(invite.teamId),
+    },
+    inviter: invite.inviterId
+      ? {
+          id: invite.inviterId,
+          name: invite.inviterName ?? '',
+          email: invite.inviterEmail ?? '',
+          image: invite.inviterImage,
+        }
+      : null,
+  }))
+}