Merge branch 'main' into feat/pii-encryption

Author: Junman140

.github/workflows/deploy.yml

@@ -0,0 +1,52 @@
+name: Deployment Pipeline
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Environment to deploy to'
+        required: true
+        default: 'development'
+        type: choice
+        options:
+          - development
+          - staging
+          - production
+
+jobs:
+  deploy-dev:
+    name: Deploy to Development
+    runs-on: ubuntu-latest
+    environment:
+      name: development
+    steps:
+      - uses: actions/checkout@v3
+      - name: Deploy
+        run: echo "Deploying to development environment..."
+
+  deploy-staging:
+    name: Deploy to Staging
+    needs: deploy-dev
+    runs-on: ubuntu-latest
+    environment:
+      name: staging
+      url: https://staging.subtrackr.app
+    steps:
+      - uses: actions/checkout@v3
+      - name: Deploy
+        run: echo "Deploying to staging environment with manual approval gate..."
+
+  deploy-prod:
+    name: Deploy to Production
+    needs: deploy-staging
+    runs-on: ubuntu-latest
+    environment:
+      name: production
+      url: https://subtrackr.app
+    steps:
+      - uses: actions/checkout@v3
+      - name: Deploy
+        run: echo "Deploying to production environment with strict manual approval gate..."

backend/ml/churnModel.py

@@ -85,6 +85,35 @@ def _get_recommended_action(self, risk_level: str, top_factors: List[Dict]) -> s
         else:
             return "Offer a 1-month free subscription to retain user."
 
