@payloops/processor-core 0.0.1

package/src/activities/index.ts

@@ -0,0 +1,224 @@
+import { eq, and } from 'drizzle-orm';
+import { getDb, orders, transactions, processorConfigs, webhookEvents, merchants } from '../lib/db';
+import { decrypt } from '../lib/crypto';
+import { getProcessor } from '../lib/registry';
+import type { PaymentInput, PaymentResult, PaymentConfig, RefundResult, WebhookDeliveryResult } from '../types';
+import crypto from 'crypto';
+
+// Get processor config for a merchant
+export async function getProcessorConfig(
+  merchantId: string,
+  processor: string
+): Promise<PaymentConfig | null> {
+  const db = getDb();
+
+  const config = await db
+    .select()
+    .from(processorConfigs)
+    .where(and(eq(processorConfigs.merchantId, merchantId), eq(processorConfigs.processor, processor)))
+    .limit(1);
+
+  if (config.length === 0) return null;
+
+  const credentials = JSON.parse(decrypt(config[0].credentialsEncrypted));
+
+  return {
+    merchantId,
+    processor,
+    testMode: config[0].testMode,
+    credentials
+  };
+}
+
+// Update order status
+export async function updateOrderStatus(
+  orderId: string,
+  status: string,
+  processorOrderId?: string,
+  processorTransactionId?: string
+): Promise<void> {
+  const db = getDb();
+
+  await db
+    .update(orders)
+    .set({
+      status,
+      processorOrderId: processorOrderId || undefined,
+      updatedAt: new Date()
+    })
+    .where(eq(orders.id, orderId));
+
+  // Create transaction record if we have a transaction id
+  if (processorTransactionId) {
+    const order = await db.select().from(orders).where(eq(orders.id, orderId)).limit(1);
+
+    if (order.length > 0) {
+      await db.insert(transactions).values({
+        orderId,
+        type: status === 'captured' ? 'capture' : status === 'authorized' ? 'authorization' : 'authorization',
+        amount: order[0].amount,
+        status: status === 'failed' ? 'failed' : 'success',
+        processorTransactionId
+      });
+    }
+  }
+}
+
+// Process payment using the appropriate processor
+export async function processPayment(input: PaymentInput): Promise<PaymentResult> {
+  const config = await getProcessorConfig(input.merchantId, input.processor);
+
+  if (!config) {
+    return {
+      success: false,
+      status: 'failed',
+      errorCode: 'no_processor_config',
+      errorMessage: `Processor ${input.processor} not configured for merchant`
+    };
+  }
+
+  const processor = getProcessor(input.processor);
+  return processor.createPayment(input, config);
+}
+
+// Capture a payment
+export async function capturePayment(
+  processorOrderId: string,
+  amount: number,
+  merchantId: string,
+  processor: string
+): Promise<PaymentResult> {
+  const config = await getProcessorConfig(merchantId, processor);
+
+  if (!config) {
+    return {
+      success: false,
+      status: 'failed',
+      errorCode: 'no_processor_config',
+      errorMessage: `Processor ${processor} not configured`
+    };
+  }
+
+  const processorInstance = getProcessor(processor);
+  return processorInstance.capturePayment(processorOrderId, amount, config);
+}
+
+// Refund a payment
+export async function refundPayment(
+  processorTransactionId: string,
+  amount: number,
+  merchantId: string,
+  processor: string
+): Promise<RefundResult> {
+  const config = await getProcessorConfig(merchantId, processor);
+
+  if (!config) {
+    return {
+      success: false,
+      status: 'failed',
+      errorCode: 'no_processor_config',
+      errorMessage: `Processor ${processor} not configured`
+    };
+  }
+
+  const processorInstance = getProcessor(processor);
+  return processorInstance.refundPayment(processorTransactionId, amount, config);
+}
+
+// Deliver webhook to merchant
+export async function deliverWebhook(
+  webhookEventId: string,
+  webhookUrl: string,
+  webhookSecret: string | undefined,
+  payload: Record<string, unknown>
+): Promise<WebhookDeliveryResult> {
+  const db = getDb();
+
+  // Get current attempt count
+  const event = await db.select().from(webhookEvents).where(eq(webhookEvents.id, webhookEventId)).limit(1);
+
+  const attempts = (event[0]?.attempts || 0) + 1;
+
+  try {
+    const body = JSON.stringify(payload);
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'X-Loop-Event-Id': webhookEventId,
+      'X-Loop-Timestamp': String(Date.now())
+    };
+
+    // Sign the webhook if secret is provided
+    if (webhookSecret) {
+      const timestamp = headers['X-Loop-Timestamp'];
+      const signaturePayload = `${timestamp}.${body}`;
+      const signature = crypto.createHmac('sha256', webhookSecret).update(signaturePayload).digest('hex');
+      headers['X-Loop-Signature'] = `v1=${signature}`;
+    }
+
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers,
+      body,
+      signal: AbortSignal.timeout(30000) // 30 second timeout
+    });
+
+    const success = response.ok;
+
+    await db
+      .update(webhookEvents)
+      .set({
+        status: success ? 'delivered' : 'pending',
+        attempts,
+        lastAttemptAt: new Date(),
+        deliveredAt: success ? new Date() : undefined,
+        nextRetryAt: success ? undefined : new Date(Date.now() + getRetryDelay(attempts))
+      })
+      .where(eq(webhookEvents.id, webhookEventId));
+
+    return {
+      success,
+      statusCode: response.status,
+      attempts,
+      deliveredAt: success ? new Date() : undefined,
+      errorMessage: success ? undefined : `HTTP ${response.status}`
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+    await db
+      .update(webhookEvents)
+      .set({
+        status: attempts >= 5 ? 'failed' : 'pending',
+        attempts,
+        lastAttemptAt: new Date(),
+        nextRetryAt: attempts >= 5 ? undefined : new Date(Date.now() + getRetryDelay(attempts))
+      })
+      .where(eq(webhookEvents.id, webhookEventId));
+
+    return {
+      success: false,
+      attempts,
+      errorMessage
+    };
+  }
+}
+
+// Get merchant webhook URL
+export async function getMerchantWebhookUrl(merchantId: string): Promise<{ url: string | null; secret: string | null }> {
+  const db = getDb();
+
+  const merchant = await db.select().from(merchants).where(eq(merchants.id, merchantId)).limit(1);
+
+  return {
+    url: merchant[0]?.webhookUrl || null,
+    secret: merchant[0]?.webhookSecret || null
+  };
+}
+
+// Exponential backoff for retries
+function getRetryDelay(attempt: number): number {
+  const baseDelay = 60 * 1000; // 1 minute
+  const maxDelay = 24 * 60 * 60 * 1000; // 24 hours
+  const delay = baseDelay * Math.pow(2, attempt - 1);
+  return Math.min(delay, maxDelay);
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+// Core types
+export type {
+  PaymentConfig,
+  PaymentInput,
+  PaymentResult,
+  RefundInput,
+  RefundResult,
+  WebhookDeliveryInput,
+  WebhookDeliveryResult,
+  PaymentProcessor,
+  ProcessorRegistry
+} from './types';
+
+// Processor registry
+export { registerProcessor, getProcessor, getRegisteredProcessors, hasProcessor } from './lib/registry';
+
+// Activities (for worker registration)
+export * as activities from './activities';
+
+// Workflows
+export { PaymentWorkflow, WebhookDeliveryWorkflow } from './workflows';
+export type { PaymentWorkflowInput, WebhookDeliveryWorkflowInput } from './workflows';

package/src/lib/crypto.ts

@@ -0,0 +1,24 @@
+import { createCipheriv, createDecipheriv, createHash } from 'crypto';
+
+const ALGORITHM = 'aes-256-gcm';
+
+function getKey(): Buffer {
+  const key = process.env.ENCRYPTION_KEY;
+  if (!key) throw new Error('ENCRYPTION_KEY not set');
+  return createHash('sha256').update(key).digest();
+}
+
+export function decrypt(encryptedText: string): string {
+  const [ivHex, authTagHex, encrypted] = encryptedText.split(':');
+
+  const iv = Buffer.from(ivHex, 'hex');
+  const authTag = Buffer.from(authTagHex, 'hex');
+  const decipher = createDecipheriv(ALGORITHM, getKey(), iv);
+
+  decipher.setAuthTag(authTag);
+
+  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+
+  return decrypted;
+}

package/src/lib/db.ts

@@ -0,0 +1,91 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import {
+  pgTable,
+  text,
+  timestamp,
+  integer,
+  boolean,
+  jsonb,
+  varchar,
+  uuid
+} from 'drizzle-orm/pg-core';
+
+// Schema definitions (shared with backend)
+export const orders = pgTable('orders', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  merchantId: uuid('merchant_id').notNull(),
+  externalId: varchar('external_id', { length: 255 }).notNull(),
+  amount: integer('amount').notNull(),
+  currency: varchar('currency', { length: 3 }).notNull().default('USD'),
+  status: varchar('status', { length: 50 }).notNull().default('pending'),
+  processor: varchar('processor', { length: 50 }),
+  processorOrderId: varchar('processor_order_id', { length: 255 }),
+  metadata: jsonb('metadata').default({}),
+  workflowId: varchar('workflow_id', { length: 255 }),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull()
+});
+
+export const transactions = pgTable('transactions', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  orderId: uuid('order_id').notNull(),
+  type: varchar('type', { length: 50 }).notNull(),
+  amount: integer('amount').notNull(),
+  status: varchar('status', { length: 50 }).notNull().default('pending'),
+  processorTransactionId: varchar('processor_transaction_id', { length: 255 }),
+  processorResponse: jsonb('processor_response'),
+  errorCode: varchar('error_code', { length: 100 }),
+  errorMessage: text('error_message'),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+});
+
+export const processorConfigs = pgTable('processor_configs', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  merchantId: uuid('merchant_id').notNull(),
+  processor: varchar('processor', { length: 50 }).notNull(),
+  credentialsEncrypted: text('credentials_encrypted').notNull(),
+  priority: integer('priority').notNull().default(1),
+  enabled: boolean('enabled').notNull().default(true),
+  testMode: boolean('test_mode').notNull().default(true),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull()
+});
+
+export const webhookEvents = pgTable('webhook_events', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  merchantId: uuid('merchant_id').notNull(),
+  orderId: uuid('order_id'),
+  eventType: varchar('event_type', { length: 100 }).notNull(),
+  payload: jsonb('payload').notNull(),
+  status: varchar('status', { length: 50 }).notNull().default('pending'),
+  attempts: integer('attempts').notNull().default(0),
+  lastAttemptAt: timestamp('last_attempt_at'),
+  nextRetryAt: timestamp('next_retry_at'),
+  deliveredAt: timestamp('delivered_at'),
+  workflowId: varchar('workflow_id', { length: 255 }),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+});
+
+export const merchants = pgTable('merchants', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  name: varchar('name', { length: 255 }).notNull(),
+  email: varchar('email', { length: 255 }).notNull().unique(),
+  webhookUrl: text('webhook_url'),
+  webhookSecret: text('webhook_secret')
+});
+
+// Database connection
+let dbInstance: ReturnType<typeof drizzle> | null = null;
+
+export function getDb() {
+  if (!dbInstance) {
+    const pool = new Pool({
+      connectionString: process.env.DATABASE_URL
+    });
+    dbInstance = drizzle(pool);
+  }
+  return dbInstance;
+}
+
+export type Database = ReturnType<typeof getDb>;

