devpush 0.0.0-stage → 1.0.0-beta.4

package/src/server/notifications/preferences.ts

@@ -0,0 +1,131 @@
+import { and, eq, sql } from 'drizzle-orm'
+import { db } from '#devpush/server/db'
+import {
+  notificationPreferences,
+  notificationMutes,
+  projects,
+  teams,
+  teamMembers,
+  user,
+} from '#devpush/server/db/schema'
+import {
+  defaultNotificationPreferences,
+  notificationPreferencesSchema,
+} from '#devpush/lib/notification-preferences'
+import type { NotificationScope } from '#devpush/lib/notification-preferences'
+import { PublicError } from '#devpush/lib/public-error'
+
+export async function readNotificationPreferences(userId: string) {
+  const [row] = await db
+    .select()
+    .from(notificationPreferences)
+    .where(eq(notificationPreferences.userId, userId))
+    .limit(1)
+  return {
+    preferences: { ...defaultNotificationPreferences, ...row?.preferences },
+    version: row?.version ?? 0,
+  }
+}
+export async function saveNotificationPreferences(
+  userId: string,
+  preferences: unknown,
+  version: number,
+) {
+  const parsed = notificationPreferencesSchema.parse(preferences)
+  const [active] = await db
+    .select({ id: user.id })
+    .from(user)
+    .where(and(eq(user.id, userId), eq(user.status, 'active')))
+    .limit(1)
+  if (!active) throw new PublicError('UNAUTHORIZED')
+  const savedRows =
+    version === 0
+      ? await db
+          .insert(notificationPreferences)
+          .values({ userId, preferences: parsed, version: 1 })
+          .onConflictDoNothing()
+          .returning()
+      : await db
+          .update(notificationPreferences)
+          .set({
+            preferences: parsed,
+            version: sql`${notificationPreferences.version}+1`,
+          })
+          .where(
+            and(
+              eq(notificationPreferences.userId, userId),
+              eq(notificationPreferences.version, version),
+            ),
+          )
+          .returning()
+  const saved = savedRows[0]
+  if (!saved) throw new PublicError('SETTINGS_CONFLICT')
+  return { preferences: saved.preferences, version: saved.version }
+}
+async function requireNotificationScope(
+  userId: string,
+  scope: NotificationScope,
+) {
+  const rows =
+    scope.kind === 'workspace'
+      ? await db
+          .select({ teamId: teams.id, projectId: sql<string | null>`null` })
+          .from(teams)
+          .where(and(eq(teams.id, scope.id), eq(teams.status, 'active')))
+          .limit(1)
+      : await db
+          .select({ teamId: projects.teamId, projectId: projects.id })
+          .from(projects)
+          .innerJoin(teams, eq(teams.id, projects.teamId))
+          .where(
+            and(
+              eq(projects.id, scope.id),
+              eq(projects.status, 'active'),
+              eq(teams.status, 'active'),
+            ),
+          )
+          .limit(1)
+  const row = rows[0]
+  if (!row) throw new PublicError('PROJECT_NOT_FOUND')
+  const [member] = await db
+    .select({ id: teamMembers.id })
+    .from(teamMembers)
+    .innerJoin(user, eq(user.id, teamMembers.userId))
+    .where(
+      and(
+        eq(teamMembers.userId, userId),
+        eq(teamMembers.teamId, row.teamId),
+        eq(user.status, 'active'),
+      ),
+    )
+    .limit(1)
+  if (!member) throw new PublicError('PROJECT_NOT_FOUND')
+  return row
+}
+export async function readNotificationMute(
+  userId: string,
+  scope: NotificationScope,
+) {
+  await requireNotificationScope(userId, scope)
+  const [row] = await db
+    .select({ id: notificationMutes.id })
+    .from(notificationMutes)
+    .where(eq(notificationMutes.id, `${userId}:${scope.kind}:${scope.id}`))
+    .limit(1)
+  return { muted: Boolean(row) }
+}
+export async function saveNotificationMute(
+  userId: string,
+  scope: NotificationScope,
+  muted: boolean,
+) {
+  const target = await requireNotificationScope(userId, scope)
+  const id = `${userId}:${scope.kind}:${scope.id}`
+  if (muted)
+    await db
+      .insert(notificationMutes)
+      .values({ id, userId, ...target })
+      .onConflictDoNothing()
+  else await db.delete(notificationMutes).where(eq(notificationMutes.id, id))
+  return { muted }
+}

