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
758
apps/mobile-rn/src/features/admin/admin-service.ts
Normal file
758
apps/mobile-rn/src/features/admin/admin-service.ts
Normal file
|
|
@ -0,0 +1,758 @@
|
|||
import { SUPABASE_ANON_KEY, SUPABASE_URL } from '@d3ro/core/supabase-config'
|
||||
|
||||
export const ADMIN_ROLES = ['user', 'manager', 'admin', 'super_admin'] as const
|
||||
export const ADMIN_TIERS = ['free', 'pro', 'pro_plus'] as const
|
||||
export const ADMIN_SUBSCRIPTION_STATUSES = ['active', 'canceled', 'past_due', 'expired'] as const
|
||||
|
||||
export type AdminRole = typeof ADMIN_ROLES[number]
|
||||
export type AdminTier = typeof ADMIN_TIERS[number]
|
||||
export type AdminSubscriptionStatus = typeof ADMIN_SUBSCRIPTION_STATUSES[number]
|
||||
export type CurrentAdminRole = Exclude<AdminRole, 'user'>
|
||||
|
||||
export type AdminServiceErrorCode =
|
||||
| 'auth'
|
||||
| 'forbidden'
|
||||
| 'not-found'
|
||||
| 'conflict'
|
||||
| 'validation'
|
||||
| 'network'
|
||||
| 'timeout'
|
||||
| 'unavailable'
|
||||
| 'server'
|
||||
|
||||
export class AdminServiceError extends Error {
|
||||
constructor(
|
||||
readonly code: AdminServiceErrorCode,
|
||||
readonly status: number | null,
|
||||
readonly retryable: boolean,
|
||||
) {
|
||||
super(code)
|
||||
this.name = 'AdminServiceError'
|
||||
}
|
||||
}
|
||||
|
||||
export interface AdminProfileSummary {
|
||||
id: string
|
||||
name: string | null
|
||||
avatarUrl: string | null
|
||||
tier: AdminTier
|
||||
role: AdminRole
|
||||
createdAt: string
|
||||
}
|
||||
|
||||
export interface AdminProfileDetail extends AdminProfileSummary {
|
||||
locale: string | null
|
||||
updatedAt: string
|
||||
}
|
||||
|
||||
export interface AdminAccountDetail {
|
||||
id: string
|
||||
email: string | null
|
||||
createdAt: string
|
||||
lastSignInAt: string | null
|
||||
}
|
||||
|
||||
export interface AdminSubscription {
|
||||
id: string
|
||||
userId: string
|
||||
tier: AdminTier
|
||||
status: AdminSubscriptionStatus
|
||||
provider: string
|
||||
paymentProvider: string
|
||||
currentPeriodStart: string | null
|
||||
currentPeriodEnd: string | null
|
||||
overageCredits: number
|
||||
adminNote: string | null
|
||||
cancelAt: string | null
|
||||
createdAt: string
|
||||
updatedAt: string
|
||||
profileName?: string | null
|
||||
profileAvatarUrl?: string | null
|
||||
}
|
||||
|
||||
export interface AdminUserDetail {
|
||||
profile: AdminProfileDetail
|
||||
subscription: AdminSubscription | null
|
||||
account: AdminAccountDetail
|
||||
}
|
||||
|
||||
export interface AdminAuditEntry {
|
||||
id: number
|
||||
adminId: string
|
||||
adminName: string | null
|
||||
action: string
|
||||
targetType: 'profile' | 'subscription'
|
||||
targetId: string
|
||||
memo: string | null
|
||||
createdAt: string
|
||||
}
|
||||
|
||||
export interface AdminProviderEvent {
|
||||
provider: string
|
||||
eventType: string
|
||||
eventCreatedAt: string
|
||||
disposition: string
|
||||
receivedAt: string
|
||||
processedAt: string | null
|
||||
}
|
||||
|
||||
export interface AdminProviderOperation {
|
||||
provider: string
|
||||
operationType: string
|
||||
requestedTier: AdminTier | null
|
||||
state: string
|
||||
errorCode: string | null
|
||||
expiresAt: string
|
||||
createdAt: string
|
||||
updatedAt: string
|
||||
}
|
||||
|
||||
export interface AdminPaymentHistory {
|
||||
subscription: AdminSubscription | null
|
||||
auditLogs: AdminAuditEntry[]
|
||||
providerEvents: AdminProviderEvent[]
|
||||
providerOperations: AdminProviderOperation[]
|
||||
liveProviderHistoryAvailable: false
|
||||
}
|
||||
|
||||
export interface AdminPage<T> {
|
||||
entries: T[]
|
||||
total: number
|
||||
page: number
|
||||
limit: number
|
||||
}
|
||||
|
||||
interface RequestOptions {
|
||||
accessToken: string
|
||||
method?: 'GET' | 'POST' | 'PATCH' | 'DELETE'
|
||||
body?: Record<string, unknown>
|
||||
idempotencyKey?: string
|
||||
signal?: AbortSignal
|
||||
}
|
||||
|
||||
const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
|
||||
const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
|
||||
const MAX_RESPONSE_BYTES = 1024 * 1024
|
||||
const REQUEST_TIMEOUT_MS = 20_000
|
||||
const ROLE_SET = new Set<string>(ADMIN_ROLES)
|
||||
const TIER_SET = new Set<string>(ADMIN_TIERS)
|
||||
const STATUS_SET = new Set<string>(ADMIN_SUBSCRIPTION_STATUSES)
|
||||
|
||||
function recordValue(value: unknown): Record<string, unknown> {
|
||||
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
|
||||
throw invalidResponse()
|
||||
}
|
||||
return value as Record<string, unknown>
|
||||
}
|
||||
|
||||
function assertOnlyKeys(value: Record<string, unknown>, allowed: readonly string[]): void {
|
||||
const allowedSet = new Set(allowed)
|
||||
if (Object.keys(value).some((key) => !allowedSet.has(key))) throw invalidResponse()
|
||||
}
|
||||
|
||||
function requiredString(value: unknown, maximum = 2048): string {
|
||||
if (typeof value !== 'string' || value.length < 1 || value.length > maximum) throw invalidResponse()
|
||||
return value
|
||||
}
|
||||
|
||||
function nullableString(value: unknown, maximum = 4096): string | null {
|
||||
if (value === null) return null
|
||||
return requiredString(value, maximum)
|
||||
}
|
||||
|
||||
function uuid(value: unknown): string {
|
||||
const normalized = requiredString(value, 36)
|
||||
if (!UUID_PATTERN.test(normalized)) throw invalidResponse()
|
||||
return normalized.toLowerCase()
|
||||
}
|
||||
|
||||
function isoDateTime(value: unknown): string {
|
||||
const normalized = requiredString(value, 40)
|
||||
if (!Number.isFinite(Date.parse(normalized))) throw invalidResponse()
|
||||
return normalized
|
||||
}
|
||||
|
||||
function nullableIsoDateTime(value: unknown): string | null {
|
||||
return value === null ? null : isoDateTime(value)
|
||||
}
|
||||
|
||||
function nonNegativeInteger(value: unknown, maximum = 1_000_000): number {
|
||||
if (!Number.isSafeInteger(value) || Number(value) < 0 || Number(value) > maximum) throw invalidResponse()
|
||||
return Number(value)
|
||||
}
|
||||
|
||||
function positiveInteger(value: unknown, maximum = Number.MAX_SAFE_INTEGER): number {
|
||||
if (!Number.isSafeInteger(value) || Number(value) < 1 || Number(value) > maximum) throw invalidResponse()
|
||||
return Number(value)
|
||||
}
|
||||
|
||||
function role(value: unknown): AdminRole {
|
||||
const normalized = requiredString(value, 20)
|
||||
if (!ROLE_SET.has(normalized)) throw invalidResponse()
|
||||
return normalized as AdminRole
|
||||
}
|
||||
|
||||
function tier(value: unknown): AdminTier {
|
||||
const normalized = requiredString(value, 20)
|
||||
if (!TIER_SET.has(normalized)) throw invalidResponse()
|
||||
return normalized as AdminTier
|
||||
}
|
||||
|
||||
function nullableTier(value: unknown): AdminTier | null {
|
||||
return value === null ? null : tier(value)
|
||||
}
|
||||
|
||||
function subscriptionStatus(value: unknown): AdminSubscriptionStatus {
|
||||
const normalized = requiredString(value, 20)
|
||||
if (!STATUS_SET.has(normalized)) throw invalidResponse()
|
||||
return normalized as AdminSubscriptionStatus
|
||||
}
|
||||
|
||||
function invalidResponse(): AdminServiceError {
|
||||
return new AdminServiceError('server', 502, false)
|
||||
}
|
||||
|
||||
function parseProfileSummary(value: unknown): AdminProfileSummary {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, ['id', 'name', 'avatar_url', 'tier', 'role', 'created_at'])
|
||||
return {
|
||||
id: uuid(row.id),
|
||||
name: nullableString(row.name, 200),
|
||||
avatarUrl: nullableString(row.avatar_url, 2048),
|
||||
tier: tier(row.tier),
|
||||
role: role(row.role),
|
||||
createdAt: isoDateTime(row.created_at),
|
||||
}
|
||||
}
|
||||
|
||||
function parseProfileDetail(value: unknown): AdminProfileDetail {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, ['id', 'name', 'avatar_url', 'locale', 'tier', 'role', 'created_at', 'updated_at'])
|
||||
return {
|
||||
id: uuid(row.id),
|
||||
name: nullableString(row.name, 200),
|
||||
avatarUrl: nullableString(row.avatar_url, 2048),
|
||||
locale: nullableString(row.locale, 32),
|
||||
tier: tier(row.tier),
|
||||
role: role(row.role),
|
||||
createdAt: isoDateTime(row.created_at),
|
||||
updatedAt: isoDateTime(row.updated_at),
|
||||
}
|
||||
}
|
||||
|
||||
function parseAccount(value: unknown): AdminAccountDetail {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, ['id', 'email', 'createdAt', 'lastSignInAt'])
|
||||
const email = nullableString(row.email, 320)
|
||||
if (email !== null && !EMAIL_PATTERN.test(email)) throw invalidResponse()
|
||||
return {
|
||||
id: uuid(row.id),
|
||||
email,
|
||||
createdAt: isoDateTime(row.createdAt),
|
||||
lastSignInAt: nullableIsoDateTime(row.lastSignInAt),
|
||||
}
|
||||
}
|
||||
|
||||
const SUBSCRIPTION_KEYS = [
|
||||
'id',
|
||||
'user_id',
|
||||
'tier',
|
||||
'status',
|
||||
'provider',
|
||||
'payment_provider',
|
||||
'current_period_start',
|
||||
'current_period_end',
|
||||
'overage_credits',
|
||||
'admin_note',
|
||||
'cancel_at',
|
||||
'created_at',
|
||||
'updated_at',
|
||||
] as const
|
||||
|
||||
function parseSubscription(value: unknown): AdminSubscription {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, SUBSCRIPTION_KEYS)
|
||||
return {
|
||||
id: uuid(row.id),
|
||||
userId: uuid(row.user_id),
|
||||
tier: tier(row.tier),
|
||||
status: subscriptionStatus(row.status),
|
||||
provider: requiredString(row.provider, 64),
|
||||
paymentProvider: requiredString(row.payment_provider, 64),
|
||||
currentPeriodStart: nullableIsoDateTime(row.current_period_start),
|
||||
currentPeriodEnd: nullableIsoDateTime(row.current_period_end),
|
||||
overageCredits: nonNegativeInteger(row.overage_credits),
|
||||
adminNote: nullableString(row.admin_note, 2000),
|
||||
cancelAt: nullableIsoDateTime(row.cancel_at),
|
||||
createdAt: isoDateTime(row.created_at),
|
||||
updatedAt: isoDateTime(row.updated_at),
|
||||
}
|
||||
}
|
||||
|
||||
function parseSubscriptionListRow(value: unknown): AdminSubscription {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, [...SUBSCRIPTION_KEYS, 'profiles'])
|
||||
const base: Record<string, unknown> = {}
|
||||
for (const key of SUBSCRIPTION_KEYS) base[key] = row[key]
|
||||
const parsed = parseSubscription(base)
|
||||
if (row.profiles === null) return parsed
|
||||
const profile = recordValue(row.profiles)
|
||||
assertOnlyKeys(profile, ['name', 'avatar_url'])
|
||||
return {
|
||||
...parsed,
|
||||
profileName: nullableString(profile.name, 200),
|
||||
profileAvatarUrl: nullableString(profile.avatar_url, 2048),
|
||||
}
|
||||
}
|
||||
|
||||
function parseAudit(value: unknown, allowAdminName: boolean): AdminAuditEntry {
|
||||
const row = recordValue(value)
|
||||
const allowed = [
|
||||
'id', 'admin_id', 'action', 'target_type', 'target_id',
|
||||
'before_data', 'after_data', 'memo', 'created_at',
|
||||
...(allowAdminName ? ['admin_name'] : []),
|
||||
]
|
||||
assertOnlyKeys(row, allowed)
|
||||
const targetType = requiredString(row.target_type, 32)
|
||||
if (targetType !== 'profile' && targetType !== 'subscription') throw invalidResponse()
|
||||
return {
|
||||
id: positiveInteger(row.id, 10_000_000_000),
|
||||
adminId: uuid(row.admin_id),
|
||||
adminName: allowAdminName ? nullableString(row.admin_name, 200) : null,
|
||||
action: requiredString(row.action, 100),
|
||||
targetType,
|
||||
targetId: uuid(row.target_id),
|
||||
memo: nullableString(row.memo, 1000),
|
||||
createdAt: isoDateTime(row.created_at),
|
||||
}
|
||||
}
|
||||
|
||||
function parsePaymentAudit(value: unknown): AdminAuditEntry {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, ['id', 'admin_id', 'action', 'target_type', 'target_id', 'memo', 'created_at'])
|
||||
return parseAudit({ ...row, before_data: null, after_data: null }, false)
|
||||
}
|
||||
|
||||
function parseProviderEvent(value: unknown): AdminProviderEvent {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, [
|
||||
'id', 'provider', 'event_type', 'event_created_at', 'disposition',
|
||||
'received_at', 'processed_at',
|
||||
])
|
||||
requiredString(row.id, 256)
|
||||
return {
|
||||
provider: requiredString(row.provider, 64),
|
||||
eventType: requiredString(row.event_type, 128),
|
||||
eventCreatedAt: isoDateTime(row.event_created_at),
|
||||
disposition: requiredString(row.disposition, 64),
|
||||
receivedAt: isoDateTime(row.received_at),
|
||||
processedAt: nullableIsoDateTime(row.processed_at),
|
||||
}
|
||||
}
|
||||
|
||||
function parseProviderOperation(value: unknown): AdminProviderOperation {
|
||||
const row = recordValue(value)
|
||||
assertOnlyKeys(row, [
|
||||
'id', 'provider', 'operation_type', 'requested_tier', 'state', 'error_code',
|
||||
'expires_at', 'created_at', 'updated_at',
|
||||
])
|
||||
requiredString(row.id, 256)
|
||||
return {
|
||||
provider: requiredString(row.provider, 64),
|
||||
operationType: requiredString(row.operation_type, 128),
|
||||
requestedTier: nullableTier(row.requested_tier),
|
||||
state: requiredString(row.state, 64),
|
||||
errorCode: nullableString(row.error_code, 128),
|
||||
expiresAt: isoDateTime(row.expires_at),
|
||||
createdAt: isoDateTime(row.created_at),
|
||||
updatedAt: isoDateTime(row.updated_at),
|
||||
}
|
||||
}
|
||||
|
||||
function publicErrorCode(value: unknown): string {
|
||||
if (typeof value !== 'string' || value.length < 1 || value.length > 128) return 'invalid_error_response'
|
||||
return value
|
||||
}
|
||||
|
||||
function errorFromResponse(status: number, value: unknown): AdminServiceError {
|
||||
const body = typeof value === 'object' && value !== null && !Array.isArray(value)
|
||||
? value as Record<string, unknown>
|
||||
: {}
|
||||
const publicCode = publicErrorCode(body.error)
|
||||
if (status === 401) return new AdminServiceError('auth', status, false)
|
||||
if (status === 403) return new AdminServiceError('forbidden', status, false)
|
||||
if (status === 404) return new AdminServiceError('not-found', status, false)
|
||||
if (status === 409) return new AdminServiceError('conflict', status, publicCode === 'operation_in_progress')
|
||||
if (status === 400 || status === 413 || status === 415 || status === 422) {
|
||||
return new AdminServiceError('validation', status, false)
|
||||
}
|
||||
if (status === 501 || status === 503) return new AdminServiceError('unavailable', status, true)
|
||||
return new AdminServiceError('server', status, status >= 500)
|
||||
}
|
||||
|
||||
function validatedToken(value: string): string {
|
||||
const token = value.trim()
|
||||
if (token.length < 20 || token.length > 16_384 || /\s/.test(token)) {
|
||||
throw new AdminServiceError('auth', null, false)
|
||||
}
|
||||
return token
|
||||
}
|
||||
|
||||
async function requestAdmin(path: string, options: RequestOptions): Promise<unknown> {
|
||||
const token = validatedToken(options.accessToken)
|
||||
const controller = new AbortController()
|
||||
let externallyAborted = false
|
||||
const abortFromCaller = (): void => {
|
||||
externallyAborted = true
|
||||
controller.abort()
|
||||
}
|
||||
options.signal?.addEventListener('abort', abortFromCaller, { once: true })
|
||||
const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS)
|
||||
try {
|
||||
const response = await fetch(`${SUPABASE_URL}/functions/v1/${path}`, {
|
||||
method: options.method ?? 'GET',
|
||||
headers: {
|
||||
apikey: SUPABASE_ANON_KEY,
|
||||
Authorization: `Bearer ${token}`,
|
||||
Accept: 'application/json',
|
||||
...(options.body === undefined ? {} : { 'Content-Type': 'application/json' }),
|
||||
...(options.idempotencyKey === undefined ? {} : { 'idempotency-key': options.idempotencyKey }),
|
||||
},
|
||||
body: options.body === undefined ? undefined : JSON.stringify(options.body),
|
||||
signal: controller.signal,
|
||||
})
|
||||
const text = await response.text()
|
||||
if (new TextEncoder().encode(text).byteLength > MAX_RESPONSE_BYTES) throw invalidResponse()
|
||||
let payload: unknown = null
|
||||
if (text.length > 0) {
|
||||
try {
|
||||
payload = JSON.parse(text) as unknown
|
||||
} catch {
|
||||
throw invalidResponse()
|
||||
}
|
||||
}
|
||||
if (!response.ok) throw errorFromResponse(response.status, payload)
|
||||
return payload
|
||||
} catch (error) {
|
||||
if (error instanceof AdminServiceError) throw error
|
||||
if (controller.signal.aborted) {
|
||||
if (externallyAborted) throw new AdminServiceError('network', null, false)
|
||||
throw new AdminServiceError('timeout', null, true)
|
||||
}
|
||||
throw new AdminServiceError('network', null, true)
|
||||
} finally {
|
||||
clearTimeout(timer)
|
||||
options.signal?.removeEventListener('abort', abortFromCaller)
|
||||
}
|
||||
}
|
||||
|
||||
function queryString(params: Record<string, string | number | undefined>): string {
|
||||
const query = Object.entries(params)
|
||||
.filter((entry): entry is [string, string | number] => entry[1] !== undefined)
|
||||
.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
|
||||
.join('&')
|
||||
return query.length === 0 ? '' : `?${query}`
|
||||
}
|
||||
|
||||
function validatedPage(page: number, limit: number): void {
|
||||
if (!Number.isSafeInteger(page) || page < 1 || page > 1_000_000) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
}
|
||||
|
||||
function parsePageEnvelope<T>(
|
||||
payload: unknown,
|
||||
listKey: string,
|
||||
parseEntry: (value: unknown) => T,
|
||||
): AdminPage<T> {
|
||||
const body = recordValue(payload)
|
||||
assertOnlyKeys(body, [listKey, 'total', 'page', 'limit'])
|
||||
if (!Array.isArray(body[listKey])) throw invalidResponse()
|
||||
return {
|
||||
entries: body[listKey].map(parseEntry),
|
||||
total: nonNegativeInteger(body.total, 1_000_000_000),
|
||||
page: positiveInteger(body.page, 1_000_000),
|
||||
limit: positiveInteger(body.limit, 100),
|
||||
}
|
||||
}
|
||||
|
||||
export function currentAdminRole(metadata: unknown): CurrentAdminRole | null {
|
||||
if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) return null
|
||||
const candidate = (metadata as Record<string, unknown>).role
|
||||
return candidate === 'manager' || candidate === 'admin' || candidate === 'super_admin'
|
||||
? candidate
|
||||
: null
|
||||
}
|
||||
|
||||
export async function listAdminUsers(options: {
|
||||
accessToken: string
|
||||
page?: number
|
||||
limit?: number
|
||||
search?: string
|
||||
role?: AdminRole
|
||||
signal?: AbortSignal
|
||||
}): Promise<AdminPage<AdminProfileSummary>> {
|
||||
const page = options.page ?? 1
|
||||
const limit = options.limit ?? 20
|
||||
validatedPage(page, limit)
|
||||
const search = options.search?.trim()
|
||||
if (search !== undefined && (search.length < 1 || search.length > 100)) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
if (options.role !== undefined && !ROLE_SET.has(options.role)) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
const payload = await requestAdmin(`admin-users${queryString({ page, limit, search, role: options.role })}`, {
|
||||
accessToken: options.accessToken,
|
||||
signal: options.signal,
|
||||
})
|
||||
return parsePageEnvelope(payload, 'profiles', parseProfileSummary)
|
||||
}
|
||||
|
||||
export async function getAdminUser(
|
||||
accessToken: string,
|
||||
userId: string,
|
||||
signal?: AbortSignal,
|
||||
): Promise<AdminUserDetail> {
|
||||
if (!UUID_PATTERN.test(userId)) throw new AdminServiceError('validation', null, false)
|
||||
const payload = await requestAdmin(`admin-users${queryString({ userId })}`, { accessToken, signal })
|
||||
const body = recordValue(payload)
|
||||
assertOnlyKeys(body, ['profile', 'subscription', 'account'])
|
||||
const profile = parseProfileDetail(body.profile)
|
||||
const account = parseAccount(body.account)
|
||||
const subscription = body.subscription === null ? null : parseSubscription(body.subscription)
|
||||
if (profile.id !== userId.toLowerCase() || account.id !== profile.id ||
|
||||
(subscription !== null && subscription.userId !== profile.id)) throw invalidResponse()
|
||||
return { profile, account, subscription }
|
||||
}
|
||||
|
||||
export async function listAdminSubscriptions(options: {
|
||||
accessToken: string
|
||||
page?: number
|
||||
limit?: number
|
||||
tier?: AdminTier
|
||||
status?: AdminSubscriptionStatus
|
||||
signal?: AbortSignal
|
||||
}): Promise<AdminPage<AdminSubscription>> {
|
||||
const page = options.page ?? 1
|
||||
const limit = options.limit ?? 20
|
||||
validatedPage(page, limit)
|
||||
if (options.tier !== undefined && !TIER_SET.has(options.tier)) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
if (options.status !== undefined && !STATUS_SET.has(options.status)) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
const payload = await requestAdmin(`admin-subscriptions${queryString({
|
||||
page,
|
||||
limit,
|
||||
tier: options.tier,
|
||||
status: options.status,
|
||||
})}`, { accessToken: options.accessToken, signal: options.signal })
|
||||
return parsePageEnvelope(payload, 'subscriptions', parseSubscriptionListRow)
|
||||
}
|
||||
|
||||
export async function listAdminAudit(options: {
|
||||
accessToken: string
|
||||
page?: number
|
||||
limit?: number
|
||||
targetType?: 'profile' | 'subscription'
|
||||
targetId?: string
|
||||
signal?: AbortSignal
|
||||
}): Promise<AdminPage<AdminAuditEntry>> {
|
||||
const page = options.page ?? 1
|
||||
const limit = options.limit ?? 20
|
||||
validatedPage(page, limit)
|
||||
if (options.targetId !== undefined && !UUID_PATTERN.test(options.targetId)) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
const payload = await requestAdmin(`admin-audit-log${queryString({
|
||||
page,
|
||||
limit,
|
||||
target_type: options.targetType,
|
||||
target_id: options.targetId,
|
||||
})}`, { accessToken: options.accessToken, signal: options.signal })
|
||||
return parsePageEnvelope(payload, 'logs', (value) => parseAudit(value, true))
|
||||
}
|
||||
|
||||
export async function getAdminPaymentHistory(
|
||||
accessToken: string,
|
||||
userId: string,
|
||||
signal?: AbortSignal,
|
||||
): Promise<AdminPaymentHistory> {
|
||||
if (!UUID_PATTERN.test(userId)) throw new AdminServiceError('validation', null, false)
|
||||
const payload = await requestAdmin(`admin-payments${queryString({ userId, source: 'db' })}`, {
|
||||
accessToken,
|
||||
signal,
|
||||
})
|
||||
const body = recordValue(payload)
|
||||
assertOnlyKeys(body, [
|
||||
'subscription', 'auditLogs', 'providerEvents', 'providerOperations',
|
||||
'liveProviderHistoryAvailable',
|
||||
])
|
||||
if (!Array.isArray(body.auditLogs) || !Array.isArray(body.providerEvents) ||
|
||||
!Array.isArray(body.providerOperations) || body.liveProviderHistoryAvailable !== false) {
|
||||
throw invalidResponse()
|
||||
}
|
||||
const subscription = body.subscription === null ? null : parseSubscription(body.subscription)
|
||||
if (subscription !== null && subscription.userId !== userId.toLowerCase()) throw invalidResponse()
|
||||
return {
|
||||
subscription,
|
||||
auditLogs: body.auditLogs.map(parsePaymentAudit),
|
||||
providerEvents: body.providerEvents.map(parseProviderEvent),
|
||||
providerOperations: body.providerOperations.map(parseProviderOperation),
|
||||
liveProviderHistoryAvailable: false,
|
||||
}
|
||||
}
|
||||
|
||||
function validatedIdempotencyKey(value: string): string {
|
||||
if (!UUID_PATTERN.test(value)) throw new AdminServiceError('validation', null, false)
|
||||
return value.toLowerCase()
|
||||
}
|
||||
|
||||
function validatedMemo(value: string): string {
|
||||
const memo = value.trim()
|
||||
if (memo.length < 3 || memo.length > 1000) throw new AdminServiceError('validation', null, false)
|
||||
return memo
|
||||
}
|
||||
|
||||
export async function changeAdminUserRole(options: {
|
||||
accessToken: string
|
||||
idempotencyKey: string
|
||||
userId: string
|
||||
newRole: AdminRole
|
||||
memo: string
|
||||
signal?: AbortSignal
|
||||
}): Promise<{ userId: string; newRole: AdminRole }> {
|
||||
if (!UUID_PATTERN.test(options.userId) || !ROLE_SET.has(options.newRole)) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
const idempotencyKey = validatedIdempotencyKey(options.idempotencyKey)
|
||||
const payload = await requestAdmin('admin-users', {
|
||||
accessToken: options.accessToken,
|
||||
method: 'PATCH',
|
||||
idempotencyKey,
|
||||
body: {
|
||||
userId: options.userId.toLowerCase(),
|
||||
newRole: options.newRole,
|
||||
memo: validatedMemo(options.memo),
|
||||
},
|
||||
signal: options.signal,
|
||||
})
|
||||
const body = recordValue(payload)
|
||||
assertOnlyKeys(body, ['success', 'userId', 'newRole'])
|
||||
if (body.success !== true || uuid(body.userId) !== options.userId.toLowerCase() ||
|
||||
role(body.newRole) !== options.newRole) throw invalidResponse()
|
||||
return { userId: options.userId.toLowerCase(), newRole: options.newRole }
|
||||
}
|
||||
|
||||
export type AdminSubscriptionMutation = {
|
||||
tier?: AdminTier
|
||||
status?: AdminSubscriptionStatus
|
||||
currentPeriodEnd?: string
|
||||
overageCredits?: number
|
||||
adminNote?: string
|
||||
memo: string
|
||||
}
|
||||
|
||||
function normalizedSubscriptionMutation(value: AdminSubscriptionMutation): Record<string, unknown> {
|
||||
const body: Record<string, unknown> = { memo: validatedMemo(value.memo) }
|
||||
if (value.tier !== undefined) {
|
||||
if (!TIER_SET.has(value.tier)) throw new AdminServiceError('validation', null, false)
|
||||
body.tier = value.tier
|
||||
}
|
||||
if (value.status !== undefined) {
|
||||
if (!STATUS_SET.has(value.status)) throw new AdminServiceError('validation', null, false)
|
||||
body.status = value.status
|
||||
}
|
||||
if (value.currentPeriodEnd !== undefined) {
|
||||
if (!Number.isFinite(Date.parse(value.currentPeriodEnd))) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
body.currentPeriodEnd = new Date(Date.parse(value.currentPeriodEnd)).toISOString()
|
||||
}
|
||||
if (value.overageCredits !== undefined) {
|
||||
if (!Number.isSafeInteger(value.overageCredits) || value.overageCredits < 0 || value.overageCredits > 1_000_000) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
body.overageCredits = value.overageCredits
|
||||
}
|
||||
if (value.adminNote !== undefined) {
|
||||
if (value.adminNote.length > 2000) throw new AdminServiceError('validation', null, false)
|
||||
body.adminNote = value.adminNote
|
||||
}
|
||||
return body
|
||||
}
|
||||
|
||||
async function mutateAdminSubscription(
|
||||
action: 'create' | 'update' | 'delete',
|
||||
options: {
|
||||
accessToken: string
|
||||
idempotencyKey: string
|
||||
userId: string
|
||||
mutation: AdminSubscriptionMutation
|
||||
signal?: AbortSignal
|
||||
},
|
||||
): Promise<AdminSubscription> {
|
||||
if (!UUID_PATTERN.test(options.userId)) throw new AdminServiceError('validation', null, false)
|
||||
const idempotencyKey = validatedIdempotencyKey(options.idempotencyKey)
|
||||
const body = action === 'delete'
|
||||
? { memo: validatedMemo(options.mutation.memo) }
|
||||
: normalizedSubscriptionMutation(options.mutation)
|
||||
if (action === 'create') body.userId = options.userId.toLowerCase()
|
||||
if (action === 'create' && body.tier === undefined) {
|
||||
throw new AdminServiceError('validation', null, false)
|
||||
}
|
||||
const path = action === 'create'
|
||||
? 'admin-subscriptions'
|
||||
: `admin-subscriptions${queryString({ userId: options.userId.toLowerCase() })}`
|
||||
const payload = await requestAdmin(path, {
|
||||
accessToken: options.accessToken,
|
||||
method: action === 'create' ? 'POST' : action === 'update' ? 'PATCH' : 'DELETE',
|
||||
idempotencyKey,
|
||||
body,
|
||||
signal: options.signal,
|
||||
})
|
||||
const response = recordValue(payload)
|
||||
assertOnlyKeys(response, ['success', 'subscription'])
|
||||
if (response.success !== true) throw invalidResponse()
|
||||
const subscription = parseSubscription(response.subscription)
|
||||
if (subscription.userId !== options.userId.toLowerCase()) throw invalidResponse()
|
||||
return subscription
|
||||
}
|
||||
|
||||
export function createAdminSubscription(options: {
|
||||
accessToken: string
|
||||
idempotencyKey: string
|
||||
userId: string
|
||||
mutation: AdminSubscriptionMutation & { tier: AdminTier }
|
||||
signal?: AbortSignal
|
||||
}): Promise<AdminSubscription> {
|
||||
return mutateAdminSubscription('create', options)
|
||||
}
|
||||
|
||||
export function updateAdminSubscription(options: {
|
||||
accessToken: string
|
||||
idempotencyKey: string
|
||||
userId: string
|
||||
mutation: AdminSubscriptionMutation
|
||||
signal?: AbortSignal
|
||||
}): Promise<AdminSubscription> {
|
||||
return mutateAdminSubscription('update', options)
|
||||
}
|
||||
|
||||
export function deleteAdminSubscription(options: {
|
||||
accessToken: string
|
||||
idempotencyKey: string
|
||||
userId: string
|
||||
memo: string
|
||||
signal?: AbortSignal
|
||||
}): Promise<AdminSubscription> {
|
||||
return mutateAdminSubscription('delete', {
|
||||
...options,
|
||||
mutation: { memo: options.memo },
|
||||
})
|
||||
}
|
||||
15
apps/mobile-rn/src/features/admin/admin-session.ts
Normal file
15
apps/mobile-rn/src/features/admin/admin-session.ts
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
import { supabase } from '../../lib/supabase'
|
||||
import { AdminServiceError } from './admin-service'
|
||||
|
||||
export async function requireAdminAccessToken(expectedUserId: string): Promise<string> {
|
||||
const { data, error } = await supabase.auth.getSession()
|
||||
const session = data.session
|
||||
if (error !== null || session === null || session.user.id !== expectedUserId) {
|
||||
throw new AdminServiceError('auth', null, false)
|
||||
}
|
||||
const token = session.access_token.trim()
|
||||
if (token.length < 20 || token.length > 16_384 || /\s/.test(token)) {
|
||||
throw new AdminServiceError('auth', null, false)
|
||||
}
|
||||
return token
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue