devpush 0.0.0-stage → 1.0.0-beta.4

package/src/server/teams/types.ts

@@ -0,0 +1,101 @@
+import type { AgentUpdate } from '#devpush/server/agents/compatibility'
+import type { TeamRole } from '#devpush/lib/team-role'
+import type { getResourceColor } from '#devpush/server/resources/color'
+import type { ServerMonitoringSummary } from '#devpush/server/servers/monitoring'
+import type { ServerStatus } from '#devpush/server/servers/status'
+
+export type TeamSummary = {
+  settingsVersion: number
+  id: string
+  slug: string
+  name: string
+  image: string | null
+  color: ReturnType<typeof getResourceColor>
+  role: TeamRole
+}
+
+export type ProjectSummary = {
+  id: string
+  name: string
+  avatarUrl: string | null
+  githubRepo: string
+  defaultHost: string | null
+  defaultRouteHttps: boolean
+  color: ReturnType<typeof getResourceColor>
+}
+
+export type ServerSummary = {
+  id: string
+  name: string
+  publicIpv4?: string | null
+  publicIpv6?: string | null
+  publicAddress: string | null
+  status: ServerStatus
+  agentVersion: string | null
+  agentUpdate: AgentUpdate
+  lastSeenAt: string | null
+  monitoring: ServerMonitoringSummary
+}
+
+export type TeamMemberSummary = {
+  id: string
+  role: TeamRole
+  user: {
+    id: string
+    name: string
+    username: string
+    email: string
+    image: string | null
+  }
+}
+
+export type TeamInviteSummary = {
+  id: string
+  email: string
+  role: Exclude<TeamRole, 'owner'>
+  expiresAt: string
+  createdAt: string
+  inviter: {
+    id: string
+    name: string
+    email: string
+    image: string | null
+  } | null
+}
+
+export type UserTeamInviteSummary = {
+  id: string
+  role: Exclude<TeamRole, 'owner'>
+  expiresAt: string
+  createdAt: string
+  team: {
+    id: string
+    slug: string
+    name: string
+    image: string | null
+    color: ReturnType<typeof getResourceColor>
+  }
+  inviter: {
+    id: string
+    name: string
+    email: string
+    image: string | null
+  } | null
+}
+
+export type UserContext = {
+  user: {
+    profileConfirmedAt?: number | null
+    settingsVersion: number
+    id: string
+    name: string
+    username: string
+    email: string
+    image: string | null
+    defaultTeamId: string | null
+    isInstallationAdmin: boolean
+  }
+  teams: Array<TeamSummary>
+  defaultTeam: TeamSummary
+  invites: Array<UserTeamInviteSummary>
+}

package/src/server/uploads/avatar.ts