package/src/server/notifications/query.ts

@@ -0,0 +1,16 @@
+import type { SQL } from 'drizzle-orm'
+import { db } from '#devpush/server/db'
+
+/** Raw Drizzle rows are positional on SQLite/libSQL and named on D1. */
+export async function notificationRows<T>(
+  query: SQL,
+  columns: readonly (keyof T)[],
+): Promise<T[]> {
+  const rows: unknown[] = await db.all(query)
+  return rows.map(
+    (row) =>
+      (Array.isArray(row)
+        ? Object.fromEntries(columns.map((key, index) => [key, row[index]]))
+        : row) as T,
+  )
+}

package/src/server/plugins/scope.ts

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import type { PluginServices } from '#devpush/plugins/contract'
+
+const scope = new AsyncLocalStorage<{ services?: PluginServices }>()
+
+/** Reuse providers within a request/tick, never across unrelated Worker invocations. */
+export function withPluginScope<T>(work: () => T): T {
+  return scope.run({}, work)
+}
+
+export function scopedPluginServices(
+  create: () => PluginServices,
+): PluginServices {
+  const current = scope.getStore()
+  if (!current) return create()
+  return (current.services ??= create())
+}

package/src/server/plugins/server-context.ts

@@ -0,0 +1,157 @@
+import { config } from '#devpush/server/config'
+import { deferBackgroundTask } from '#devpush/server/runtime/background'
+import { and, asc, eq, gt, sql } from 'drizzle-orm'
+import { db } from '#devpush/server/db'
+import { getResourceColor } from '#devpush/server/resources/color'
+import { servers, teams, teamMembers, user } from '#devpush/server/db/schema'
+import {
+  renderNotificationEmail,
+  sendEmail,
+} from '#devpush/server/email/service'
+import type { PluginContext } from '#devpush/plugins/contract'
+
+const fields = {
+  id: servers.id,
+  teamId: servers.teamId,
+  teamSlug: teams.slug,
+  teamStatus: teams.status,
+  handle: servers.handle,
+  status: servers.status,
+  publicAddress: servers.publicAddress,
+  publicIpv4: servers.publicIpv4,
+  publicIpv6: servers.publicIpv6,
+  agentCapabilities: servers.agentCapabilities,
+}
+
+export const pluginContext: PluginContext = {
+  defer: deferBackgroundTask,
+  async prepareNotification(input) {
+    const [recipient] = await db
+      .select({ email: user.email })
+      .from(user)
+      .where(and(eq(user.id, input.userId), eq(user.status, 'active')))
+      .limit(1)
+    if (!recipient) return null
+    if (!config.EMAIL_FROM) throw new Error('EMAIL_FROM is not configured.')
+    return {
+      from: config.EMAIL_FROM,
+      to: recipient.email,
+      subject: input.subject,
+      text: input.action
+        ? `${input.message}\n\n${input.action.label}: ${input.action.url}`
+        : input.message,
+      html: await renderNotificationEmail({
+        to: recipient.email,
+        title: input.subject,
+        message: input.message,
+        action: input.action,
+      }),
+    }
+  },
+  async notifyUser(input) {
+    const prepared =
+      input.prepared ?? (await pluginContext.prepareNotification!(input))
+    if (!prepared) return false
+    // Never send a queued message to a removed account or an old mailbox. A
+    // changed address discards this recipient; it must not mutate a provider key.
+    const [recipient] = await db
+      .select({ email: user.email })
+      .from(user)
+      .where(and(eq(user.id, input.userId), eq(user.status, 'active')))
+      .limit(1)
+    if (!recipient || recipient.email !== prepared.to) return false
+    await sendEmail(prepared, input.idempotencyKey)
+    return true
+  },
+  async listWorkspaceOwners(teamId) {
+    const rows = await db
+      .select({ id: user.id })
+      .from(user)
+      .innerJoin(teamMembers, eq(teamMembers.userId, user.id))
+      .innerJoin(teams, eq(teams.id, teamMembers.teamId))
+      .where(
+        and(
+          eq(teamMembers.teamId, teamId),
+          eq(teamMembers.role, 'owner'),
+          eq(user.status, 'active'),
+        ),
+      )
+    return rows.map((row) => row.id)
+  },
+  async readWorkspace(teamId) {
+    const rows = await db
+      .select({
+        createdAt: sql<number>`${teams.createdAt}`,
+        personalOwnerId: sql<
+          string | null
+        >`(select u.id from user u where u.default_team_id=${teamId} and u.status='active' limit 1)`,
+        id: teams.id,
+        slug: teams.slug,
+        name: teams.name,
+        image: teams.avatarPath,
+        status: teams.status,
+        serverCount: sql<number>`(select count(*) from servers s where s.team_id=${teamId} and s.status <> 'deleted')`,
+        serverCountChangedAt: sql<number>`(select coalesce(max(case when s.status='deleted' then s.updated_at else s.created_at end), ${teams.createdAt}) from servers s where s.team_id=${teamId})`,
+        memberCount: sql<number>`(select count(*) from team_members m join user u on u.id=m.user_id where m.team_id=${teamId} and u.status='active')`,
+      })
+      .from(teams)
+      .where(eq(teams.id, teamId))
+      .limit(1)
+    return rows[0] ? { ...rows[0], color: getResourceColor(rows[0].id) } : null
+  },
+  async authorizeWorkspace(userId, teamSlug) {
+    const rows = await db
+      .select({
+        id: teams.id,
+        slug: teams.slug,
+        name: teams.name,
+        role: teamMembers.role,
+      })
+      .from(teams)
+      .innerJoin(teamMembers, eq(teamMembers.teamId, teams.id))
+      .innerJoin(user, eq(user.id, teamMembers.userId))
+      .where(
+        and(
+          eq(teams.slug, teamSlug),
+          eq(teamMembers.userId, userId),
+          eq(teams.status, 'active'),
+          eq(user.status, 'active'),
+        ),
+      )
+      .limit(1)
+    return rows[0] ?? null
+  },
+  async hasServerRouting(serverId) {
+    const rows = await db.all<{ present: number }>(sql`
+      select 1 as present from aliases a
+      join environments e on e.id = a.environment_id
+      join projects p on p.id = a.project_id
+      left join deployments d on d.id = a.deployment_id
+      left join deployments previous on previous.id = a.previous_deployment_id
+      where d.server_id = ${serverId} or previous.server_id = ${serverId}
+        or (a.deployment_id is null and coalesce(e.server_id,p.default_server_id) = ${serverId})
+      limit 1
+    `)
+    return rows.length > 0
+  },
+  async readServer(serverId) {
+    const rows = await db
+      .select(fields)
+      .from(servers)
+      .innerJoin(teams, eq(teams.id, servers.teamId))
+      .where(eq(servers.id, serverId))
+      .limit(1)
+    return rows[0] ?? null
+  },
+  async listServers({ afterId, limit }) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+      throw new Error('Server page size must be between 1 and 100.')
+    return db
+      .select(fields)
+      .from(servers)
+      .innerJoin(teams, eq(teams.id, servers.teamId))
+      .where(and(afterId ? gt(servers.id, afterId) : undefined))
+      .orderBy(asc(servers.id))
+      .limit(limit)
+  },
+}

