@misterhomer1992/miit-bot-payment 1.1.6 → 2.0.4

package/package.json

@@ -1,13 +1,15 @@
 {
     "name": "@misterhomer1992/miit-bot-payment",
-    "version": "1.1.6",
+    "version": "2.0.4",
     "description": "A TypeScript utility library for payment validation and formatting",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {
         "build": "tsc",
+        "build:test": "tsc --project tsconfig.test.json",
+        "prepare": "npm run build",
         "prepublishOnly": "npm run build",
-        "test": "node --test dist/**/*.test.js",
+        "test": "npm run build:test && node --test dist/**/*.test.js",
         "lint": "eslint src --ext .ts",
         "format": "prettier --write \"src/**/*.ts\"",
         "watch": "tsc --watch",
@@ -29,14 +31,14 @@
         "dotenv": "17.2.2",
         "axios": "1.12.2",
         "firebase-admin": "12.1.0",
-        "@misterhomer1992/wayforpay-api": "3.0.1"
+        "@misterhomer1992/wayforpay-api": "3.0.1",
+        "typescript": "^5.3.2"
     },
     "devDependencies": {
         "@types/node": "^20.10.0",
         "@typescript-eslint/eslint-plugin": "^6.13.0",
         "@typescript-eslint/parser": "^6.13.0",
         "ts-node": "^10.9.2",
-        "typescript": "^5.3.2",
         "eslint": "^8.48.0",
         "eslint-config-airbnb": "^19.0.4",
         "eslint-config-prettier": "^9.0.0",
@@ -44,8 +46,10 @@
     },
     "files": [
         "dist",
+        "src",
         "README.md",
-        "LICENSE"
+        "LICENSE",
+        "tsconfig.json"
     ],
     "repository": {
         "type": "git",

package/src/config/ConfigurationManager.ts

@@ -0,0 +1,159 @@
+import type { PackageConfig, PartialPackageConfig, WayForPayConfig, CacheConfig, GracePeriodConfig } from './types';
+import { DEFAULT_CACHE_CONFIG, DEFAULT_GRACE_PERIOD_CONFIG } from './defaults';
+import { loadWayForPayConfigFromEnv, loadCacheConfigFromEnv, loadGracePeriodConfigFromEnv } from './environment';
+
+/**
+ * ConfigurationManager provides centralized configuration management for the package.
+ * Supports environment-based configuration with programmatic overrides.
+ */
+export class ConfigurationManager {
+    private static instance: ConfigurationManager | null = null;
+    private config: PackageConfig;
+    private initialized: boolean = false;
+
+    private constructor() {
+        this.config = this.loadDefaultConfig();
+    }
+
+    /**
+     * Gets the singleton instance of ConfigurationManager.
+     */
+    public static getInstance(): ConfigurationManager {
+        if (!ConfigurationManager.instance) {
+            ConfigurationManager.instance = new ConfigurationManager();
+        }
+        return ConfigurationManager.instance;
+    }
+
+    /**
+     * Resets the singleton instance (useful for testing).
+     */
+    public static resetInstance(): void {
+        ConfigurationManager.instance = null;
+    }
+
+    /**
+     * Initializes the configuration with optional overrides.
+     * Should be called once at application startup.
+     */
+    public initialize(overrides?: PartialPackageConfig): void {
+        this.config = this.mergeConfig(this.loadDefaultConfig(), overrides);
+        this.initialized = true;
+    }
+
+    /**
+     * Checks if the configuration has been explicitly initialized.
+     */
+    public isInitialized(): boolean {
+        return this.initialized;
+    }
+
+    /**
+     * Gets the complete configuration.
+     */
+    public getConfig(): PackageConfig {
+        return { ...this.config };
+    }
+
+    /**
+     * Gets WayForPay configuration.
+     */
+    public getWayForPayConfig(): WayForPayConfig {
+        return { ...this.config.wayforpay };
+    }
+
+    /**
+     * Gets cache configuration.
+     */
+    public getCacheConfig(): CacheConfig {
+        return { ...this.config.cache };
+    }
+
+    /**
+     * Gets grace period configuration.
+     */
+    public getGracePeriodConfig(): GracePeriodConfig {
+        return { ...this.config.gracePeriod };
+    }
+
+    /**
+     * Updates configuration at runtime.
+     */
+    public updateConfig(overrides: PartialPackageConfig): void {
+        this.config = this.mergeConfig(this.config, overrides);
+    }
+
+    /**
+     * Validates that required WayForPay credentials are present.
+     */
+    public validateWayForPayConfig(): { valid: boolean; missingFields: string[] } {
+        const missingFields: string[] = [];
+        const { wayforpay } = this.config;
+
+        if (!wayforpay.merchantAccount) {
+            missingFields.push('merchantAccount');
+        }
+        if (!wayforpay.merchantSecretKey) {
+            missingFields.push('merchantSecretKey');
+        }
+        if (!wayforpay.merchantDomainName) {
+            missingFields.push('merchantDomainName');
+        }
+
+        return {
+            valid: missingFields.length === 0,
+            missingFields,
+        };
+    }
+
+    /**
+     * Loads default configuration from environment and defaults.
+     */
+    private loadDefaultConfig(): PackageConfig {
+        const envWayForPay = loadWayForPayConfigFromEnv();
+        const envCache = loadCacheConfigFromEnv();
+        const envGracePeriod = loadGracePeriodConfigFromEnv();
+
+        return {
+            wayforpay: {
+                merchantAccount: envWayForPay.merchantAccount ?? '',
+                merchantSecretKey: envWayForPay.merchantSecretKey ?? '',
+                merchantDomainName: envWayForPay.merchantDomainName ?? '',
+                serviceUrl: envWayForPay.serviceUrl,
+                merchantPassword: envWayForPay.merchantPassword,
+            },
+            cache: {
+                ttlMs: envCache.ttlMs ?? DEFAULT_CACHE_CONFIG.ttlMs,
+                maxSize: envCache.maxSize ?? DEFAULT_CACHE_CONFIG.maxSize,
+            },
+            gracePeriod: {
+                durationMs: envGracePeriod.durationMs ?? DEFAULT_GRACE_PERIOD_CONFIG.durationMs,
+                enabled: envGracePeriod.enabled ?? DEFAULT_GRACE_PERIOD_CONFIG.enabled,
+            },
+        };
+    }
+
+    /**
+     * Merges configuration with overrides.
+     */
+    private mergeConfig(base: PackageConfig, overrides?: PartialPackageConfig): PackageConfig {
+        if (!overrides) {
+            return base;
+        }
+
+        return {
+            wayforpay: {
+                ...base.wayforpay,
+                ...overrides.wayforpay,
+            },
+            cache: {
+                ...base.cache,
+                ...overrides.cache,
+            },
+            gracePeriod: {
+                ...base.gracePeriod,
+                ...overrides.gracePeriod,
+            },
+        };
+    }
+}

package/src/config/defaults.ts

@@ -0,0 +1,27 @@
+import type { CacheConfig, GracePeriodConfig } from './types';
+
+/**
+ * Default cache TTL: 20 hours in milliseconds.
+ */
+export const DEFAULT_CACHE_TTL_MS = 20 * 60 * 60 * 1000;
+
+/**
+ * Default cache configuration.
+ */
+export const DEFAULT_CACHE_CONFIG: CacheConfig = {
+    ttlMs: DEFAULT_CACHE_TTL_MS,
+    maxSize: undefined,
+};
+
+/**
+ * Default grace period: 3 days in milliseconds.
+ */
+export const DEFAULT_GRACE_PERIOD_MS = 3 * 24 * 60 * 60 * 1000;
+
+/**
+ * Default grace period configuration.
+ */
+export const DEFAULT_GRACE_PERIOD_CONFIG: GracePeriodConfig = {
+    durationMs: DEFAULT_GRACE_PERIOD_MS,
+    enabled: true,
+};

package/src/config/environment.ts

@@ -0,0 +1,94 @@
+import type { WayForPayConfig, CacheConfig, GracePeriodConfig } from './types';
+import { DEFAULT_CACHE_TTL_MS, DEFAULT_GRACE_PERIOD_MS } from './defaults';
+
+/**
+ * Environment variable names for WayForPay configuration.
+ */
+export const WAYFORPAY_ENV_VARS = {
+    MERCHANT_ACCOUNT: 'WAYFORPAY_MERCHANT_ACCOUNT',
+    MERCHANT_SECRET_KEY: 'WAYFORPAY_MERCHANT_SECRET_KEY',
+    MERCHANT_DOMAIN: 'WAYFORPAY_MERCHANT_DOMAIN',
+    SERVICE_URL: 'WAYFORPAY_SERVICE_URL',
+    MERCHANT_PASSWORD: 'WAYFORPAY_MERCHANT_PASSWORD',
+} as const;
+
+/**
+ * Environment variable names for cache configuration.
+ */
+export const CACHE_ENV_VARS = {
+    TTL_MS: 'CACHE_TTL_MS',
+    MAX_SIZE: 'CACHE_MAX_SIZE',
+} as const;
+
+/**
+ * Environment variable names for grace period configuration.
+ */
+export const GRACE_PERIOD_ENV_VARS = {
+    DURATION_MS: 'GRACE_PERIOD_DURATION_MS',
+    ENABLED: 'GRACE_PERIOD_ENABLED',
+} as const;
+
+/**
+ * Gets a string environment variable value.
+ */
+function getEnvString(name: string): string | undefined {
+    return process.env[name];
+}
+
+/**
+ * Gets a numeric environment variable value.
+ */
+function getEnvNumber(name: string): number | undefined {
+    const value = process.env[name];
+    if (value === undefined || value === '') {
+        return undefined;
+    }
+    const parsed = parseInt(value, 10);
+    return isNaN(parsed) ? undefined : parsed;
+}
+
+/**
+ * Gets a boolean environment variable value.
+ * Accepts 'true', '1', 'yes' as truthy values.
+ */
+function getEnvBoolean(name: string): boolean | undefined {
+    const value = process.env[name];
+    if (value === undefined || value === '') {
+        return undefined;
+    }
+    return ['true', '1', 'yes'].includes(value.toLowerCase());
+}
+
+/**
+ * Loads WayForPay configuration from environment variables.
+ */
+export function loadWayForPayConfigFromEnv(): Partial<WayForPayConfig> {
+    return {
+        merchantAccount: getEnvString(WAYFORPAY_ENV_VARS.MERCHANT_ACCOUNT),
+        merchantSecretKey: getEnvString(WAYFORPAY_ENV_VARS.MERCHANT_SECRET_KEY),
+        merchantDomainName: getEnvString(WAYFORPAY_ENV_VARS.MERCHANT_DOMAIN),
+        serviceUrl: getEnvString(WAYFORPAY_ENV_VARS.SERVICE_URL),
+        merchantPassword: getEnvString(WAYFORPAY_ENV_VARS.MERCHANT_PASSWORD),
+    };
+}
+
+/**
+ * Loads cache configuration from environment variables.
+ */
+export function loadCacheConfigFromEnv(): Partial<CacheConfig> {
+    return {
+        ttlMs: getEnvNumber(CACHE_ENV_VARS.TTL_MS) ?? DEFAULT_CACHE_TTL_MS,
+        maxSize: getEnvNumber(CACHE_ENV_VARS.MAX_SIZE),
+    };
+}
+
+/**
+ * Loads grace period configuration from environment variables.
+ */
+export function loadGracePeriodConfigFromEnv(): Partial<GracePeriodConfig> {
+    const enabled = getEnvBoolean(GRACE_PERIOD_ENV_VARS.ENABLED);
+    return {
+        durationMs: getEnvNumber(GRACE_PERIOD_ENV_VARS.DURATION_MS) ?? DEFAULT_GRACE_PERIOD_MS,
+        enabled: enabled ?? true,
+    };
+}

package/src/config/index.ts

@@ -0,0 +1,22 @@
+export { ConfigurationManager } from './ConfigurationManager';
+export type {
+    PackageConfig,
+    PartialPackageConfig,
+    WayForPayConfig,
+    CacheConfig,
+    GracePeriodConfig,
+} from './types';
+export {
+    DEFAULT_CACHE_TTL_MS,
+    DEFAULT_CACHE_CONFIG,
+    DEFAULT_GRACE_PERIOD_MS,
+    DEFAULT_GRACE_PERIOD_CONFIG,
+} from './defaults';
+export {
+    WAYFORPAY_ENV_VARS,
+    CACHE_ENV_VARS,
+    GRACE_PERIOD_ENV_VARS,
+    loadWayForPayConfigFromEnv,
+    loadCacheConfigFromEnv,
+    loadGracePeriodConfigFromEnv,
+} from './environment';

package/src/config/types.ts

@@ -0,0 +1,56 @@
+/**
+ * WayForPay payment provider credentials configuration.
+ */
+export interface WayForPayConfig {
+    /** Merchant account identifier from WayForPay dashboard */
+    merchantAccount: string;
+    /** Secret key for signing requests */
+    merchantSecretKey: string;
+    /** Merchant domain name registered with WayForPay */
+    merchantDomainName: string;
+    /** Optional service URL for webhook callbacks */
+    serviceUrl?: string;
+    /** Optional merchant password for edit operations */
+    merchantPassword?: string;
+}
+
+/**
+ * Cache configuration settings.
+ */
+export interface CacheConfig {
+    /** Default cache TTL in milliseconds */
+    ttlMs: number;
+    /** Optional maximum cache size (number of entries) */
+    maxSize?: number;
+}
+
+/**
+ * Subscription grace period configuration.
+ */
+export interface GracePeriodConfig {
+    /** Grace period duration in milliseconds after subscription expires */
+    durationMs: number;
+    /** Whether grace period is enabled */
+    enabled: boolean;
+}
+
+/**
+ * Complete package configuration.
+ */
+export interface PackageConfig {
+    /** WayForPay payment provider configuration */
+    wayforpay: WayForPayConfig;
+    /** Cache settings */
+    cache: CacheConfig;
+    /** Grace period settings for subscriptions */
+    gracePeriod: GracePeriodConfig;
+}
+
+/**
+ * Partial configuration for overriding defaults.
+ */
+export type PartialPackageConfig = {
+    wayforpay?: Partial<WayForPayConfig>;
+    cache?: Partial<CacheConfig>;
+    gracePeriod?: Partial<GracePeriodConfig>;
+};

package/src/index.ts

@@ -0,0 +1,29 @@
+export * from './modules/payments';
+export * from './modules/invoice';
+export * from './modules/subscription';
+export * from './modules/subscriptionPlan';
+export * from './modules/user';
+export * from './modules/tokenPack';
+export * from './modules/token';
+export * from './modules/cache';
+export * from './modules/errors';
+export * from './config';
+
+// Status constants for common use cases
+export const SUBSCRIPTION_STATUS = {
+    ACTIVE: 'active',
+    EXPIRED: 'expired',
+    CANCELLED: 'cancelled',
+} as const;
+
+export const PAYMENT_STATUS = {
+    PENDING: 'pending',
+    COMPLETED: 'completed',
+    FAILED: 'failed',
+    EXPIRED: 'expired',
+} as const;
+
+export const PAYMENT_TYPE = {
+    SUBSCRIPTION: 'subscription',
+    TOKEN_PACK: 'token_pack',
+} as const;

package/src/modules/cache/InMemoryCache.ts

@@ -0,0 +1,98 @@
+import { CacheEntry, ICacheOptions, ICache } from './types';
+
+export class InMemoryCache<T> implements ICache<T> {
+    private readonly cache: Map<string, CacheEntry<T>>;
+    private readonly defaultTtl: number;
+    private readonly maxSize: number;
+
+    constructor(options: ICacheOptions) {
+        this.cache = new Map();
+        this.defaultTtl = options.ttl;
+        this.maxSize = options.maxSize || Infinity;
+    }
+
+    public get(key: string): T | undefined {
+        const entry = this.cache.get(key);
+
+        if (!entry) {
+            return undefined;
+        }
+
+        if (this.isExpired(entry)) {
+            this.cache.delete(key);
+            return undefined;
+        }
+
+        return entry.value;
+    }
+
+    public set(key: string, value: T, ttl?: number): void {
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            this.evictOldest();
+        }
+
+        const expiresAt = Date.now() + (ttl ?? this.defaultTtl);
+
+        this.cache.set(key, {
+            value,
+            expiresAt,
+        });
+    }
+
+    public has(key: string): boolean {
+        const entry = this.cache.get(key);
+
+        if (!entry) {
+            return false;
+        }
+
+        if (this.isExpired(entry)) {
+            this.cache.delete(key);
+            return false;
+        }
+
+        return true;
+    }
+
+    public delete(key: string): boolean {
+        return this.cache.delete(key);
+    }
+
+    public clear(): void {
+        this.cache.clear();
+    }
+
+    public size(): number {
+        return this.cache.size;
+    }
+
+    public cleanup(): void {
+        const now = Date.now();
+
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.expiresAt <= now) {
+                this.cache.delete(key);
+            }
+        }
+    }
+
+    private isExpired(entry: CacheEntry<T>): boolean {
+        return entry.expiresAt <= Date.now();
+    }
+
+    private evictOldest(): void {
+        let oldestKey: string | null = null;
+        let oldestTime = Infinity;
+
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.expiresAt < oldestTime) {
+                oldestTime = entry.expiresAt;
+                oldestKey = key;
+            }
+        }
+
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+        }
+    }
+}

