@waffo/waffo-node 2.0.4 → 2.2.0

package/dist/index.mjs

@@ -1,278 +1,241 @@
 import * as crypto from 'crypto';
 
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-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/types/config/environment.ts
-var Environment, EnvironmentBaseUrl;
-var init_environment = __esm({
-  "src/types/config/environment.ts"() {
-    Environment = /* @__PURE__ */ ((Environment2) => {
-      Environment2["SANDBOX"] = "SANDBOX";
-      Environment2["PRODUCTION"] = "PRODUCTION";
-      return Environment2;
-    })(Environment || {});
-    EnvironmentBaseUrl = {
-      ["SANDBOX" /* SANDBOX */]: "https://api-sandbox.waffo.com/api/v1",
-      ["PRODUCTION" /* PRODUCTION */]: "https://api.waffo.com/api/v1"
-    };
-  }
-});
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["SANDBOX"] = "SANDBOX";
+  Environment2["PRODUCTION"] = "PRODUCTION";
+  return Environment2;
+})(Environment || {});
+var EnvironmentBaseUrl = {
+  ["SANDBOX" /* SANDBOX */]: "https://api-sandbox.waffo.com/api/v1",
+  ["PRODUCTION" /* PRODUCTION */]: "https://api.waffo.com/api/v1"
+};
 
 // src/errors/waffo-error.ts
-var WaffoError, WaffoErrorCode;
-var init_waffo_error = __esm({
-  "src/errors/waffo-error.ts"() {
-    WaffoError = class _WaffoError extends Error {
-      /** Error code identifying the type of error */
-      errorCode;
-      /** The underlying error that caused this error, if any */
-      cause;
-      /**
-       * Creates a new WaffoError.
-       *
-       * @param errorCode - The error code (e.g., "S0003" for signing failure)
-       * @param message - Human-readable error message
-       * @param cause - The underlying error that caused this error
-       */
-      constructor(errorCode, message, cause) {
-        super(message);
-        this.name = "WaffoError";
-        this.errorCode = errorCode;
-        this.cause = cause;
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _WaffoError);
-        }
-      }
-      /**
-       * Returns a string representation of the error.
-       */
-      toString() {
-        return `[${this.errorCode}] ${this.message}`;
-      }
-    };
-    WaffoErrorCode = {
-      /** Invalid public key */
-      INVALID_PUBLIC_KEY: "S0002",
-      /** Failed to sign data */
-      SIGN_FAILED: "S0003",
-      /** Response signature verification failed */
-      VERIFY_FAILED: "S0004",
-      /** Request serialization failed */
-      SERIALIZE_FAILED: "S0005",
-      /** Unexpected error */
-      UNEXPECTED: "S0006",
-      /** Invalid private key */
-      INVALID_PRIVATE_KEY: "S0007"
-    };
+var WaffoError = class _WaffoError extends Error {
+  /** Error code identifying the type of error */
+  errorCode;
+  /** The underlying error that caused this error, if any */
+  cause;
+  /**
+   * Creates a new WaffoError.
+   *
+   * @param errorCode - The error code (e.g., "S0003" for signing failure)
+   * @param message - Human-readable error message
+   * @param cause - The underlying error that caused this error
+   */
+  constructor(errorCode, message, cause) {
+    super(message);
+    this.name = "WaffoError";
+    this.errorCode = errorCode;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _WaffoError);
+    }
+  }
+  /**
+   * Returns a string representation of the error.
+   */
+  toString() {
+    return `[${this.errorCode}] ${this.message}`;
   }
-});
+};
+var WaffoErrorCode = {
+  /** Invalid public key */
+  INVALID_PUBLIC_KEY: "S0002",
+  /** Failed to sign data */
+  SIGN_FAILED: "S0003",
+  /** Response signature verification failed */
+  VERIFY_FAILED: "S0004",
+  /** Request serialization failed */
+  SERIALIZE_FAILED: "S0005",
+  /** Unexpected error */
+  UNEXPECTED: "S0006",
+  /** Invalid private key */
+  INVALID_PRIVATE_KEY: "S0007"
+};
 
 // src/errors/waffo-unknown-status-error.ts