package/src/server/plugins/services.server.ts

@@ -0,0 +1,10 @@
+import { scopedPluginServices } from './scope'
+import plugins from '#devpush/plugins/registered-server'
+import { pluginContext } from './server-context'
+import { composeServerPlugins } from '#devpush/plugins/server'
+
+export function getPluginServices() {
+  return scopedPluginServices(() =>
+    composeServerPlugins(plugins, process.env, pluginContext),
+  )
+}

package/src/server/plugins/workspace-access.ts

@@ -0,0 +1,74 @@
+import { getPluginServices } from './services.server'
+import type {
+  WorkspaceOperation,
+  WorkspaceActor,
+} from '#devpush/plugins/contract'
+import { WorkspacePolicyError } from '#devpush/plugins/server'
+import { PublicError } from '#devpush/lib/public-error'
+
+declare const admissionBrand: unique symbol
+export interface WorkspaceAdmission {
+  readonly teamId: string
+  readonly operation: WorkspaceOperation
+  readonly [admissionBrand]: true
+}
+const activeAdmissions = new WeakSet<object>()
+export function requireWorkspaceAdmission(
+  admission: WorkspaceAdmission,
+  teamId: string,
+  operation: WorkspaceOperation,
+) {
+  if (
+    !activeAdmissions.has(admission) ||
+    admission.teamId !== teamId ||
+    admission.operation !== operation
+  )
+    throw new Error('Invalid workspace mutation admission.')
+}
+
+export async function withWorkspaceAccess<T>(
+  teamId: string,
+  operation: WorkspaceOperation,
+  action: (admission: WorkspaceAdmission) => Promise<T>,
+  actor: WorkspaceActor,
+): Promise<T> {
+  const access = getPluginServices().workspaceAccess
+  const invoke = async () => {
+    const admission = Object.freeze({ teamId, operation }) as WorkspaceAdmission
+    activeAdmissions.add(admission)
+    try {
+      return await action(admission)
+    } finally {
+      activeAdmissions.delete(admission)
+    }
+  }
+  if (!access) return invoke()
+  try {
+    return await access.run({ teamId, operation, actor }, invoke)
+  } catch (error) {
+    if (error instanceof WorkspacePolicyError) {
+      const codes = {
+        restricted: 'WORKSPACE_RESTRICTED',
+        limit: 'WORKSPACE_LIMIT_REACHED',
+        busy: 'RESOURCE_BUSY',
+      } as const
+      throw new PublicError(codes[error.reason], undefined, error.publicDetails)
+    }
+    throw error
+  }
+}
+
+/** No core effect is performed; the policy may still do its own accounting or I/O. */
+export async function checkWorkspaceAccess(
+  teamId: string,
+  operation: WorkspaceOperation,
+  actor: WorkspaceActor,
+) {
+  return withWorkspaceAccess(teamId, operation, async () => undefined, actor)
+}
+export function isWorkspacePolicyRefusal(error: unknown): boolean {
+  return (
+    error instanceof PublicError &&
+    ['WORKSPACE_RESTRICTED', 'WORKSPACE_LIMIT_REACHED'].includes(error.code)
+  )
+}