package/src/modules/cache/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './InMemoryCache';

package/src/modules/cache/types.ts

@@ -0,0 +1,60 @@
+interface CacheEntry<T> {
+    value: T;
+    expiresAt: number;
+}
+
+interface ICacheOptions {
+    /** Time to live in milliseconds */
+    ttl: number;
+    /** Maximum number of entries in the cache */
+    maxSize?: number;
+}
+
+interface ICache<T> {
+    /**
+     * Gets a value from the cache.
+     * @param key - The cache key
+     * @returns The cached value or undefined if not found or expired
+     */
+    get(key: string): T | undefined;
+
+    /**
+     * Sets a value in the cache.
+     * @param key - The cache key
+     * @param value - The value to cache
+     * @param ttl - Optional TTL override in milliseconds
+     */
+    set(key: string, value: T, ttl?: number): void;
+
+    /**
+     * Checks if a key exists in the cache and is not expired.
+     * @param key - The cache key
+     * @returns True if the key exists and is not expired
+     */
+    has(key: string): boolean;
+
+    /**
+     * Deletes a key from the cache.
+     * @param key - The cache key
+     * @returns True if the key was deleted
+     */
+    delete(key: string): boolean;
+
+    /**
+     * Clears all entries from the cache.
+     */
+    clear(): void;
+
+    /**
+     * Gets the number of entries in the cache.
+     * @returns The number of entries
+     */
+    size(): number;
+
+    /**
+     * Removes all expired entries from the cache.
+     */
+    cleanup(): void;
+}
+
+export type { CacheEntry, ICacheOptions, ICache };