-var WaffoUnknownStatusError;
-var init_waffo_unknown_status_error = __esm({
-  "src/errors/waffo-unknown-status-error.ts"() {
-    WaffoUnknownStatusError = class _WaffoUnknownStatusError extends Error {
-      /** Error code for network errors */
-      static CODE_NETWORK_ERROR = "S0001";
-      /** Error code for unknown server status */
-      static CODE_UNKNOWN_STATUS = "E0001";
-      /** Error code identifying the type of error */
-      errorCode;
-      /** The underlying error that caused this error, if any */
-      cause;
-      /**
-       * Creates a new WaffoUnknownStatusError.
-       *
-       * @param errorCode - The error code (e.g., "S0001" for network error)
-       * @param message - Human-readable error message
-       * @param cause - The underlying error that caused this error
-       */
-      constructor(errorCode, message, cause) {
-        super(message);
-        this.name = "WaffoUnknownStatusError";
-        this.errorCode = errorCode;
-        this.cause = cause;
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, _WaffoUnknownStatusError);
-        }
-      }
-      /**
-       * Returns a string representation of the error.
-       */
-      toString() {
-        return `[${this.errorCode}] ${this.message}`;
-      }
-    };
+var WaffoUnknownStatusError = class _WaffoUnknownStatusError extends Error {
+  /** Error code for network errors */
+  static CODE_NETWORK_ERROR = "S0001";
+  /** Error code for unknown server status */
+  static CODE_UNKNOWN_STATUS = "E0001";
+  /** Error code identifying the type of error */
+  errorCode;
+  /** The underlying error that caused this error, if any */
+  cause;
+  /**
+   * Creates a new WaffoUnknownStatusError.
+   *
+   * @param errorCode - The error code (e.g., "S0001" for network error)
+   * @param message - Human-readable error message
+   * @param cause - The underlying error that caused this error
+   */
+  constructor(errorCode, message, cause) {
+    super(message);
+    this.name = "WaffoUnknownStatusError";
+    this.errorCode = errorCode;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _WaffoUnknownStatusError);
+    }
   }
-});
+  /**
+   * Returns a string representation of the error.
+   */
+  toString() {
+    return `[${this.errorCode}] ${this.message}`;
+  }
+};
 