package/src/lib/observability/index.ts

@@ -0,0 +1,2 @@
+export { initTelemetry } from './otel';
+export { logger, createActivityLogger, createWorkflowLogger } from './logger';

package/src/lib/observability/logger.ts

@@ -0,0 +1,44 @@
+import pino from 'pino';
+import { trace } from '@opentelemetry/api';
+
+const NODE_ENV = process.env.NODE_ENV || 'development';
+const SERVICE_NAME = process.env.OTEL_SERVICE_NAME || 'loop-processor-core';
+
+const traceMixin = () => {
+  const span = trace.getActiveSpan();
+  if (!span) return {};
+
+  const spanContext = span.spanContext();
+  return {
+    trace_id: spanContext.traceId,
+    span_id: spanContext.spanId
+  };
+};
+
+export const logger = pino({
+  level: NODE_ENV === 'production' ? 'info' : 'debug',
+  mixin: traceMixin,
+  base: {
+    service: SERVICE_NAME,
+    env: NODE_ENV
+  },
+  timestamp: pino.stdTimeFunctions.isoTime,
+  transport:
+    NODE_ENV !== 'production'
+      ? { target: 'pino-pretty', options: { colorize: true } }
+      : undefined
+});
+
+export function createActivityLogger(activityName: string, correlationId?: string) {
+  return logger.child({
+    activity: activityName,
+    correlationId
+  });
+}
+
+export function createWorkflowLogger(workflowId: string, correlationId?: string) {
+  return logger.child({
+    workflowId,
+    correlationId
+  });
+}