package/src/modules/cancellableAPI/utils.ts

@@ -0,0 +1,60 @@
+import { SimpleFn } from '../../types/function';
+import { mockTimeoutResponse } from '../network/utils';
+
+type DefaultParams = Record<string, unknown> & {
+    userId: string;
+    platform: string;
+};
+
+function wrapCancellableAPI<
+    T extends SimpleFn,
+    TParams extends any[] = Parameters<T> extends never[] ? [DefaultParams] : Parameters<T> & [DefaultParams],
+>(api: T, props?: { timeout?: number }) {
+    return function (...args: TParams): Promise<Awaited<ReturnType<T>> | never> {
+        const { promise: timeoutPromise, cleanUp } = mockTimeoutResponse({
+            timeout: props?.timeout,
+        });
+
+        return Promise.race([api(...args), timeoutPromise])
+            .catch((e) => {
+                throw e;
+            })
+            .finally(cleanUp);
+    };
+}
+
+function wrapTimeoutAPI<
+    T extends SimpleFn,
+    TParams extends any[] = Parameters<T> extends never[] ? [DefaultParams] : Parameters<T> & [DefaultParams],
+>(api: T, props?: { timeout?: number }) {
+    return function (...args: TParams): Promise<Awaited<ReturnType<T>> | never> {
+        const { promise: timeoutPromise, cleanUp } = mockTimeoutResponse({
+            timeout: props?.timeout,
+        });
+
+        return Promise.race([api(...args), timeoutPromise])
+            .catch((e) => {
+                throw e;
+            })
+            .finally(cleanUp);
+    };
+}
+
+function wrapRawTimeoutAPI<T extends SimpleFn, TParams extends any[] = Parameters<T>>(
+    api: T,
+    props?: { timeout?: number },
+) {
+    return function (...args: TParams): Promise<Awaited<ReturnType<T>> | never> {
+        const { promise: timeoutPromise, cleanUp } = mockTimeoutResponse({
+            timeout: props?.timeout,
+        });
+
+        return Promise.race([api(...args), timeoutPromise])
+            .catch((e) => {
+                throw e;
+            })
+            .finally(cleanUp);
+    };
+}
+
+export { wrapCancellableAPI, wrapTimeoutAPI, wrapRawTimeoutAPI };

package/src/modules/errors/index.ts

@@ -0,0 +1,16 @@
+export {
+    BaseError,
+    PaymentError,
+    PaymentErrorCode,
+    SubscriptionError,
+    SubscriptionErrorCode,
+    ValidationError,
+    ValidationErrorCode,
+    NotFoundError,
+    NotFoundErrorCode,
+    isBaseError,
+    isPaymentError,
+    isSubscriptionError,
+    isValidationError,
+    isNotFoundError,
+} from './types';