-// src/errors/index.ts
-var init_errors = __esm({
-  "src/errors/index.ts"() {
-    init_waffo_error();
-    init_waffo_unknown_status_error();
-  }
-});
-var RsaUtils;
-var init_rsa_utils = __esm({
-  "src/utils/rsa-utils.ts"() {
-    init_errors();
-    ((RsaUtils2) => {
-      const ALGORITHM = "RSA-SHA256";
-      const KEY_SIZE = 2048;
-      function sign(data, base64PrivateKey) {
-        try {
-          const privateKeyBuffer = Buffer.from(base64PrivateKey, "base64");
-          const signer = crypto.createSign(ALGORITHM);
-          signer.update(data, "utf8");
-          const signature = signer.sign({
-            key: privateKeyBuffer,
-            format: "der",
-            type: "pkcs8"
-          });
-          return signature.toString("base64");
-        } catch (error) {
-          throw new WaffoError(
-            WaffoErrorCode.SIGN_FAILED,
-            `Failed to sign data: ${error instanceof Error ? error.message : String(error)}`,
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      RsaUtils2.sign = sign;
-      function verify(data, base64Signature, base64PublicKey) {
-        try {
-          const publicKeyBuffer = Buffer.from(base64PublicKey, "base64");
-          const signatureBuffer = Buffer.from(base64Signature, "base64");
-          const verifier = crypto.createVerify(ALGORITHM);
-          verifier.update(data, "utf8");
-          return verifier.verify(
-            {
-              key: publicKeyBuffer,
-              format: "der",
-              type: "spki"
-            },
-            signatureBuffer
-          );
-        } catch {
-          return false;
-        }
-      }
-      RsaUtils2.verify = verify;
-      function validatePrivateKey(base64PrivateKey) {
-        if (!base64PrivateKey || base64PrivateKey.trim() === "") {
-          throw new WaffoError(
-            WaffoErrorCode.INVALID_PRIVATE_KEY,
-            "Private key is null or empty"
-          );
-        }
-        try {
-          const keyBuffer = Buffer.from(base64PrivateKey, "base64");
-          crypto.createPrivateKey({
-            key: keyBuffer,
-            format: "der",
-            type: "pkcs8"
-          });
-        } catch (error) {
-          if (error instanceof WaffoError) throw error;
-          const message = error instanceof Error ? error.message : String(error);
-          if (message.includes("bad base64")) {
-            throw new WaffoError(
-              WaffoErrorCode.INVALID_PRIVATE_KEY,
-              "Invalid private key: not valid Base64 encoding",
-              error instanceof Error ? error : void 0
-            );
-          }
-          throw new WaffoError(
-            WaffoErrorCode.INVALID_PRIVATE_KEY,
-            `Invalid private key: ${message}`,
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      RsaUtils2.validatePrivateKey = validatePrivateKey;
-      function validatePublicKey(base64PublicKey) {
-        if (!base64PublicKey || base64PublicKey.trim() === "") {
-          throw new WaffoError(
-            WaffoErrorCode.INVALID_PUBLIC_KEY,
-            "Public key is null or empty"
-          );
-        }
-        try {
-          const keyBuffer = Buffer.from(base64PublicKey, "base64");
-          crypto.createPublicKey({
-            key: keyBuffer,
-            format: "der",
-            type: "spki"
-          });
-        } catch (error) {
-          if (error instanceof WaffoError) throw error;
-          const message = error instanceof Error ? error.message : String(error);
-          if (message.includes("bad base64")) {
-            throw new WaffoError(
-              WaffoErrorCode.INVALID_PUBLIC_KEY,
-              "Invalid public key: not valid Base64 encoding",
-              error instanceof Error ? error : void 0
-            );
-          }
-          throw new WaffoError(
-            WaffoErrorCode.INVALID_PUBLIC_KEY,
-            `Invalid public key: ${message}`,
-            error instanceof Error ? error : void 0
-          );
-        }
-      }
-      RsaUtils2.validatePublicKey = validatePublicKey;
-      function generateKeyPair() {
-        try {
-          const { privateKey, publicKey } = crypto.generateKeyPairSync("rsa", {
-            modulusLength: KEY_SIZE,
-            publicKeyEncoding: {
-              type: "spki",
-              format: "der"
-            },
-            privateKeyEncoding: {
-              type: "pkcs8",
-              format: "der"
-            }
-          });
-          return {
-            privateKey: privateKey.toString("base64"),
-            publicKey: publicKey.toString("base64")
-          };
-        } catch (error) {
-          throw new WaffoError(
-            WaffoErrorCode.SIGN_FAILED,
-            `Failed to generate key pair: ${error instanceof Error ? error.message : String(error)}`,
-            error instanceof Error ? error : void 0
-          );
-        }
+// src/utils/rsa-utils.ts
+var ALGORITHM = "RSA-SHA256";
+var KEY_SIZE = 2048;
+function sign(data, base64PrivateKey) {
+  try {
+    const privateKeyBuffer = Buffer.from(base64PrivateKey, "base64");
+    const signer = crypto.createSign(ALGORITHM);
+    signer.update(data, "utf8");
+    const signature = signer.sign({
+      key: privateKeyBuffer,
+      format: "der",
+      type: "pkcs8"
+    });
+    return signature.toString("base64");
+  } catch (error) {
+    throw new WaffoError(
+      WaffoErrorCode.SIGN_FAILED,
+      `Failed to sign data: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function verify(data, base64Signature, base64PublicKey) {
+  try {
+    const publicKeyBuffer = Buffer.from(base64PublicKey, "base64");
+    const signatureBuffer = Buffer.from(base64Signature, "base64");
+    const verifier = crypto.createVerify(ALGORITHM);
+    verifier.update(data, "utf8");
+    return verifier.verify(
+      {
+        key: publicKeyBuffer,
+        format: "der",
+        type: "spki"
+      },
+      signatureBuffer
+    );
+  } catch {
+    return false;
+  }
+}
+function validatePrivateKey(base64PrivateKey) {
+  if (!base64PrivateKey || base64PrivateKey.trim() === "") {
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PRIVATE_KEY,
+      "Private key is null or empty"
+    );
+  }
+  try {
+    const keyBuffer = Buffer.from(base64PrivateKey, "base64");
+    crypto.createPrivateKey({
+      key: keyBuffer,
+      format: "der",
+      type: "pkcs8"
+    });
+  } catch (error) {
+    if (error instanceof WaffoError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("bad base64")) {
+      throw new WaffoError(
+        WaffoErrorCode.INVALID_PRIVATE_KEY,
+        "Invalid private key: not valid Base64 encoding",
+        error instanceof Error ? error : void 0
+      );
+    }
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PRIVATE_KEY,
+      `Invalid private key: ${message}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function validatePublicKey(base64PublicKey) {
+  if (!base64PublicKey || base64PublicKey.trim() === "") {
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PUBLIC_KEY,
+      "Public key is null or empty"
+    );
+  }
+  try {
+    const keyBuffer = Buffer.from(base64PublicKey, "base64");
+    crypto.createPublicKey({
+      key: keyBuffer,
+      format: "der",
+      type: "spki"
+    });
+  } catch (error) {
+    if (error instanceof WaffoError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("bad base64")) {
+      throw new WaffoError(
+        WaffoErrorCode.INVALID_PUBLIC_KEY,
+        "Invalid public key: not valid Base64 encoding",
+        error instanceof Error ? error : void 0
+      );
+    }
+    throw new WaffoError(
+      WaffoErrorCode.INVALID_PUBLIC_KEY,
+      `Invalid public key: ${message}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function generateKeyPair() {
+  try {
+    const { privateKey, publicKey } = crypto.generateKeyPairSync("rsa", {
+      modulusLength: KEY_SIZE,
+      publicKeyEncoding: {
+        type: "spki",
+        format: "der"
+      },
+      privateKeyEncoding: {
+        type: "pkcs8",
+        format: "der"
       }
-      RsaUtils2.generateKeyPair = generateKeyPair;
-    })(RsaUtils || (RsaUtils = {}));
+    });
+    return {
+      privateKey: privateKey.toString("base64"),
+      publicKey: publicKey.toString("base64")
+    };
+  } catch (error) {
+    throw new WaffoError(
+      WaffoErrorCode.SIGN_FAILED,
+      `Failed to generate key pair: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
   }
-});
+}
+var RsaUtils = {
+  sign,
+  verify,
+  validatePrivateKey,
+  validatePublicKey,
+  generateKeyPair
+};
 
 // src/types/config/waffo-config.ts
+var WaffoConfigEnvVars = {
+  API_KEY: "WAFFO_API_KEY",
+  PRIVATE_KEY: "WAFFO_PRIVATE_KEY",
+  PUBLIC_KEY: "WAFFO_PUBLIC_KEY",
+  MERCHANT_ID: "WAFFO_MERCHANT_ID",
+  ENVIRONMENT: "WAFFO_ENVIRONMENT"
+};
+var WaffoConfigDefaults = {
+  CONNECT_TIMEOUT: 1e4,
+  READ_TIMEOUT: 3e4
+};
 function createWaffoConfig(config) {
   if (!config.apiKey) {
     throw new Error("apiKey is required");
@@ -324,44 +287,6 @@ function fromEnv() {
     merchantId
   });
 }
-var WaffoConfigEnvVars, WaffoConfigDefaults;
-var init_waffo_config = __esm({
-  "src/types/config/waffo-config.ts"() {
-    init_environment();
-    init_rsa_utils();
-    WaffoConfigEnvVars = {
-      API_KEY: "WAFFO_API_KEY",
-      PRIVATE_KEY: "WAFFO_PRIVATE_KEY",
-      PUBLIC_KEY: "WAFFO_PUBLIC_KEY",
-      MERCHANT_ID: "WAFFO_MERCHANT_ID",
-      ENVIRONMENT: "WAFFO_ENVIRONMENT"
-    };
-    WaffoConfigDefaults = {
-      CONNECT_TIMEOUT: 1e4,
-      READ_TIMEOUT: 3e4
-    };
-  }
-});
-
-// src/types/config/index.ts
-var config_exports = {};
-__export(config_exports, {
-  Environment: () => Environment,
-  EnvironmentBaseUrl: () => EnvironmentBaseUrl,
-  WaffoConfigDefaults: () => WaffoConfigDefaults,
-  WaffoConfigEnvVars: () => WaffoConfigEnvVars,
-  createWaffoConfig: () => createWaffoConfig,
-  fromEnv: () => fromEnv
-});
-var init_config = __esm({
-  "src/types/config/index.ts"() {
-    init_environment();
-    init_waffo_config();
-  }
-});
-
-// src/core/waffo-http-client.ts
-init_config();
 
 // src/types/api-response.ts
 var ApiResponse = class _ApiResponse {
@@ -509,9 +434,6 @@ var DefaultHttpTransport = class {
 };
 
 // src/core/waffo-http-client.ts
-init_rsa_utils();
-init_waffo_error();
-init_waffo_unknown_status_error();
 var HEADER_API_KEY = "x-api-key";
 var HEADER_SIGNATURE = "x-signature";
 var HEADER_API_VERSION = "x-api-version";
@@ -519,7 +441,7 @@ var HEADER_SDK_VERSION = "x-sdk-version";
 var HEADER_CONTENT_TYPE = "content-type";
 var CONTENT_TYPE_JSON = "application/json";
 var API_VERSION = "1.0.0";
-var SDK_VERSION = "waffo-node/1.0.0";
+var SDK_VERSION = "waffo-node/2.2.0";
 var WaffoHttpClient = class {
   baseUrl;
   apiKey;
@@ -668,12 +590,10 @@ var WaffoHttpClient = class {
 };
 
 // src/core/webhook-handler.ts
-init_rsa_utils();
 var WebhookEventType = /* @__PURE__ */ ((WebhookEventType2) => {
   WebhookEventType2["PAYMENT_NOTIFICATION"] = "PAYMENT_NOTIFICATION";
   WebhookEventType2["REFUND_NOTIFICATION"] = "REFUND_NOTIFICATION";
   WebhookEventType2["SUBSCRIPTION_STATUS_NOTIFICATION"] = "SUBSCRIPTION_STATUS_NOTIFICATION";
-  WebhookEventType2["SUBSCRIPTION_PAYMENT_NOTIFICATION"] = "SUBSCRIPTION_PAYMENT_NOTIFICATION";
   WebhookEventType2["SUBSCRIPTION_PERIOD_CHANGED_NOTIFICATION"] = "SUBSCRIPTION_PERIOD_CHANGED_NOTIFICATION";
   return WebhookEventType2;
 })(WebhookEventType || {});
@@ -713,7 +633,8 @@ var WebhookHandler = class {
     return this;
   }
   /**
-   * Registers a handler for subscription payment notifications.
+   * Registers a fallback handler for SUBSCRIPTION_STATUS_NOTIFICATION events.
+   * Only called when onSubscriptionStatus handler is not registered.
    */
   onSubscriptionPayment(handler) {
     this.subscriptionPaymentHandler = handler;
@@ -760,10 +681,7 @@ var WebhookHandler = class {
         case "SUBSCRIPTION_STATUS_NOTIFICATION" /* SUBSCRIPTION_STATUS_NOTIFICATION */:
           if (this.subscriptionStatusHandler) {
             await this.subscriptionStatusHandler(parsed);
-          }
-          break;
-        case "SUBSCRIPTION_PAYMENT_NOTIFICATION" /* SUBSCRIPTION_PAYMENT_NOTIFICATION */:
-          if (this.subscriptionPaymentHandler) {
+          } else if (this.subscriptionPaymentHandler) {
             await this.subscriptionPaymentHandler(parsed);
           }
           break;
@@ -1183,8 +1101,7 @@ var Waffo = class _Waffo {
    * @returns Waffo SDK instance
    */
   static fromEnv() {
-    const { WaffoConfig } = (init_config(), __toCommonJS(config_exports));
-    return new _Waffo(WaffoConfig.fromEnv());
+    return new _Waffo(fromEnv());
   }
   /**
    * Returns the order resource for managing payment orders.
@@ -1251,13 +1168,13 @@ var Waffo = class _Waffo {
    * // Setup webhook handler
    * const handler = waffo.webhook()
    *   .onPayment((notification) => {
-   *     console.log('Payment:', notification.orderStatus);
+   *     console.log('Payment:', notification.result?.orderStatus);
    *   })
    *   .onRefund((notification) => {
-   *     console.log('Refund:', notification.refundStatus);
+   *     console.log('Refund:', notification.result?.refundStatus);
    *   })
    *   .onSubscriptionStatus((notification) => {
-   *     console.log('Subscription:', notification.subscriptionStatus);
+   *     console.log('Subscription:', notification.result?.subscriptionStatus);
    *   });
    *
    * // In Express.js route handler
@@ -1284,12 +1201,6 @@ var Waffo = class _Waffo {
   }
 };
 
-// src/index.ts
-init_config();
-init_waffo_error();
-init_waffo_unknown_status_error();
-init_rsa_utils();
-
 export { ApiResponse, Environment, EnvironmentBaseUrl, MerchantConfigResource, OrderResource, PayMethodConfigResource, RefundResource, RsaUtils, SubscriptionResource, Waffo, WaffoConfigDefaults, WaffoError, WaffoErrorCode, WaffoHttpClient, WaffoUnknownStatusError, WebhookEventType, WebhookHandler };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map