@raba7ni/raba7ni 1.0.0

package/dist/index.js

@@ -0,0 +1,734 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+var crypto = require('crypto');
+
+/**
+ * SDK initialization error
+ */
+class Raba7niError extends Error {
+    constructor(message, code, statusCode, response) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = 'Raba7niError';
+    }
+}
+/**
+ * Authentication error
+ */
+class AuthenticationError extends Raba7niError {
+    constructor(message = 'Authentication failed') {
+        super(message, 'AUTHENTICATION_ERROR', 401);
+        this.name = 'AuthenticationError';
+    }
+}
+/**
+ * Rate limit error
+ */
+class RateLimitError extends Raba7niError {
+    constructor(message = 'Rate limit exceeded', retryAfter) {
+        super(message, 'RATE_LIMIT_ERROR', 429);
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitError';
+    }
+}
+/**
+ * Validation error
+ */
+class ValidationError extends Raba7niError {
+    constructor(message, validationErrors) {
+        super(message, 'VALIDATION_ERROR', 422);
+        this.validationErrors = validationErrors;
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Network error
+ */
+class NetworkError extends Raba7niError {
+    constructor(message, originalError) {
+        super(message, 'NETWORK_ERROR');
+        this.originalError = originalError;
+        this.name = 'NetworkError';
+    }
+}
+
+/**
+ * Core API client for Raba7ni Developer API
+ */
+class Raba7niClient {
+    constructor(config) {
+        this.rateLimitInfo = {
+            hourlyLimit: 0,
+            hourlyRemaining: 0,
+            dailyLimit: 0,
+            dailyRemaining: 0
+        };
+        // Set default values
+        this.config = {
+            baseUrl: config.baseUrl || 'https://api.raba7ni.com',
+            locale: config.locale || 'en',
+            timeout: config.timeout || 30000,
+            maxRetries: config.maxRetries || 3,
+            retryDelay: config.retryDelay || 1000,
+            ...config
+        };
+        // Validate required fields
+        if (!this.config.appId || !this.config.appId.startsWith('app_')) {
+            throw new Error('Invalid appId: must start with "app_"');
+        }
+        if (!this.config.apiKey || !this.config.apiKey.startsWith('dev_')) {
+            throw new Error('Invalid apiKey: must start with "dev_"');
+        }
+        // Create axios instance
+        this.axiosInstance = axios.create({
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'X-App-Id': this.config.appId,
+                'X-Api-Key': this.config.apiKey
+            }
+        });
+        // Add request interceptor for logging and debugging
+        this.axiosInstance.interceptors.request.use((config) => {
+            // Add locale to URL if not already present
+            if (!config.url?.includes('/api/')) {
+                config.url = `/api/${this.config.locale}/v1/developer${config.url || ''}`;
+            }
+            return config;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+        // Add response interceptor for error handling and rate limit tracking
+        this.axiosInstance.interceptors.response.use((response) => {
+            this.extractRateLimitInfo(response);
+            return response;
+        }, (error) => {
+            if (error.response) {
+                this.extractRateLimitInfo(error.response);
+                this.handleApiError(error);
+            }
+            else if (error.request) {
+                throw new NetworkError('Network error: No response received', error);
+            }
+            else {
+                throw new NetworkError('Network error: Request setup failed', error);
+            }
+            return Promise.reject(error);
+        });
+    }
+    /**
+     * Extract rate limit information from response headers
+     */
+    extractRateLimitInfo(response) {
+        const headers = response.headers;
+        this.rateLimitInfo = {
+            hourlyLimit: parseInt(headers['x-ratelimit-hourly-limit']) || 0,
+            hourlyRemaining: parseInt(headers['x-ratelimit-hourly-remaining']) || 0,
+            dailyLimit: parseInt(headers['x-ratelimit-daily-limit']) || 0,
+            dailyRemaining: parseInt(headers['x-ratelimit-daily-remaining']) || 0,
+            resetTime: headers['x-ratelimit-reset']
+        };
+    }
+    /**
+     * Handle API errors and convert to appropriate error classes
+     */
+    handleApiError(error) {
+        const status = error.response?.status;
+        const data = error.response?.data;
+        switch (status) {
+            case 401:
+                throw new AuthenticationError(data?.message || 'Authentication failed');
+            case 403:
+                throw new Raba7niError(data?.message || 'Access forbidden', 'FORBIDDEN', 403, data);
+            case 404:
+                throw new Raba7niError(data?.message || 'Resource not found', 'NOT_FOUND', 404, data);
+            case 422:
+                throw new ValidationError(data?.message || 'Validation failed', data?.errors);
+            case 429:
+                const retryAfter = error.response?.headers['retry-after'];
+                throw new RateLimitError(data?.message || 'Rate limit exceeded', retryAfter ? parseInt(retryAfter) : undefined);
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                throw new Raba7niError(data?.message || 'Server error', 'SERVER_ERROR', status, data);
+            default:
+                throw new Raba7niError(data?.message || error.message || 'Unknown error', 'UNKNOWN_ERROR', status, data);
+        }
+    }
+    /**
+     * Make HTTP request with retry logic
+     */
+    async request(config) {
+        let lastError;
+        for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+            try {
+                const response = await this.axiosInstance.request(config);
+                return response.data;
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on authentication or validation errors
+                if (error instanceof AuthenticationError ||
+                    error instanceof ValidationError ||
+                    error instanceof Raba7niError &&
+                        (error.statusCode === 403 || error.statusCode === 404)) {
+                    throw error;
+                }
+                // Retry on rate limit errors with exponential backoff
+                if (error instanceof RateLimitError) {
+                    if (attempt === this.config.maxRetries) {
+                        throw error;
+                    }
+                    const delay = error.retryAfter
+                        ? error.retryAfter * 1000
+                        : this.config.retryDelay * Math.pow(2, attempt);
+                    await this.sleep(delay);
+                    continue;
+                }
+                // Retry on network errors
+                if (error instanceof NetworkError && attempt < this.config.maxRetries) {
+                    const delay = this.config.retryDelay * Math.pow(2, attempt);
+                    await this.sleep(delay);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Sleep helper for retry delays
+     */
+    sleep(ms) {
+        return new Promise(resolve => {
+            if (typeof setTimeout !== 'undefined') {
+                setTimeout(resolve, ms);
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * Get current rate limit information
+     */
+    getRateLimitInfo() {
+        return { ...this.rateLimitInfo };
+    }
+    /**
+     * Make GET request
+     */
+    async get(url, config) {
+        return this.request({ ...config, method: 'GET', url });
+    }
+    /**
+     * Make POST request
+     */
+    async post(url, data, config) {
+        return this.request({ ...config, method: 'POST', url, data });
+    }
+    /**
+     * Make PUT request
+     */
+    async put(url, data, config) {
+        return this.request({ ...config, method: 'PUT', url, data });
+    }
+    /**
+     * Make PATCH request
+     */
+    async patch(url, data, config) {
+        return this.request({ ...config, method: 'PATCH', url, data });
+    }
+    /**
+     * Make DELETE request
+     */
+    async delete(url, config) {
+        return this.request({ ...config, method: 'DELETE', url });
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        if (config.appId) {
+            this.axiosInstance.defaults.headers['X-App-Id'] = config.appId;
+        }
+        if (config.apiKey) {
+            this.axiosInstance.defaults.headers['X-Api-Key'] = config.apiKey;
+        }
+        if (config.baseUrl) {
+            this.axiosInstance.defaults.baseURL = config.baseUrl;
+        }
+        if (config.timeout) {
+            this.axiosInstance.defaults.timeout = config.timeout;
+        }
+    }
+}
+
+/**
+ * Utility functions for the Raba7ni SDK
+ */
+/**
+ * Normalize phone number to E.164 format
+ */
+function normalizePhoneNumber(phoneNumber) {
+    if (!phoneNumber) {
+        throw new Error('Phone number is required');
+    }
+    // Remove all non-numeric characters except +
+    let normalized = phoneNumber.replace(/[^\d+]/g, '');
+    // If starts with +, keep it, otherwise assume international format
+    if (!normalized.startsWith('+')) {
+        // Remove leading zeros
+        normalized = normalized.replace(/^0+/, '');
+        // If no country code, you might want to add a default one
+        // For now, we'll assume the input is already in international format
+        // In a real implementation, you might want to use a library like
+        // google-libphonenumber to handle country codes properly
+        normalized = '+' + normalized;
+    }
+    // Basic validation
+    if (normalized.length < 8 || normalized.length > 15) {
+        throw new Error('Invalid phone number format');
+    }
+    return normalized;
+}
+/**
+ * Validate email format
+ */
+function validateEmail(email) {
+    if (!email) {
+        return false;
+    }
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * Validate card ID
+ */
+function validateCardId(cardId) {
+    const id = typeof cardId === 'string' ? parseInt(cardId, 10) : cardId;
+    if (isNaN(id) || id <= 0) {
+        throw new Error('Card ID must be a positive integer');
+    }
+    return id;
+}
+/**
+ * Validate monetary amount
+ */
+function validateAmount(amount) {
+    const num = typeof amount === 'string' ? parseFloat(amount) : amount;
+    if (isNaN(num) || num < 0) {
+        throw new Error('Amount must be a non-negative number');
+    }
+    // Round to 2 decimal places
+    return Math.round(num * 100) / 100;
+}
+/**
+ * Sanitize string input
+ */
+function sanitizeString(input, maxLength = 255) {
+    if (!input) {
+        return '';
+    }
+    // Remove HTML tags and extra whitespace
+    let sanitized = input.replace(/<[^>]*>/g, '').trim();
+    // Truncate if too long
+    if (sanitized.length > maxLength) {
+        sanitized = sanitized.substring(0, maxLength);
+    }
+    return sanitized;
+}
+/**
+ * Validate name field
+ */
+function validateName(name) {
+    if (!name || name.trim().length === 0) {
+        throw new Error('Name is required');
+    }
+    const sanitized = sanitizeString(name.trim(), 100);
+    if (sanitized.length < 2) {
+        throw new Error('Name must be at least 2 characters long');
+    }
+    return sanitized;
+}
+/**
+ * Deep clone object
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => deepClone(item));
+    }
+    const cloned = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            cloned[key] = deepClone(obj[key]);
+        }
+    }
+    return cloned;
+}
+/**
+ * Retry delay calculation with exponential backoff
+ */
+function calculateRetryDelay(attempt, baseDelay = 1000) {
+    return Math.min(baseDelay * Math.pow(2, attempt), 30000); // Max 30 seconds
+}
+/**
+ * Generate random string for request tracking
+ */
+function generateRequestId() {
+    return Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15);
+}
+/**
+ * Check if a value is a valid ISO date string
+ */
+function isValidISODate(dateString) {
+    if (!dateString) {
+        return false;
+    }
+    const date = new Date(dateString);
+    return !isNaN(date.getTime()) && dateString.includes('T');
+}
+/**
+ * Format date to ISO string
+ */
+function formatDate(date) {
+    if (typeof date === 'string') {
+        return date;
+    }
+    return date.toISOString();
+}
+
+/**
+ * Main Raba7ni SDK class
+ */
+class Raba7niSDK {
+    constructor(config) {
+        this.client = new Raba7niClient(config);
+    }
+    /**
+     * Validate if a phone number is a member of a specific card
+     */
+    async validateMember(cardId, phoneNumber, options = {}) {
+        const validatedCardId = validateCardId(cardId);
+        const normalizedPhone = normalizePhoneNumber(phoneNumber);
+        const request = {
+            card_id: validatedCardId,
+            phone_number: normalizedPhone,
+            include_member_data: options.include_member_data || false
+        };
+        const response = await this.client.post('validate-member', request);
+        return response.data;
+    }
+    /**
+     * Get detailed information about a member for a specific card
+     */
+    async getMemberDetails(cardId, phoneNumber) {
+        const validatedCardId = validateCardId(cardId);
+        const normalizedPhone = normalizePhoneNumber(phoneNumber);
+        const request = {
+            card_id: validatedCardId,
+            phone_number: normalizedPhone
+        };
+        const response = await this.client.post('member-details', request);
+        return response.data;
+    }
+    /**
+     * Find an existing member by email/phone, or create a new account.
+     * Optionally create an online order and/or award points.
+     */
+    async findOrCreateMember(request) {
+        const validatedRequest = {
+            card_id: validateCardId(request.card_id),
+            name: validateName(request.name),
+            email: sanitizeString(request.email.toLowerCase()),
+            phone_number: normalizePhoneNumber(request.phone_number),
+            create_order: request.create_order,
+            order: request.order ? {
+                award_points: request.order.award_points || false,
+                total_amount: validateAmount(request.order.total_amount),
+                delivery_cost: request.order.delivery_cost
+                    ? validateAmount(request.order.delivery_cost)
+                    : undefined,
+                items: request.order.items?.map(item => ({
+                    name: sanitizeString(item.name, 100),
+                    amount: validateAmount(item.amount),
+                    metadata: item.metadata || {}
+                }))
+            } : undefined
+        };
+        // Validate email format if provided
+        if (validatedRequest.email && !validateEmail(validatedRequest.email)) {
+            throw new Error('Invalid email format');
+        }
+        const response = await this.client.post('find-or-create-member', validatedRequest);
+        return response.data;
+    }
+    /**
+     * Get card information
+     */
+    async getCardInfo(cardId) {
+        const validatedCardId = validateCardId(cardId);
+        const response = await this.client.get(`cards/${validatedCardId}`);
+        return response.data;
+    }
+    /**
+     * Get available API scopes
+     */
+    async getScopes() {
+        const response = await this.client.get('scopes');
+        return response.data;
+    }
+    /**
+     * Get available webhook events
+     */
+    async getWebhookEvents() {
+        const response = await this.client.get('webhook-events');
+        return response.data;
+    }
+    /**
+     * Get current rate limit information
+     */
+    getRateLimitInfo() {
+        return this.client.getRateLimitInfo();
+    }
+    /**
+     * Update SDK configuration
+     */
+    updateConfig(config) {
+        this.client.updateConfig(config);
+    }
+    /**
+     * Helper method to make custom API requests
+     */
+    async request(method, endpoint, data, options) {
+        let response;
+        switch (method.toUpperCase()) {
+            case 'GET':
+                response = await this.client.get(endpoint, options);
+                break;
+            case 'POST':
+                response = await this.client.post(endpoint, data, options);
+                break;
+            case 'PUT':
+                response = await this.client.put(endpoint, data, options);
+                break;
+            case 'PATCH':
+                response = await this.client.patch(endpoint, data, options);
+                break;
+            case 'DELETE':
+                response = await this.client.delete(endpoint, options);
+                break;
+            default:
+                throw new Error(`Unsupported HTTP method: ${method}`);
+        }
+        return response.data;
+    }
+}
+
+/**
+ * Webhook signature verification utilities
+ */
+/**
+ * Verify webhook signature
+ */
+function verifyWebhookSignature(payload, signature, secret) {
+    if (!payload || !signature || !secret) {
+        return false;
+    }
+    try {
+        const expectedSignature = crypto.createHmac('sha256', secret)
+            .update(payload, 'utf8')
+            .digest('hex');
+        // Use constant-time comparison to prevent timing attacks
+        return crypto.timingSafeEqual(Buffer.from(signature, 'hex'), Buffer.from(expectedSignature, 'hex'));
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Parse webhook payload with type safety
+ */
+function parseWebhookPayload(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        // Validate required fields
+        if (!parsed.event || !parsed.timestamp || !parsed.data) {
+            throw new Error('Invalid webhook payload: missing required fields');
+        }
+        // Validate timestamp format
+        const timestamp = new Date(parsed.timestamp);
+        if (isNaN(timestamp.getTime())) {
+            throw new Error('Invalid webhook payload: invalid timestamp format');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Failed to parse webhook payload: ${error}`);
+    }
+}
+/**
+ * Type guard for member joined webhook
+ */
+function isMemberJoinedWebhook(payload) {
+    return payload.event === 'member_joined';
+}
+/**
+ * Type guard for member left webhook
+ */
+function isMemberLeftWebhook(payload) {
+    return payload.event === 'member_left';
+}
+/**
+ * Type guard for points earned webhook
+ */
+function isPointsEarnedWebhook(payload) {
+    return payload.event === 'points_earned';
+}
+/**
+ * Type guard for points redeemed webhook
+ */
+function isPointsRedeemedWebhook(payload) {
+    return payload.event === 'points_redeemed';
+}
+/**
+ * Type guard for transaction created webhook
+ */
+function isTransactionCreatedWebhook(payload) {
+    return payload.event === 'transaction_created';
+}
+/**
+ * Webhook handler class
+ */
+class WebhookHandler {
+    constructor(secret) {
+        if (!secret) {
+            throw new Error('Webhook secret is required');
+        }
+        this.secret = secret;
+    }
+    /**
+     * Verify and parse incoming webhook
+     */
+    async verifyAndParse(payload, signature) {
+        if (!this.verifyWebhookSignature(payload, signature)) {
+            throw new Error('Invalid webhook signature');
+        }
+        return this.parseWebhookPayload(payload);
+    }
+    /**
+     * Verify webhook signature
+     */
+    verifyWebhookSignature(payload, signature) {
+        return verifyWebhookSignature(payload, signature, this.secret);
+    }
+    /**
+     * Parse webhook payload
+     */
+    parseWebhookPayload(payload) {
+        return parseWebhookPayload(payload);
+    }
+    /**
+     * Handle webhook with event-specific callbacks
+     */
+    async handleWebhook(payload, signature, handlers) {
+        const webhook = await this.verifyAndParse(payload, signature);
+        try {
+            switch (webhook.event) {
+                case 'member_joined':
+                    if (handlers.onMemberJoined && isMemberJoinedWebhook(webhook)) {
+                        await handlers.onMemberJoined(webhook.data);
+                    }
+                    break;
+                case 'member_left':
+                    if (handlers.onMemberLeft && isMemberLeftWebhook(webhook)) {
+                        await handlers.onMemberLeft(webhook.data);
+                    }
+                    break;
+                case 'points_earned':
+                    if (handlers.onPointsEarned && isPointsEarnedWebhook(webhook)) {
+                        await handlers.onPointsEarned(webhook.data);
+                    }
+                    break;
+                case 'points_redeemed':
+                    if (handlers.onPointsRedeemed && isPointsRedeemedWebhook(webhook)) {
+                        await handlers.onPointsRedeemed(webhook.data);
+                    }
+                    break;
+                case 'transaction_created':
+                    if (handlers.onTransactionCreated && isTransactionCreatedWebhook(webhook)) {
+                        await handlers.onTransactionCreated(webhook.data);
+                    }
+                    break;
+                default:
+                    if (handlers.onUnknownEvent) {
+                        await handlers.onUnknownEvent(webhook.event, webhook.data);
+                    }
+                    break;
+            }
+        }
+        catch (error) {
+            throw new Error(`Error handling webhook event ${webhook.event}: ${error}`);
+        }
+    }
+    /**
+     * Update webhook secret
+     */
+    updateSecret(secret) {
+        if (!secret) {
+            throw new Error('Webhook secret is required');
+        }
+        this.secret = secret;
+    }
+    /**
+     * Get current secret
+     */
+    getSecret() {
+        return this.secret;
+    }
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.NetworkError = NetworkError;
+exports.Raba7niClient = Raba7niClient;
+exports.Raba7niError = Raba7niError;
+exports.Raba7niSDK = Raba7niSDK;
+exports.RateLimitError = RateLimitError;
+exports.ValidationError = ValidationError;
+exports.WebhookHandler = WebhookHandler;
+exports.calculateRetryDelay = calculateRetryDelay;
+exports.deepClone = deepClone;
+exports.default = Raba7niSDK;
+exports.formatDate = formatDate;
+exports.generateRequestId = generateRequestId;
+exports.isMemberJoinedWebhook = isMemberJoinedWebhook;
+exports.isMemberLeftWebhook = isMemberLeftWebhook;
+exports.isPointsEarnedWebhook = isPointsEarnedWebhook;
+exports.isPointsRedeemedWebhook = isPointsRedeemedWebhook;
+exports.isTransactionCreatedWebhook = isTransactionCreatedWebhook;
+exports.isValidISODate = isValidISODate;
+exports.normalizePhoneNumber = normalizePhoneNumber;
+exports.parseWebhookPayload = parseWebhookPayload;
+exports.sanitizeString = sanitizeString;
+exports.validateAmount = validateAmount;
+exports.validateCardId = validateCardId;
+exports.validateEmail = validateEmail;
+exports.validateName = validateName;
+exports.verifyWebhookSignature = verifyWebhookSignature;
+//# sourceMappingURL=index.js.map