+
+class RevenueForecastModel:
+    def forecast(self, observations: List[Dict], horizon: int = 3) -> List[Dict]:
+        values = [float(item.get("revenue", 0)) for item in observations]
+        if not values:
+            return []
+
+        latest = values[-1]
+        deltas = [values[index] - values[index - 1] for index in range(1, len(values))]
+        average_delta = sum(deltas) / len(deltas) if deltas else 0
+        variance = (
+            sum((delta - average_delta) ** 2 for delta in deltas) / len(deltas)
+            if deltas
+            else max(latest * 0.05, 1)
+        )
+        deviation = math.sqrt(variance)
+
+        forecast = []
+        for step in range(1, horizon + 1):
+            expected = max(0, latest + average_delta * step)
+            confidence = deviation * math.sqrt(step) * 1.96
+            forecast.append({
+                "period": f"forecast_{step}",
+                "expected_revenue": round(expected, 2),
+                "lower_bound": round(max(0, expected - confidence), 2),
+                "upper_bound": round(expected + confidence, 2),
+            })
+        return forecast
+
 if __name__ == "__main__":
     model = ChurnPredictionModel()
     test_data = {

backend/services/billing/metering_service.ts

@@ -0,0 +1,27 @@
+export interface UsageMetric {
+  userId: string;
+  metricType: 'api' | 'compute' | 'storage';
+  amount: number;
+  timestamp: Date;
+}
+
+export class MeteringService {
+  private thresholdAlerts = [0.8, 1.0, 1.2]; // 80%, 100%, 120%
+
+  async recordUsage(metric: UsageMetric): Promise<void> {
+    // Low-latency metering pipeline integration
+    console.log(`Recorded ${metric.amount} for ${metric.metricType}`);
+    
+    await this.checkThresholds(metric.userId);
+  }
+
+  async checkThresholds(userId: string): Promise<void> {
+    // Check usage against thresholds and trigger alerts
+    console.log(`Checked thresholds for ${userId}`);
+  }
+
+  async calculateOverage(userId: string): Promise<number> {
+    // Tiered overage calculation
+    return 0;
+  }
+}

backend/services/dunningService.ts

@@ -0,0 +1,252 @@
+import type {
+  DunningAnalytics,
+  DunningCommunication,
+  DunningCommunicationTemplate,
+  DunningConfiguration,
+  DunningEntry,
+  DunningStage,
+  DunningStageConfig,
+} from '../../src/types/dunning';
+import { DEFAULT_DUNNING_STAGES, DUNNING_TEMPLATES } from '../../src/types/dunning';
+
+const ONE_HOUR_MS = 3_600_000;
+
+const now = (): number => Date.now();
+
+const createId = (prefix: string): string =>
+  `${prefix}_${now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+
+export class DunningService {
+  private entries = new Map<string, DunningEntry>();
+  private configurations = new Map<string, DunningConfiguration>();
+  private communicationLog = new Map<string, DunningCommunication[]>();
+
+  configurePlan(planId: string, config: Partial<DunningConfiguration>): DunningConfiguration {
+    const existing = this.configurations.get(planId);
+    const merged: DunningConfiguration = {
+      planId,
+      stages: config.stages ?? existing?.stages ?? DEFAULT_DUNNING_STAGES,
+      maxRetries: config.maxRetries ?? existing?.maxRetries ?? 3,
+      retryIntervalHours: config.retryIntervalHours ?? existing?.retryIntervalHours ?? 1,
+      warnAfterFailures: config.warnAfterFailures ?? existing?.warnAfterFailures ?? 3,
+      suspendAfterDays: config.suspendAfterDays ?? existing?.suspendAfterDays ?? 3,
+      cancelAfterDays: config.cancelAfterDays ?? existing?.cancelAfterDays ?? 7,
+      communicationChannels: config.communicationChannels ?? existing?.communicationChannels ?? ['email', 'push'],
+    };
+    this.configurations.set(planId, merged);
+    return merged;
+  }
+
+  getConfiguration(planId: string): DunningConfiguration | undefined {
+    return this.configurations.get(planId);
+  }
+
+  startDunning(
+    subscriptionId: string,
+    subscriberId: string,
+    merchantId: string,
+    planId: string,
+  ): DunningEntry {
+    const existing = this.entries.get(subscriptionId);
+    if (existing) {
+      return existing;
+    }
+
+    const config = this.configurations.get(planId);
+    const firstStage = config?.stages[0] ?? DEFAULT_DUNNING_STAGES[0];
+    const now_ts = now();
+
+    const entry: DunningEntry = {
+      id: createId('dun'),
+      subscriptionId,
+      subscriberId,
+      merchantId,
+      planId,
+      currentStage: firstStage.stage,
+      failedAttempts: 0,
+      totalFailedCharges: 0,
+      firstFailureAt: now_ts,
+      lastFailureAt: now_ts,
+      lastAttemptAt: now_ts,
+      nextActionAt: now_ts + firstStage.delayHours * ONE_HOUR_MS,
+      isPaused: false,
+      communicationLog: [],
+      createdAt: now_ts,
+      updatedAt: now_ts,
+    };
+
+    this.entries.set(subscriptionId, entry);
+    this.communicationLog.set(subscriptionId, []);
+    return entry;
+  }
+
+  recordFailedCharge(subscriptionId: string): DunningEntry | null {
+    const entry = this.entries.get(subscriptionId);
+    if (!entry || entry.isPaused) return null;
+
+    const config = this.configurations.get(entry.planId);
+    const now_ts = now();
+
+    entry.failedAttempts += 1;
+    entry.totalFailedCharges += 1;
+    entry.lastFailureAt = now_ts;
+    entry.lastAttemptAt = now_ts;
+    entry.updatedAt = now_ts;
+
+    const currentStageIndex = config
+      ? config.stages.findIndex((s) => s.stage === entry.currentStage)
+      : -1;
+
+    const shouldAdvanceStage = (): boolean => {
+      if (currentStageIndex < 0) return false;
+      if (!config) return false;
+      const stageConfig = config.stages[currentStageIndex];
+      return entry.failedAttempts >= stageConfig.maxAttempts;
+    };
+
+    if (shouldAdvanceStage() && config) {
+      const nextStageIndex = currentStageIndex + 1;
+      if (nextStageIndex < config.stages.length) {
+        const nextStage = config.stages[nextStageIndex];
+        entry.currentStage = nextStage.stage;
+        entry.failedAttempts = 0;
+        entry.nextActionAt = now_ts + nextStage.delayHours * ONE_HOUR_MS;
+        this.sendCommunication(entry, nextStage);
+      } else {
+        entry.currentStage = 'cancel';
+        entry.nextActionAt = now_ts + 24 * ONE_HOUR_MS;
+      }
+    } else {
+      const retryDelay = config?.retryIntervalHours ?? 1;
+      entry.nextActionAt = now_ts + retryDelay * ONE_HOUR_MS;
+    }
+
+    this.entries.set(subscriptionId, entry);
+    return entry;
+  }
+
+  recordSuccessfulCharge(subscriptionId: string): void {
+    const entry = this.entries.get(subscriptionId);
+    if (!entry) return;
+
+    this.entries.delete(subscriptionId);
+    this.communicationLog.delete(subscriptionId);
+  }
+
+  getDunningEntry(subscriptionId: string): DunningEntry | undefined {
+    return this.entries.get(subscriptionId);
+  }
+
+  listActiveDunning(merchantId?: string): DunningEntry[] {
+    const all = Array.from(this.entries.values());
+    if (merchantId) {
+      return all.filter((e) => e.merchantId === merchantId);
+    }
+    return all;
+  }
+
+  pauseDunning(subscriptionId: string): DunningEntry | null {
+    const entry = this.entries.get(subscriptionId);
+    if (!entry) return null;
+    entry.isPaused = true;
+    entry.updatedAt = now();
+    this.entries.set(subscriptionId, entry);
+    return entry;
+  }
+
+  resumeDunning(subscriptionId: string): DunningEntry | null {
+    const entry = this.entries.get(subscriptionId);
+    if (!entry) return null;
+
+    const config = this.configurations.get(entry.planId);
+    const stageConfig = config?.stages.find((s) => s.stage === entry.currentStage);
+    entry.isPaused = false;
+    entry.nextActionAt = now() + (stageConfig?.delayHours ?? 24) * ONE_HOUR_MS;
+    entry.updatedAt = now();
+    this.entries.set(subscriptionId, entry);
+    return entry;
+  }
+
+  overrideStage(subscriptionId: string, stage: DunningStage): DunningEntry | null {
+    const entry = this.entries.get(subscriptionId);
+    if (!entry) return null;
+
+    const config = this.configurations.get(entry.planId);
+    const stageConfig = config?.stages.find((s) => s.stage === stage);
+    entry.currentStage = stage;
+    entry.failedAttempts = 0;
+    entry.nextActionAt = now() + (stageConfig?.delayHours ?? 24) * ONE_HOUR_MS;
+    entry.updatedAt = now();
+    this.entries.set(subscriptionId, entry);
+    return entry;
+  }
+
+  getCommunications(subscriptionId: string): DunningCommunication[] {
+    return this.communicationLog.get(subscriptionId) ?? [];
+  }
+
+  getAnalytics(merchantId?: string): DunningAnalytics {
+    const allEntries = this.listActiveDunning(merchantId);
+    const stageBreakdown: Record<DunningStage, number> = {
+      retry: 0,
+      warn: 0,
+      suspend: 0,
+      cancel: 0,
+    };
+
+    for (const entry of allEntries) {
+      stageBreakdown[entry.currentStage] = (stageBreakdown[entry.currentStage] ?? 0) + 1;
+    }
+
+    const totalRecovered = Array.from(this.entries.values()).filter(
+      (e) => e.totalFailedCharges === 0
+    ).length;
+
+    return {
+      totalActiveDunning: allEntries.length,
+      stageBreakdown,
+      recoveryRate: 0,
+      totalRecovered,
+      totalLost: stageBreakdown.cancel,
+      averageDaysToRecovery: 0,
+      stageSuccessRates: {
+        retry: 0,
+        warn: 0,
+        suspend: 0,
+        cancel: 0,
+      },
+    };
+  }
+
+  private sendCommunication(entry: DunningEntry, stageConfig: DunningStageConfig): DunningCommunication {
+    const template = DUNNING_TEMPLATES.find((t) => t.id === stageConfig.templateId);
+    const comm: DunningCommunication = {
+      id: createId('dcom'),
+      stage: stageConfig.stage,
+      channel: 'push',
+      templateId: stageConfig.templateId,
+      sentAt: now(),
+      status: 'sent',
+      metadata: {
+        subscription_id: entry.subscriptionId,
+        template_subject: template?.subject ?? '',
+      },
+    };
+
+    const log = this.communicationLog.get(entry.subscriptionId) ?? [];
+    log.push(comm);
+    this.communicationLog.set(entry.subscriptionId, log);
+    entry.communicationLog.push(comm);
+
+    return comm;
+  }
+
+  getProcessableEntries(): DunningEntry[] {
+    const now_ts = now();
+    return Array.from(this.entries.values()).filter(
+      (e) => !e.isPaused && e.nextActionAt <= now_ts
+    );
+  }
+}
+
+export const dunningService = new DunningService();