@payloops/processor-core 0.0.1

package/dist/chunk-X2Y2ZUQA.js

@@ -0,0 +1,297 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/activities/index.ts
+var activities_exports = {};
+__export(activities_exports, {
+  capturePayment: () => capturePayment,
+  deliverWebhook: () => deliverWebhook,
+  getMerchantWebhookUrl: () => getMerchantWebhookUrl,
+  getProcessorConfig: () => getProcessorConfig,
+  processPayment: () => processPayment,
+  refundPayment: () => refundPayment,
+  updateOrderStatus: () => updateOrderStatus
+});
+import { eq, and } from "drizzle-orm";
+
+// src/lib/db.ts
+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";
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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")
+});
+var dbInstance = null;
+function getDb() {
+  if (!dbInstance) {
+    const pool = new Pool({
+      connectionString: process.env.DATABASE_URL
+    });
+    dbInstance = drizzle(pool);
+  }
+  return dbInstance;
+}
+
+// src/lib/crypto.ts
+import { createDecipheriv, createHash } from "crypto";
+var ALGORITHM = "aes-256-gcm";
+function getKey() {
+  const key = process.env.ENCRYPTION_KEY;
+  if (!key) throw new Error("ENCRYPTION_KEY not set");
+  return createHash("sha256").update(key).digest();
+}
+function decrypt(encryptedText) {
+  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;
+}
+
+// src/lib/registry.ts
+var processors = /* @__PURE__ */ new Map();
+function registerProcessor(processor) {
+  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}`);
+}
+function getProcessor(name) {
+  const processor = processors.get(name);
+  if (!processor) {
+    throw new Error(`Processor ${name} not found. Available: ${Array.from(processors.keys()).join(", ")}`);
+  }
+  return processor;
+}
+function getRegisteredProcessors() {
+  return Array.from(processors.keys());
+}
+function hasProcessor(name) {
+  return processors.has(name);
+}
+
+// src/activities/index.ts
+import crypto from "crypto";
+async function getProcessorConfig(merchantId, processor) {
+  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
+  };
+}
+async function updateOrderStatus(orderId, status, processorOrderId, processorTransactionId) {
+  const db = getDb();
+  await db.update(orders).set({
+    status,
+    processorOrderId: processorOrderId || void 0,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(eq(orders.id, orderId));
+  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
+      });
+    }
+  }
+}
+async function processPayment(input) {
+  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);
+}
+async function capturePayment(processorOrderId, amount, merchantId, processor) {
+  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);
+}
+async function refundPayment(processorTransactionId, amount, merchantId, processor) {
+  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);
+}
+async function deliverWebhook(webhookEventId, webhookUrl, webhookSecret, payload) {
+  const db = getDb();
+  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 = {
+      "Content-Type": "application/json",
+      "X-Loop-Event-Id": webhookEventId,
+      "X-Loop-Timestamp": String(Date.now())
+    };
+    if (webhookSecret) {
+      const timestamp2 = headers["X-Loop-Timestamp"];
+      const signaturePayload = `${timestamp2}.${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(3e4)
+      // 30 second timeout
+    });
+    const success = response.ok;
+    await db.update(webhookEvents).set({
+      status: success ? "delivered" : "pending",
+      attempts,
+      lastAttemptAt: /* @__PURE__ */ new Date(),
+      deliveredAt: success ? /* @__PURE__ */ new Date() : void 0,
+      nextRetryAt: success ? void 0 : new Date(Date.now() + getRetryDelay(attempts))
+    }).where(eq(webhookEvents.id, webhookEventId));
+    return {
+      success,
+      statusCode: response.status,
+      attempts,
+      deliveredAt: success ? /* @__PURE__ */ new Date() : void 0,
+      errorMessage: success ? void 0 : `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: /* @__PURE__ */ new Date(),
+      nextRetryAt: attempts >= 5 ? void 0 : new Date(Date.now() + getRetryDelay(attempts))
+    }).where(eq(webhookEvents.id, webhookEventId));
+    return {
+      success: false,
+      attempts,
+      errorMessage
+    };
+  }
+}
+async function getMerchantWebhookUrl(merchantId) {
+  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
+  };
+}
+function getRetryDelay(attempt) {
+  const baseDelay = 60 * 1e3;
+  const maxDelay = 24 * 60 * 60 * 1e3;
+  const delay = baseDelay * Math.pow(2, attempt - 1);
+  return Math.min(delay, maxDelay);
+}
+
+export {
+  registerProcessor,
+  getProcessor,
+  getRegisteredProcessors,
+  hasProcessor,
+  getProcessorConfig,
+  updateOrderStatus,
+  processPayment,
+  capturePayment,
+  refundPayment,
+  deliverWebhook,
+  getMerchantWebhookUrl,
+  activities_exports
+};

package/dist/index-CXmmtGo_.d.ts

@@ -0,0 +1,25 @@
+import { a as PaymentConfig, b as PaymentInput, c as PaymentResult, d as RefundResult, e as WebhookDeliveryResult } from './index-CsnpS83V.js';
+
+declare function getProcessorConfig(merchantId: string, processor: string): Promise<PaymentConfig | null>;
+declare function updateOrderStatus(orderId: string, status: string, processorOrderId?: string, processorTransactionId?: string): Promise<void>;
+declare function processPayment(input: PaymentInput): Promise<PaymentResult>;
+declare function capturePayment(processorOrderId: string, amount: number, merchantId: string, processor: string): Promise<PaymentResult>;
+declare function refundPayment(processorTransactionId: string, amount: number, merchantId: string, processor: string): Promise<RefundResult>;
+declare function deliverWebhook(webhookEventId: string, webhookUrl: string, webhookSecret: string | undefined, payload: Record<string, unknown>): Promise<WebhookDeliveryResult>;
+declare function getMerchantWebhookUrl(merchantId: string): Promise<{
+    url: string | null;
+    secret: string | null;
+}>;
+
+declare const index_capturePayment: typeof capturePayment;
+declare const index_deliverWebhook: typeof deliverWebhook;
+declare const index_getMerchantWebhookUrl: typeof getMerchantWebhookUrl;
+declare const index_getProcessorConfig: typeof getProcessorConfig;
+declare const index_processPayment: typeof processPayment;
+declare const index_refundPayment: typeof refundPayment;
+declare const index_updateOrderStatus: typeof updateOrderStatus;
+declare namespace index {
+  export { index_capturePayment as capturePayment, index_deliverWebhook as deliverWebhook, index_getMerchantWebhookUrl as getMerchantWebhookUrl, index_getProcessorConfig as getProcessorConfig, index_processPayment as processPayment, index_refundPayment as refundPayment, index_updateOrderStatus as updateOrderStatus };
+}
+
+export { getMerchantWebhookUrl as a, capturePayment as c, deliverWebhook as d, getProcessorConfig as g, index as i, processPayment as p, refundPayment as r, updateOrderStatus as u };

package/dist/index-CsnpS83V.d.ts

@@ -0,0 +1,72 @@
+interface PaymentConfig {
+    merchantId: string;
+    processor: string;
+    testMode: boolean;
+    credentials: Record<string, string>;
+}
+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;
+    };
+}
+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>;
+}
+interface RefundInput {
+    orderId: string;
+    transactionId: string;
+    amount: number;
+    reason?: string;
+}
+interface RefundResult {
+    success: boolean;
+    refundId?: string;
+    status: 'pending' | 'success' | 'failed';
+    errorCode?: string;
+    errorMessage?: string;
+}
+interface WebhookDeliveryInput {
+    webhookEventId: string;
+    merchantId: string;
+    webhookUrl: string;
+    webhookSecret?: string;
+    payload: Record<string, unknown>;
+}
+interface WebhookDeliveryResult {
+    success: boolean;
+    statusCode?: number;
+    attempts: number;
+    deliveredAt?: Date;
+    errorMessage?: string;
+}
+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>;
+}
+type ProcessorRegistry = Map<string, PaymentProcessor>;
+
+export type { PaymentProcessor as P, RefundInput as R, WebhookDeliveryInput as W, PaymentConfig as a, PaymentInput as b, PaymentResult as c, RefundResult as d, WebhookDeliveryResult as e, ProcessorRegistry as f };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { P as PaymentProcessor } from './index-CsnpS83V.js';
+export { a as PaymentConfig, b as PaymentInput, c as PaymentResult, f as ProcessorRegistry, R as RefundInput, d as RefundResult, W as WebhookDeliveryInput, e as WebhookDeliveryResult } from './index-CsnpS83V.js';
+export { i as activities } from './index-CXmmtGo_.js';
+export { PaymentWorkflow, PaymentWorkflowInput, WebhookDeliveryWorkflow, WebhookDeliveryWorkflowInput } from './workflows/index.js';
+import '@temporalio/common';
+
+declare function registerProcessor(processor: PaymentProcessor): void;
+declare function getProcessor(name: string): PaymentProcessor;
+declare function getRegisteredProcessors(): string[];
+declare function hasProcessor(name: string): boolean;
+
+export { PaymentProcessor, getProcessor, getRegisteredProcessors, hasProcessor, registerProcessor };

package/dist/index.js

@@ -0,0 +1,21 @@
+import {
+  activities_exports,
+  getProcessor,
+  getRegisteredProcessors,
+  hasProcessor,
+  registerProcessor
+} from "./chunk-X2Y2ZUQA.js";
+import {
+  PaymentWorkflow,
+  WebhookDeliveryWorkflow
+} from "./chunk-CZTZBCNV.js";
+import "./chunk-MLKGABMK.js";
+export {
+  PaymentWorkflow,
+  WebhookDeliveryWorkflow,
+  activities_exports as activities,
+  getProcessor,
+  getRegisteredProcessors,
+  hasProcessor,
+  registerProcessor
+};

package/dist/workflows/index.d.ts

@@ -0,0 +1,27 @@
+import * as _temporalio_common from '@temporalio/common';
+import { c as PaymentResult, e as WebhookDeliveryResult } from '../index-CsnpS83V.js';
+
+interface PaymentWorkflowInput {
+    orderId: string;
+    merchantId: string;
+    amount: number;
+    currency: string;
+    processor: string;
+    returnUrl?: string;
+}
+declare const completePaymentSignal: _temporalio_common.SignalDefinition<[{
+    success: boolean;
+    processorTransactionId?: string;
+}], string>;
+declare const cancelPaymentSignal: _temporalio_common.SignalDefinition<[], "cancelPayment">;
+declare function PaymentWorkflow(input: PaymentWorkflowInput): Promise<PaymentResult>;
+
+interface WebhookDeliveryWorkflowInput {
+    webhookEventId: string;
+    merchantId: string;
+    webhookUrl: string;
+    payload: Record<string, unknown>;
+}
+declare function WebhookDeliveryWorkflow(input: WebhookDeliveryWorkflowInput): Promise<WebhookDeliveryResult>;
+
+export { PaymentWorkflow, type PaymentWorkflowInput, WebhookDeliveryWorkflow, type WebhookDeliveryWorkflowInput, cancelPaymentSignal, completePaymentSignal };

package/dist/workflows/index.js

@@ -0,0 +1,13 @@
+import {
+  PaymentWorkflow,
+  WebhookDeliveryWorkflow,
+  cancelPaymentSignal,
+  completePaymentSignal
+} from "../chunk-CZTZBCNV.js";
+import "../chunk-MLKGABMK.js";
+export {
+  PaymentWorkflow,
+  WebhookDeliveryWorkflow,
+  cancelPaymentSignal,
+  completePaymentSignal
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@payloops/processor-core",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./workflows": {
+      "import": "./dist/workflows/index.js",
+      "types": "./dist/workflows/index.d.ts"
+    },
+    "./activities": {
+      "import": "./dist/activities/index.js",
+      "types": "./dist/activities/index.d.ts"
+    }
+  },
+  "scripts": {
+    "dev": "tsx watch src/worker.ts",
+    "build": "tsup src/index.ts src/workflows/index.ts src/activities/index.ts --format esm --dts",
+    "start": "node dist/worker.js",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@astami/temporal-functions": "^0.1.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.53.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.57.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.57.0",
+    "@opentelemetry/sdk-node": "^0.57.0",
+    "@opentelemetry/semantic-conventions": "^1.28.0",
+    "@temporalio/activity": "^1.11.7",
+    "@temporalio/client": "^1.11.7",
+    "@temporalio/worker": "^1.11.7",
+    "@temporalio/workflow": "^1.11.7",
+    "drizzle-orm": "^0.39.1",
+    "pg": "^8.13.1",
+    "pino": "^9.6.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "pino-pretty": "^13.0.0",
+    "@types/pg": "^8.11.10",
+    "eslint": "^9.0.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.9.3"
+  }
+}