@payloops/processor-core 0.0.1 → 0.0.8

package/src/lib/crypto.ts

@@ -1,24 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

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

package/src/lib/observability/logger.ts

@@ -1,44 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,105 +0,0 @@
-// 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

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

package/src/workflows/payment.ts

@@ -1,111 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,20 +0,0 @@
-{
-  "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"]
-}