package/src/server/projects/backup-policy-state.ts

@@ -0,0 +1,68 @@
+import { backupRetentionSchema } from '#devpush/lib/backup-policy-schema'
+import type { ApiMutationAdmission } from '#devpush/server/api/admission'
+import { sql } from 'drizzle-orm'
+import type { AtomicStore } from '#devpush/server/db/atomic'
+import { teamSettingsAccess } from '#devpush/server/settings-version'
+
+export async function saveProjectBackupPolicyState(
+  store: AtomicStore,
+  input: {
+    projectId: string
+    teamId: string
+    userId: string
+    settingsVersion: number | null
+    policy: {
+      id: string
+      name: string
+      environmentId: string
+      enabled: boolean
+      schedule: unknown
+      destination: { storageId?: string }
+      retention: unknown
+      volumes: unknown
+      databaseDumps: unknown
+    }
+    now: Date
+    admission?: ApiMutationAdmission
+  },
+) {
+  const p = input.policy
+  const retention = backupRetentionSchema.parse(p.retention)
+  const access = sql`${teamSettingsAccess(input.teamId, input.userId)} and exists(select 1 from projects where id = ${input.projectId} and team_id = ${input.teamId} and status = 'active')
+    and exists(select 1 from environments where id = ${p.environmentId} and project_id = ${input.projectId} and status = 'active')
+    and (${p.destination.storageId ?? null} is null or exists(select 1 from backup_storage where id = ${p.destination.storageId ?? null} and team_id = ${input.teamId})) and (${Number(retention.remote.enabled)} = 0 or ${p.destination.storageId ?? null} is not null) and ${input.admission?.guard ?? sql`1`}`
+  const now = input.now.getTime()
+  const effect =
+    input.settingsVersion === null
+      ? store.all(sql`insert into backup_configs (id,project_id,name,environment_id,enabled,destination_type,schedule,destination,retention,volumes,database_dumps,created_at,updated_at)
+      select ${p.id},${input.projectId},${p.name},${p.environmentId},${Number(p.enabled)},'s3',${JSON.stringify(p.schedule)},${JSON.stringify(p.destination)},${JSON.stringify(retention)},${JSON.stringify(p.volumes)},${JSON.stringify(p.databaseDumps)},${now},${now}
+      where ${access} and not exists(select 1 from backup_configs where id = ${p.id}) returning id`)
+      : store.all(sql`update backup_configs set name = ${p.name},environment_id = ${p.environmentId},enabled = ${Number(p.enabled)},schedule = ${JSON.stringify(p.schedule)},destination = ${JSON.stringify(p.destination)},retention = ${JSON.stringify(retention)},volumes = ${JSON.stringify(p.volumes)},database_dumps = ${JSON.stringify(p.databaseDumps)},updated_at = ${now},settings_version = settings_version + 1
+      where id = ${p.id} and project_id = ${input.projectId} and settings_version = ${input.settingsVersion} and ${access} returning id`)
+  const [rows] = await store.batch([
+    effect,
+    ...(input.admission?.statements ?? []),
+  ])
+  return rows.length === 1
+}
+
+export async function deleteProjectBackupPolicyState(
+  store: AtomicStore,
+  input: {
+    projectId: string
+    teamId: string
+    userId: string
+    policyId: string
+    settingsVersion: number
+    admission?: ApiMutationAdmission
+  },
+) {
+  const effect = store.all(
+    sql`delete from backup_configs where id = ${input.policyId} and project_id = ${input.projectId} and settings_version = ${input.settingsVersion} and ${teamSettingsAccess(input.teamId, input.userId)} and exists(select 1 from projects where id = ${input.projectId} and status = 'active' and team_id = ${input.teamId}) and ${input.admission?.guard ?? sql`1`} returning id`,
+  )
+  const [rows] = await store.batch([
+    effect,
+    ...(input.admission?.statements ?? []),
+  ])
+  return rows.length === 1
+}

