@nile-squad/nylonpay-ts 1.0.0 → 1.0.1

package/README.md

@@ -35,14 +35,13 @@ payment.on("failed", ({ error }) => notifyCustomer(error));
 
 ## Configuration
 
-> Test vs. live mode is selected by your API key — a sandbox key routes to test
-> providers, a live key processes real money. There is no `environment` option.
+Use your test keys to work in sandbox, or your production keys to go live. There is no separate `environment` option — the key determines the mode.
 
 | Option | Required | Default | Description |
 |---|---|---|---|
 | `apiKey` | Yes | | Must start with `npk_` |
 | `apiSecret` | Yes | | Must start with `nps_` |
-| `baseUrl` | No | `https://api.nylonpay.io/api/services` | API endpoint |
+| `baseUrl` | No | Default is used | Override only if self-hosting |
 | `timeoutMs` | No | `30000` | Request timeout in milliseconds |
 | `maxRetries` | No | `3` | Retry count for failed requests |
 | `maxPollIntervalMs` | No | `2000` | Polling interval for async payments |
@@ -170,7 +169,7 @@ app.post("/webhooks", (req, res) => {
   const isValid = nylonpay.verifyWebhookSignature({
     payload: req.rawBody,
     signature: req.headers["x-nylon-signature"],
-    secret: process.env.NYLONPAY_WEBHOOK_SECRET,
+    secret: "nps_...",
   });
 
   if (!isValid) return res.status(401).send("Invalid signature");

package/dist/index.cjs

@@ -15,7 +15,7 @@ function createEmitter() {
     if (!state.listeners.has(event)) {
       state.listeners.set(event, /* @__PURE__ */ new Set());
     }
-    state.listeners.get(event).add(handler);
+    state.listeners.get(event)?.add(handler);
     return () => off(event, handler);
   }
   function once(event, handler) {
@@ -55,217 +55,24 @@ function createEmitter() {
   const emitter = { on, once, off, emit, clear, listenerCount };
   return emitter;
 }
-
-// src/payment.ts
-var STATUS_TO_EVENT = {
-  successful: "success",
-  failed: "failed",
-  processing: "processing",
-  cancelled: "cancelled"
-};
-function statusToEvent(status) {
-  return STATUS_TO_EVENT[status] ?? null;
+function generateFingerprint() {
+  const components = [
+    `type:${os.type()}`,
+    `platform:${os.platform()}`,
+    `arch:${os.arch()}`,
+    `release:${os.release()}`,
+    `hostname:${os.hostname()}`,
+    `node:${process.versions.node}`,
+    `v8:${process.versions.v8}`
+  ].join("|");
+  return crypto.createHash("sha256").update(components).digest("hex");
 }
-var TERMINAL_STATES = /* @__PURE__ */ new Set([
-  "successful",
-  "failed",
-  "cancelled"
-]);
-function createPaymentInstance(initialResponse, deps) {
-  const state = {
-    reference: initialResponse.reference,
-    status: initialResponse.status,
-    transaction: null,
-    pollingTimer: null,
-    resolved: false,
-    pollAttempts: 0,
-    pollStartTime: Date.now(),
-    emitter: createEmitter(),
-    fetchStatus: deps.fetchStatus,
-    fetchTransaction: deps.fetchTransaction,
-    pollIntervalMs: deps.pollIntervalMs ?? 2e3,
-    maxPollDuration: deps.maxPollDuration ?? 3e5,
-    maxPollAttempts: deps.maxPollAttempts ?? 150
-  };
-  function resolveWithError(error) {
-    state.resolved = true;
-    stopPolling();
-    emitEvent("error", error);
-  }
-  function emitEvent(event, error) {
-    const data = {
-      event,
-      transaction: state.transaction ?? void 0,
-      error,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    state.emitter.emit(event, data);
-  }
-  async function handleTerminalState(status) {
-    const txResult = await state.fetchTransaction({
-      reference: state.reference
-    });
-    if (txResult.isOk) {
-      state.transaction = txResult.value;
-      const event = statusToEvent(status);
-      if (event) {
-        emitEvent(event);
-      }
-    } else {
-      emitEvent("error", `Failed to fetch transaction: ${txResult.error}`);
-    }
-    state.resolved = true;
-    stopPolling();
-  }
-  async function handleStatusUpdate(response) {
-    if (response.reference !== state.reference) {
-      resolveWithError(
-        `Reference mismatch: expected ${state.reference} but got ${response.reference}`
-      );
-      return;
-    }
-    const newStatus = response.status;
-    const oldStatus = state.status;
-    state.status = newStatus;
-    if (newStatus !== oldStatus) {
-      const event = statusToEvent(newStatus);
-      if (event) {
-        if (TERMINAL_STATES.has(newStatus)) {
-          await handleTerminalState(newStatus);
-          return;
-        }
-        emitEvent(event);
-      }
-    }
-  }
-  function handlePollError(error) {
-    const isNotFound = error.includes("not found") || error.includes("NOT_FOUND");
-    if (isNotFound) {
-      return;
-    }
-    emitEvent("error", error);
-    state.resolved = true;
-    stopPolling();
-  }
-  function scheduleNextPoll() {
-    if (state.resolved || state.pollingTimer) {
-      return;
-    }
-    state.pollingTimer = setTimeout(() => {
-      state.pollingTimer = null;
-      void pollStatus();
-    }, state.pollIntervalMs);
-  }
-  async function pollStatus() {
-    if (state.resolved) {
-      stopPolling();
-      return;
-    }
-    if (state.pollAttempts >= state.maxPollAttempts) {
-      resolveWithError("Polling timeout: exceeded maximum attempts");
-      return;
-    }
-    if (Date.now() - state.pollStartTime >= state.maxPollDuration) {
-      resolveWithError("Polling timeout: exceeded maximum duration");
-      return;
-    }
-    state.pollAttempts += 1;
-    const result = await state.fetchStatus({ reference: state.reference });
-    if (result.isOk) {
-      await handleStatusUpdate(result.value);
-    } else {
-      handlePollError(result.error);
-    }
-    if (state.resolved) {
-      stopPolling();
-      return;
-    }
-    scheduleNextPoll();
-  }
-  function startPolling() {
-    scheduleNextPoll();
-  }
-  function stopPolling() {
-    if (state.pollingTimer) {
-      clearTimeout(state.pollingTimer);
-      state.pollingTimer = null;
-    }
-  }
-  function on(event, handler) {
-    state.emitter.on(event, handler);
-    return paymentInstance;
-  }
-  function off(event, handler) {
-    state.emitter.off(event, handler);
-    return paymentInstance;
-  }
-  function once(event, handler) {
-    state.emitter.once(event, handler);
-    return paymentInstance;
-  }
-  function wait() {
-    return new Promise((resolve, reject) => {
-      if (state.resolved) {
-        if (state.status === "successful" && state.transaction) {
-          resolve(state.transaction);
-        } else {
-          reject(new Error(`Payment ${state.status ?? "error"}`));
-        }
-        return;
-      }
-      function onSuccess() {
-        cleanup();
-        if (state.transaction) {
-          resolve(state.transaction);
-        } else {
-          reject(
-            new Error("Payment successful but transaction data unavailable")
-          );
-        }
-      }
-      function onFailed() {
-        cleanup();
-        reject(new Error("Payment failed"));
-      }
-      function onCancelled() {
-        cleanup();
-        reject(new Error("Payment cancelled"));
-      }
-      function onError(data) {
-        cleanup();
-        const eventData = data;
-        reject(new Error(eventData.error ?? "Payment error"));
-      }
-      function cleanup() {
-        state.emitter.off("success", onSuccess);
-        state.emitter.off("failed", onFailed);
-        state.emitter.off("cancelled", onCancelled);
-        state.emitter.off("error", onError);
-      }
-      state.emitter.on("success", onSuccess);
-      state.emitter.on("failed", onFailed);
-      state.emitter.on("cancelled", onCancelled);
-      state.emitter.on("error", onError);
-    });
-  }
-  const paymentInstance = {
-    get reference() {
-      return state.reference;
-    },
-    get status() {
-      return state.status;
-    },
-    on,
-    once,
-    off,
-    wait
-  };
-  startPolling();
-  return paymentInstance;
+function generateNonce(length = 16) {
+  return crypto.randomBytes(length).toString("hex");
 }
 
 // src/sdk.config.ts
-var DEFAULT_BASE_URL = "https://api.nylonpay.io/api/services";
+var DEFAULT_BASE_URL = "https://api.nylonpay.nilesquad.com/api/services";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_MAX_POLL_INTERVAL_MS = 2e3;
@@ -283,21 +90,6 @@ var SDK_ACTIONS = {
   createInvoice: "sdk-create-invoice"
 };
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
-function generateFingerprint() {
-  const components = [
-    `type:${os.type()}`,
-    `platform:${os.platform()}`,
-    `arch:${os.arch()}`,
-    `release:${os.release()}`,
-    `hostname:${os.hostname()}`,
-    `node:${process.versions.node}`,
-    `v8:${process.versions.v8}`
-  ].join("|");
-  return crypto.createHash("sha256").update(components).digest("hex");
-}
-function generateNonce(length = 16) {
-  return crypto.randomBytes(length).toString("hex");
-}
 function sortValue(value) {
   if (Array.isArray(value)) {
     return value.map((entry) => sortValue(entry));
@@ -517,6 +309,214 @@ function parseError(error) {
   }
   return { code: "UNKNOWN", message: error };
 }
+
+// src/payment.ts
+var STATUS_TO_EVENT = {
+  successful: "success",
+  failed: "failed",
+  processing: "processing",
+  cancelled: "cancelled"
+};
+function statusToEvent(status) {
+  return STATUS_TO_EVENT[status] ?? null;
+}
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "successful",
+  "failed",
+  "cancelled"
+]);
+function createPaymentInstance(initialResponse, deps) {
+  const state = {
+    reference: initialResponse.reference,
+    status: initialResponse.status,
+    transaction: null,
+    pollingTimer: null,
+    resolved: false,
+    pollAttempts: 0,
+    pollStartTime: Date.now(),
+    emitter: createEmitter(),
+    fetchStatus: deps.fetchStatus,
+    fetchTransaction: deps.fetchTransaction,
+    pollIntervalMs: deps.pollIntervalMs ?? 2e3,
+    maxPollDuration: deps.maxPollDuration ?? 3e5,
+    maxPollAttempts: deps.maxPollAttempts ?? 150
+  };
+  function resolveWithError(error) {
+    state.resolved = true;
+    stopPolling();
+    emitEvent("error", parseError(error).message);
+  }
+  function emitEvent(event, error) {
+    const data = {
+      event,
+      transaction: state.transaction ?? void 0,
+      error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    state.emitter.emit(event, data);
+  }
+  async function handleTerminalState(status) {
+    const txResult = await state.fetchTransaction({
+      reference: state.reference
+    });
+    if (txResult.isOk) {
+      state.transaction = txResult.value;
+      const event = statusToEvent(status);
+      if (event) {
+        emitEvent(event);
+      }
+    } else {
+      emitEvent("error", `Failed to fetch transaction: ${txResult.error}`);
+    }
+    state.resolved = true;
+    stopPolling();
+  }
+  async function handleStatusUpdate(response) {
+    if (response.reference !== state.reference) {
+      resolveWithError(
+        `Reference mismatch: expected ${state.reference} but got ${response.reference}`
+      );
+      return;
+    }
+    const newStatus = response.status;
+    const oldStatus = state.status;
+    state.status = newStatus;
+    if (newStatus !== oldStatus) {
+      const event = statusToEvent(newStatus);
+      if (event) {
+        if (TERMINAL_STATES.has(newStatus)) {
+          await handleTerminalState(newStatus);
+          return;
+        }
+        emitEvent(event);
+      }
+    }
+  }
+  function handlePollError(error) {
+    const isNotFound = error.includes("not found") || error.includes("NOT_FOUND");
+    if (isNotFound) {
+      return;
+    }
+    emitEvent("error", parseError(error).message);
+    state.resolved = true;
+    stopPolling();
+  }
+  function scheduleNextPoll() {
+    if (state.resolved || state.pollingTimer) {
+      return;
+    }
+    state.pollingTimer = setTimeout(() => {
+      state.pollingTimer = null;
+      void pollStatus();
+    }, state.pollIntervalMs);
+  }
+  async function pollStatus() {
+    if (state.resolved) {
+      stopPolling();
+      return;
+    }
+    if (state.pollAttempts >= state.maxPollAttempts) {
+      resolveWithError("Polling timeout: exceeded maximum attempts");
+      return;
+    }
+    if (Date.now() - state.pollStartTime >= state.maxPollDuration) {
+      resolveWithError("Polling timeout: exceeded maximum duration");
+      return;
+    }
+    state.pollAttempts += 1;
+    const result = await state.fetchStatus({ reference: state.reference });
+    if (result.isOk) {
+      await handleStatusUpdate(result.value);
+    } else {
+      handlePollError(result.error);
+    }
+    if (state.resolved) {
+      stopPolling();
+      return;
+    }
+    scheduleNextPoll();
+  }
+  function startPolling() {
+    scheduleNextPoll();
+  }
+  function stopPolling() {
+    if (state.pollingTimer) {
+      clearTimeout(state.pollingTimer);
+      state.pollingTimer = null;
+    }
+  }
+  function on(event, handler) {
+    state.emitter.on(event, handler);
+    return paymentInstance;
+  }
+  function off(event, handler) {
+    state.emitter.off(event, handler);
+    return paymentInstance;
+  }
+  function once(event, handler) {
+    state.emitter.once(event, handler);
+    return paymentInstance;
+  }
+  function wait() {
+    return new Promise((resolve, reject) => {
+      if (state.resolved) {
+        if (state.status === "successful" && state.transaction) {
+          resolve(state.transaction);
+        } else {
+          reject(new Error(`Payment ${state.status ?? "error"}`));
+        }
+        return;
+      }
+      function onSuccess() {
+        cleanup();
+        if (state.transaction) {
+          resolve(state.transaction);
+        } else {
+          reject(
+            new Error("Payment successful but transaction data unavailable")
+          );
+        }
+      }
+      function onFailed() {
+        cleanup();
+        reject(new Error("Payment failed"));
+      }
+      function onCancelled() {
+        cleanup();
+        reject(new Error("Payment cancelled"));
+      }
+      function onError(data) {
+        cleanup();
+        const eventData = data;
+        reject(new Error(eventData.error ?? "Payment error"));
+      }
+      function cleanup() {
+        state.emitter.off("success", onSuccess);
+        state.emitter.off("failed", onFailed);
+        state.emitter.off("cancelled", onCancelled);
+        state.emitter.off("error", onError);
+      }
+      state.emitter.on("success", onSuccess);
+      state.emitter.on("failed", onFailed);
+      state.emitter.on("cancelled", onCancelled);
+      state.emitter.on("error", onError);
+    });
+  }
+  const paymentInstance = {
+    get reference() {
+      return state.reference;
+    },
+    get status() {
+      return state.status;
+    },
+    on,
+    once,
+    off,
+    wait
+  };
+  startPolling();
+  return paymentInstance;
+}
 function verifyWebhookSignature(input) {
   const payloadBytes = typeof input.payload === "string" ? Buffer.from(input.payload, "utf8") : Buffer.from(input.payload);
   const expectedSignature = crypto.createHmac("sha256", input.secret).update(payloadBytes).digest("hex");