プッシュ通知を『送るのをやめた』ら離脱率が下がった話 — Rork Max で作るAIチャーン予測通知システムの全設計

// churn-score.ts — チャーンスコア計算ロジック
// スコアが高いほど「離脱リスクが高い」
 
interface UserActivity {
  userId: string;
  lastOpenAt: Date;       // 最後にアプリを開いた日時
  sessionCount7d: number; // 過去7日間のセッション数
  sessionCount30d: number; // 過去30日間のセッション数
  hasPremium: boolean;    // 有料会員かどうか
  notificationsSent: number; // 過去7日間に送った通知数（送りすぎ防止）
  notificationOpened: boolean; // 直近の通知を開いたか
}
 
function calculateChurnScore(user: UserActivity): number {
  let score = 0;
  const now = new Date();
  const daysSinceLastOpen = Math.floor(
    (now.getTime() - user.lastOpenAt.getTime()) / (1000 * 60 * 60 * 24)
  );
 
  // ① 最終接触からの経過日数（最も重要な指標）
  if (daysSinceLastOpen >= 7) score += 40;
  else if (daysSinceLastOpen >= 3) score += 20;
  else if (daysSinceLastOpen >= 1) score += 5;
  else return -1; // 今日使ったユーザーは通知不要、-1 で除外
 
  // ② 週次利用頻度（低いほどリスク高）
  if (user.sessionCount7d === 0) score += 30;
  else if (user.sessionCount7d <= 2) score += 15;
  else if (user.sessionCount7d <= 5) score += 5;
  else score -= 10; // ヘビーユーザーはリスク低
 
  // ③ 月次エンゲージメント推移
  const weeklyAvg = user.sessionCount30d / 4;
  if (user.sessionCount7d < weeklyAvg * 0.5) score += 15; // 先月比50%以下
  else if (user.sessionCount7d < weeklyAvg * 0.7) score += 8;
 
  // ④ 有料会員は離脱コストが高い（=通知効果も高い）
  if (user.hasPremium) score += 10;
 
  // ⑤ 通知の送りすぎ防止（スパム化の検出）
  if (user.notificationsSent >= 3 && !user.notificationOpened) {
    score -= 20; // 3回送って開かなかった → しばらく送らない
  }
 
  return Math.max(0, Math.min(100, score));
}
 
// 判定基準
// 60以上: 高リスク（通知必要）
// 30-59: 中リスク（様子見・1回通知）
// 0-29: 低リスク（通知不要）

-- Supabase SQL Editor で実行
create table user_events (
  id uuid default gen_random_uuid() primary key,
  user_id uuid references auth.users not null,
  event_name text not null,         -- 'app_open', 'feature_used', 'session_end' など
  created_at timestamptz default now(),
  properties jsonb                  -- 追加メタデータ（どの機能を使ったか等）
);
 
-- インデックスはuser_id + created_at の複合が必須（スコア計算でよく使う）
create index idx_user_events_user_created 
  on user_events(user_id, created_at desc);
 
-- RLS: 自分のイベントのみ書き込み可
alter table user_events enable row level security;
 
create policy "users can insert own events"
  on user_events for insert
  with check (auth.uid() = user_id);

// App.tsx または _layout.tsx への追加
import { supabase } from '@/lib/supabase';
import { useEffect } from 'react';
import { AppState } from 'react-native';
 
export function useAppEventTracking() {
  useEffect(() => {
    // アプリがフォアグラウンドに来るたびに記録
    const subscription = AppState.addEventListener('change', async (state) => {
      if (state === 'active') {
        const { data: { user } } = await supabase.auth.getUser();
        if (!user) return;
 
        await supabase.from('user_events').insert({
          user_id: user.id,
          event_name: 'app_open',
          properties: { timestamp: new Date().toISOString() }
        });
      }
    });
 
    return () => subscription.remove();
  }, []);
}

// supabase/functions/calculate-churn-scores/index.ts
// このFunctionはcronで毎日1回呼び出す
 
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2';
import { Anthropic } from 'https://esm.sh/@anthropic-ai/sdk@0.20.0';
 
const supabase = createClient(
  Deno.env.get('SUPABASE_URL')!,
  Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')! // service_roleキーはサーバー側のみ
);
 
const anthropic = new Anthropic({
  apiKey: Deno.env.get('ANTHROPIC_API_KEY')!
});
 
Deno.serve(async (req) => {
  // cronからのリクエストのみ許可
  const authHeader = req.headers.get('Authorization');
  if (authHeader !== `Bearer ${Deno.env.get('CRON_SECRET')}`) {
    return new Response('Unauthorized', { status: 401 });
  }
 
  try {
    // 過去30日間にサインアップしたアクティブユーザーを取得
    const { data: users, error } = await supabase
      .from('profiles')
      .select('id, onesignal_player_id, app_usage_summary')
      .not('onesignal_player_id', 'is', null) // 通知を許可しているユーザーのみ
      .gte('created_at', new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString());
 
    if (error) throw error;
 
    const notifications = [];
 
    for (const user of users ?? []) {
      // 過去7日間のセッション数を集計
      const { count: sessions7d } = await supabase
        .from('user_events')
        .select('*', { count: 'exact', head: true })
        .eq('user_id', user.id)
        .eq('event_name', 'app_open')
        .gte('created_at', new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString());
 
      // 最終アクセス時刻を取得
      const { data: lastEvent } = await supabase
        .from('user_events')
        .select('created_at')
        .eq('user_id', user.id)
        .eq('event_name', 'app_open')
        .order('created_at', { ascending: false })
        .limit(1)
        .single();
 
      if (!lastEvent) continue;
 
      const activity = {
        userId: user.id,
        lastOpenAt: new Date(lastEvent.created_at),
        sessionCount7d: sessions7d ?? 0,
        sessionCount30d: user.app_usage_summary?.sessions30d ?? 0,
        hasPremium: user.app_usage_summary?.has_premium ?? false,
        notificationsSent: user.app_usage_summary?.notifications_sent_7d ?? 0,
        notificationOpened: user.app_usage_summary?.last_notification_opened ?? false,
      };
 
      const score = calculateChurnScore(activity);
      
      // スコア30以上のユーザーのみ通知対象
      if (score >= 30) {
        notifications.push({
          userId: user.id,
          playerId: user.onesignal_player_id,
          score,
          activity,
        });
      }
    }
 
    // スコアが高い順に並べ替えて通知を生成・送信
    notifications.sort((a, b) => b.score - a.score);
    
    let sentCount = 0;
    for (const target of notifications) {
      const message = await generatePersonalizedMessage(target.activity, anthropic);
      await sendNotification(target.playerId, message);
      sentCount++;
      
      // レート制限対策（1日300件まで）
      if (sentCount >= 300) break;
      await new Promise(resolve => setTimeout(resolve, 100)); // 100msスリープ
    }
 
    return new Response(
      JSON.stringify({ processed: notifications.length, sent: sentCount }),
      { headers: { 'Content-Type': 'application/json' } }
    );
  } catch (error) {
    console.error('Churn notification error:', error);
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    );
  }
});

// 通知文を生成する関数
async function generatePersonalizedMessage(
  activity: UserActivity,
  anthropic: Anthropic
): Promise<{ title: string; body: string }> {
  const daysSinceLastOpen = Math.floor(
    (new Date().getTime() - activity.lastOpenAt.getTime()) / (1000 * 60 * 60 * 24)
  );
 
  // ユーザーのコンテキストをClaudeに伝える
  const prompt = `
あなたはフィットネストラッキングアプリのプッシュ通知を書くAIです。
以下のユーザー情報をもとに、自然で温かみのある通知文を作成してください。
 
ユーザー情報:
- 最後にアプリを開いてから: ${daysSinceLastOpen}日
- 先週のセッション数: ${activity.sessionCount7d}回
- 先月の週平均セッション: ${(activity.sessionCount30d / 4).toFixed(1)}回
- プレミアム会員: ${activity.hasPremium ? 'はい' : 'いいえ'}
 
要件:
- タイトルは15文字以内
- 本文は40文字以内
- 絵文字を1〜2個使う
- 「機能を使ってください」のような命令形は避ける
- 継続を責めるのではなく、戻ってきやすい雰囲気を作る
 
JSON形式で出力:
{"title": "...", "body": "..."}
`;
 
  const response = await anthropic.messages.create({
    model: 'claude-haiku-4-5-20251001', // 大量生成には Haiku が最適
    max_tokens: 200,
    messages: [{ role: 'user', content: prompt }]
  });
 
  const content = response.content[0];
  if (content.type !== 'text') {
    // フォールバックメッセージ
    return { title: '久しぶりです 👋', body: 'またいつでも戻ってきてください' };
  }
 
  try {
    return JSON.parse(content.text);
  } catch {
    // JSONパース失敗時のフォールバック
    return { title: '久しぶりです 👋', body: 'またいつでも戻ってきてください' };
  }
}

// OneSignal REST API で通知を送信
async function sendNotification(
  playerId: string,
  message: { title: string; body: string }
): Promise<boolean> {
  const ONESIGNAL_APP_ID = Deno.env.get('ONESIGNAL_APP_ID')!;
  const ONESIGNAL_REST_API_KEY = Deno.env.get('ONESIGNAL_REST_API_KEY')!;
 
  const response = await fetch('https://onesignal.com/api/v1/notifications', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Basic ${ONESIGNAL_REST_API_KEY}`,
    },
    body: JSON.stringify({
      app_id: ONESIGNAL_APP_ID,
      include_player_ids: [playerId],
      headings: { en: message.title, ja: message.title },
      contents: { en: message.body, ja: message.body },
      // チャーン通知専用のデータタグを付ける（効果測定に使う）
      data: { notification_type: 'churn_prevention', sent_at: new Date().toISOString() },
    }),
  });
 
  if (!response.ok) {
    const errorData = await response.json();
    console.error('OneSignal送信エラー:', errorData);
    return false;
  }
 
  return true;
}

create extension if not exists pg_cron;
create extension if not exists pg_net;
 
-- 21:00 UTC ＝ 翌 06:00 JST に1回だけ実行する
select cron.schedule(
  'daily-churn-scoring',
  '0 21 * * *',
  $$
  select net.http_post(
    url := 'https://YOUR_PROJECT_REF.supabase.co/functions/v1/calculate-churn-scores',
    headers := '{"Content-Type":"application/json","Authorization":"Bearer YOUR_CRON_SECRET"}'::jsonb,
    body := '{}'::jsonb
  );
  $$
);

create table if not exists churn_batch_runs (
  run_date      date primary key,
  started_at    timestamptz default now(),
  notified_count integer default 0
);

// Edge Function の冒頭。今日の枠を取れたときだけ先へ進む
const { data: slot } = await supabase
  .from('churn_batch_runs')
  .upsert(
    { run_date: new Date().toISOString().slice(0, 10) },
    { onConflict: 'run_date', ignoreDuplicates: true }
  )
  .select('run_date');
 
if (!slot || slot.length === 0) {
  // 今日の分はすでに別の起動が処理している
  return new Response(JSON.stringify({ skipped: 'already_ran_today' }), { status: 200 });
}

-- 通知済みのユーザーを追跡するカラム
alter table profiles 
  add column last_churn_notification_at timestamptz,
  add column notifications_sent_7d integer default 0;
 
-- Edge Functionで送信後に更新
update profiles 
set last_churn_notification_at = now(),
    notifications_sent_7d = notifications_sent_7d + 1
where id = '...';

function validateNotificationMessage(msg: { title: string; body: string }): boolean {
  if (typeof msg.title !== 'string' || msg.title.length > 50) return false;
  if (typeof msg.body !== 'string' || msg.body.length > 100) return false;
  // 不適切なコンテンツの簡易チェック（必要に応じて強化）
  const forbidden = ['エラー', 'undefined', 'null', '{', '}'];
  if (forbidden.some(word => msg.title.includes(word) || msg.body.includes(word))) return false;
  return true;
}

// A/Bグループ割り当て（user_idのハッシュで安定して振り分ける）
function getNotificationGroup(userId: string): 'treatment' | 'control' {
  const hash = userId.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
  return hash % 2 === 0 ? 'treatment' : 'control';
}