@mmapp/react-compiler 0.1.0-alpha.1

package/examples/uber-app/actions/matching.server.ts

@@ -0,0 +1,177 @@
+/**
+ * @workflow slug="uber-rideshare"
+ * @description Driver matching algorithm — finds optimal driver based on proximity, rating, and vehicle type
+ */
+
+import type { TransitionContext, ActionResult } from '@mindmatrix/react';
+
+/** Haversine distance in kilometers between two lat/lng points */
+function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number {
+  const R = 6371;
+  const dLat = ((lat2 - lat1) * Math.PI) / 180;
+  const dLon = ((lon2 - lon1) * Math.PI) / 180;
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos((lat1 * Math.PI) / 180) *
+      Math.cos((lat2 * Math.PI) / 180) *
+      Math.sin(dLon / 2) *
+      Math.sin(dLon / 2);
+  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+
+/** Score a driver for matching — higher is better */
+function scoreDriver(
+  driver: Record<string, unknown>,
+  pickupLat: number,
+  pickupLng: number,
+  requestedType: string
+): number {
+  const dist = haversineKm(
+    pickupLat,
+    pickupLng,
+    driver.currentLatitude as number,
+    driver.currentLongitude as number
+  );
+
+  // Distance score: closer = higher (max 50 points, 0 at 15km+)
+  const distanceScore = Math.max(0, 50 - dist * (50 / 15));
+
+  // Rating score: 0-25 points
+  const ratingScore = ((driver.driverRating as number) / 5) * 25;
+
+  // Acceptance rate score: 0-15 points
+  const acceptScore = ((driver.acceptanceRate as number) / 100) * 15;
+
+  // Vehicle type match bonus: 10 points
+  const typeBonus = driver.vehicleType === requestedType ? 10 : 0;
+
+  return distanceScore + ratingScore + acceptScore + typeBonus;
+}
+
+/** Find and match the best available driver for a ride request */
+export async function findBestDriver(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const { originLatitude, originLongitude, vehicleType } = instance.fields as Record<string, unknown>;
+
+  // Query nearby online drivers with matching vehicle type
+  const drivers = await env.query('uber-user', {
+    filter: {
+      role: 'driver',
+      isOnline: true,
+      status: 'active',
+    },
+    limit: 50,
+  });
+
+  if (!drivers.data || drivers.data.length === 0) {
+    return { success: false, data: { reason: 'no_drivers_available' } };
+  }
+
+  // Score and rank all candidate drivers
+  const scored = drivers.data
+    .map((driver: Record<string, unknown>) => ({
+      driver,
+      score: scoreDriver(
+        driver,
+        originLatitude as number,
+        originLongitude as number,
+        vehicleType as string
+      ),
+      distance: haversineKm(
+        originLatitude as number,
+        originLongitude as number,
+        driver.currentLatitude as number,
+        driver.currentLongitude as number
+      ),
+    }))
+    .filter((d) => d.distance <= 15) // Max 15km radius
+    .sort((a, b) => b.score - a.score);
+
+  if (scored.length === 0) {
+    return { success: false, data: { reason: 'no_drivers_in_range' } };
+  }
+
+  const best = scored[0];
+  const etaMinutes = Math.round((best.distance / 30) * 60); // Assume 30km/h avg
+
+  return {
+    success: true,
+    data: {
+      driverId: best.driver.id,
+      driverName: best.driver.displayName,
+      vehicleId: best.driver.vehicleId,
+      driverLatitude: best.driver.currentLatitude,
+      driverLongitude: best.driver.currentLongitude,
+      driverRating: best.driver.driverRating,
+      etaMinutes,
+      matchScore: best.score,
+      candidatesEvaluated: scored.length,
+    },
+  };
+}
+
+/** Batch-match multiple ride requests to available drivers (for dispatch optimization) */
+export async function batchMatchDrivers(ctx: TransitionContext): Promise<ActionResult> {
+  const { env } = ctx;
+
+  const pendingRides = await env.query('uber-ride', {
+    filter: { status: 'searching' },
+    limit: 100,
+    orderBy: 'requestedAt',
+    order: 'asc',
+  });
+
+  const matchedDriverIds = new Set<string>();
+  const results: Array<{ rideId: string; driverId: string; eta: number }> = [];
+
+  for (const ride of pendingRides.data) {
+    const drivers = await env.query('uber-user', {
+      filter: {
+        role: 'driver',
+        isOnline: true,
+        status: 'active',
+      },
+      limit: 50,
+    });
+
+    const available = drivers.data.filter(
+      (d: Record<string, unknown>) => !matchedDriverIds.has(d.id as string)
+    );
+
+    if (available.length > 0) {
+      const scored = available
+        .map((driver: Record<string, unknown>) => ({
+          driver,
+          score: scoreDriver(
+            driver,
+            ride.originLatitude as number,
+            ride.originLongitude as number,
+            ride.vehicleType as string
+          ),
+          distance: haversineKm(
+            ride.originLatitude as number,
+            ride.originLongitude as number,
+            driver.currentLatitude as number,
+            driver.currentLongitude as number
+          ),
+        }))
+        .filter((d) => d.distance <= 15)
+        .sort((a, b) => b.score - a.score);
+
+      if (scored.length > 0) {
+        const best = scored[0];
+        matchedDriverIds.add(best.driver.id as string);
+        results.push({
+          rideId: ride.id as string,
+          driverId: best.driver.id as string,
+          eta: Math.round((best.distance / 30) * 60),
+        });
+      }
+    }
+  }
+
+  return {
+    success: true,
+    data: { matched: results.length, total: pendingRides.data.length, results },
+  };
+}

package/examples/uber-app/actions/notifications.server.ts

@@ -0,0 +1,176 @@
+/**
+ * @workflow slug="uber-rideshare"
+ * @description Push notification delivery for ride lifecycle events
+ */
+
+import type { TransitionContext, ActionResult } from '@mindmatrix/react';
+
+type NotificationChannel = 'push' | 'sms' | 'email' | 'in_app';
+
+interface NotificationPayload {
+  userId: string;
+  title: string;
+  body: string;
+  channels: NotificationChannel[];
+  data?: Record<string, unknown>;
+  priority?: 'high' | 'normal' | 'low';
+  sound?: string;
+  badge?: number;
+}
+
+/** Send notification via configured channels */
+async function sendNotification(
+  env: TransitionContext['env'],
+  payload: NotificationPayload
+): Promise<void> {
+  // In production: calls FCM/APNs/Twilio/SendGrid
+  await env.emit('notification:sent', {
+    userId: payload.userId,
+    title: payload.title,
+    channels: payload.channels,
+    timestamp: new Date().toISOString(),
+  });
+}
+
+/** Notify rider that a driver has been matched */
+export async function notifyRideMatched(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  await sendNotification(env, {
+    userId: fields.riderId as string,
+    title: 'Driver Found!',
+    body: `${fields.driverName} is on the way in a ${fields.vehicleType}. ETA: ${fields.etaMinutes} min`,
+    channels: ['push', 'in_app'],
+    priority: 'high',
+    sound: 'ride_matched.mp3',
+    data: {
+      type: 'ride_matched',
+      rideId: instance.id,
+      driverName: fields.driverName,
+      etaMinutes: fields.etaMinutes,
+    },
+  });
+
+  return { success: true, data: { notified: 'rider', event: 'ride_matched' } };
+}
+
+/** Notify rider that driver has arrived at pickup */
+export async function notifyDriverArrived(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  await sendNotification(env, {
+    userId: fields.riderId as string,
+    title: 'Your driver has arrived',
+    body: `${fields.driverName} is waiting at the pickup location. Share code: ${fields.shareCode}`,
+    channels: ['push', 'sms', 'in_app'],
+    priority: 'high',
+    sound: 'driver_arrived.mp3',
+    data: { type: 'driver_arrived', rideId: instance.id, shareCode: fields.shareCode },
+  });
+
+  return { success: true, data: { notified: 'rider', event: 'driver_arrived' } };
+}
+
+/** Notify driver of an incoming ride request */
+export async function notifyNewRideRequest(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  await sendNotification(env, {
+    userId: fields.driverId as string,
+    title: 'New Ride Request',
+    body: `Pickup: ${fields.originAddress}. Fare: $${fields.estimatedFare}`,
+    channels: ['push', 'in_app'],
+    priority: 'high',
+    sound: 'new_request.mp3',
+    badge: 1,
+    data: {
+      type: 'ride_request',
+      rideId: instance.id,
+      originAddress: fields.originAddress,
+      estimatedFare: fields.estimatedFare,
+      vehicleType: fields.vehicleType,
+    },
+  });
+
+  return { success: true, data: { notified: 'driver', event: 'ride_request' } };
+}
+
+/** Notify rider when ride is completed with fare summary */
+export async function notifyRideCompleted(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  // Notify rider
+  await sendNotification(env, {
+    userId: fields.riderId as string,
+    title: 'Ride Complete',
+    body: `You arrived at ${fields.destinationAddress}. Total: $${fields.actualFare}`,
+    channels: ['push', 'in_app'],
+    data: { type: 'ride_completed', rideId: instance.id, fare: fields.actualFare },
+  });
+
+  // Notify driver
+  await sendNotification(env, {
+    userId: fields.driverId as string,
+    title: 'Trip Complete',
+    body: `Earnings: $${fields.actualFare}. Don't forget to rate your rider.`,
+    channels: ['push', 'in_app'],
+    data: { type: 'ride_completed', rideId: instance.id },
+  });
+
+  return { success: true, data: { notified: 'both', event: 'ride_completed' } };
+}
+
+/** Notify about ride cancellation */
+export async function notifyCancellation(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+  const cancelledBy = fields.cancelledBy as string;
+
+  const targetUserId = cancelledBy === 'rider'
+    ? fields.driverId as string
+    : fields.riderId as string;
+
+  if (targetUserId) {
+    await sendNotification(env, {
+      userId: targetUserId,
+      title: 'Ride Cancelled',
+      body: `The ride was cancelled by the ${cancelledBy}. ${
+        (fields.cancellationFee as number) > 0
+          ? `Cancellation fee: $${fields.cancellationFee}`
+          : 'No cancellation fee.'
+      }`,
+      channels: ['push', 'in_app'],
+      data: {
+        type: 'ride_cancelled',
+        rideId: instance.id,
+        cancelledBy,
+        cancellationFee: fields.cancellationFee,
+      },
+    });
+  }
+
+  return { success: true, data: { notified: targetUserId ? 'counterparty' : 'none', event: 'cancellation' } };
+}
+
+/** Send safety alert to emergency contacts */
+export async function sendSafetyAlert(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  await env.emit('safety:alert', {
+    rideId: instance.id,
+    riderId: fields.riderId,
+    driverId: fields.driverId,
+    location: {
+      latitude: fields.driverLatitude,
+      longitude: fields.driverLongitude,
+    },
+    timestamp: new Date().toISOString(),
+  });
+
+  return { success: true, data: { event: 'safety_alert', emergencyContacted: true } };
+}

package/examples/uber-app/actions/payments.server.ts

@@ -0,0 +1,184 @@
+/**
+ * @workflow slug="uber-rideshare"
+ * @description Payment processing — authorization, capture, settlement, refund, and payout
+ */
+
+import type { TransitionContext, ActionResult } from '@mindmatrix/react';
+
+/** Authorize a payment hold before ride starts */
+export async function authorizePayment(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  // Pre-authorize for estimated fare + 20% buffer
+  const estimatedFare = fields.estimatedFare as number;
+  const authAmount = Math.round(estimatedFare * 1.2 * 100) / 100;
+
+  // Mock processor call — in production this calls Stripe/Adyen
+  const processorTransactionId = `txn_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const authorizationCode = `auth_${Math.random().toString(36).slice(2, 10)}`;
+
+  await env.emit('payment:authorized', {
+    rideId: fields.rideId,
+    amount: authAmount,
+    processorTransactionId,
+  });
+
+  return {
+    success: true,
+    data: {
+      status: 'authorized',
+      processorTransactionId,
+      authorizationCode,
+      totalAmount: authAmount,
+      authorizedAt: new Date().toISOString(),
+    },
+  };
+}
+
+/** Capture the actual fare after ride completion */
+export async function capturePayment(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  const actualFare = fields.actualFare as number;
+  const tipAmount = (fields.tipAmount as number) || 0;
+  const totalCapture = actualFare + tipAmount;
+
+  // Calculate tax
+  const taxRate = 8.875;
+  const taxAmount = Math.round(totalCapture * (taxRate / 100) * 100) / 100;
+
+  // Platform split: 25% of fare (not tip)
+  const platformFeePercent = 25;
+  const platformFee = Math.round(actualFare * (platformFeePercent / 100) * 100) / 100;
+  const driverPayout = Math.round((actualFare - platformFee + tipAmount) * 100) / 100;
+
+  // Generate receipt
+  const invoiceNumber = `INV-${new Date().getFullYear()}-${String(Date.now()).slice(-8)}`;
+  const receiptUrl = `/receipts/${invoiceNumber}`;
+
+  await env.emit('payment:captured', {
+    rideId: fields.rideId,
+    amount: totalCapture,
+    driverPayout,
+    platformFee,
+  });
+
+  return {
+    success: true,
+    data: {
+      status: 'captured',
+      totalAmount: Math.round(totalCapture * 100) / 100,
+      taxAmount,
+      taxRate,
+      platformFee,
+      platformFeePercent,
+      driverPayout,
+      capturedAt: new Date().toISOString(),
+      invoiceNumber,
+      receiptUrl,
+    },
+  };
+}
+
+/** Settle payment — transfer funds to driver account */
+export async function settlePayment(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  const driverPayout = fields.driverPayout as number;
+  const driverId = fields.driverId as string;
+  const payoutId = `po_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+  // Credit driver's earnings balance
+  await env.update('uber-user', driverId, {
+    earningsBalance: { $increment: driverPayout },
+  });
+
+  await env.emit('payment:settled', {
+    rideId: fields.rideId,
+    driverId,
+    payoutId,
+    amount: driverPayout,
+  });
+
+  return {
+    success: true,
+    data: {
+      status: 'settled',
+      payoutId,
+      payoutStatus: 'completed',
+      settledAt: new Date().toISOString(),
+      payoutCompletedAt: new Date().toISOString(),
+    },
+  };
+}
+
+/** Process a refund — full or partial */
+export async function processRefund(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance, env } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  const refundAmount = fields.refundAmount as number;
+  const totalAmount = fields.totalAmount as number;
+  const isPartial = refundAmount < totalAmount;
+
+  // Reverse platform fee proportionally
+  const refundRatio = refundAmount / totalAmount;
+  const platformFeeRefund = Math.round((fields.platformFee as number) * refundRatio * 100) / 100;
+  const driverPayoutDeduction = Math.round((fields.driverPayout as number) * refundRatio * 100) / 100;
+
+  // Debit driver's earnings balance
+  const driverId = fields.driverId as string;
+  await env.update('uber-user', driverId, {
+    earningsBalance: { $increment: -driverPayoutDeduction },
+  });
+
+  // Credit rider's wallet
+  const riderId = fields.riderId as string;
+  await env.update('uber-user', riderId, {
+    walletBalance: { $increment: refundAmount },
+  });
+
+  await env.emit('payment:refunded', {
+    rideId: fields.rideId,
+    amount: refundAmount,
+    isPartial,
+  });
+
+  return {
+    success: true,
+    data: {
+      status: isPartial ? 'partially_refunded' : 'refunded',
+      refundAmount,
+      refundedAt: new Date().toISOString(),
+    },
+  };
+}
+
+/** Process driver payout to external bank account */
+export async function processDriverPayout(ctx: TransitionContext): Promise<ActionResult> {
+  const { instance } = ctx;
+  const fields = instance.fields as Record<string, unknown>;
+
+  const driverId = fields.driverId as string;
+  const amount = fields.earningsBalance as number;
+
+  if (amount < 25) {
+    return { success: false, data: { reason: 'minimum_payout_not_met', minimum: 25, current: amount } };
+  }
+
+  const payoutId = `payout_${Date.now()}`;
+
+  return {
+    success: true,
+    data: {
+      payoutId,
+      amount,
+      driverId,
+      payoutStatus: 'processing',
+      payoutScheduledAt: new Date().toISOString(),
+    },
+  };
+}