@littlebearapps/platform-admin-sdk 2.1.0 → 2.2.0

package/templates/standard/tests/integration/connectors.test.ts

@@ -0,0 +1,241 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import type { ScheduledEvent, ExecutionContext } from '@cloudflare/workers-types';
+import stripeConnector from '../../workers/stripe-connector';
+import adsConnector from '../../workers/ads-connector';
+import plausibleConnector from '../../workers/plausible-connector';
+import ga4Connector from '../../workers/ga4-connector';
+import { MockD1Database, MockKVNamespace, MockQueue } from '../helpers/mock-storage';
+
+// The Worker runtime provides these types; in tests we use simple placeholders
+const scheduledEvent = {} as ScheduledEvent;
+
+// Mock ExecutionContext for SDK integration
+const mockCtx = {
+  waitUntil: () => {},
+  passThroughOnException: () => {},
+} as unknown as ExecutionContext;
+
+describe('Business intelligence connectors', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Stripe connector', () => {
+    let env: {
+      PLATFORM_DB: MockD1Database;
+      PLATFORM_CACHE: MockKVNamespace;
+      PLATFORM_TELEMETRY: MockQueue;
+      STRIPE_API_KEY: string;
+    };
+
+    beforeEach(() => {
+      env = {
+        PLATFORM_DB: new MockD1Database(),
+        PLATFORM_CACHE: new MockKVNamespace(),
+        PLATFORM_TELEMETRY: new MockQueue(),
+        STRIPE_API_KEY: 'sk_test',
+      };
+    });
+
+    it('stores revenue metrics and raises alerts on anomalies', async () => {
+      const fetchMock = vi.spyOn(globalThis, 'fetch').mockImplementationOnce(
+        async () =>
+          new Response(
+            JSON.stringify({
+              data: [
+                {
+                  status: 'active',
+                  items: {
+                    data: [{ price: { unit_amount: 2500, recurring: { interval: 'month' } } }],
+                  },
+                },
+                {
+                  status: 'trialing',
+                  items: {
+                    data: [{ price: { unit_amount: 12000, recurring: { interval: 'year' } } }],
+                  },
+                },
+                {
+                  status: 'canceled',
+                  items: {
+                    data: [{ price: { unit_amount: 1000, recurring: { interval: 'month' } } }],
+                  },
+                },
+              ],
+            })
+          )
+      );
+      fetchMock.mockImplementationOnce(
+        async () =>
+          new Response(
+            JSON.stringify({
+              data: [{ status: 'paid' }, { status: 'open' }, { status: 'uncollectible' }],
+            })
+          )
+      );
+
+      env.PLATFORM_DB.queueFirstResult({ value: 200 }); // previous MRR
+      env.PLATFORM_DB.queueFirstResult({ value: 0.01 }); // previous churn rate
+      env.PLATFORM_DB.queueFirstResult({ value: 0.01 }); // previous failed payment rate
+
+      await stripeConnector.scheduled(scheduledEvent, env as any, mockCtx);
+
+      const metricStatements = env.PLATFORM_DB.statements.filter((stmt) =>
+        stmt.sql.includes('INSERT INTO revenue_metrics')
+      );
+      expect(metricStatements.length).toBeGreaterThanOrEqual(4);
+
+      const alertStatement = env.PLATFORM_DB.statements.find((stmt) =>
+        stmt.sql.includes('INSERT INTO alerts')
+      );
+      expect(alertStatement).toBeTruthy();
+      expect(env.PLATFORM_CACHE.store.has('stripe:mrr')).toBe(true);
+    });
+  });
+
+  describe('Google Ads connector', () => {
+    let env: {
+      PLATFORM_DB: MockD1Database;
+      PLATFORM_CACHE: MockKVNamespace;
+      PLATFORM_TELEMETRY: MockQueue;
+      GOOGLE_ADS_DEVELOPER_TOKEN: string;
+      GOOGLE_ADS_CLIENT_ID: string;
+    };
+
+    beforeEach(() => {
+      env = {
+        PLATFORM_DB: new MockD1Database(),
+        PLATFORM_CACHE: new MockKVNamespace(),
+        PLATFORM_TELEMETRY: new MockQueue(),
+        GOOGLE_ADS_DEVELOPER_TOKEN: 'dev-token',
+        GOOGLE_ADS_CLIENT_ID: 'client-id',
+      };
+    });
+
+    it('calculates CAC and ROAS metrics with anomaly detection', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+        new Response(
+          JSON.stringify([
+            {
+              results: [
+                {
+                  metrics: {
+                    costMicros: 5_000_000_000,
+                    conversions: 100,
+                    installs: 200,
+                    conversionsValue: 12_000,
+                  },
+                },
+              ],
+            },
+          ])
+        )
+      );
+
+      env.PLATFORM_DB.queueFirstResult({ value: 20 }); // previous CAC
+      env.PLATFORM_DB.queueFirstResult({ value: 5 }); // previous ROAS
+
+      await adsConnector.scheduled(scheduledEvent, env as any, mockCtx);
+
+      const cacheKeys = Array.from(env.PLATFORM_CACHE.store.keys());
+      expect(cacheKeys).toContain('ads:cac');
+
+      const alert = env.PLATFORM_DB.statements.find((stmt) =>
+        stmt.sql.includes('INSERT INTO alerts')
+      );
+      expect(alert).toBeTruthy();
+    });
+  });
+
+  describe('Plausible connector', () => {
+    let env: {
+      PLATFORM_DB: MockD1Database;
+      PLATFORM_CACHE: MockKVNamespace;
+      PLATFORM_TELEMETRY: MockQueue;
+      PLAUSIBLE_API_KEY: string;
+    };
+
+    beforeEach(() => {
+      env = {
+        PLATFORM_DB: new MockD1Database(),
+        PLATFORM_CACHE: new MockKVNamespace(),
+        PLATFORM_TELEMETRY: new MockQueue(),
+        PLAUSIBLE_API_KEY: 'plausible-key',
+      };
+    });
+
+    it('stores usage metrics and raises alerts when usage drops', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+        new Response(
+          JSON.stringify({
+            results: {
+              visitors: { value: 300, returning: 90 },
+              events: {
+                'feature:pdf_support': 30,
+                'feature:other': 70,
+              },
+            },
+          })
+        )
+      );
+
+      env.PLATFORM_DB.queueFirstResult({ value: 600 });
+
+      await plausibleConnector.scheduled(scheduledEvent, env as any, mockCtx);
+
+      expect(env.PLATFORM_CACHE.store.has('plausible:active_users')).toBe(true);
+      const alert = env.PLATFORM_DB.statements.find((stmt) =>
+        stmt.sql.includes('INSERT INTO alerts')
+      );
+      expect(alert).toBeTruthy();
+    });
+  });
+
+  describe('GA4 connector', () => {
+    let env: {
+      PLATFORM_DB: MockD1Database;
+      PLATFORM_CACHE: MockKVNamespace;
+      PLATFORM_TELEMETRY: MockQueue;
+      GA4_PROPERTY_ID: string;
+    };
+
+    beforeEach(() => {
+      env = {
+        PLATFORM_DB: new MockD1Database(),
+        PLATFORM_CACHE: new MockKVNamespace(),
+        PLATFORM_TELEMETRY: new MockQueue(),
+        GA4_PROPERTY_ID: 'properties/1234',
+      };
+    });
+
+    it('tracks install and review sentiment metrics with alerts on regression', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValue(
+        new Response(
+          JSON.stringify({
+            rows: [
+              {
+                metricValues: [
+                  { value: '1000' },
+                  { value: '150' },
+                  { value: '80' },
+                  { value: '100' },
+                ],
+              },
+            ],
+          })
+        )
+      );
+
+      env.PLATFORM_DB.queueFirstResult({ value: 0.25 }); // previous install rate
+      env.PLATFORM_DB.queueFirstResult({ value: 0.9 }); // previous positive review rate
+
+      await ga4Connector.scheduled(scheduledEvent, env as any, mockCtx);
+
+      expect(env.PLATFORM_CACHE.store.has('ga4:install_rate')).toBe(true);
+      const alert = env.PLATFORM_DB.statements.find((stmt) =>
+        stmt.sql.includes('INSERT INTO alerts')
+      );
+      expect(alert).toBeTruthy();
+    });
+  });
+});

