redesign the homepage

apps/homepage/src/lib/demo/adapters/blocked.ts

@@ -0,0 +1,14 @@
+import type { LeadDestinationAdapter, LeadDestinationResult } from './types';
+
+export class BlockedLeadDestinationAdapter implements LeadDestinationAdapter {
+  readonly name = 'blocked';
+
+  async submitLead(): Promise<LeadDestinationResult> {
+    return {
+      ok: false,
+      category: 'configuration',
+      retryable: false,
+      code: 'lead_destination_not_approved',
+    };
+  }
+}

apps/homepage/src/lib/demo/adapters/index.ts

@@ -0,0 +1,17 @@
+import type { IntegrationEnvironment } from '@/lib/integrations/environment';
+import { BlockedLeadDestinationAdapter } from './blocked';
+import { LocalLeadDestinationAdapter } from './local';
+import type { LeadDestinationAdapter } from './types';
+
+export function createLeadDestinationAdapter(
+  environment: IntegrationEnvironment,
+): LeadDestinationAdapter {
+  const approvedLocalRuntime =
+    environment.NODE_ENV !== 'production' || environment.DEMO_LOCAL_TEST_MODE;
+  if (approvedLocalRuntime && environment.DEMO_SUBMISSION_MODE === 'local') {
+    return new LocalLeadDestinationAdapter();
+  }
+  return new BlockedLeadDestinationAdapter();
+}
+
+export type { IntegrationContext, LeadDestinationAdapter, LeadDestinationResult } from './types';

apps/homepage/src/lib/demo/adapters/local.ts

@@ -0,0 +1,46 @@
+import type { LeadDestinationAdapter, LeadDestinationResult } from './types';
+
+function abortError(): Error {
+  return new DOMException('Operation aborted', 'AbortError');
+}
+
+export class LocalLeadDestinationAdapter implements LeadDestinationAdapter {
+  readonly name = 'local-discard';
+
+  async submitLead(
+    _lead: Parameters<LeadDestinationAdapter['submitLead']>[0],
+    context: Parameters<LeadDestinationAdapter['submitLead']>[1],
+  ): Promise<LeadDestinationResult> {
+    if (context.signal.aborted) throw abortError();
+
+    switch (context.testScenario) {
+      case 'duplicate':
+        return { ok: false, category: 'duplicate', retryable: false, code: 'local_duplicate' };
+      case 'integration-error':
+        return { ok: false, category: 'integration', retryable: true, code: 'local_error' };
+      case 'timeout':
+        await new Promise<void>((resolve, reject) => {
+          const timer = setTimeout(resolve, 30_000);
+          context.signal.addEventListener(
+            'abort',
+            () => {
+              clearTimeout(timer);
+              reject(abortError());
+            },
+            { once: true },
+          );
+        });
+        break;
+      case 'success':
+      case undefined:
+        break;
+    }
+
+    return {
+      ok: true,
+      externalId: `local_${context.correlationId}`,
+      acceptedAt: new Date().toISOString(),
+      mode: 'local',
+    };
+  }
+}

apps/homepage/src/lib/demo/adapters/types.ts

@@ -0,0 +1,23 @@
+import type { DemoLead } from '../schema';
+
+export interface IntegrationContext {
+  correlationId: string;
+  idempotencyKey: string;
+  signal: AbortSignal;
+  environment: 'development' | 'test' | 'production';
+  testScenario?: 'success' | 'duplicate' | 'timeout' | 'integration-error';
+}
+
+export type LeadDestinationResult =
+  | { ok: true; externalId: string; acceptedAt: string; mode: 'local' }
+  | {
+      ok: false;
+      category: 'duplicate' | 'integration' | 'timeout' | 'configuration';
+      retryable: boolean;
+      code: string;
+    };
+
+export interface LeadDestinationAdapter {
+  readonly name: string;
+  submitLead(lead: DemoLead, context: IntegrationContext): Promise<LeadDestinationResult>;
+}