feat(release): prepare 1.1.0 candidate

This commit is contained in:
Yun Chan 2026-08-29 18:33:45 +09:00
parent 5a34f66981
commit 5205dcdfa9
736 changed files with 115667 additions and 12203 deletions

View 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 })
}

View 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)
},
}
}