package/templates/standard/tests/integration/github-monitor.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import githubMonitor from '../../workers/github-monitor';
+import { createGitHubMonitorEnv } from '../helpers/mock-storage';
+import type {
+  MockD1Database,
+  MockKVNamespace,
+  MockR2Bucket,
+  MockQueue,
+} from '../helpers/mock-storage';
+
+// Mock ExecutionContext for SDK integration
+const mockCtx = {
+  waitUntil: () => {},
+  passThroughOnException: () => {},
+} as unknown as ExecutionContext;
+
+describe('GitHub Monitor Worker', () => {
+  let env: {
+    PLATFORM_DB: MockD1Database;
+    PLATFORM_CACHE: MockKVNamespace;
+    PLATFORM_ARCHIVES: MockR2Bucket;
+    PLATFORM_TELEMETRY: MockQueue;
+    GITHUB_WEBHOOK_SECRET: string;
+  };
+
+  beforeEach(() => {
+    env = createGitHubMonitorEnv();
+  });
+
+  it('rejects invalid signatures', async () => {
+    const body = JSON.stringify({ action: 'opened' });
+    const request = new Request('https://example.com/webhook', {
+      method: 'POST',
+      body,
+      headers: {
+        'x-hub-signature-256': 'sha256=invalid',
+        'x-github-event': 'issues',
+      },
+    });
+
+    const response = await githubMonitor.fetch(request, env as any, mockCtx);
+    expect(response.status).toBe(401);
+  });
+
+  it('stores CloakPipe robot issues', async () => {
+    const payload = {
+      action: 'opened',
+      repository: { full_name: 'littlebearapps/cloakpipe' },
+      issue: {
+        number: 42,
+        title: 'Robot detected anomaly',
+        labels: [{ name: 'robot' }],
+      },
+    };
+
+    const response = await invokeWorker(payload, env, 'issues');
+
+    expect(response.status).toBe(200);
+    const insertStatement = env.PLATFORM_DB.statements.find((stmt) =>
+      stmt.sql.includes('INSERT INTO github_events')
+    );
+    expect(insertStatement).toBeTruthy();
+    expect(env.PLATFORM_ARCHIVES.objects.size).toBe(1);
+  });
+
+  it('records HomeoStat bot pull requests', async () => {
+    const payload = {
+      action: 'opened',
+      repository: { full_name: 'littlebearapps/homeostat' },
+      pull_request: {
+        number: 99,
+        merged: false,
+        user: { login: 'homeostat-bot' },
+        labels: [],
+      },
+    };
+
+    await invokeWorker(payload, env, 'pull_request');
+
+    const insertStatement = env.PLATFORM_DB.statements.find(
+      (stmt) => stmt.sql.includes('INSERT INTO github_events') && stmt.params.includes('pr')
+    );
+    expect(insertStatement).toBeTruthy();
+  });
+
+  it('records GateKeeper workflow failures and raises alerts', async () => {
+    env.PLATFORM_DB.queueFirstResult({ count: 11 });
+
+    const payload = {
+      repository: { full_name: 'littlebearapps/gatekeeper' },
+      workflow_run: {
+        name: 'extension publish',
+        status: 'completed',
+        conclusion: 'failure',
+      },
+    };
+
+    await invokeWorker(payload, env, 'workflow_run');
+
+    const alertInsert = env.PLATFORM_DB.statements.find((stmt) =>
+      stmt.sql.includes('INSERT INTO alerts')
+    );
+    expect(alertInsert).toBeTruthy();
+  });
+});
+
+async function invokeWorker(
+  payload: unknown,
+  env: ReturnType<typeof createGitHubMonitorEnv>,
+  event: string
+) {
+  const body = JSON.stringify(payload);
+  const signature = await createSignature(body, env.GITHUB_WEBHOOK_SECRET);
+
+  const request = new Request('https://example.com/webhook', {
+    method: 'POST',
+    body,
+    headers: {
+      'x-hub-signature-256': signature,
+      'x-github-event': event,
+    },
+  });
+
+  return githubMonitor.fetch(request, env as any, mockCtx);
+}
+
+async function createSignature(body: string, secret: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    'raw',
+    encoder.encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign']
+  );
+
+  const buffer = await crypto.subtle.sign('HMAC', key, encoder.encode(body));
+  const hex = Array.from(new Uint8Array(buffer))
+    .map((byte) => byte.toString(16).padStart(2, '0'))
+    .join('');
+
+  return `sha256=${hex}`;
+}

