@nile-squad/nylonpay-ts 1.0.0 → 1.0.2

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");
@@ -197,6 +196,19 @@ payment.off("success", handler);
 const tx = await payment.wait();
 ```
 
+Use `safeTry` from `slang-ts` to handle the promise without try/catch:
+
+```ts
+import { safeTry } from "slang-ts";
+
+const result = await safeTry(() => payment.wait());
+if (result.isOk) {
+  console.log("paid:", result.value.reference);
+} else {
+  console.log("failed or timed out:", result.error);
+}
+```
+
 ## Error Handling
 
 All operations return `Result<T, string>` from [slang-ts](https://github.com/nile-squad/slang-ts). Use `parseError` to get structured error objects.
@@ -208,7 +220,7 @@ const result = await nylonpay.getStatus({ reference: "ORDER-123" });
 if (!result.isOk) {
   const error = parseError(result.error);
   if (error.retryable) {
-    // Retry the request
+    // retry
   }
 }
 ```

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");
@@ -573,11 +573,25 @@ function createSdkInstance(config) {
     if (input.method === "bank" && !input.bank) {
       throw new Error('bank details are required when method is "bank"');
     }
-    const payload = { ...input, reference };
+    let payload = { ...input, reference };
+    if (config.hooks?.beforeCollect) {
+      const mutated = await config.hooks.beforeCollect(payload);
+      if (mutated != null)
+        payload = { ...mutated, reference: mutated.reference ?? reference };
+    }
     const result = await transport.send({
       action: SDK_ACTIONS.collectPayment,
       payload
     });
+    if (config.hooks?.afterCollect) {
+      await config.hooks.afterCollect(
+        result.isOk ? slangTs.Ok({
+          reference: result.value.reference,
+          status: result.value.status
+        }) : slangTs.Err(result.error),
+        payload
+      );
+    }
     if (result.isOk) {
       return createPaymentInstance(result.value, commonDeps);
     }
@@ -601,11 +615,25 @@ function createSdkInstance(config) {
     if (input.method === "bank" && !input.bank) {
       throw new Error('bank details are required when method is "bank"');
     }
-    const payload = { ...input, reference };
+    let payload = { ...input, reference };
+    if (config.hooks?.beforeCollect) {
+      const mutated = await config.hooks.beforeCollect(payload);
+      if (mutated != null)
+        payload = { ...mutated, reference: mutated.reference ?? reference };
+    }
     const result = await transport.send({
       action: SDK_ACTIONS.collectPaymentAndResolve,
       payload
     });
+    if (config.hooks?.afterCollect) {
+      await config.hooks.afterCollect(
+        result.isOk ? slangTs.Ok({
+          reference: result.value.reference,
+          status: result.value.status
+        }) : slangTs.Err(result.error),
+        payload
+      );
+    }
     if (result.isOk) {
       return slangTs.Ok(result.value);
     }
@@ -625,11 +653,25 @@ function createSdkInstance(config) {
       input.destination.accountNumber,
       "destination.accountNumber"
     );
-    const payload = { ...input, reference };
+    let payload = { ...input, reference };
+    if (config.hooks?.beforePayout) {
+      const mutated = await config.hooks.beforePayout(payload);
+      if (mutated != null)
+        payload = { ...mutated, reference: mutated.reference ?? reference };
+    }
     const result = await transport.send({
       action: SDK_ACTIONS.makePayout,
       payload
     });
+    if (config.hooks?.afterPayout) {
+      await config.hooks.afterPayout(
+        result.isOk ? slangTs.Ok({
+          reference: result.value.reference,
+          status: result.value.status
+        }) : slangTs.Err(result.error),
+        payload
+      );
+    }
     if (result.isOk) {
       return createPaymentInstance(result.value, commonDeps);
     }
@@ -658,11 +700,25 @@ function createSdkInstance(config) {
       input.destination.accountNumber,
       "destination.accountNumber"
     );
-    const payload = { ...input, reference };
+    let payload = { ...input, reference };
+    if (config.hooks?.beforePayout) {
+      const mutated = await config.hooks.beforePayout(payload);
+      if (mutated != null)
+        payload = { ...mutated, reference: mutated.reference ?? reference };
+    }
     const result = await transport.send({
       action: SDK_ACTIONS.makePayoutAndResolve,
       payload
     });
+    if (config.hooks?.afterPayout) {
+      await config.hooks.afterPayout(
+        result.isOk ? slangTs.Ok({
+          reference: result.value.reference,
+          status: result.value.status
+        }) : slangTs.Err(result.error),
+        payload
+      );
+    }
     if (result.isOk) {
       return slangTs.Ok(result.value);
     }
@@ -747,6 +803,7 @@ function createSdkInstance(config) {
 }
 
 // src/create-nylon-pay.ts
+var instances = /* @__PURE__ */ new Map();
 function createNylonPay(config) {
   if (!config.apiKey) {
     throw new Error("apiKey is required");
@@ -760,18 +817,27 @@ function createNylonPay(config) {
   if (!config.apiSecret.startsWith("nps_")) {
     throw new Error('apiSecret must start with "nps_"');
   }
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+  const instanceKey = `${config.apiKey}:${baseUrl}`;
+  if (!config.force) {
+    const existing = instances.get(instanceKey);
+    if (existing) return existing;
+  }
   const resolvedConfig = {
     apiKey: config.apiKey,
     apiSecret: config.apiSecret,
-    baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+    baseUrl,
     timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
     maxPollIntervalMs: config.maxPollIntervalMs ?? DEFAULT_MAX_POLL_INTERVAL_MS,
     maxPollDurationMs: config.maxPollDurationMs ?? DEFAULT_MAX_POLL_DURATION_MS,
     maxPollAttempts: config.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS,
-    fetch: config.fetch ?? globalThis.fetch.bind(globalThis)
+    fetch: config.fetch ?? globalThis.fetch.bind(globalThis),
+    hooks: config.hooks
   };
-  return createSdkInstance(resolvedConfig);
+  const instance = createSdkInstance(resolvedConfig);
+  instances.set(instanceKey, instance);
+  return instance;
 }
 
 exports.createNylonPay = createNylonPay;