keez-invoicing 1.1.5

package/dist/src/keezApi.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeezApi = void 0;
+const authorise_1 = require("./api/authorise");
+const getAll_1 = require("./api/invoices/getAll");
+const view_1 = require("./api/invoices/view");
+const sendMail_1 = require("./api/invoices/sendMail");
+const create_1 = require("./api/invoices/create");
+const validate_1 = require("./api/invoices/validate");
+const update_1 = require("./api/invoices/update");
+const delete_1 = require("./api/invoices/delete");
+const submitEfactura_1 = require("./api/invoices/submitEfactura");
+const cancel_1 = require("./api/invoices/cancel");
+const downloadPdf_1 = require("./api/invoices/downloadPdf");
+const logger_1 = require("./helpers/logger");
+const items_1 = require("./api/items");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Main' });
+class KeezApi {
+    constructor(params) {
+        this.authResponse = null;
+        this.appId = params.application_id;
+        this.apiSecret = params.secret;
+        this.apiClientId = params.client_eid;
+        this.isLive = params.live;
+    }
+    /**
+     * Get the base domain for the API
+     * @returns {string} - The base domain
+     */
+    getBaseDomain() {
+        return this.isLive ? 'https://app.keez.ro' : 'https://staging.keez.ro';
+    }
+    async checkIfTokenIsValid() {
+        if (!this.authToken || !this.authResponse || this.authResponse.expires_at < Date.now()) {
+            keezLogger.info('Token is invalid, generating a new one');
+            await this.generateToken();
+        }
+    }
+    async generateToken() {
+        const authResponse = await (0, authorise_1.apiGenerateToken)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            apiSecret: this.apiSecret,
+        });
+        this.authResponse = authResponse;
+        this.authToken = authResponse.access_token;
+    }
+    /**
+     * Set live mode
+     *
+     * @param {boolean} mode - `False` will use the staging mode and `True` will use the production mode
+     */
+    setLive(mode) {
+        this.isLive = mode;
+    }
+    // ==================== INVOICE METHODS ====================
+    /**
+     * Get all invoices with optional filtering and pagination
+     * @param params - Optional filter parameters
+     */
+    async getAllInvoices(params) {
+        await this.checkIfTokenIsValid();
+        return (0, getAll_1.apiGetAllInvoices)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            filterParams: params,
+        });
+    }
+    /**
+     * Get an invoice by its external ID
+     * @param invoiceExternalId - The external ID of the invoice
+     */
+    async getInvoiceByExternalId(invoiceExternalId) {
+        await this.checkIfTokenIsValid();
+        return (0, view_1.apiGetInvoiceByExternalId)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            invoiceId: invoiceExternalId,
+        });
+    }
+    async sendInvoice(emailOrParams, invoiceExternalId) {
+        await this.checkIfTokenIsValid();
+        if (typeof emailOrParams === 'string') {
+            return (0, sendMail_1.apiSendInvoice)({
+                baseDomain: this.getBaseDomain(),
+                appId: this.appId,
+                bearerToken: this.authToken,
+                clientMail: emailOrParams,
+                invoiceId: invoiceExternalId,
+            });
+        }
+        return (0, sendMail_1.apiSendInvoice)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            bearerToken: this.authToken,
+            emailParams: emailOrParams,
+            invoiceId: invoiceExternalId,
+        });
+    }
+    /**
+     * Create a new invoice
+     * @param invoiceParams - The invoice parameters
+     */
+    async createInvoice(invoiceParams) {
+        await this.checkIfTokenIsValid();
+        return (0, create_1.apiCreateInvoice)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            invoice: invoiceParams,
+        });
+    }
+    /**
+     * Validate an invoice
+     * @param invoiceExternalId - The external ID of the invoice
+     */
+    async validateInvoice(invoiceExternalId) {
+        await this.checkIfTokenIsValid();
+        return (0, validate_1.apiValidateInvoice)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            invoiceId: invoiceExternalId,
+        });
+    }
+    /**
+     * Update an existing invoice
+     * @param invoiceId - The external ID of the invoice to update
+     * @param invoice - The updated invoice data
+     */
+    async updateInvoice(invoiceId, invoice) {
+        await this.checkIfTokenIsValid();
+        return (0, update_1.apiUpdateInvoice)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            invoiceId,
+            invoice,
+        });
+    }
+    /**
+     * Delete an invoice
+     * @param invoiceId - The external ID of the invoice to delete
+     */
+    async deleteInvoice(invoiceId) {
+        await this.checkIfTokenIsValid();
+        return (0, delete_1.apiDeleteInvoice)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            invoiceId,
+        });
+    }
+    /**
+     * Submit an invoice to eFactura (Romanian electronic invoicing system)
+     * @param invoiceId - The external ID of the invoice to submit
+     * @returns The upload index or confirmation from eFactura
+     */
+    async submitInvoiceToEfactura(invoiceId) {
+        await this.checkIfTokenIsValid();
+        return (0, submitEfactura_1.apiSubmitEfactura)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            invoiceId,
+        });
+    }
+    /**
+     * Cancel an invoice
+     * @param invoiceId - The external ID of the invoice to cancel
+     */
+    async cancelInvoice(invoiceId) {
+        await this.checkIfTokenIsValid();
+        return (0, cancel_1.apiCancelInvoice)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            invoiceId,
+        });
+    }
+    /**
+     * Download an invoice as PDF
+     * @param invoiceId - The external ID of the invoice
+     * @returns Buffer containing the PDF data
+     */
+    async downloadInvoicePdf(invoiceId) {
+        await this.checkIfTokenIsValid();
+        return (0, downloadPdf_1.apiDownloadInvoicePdf)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            bearerToken: this.authToken,
+            invoiceId,
+        });
+    }
+    // ==================== ITEM METHODS ====================
+    /**
+     * Get all items with optional filtering and pagination
+     * @param params - Optional filter parameters
+     */
+    async getAllItems(params) {
+        await this.checkIfTokenIsValid();
+        return (0, items_1.apiGetAllItems)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            filterParams: params,
+        });
+    }
+    /**
+     * Get an item by its external ID
+     * @param itemId - The external ID of the item
+     */
+    async getItemByExternalId(itemId) {
+        await this.checkIfTokenIsValid();
+        return (0, items_1.apiGetItemById)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            itemId,
+        });
+    }
+    /**
+     * Create a new item
+     * @param item - The item data to create
+     * @returns The external ID of the created item
+     */
+    async createItem(item) {
+        await this.checkIfTokenIsValid();
+        return (0, items_1.apiCreateItem)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            item,
+        });
+    }
+    /**
+     * Update an existing item (full replacement)
+     * @param itemId - The external ID of the item to update
+     * @param item - The updated item data
+     */
+    async updateItem(itemId, item) {
+        await this.checkIfTokenIsValid();
+        return (0, items_1.apiUpdateItem)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            itemId,
+            item,
+        });
+    }
+    /**
+     * Partially update an existing item
+     * @param itemId - The external ID of the item to patch
+     * @param item - The fields to update
+     */
+    async patchItem(itemId, item) {
+        await this.checkIfTokenIsValid();
+        return (0, items_1.apiPatchItem)({
+            baseDomain: this.getBaseDomain(),
+            appId: this.appId,
+            appClientId: this.apiClientId,
+            bearerToken: this.authToken,
+            itemId,
+            item,
+        });
+    }
+}
+exports.KeezApi = KeezApi;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keezApi.js","sourceRoot":"","sources":["../../src/keezApi.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeezConstructor } from './config/constructorParam';\nimport { apiGenerateToken } from './api/authorise';\nimport { apiGetAllInvoices } from './api/invoices/getAll';\nimport { apiGetInvoiceByExternalId } from './api/invoices/view';\nimport { apiSendInvoice } from './api/invoices/sendMail';\nimport { InvoiceRequest } from './dto/createInvoiceRequest';\nimport { apiCreateInvoice } from './api/invoices/create';\nimport { apiValidateInvoice } from './api/invoices/validate';\nimport { apiUpdateInvoice } from './api/invoices/update';\nimport { apiDeleteInvoice } from './api/invoices/delete';\nimport { apiSubmitEfactura } from './api/invoices/submitEfactura';\nimport { apiCancelInvoice } from './api/invoices/cancel';\nimport { apiDownloadInvoicePdf } from './api/invoices/downloadPdf';\nimport { AuthResponse } from './dto/authResponse';\nimport { logger } from './helpers/logger';\nimport { InvoiceFilterParams, InvoiceRequestV2, SendInvoiceEmailParams } from './dto/invoices';\nimport { apiGetAllItems, apiGetItemById, apiCreateItem, apiUpdateItem, apiPatchItem } from './api/items';\nimport {\n    AllItemsResponse,\n    CreateItemRequest,\n    ItemFilterParams,\n    ItemResponse,\n    PatchItemRequest,\n    UpdateItemRequest,\n} from './dto/items';\n\nconst keezLogger = logger.child({ _library: 'KeezWrapper', _method: 'Main' });\n\nexport class KeezApi {\n    private readonly appId: string;\n    private readonly apiSecret: string;\n    private readonly apiClientId: string;\n    private authResponse: AuthResponse | null = null;\n    private authToken: string;\n    private isLive: boolean;\n\n    constructor(params: KeezConstructor) {\n        this.appId = params.application_id;\n        this.apiSecret = params.secret;\n        this.apiClientId = params.client_eid;\n        this.isLive = params.live;\n    }\n\n    /**\n     * Get the base domain for the API\n     * @returns {string} - The base domain\n     */\n    public getBaseDomain(): string {\n        return this.isLive ? 'https://app.keez.ro' : 'https://staging.keez.ro';\n    }\n\n    private async checkIfTokenIsValid() {\n        if (!this.authToken || !this.authResponse || this.authResponse.expires_at < Date.now()) {\n            keezLogger.info('Token is invalid, generating a new one');\n            await this.generateToken();\n        }\n    }\n\n    private async generateToken() {\n        const authResponse = await apiGenerateToken({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            apiSecret: this.apiSecret,\n        });\n        this.authResponse = authResponse;\n        this.authToken = authResponse.access_token;\n    }\n\n    /**\n     * Set live mode\n     *\n     * @param {boolean} mode - `False` will use the staging mode and `True` will use the production mode\n     */\n    public setLive(mode: boolean) {\n        this.isLive = mode;\n    }\n\n    // ==================== INVOICE METHODS ====================\n\n    /**\n     * Get all invoices with optional filtering and pagination\n     * @param params - Optional filter parameters\n     */\n    public async getAllInvoices(params?: InvoiceFilterParams) {\n        await this.checkIfTokenIsValid();\n        return apiGetAllInvoices({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            filterParams: params,\n        });\n    }\n\n    /**\n     * Get an invoice by its external ID\n     * @param invoiceExternalId - The external ID of the invoice\n     */\n    public async getInvoiceByExternalId(invoiceExternalId: string) {\n        await this.checkIfTokenIsValid();\n        return apiGetInvoiceByExternalId({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            invoiceId: invoiceExternalId,\n        });\n    }\n\n    /**\n     * Send an invoice via email\n     * @param email - The recipient email address\n     * @param invoiceExternalId - The external ID of the invoice\n     */\n    public async sendInvoice(email: string, invoiceExternalId: string): Promise<string>;\n    /**\n     * Send an invoice via email with CC/BCC support\n     * @param emailParams - Email parameters including to, cc, and bcc\n     * @param invoiceExternalId - The external ID of the invoice\n     */\n    public async sendInvoice(emailParams: SendInvoiceEmailParams, invoiceExternalId: string): Promise<string>;\n    public async sendInvoice(\n        emailOrParams: string | SendInvoiceEmailParams,\n        invoiceExternalId: string\n    ): Promise<string> {\n        await this.checkIfTokenIsValid();\n        if (typeof emailOrParams === 'string') {\n            return apiSendInvoice({\n                baseDomain: this.getBaseDomain(),\n                appId: this.appId,\n                bearerToken: this.authToken,\n                clientMail: emailOrParams,\n                invoiceId: invoiceExternalId,\n            });\n        }\n        return apiSendInvoice({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            bearerToken: this.authToken,\n            emailParams: emailOrParams,\n            invoiceId: invoiceExternalId,\n        });\n    }\n\n    /**\n     * Create a new invoice\n     * @param invoiceParams - The invoice parameters\n     */\n    public async createInvoice(invoiceParams: InvoiceRequest) {\n        await this.checkIfTokenIsValid();\n        return apiCreateInvoice({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            invoice: invoiceParams,\n        });\n    }\n\n    /**\n     * Validate an invoice\n     * @param invoiceExternalId - The external ID of the invoice\n     */\n    public async validateInvoice(invoiceExternalId: string) {\n        await this.checkIfTokenIsValid();\n        return apiValidateInvoice({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            invoiceId: invoiceExternalId,\n        });\n    }\n\n    /**\n     * Update an existing invoice\n     * @param invoiceId - The external ID of the invoice to update\n     * @param invoice - The updated invoice data\n     */\n    public async updateInvoice(invoiceId: string, invoice: InvoiceRequestV2): Promise<void> {\n        await this.checkIfTokenIsValid();\n        return apiUpdateInvoice({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            invoiceId,\n            invoice,\n        });\n    }\n\n    /**\n     * Delete an invoice\n     * @param invoiceId - The external ID of the invoice to delete\n     */\n    public async deleteInvoice(invoiceId: string): Promise<void> {\n        await this.checkIfTokenIsValid();\n        return apiDeleteInvoice({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            invoiceId,\n        });\n    }\n\n    /**\n     * Submit an invoice to eFactura (Romanian electronic invoicing system)\n     * @param invoiceId - The external ID of the invoice to submit\n     * @returns The upload index or confirmation from eFactura\n     */\n    public async submitInvoiceToEfactura(invoiceId: string): Promise<string> {\n        await this.checkIfTokenIsValid();\n        return apiSubmitEfactura({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            invoiceId,\n        });\n    }\n\n    /**\n     * Cancel an invoice\n     * @param invoiceId - The external ID of the invoice to cancel\n     */\n    public async cancelInvoice(invoiceId: string): Promise<void> {\n        await this.checkIfTokenIsValid();\n        return apiCancelInvoice({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            invoiceId,\n        });\n    }\n\n    /**\n     * Download an invoice as PDF\n     * @param invoiceId - The external ID of the invoice\n     * @returns Buffer containing the PDF data\n     */\n    public async downloadInvoicePdf(invoiceId: string): Promise<Buffer> {\n        await this.checkIfTokenIsValid();\n        return apiDownloadInvoicePdf({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            bearerToken: this.authToken,\n            invoiceId,\n        });\n    }\n\n    // ==================== ITEM METHODS ====================\n\n    /**\n     * Get all items with optional filtering and pagination\n     * @param params - Optional filter parameters\n     */\n    public async getAllItems(params?: ItemFilterParams): Promise<AllItemsResponse> {\n        await this.checkIfTokenIsValid();\n        return apiGetAllItems({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            filterParams: params,\n        });\n    }\n\n    /**\n     * Get an item by its external ID\n     * @param itemId - The external ID of the item\n     */\n    public async getItemByExternalId(itemId: string): Promise<ItemResponse> {\n        await this.checkIfTokenIsValid();\n        return apiGetItemById({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            itemId,\n        });\n    }\n\n    /**\n     * Create a new item\n     * @param item - The item data to create\n     * @returns The external ID of the created item\n     */\n    public async createItem(item: CreateItemRequest): Promise<string> {\n        await this.checkIfTokenIsValid();\n        return apiCreateItem({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            item,\n        });\n    }\n\n    /**\n     * Update an existing item (full replacement)\n     * @param itemId - The external ID of the item to update\n     * @param item - The updated item data\n     */\n    public async updateItem(itemId: string, item: UpdateItemRequest): Promise<void> {\n        await this.checkIfTokenIsValid();\n        return apiUpdateItem({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            itemId,\n            item,\n        });\n    }\n\n    /**\n     * Partially update an existing item\n     * @param itemId - The external ID of the item to patch\n     * @param item - The fields to update\n     */\n    public async patchItem(itemId: string, item: PatchItemRequest): Promise<void> {\n        await this.checkIfTokenIsValid();\n        return apiPatchItem({\n            baseDomain: this.getBaseDomain(),\n            appId: this.appId,\n            appClientId: this.apiClientId,\n            bearerToken: this.authToken,\n            itemId,\n            item,\n        });\n    }\n}\n"]}