@@ -0,0 +1,133 @@
+import { PublicError } from '#devpush/lib/public-error'
+import {
+  getObjectStore,
+  isObjectStorageConfigured,
+} from '#devpush/server/storage/object-store'
+
+export type AvatarOwner = {
+  filePrefix: 'user' | 'team' | 'project'
+  resourceId: string
+}
+
+export async function resolveAvatarUpdate({
+  currentAvatarPath,
+  avatarDataUrl,
+  deleteAvatar,
+  filePrefix,
+  resourceId,
+}: {
+  currentAvatarPath: string | null
+  avatarDataUrl?: string | null
+  deleteAvatar: boolean
+  filePrefix: AvatarOwner['filePrefix']
+  resourceId: string
+}) {
+  if (!avatarDataUrl && !deleteAvatar) {
+    return currentAvatarPath
+  }
+
+  if (deleteAvatar || !avatarDataUrl) {
+    return null
+  }
+
+  if (!isObjectStorageConfigured()) {
+    throw new PublicError('AVATAR_STORAGE_UNAVAILABLE')
+  }
+  const parsed = parseAvatarDataUrl(avatarDataUrl)
+  if (!/^[A-Za-z0-9_-]+$/.test(resourceId))
+    throw new Error('Invalid avatar owner.')
+  const version = crypto.randomUUID().replaceAll('-', '')
+  const fileName = `${filePrefix}_${resourceId}~${version}.${parsed.extension}`
+  const publicPath = `/uploads/avatars/${fileName}`
+
+  await getObjectStore().put(
+    `avatars/${fileName}`,
+    parsed.buffer,
+    parsed.mimeType,
+  )
+
+  return publicPath
+}
+
+function parseAvatarDataUrl(dataUrl: string) {
+  const match =
+    /^data:(image\/(?:png|jpeg|webp));base64,([A-Za-z0-9+/=]+)$/.exec(dataUrl)
+
+  if (!match || match[1] === undefined || match[2] === undefined) {
+    throw new PublicError('AVATAR_TYPE_UNSUPPORTED')
+  }
+
+  const mimeType = match[1]
+  const buffer = Buffer.from(match[2], 'base64')
+
+  if (buffer.byteLength > 2 * 1024 * 1024) {
+    throw new PublicError('AVATAR_TOO_LARGE')
+  }
+
+  if (!matchesImageSignature(buffer, mimeType)) {
+    throw new PublicError('AVATAR_CONTENT_MISMATCH')
+  }
+
+  return {
+    buffer,
+    mimeType,
+    extension:
+      mimeType === 'image/jpeg'
+        ? 'jpg'
+        : mimeType === 'image/png'
+          ? 'png'
+          : 'webp',
+  }
+}
+
+function matchesImageSignature(buffer: Buffer, mimeType: string) {
+  if (mimeType === 'image/png') {
+    return buffer
+      .subarray(0, 8)
+      .equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+  }
+
+  if (mimeType === 'image/jpeg') {
+    return (
+      buffer.length >= 3 &&
+      buffer[0] === 0xff &&
+      buffer[1] === 0xd8 &&
+      buffer[2] === 0xff
+    )
+  }
+
+  return (
+    buffer.length >= 12 &&
+    buffer.subarray(0, 4).toString('ascii') === 'RIFF' &&
+    buffer.subarray(8, 12).toString('ascii') === 'WEBP'
+  )
+}
+
+export async function removeOwnedAvatar(
+  publicPath: string | null | undefined,
+  owner: AvatarOwner,
+  options: { strict?: boolean } = {},
+) {
+  if (!publicPath) {
+    return
+  }
+
+  if (!publicPath.startsWith('/uploads/avatars/')) {
+    return
+  }
+  const prefix = `/uploads/avatars/${owner.filePrefix}_${owner.resourceId}`
+  if (
+    !/^[A-Za-z0-9_-]+$/.test(owner.resourceId) ||
+    !publicPath.startsWith(prefix)
+  )
+    return
+  const suffix = publicPath.slice(prefix.length)
+  if (!/^(?:~[a-f0-9]{32})?\.(?:png|jpe?g|webp)$/.test(suffix)) return
+
+  try {
+    await getObjectStore().delete(publicPath.slice('/uploads/'.length))
+  } catch (error) {
+    if (options.strict) throw error
+    // Missing old avatar files should not block saving settings.
+  }
+}

package/src/server/users/deletion-state.ts

