@singularity-payments/elysia 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,514 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MpesaClient: () => import_core2.MpesaClient,
+  createMpesa: () => createMpesa,
+  createMpesaHandlers: () => createMpesaHandlers
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@singularity-payments/core");
+var import_elysia = require("elysia");
+
+// src/handlers.ts
+function createMpesaHandlers(client) {
+  const handlers = {
+    stkCallback: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const ipAddress = ctx.request.headers.get("x-forwarded-for") || ctx.request.headers.get("x-real-ip") || void 0;
+        const response = await client.handleSTKCallback(body, ipAddress);
+        ctx.set.status = 200;
+        return response;
+      } catch (error) {
+        console.error("STK Callback error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Internal error processing callback"
+        };
+      }
+    },
+    c2bValidation: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const response = await client.handleC2BValidation(body);
+        ctx.set.status = 200;
+        return response;
+      } catch (error) {
+        console.error("C2B Validation error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Validation failed"
+        };
+      }
+    },
+    c2bConfirmation: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const response = await client.handleC2BConfirmation(body);
+        ctx.set.status = 200;
+        return response;
+      } catch (error) {
+        console.error("C2B Confirmation error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    b2cResult: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const parsed = client.getCallbackHandler().parseB2CCallback(body);
+        console.log("B2C Result:", parsed);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Accepted"
+        };
+      } catch (error) {
+        console.error("B2C Result error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    b2cTimeout: async (ctx) => {
+      try {
+        const body = ctx.body;
+        console.log("B2C Timeout:", body);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Timeout received"
+        };
+      } catch (error) {
+        console.error("B2C Timeout error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    b2bResult: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const parsed = client.getCallbackHandler().parseB2BCallback(body);
+        console.log("B2B Result:", parsed);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Accepted"
+        };
+      } catch (error) {
+        console.error("B2B Result error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    b2bTimeout: async (ctx) => {
+      try {
+        const body = ctx.body;
+        console.log("B2B Timeout:", body);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Timeout received"
+        };
+      } catch (error) {
+        console.error("B2B Timeout error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    balanceResult: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const parsed = client.getCallbackHandler().parseAccountBalanceCallback(body);
+        console.log("Balance Result:", parsed);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Accepted"
+        };
+      } catch (error) {
+        console.error("Balance Result error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    balanceTimeout: async (ctx) => {
+      try {
+        const body = ctx.body;
+        console.log("Balance Timeout:", body);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Timeout received"
+        };
+      } catch (error) {
+        console.error("Balance Timeout error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    reversalResult: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const parsed = client.getCallbackHandler().parseReversalCallback(body);
+        console.log("Reversal Result:", parsed);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Accepted"
+        };
+      } catch (error) {
+        console.error("Reversal Result error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    reversalTimeout: async (ctx) => {
+      try {
+        const body = ctx.body;
+        console.log("Reversal Timeout:", body);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Timeout received"
+        };
+      } catch (error) {
+        console.error("Reversal Timeout error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    statusResult: async (ctx) => {
+      try {
+        const body = ctx.body;
+        const parsed = client.getCallbackHandler().parseTransactionStatusCallback(body);
+        console.log("Status Result:", parsed);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Accepted"
+        };
+      } catch (error) {
+        console.error("Status Result error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    statusTimeout: async (ctx) => {
+      try {
+        const body = ctx.body;
+        console.log("Status Timeout:", body);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 0,
+          ResultDesc: "Timeout received"
+        };
+      } catch (error) {
+        console.error("Status Timeout error:", error);
+        ctx.set.status = 200;
+        return {
+          ResultCode: 1,
+          ResultDesc: "Processing failed"
+        };
+      }
+    },
+    stkPush: async (ctx) => {
+      try {
+        const {
+          amount,
+          phoneNumber,
+          accountReference,
+          transactionDesc,
+          callbackUrl
+        } = ctx.body;
+        if (!amount || !phoneNumber) {
+          ctx.set.status = 400;
+          return { error: "Amount and phone number are required" };
+        }
+        const response = await client.stkPush({
+          amount: Number(amount),
+          phoneNumber: String(phoneNumber),
+          accountReference: accountReference || "Payment",
+          transactionDesc: transactionDesc || "Payment",
+          callbackUrl
+        });
+        return response;
+      } catch (error) {
+        console.error("STK Push error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    stkQuery: async (ctx) => {
+      try {
+        const { CheckoutRequestID } = ctx.body;
+        if (!CheckoutRequestID) {
+          ctx.set.status = 400;
+          return { error: "CheckoutRequestID is required" };
+        }
+        const response = await client.stkQuery({ CheckoutRequestID });
+        return response;
+      } catch (error) {
+        console.error("STK Query error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    b2c: async (ctx) => {
+      try {
+        const {
+          amount,
+          phoneNumber,
+          commandID,
+          remarks,
+          occasion,
+          resultUrl,
+          timeoutUrl
+        } = ctx.body;
+        if (!amount || !phoneNumber || !commandID) {
+          ctx.set.status = 400;
+          return {
+            error: "Amount, phone number, and command ID are required"
+          };
+        }
+        const response = await client.b2c({
+          amount: Number(amount),
+          phoneNumber: String(phoneNumber),
+          commandID,
+          remarks: remarks || "Payment",
+          occasion,
+          resultUrl,
+          timeoutUrl
+        });
+        return response;
+      } catch (error) {
+        console.error("B2C error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    b2b: async (ctx) => {
+      try {
+        const {
+          amount,
+          partyB,
+          commandID,
+          senderIdentifierType,
+          receiverIdentifierType,
+          accountReference,
+          remarks,
+          resultUrl,
+          timeoutUrl
+        } = ctx.body;
+        console.log("B2B Request Parameters:", {
+          amount,
+          partyB,
+          commandID,
+          senderIdentifierType,
+          receiverIdentifierType,
+          accountReference,
+          remarks
+        });
+        if (!amount || !partyB || !commandID || !accountReference) {
+          ctx.set.status = 400;
+          return {
+            error: "Amount, partyB, commandID, and account reference are required"
+          };
+        }
+        const response = await client.b2b({
+          amount: Number(amount),
+          partyB: String(partyB),
+          commandID,
+          senderIdentifierType,
+          receiverIdentifierType,
+          accountReference: String(accountReference),
+          remarks: remarks || "Payment",
+          resultUrl,
+          timeoutUrl
+        });
+        console.log("B2B Response:", response);
+        return response;
+      } catch (error) {
+        console.error("B2B error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    balance: async (ctx) => {
+      try {
+        const response = await client.accountBalance(
+          ctx.body
+        );
+        return response;
+      } catch (error) {
+        console.error("Balance error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    transactionStatus: async (ctx) => {
+      try {
+        const { transactionID } = ctx.body;
+        if (!transactionID) {
+          ctx.set.status = 400;
+          return { error: "Transaction ID is required" };
+        }
+        const response = await client.transactionStatus(ctx.body);
+        return response;
+      } catch (error) {
+        console.error("Transaction Status error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    reversal: async (ctx) => {
+      try {
+        const { transactionID, amount } = ctx.body;
+        if (!transactionID || !amount) {
+          ctx.set.status = 400;
+          return { error: "Transaction ID and amount are required" };
+        }
+        const response = await client.reversal(ctx.body);
+        return response;
+      } catch (error) {
+        console.error("Reversal error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    registerC2B: async (ctx) => {
+      try {
+        const { shortCode, responseType, confirmationURL, validationURL } = ctx.body;
+        if (!confirmationURL || !validationURL) {
+          ctx.set.status = 400;
+          return {
+            error: "Confirmation URL and validation URL are required"
+          };
+        }
+        const response = await client.registerC2BUrl({
+          shortCode,
+          responseType,
+          confirmationURL,
+          validationURL
+        });
+        return response;
+      } catch (error) {
+        console.error("Register C2B error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    },
+    generateQR: async (ctx) => {
+      try {
+        const {
+          merchantName,
+          refNo,
+          amount,
+          transactionType,
+          creditPartyIdentifier,
+          size
+        } = ctx.body;
+        if (!merchantName || !refNo || !amount || !transactionType || !creditPartyIdentifier) {
+          ctx.set.status = 400;
+          return {
+            error: "Merchant name, reference number, amount, transaction type, and credit party identifier are required",
+            received: ctx.body
+          };
+        }
+        let qrSize = void 0;
+        if (size) {
+          if (size !== "500" && size !== "300") {
+            ctx.set.status = 400;
+            return {
+              error: "Size must be either '300' or '500'"
+            };
+          }
+          qrSize = size;
+        }
+        const response = await client.generateDynamicQR({
+          merchantName,
+          refNo,
+          amount: Number(amount),
+          transactionType,
+          creditPartyIdentifier,
+          size: qrSize
+        });
+        return response;
+      } catch (error) {
+        console.error("Generate QR error:", error);
+        ctx.set.status = 500;
+        return { error: error.message || "Request failed" };
+      }
+    }
+  };
+  return handlers;
+}
+
+// src/index.ts
+var import_core2 = require("@singularity-payments/core");
+function createMpesa(config, options) {
+  const client = new import_core.MpesaClient(config, options);
+  const handlers = createMpesaHandlers(client);
+  const app = new import_elysia.Elysia({ prefix: "/mpesa" }).post("/stk-push", handlers.stkPush).post("/stk-query", handlers.stkQuery).post("/callback", handlers.stkCallback).post("/b2c", handlers.b2c).post("/b2b", handlers.b2b).post("/balance", handlers.balance).post("/transaction-status", handlers.transactionStatus).post("/reversal", handlers.reversal).post("/register-c2b", handlers.registerC2B).post("/generate-qr", handlers.generateQR).post("/c2b-validation", handlers.c2bValidation).post("/c2b-confirmation", handlers.c2bConfirmation).post("/b2c-result", handlers.b2cResult).post("/b2c-timeout", handlers.b2cTimeout).post("/b2b-result", handlers.b2bResult).post("/b2b-timeout", handlers.b2bTimeout).post("/balance-result", handlers.balanceResult).post("/balance-timeout", handlers.balanceTimeout).post("/reversal-result", handlers.reversalResult).post("/reversal-timeout", handlers.reversalTimeout).post("/status-result", handlers.statusResult).post("/status-timeout", handlers.statusTimeout);
+  return {
+    client,
+    handlers,
+    app
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MpesaClient,
+  createMpesa,
+  createMpesaHandlers
+});