package/src/lib/observability/otel.ts

@@ -0,0 +1,53 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { Resource } from '@opentelemetry/resources';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+
+let sdk: NodeSDK | null = null;
+
+export function initTelemetry(serviceName: string, serviceVersion = '0.0.1'): NodeSDK {
+  if (sdk) return sdk;
+
+  const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318';
+
+  sdk = new NodeSDK({
+    resource: new Resource({
+      [ATTR_SERVICE_NAME]: serviceName,
+      [ATTR_SERVICE_VERSION]: serviceVersion,
+      'deployment.environment': process.env.NODE_ENV || 'development'
+    }),
+
+    traceExporter: new OTLPTraceExporter({
+      url: `${otlpEndpoint}/v1/traces`
+    }),
+
+    metricReader: new PeriodicExportingMetricReader({
+      exporter: new OTLPMetricExporter({
+        url: `${otlpEndpoint}/v1/metrics`
+      }),
+      exportIntervalMillis: 30000
+    }),
+
+    instrumentations: [
+      getNodeAutoInstrumentations({
+        '@opentelemetry/instrumentation-fs': { enabled: false },
+        '@opentelemetry/instrumentation-http': { enabled: true },
+        '@opentelemetry/instrumentation-pg': { enabled: true }
+      })
+    ]
+  });
+
+  sdk.start();
+
+  process.on('SIGTERM', () => {
+    sdk
+      ?.shutdown()
+      .then(() => console.log('Telemetry shut down'))
+      .catch((err) => console.error('Telemetry shutdown error', err));
+  });
+
+  return sdk;
+}