@@ -0,0 +1,93 @@
+import { sql } from 'drizzle-orm'
+import type { AtomicStore } from '#devpush/server/db/atomic'
+import { teamDeletionStatements } from '#devpush/server/teams/deletion-state'
+import { installationAdminPredicate } from '#devpush/server/admin/access'
+
+export type UserCleanupJobPayload = {
+  schemaVersion: 1
+  userId: string
+  email: string
+  avatarPath: string | null
+  soleMemberOwnedTeamIds: string[]
+}
+
+export async function deleteUserState(
+  store: AtomicStore,
+  input: {
+    userId: string
+    email: string
+    now: Date
+    adminActorUserId?: string
+  },
+) {
+  const now = input.now.getTime()
+  const jobId = crypto.randomUUID()
+  const guard = sql`u.id = ${input.userId} and u.email = ${input.email}
+    and ${
+      input.adminActorUserId
+        ? sql`u.status in ('active', 'banned') and u.id <> ${input.adminActorUserId} and ${installationAdminPredicate(input.adminActorUserId)}`
+        : sql`u.status = 'active'`
+    }
+    and not exists(select 1 from team_members owner join teams t on t.id = owner.team_id
+      where owner.user_id = ${input.userId} and owner.role = 'owner' and t.status = 'active'
+        and exists(select 1 from team_members other where other.team_id = t.id and other.user_id <> ${input.userId})
+        and not exists(select 1 from team_members other_owner join user other_user on other_user.id = other_owner.user_id
+          where other_owner.team_id = t.id and other_user.status = 'active'
+          and other_owner.user_id <> ${input.userId} and other_owner.role = 'owner'))`
+  const queued = sql`exists(select 1 from user_cleanup_jobs where id = ${jobId} and user_id = ${input.userId})`
+  const [created] = await store.batch([
+    store.all(sql`insert into user_cleanup_jobs (id, user_id, status, payload, available_at, created_at, updated_at)
+      select ${jobId}, u.id, 'queued', json_object('schemaVersion', 1, 'userId', u.id, 'email', u.email,
+        'avatarPath', u.image, 'soleMemberOwnedTeamIds', json((select json_group_array(id) from
+          (select t.id from teams t join team_members sole on sole.team_id = t.id
+            where t.status = 'active' and sole.user_id = ${input.userId} and sole.role = 'owner'
+            and not exists(select 1 from team_members other where other.team_id = t.id and other.user_id <> ${input.userId}) order by t.id)))),
+        ${now}, ${now}, ${now} from user u where ${guard} returning id`),
+    store.run(sql`delete from team_invites where team_id in (
+      select value from user_cleanup_jobs as cleanup, json_each(cleanup.payload, '$.soleMemberOwnedTeamIds')
+      where cleanup.id = ${jobId}) and ${queued}`),
+    store.run(
+      sql`delete from session where user_id = ${input.userId} and ${queued}`,
+    ),
+    store.run(
+      sql`delete from account where user_id = ${input.userId} and ${queued}`,
+    ),
+    store.run(sql`update user set status = 'deleted', default_team_id = null, updated_at = ${now}
+      where id = ${input.userId} and ${queued}`),
+  ])
+  return created.length === 1
+}
+
+export async function cleanupDeletedUserState(
+  store: AtomicStore,
+  input: {
+    payload: UserCleanupJobPayload
+    now: Date
+    claim: { id: string; attempt: number }
+  },
+) {
+  const p = input.payload
+  const guard = sql`exists(select 1 from user where id = ${p.userId} and status = 'deleted') and exists(select 1 from user_cleanup_jobs where id = ${input.claim.id} and user_id = ${p.userId} and status = 'running' and attempt = ${input.claim.attempt} and claimed_at = ${input.now.getTime()})`
+  const statements = teamDeletionStatements({
+    teamIds: sql`select id from teams where status = 'active'
+      and id in (select value from json_each(${JSON.stringify(p.soleMemberOwnedTeamIds)}))
+      and exists(select 1 from team_members sole where sole.team_id = teams.id and sole.user_id = ${p.userId} and sole.role = 'owner')
+      and not exists(select 1 from team_members other where other.team_id = teams.id and other.user_id <> ${p.userId})`,
+    guard,
+    reason: 'Team deleted because the owning user was deleted.',
+    message: 'Canceled because the owning user was deleted.',
+    now: input.now,
+    clearDefaults: true,
+  })
+  const [found] = await store.batch([
+    store.all(sql`select id from user where id = ${p.userId} and ${guard}`),
+    ...statements.map((query) => store.run(query)),
+    store.run(
+      sql`delete from team_invites where (inviter_id = ${p.userId} or lower(email) = ${p.email.toLowerCase()}) and ${guard}`,
+    ),
+    store.run(
+      sql`delete from team_members where user_id = ${p.userId} and ${guard}`,
+    ),
+  ])
+  if (found.length !== 1) throw new Error('Deleted user not found.')
+}

package/src/server/users/functions.ts

