@sahabaplus/moyasar/dist/features/invoice/service.js

A comprehensive TypeScript SDK for integrating with the Moyasar payment gateway

import { API_ENDPOINTS } from "../../shared/constants/index";
import { InvoiceStatus } from "./enums";
import { InvoiceUtils } from "./utils";
import { InvoiceError } from "./errors";
import { MoyasarError } from "../../shared/errors/index";
export class InvoiceService {
    constructor(p) {
        this.apiClient = p.apiClient;
    }
    /**
     * Create a new invoice
     */
    async create(params) {
        // Validate input
        const validation = InvoiceUtils.validateCreateInvoiceRequest(params);
        if (!validation.success) {
            throw new InvoiceError(`Validation failed: ${validation.errors.join(", ")}`);
        }
        try {
            const invoice = await this.apiClient.request({
                method: "POST",
                url: API_ENDPOINTS.invoices,
                data: params,
            });
            return invoice;
        }
        catch (error) {
            const invoiceError = this.handleError(error, "Failed to create invoice");
            throw invoiceError;
        }
    }
    /**
     * Create multiple invoices in bulk
     */
    async createBulk(params) {
        // Validate input
        const validation = InvoiceUtils.validateBulkCreateRequest(params);
        if (!validation.success) {
            throw new InvoiceError(`Validation failed: ${validation.errors.join(", ")}`);
        }
        try {
            const response = await this.apiClient.request({
                method: "POST",
                url: API_ENDPOINTS.bulkInvoices,
                data: params,
            });
            return response;
        }
        catch (error) {
            const invoiceError = this.handleError(error, "Failed to create bulk invoices");
            throw invoiceError;
        }
    }
    /**
     * List invoices with optional filtering
     */
    async list(options = {}) {
        try {
            // Convert metadata filters to proper query format
            const queryParams = this.parseBody(options);
            return await this.apiClient.request({
                method: "GET",
                url: API_ENDPOINTS.invoices,
                params: queryParams,
            });
        }
        catch (error) {
            const invoiceError = this.handleError(error, "Failed to list invoices");
            throw invoiceError;
        }
    }
    /**
     * Retrieve a specific invoice
     */
    async retrieve(invoiceId) {
        if (!invoiceId) {
            throw new InvoiceError("Invoice ID is required");
        }
        try {
            return await this.apiClient.request({
                method: "GET",
                url: `${API_ENDPOINTS.invoices}/${invoiceId}`,
            });
        }
        catch (error) {
            const invoiceError = this.handleError(error, `Failed to retrieve invoice ${invoiceId}`);
            throw invoiceError;
        }
    }
    /**
     * Update an invoice
     */
    async update(invoiceId, params) {
        if (!invoiceId) {
            throw new InvoiceError("Invoice ID is required");
        }
        try {
            const invoice = await this.apiClient.request({
                method: "PUT",
                url: `${API_ENDPOINTS.invoices}/${invoiceId}`,
                data: params,
            });
            return invoice;
        }
        catch (error) {
            const invoiceError = this.handleError(error, `Failed to update invoice ${invoiceId}`);
            throw invoiceError;
        }
    }
    /**
     * Cancel an invoice
     */
    async cancel(invoiceId) {
        if (!invoiceId) {
            throw new InvoiceError("Invoice ID is required");
        }
        try {
            const invoice = await this.apiClient.request({
                method: "PUT",
                url: `${API_ENDPOINTS.invoices}/${invoiceId}/cancel`,
            });
            return invoice;
        }
        catch (error) {
            const invoiceError = this.handleError(error, `Failed to cancel invoice ${invoiceId}`);
            throw invoiceError;
        }
    }
    /**
     * Search invoices by metadata
     */
    async searchByMetadata(metadata, options = {}) {
        const metadataQuery = InvoiceUtils.buildMetadataQuery(metadata);
        return this.list({
            ...options,
            ...metadataQuery,
        });
    }
    /**
     * Get invoices by status
     */
    async getByStatus(status, options = {}) {
        return this.list({
            ...options,
            status,
        });
    }
    /**
     * Get expired invoices
     */
    async getExpired(options = {}) {
        return this.getByStatus(InvoiceStatus.EXPIRED, options);
    }
    /**
     * Get paid invoices
     */
    async getPaid(options = {}) {
        return this.getByStatus(InvoiceStatus.PAID, options);
    }
    handleError(error, message) {
        if (error instanceof InvoiceError) {
            return error;
        }
        if (error instanceof MoyasarError) {
            return new InvoiceError(`${message}: ${error.message}`, {
                ...error.details,
            });
        }
        const errorMessage = error?.message || error?.toString() || "Unknown error";
        return new InvoiceError(`${message}: ${errorMessage}`, {
            cause: errorMessage,
        });
    }
    parseBody(p) {
        const copied = { ...p };
        Object.entries(copied).forEach(([key, value]) => {
            if (typeof value === "object") {
                if (value instanceof Date) {
                    // @ts-expect-error
                    copied[key] = value.toISOString();
                }
            }
        });
        return copied;
    }
}
//# sourceMappingURL=service.js.map