package/src/lib/registry.ts

@@ -0,0 +1,28 @@
+import type { PaymentProcessor, ProcessorRegistry } from '../types';
+
+// Global processor registry
+const processors: ProcessorRegistry = new Map();
+
+export function registerProcessor(processor: PaymentProcessor): void {
+  if (processors.has(processor.name)) {
+    throw new Error(`Processor ${processor.name} is already registered`);
+  }
+  processors.set(processor.name, processor);
+  console.log(`Registered processor: ${processor.name}`);
+}
+
+export function getProcessor(name: string): PaymentProcessor {
+  const processor = processors.get(name);
+  if (!processor) {
+    throw new Error(`Processor ${name} not found. Available: ${Array.from(processors.keys()).join(', ')}`);
+  }
+  return processor;
+}
+
+export function getRegisteredProcessors(): string[] {
+  return Array.from(processors.keys());
+}
+
+export function hasProcessor(name: string): boolean {
+  return processors.has(name);
+}

package/src/types/index.ts

@@ -0,0 +1,95 @@
+export interface PaymentConfig {
+  merchantId: string;
+  processor: string;
+  testMode: boolean;
+  credentials: Record<string, string>;
+}
+
+export interface PaymentInput {
+  orderId: string;
+  merchantId: string;
+  amount: number;
+  currency: string;
+  processor: string;
+  returnUrl?: string;
+  cancelUrl?: string;
+  metadata?: Record<string, unknown>;
+  customer?: {
+    id?: string;
+    email?: string;
+    name?: string;
+  };
+  paymentMethod?: {
+    type: 'card' | 'upi' | 'netbanking' | 'wallet';
+    token?: string;
+  };
+}
+
+export interface PaymentResult {
+  success: boolean;
+  status: 'authorized' | 'captured' | 'failed' | 'pending' | 'requires_action';
+  processorOrderId?: string;
+  processorTransactionId?: string;
+  redirectUrl?: string;
+  errorCode?: string;
+  errorMessage?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface RefundInput {
+  orderId: string;
+  transactionId: string;
+  amount: number;
+  reason?: string;
+}
+
+export interface RefundResult {
+  success: boolean;
+  refundId?: string;
+  status: 'pending' | 'success' | 'failed';
+  errorCode?: string;
+  errorMessage?: string;
+}
+
+export interface WebhookDeliveryInput {
+  webhookEventId: string;
+  merchantId: string;
+  webhookUrl: string;
+  webhookSecret?: string;
+  payload: Record<string, unknown>;
+}
+
+export interface WebhookDeliveryResult {
+  success: boolean;
+  statusCode?: number;
+  attempts: number;
+  deliveredAt?: Date;
+  errorMessage?: string;
+}
+
+// Processor interface that each processor must implement
+export interface PaymentProcessor {
+  name: string;
+
+  createPayment(input: PaymentInput, config: PaymentConfig): Promise<PaymentResult>;
+
+  capturePayment(
+    processorOrderId: string,
+    amount: number,
+    config: PaymentConfig
+  ): Promise<PaymentResult>;
+
+  refundPayment(
+    processorTransactionId: string,
+    amount: number,
+    config: PaymentConfig
+  ): Promise<RefundResult>;
+
+  getPaymentStatus(
+    processorOrderId: string,
+    config: PaymentConfig
+  ): Promise<PaymentResult>;
+}
+
+// Processor registry type
+export type ProcessorRegistry = Map<string, PaymentProcessor>;

package/src/worker.ts

@@ -0,0 +1,105 @@
+// Initialize OpenTelemetry FIRST, before any other imports
+import { initTelemetry } from './lib/observability/otel';
+initTelemetry(process.env.OTEL_SERVICE_NAME || 'loop-processor-core', '0.0.1');
+
+import { Worker, NativeConnection } from '@temporalio/worker';
+import { trace, SpanStatusCode } from '@opentelemetry/api';
+import * as activities from './activities';
+import { logger } from './lib/observability/logger';
+
+const tracer = trace.getTracer('loop-processor-core');
+
+async function run() {
+  const connection = await NativeConnection.connect({
+    address: process.env.TEMPORAL_ADDRESS || 'localhost:7233'
+  });
+
+  const worker = await Worker.create({
+    connection,
+    namespace: process.env.TEMPORAL_NAMESPACE || 'loop',
+    taskQueue: 'payment-queue',
+    workflowsPath: new URL('./workflows/index.js', import.meta.url).pathname,
+    activities,
+    interceptors: {
+      activityInbound: [
+        (ctx) => ({
+          async execute(input, next) {
+            const activityType = ctx.info.activityType;
+            const workflowId = ctx.info.workflowExecution.workflowId;
+
+            const span = tracer.startSpan(`activity.${activityType}`, {
+              attributes: {
+                'temporal.activity.type': activityType,
+                'temporal.workflow.id': workflowId,
+                'temporal.task_queue': ctx.info.taskQueue
+              }
+            });
+
+            logger.info(
+              {
+                activity: activityType,
+                workflowId
+              },
+              'Activity started'
+            );
+
+            const startTime = Date.now();
+
+            try {
+              const result = await next(input);
+
+              span.setStatus({ code: SpanStatusCode.OK });
+
+              logger.info(
+                {
+                  activity: activityType,
+                  workflowId,
+                  duration: Date.now() - startTime
+                },
+                'Activity completed'
+              );
+
+              return result;
+            } catch (error) {
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : 'Unknown error'
+              });
+              span.recordException(error as Error);
+
+              logger.error(
+                {
+                  activity: activityType,
+                  workflowId,
+                  error,
+                  duration: Date.now() - startTime
+                },
+                'Activity failed'
+              );
+
+              throw error;
+            } finally {
+              span.end();
+            }
+          }
+        })
+      ]
+    }
+  });
+
+  logger.info(
+    {
+      taskQueue: 'payment-queue',
+      namespace: process.env.TEMPORAL_NAMESPACE || 'loop',
+      temporalAddress: process.env.TEMPORAL_ADDRESS || 'localhost:7233'
+    },
+    'Starting Temporal worker'
+  );
+
+  await worker.run();
+}
+
+run().catch((err) => {
+  logger.error({ error: err }, 'Worker failed');
+  process.exit(1);
+});

package/src/workflows/index.ts

@@ -0,0 +1,5 @@
+export { PaymentWorkflow, completePaymentSignal, cancelPaymentSignal } from './payment';
+export type { PaymentWorkflowInput } from './payment';
+
+export { WebhookDeliveryWorkflow } from './webhook';
+export type { WebhookDeliveryWorkflowInput } from './webhook';