@@ -0,0 +1,160 @@
+import { getAuthMethods } from '#devpush/server/auth/auth-methods'
+import {
+  getAuthSession,
+  requireAuthSession,
+} from '#devpush/server/auth/session.server'
+import { getUserContext } from '#devpush/server/teams/service'
+import {
+  listAuthAccounts,
+  listUserTeams,
+  assertActiveUser,
+  disconnectAuthAccount,
+  deleteUserAccount,
+  leaveTeam,
+  updateUserGeneral,
+} from '#devpush/server/users/service'
+import { and, eq, sql } from 'drizzle-orm'
+import { db } from '#devpush/server/db'
+import { user } from '#devpush/server/db/schema'
+import { PublicError } from '#devpush/lib/public-error'
+import { assertAllowedEmailChange } from '#devpush/server/auth/email-change'
+import { publicErrorsMiddleware } from '#devpush/server/http/public-errors'
+import { getRequest } from '@tanstack/react-start/server'
+import { createServerFn } from '@tanstack/react-start'
+import { z } from 'zod'
+
+import { auth } from '#devpush/server/auth/better-auth'
+import {
+  accountSettingsSchema,
+  accountEmailSchema,
+  accountValidationErrors,
+  accountServiceErrors,
+} from '#devpush/lib/account-settings-schema'
+
+export const updateUserGeneralAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: z.input<typeof accountSettingsSchema>) => data)
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    const parsed = accountSettingsSchema.safeParse(data)
+    if (!parsed.success)
+      return { fieldErrors: accountValidationErrors(parsed.error.issues) }
+    try {
+      const profile = await updateUserGeneral({
+        userId: session.user.id,
+        ...parsed.data,
+      })
+      return { user: profile, fieldErrors: null }
+    } catch (error) {
+      const fieldErrors = accountServiceErrors(error)
+      if (fieldErrors) return { fieldErrors }
+      throw error
+    }
+  })
+
+export const requestEmailChangeAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) => accountEmailSchema.parse(data))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    if (data.newEmail === session.user.email.toLowerCase())
+      throw new PublicError('ACCOUNT_EMAIL_UNCHANGED')
+
+    const request = getRequest()
+
+    await assertActiveUser(session.user.id)
+    await assertAllowedEmailChange(data.newEmail)
+
+    const changed = await db
+      .update(user)
+      .set({ settingsVersion: sql`${user.settingsVersion} + 1` })
+      .where(
+        and(
+          eq(user.id, session.user.id),
+          eq(user.status, 'active'),
+          eq(user.settingsVersion, data.settingsVersion),
+          eq(user.email, session.user.email),
+        ),
+      )
+      .returning({ settingsVersion: user.settingsVersion })
+    if (!changed.length) throw new PublicError('SETTINGS_CONFLICT')
+    await auth.api.changeEmail({
+      body: {
+        newEmail: data.newEmail,
+        callbackURL: '/settings#email',
+      },
+      headers: request.headers,
+    })
+    return changed[0]!
+  })
+
+export const disconnectAuthAccountAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) =>
+    z
+      .object({
+        providerId: z.string().min(1),
+        accountId: z.string().min(1).optional().nullable(),
+      })
+      .parse(data),
+  )
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return disconnectAuthAccount({
+      userId: session.user.id,
+      ...data,
+    })
+  })
+
+export const leaveTeamAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) =>
+    z.object({ teamId: z.string().min(1) }).parse(data),
+  )
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return leaveTeam({
+      userId: session.user.id,
+      teamId: data.teamId,
+    })
+  })
+
+export const deleteUserAccountAction = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((data: unknown) =>
+    z.object({ confirmationName: z.string().trim().min(1) }).parse(data),
+  )
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+
+    return deleteUserAccount({
+      userId: session.user.id,
+      confirmationName: data.confirmationName,
+    })
+  })
+
+export const getUserSettingsContext = createServerFn({ method: 'GET' })
+  .middleware([publicErrorsMiddleware])
+  .handler(async () => {
+    const session = await getAuthSession()
+
+    if (!session) {
+      return null
+    }
+
+    const [context, accounts, teams] = await Promise.all([
+      getUserContext(session.user.id),
+      listAuthAccounts(session.user.id, { validateUser: false }),
+      listUserTeams(session.user.id),
+    ])
+
+    return {
+      ...context,
+      accounts,
+      authMethods: getAuthMethods(),
+      teams,
+    }
+  })

package/src/server/users/onboarding.ts

@@ -0,0 +1,17 @@
+import { createServerFn } from '@tanstack/react-start'
+import { requireAuthSession } from '#devpush/server/auth/session.server'
+import { publicErrorsMiddleware } from '#devpush/server/http/public-errors'
+import { accountSettingsSchema } from '#devpush/lib/account-settings-schema'
+import { updateUserGeneral } from './service'
+
+export const confirmProfile = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator((input: unknown) => accountSettingsSchema.parse(input))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    return updateUserGeneral({
+      ...data,
+      userId: session.user.id,
+      confirmProfile: true,
+    })
+  })