feat(release): prepare 1.1.0 candidate
This commit is contained in:
parent
5a34f66981
commit
5205dcdfa9
736 changed files with 115667 additions and 12203 deletions
48
apps/mobile-rn/src/features/teams/pending-invite.ts
Normal file
48
apps/mobile-rn/src/features/teams/pending-invite.ts
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
import { Platform } from 'react-native'
|
||||
import * as Keychain from 'react-native-keychain'
|
||||
import { normalizeInviteToken } from './team-service'
|
||||
|
||||
const PENDING_INVITE_SERVICE = 'com.d3ro.voice.pending-team-invite.v1'
|
||||
const PENDING_INVITE_USERNAME = 'pending-invite'
|
||||
|
||||
function keychainOptions() {
|
||||
return {
|
||||
service: PENDING_INVITE_SERVICE,
|
||||
accessible: Keychain.ACCESSIBLE.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY,
|
||||
...(Platform.OS === 'android'
|
||||
? {
|
||||
securityLevel: Keychain.SECURITY_LEVEL.SECURE_SOFTWARE,
|
||||
storage: Keychain.STORAGE_TYPE.AES_GCM_NO_AUTH,
|
||||
}
|
||||
: {}),
|
||||
}
|
||||
}
|
||||
|
||||
export async function savePendingInviteToken(tokenValue: string): Promise<void> {
|
||||
const token = normalizeInviteToken(tokenValue)
|
||||
const stored = await Keychain.setGenericPassword(
|
||||
PENDING_INVITE_USERNAME,
|
||||
token,
|
||||
keychainOptions(),
|
||||
)
|
||||
if (stored === false) throw new Error('pending_invite_secure_storage_failed')
|
||||
}
|
||||
|
||||
export async function loadPendingInviteToken(): Promise<string | null> {
|
||||
const credentials = await Keychain.getGenericPassword({ service: PENDING_INVITE_SERVICE })
|
||||
if (credentials === false) return null
|
||||
if (credentials.username !== PENDING_INVITE_USERNAME) {
|
||||
await clearPendingInviteToken()
|
||||
return null
|
||||
}
|
||||
try {
|
||||
return normalizeInviteToken(credentials.password)
|
||||
} catch {
|
||||
await clearPendingInviteToken()
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
export async function clearPendingInviteToken(): Promise<void> {
|
||||
await Keychain.resetGenericPassword({ service: PENDING_INVITE_SERVICE })
|
||||
}
|
||||
694
apps/mobile-rn/src/features/teams/team-service.ts
Normal file
694
apps/mobile-rn/src/features/teams/team-service.ts
Normal file
|
|
@ -0,0 +1,694 @@
|
|||
import type { RealtimeChannel } from '@supabase/supabase-js'
|
||||
import type { Meeting, Team, TeamRole } from '@d3ro/api-client'
|
||||
import { supabase } from '../../lib/supabase'
|
||||
|
||||
export interface TeamSummary extends Team {
|
||||
role: TeamRole
|
||||
memberCount: number
|
||||
}
|
||||
|
||||
export interface TeamMemberDirectoryEntry {
|
||||
userId: string
|
||||
role: TeamRole
|
||||
joinedAt: string
|
||||
displayName: string | null
|
||||
avatarUrl: string | null
|
||||
}
|
||||
|
||||
export interface TeamInviteListEntry {
|
||||
id: string
|
||||
email: string
|
||||
role: Exclude<TeamRole, 'owner'>
|
||||
expiresAt: string
|
||||
createdAt: string
|
||||
invitedBy: string | null
|
||||
}
|
||||
|
||||
export interface TeamInviteResult {
|
||||
id: string
|
||||
url: string
|
||||
expiresAt: string
|
||||
emailSent: boolean
|
||||
emailError: string | null
|
||||
}
|
||||
|
||||
export interface TeamAcceptResult {
|
||||
teamId: string
|
||||
role: Exclude<TeamRole, 'owner'> | TeamRole
|
||||
alreadyMember: boolean
|
||||
}
|
||||
|
||||
export interface TeamDetail {
|
||||
team: Team
|
||||
currentRole: TeamRole
|
||||
members: TeamMemberDirectoryEntry[]
|
||||
invites: TeamInviteListEntry[]
|
||||
meetings: Meeting[]
|
||||
}
|
||||
|
||||
export type TeamServiceErrorCode =
|
||||
| 'auth'
|
||||
| 'conflict'
|
||||
| 'duplicate'
|
||||
| 'email-mismatch'
|
||||
| 'expired'
|
||||
| 'forbidden'
|
||||
| 'invalid-response'
|
||||
| 'invalid-token'
|
||||
| 'network'
|
||||
| 'not-found'
|
||||
| 'rate-limited'
|
||||
| 'server-contract'
|
||||
| 'server'
|
||||
| 'validation'
|
||||
|
||||
export class TeamServiceError extends Error {
|
||||
constructor(
|
||||
public readonly code: TeamServiceErrorCode,
|
||||
message: string,
|
||||
) {
|
||||
super(message)
|
||||
this.name = 'TeamServiceError'
|
||||
}
|
||||
}
|
||||
|
||||
export interface TeamSubscription {
|
||||
unsubscribe: () => Promise<void>
|
||||
}
|
||||
|
||||
const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
|
||||
const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
|
||||
const INVITE_TOKEN_PATTERN = /^[A-Za-z0-9_-]{32}$/
|
||||
const TEAM_NAME_MAX_LENGTH = 80
|
||||
const EMAIL_MAX_LENGTH = 254
|
||||
const TRUSTED_INVITE_ORIGIN = 'https://d3ro.chanpaca.net'
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null && !Array.isArray(value)
|
||||
}
|
||||
|
||||
function isIsoDate(value: unknown): value is string {
|
||||
return typeof value === 'string' && Number.isFinite(Date.parse(value))
|
||||
}
|
||||
|
||||
function isRole(value: unknown): value is TeamRole {
|
||||
return value === 'owner' || value === 'admin' || value === 'member'
|
||||
}
|
||||
|
||||
function firstRow(value: unknown): unknown {
|
||||
if (Array.isArray(value)) return value[0] ?? null
|
||||
return value
|
||||
}
|
||||
|
||||
function requireUuid(value: string, label: string): void {
|
||||
if (!UUID_PATTERN.test(value)) {
|
||||
throw new TeamServiceError('validation', `${label} is invalid`)
|
||||
}
|
||||
}
|
||||
|
||||
export function normalizeTeamName(value: string): string {
|
||||
const name = value.trim().replace(/\s+/g, ' ')
|
||||
if (name.length === 0 || name.length > TEAM_NAME_MAX_LENGTH) {
|
||||
throw new TeamServiceError(
|
||||
'validation',
|
||||
`Team name must contain 1-${TEAM_NAME_MAX_LENGTH} characters`,
|
||||
)
|
||||
}
|
||||
return name
|
||||
}
|
||||
|
||||
export function normalizeInviteEmail(value: string): string {
|
||||
const email = value.trim().toLocaleLowerCase('en-US')
|
||||
if (
|
||||
email.length === 0
|
||||
|| email.length > EMAIL_MAX_LENGTH
|
||||
|| !EMAIL_PATTERN.test(email)
|
||||
) {
|
||||
throw new TeamServiceError('validation', 'Invite email is invalid')
|
||||
}
|
||||
return email
|
||||
}
|
||||
|
||||
export function normalizeInviteToken(value: string): string {
|
||||
const token = value.trim()
|
||||
if (!INVITE_TOKEN_PATTERN.test(token)) {
|
||||
throw new TeamServiceError('invalid-token', 'Invite token is invalid')
|
||||
}
|
||||
return token
|
||||
}
|
||||
|
||||
export function extractInviteToken(urlOrToken: string): string {
|
||||
const value = urlOrToken.trim()
|
||||
if (INVITE_TOKEN_PATTERN.test(value)) return value
|
||||
|
||||
const match = value.match(/[?&]token=([^&#]+)/)
|
||||
if (match?.[1] === undefined) {
|
||||
throw new TeamServiceError('invalid-token', 'Invite link does not contain a token')
|
||||
}
|
||||
|
||||
try {
|
||||
return normalizeInviteToken(decodeURIComponent(match[1].replace(/\+/g, '%20')))
|
||||
} catch (error) {
|
||||
if (error instanceof TeamServiceError) throw error
|
||||
throw new TeamServiceError('invalid-token', 'Invite token cannot be decoded')
|
||||
}
|
||||
}
|
||||
|
||||
export function normalizeInviteUrl(value: string): string {
|
||||
let parsed: URL
|
||||
try {
|
||||
parsed = new URL(value)
|
||||
} catch {
|
||||
throw new TeamServiceError('invalid-response', 'Invite response URL is invalid')
|
||||
}
|
||||
if (
|
||||
parsed.origin !== TRUSTED_INVITE_ORIGIN
|
||||
|| (parsed.pathname !== '/accept-invite' && parsed.pathname !== '/accept-invite/')
|
||||
|| parsed.username !== ''
|
||||
|| parsed.password !== ''
|
||||
|| parsed.hash !== ''
|
||||
|| Array.from(parsed.searchParams.keys()).length !== 1
|
||||
) {
|
||||
throw new TeamServiceError('invalid-response', 'Invite response URL is not trusted')
|
||||
}
|
||||
normalizeInviteToken(parsed.searchParams.get('token') ?? '')
|
||||
return parsed.toString()
|
||||
}
|
||||
|
||||
function normalizeTeam(value: unknown): Team {
|
||||
if (!isRecord(value)) {
|
||||
throw new TeamServiceError('invalid-response', 'Team response is not an object')
|
||||
}
|
||||
const avatarUrl = value.avatar_url ?? null
|
||||
if (
|
||||
typeof value.id !== 'string'
|
||||
|| !UUID_PATTERN.test(value.id)
|
||||
|| typeof value.name !== 'string'
|
||||
|| value.name.trim().length === 0
|
||||
|| typeof value.owner_id !== 'string'
|
||||
|| !UUID_PATTERN.test(value.owner_id)
|
||||
|| (avatarUrl !== null && typeof avatarUrl !== 'string')
|
||||
|| !isIsoDate(value.created_at)
|
||||
|| !isIsoDate(value.updated_at)
|
||||
) {
|
||||
throw new TeamServiceError('invalid-response', 'Team response is malformed')
|
||||
}
|
||||
|
||||
return {
|
||||
id: value.id,
|
||||
name: value.name,
|
||||
owner_id: value.owner_id,
|
||||
avatar_url: avatarUrl,
|
||||
created_at: value.created_at,
|
||||
updated_at: value.updated_at,
|
||||
}
|
||||
}
|
||||
|
||||
export function normalizeTeamMember(value: unknown): TeamMemberDirectoryEntry {
|
||||
if (!isRecord(value)) {
|
||||
throw new TeamServiceError('invalid-response', 'Team member response is not an object')
|
||||
}
|
||||
const userId = typeof value.user_id === 'string' ? value.user_id : value.userId
|
||||
const joinedAt = typeof value.joined_at === 'string' ? value.joined_at : value.joinedAt
|
||||
const displayName = value.display_name ?? value.displayName ?? null
|
||||
const avatarUrl = value.avatar_url ?? value.avatarUrl ?? null
|
||||
if (
|
||||
typeof userId !== 'string'
|
||||
|| !UUID_PATTERN.test(userId)
|
||||
|| !isRole(value.role)
|
||||
|| !isIsoDate(joinedAt)
|
||||
|| (displayName !== null && typeof displayName !== 'string')
|
||||
|| (avatarUrl !== null && typeof avatarUrl !== 'string')
|
||||
) {
|
||||
throw new TeamServiceError('invalid-response', 'Team member response is malformed')
|
||||
}
|
||||
return {
|
||||
userId,
|
||||
role: value.role,
|
||||
joinedAt,
|
||||
displayName,
|
||||
avatarUrl,
|
||||
}
|
||||
}
|
||||
|
||||
export function normalizeTeamInvite(value: unknown): TeamInviteListEntry {
|
||||
if (!isRecord(value)) {
|
||||
throw new TeamServiceError('invalid-response', 'Team invite response is not an object')
|
||||
}
|
||||
const expiresAt = typeof value.expires_at === 'string' ? value.expires_at : value.expiresAt
|
||||
const createdAt = typeof value.created_at === 'string' ? value.created_at : value.createdAt
|
||||
const invitedBy = value.invited_by ?? value.invitedBy ?? null
|
||||
if (
|
||||
typeof value.id !== 'string'
|
||||
|| !UUID_PATTERN.test(value.id)
|
||||
|| typeof value.email !== 'string'
|
||||
|| (value.role !== 'admin' && value.role !== 'member')
|
||||
|| !isIsoDate(expiresAt)
|
||||
|| !isIsoDate(createdAt)
|
||||
|| (invitedBy !== null && typeof invitedBy !== 'string')
|
||||
) {
|
||||
throw new TeamServiceError('invalid-response', 'Team invite response is malformed')
|
||||
}
|
||||
if ('token' in value || 'invite_token' in value || 'inviteToken' in value) {
|
||||
throw new TeamServiceError('invalid-response', 'Invite list leaked a bearer token')
|
||||
}
|
||||
return {
|
||||
id: value.id,
|
||||
email: value.email,
|
||||
role: value.role,
|
||||
expiresAt,
|
||||
createdAt,
|
||||
invitedBy,
|
||||
}
|
||||
}
|
||||
|
||||
function errorDetails(error: unknown): { code: string; message: string } {
|
||||
const candidate = error as {
|
||||
code?: unknown
|
||||
message?: unknown
|
||||
details?: unknown
|
||||
hint?: unknown
|
||||
}
|
||||
return {
|
||||
code: typeof candidate?.code === 'string' ? candidate.code : '',
|
||||
message: [candidate?.message, candidate?.details, candidate?.hint]
|
||||
.filter((value): value is string => typeof value === 'string')
|
||||
.join(' '),
|
||||
}
|
||||
}
|
||||
|
||||
function toTeamServiceError(error: unknown): TeamServiceError {
|
||||
if (error instanceof TeamServiceError) return error
|
||||
const details = errorDetails(error)
|
||||
const lower = details.message.toLowerCase()
|
||||
const hasCode = (code: string): boolean => details.code === code || lower.includes(code)
|
||||
if (
|
||||
error instanceof TypeError
|
||||
|| lower.includes('network request failed')
|
||||
|| lower.includes('failed to fetch')
|
||||
) return new TeamServiceError('network', details.message || 'Team request failed')
|
||||
if (details.code === 'PGRST301' || lower.includes('jwt') || lower.includes('not authenticated')) {
|
||||
return new TeamServiceError('auth', details.message || 'Authentication is required')
|
||||
}
|
||||
if (details.code === 'PGRST202' || lower.includes('could not find the function')) {
|
||||
return new TeamServiceError('server-contract', details.message || 'Team server contract is unavailable')
|
||||
}
|
||||
if (hasCode('invite_email_mismatch') || lower.includes('email mismatch')) {
|
||||
return new TeamServiceError('email-mismatch', details.message)
|
||||
}
|
||||
if (hasCode('invalid_invite_token') || lower.includes('invalid token')) {
|
||||
return new TeamServiceError('invalid-token', details.message || 'Invite token is invalid')
|
||||
}
|
||||
if (hasCode('invite_expired') || lower.includes('expired')) {
|
||||
return new TeamServiceError('expired', details.message)
|
||||
}
|
||||
if (
|
||||
details.code === '23505'
|
||||
|| hasCode('already_team_member')
|
||||
|| hasCode('invite_already_accepted')
|
||||
|| lower.includes('duplicate')
|
||||
|| lower.includes('already invited')
|
||||
|| lower.includes('already accepted')
|
||||
) {
|
||||
return new TeamServiceError('duplicate', details.message || 'Team request is duplicated')
|
||||
}
|
||||
if (hasCode('invite_acceptance_conflict') || lower.includes('team_membership_failed')) {
|
||||
return new TeamServiceError('conflict', details.message || 'Team request conflicted')
|
||||
}
|
||||
if (hasCode('invite_not_found') || hasCode('team_member_not_found') || details.code === 'P0002') {
|
||||
return new TeamServiceError('not-found', details.message || 'Team resource was not found')
|
||||
}
|
||||
if (hasCode('invite_rate_limited') || details.code === '54000') {
|
||||
return new TeamServiceError('rate-limited', details.message || 'Too many team invitations')
|
||||
}
|
||||
if (
|
||||
details.code === '42501'
|
||||
|| hasCode('team_admin_required')
|
||||
|| hasCode('team_owner_required')
|
||||
|| lower.includes('forbidden')
|
||||
|| lower.includes('permission')
|
||||
) {
|
||||
return new TeamServiceError('forbidden', details.message || 'Team request is forbidden')
|
||||
}
|
||||
if (details.code.startsWith('22')) {
|
||||
return new TeamServiceError('validation', details.message || 'Team input is invalid')
|
||||
}
|
||||
return new TeamServiceError('server', details.message || 'Team request failed')
|
||||
}
|
||||
|
||||
async function invokeRpc(name: string, params: Record<string, unknown>): Promise<unknown> {
|
||||
try {
|
||||
const { data, error } = await supabase.rpc(name, params)
|
||||
if (error !== null) throw error
|
||||
return data
|
||||
} catch (error) {
|
||||
throw toTeamServiceError(error)
|
||||
}
|
||||
}
|
||||
|
||||
async function readFunctionFailure(error: unknown): Promise<TeamServiceError> {
|
||||
const context = (error as { context?: unknown })?.context
|
||||
if (context instanceof Response) {
|
||||
try {
|
||||
const payload: unknown = await context.clone().json()
|
||||
if (isRecord(payload)) {
|
||||
const code = typeof payload.error === 'string' ? payload.error : ''
|
||||
const message = typeof payload.message === 'string'
|
||||
? payload.message
|
||||
: code || `Team function returned ${context.status}`
|
||||
return toTeamServiceError({ code, message })
|
||||
}
|
||||
} catch {
|
||||
return toTeamServiceError({ message: `Team function returned ${context.status}` })
|
||||
}
|
||||
}
|
||||
return toTeamServiceError(error)
|
||||
}
|
||||
|
||||
export async function listTeams(userId: string): Promise<TeamSummary[]> {
|
||||
requireUuid(userId, 'Authenticated user')
|
||||
try {
|
||||
const membershipResult = await supabase
|
||||
.from('team_members')
|
||||
.select('team_id,role,joined_at')
|
||||
.eq('user_id', userId)
|
||||
if (membershipResult.error !== null) throw membershipResult.error
|
||||
|
||||
const memberships = (membershipResult.data ?? []).filter((row): row is {
|
||||
team_id: string
|
||||
role: TeamRole
|
||||
joined_at: string
|
||||
} => isRecord(row) && typeof row.team_id === 'string' && isRole(row.role))
|
||||
if (memberships.length === 0) return []
|
||||
|
||||
const teamIds = memberships.map((membership) => membership.team_id)
|
||||
const [teamResult, memberResult] = await Promise.all([
|
||||
supabase.from('teams').select('*').in('id', teamIds),
|
||||
supabase.from('team_members').select('team_id').in('team_id', teamIds),
|
||||
])
|
||||
if (teamResult.error !== null) throw teamResult.error
|
||||
if (memberResult.error !== null) throw memberResult.error
|
||||
|
||||
const roleByTeam = new Map(memberships.map((membership) => [
|
||||
membership.team_id,
|
||||
membership.role,
|
||||
]))
|
||||
const countByTeam = new Map<string, number>()
|
||||
for (const member of memberResult.data ?? []) {
|
||||
if (!isRecord(member) || typeof member.team_id !== 'string') continue
|
||||
countByTeam.set(member.team_id, (countByTeam.get(member.team_id) ?? 0) + 1)
|
||||
}
|
||||
|
||||
return (teamResult.data ?? [])
|
||||
.map(normalizeTeam)
|
||||
.map((team) => {
|
||||
const role = roleByTeam.get(team.id)
|
||||
if (role === undefined) {
|
||||
throw new TeamServiceError('invalid-response', 'Team membership is missing')
|
||||
}
|
||||
return { ...team, role, memberCount: countByTeam.get(team.id) ?? 0 }
|
||||
})
|
||||
.sort((left, right) => right.updated_at.localeCompare(left.updated_at))
|
||||
} catch (error) {
|
||||
throw toTeamServiceError(error)
|
||||
}
|
||||
}
|
||||
|
||||
export async function createTeam(userId: string, nameValue: string): Promise<TeamSummary> {
|
||||
requireUuid(userId, 'Authenticated user')
|
||||
const name = normalizeTeamName(nameValue)
|
||||
const data = firstRow(await invokeRpc('create_team', { team_name: name }))
|
||||
const team = normalizeTeam(data)
|
||||
if (team.owner_id !== userId) {
|
||||
throw new TeamServiceError('invalid-response', 'Created team has a different owner')
|
||||
}
|
||||
return { ...team, role: 'owner', memberCount: 1 }
|
||||
}
|
||||
|
||||
async function listTeamMembers(teamId: string): Promise<TeamMemberDirectoryEntry[]> {
|
||||
const data = await invokeRpc('list_team_members', { target_team_id: teamId })
|
||||
if (!Array.isArray(data)) {
|
||||
throw new TeamServiceError('invalid-response', 'Team members response is not a list')
|
||||
}
|
||||
return data.map(normalizeTeamMember)
|
||||
}
|
||||
|
||||
async function listTeamInvites(teamId: string): Promise<TeamInviteListEntry[]> {
|
||||
const data = await invokeRpc('list_team_invites', { target_team_id: teamId })
|
||||
if (!Array.isArray(data)) {
|
||||
throw new TeamServiceError('invalid-response', 'Team invites response is not a list')
|
||||
}
|
||||
return data.map(normalizeTeamInvite)
|
||||
}
|
||||
|
||||
export async function getTeamDetail(userId: string, teamId: string): Promise<TeamDetail> {
|
||||
requireUuid(userId, 'Authenticated user')
|
||||
requireUuid(teamId, 'Team')
|
||||
try {
|
||||
const [teamResult, members, meetingsResult] = await Promise.all([
|
||||
supabase.from('teams').select('*').eq('id', teamId).maybeSingle(),
|
||||
listTeamMembers(teamId),
|
||||
supabase
|
||||
.from('meetings')
|
||||
.select('*')
|
||||
.eq('team_id', teamId)
|
||||
.order('started_at', { ascending: false })
|
||||
.limit(20),
|
||||
])
|
||||
if (teamResult.error !== null) throw teamResult.error
|
||||
if (teamResult.data === null) {
|
||||
throw new TeamServiceError('not-found', 'Team was not found')
|
||||
}
|
||||
if (meetingsResult.error !== null) throw meetingsResult.error
|
||||
const team = normalizeTeam(teamResult.data)
|
||||
const ownMembership = members.find((member) => member.userId === userId)
|
||||
if (ownMembership === undefined) {
|
||||
throw new TeamServiceError('forbidden', 'Current user is not a team member')
|
||||
}
|
||||
|
||||
const invites = ownMembership.role === 'owner' || ownMembership.role === 'admin'
|
||||
? await listTeamInvites(teamId)
|
||||
: []
|
||||
const meetings = (meetingsResult.data ?? []) as Meeting[]
|
||||
if (meetings.some((meeting) => meeting.team_id !== teamId)) {
|
||||
throw new TeamServiceError('invalid-response', 'Meeting response crossed team boundary')
|
||||
}
|
||||
return { team, currentRole: ownMembership.role, members, invites, meetings }
|
||||
} catch (error) {
|
||||
throw toTeamServiceError(error)
|
||||
}
|
||||
}
|
||||
|
||||
export async function renameTeamRevisionSafe(
|
||||
userId: string,
|
||||
current: Team,
|
||||
nameValue: string,
|
||||
): Promise<Team> {
|
||||
requireUuid(userId, 'Authenticated user')
|
||||
const name = normalizeTeamName(nameValue)
|
||||
if (current.owner_id !== userId) {
|
||||
throw new TeamServiceError('forbidden', 'Only the team owner can rename the team')
|
||||
}
|
||||
if (current.name === name) return current
|
||||
try {
|
||||
const { data, error } = await supabase
|
||||
.from('teams')
|
||||
.update({ name })
|
||||
.eq('id', current.id)
|
||||
.eq('owner_id', userId)
|
||||
.eq('updated_at', current.updated_at)
|
||||
.select('*')
|
||||
.maybeSingle()
|
||||
if (error !== null) throw error
|
||||
if (data === null) {
|
||||
throw new TeamServiceError('conflict', 'Team changed or was removed')
|
||||
}
|
||||
return normalizeTeam(data)
|
||||
} catch (error) {
|
||||
throw toTeamServiceError(error)
|
||||
}
|
||||
}
|
||||
|
||||
export async function deleteTeamRevisionSafe(userId: string, current: Team): Promise<void> {
|
||||
requireUuid(userId, 'Authenticated user')
|
||||
if (current.owner_id !== userId) {
|
||||
throw new TeamServiceError('forbidden', 'Only the team owner can delete the team')
|
||||
}
|
||||
try {
|
||||
const { data, error } = await supabase
|
||||
.from('teams')
|
||||
.delete()
|
||||
.eq('id', current.id)
|
||||
.eq('owner_id', userId)
|
||||
.eq('updated_at', current.updated_at)
|
||||
.select('id')
|
||||
.maybeSingle()
|
||||
if (error !== null) throw error
|
||||
if (data === null) {
|
||||
throw new TeamServiceError('conflict', 'Team changed or was removed')
|
||||
}
|
||||
} catch (error) {
|
||||
throw toTeamServiceError(error)
|
||||
}
|
||||
}
|
||||
|
||||
export async function updateTeamMemberRole(
|
||||
teamId: string,
|
||||
memberUserId: string,
|
||||
role: Exclude<TeamRole, 'owner'>,
|
||||
): Promise<TeamMemberDirectoryEntry> {
|
||||
requireUuid(teamId, 'Team')
|
||||
requireUuid(memberUserId, 'Team member')
|
||||
if (role !== 'admin' && role !== 'member') {
|
||||
throw new TeamServiceError('validation', 'Member role is invalid')
|
||||
}
|
||||
await invokeRpc('update_team_member_role', {
|
||||
target_team_id: teamId,
|
||||
member_user_id: memberUserId,
|
||||
new_role: role,
|
||||
})
|
||||
const member = (await listTeamMembers(teamId))
|
||||
.find((candidate) => candidate.userId === memberUserId)
|
||||
if (member === undefined) {
|
||||
throw new TeamServiceError('invalid-response', 'Updated team member is missing')
|
||||
}
|
||||
if (member.userId !== memberUserId || member.role !== role) {
|
||||
throw new TeamServiceError('invalid-response', 'Updated a different team member')
|
||||
}
|
||||
return member
|
||||
}
|
||||
|
||||
export async function removeTeamMember(teamId: string, memberUserId: string): Promise<void> {
|
||||
requireUuid(teamId, 'Team')
|
||||
requireUuid(memberUserId, 'Team member')
|
||||
await invokeRpc('remove_team_member', {
|
||||
target_team_id: teamId,
|
||||
member_user_id: memberUserId,
|
||||
})
|
||||
}
|
||||
|
||||
export async function leaveTeam(teamId: string, userId: string): Promise<void> {
|
||||
requireUuid(teamId, 'Team')
|
||||
requireUuid(userId, 'Authenticated user')
|
||||
await removeTeamMember(teamId, userId)
|
||||
}
|
||||
|
||||
export async function createTeamInvite(
|
||||
teamId: string,
|
||||
emailValue: string,
|
||||
role: Exclude<TeamRole, 'owner'>,
|
||||
): Promise<TeamInviteResult> {
|
||||
requireUuid(teamId, 'Team')
|
||||
const email = normalizeInviteEmail(emailValue)
|
||||
if (role !== 'admin' && role !== 'member') {
|
||||
throw new TeamServiceError('validation', 'Invite role is invalid')
|
||||
}
|
||||
try {
|
||||
const { data, error } = await supabase.functions.invoke('team-invite', {
|
||||
body: { team_id: teamId, email, role },
|
||||
})
|
||||
if (error !== null) throw await readFunctionFailure(error)
|
||||
if (!isRecord(data)) {
|
||||
throw new TeamServiceError('invalid-response', 'Invite response is not an object')
|
||||
}
|
||||
const expiresAt = data.expires_at
|
||||
const emailSent = data.email_sent ?? false
|
||||
const emailError = data.email_error ?? null
|
||||
if (
|
||||
typeof data.id !== 'string'
|
||||
|| !UUID_PATTERN.test(data.id)
|
||||
|| typeof data.url !== 'string'
|
||||
|| !isIsoDate(expiresAt)
|
||||
|| typeof emailSent !== 'boolean'
|
||||
|| (emailError !== null && typeof emailError !== 'string')
|
||||
) {
|
||||
throw new TeamServiceError('invalid-response', 'Invite response is malformed')
|
||||
}
|
||||
return {
|
||||
id: data.id,
|
||||
url: normalizeInviteUrl(data.url),
|
||||
expiresAt,
|
||||
emailSent,
|
||||
emailError,
|
||||
}
|
||||
} catch (error) {
|
||||
throw toTeamServiceError(error)
|
||||
}
|
||||
}
|
||||
|
||||
export async function cancelTeamInvite(teamId: string, inviteId: string): Promise<void> {
|
||||
requireUuid(teamId, 'Team')
|
||||
requireUuid(inviteId, 'Invite')
|
||||
await invokeRpc('cancel_team_invite', { invite_id: inviteId })
|
||||
}
|
||||
|
||||
export async function acceptTeamInvite(tokenValue: string): Promise<TeamAcceptResult> {
|
||||
const token = normalizeInviteToken(tokenValue)
|
||||
try {
|
||||
const { data, error } = await supabase.functions.invoke('team-accept', {
|
||||
body: { token },
|
||||
})
|
||||
if (error !== null) throw await readFunctionFailure(error)
|
||||
if (!isRecord(data)) {
|
||||
throw new TeamServiceError('invalid-response', 'Accept response is not an object')
|
||||
}
|
||||
const teamId = data.team_id
|
||||
const role = data.role
|
||||
const alreadyMember = data.already_member ?? false
|
||||
if (
|
||||
typeof teamId !== 'string'
|
||||
|| !UUID_PATTERN.test(teamId)
|
||||
|| !isRole(role)
|
||||
|| typeof alreadyMember !== 'boolean'
|
||||
) {
|
||||
throw new TeamServiceError('invalid-response', 'Accept response is malformed')
|
||||
}
|
||||
return { teamId, role, alreadyMember }
|
||||
} catch (error) {
|
||||
const mapped = toTeamServiceError(error)
|
||||
if (mapped.code === 'not-found') {
|
||||
throw new TeamServiceError('invalid-token', mapped.message || 'Invite token is invalid')
|
||||
}
|
||||
throw mapped
|
||||
}
|
||||
}
|
||||
|
||||
export function subscribeToTeam(
|
||||
teamId: string,
|
||||
onRemoteChange: () => void,
|
||||
onStatus: (status: string) => void,
|
||||
): TeamSubscription {
|
||||
requireUuid(teamId, 'Team')
|
||||
let channel: RealtimeChannel | null = supabase
|
||||
.channel(`mobile-team-${teamId}`)
|
||||
.on(
|
||||
'postgres_changes',
|
||||
{ event: '*', schema: 'public', table: 'teams', filter: `id=eq.${teamId}` },
|
||||
onRemoteChange,
|
||||
)
|
||||
.on(
|
||||
'postgres_changes',
|
||||
{ event: '*', schema: 'public', table: 'team_members', filter: `team_id=eq.${teamId}` },
|
||||
onRemoteChange,
|
||||
)
|
||||
.on(
|
||||
'postgres_changes',
|
||||
{ event: '*', schema: 'public', table: 'team_invites', filter: `team_id=eq.${teamId}` },
|
||||
onRemoteChange,
|
||||
)
|
||||
.on(
|
||||
'postgres_changes',
|
||||
{ event: '*', schema: 'public', table: 'meetings', filter: `team_id=eq.${teamId}` },
|
||||
onRemoteChange,
|
||||
)
|
||||
.subscribe(onStatus)
|
||||
|
||||
return {
|
||||
unsubscribe: async (): Promise<void> => {
|
||||
if (channel === null) return
|
||||
const activeChannel = channel
|
||||
channel = null
|
||||
await supabase.removeChannel(activeChannel)
|
||||
},
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue