chore: create new notification plan

2025-09-04 13:09:00 +00:00
parent de45e83ffb
commit 5110c17fba
1 changed files with 603 additions and 0 deletions
--- a/doc/notification-system-implementation-plan.md
+++ b/doc/notification-system-implementation-plan.md
@@ -0,0 +1,603 @@
+# TimeSafari Notification System — Feature-First Execution Pack
+
+**Author**: Matthew Raymer  
+**Date**: 2025-01-27T15:00Z (UTC)  
+**Status**: 🚀 **ACTIVE** - Surgical PR implementation for Capacitor platforms
+
+## What we'll ship (v1 in-app)
+
+- Multi-daily **one-shot local notifications** (rolling window)
+- **Online-first** (ETag, 10–15s timeout) with **offline-first** fallback
+- **SQLite** persistence + **14-day** retention
+- **Templating**: `{title, body}` with `{{var}}`
+- **Event queue**: delivery/error/heartbeat (drained on foreground)
+- Same TS API that we can swap to native (v2) later
+
+---
+
+## Minimal PR layout
+
+```
+/src/services/notifs/
+  types.ts
+  NotificationOrchestrator.ts
+  adapters/
+    DataStoreSqlite.ts
+    SchedulerCapacitor.ts
+    CallbacksHttp.ts
+/migrations/
+  00XX_notifs.sql
+/sw_scripts/
+  notification-click.js   # (or merge into sw_scripts-combined.js)
+/app/bootstrap/
+  notifications.ts        # init + feature flags
+```
+
+---
+
+## Changes (surgical)
+
+### 1) Dependencies
+
+```bash
+npm i @capacitor/local-notifications
+npx cap sync
+```
+
+### 2) Capacitor setup
+
+```typescript
+// capacitor.config.ts
+plugins: {
+  LocalNotifications: {
+    smallIcon: 'ic_stat_name',
+    iconColor: '#4a90e2'
+  }
+}
+```
+
+### 3) Android channel + iOS category (once at app start)
+
+```typescript
+import { LocalNotifications } from '@capacitor/local-notifications';
+
+export async function initNotifChannels() {
+  await LocalNotifications.createChannel({
+    id: 'timesafari.daily',
+    name: 'TimeSafari Daily',
+    description: 'Daily briefings',
+    importance: 4, // high
+  });
+
+  await LocalNotifications.registerActionTypes({
+    types: [{
+      id: 'TS_DAILY',
+      actions: [{ id: 'OPEN', title: 'Open' }]
+    }]
+  });
+}
+```
+
+### 4) SQLite migration
+
+```sql
+-- /migrations/00XX_notifs.sql
+CREATE TABLE IF NOT EXISTS notif_contents(
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  slot_id TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  fetched_at INTEGER NOT NULL,
+  etag TEXT,
+  UNIQUE(slot_id, fetched_at)
+);
+
+CREATE INDEX IF NOT EXISTS notif_idx_contents_slot_time
+  ON notif_contents(slot_id, fetched_at DESC);
+
+CREATE TABLE IF NOT EXISTS notif_deliveries(
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  slot_id TEXT NOT NULL,
+  fire_at INTEGER NOT NULL,
+  delivered_at INTEGER,
+  status TEXT NOT NULL,
+  error_code TEXT,
+  error_message TEXT
+);
+
+CREATE TABLE IF NOT EXISTS notif_config(
+  k TEXT PRIMARY KEY,
+  v TEXT NOT NULL
+);
+```
+
+*Retention job (daily):*
+
+```sql
+DELETE FROM notif_contents
+WHERE fetched_at < strftime('%s','now','-14 days');
+
+DELETE FROM notif_deliveries
+WHERE fire_at < strftime('%s','now','-14 days');
+```
+
+### 5) Types (shared API)
+
+```typescript
+// src/services/notifs/types.ts
+export type NotificationTime = { hour: number; minute: number };
+export type SlotId = string;
+
+export type FetchSpec = {
+  method: 'GET'|'POST';
+  url: string;
+  headers?: Record<string,string>;
+  bodyJson?: Record<string,unknown>;
+  timeoutMs?: number;
+};
+
+export type CallbackProfile = {
+  fetchContent: FetchSpec;
+  ackDelivery?: Omit<FetchSpec,'bodyJson'|'timeoutMs'>;
+  reportError?: Omit<FetchSpec,'bodyJson'|'timeoutMs'>;
+  heartbeat?: Omit<FetchSpec,'bodyJson'> & { intervalMinutes?: number };
+};
+
+export type ConfigureOptions = {
+  times: NotificationTime[];
+  ttlSeconds?: number;
+  prefetchLeadMinutes?: number;
+  storage: 'shared'|'plugin';
+  dbPath?: string;
+  contentTemplate?: { title: string; body: string };
+  callbackProfile?: CallbackProfile;
+};
+
+export interface DataStore {
+  saveContent(slotId: SlotId, payload: unknown, etag?: string): Promise<void>;
+  getLatestContent(slotId: SlotId): Promise<{
+    payload: unknown;
+    fetchedAt: number;
+    etag?: string
+  }|null>;
+  recordDelivery(
+    slotId: SlotId,
+    fireAt: number,
+    status: 'scheduled'|'shown'|'error',
+    error?: { code?: string; message?: string }
+  ): Promise<void>;
+  enqueueEvent(e: unknown): Promise<void>;
+  drainEvents(): Promise<unknown[]>;
+}
+
+export interface Scheduler {
+  capabilities(): Promise<{ exactAlarms: boolean; maxPending?: number }>;
+  scheduleExact(slotId: SlotId, whenMs: number, payloadRef: string): Promise<void>;
+  scheduleWindow(
+    slotId: SlotId,
+    windowStartMs: number,
+    windowLenMs: number,
+    payloadRef: string
+  ): Promise<void>;
+  cancelBySlot(slotId: SlotId): Promise<void>;
+  rescheduleAll(next: Array<{ slotId: SlotId; whenMs: number }>): Promise<void>;
+}
+```
+
+### 6) Adapters (thin)
+
+```typescript
+// src/services/notifs/adapters/DataStoreSqlite.ts
+import type { DataStore, SlotId } from '../types';
+import { PlatformServiceMixin } from '@/utils/PlatformServiceMixin';
+
+export class DataStoreSqlite implements DataStore {
+  constructor(private platformService: PlatformServiceMixin) {}
+
+  async saveContent(slotId: SlotId, payload: unknown, etag?: string): Promise<void> {
+    const fetchedAt = Date.now();
+    const payloadJson = JSON.stringify(payload);
+    
+    await this.platformService.$exec(
+      `INSERT OR REPLACE INTO notif_contents (slot_id, payload_json, fetched_at, etag)
+       VALUES (?, ?, ?, ?)`,
+      [slotId, payloadJson, fetchedAt, etag]
+    );
+  }
+
+  async getLatestContent(slotId: SlotId): Promise<{
+    payload: unknown;
+    fetchedAt: number;
+    etag?: string
+  }|null> {
+    const result = await this.platformService.$db(
+      `SELECT payload_json, fetched_at, etag
+       FROM notif_contents
+       WHERE slot_id = ?
+       ORDER BY fetched_at DESC
+       LIMIT 1`,
+      [slotId]
+    );
+
+    if (!result || result.length === 0) {
+      return null;
+    }
+
+    const row = result[0];
+    return {
+      payload: JSON.parse(row.payload_json),
+      fetchedAt: row.fetched_at,
+      etag: row.etag
+    };
+  }
+
+  async recordDelivery(
+    slotId: SlotId,
+    fireAt: number,
+    status: 'scheduled'|'shown'|'error',
+    error?: { code?: string; message?: string }
+  ): Promise<void> {
+    const deliveredAt = status === 'shown' ? Date.now() : null;
+    
+    await this.platformService.$exec(
+      `INSERT INTO notif_deliveries (slot_id, fire_at, delivered_at, status, error_code, error_message)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [slotId, fireAt, deliveredAt, status, error?.code, error?.message]
+    );
+  }
+
+  async enqueueEvent(e: unknown): Promise<void> {
+    // Simple in-memory queue for now, can be enhanced with SQLite
+    // This will be drained when app comes to foreground
+  }
+
+  async drainEvents(): Promise<unknown[]> {
+    // Return and clear queued events
+    return [];
+  }
+}
+
+// src/services/notifs/adapters/SchedulerCapacitor.ts
+import { LocalNotifications } from '@capacitor/local-notifications';
+import type { Scheduler, SlotId } from '../types';
+
+export class SchedulerCapacitor implements Scheduler {
+  async capabilities(): Promise<{ exactAlarms: boolean; maxPending?: number }> {
+    // iOS: ~64 pending notifications
+    // Android: depends on exact alarm permissions
+    return {
+      exactAlarms: true, // Assume we have permissions
+      maxPending: 64
+    };
+  }
+
+  async scheduleExact(slotId: SlotId, whenMs: number, payloadRef: string): Promise<void> {
+    await LocalNotifications.schedule({
+      notifications: [{
+        id: this.generateNotificationId(slotId),
+        title: 'TimeSafari',
+        body: 'Your daily update is ready',
+        schedule: { at: new Date(whenMs) },
+        extra: { slotId, payloadRef }
+      }]
+    });
+  }
+
+  async scheduleWindow(
+    slotId: SlotId,
+    windowStartMs: number,
+    windowLenMs: number,
+    payloadRef: string
+  ): Promise<void> {
+    // For platforms that don't support exact alarms
+    await LocalNotifications.schedule({
+      notifications: [{
+        id: this.generateNotificationId(slotId),
+        title: 'TimeSafari',
+        body: 'Your daily update is ready',
+        schedule: {
+          at: new Date(windowStartMs),
+          repeats: false
+        },
+        extra: { slotId, payloadRef }
+      }]
+    });
+  }
+
+  async cancelBySlot(slotId: SlotId): Promise<void> {
+    const id = this.generateNotificationId(slotId);
+    await LocalNotifications.cancel({ notifications: [{ id }] });
+  }
+
+  async rescheduleAll(next: Array<{ slotId: SlotId; whenMs: number }>): Promise<void> {
+    // Cancel all existing notifications
+    await LocalNotifications.cancel({ notifications: [] });
+    
+    // Schedule new ones
+    const notifications = next.map(({ slotId, whenMs }) => ({
+      id: this.generateNotificationId(slotId),
+      title: 'TimeSafari',
+      body: 'Your daily update is ready',
+      schedule: { at: new Date(whenMs) },
+      extra: { slotId }
+    }));
+
+    await LocalNotifications.schedule({ notifications });
+  }
+
+  private generateNotificationId(slotId: SlotId): number {
+    // Simple hash of slotId to generate unique notification ID
+    let hash = 0;
+    for (let i = 0; i < slotId.length; i++) {
+      const char = slotId.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash);
+  }
+}
+```
+
+### 7) Orchestrator (lean core)
+
+```typescript
+// src/services/notifs/NotificationOrchestrator.ts
+import type { ConfigureOptions, SlotId, DataStore, Scheduler } from './types';
+import { logger } from '@/utils/logger';
+
+export class NotificationOrchestrator {
+  constructor(private store: DataStore, private sched: Scheduler) {}
+
+  private opts!: ConfigureOptions;
+
+  async configure(o: ConfigureOptions): Promise<void> {
+    this.opts = o;
+    
+    // Persist configuration to SQLite
+    await this.store.enqueueEvent({
+      type: 'config_updated',
+      config: o,
+      timestamp: Date.now()
+    });
+  }
+
+  async runFullPipelineNow(): Promise<void> {
+    try {
+      // 1) For each upcoming slot, attempt online-first fetch
+      const upcomingSlots = this.getUpcomingSlots();
+      
+      for (const slot of upcomingSlots) {
+        await this.fetchAndScheduleSlot(slot);
+      }
+      
+      logger.log('[NotificationOrchestrator] Full pipeline completed');
+    } catch (error) {
+      logger.error('[NotificationOrchestrator] Pipeline failed:', error);
+      throw error;
+    }
+  }
+
+  async deliverStoredNow(slotId?: SlotId): Promise<void> {
+    const targetSlots = slotId ? [slotId] : this.getUpcomingSlots();
+    
+    for (const slot of targetSlots) {
+      const content = await this.store.getLatestContent(slot);
+      if (content) {
+        const payloadRef = this.createPayloadRef(content.payload);
+        await this.sched.scheduleExact(slot, Date.now() + 5000, payloadRef);
+      }
+    }
+  }
+
+  async reschedule(): Promise<void> {
+    const nextOccurrences = this.getUpcomingSlots().map(slotId => ({
+      slotId,
+      whenMs: this.getNextSlotTime(slotId)
+    }));
+    
+    await this.sched.rescheduleAll(nextOccurrences);
+  }
+
+  async getState(): Promise<{
+    pendingCount: number;
+    nextOccurrences: Array<{slotId: string; when: string}>
+  }> {
+    const capabilities = await this.sched.capabilities();
+    const upcomingSlots = this.getUpcomingSlots();
+    
+    return {
+      pendingCount: Math.min(upcomingSlots.length, capabilities.maxPending || 64),
+      nextOccurrences: upcomingSlots.map(slotId => ({
+        slotId,
+        when: new Date(this.getNextSlotTime(slotId)).toISOString()
+      }))
+    };
+  }
+
+  private async fetchAndScheduleSlot(slotId: SlotId): Promise<void> {
+    try {
+      // Attempt online-first fetch
+      if (this.opts.callbackProfile?.fetchContent) {
+        const content = await this.fetchContent(slotId);
+        if (content) {
+          await this.store.saveContent(slotId, content.payload, content.etag);
+          await this.scheduleSlot(slotId, content.payload);
+          return;
+        }
+      }
+      
+      // Fallback to offline-first
+      const storedContent = await this.store.getLatestContent(slotId);
+      if (storedContent && this.isWithinTTL(storedContent.fetchedAt)) {
+        await this.scheduleSlot(slotId, storedContent.payload);
+      }
+    } catch (error) {
+      logger.error(`[NotificationOrchestrator] Failed to fetch/schedule ${slotId}:`, error);
+      await this.store.recordDelivery(slotId, Date.now(), 'error', {
+        code: 'fetch_failed',
+        message: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  }
+
+  private async fetchContent(slotId: SlotId): Promise<{
+    payload: unknown;
+    etag?: string
+  }|null> {
+    const spec = this.opts.callbackProfile!.fetchContent;
+    const response = await fetch(spec.url, {
+      method: spec.method,
+      headers: spec.headers,
+      body: spec.bodyJson ? JSON.stringify(spec.bodyJson) : undefined,
+      signal: AbortSignal.timeout(spec.timeoutMs || 15000)
+    });
+
+    if (response.status === 304) {
+      return null; // Not modified
+    }
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const payload = await response.json();
+    const etag = response.headers.get('etag') || undefined;
+
+    return { payload, etag };
+  }
+
+  private async scheduleSlot(slotId: SlotId, payload: unknown): Promise<void> {
+    const whenMs = this.getNextSlotTime(slotId);
+    const payloadRef = this.createPayloadRef(payload);
+    
+    await this.sched.scheduleExact(slotId, whenMs, payloadRef);
+    await this.store.recordDelivery(slotId, whenMs, 'scheduled');
+  }
+
+  private getUpcomingSlots(): SlotId[] {
+    const now = new Date();
+    const slots: SlotId[] = [];
+    
+    for (const time of this.opts.times) {
+      const slotId = `slot-${time.hour.toString().padStart(2, '0')}-${time.minute.toString().padStart(2, '0')}`;
+      const nextTime = this.getNextSlotTime(slotId);
+      
+      // Include slots for today and tomorrow (within rolling window)
+      if (nextTime <= now.getTime() + (2 * 24 * 60 * 60 * 1000)) {
+        slots.push(slotId);
+      }
+    }
+    
+    return slots;
+  }
+
+  private getNextSlotTime(slotId: SlotId): number {
+    const [_, hourStr, minuteStr] = slotId.match(/slot-(\d{2})-(\d{2})/) || [];
+    const hour = parseInt(hourStr, 10);
+    const minute = parseInt(minuteStr, 10);
+    
+    const now = new Date();
+    const next = new Date(now);
+    next.setHours(hour, minute, 0, 0);
+    
+    // If time has passed today, schedule for tomorrow
+    if (next <= now) {
+      next.setDate(next.getDate() + 1);
+    }
+    
+    return next.getTime();
+  }
+
+  private createPayloadRef(payload: unknown): string {
+    return `payload-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private isWithinTTL(fetchedAt: number): boolean {
+    const ttlMs = (this.opts.ttlSeconds || 86400) * 1000;
+    return Date.now() - fetchedAt < ttlMs;
+  }
+}
+```
+
+### 8) Bootstrap + feature flags
+
+```typescript
+// /app/bootstrap/notifications.ts
+import { initNotifChannels } from './initNotifChannels';
+import { NotificationOrchestrator } from '@/services/notifs/NotificationOrchestrator';
+import { DataStoreSqlite } from '@/services/notifs/adapters/DataStoreSqlite';
+import { SchedulerCapacitor } from '@/services/notifs/adapters/SchedulerCapacitor';
+import { PlatformServiceMixin } from '@/utils/PlatformServiceMixin';
+import { Capacitor } from '@capacitor/core';
+
+let orchestrator: NotificationOrchestrator | null = null;
+
+export async function initNotifications(): Promise<void> {
+  // Only initialize on Capacitor platforms
+  if (!Capacitor.isNativePlatform()) {
+    return;
+  }
+
+  try {
+    await initNotifChannels();
+    
+    const platformService = new PlatformServiceMixin();
+    const store = new DataStoreSqlite(platformService);
+    const scheduler = new SchedulerCapacitor();
+    
+    orchestrator = new NotificationOrchestrator(store, scheduler);
+    
+    // Run pipeline on app start
+    await orchestrator.runFullPipelineNow();
+    await orchestrator.reschedule();
+    
+    logger.log('[Notifications] Initialized successfully');
+  } catch (error) {
+    logger.error('[Notifications] Initialization failed:', error);
+  }
+}
+
+export function getNotificationOrchestrator(): NotificationOrchestrator | null {
+  return orchestrator;
+}
+```
+
+### 9) Service Worker click handler (web)
+
+```javascript
+// sw_scripts/notification-click.js (or inside combined file)
+self.addEventListener('notificationclick', (event) => {
+  event.notification.close();
+  
+  // Extract slotId from notification data
+  const slotId = event.notification.data?.slotId;
+  
+  // Open appropriate route based on notification type
+  const route = slotId ? '/#/daily' : '/#/notifications';
+  
+  event.waitUntil(
+    clients.openWindow(route).catch(() => {
+      // Fallback if openWindow fails
+      return clients.openWindow('/');
+    })
+  );
+});
+```
+
+---
+
+## Acceptance (v1)
+
+- Locals fire at configured slots with app **killed**
+- Online-first w/ **ETag** + **timeout**; falls back to offline-first (TTL respected)
+- DB retains 14 days; retention job prunes
+- Foreground drains queued events
+- One-line adapter swap path ready for v2
+
+---
+
+## Platform Notes
+
+- **Capacitor Only**: This implementation is designed for iOS/Android via Capacitor
+- **Web Fallback**: Web platform will use existing service worker + push notifications
+- **Electron**: Will need separate implementation using native notification APIs
+- **Feature Flags**: Can be toggled per platform in bootstrap configuration