@payloops/processor-core 0.0.1

package/src/workflows/payment.ts

@@ -0,0 +1,111 @@
+import { proxyActivities, sleep, continueAsNew, defineSignal, setHandler } from '@temporalio/workflow';
+import type * as activities from '../activities';
+import type { PaymentInput, PaymentResult } from '../types';
+
+const { processPayment, updateOrderStatus, capturePayment } = proxyActivities<typeof activities>({
+  startToCloseTimeout: '2 minutes',
+  retry: {
+    initialInterval: '1s',
+    maximumInterval: '1m',
+    backoffCoefficient: 2,
+    maximumAttempts: 5
+  }
+});
+
+export interface PaymentWorkflowInput {
+  orderId: string;
+  merchantId: string;
+  amount: number;
+  currency: string;
+  processor: string;
+  returnUrl?: string;
+}
+
+// Signals for external events
+export const completePaymentSignal = defineSignal<[{ success: boolean; processorTransactionId?: string }]>(
+  'completePayment'
+);
+
+export const cancelPaymentSignal = defineSignal('cancelPayment');
+
+export async function PaymentWorkflow(input: PaymentWorkflowInput): Promise<PaymentResult> {
+  let paymentCompleted = false;
+  let paymentResult: PaymentResult | null = null;
+  let cancelled = false;
+
+  // Handle external payment completion (3DS, redirect flows)
+  setHandler(completePaymentSignal, (result) => {
+    paymentCompleted = true;
+    paymentResult = {
+      success: result.success,
+      status: result.success ? 'captured' : 'failed',
+      processorTransactionId: result.processorTransactionId
+    };
+  });
+
+  // Handle cancellation
+  setHandler(cancelPaymentSignal, () => {
+    cancelled = true;
+  });
+
+  try {
+    // Step 1: Process payment
+    const result = await processPayment({
+      orderId: input.orderId,
+      merchantId: input.merchantId,
+      amount: input.amount,
+      currency: input.currency,
+      processor: input.processor,
+      returnUrl: input.returnUrl
+    });
+
+    // If payment requires redirect (3DS, UPI, etc.)
+    if (result.status === 'requires_action') {
+      await updateOrderStatus(input.orderId, 'requires_action', result.processorOrderId);
+
+      // Wait for completion signal (with timeout)
+      const timeout = 15 * 60 * 1000; // 15 minutes
+      const startTime = Date.now();
+
+      while (!paymentCompleted && !cancelled && Date.now() - startTime < timeout) {
+        await sleep('10 seconds');
+      }
+
+      if (cancelled) {
+        await updateOrderStatus(input.orderId, 'cancelled');
+        return { success: false, status: 'failed', errorCode: 'cancelled', errorMessage: 'Payment cancelled' };
+      }
+
+      if (!paymentCompleted) {
+        await updateOrderStatus(input.orderId, 'failed');
+        return { success: false, status: 'failed', errorCode: 'timeout', errorMessage: 'Payment timeout' };
+      }
+
+      if (paymentResult !== null) {
+        const finalResult = paymentResult as PaymentResult;
+        await updateOrderStatus(
+          input.orderId,
+          finalResult.status,
+          result.processorOrderId,
+          finalResult.processorTransactionId
+        );
+        return finalResult;
+      }
+    }
+
+    // Update order with result
+    await updateOrderStatus(input.orderId, result.status, result.processorOrderId, result.processorTransactionId);
+
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    await updateOrderStatus(input.orderId, 'failed');
+
+    return {
+      success: false,
+      status: 'failed',
+      errorCode: 'workflow_error',
+      errorMessage
+    };
+  }
+}

package/src/workflows/webhook.ts

@@ -0,0 +1,64 @@
+import { proxyActivities, sleep } from '@temporalio/workflow';
+import type * as activities from '../activities';
+import type { WebhookDeliveryResult } from '../types';
+
+const { deliverWebhook, getMerchantWebhookUrl } = proxyActivities<typeof activities>({
+  startToCloseTimeout: '1 minute',
+  retry: {
+    initialInterval: '1s',
+    maximumInterval: '30s',
+    backoffCoefficient: 2,
+    maximumAttempts: 3
+  }
+});
+
+export interface WebhookDeliveryWorkflowInput {
+  webhookEventId: string;
+  merchantId: string;
+  webhookUrl: string;
+  payload: Record<string, unknown>;
+}
+
+const MAX_ATTEMPTS = 5;
+const RETRY_DELAYS = [
+  60 * 1000, // 1 minute
+  5 * 60 * 1000, // 5 minutes
+  30 * 60 * 1000, // 30 minutes
+  2 * 60 * 60 * 1000, // 2 hours
+  24 * 60 * 60 * 1000 // 24 hours
+];
+
+export async function WebhookDeliveryWorkflow(input: WebhookDeliveryWorkflowInput): Promise<WebhookDeliveryResult> {
+  // Get merchant's webhook secret
+  const { secret } = await getMerchantWebhookUrl(input.merchantId);
+
+  let attempt = 0;
+  let lastResult: WebhookDeliveryResult | null = null;
+
+  while (attempt < MAX_ATTEMPTS) {
+    attempt++;
+
+    const result = await deliverWebhook(input.webhookEventId, input.webhookUrl, secret || undefined, input.payload);
+
+    lastResult = result;
+
+    if (result.success) {
+      return result;
+    }
+
+    // If we've exhausted all attempts, return failure
+    if (attempt >= MAX_ATTEMPTS) {
+      return {
+        success: false,
+        attempts: attempt,
+        errorMessage: result.errorMessage || 'Max attempts reached'
+      };
+    }
+
+    // Wait before next retry
+    const delay = RETRY_DELAYS[attempt - 1] || RETRY_DELAYS[RETRY_DELAYS.length - 1];
+    await sleep(delay);
+  }
+
+  return lastResult || { success: false, attempts: attempt, errorMessage: 'Unknown error' };
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}