@paykit-sdk/core/dist/error.js

The Payment Toolkit for Typescript

'use strict';

// src/error.ts
var PayKitError = class extends Error {
  code;
  statusCode;
  provider;
  method;
  context;
  constructor(message, options) {
    super(message);
    this.name = this.constructor.name;
    this.code = options?.code || "PAYKIT_ERROR";
    this.statusCode = options?.statusCode || 500;
    this.provider = options?.provider;
    this.method = options?.method;
    this.context = options?.context;
    if (options?.cause) {
      this.cause = options.cause;
    }
    Error.captureStackTrace(this, this.constructor);
  }
};
var NotImplementedError = class extends PayKitError {
  constructor(method, provider, options) {
    const message = options?.futureSupport ? `${method} is not yet implemented${provider ? ` for ${provider}` : ""}. This feature is planned for a future release. If you need this urgently, please open an issue at https://github.com/usepaykit/paykit-sdk/issues` : `${method} is not implemented${provider ? ` for ${provider}` : ""}. If you believe this should be supported, please contact the maintainer at https://github.com/usepaykit/paykit-sdk/issues`;
    super(message, {
      code: "NOT_IMPLEMENTED",
      statusCode: 501,
      provider,
      method
    });
    this.stack = void 0;
  }
};
var ProviderNotSupportedError = class extends PayKitError {
  constructor(method, provider, options) {
    let message = `${provider} does not support ${method}.`;
    if (options?.reason) {
      message += ` ${options.reason}`;
    }
    if (options?.alternative) {
      message += ` Alternative: ${options.alternative}`;
    }
    super(message, {
      code: "PROVIDER_NOT_SUPPORTED",
      statusCode: 501,
      provider,
      method,
      context: {
        reason: options?.reason,
        alternative: options?.alternative
      }
    });
  }
};
var ValidationError = class _ValidationError extends PayKitError {
  constructor(message, options) {
    super(message, {
      code: "VALIDATION_ERROR",
      statusCode: 400,
      provider: options?.provider,
      method: options?.method,
      context: { field: options?.field, value: options?.value },
      cause: options?.cause
    });
  }
  /**
   * Helper to create ValidationError from Zod error
   */
  static fromZodError(zodError, provider, method) {
    const message = zodError.message.split("\n").join(" ");
    return new _ValidationError(message, {
      provider,
      method,
      cause: zodError
    });
  }
};
var ResourceNotFoundError = class extends PayKitError {
  constructor(resourceType, resourceId, provider) {
    super(`${resourceType} with ID "${resourceId}" not found`, {
      code: "RESOURCE_NOT_FOUND",
      statusCode: 404,
      provider,
      context: { resourceType, resourceId }
    });
  }
};
var WebhookError = class extends PayKitError {
  constructor(message, options) {
    super(message, {
      code: "WEBHOOK_ERROR",
      statusCode: 400,
      provider: options?.provider,
      context: { provider: options?.provider }
    });
    this.stack = void 0;
  }
};
var ConfigurationError = class extends PayKitError {
  constructor(message, options) {
    super(message, {
      code: "CONFIGURATION_ERROR",
      statusCode: 500,
      provider: options?.provider,
      context: { missingKeys: options?.missingKeys }
    });
    this.stack = void 0;
  }
};
var OperationFailedError = class extends PayKitError {
  constructor(operation, provider, options) {
    const message = `Failed to ${operation}${provider ? ` with ${provider}` : ""}${options?.reason ? `: ${options.reason}` : ""}`;
    super(message, {
      code: "OPERATION_FAILED",
      statusCode: 500,
      provider,
      method: operation,
      cause: options?.cause
    });
    this.stack = void 0;
  }
};
var AuthenticationError = class extends PayKitError {
  constructor(provider, message) {
    super(
      message || `Authentication failed for ${provider}. Please check your API credentials.`,
      {
        code: "AUTHENTICATION_ERROR",
        statusCode: 401,
        provider
      }
    );
  }
};
var RateLimitError = class extends PayKitError {
  constructor(provider, options) {
    super(
      `Rate limit exceeded for ${provider}${options?.retryAfter ? `. Retry after ${options.retryAfter} seconds` : ""}`,
      {
        code: "RATE_LIMIT_ERROR",
        statusCode: 429,
        provider,
        context: {
          retryAfter: options?.retryAfter,
          limit: options?.limit
        }
      }
    );
  }
};
var InvalidTypeError = class extends PayKitError {
  constructor(field, expectedType, receivedType, options) {
    super(
      `Invalid type for "${field}": expected ${expectedType}, received ${receivedType}`,
      {
        code: "INVALID_TYPE",
        statusCode: 400,
        provider: options?.provider,
        method: options?.method,
        context: { field, expectedType, receivedType }
      }
    );
    this.stack = void 0;
  }
};
var ConstraintViolationError = class extends PayKitError {
  constructor(constraint, options) {
    super(
      `Constraint violation: ${constraint}${options?.limit ? ` (limit: ${options.limit}, received: ${options.value})` : ""}`,
      {
        code: "CONSTRAINT_VIOLATION",
        statusCode: 400,
        provider: options?.provider,
        context: {
          constraint,
          value: options?.value,
          limit: options?.limit
        }
      }
    );
  }
};
var UnTraceableError = class extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
    this.stack = void 0;
  }
};

exports.AuthenticationError = AuthenticationError;
exports.ConfigurationError = ConfigurationError;
exports.ConstraintViolationError = ConstraintViolationError;
exports.InvalidTypeError = InvalidTypeError;
exports.NotImplementedError = NotImplementedError;
exports.OperationFailedError = OperationFailedError;
exports.PayKitError = PayKitError;
exports.ProviderNotSupportedError = ProviderNotSupportedError;
exports.RateLimitError = RateLimitError;
exports.ResourceNotFoundError = ResourceNotFoundError;
exports.UnTraceableError = UnTraceableError;
exports.ValidationError = ValidationError;
exports.WebhookError = WebhookError;