feat(release): prepare 1.1.0 candidate

server/supabase/functions/google-play-rtdn/index.ts

@@ -0,0 +1,198 @@
+import { createServiceRoleClient } from '../_shared/quota.ts'
+import {
+  acknowledgeGooglePlaySubscription,
+  fetchGooglePlaySubscription,
+  GOOGLE_PLAY_PRODUCT_TIERS,
+  GooglePlayVerificationError,
+  sha256Hex,
+  verifyGooglePlaySubscription,
+  verifyGooglePlaySubscriptionPayload,
+  type NormalizedGooglePlayPurchase,
+} from '../_shared/google-play.ts'
+import {
+  GooglePubSubError,
+  parseGooglePlayRtdn,
+  verifyGooglePubSubIdentity,
+} from '../_shared/google-pubsub.ts'
+
+function jsonResponse(body: Record<string, unknown>, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  })
+}
+
+Deno.serve(async (req: Request) => {
+  if (req.method !== 'POST') return jsonResponse({ error: 'method_not_allowed' }, 405)
+
+  let eventId: string | null = null
+  const serviceClient = createServiceRoleClient()
+  try {
+    await verifyGooglePubSubIdentity(req)
+    const notification = parseGooglePlayRtdn(await req.json())
+    if (notification.kind === 'test') {
+      return jsonResponse({ success: true, test: true })
+    }
+
+    const currentTokenHash = await sha256Hex(notification.purchaseToken)
+    const { data: knownPurchase, error: purchaseError } = await serviceClient
+      .from('iap_purchases')
+      .select('user_id, product_id')
+      .eq('platform', 'google_play')
+      .eq('token_hash', currentTokenHash)
+      .maybeSingle()
+    if (purchaseError) throw new Error('purchase_lookup_failed')
+
+    let purchaseRecord = knownPurchase as { user_id?: unknown; product_id?: unknown } | null
+    let preverifiedPurchase: NormalizedGooglePlayPurchase | null = null
+
+    // Google Play subscriptions-center re-subscriptions can notify the server
+    // before the app has registered the new token. Map those only through the
+    // prior token that our database already owns; never guess a user.
+    if (!purchaseRecord) {
+      const verification = await fetchGooglePlaySubscription(notification.purchaseToken)
+      const recognizedItems = (verification.lineItems ?? []).filter((item) => (
+        typeof item.productId === 'string'
+        && GOOGLE_PLAY_PRODUCT_TIERS[item.productId] !== undefined
+      ))
+      const expiredToken = verification.outOfAppPurchaseContext?.expiredPurchaseToken
+      if (
+        recognizedItems.length !== 1
+        || typeof expiredToken !== 'string'
+        || expiredToken.length < 8
+        || expiredToken.length > 4096
+      ) {
+        throw new GooglePubSubError('purchase_not_registered', 503)
+      }
+
+      const { data: previousPurchase, error: previousError } = await serviceClient
+        .from('iap_purchases')
+        .select('user_id')
+        .eq('platform', 'google_play')
+        .eq('token_hash', await sha256Hex(expiredToken))
+        .maybeSingle()
+      if (previousError) throw new Error('previous_purchase_lookup_failed')
+      const previous = previousPurchase as { user_id?: unknown } | null
+      if (typeof previous?.user_id !== 'string') {
+        throw new GooglePubSubError('purchase_not_registered', 503)
+      }
+
+      purchaseRecord = {
+        user_id: previous.user_id,
+        product_id: recognizedItems[0].productId,
+      }
+      preverifiedPurchase = await verifyGooglePlaySubscriptionPayload(
+        previous.user_id,
+        recognizedItems[0].productId as string,
+        verification,
+        (candidate) => Promise.resolve(candidate === expiredToken),
+      )
+    }
+
+    if (typeof purchaseRecord.user_id !== 'string' || typeof purchaseRecord.product_id !== 'string') {
+      throw new Error('purchase_lookup_failed')
+    }
+
+    const ownsExpiredPurchaseToken = async (expiredToken: string): Promise<boolean> => {
+      const { data: prior, error: priorError } = await serviceClient
+        .from('iap_purchases')
+        .select('id')
+        .eq('platform', 'google_play')
+        .eq('user_id', purchaseRecord.user_id as string)
+        .eq('token_hash', await sha256Hex(expiredToken))
+        .maybeSingle()
+      if (priorError) throw new Error('previous_purchase_lookup_failed')
+      return prior !== null
+    }
+
+    const { data: insertedEvent, error: insertError } = await serviceClient
+      .from('store_notification_events')
+      .insert({
+        platform: 'google_play',
+        message_id: notification.messageId,
+        event_type: `subscription:${notification.notificationType}`,
+      })
+      .select('id')
+      .single()
+    if (insertError) {
+      if (insertError.code !== '23505') throw new Error('notification_insert_failed')
+      const { data: existingEvent, error: existingError } = await serviceClient
+        .from('store_notification_events')
+        .select('id, processed_at')
+        .eq('platform', 'google_play')
+        .eq('message_id', notification.messageId)
+        .single()
+      if (existingError || !existingEvent) throw new Error('notification_lookup_failed')
+      const existingRecord = existingEvent as { id?: unknown; processed_at?: unknown }
+      if (existingRecord.processed_at) return jsonResponse({ success: true, duplicate: true })
+      if (typeof existingRecord.id !== 'string') throw new Error('notification_lookup_failed')
+      eventId = existingRecord.id
+    } else {
+      const insertedRecord = insertedEvent as { id?: unknown }
+      if (typeof insertedRecord.id !== 'string') throw new Error('notification_insert_failed')
+      eventId = insertedRecord.id
+    }
+
+    let purchase = preverifiedPurchase ?? await verifyGooglePlaySubscription(
+      purchaseRecord.user_id,
+      purchaseRecord.product_id,
+      notification.purchaseToken,
+      fetch,
+      ownsExpiredPurchaseToken,
+    )
+    if (purchase.entitled && !purchase.acknowledged) {
+      await acknowledgeGooglePlaySubscription(purchase.productId, notification.purchaseToken)
+      purchase = {
+        ...purchase,
+        acknowledged: true,
+        verification: {
+          ...purchase.verification,
+          acknowledgementState: 'ACKNOWLEDGEMENT_STATE_ACKNOWLEDGED',
+        },
+      }
+    }
+    const { error: applyError } = await serviceClient.rpc('apply_verified_google_play_purchase', {
+      p_user_id: purchaseRecord.user_id,
+      p_platform: purchase.platform,
+      p_product_id: purchase.productId,
+      p_store_transaction_id: purchase.storeTransactionId,
+      p_token_hash: currentTokenHash,
+      p_linked_token_hash: purchase.linkedPurchaseToken
+        ? await sha256Hex(purchase.linkedPurchaseToken)
+        : null,
+      p_purchase_token: notification.purchaseToken,
+      p_purchase_state: purchase.purchaseState,
+      p_purchase_at: purchase.purchaseAt,
+      p_expires_at: purchase.expiresAt,
+      p_auto_renewing: purchase.autoRenewing,
+      p_acknowledged: purchase.acknowledged,
+      p_tier: purchase.tier,
+      p_entitled: purchase.entitled,
+      p_verification: purchase.verification,
+    })
+    if (applyError) throw new Error('purchase_persistence_failed')
+    if (!eventId) throw new Error('notification_lookup_failed')
+
+    const { error: completeError } = await serviceClient
+      .from('store_notification_events')
+      .update({ processed_at: new Date().toISOString(), processing_error: null })
+      .eq('id', eventId)
+    if (completeError) throw new Error('notification_completion_failed')
+    return jsonResponse({ success: true })
+  } catch (error) {
+    if (eventId) {
+      const errorCode = error instanceof GooglePlayVerificationError
+        || error instanceof GooglePubSubError
+        ? error.code
+        : 'notification_processing_failed'
+      await serviceClient
+        .from('store_notification_events')
+        .update({ processing_error: errorCode })
+        .eq('id', eventId)
+    }
+    if (error instanceof GooglePubSubError || error instanceof GooglePlayVerificationError) {
+      return jsonResponse({ error: error.code }, error.status)
+    }
+    return jsonResponse({ error: 'notification_processing_failed' }, 500)
+  }
+})