package/src/server/projects/backups.ts

@@ -0,0 +1,219 @@
+import { withWorkspaceAccess } from '#devpush/server/plugins/workspace-access'
+import { requireBackupsEnabled } from '#devpush/server/backups/feature'
+import { getProjectSettingsContext } from './settings-context'
+import { PublicError } from '#devpush/lib/public-error'
+import { prepareBackupPolicy } from '#devpush/server/backups/policy-validation'
+
+import { canManageTeamSettings } from '#devpush/lib/team-role'
+import type { TeamRole } from '#devpush/lib/team-role'
+import { db } from '#devpush/server/db'
+import {
+  saveProjectBackupPolicyState,
+  deleteProjectBackupPolicyState,
+} from './backup-policy-state'
+import {
+  queueBackupRestoreJob,
+  queueEnvironmentBackup,
+} from '#devpush/server/backups/service'
+import { getProjectContext } from './context'
+import type { BackupDestinationInput, ProjectBackupConfig } from './types'
+
+export async function saveProjectBackupPolicy({
+  projectId,
+  userId,
+  teamSlug,
+  projectName,
+  policy,
+  settingsVersion,
+}: {
+  projectId?: string
+  userId: string
+  teamSlug: string
+  projectName: string
+  settingsVersion: number | null
+  policy: Omit<ProjectBackupConfig, 'settingsVersion' | 'destination'> & {
+    destination: BackupDestinationInput
+  }
+}) {
+  requireBackupsEnabled()
+  const context = await getProjectSettingsContext({
+    projectId,
+    reloadSection: 'backups',
+    userId,
+    teamSlug,
+    projectName,
+    scope: 'shell',
+  })
+  return withWorkspaceAccess(
+    context.team.id,
+    'backup.policy.save',
+    async () => {
+      requireBackupManagement(context.team.role)
+      const normalized = await prepareBackupPolicy({
+        teamId: context.team.id,
+        projectId: context.project.id,
+        policy,
+      })
+      const changed = await saveProjectBackupPolicyState(db, {
+        projectId: context.project.id,
+        teamId: context.team.id,
+        userId,
+        settingsVersion,
+        policy: normalized,
+        now: new Date(),
+      })
+      if (!changed) throw new PublicError('SETTINGS_CONFLICT')
+      return getProjectContext({
+        userId,
+        teamSlug,
+        projectName,
+        scope: 'backups',
+      })
+    },
+    { kind: 'user', userId },
+  )
+}
+
+export async function deleteProjectBackupPolicy({
+  projectId,
+  userId,
+  teamSlug,
+  projectName,
+  policyId,
+  settingsVersion,
+}: {
+  projectId?: string
+  userId: string
+  teamSlug: string
+  projectName: string
+  policyId: string
+  settingsVersion: number
+}) {
+  requireBackupsEnabled()
+  const context = await getProjectSettingsContext({
+    projectId,
+    reloadSection: 'backups',
+    userId,
+    teamSlug,
+    projectName,
+    scope: 'shell',
+  })
+  return withWorkspaceAccess(
+    context.team.id,
+    'backup.policy.delete',
+    async () => {
+      requireBackupManagement(context.team.role)
+      if (
+        !(await deleteProjectBackupPolicyState(db, {
+          projectId: context.project.id,
+          teamId: context.team.id,
+          userId,
+          policyId,
+          settingsVersion,
+        }))
+      )
+        throw new PublicError('SETTINGS_CONFLICT')
+      return getProjectContext({
+        userId,
+        teamSlug,
+        projectName,
+        scope: 'backups',
+      })
+    },
+    { kind: 'user', userId },
+  )
+}
+
+export async function createManualBackupRun({
+  backupConfigId,
+  userId,
+  teamSlug,
+  projectName,
+}: {
+  backupConfigId: string
+  userId: string
+  teamSlug: string
+  projectName: string
+}) {
+  requireBackupsEnabled()
+  const context = await getProjectContext({
+    userId,
+    teamSlug,
+    projectName,
+    scope: 'backups',
+  })
+  const backupConfig = context.backupConfigs.find(
+    (candidate) => candidate.id === backupConfigId,
+  )
+
+  if (!backupConfig) {
+    throw new PublicError('BACKUP_POLICY_NOT_FOUND')
+  }
+
+  requireBackupManagement(context.team.role)
+  const queued = await queueEnvironmentBackup({
+    actor: { kind: 'user', userId: userId },
+    backupConfigId,
+    projectId: context.project.id,
+    environmentId: backupConfig.environmentId,
+    manifest: {
+      trigger: 'manual',
+      backupConfigId,
+      requestedAt: new Date().toISOString(),
+    },
+  })
+  if (!queued) {
+    throw new PublicError('BACKUP_ALREADY_ACTIVE')
+  }
+
+  return getProjectContext({ userId, teamSlug, projectName, scope: 'backups' })
+}
+
+export async function createBackupRestoreJob({
+  userId,
+  teamSlug,
+  projectName,
+  backupRunId,
+  artifacts,
+}: {
+  userId: string
+  teamSlug: string
+  projectName: string
+  backupRunId: string
+  artifacts: Array<
+    | {
+        artifactId: string
+        type: 'volume'
+        targetVolume: string
+      }
+    | {
+        artifactId: string
+        type: 'database'
+        targetService: string
+      }
+  >
+}) {
+  requireBackupsEnabled()
+  const context = await getProjectContext({
+    userId,
+    teamSlug,
+    projectName,
+    scope: 'shell',
+  })
+  requireBackupManagement(context.team.role)
+
+  await queueBackupRestoreJob({
+    actor: { kind: 'user', userId: userId },
+    projectId: context.project.id,
+    backupRunId,
+    artifacts,
+  })
+
+  return getProjectContext({ userId, teamSlug, projectName, scope: 'backups' })
+}
+
+function requireBackupManagement(role: TeamRole) {
+  if (!canManageTeamSettings(role)) {
+    throw new PublicError('BACKUP_MANAGEMENT_FORBIDDEN')
+  }
+}