package/templates/standard/tests/integration/ingestion.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import ingestGitHub from '../../workers/ingest-github';
+import ingestStripe from '../../workers/ingest-stripe';
+import ingestLogger from '../../workers/ingest-logger';
+import { MockD1Database, MockR2Bucket, MockQueue } from '../helpers/mock-storage';
+
+declare const crypto: Crypto;
+
+// Mock ExecutionContext for SDK integration
+const mockCtx = {
+  waitUntil: () => {},
+  passThroughOnException: () => {},
+} as unknown as ExecutionContext;
+
+describe('Webhook ingestion workers', () => {
+  describe('GitHub ingestion', () => {
+    let env: {
+      PLATFORM_DB: MockD1Database;
+      PLATFORM_ARCHIVES: MockR2Bucket;
+      PLATFORM_TELEMETRY: MockQueue;
+      GITHUB_WEBHOOK_SECRET: string;
+    };
+
+    beforeEach(() => {
+      env = {
+        PLATFORM_DB: new MockD1Database(),
+        PLATFORM_ARCHIVES: new MockR2Bucket(),
+        PLATFORM_TELEMETRY: new MockQueue(),
+        GITHUB_WEBHOOK_SECRET: 'github-secret',
+      };
+    });
+
+    it('rejects invalid signatures', async () => {
+      const request = new Request('https://example.com', {
+        method: 'POST',
+        body: JSON.stringify({}),
+        headers: {
+          'x-github-event': 'issues',
+          'x-hub-signature-256': 'sha256=invalid',
+        },
+      });
+
+      const response = await ingestGitHub.fetch(request, env as any, mockCtx);
+      expect(response.status).toBe(401);
+    });
+
+    it('stores robot issues', async () => {
+      const payload = {
+        action: 'opened',
+        repository: { full_name: 'littlebearapps/cloakpipe' },
+        issue: {
+          number: 101,
+          title: 'Robot triggered error',
+          labels: [{ name: 'robot' }],
+          node_id: 'MDU6SXNzdWUx',
+        },
+      };
+
+      const body = JSON.stringify(payload);
+      const signature = await signGitHubPayload(body, env.GITHUB_WEBHOOK_SECRET);
+      const request = new Request('https://example.com', {
+        method: 'POST',
+        body,
+        headers: {
+          'x-github-event': 'issues',
+          'x-hub-signature-256': signature,
+        },
+      });
+
+      const response = await ingestGitHub.fetch(request, env as any, mockCtx);
+      expect(response.status).toBe(200);
+      const insert = env.PLATFORM_DB.statements.find((stmt) =>
+        stmt.sql.includes('INSERT INTO github_events')
+      );
+      expect(insert).toBeTruthy();
+      expect(env.PLATFORM_ARCHIVES.objects.size).toBe(1);
+    });
+  });
+
+  describe('Stripe ingestion', () => {
+    let env: {
+      PLATFORM_DB: MockD1Database;
+      PLATFORM_ARCHIVES: MockR2Bucket;
+      PLATFORM_TELEMETRY: MockQueue;
+      STRIPE_WEBHOOK_SECRET: string;
+    };
+
+    beforeEach(() => {
+      env = {
+        PLATFORM_DB: new MockD1Database(),
+        PLATFORM_ARCHIVES: new MockR2Bucket(),
+        PLATFORM_TELEMETRY: new MockQueue(),
+        STRIPE_WEBHOOK_SECRET: 'whsec_test',
+      };
+    });
+
+    it('validates signatures and stores events', async () => {
+      const event = {
+        id: 'evt_123',
+        type: 'invoice.paid',
+        data: { object: { amount_paid: 5500, status: 'paid' } },
+      };
+      const body = JSON.stringify(event);
+      const timestamp = Math.floor(Date.now() / 1000).toString();
+      const signature = await signStripePayload(timestamp, body, env.STRIPE_WEBHOOK_SECRET);
+      const request = new Request('https://example.com', {
+        method: 'POST',
+        body,
+        headers: {
+          'stripe-signature': `t=${timestamp},v1=${signature}`,
+        },
+      });
+
+      const response = await ingestStripe.fetch(request, env as any, mockCtx);
+      expect(response.status).toBe(200);
+      const metricInsert = env.PLATFORM_DB.statements.find((stmt) =>
+        stmt.sql.includes('INSERT INTO revenue_metrics')
+      );
+      expect(metricInsert).toBeTruthy();
+      expect(env.PLATFORM_ARCHIVES.objects.size).toBe(1);
+    });
+  });
+
+  describe('CloakPipe logger ingestion', () => {
+    let env: {
+      PLATFORM_DB: MockD1Database;
+      PLATFORM_ARCHIVES: MockR2Bucket;
+      PLATFORM_TELEMETRY: MockQueue;
+    };
+
+    beforeEach(() => {
+      env = {
+        PLATFORM_DB: new MockD1Database(),
+        PLATFORM_ARCHIVES: new MockR2Bucket(),
+        PLATFORM_TELEMETRY: new MockQueue(),
+      };
+    });
+
+    it('validates schemas and stores error reports', async () => {
+      const envelope = {
+        id: '01JBQH7YFQM9K3W8XTZP5VN2QR',
+        source: 'cloakpipe',
+        type: 'error_report',
+        timestamp: '2025-10-25T14:30:00.000Z',
+        data: {
+          extension_id: 'convert-my-file',
+          fingerprint: 'TypeError-getNativeInputProps-undefined',
+          message: 'Cannot read properties of undefined',
+          stack_trace: 'TypeError: Cannot read properties of undefined',
+          breadcrumbs: [
+            {
+              timestamp: '2025-10-25T14:29:58.000Z',
+              category: 'user',
+              message: 'Clicked upload button',
+            },
+          ],
+          user_agent: 'Mozilla/5.0...',
+          extension_version: '1.2.3',
+        },
+        metadata: {
+          schema_version: '1.0.0',
+          correlation_id: '01JBQH7YFQM9K3W8XTZP5VN2QS',
+        },
+      };
+
+      const request = new Request('https://example.com', {
+        method: 'POST',
+        body: JSON.stringify(envelope),
+      });
+
+      const response = await ingestLogger.fetch(request, env as any, mockCtx);
+      expect(response.status).toBe(200);
+      const insert = env.PLATFORM_DB.statements.find((stmt) =>
+        stmt.sql.includes('INSERT INTO error_reports')
+      );
+      expect(insert).toBeTruthy();
+      expect(env.PLATFORM_ARCHIVES.objects.size).toBe(1);
+    });
+  });
+});
+
+async function signGitHubPayload(body: string, secret: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    'raw',
+    encoder.encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign']
+  );
+  const buffer = await crypto.subtle.sign('HMAC', key, encoder.encode(body));
+  const hex = Array.from(new Uint8Array(buffer))
+    .map((byte) => byte.toString(16).padStart(2, '0'))
+    .join('');
+  return `sha256=${hex}`;
+}
+
+async function signStripePayload(timestamp: string, body: string, secret: string): Promise<string> {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    'raw',
+    encoder.encode(secret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign']
+  );
+  const buffer = await crypto.subtle.sign('HMAC', key, encoder.encode(`${timestamp}.${body}`));
+  return Array.from(new Uint8Array(buffer))
+    .map((byte) => byte.toString(16).padStart(2, '0'))
+    .join('');
+}