keez-invoicing 1.1.5

package/dist/coverage/lcov-report/sorter.js

@@ -0,0 +1,177 @@
+"use strict";
+/* eslint-disable */
+var addSorting = (function () {
+    'use strict';
+    var cols, currentSort = {
+        index: 0,
+        desc: false
+    };
+    // returns the summary table element
+    function getTable() {
+        return document.querySelector('.coverage-summary');
+    }
+    // returns the thead element of the summary table
+    function getTableHeader() {
+        return getTable().querySelector('thead tr');
+    }
+    // returns the tbody element of the summary table
+    function getTableBody() {
+        return getTable().querySelector('tbody');
+    }
+    // returns the th element for nth column
+    function getNthColumn(n) {
+        return getTableHeader().querySelectorAll('th')[n];
+    }
+    function onFilterInput() {
+        const searchValue = document.getElementById('fileSearch').value;
+        const rows = document.getElementsByTagName('tbody')[0].children;
+        // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+        // it will be treated as a plain text search
+        let searchRegex;
+        try {
+            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive
+        }
+        catch (error) {
+            searchRegex = null;
+        }
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            let isMatch = false;
+            if (searchRegex) {
+                // If a valid regex was created, use it for matching
+                isMatch = searchRegex.test(row.textContent);
+            }
+            else {
+                // Otherwise, fall back to the original plain text search
+                isMatch = row.textContent
+                    .toLowerCase()
+                    .includes(searchValue.toLowerCase());
+            }
+            row.style.display = isMatch ? '' : 'none';
+        }
+    }
+    // loads the search box
+    function addSearchBox() {
+        var template = document.getElementById('filterTemplate');
+        var templateClone = template.content.cloneNode(true);
+        templateClone.getElementById('fileSearch').oninput = onFilterInput;
+        template.parentElement.appendChild(templateClone);
+    }
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'), colNode, cols = [], col, i;
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML =
+                    colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'), colNode, col, data = {}, i, val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'), i;
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key, sorter = function (a, b) {
+            a = a.data[key];
+            b = b.data[key];
+            return a < b ? -1 : a > b ? 1 : 0;
+        }, finalSorter = sorter, tableBody = document.querySelector('.coverage-summary tbody'), rowNodes = tableBody.querySelectorAll('tr'), rows = [], i;
+        if (desc) {
+            finalSorter = function (a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+        rows.sort(finalSorter);
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index), cls = col.className;
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc
+            ? ' sorted-desc'
+            : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i, el, ithSorter = function ithSorter(i) {
+            var col = cols[i];
+            return function () {
+                var desc = col.defaultDescSort;
+                if (currentSort.index === i) {
+                    desc = !currentSort.desc;
+                }
+                sortByIndex(i, desc);
+                removeSortIndicators();
+                currentSort.index = i;
+                currentSort.desc = desc;
+                addSortIndicators();
+            };
+        };
+        for (i = 0; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                // add the click event handler on the th so users
+                // dont have to click on those tiny arrows
+                el = getNthColumn(i).querySelector('.sorter').parentElement;
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                }
+                else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function () {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData();
+        addSearchBox();
+        addSortIndicators();
+        enableUI();
+    };
+})();
+window.addEventListener('load', addSorting);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sorter.js","sourceRoot":"","sources":["../../../coverage/lcov-report/sorter.js"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable */\nvar addSorting = (function() {\n    'use strict';\n    var cols,\n        currentSort = {\n            index: 0,\n            desc: false\n        };\n\n    // returns the summary table element\n    function getTable() {\n        return document.querySelector('.coverage-summary');\n    }\n    // returns the thead element of the summary table\n    function getTableHeader() {\n        return getTable().querySelector('thead tr');\n    }\n    // returns the tbody element of the summary table\n    function getTableBody() {\n        return getTable().querySelector('tbody');\n    }\n    // returns the th element for nth column\n    function getNthColumn(n) {\n        return getTableHeader().querySelectorAll('th')[n];\n    }\n\n    function onFilterInput() {\n        const searchValue = document.getElementById('fileSearch').value;\n        const rows = document.getElementsByTagName('tbody')[0].children;\n\n        // Try to create a RegExp from the searchValue. If it fails (invalid regex),\n        // it will be treated as a plain text search\n        let searchRegex;\n        try {\n            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive\n        } catch (error) {\n            searchRegex = null;\n        }\n\n        for (let i = 0; i < rows.length; i++) {\n            const row = rows[i];\n            let isMatch = false;\n\n            if (searchRegex) {\n                // If a valid regex was created, use it for matching\n                isMatch = searchRegex.test(row.textContent);\n            } else {\n                // Otherwise, fall back to the original plain text search\n                isMatch = row.textContent\n                    .toLowerCase()\n                    .includes(searchValue.toLowerCase());\n            }\n\n            row.style.display = isMatch ? '' : 'none';\n        }\n    }\n\n    // loads the search box\n    function addSearchBox() {\n        var template = document.getElementById('filterTemplate');\n        var templateClone = template.content.cloneNode(true);\n        templateClone.getElementById('fileSearch').oninput = onFilterInput;\n        template.parentElement.appendChild(templateClone);\n    }\n\n    // loads all columns\n    function loadColumns() {\n        var colNodes = getTableHeader().querySelectorAll('th'),\n            colNode,\n            cols = [],\n            col,\n            i;\n\n        for (i = 0; i < colNodes.length; i += 1) {\n            colNode = colNodes[i];\n            col = {\n                key: colNode.getAttribute('data-col'),\n                sortable: !colNode.getAttribute('data-nosort'),\n                type: colNode.getAttribute('data-type') || 'string'\n            };\n            cols.push(col);\n            if (col.sortable) {\n                col.defaultDescSort = col.type === 'number';\n                colNode.innerHTML =\n                    colNode.innerHTML + '<span class=\"sorter\"></span>';\n            }\n        }\n        return cols;\n    }\n    // attaches a data attribute to every tr element with an object\n    // of data values keyed by column name\n    function loadRowData(tableRow) {\n        var tableCols = tableRow.querySelectorAll('td'),\n            colNode,\n            col,\n            data = {},\n            i,\n            val;\n        for (i = 0; i < tableCols.length; i += 1) {\n            colNode = tableCols[i];\n            col = cols[i];\n            val = colNode.getAttribute('data-value');\n            if (col.type === 'number') {\n                val = Number(val);\n            }\n            data[col.key] = val;\n        }\n        return data;\n    }\n    // loads all row data\n    function loadData() {\n        var rows = getTableBody().querySelectorAll('tr'),\n            i;\n\n        for (i = 0; i < rows.length; i += 1) {\n            rows[i].data = loadRowData(rows[i]);\n        }\n    }\n    // sorts the table using the data for the ith column\n    function sortByIndex(index, desc) {\n        var key = cols[index].key,\n            sorter = function(a, b) {\n                a = a.data[key];\n                b = b.data[key];\n                return a < b ? -1 : a > b ? 1 : 0;\n            },\n            finalSorter = sorter,\n            tableBody = document.querySelector('.coverage-summary tbody'),\n            rowNodes = tableBody.querySelectorAll('tr'),\n            rows = [],\n            i;\n\n        if (desc) {\n            finalSorter = function(a, b) {\n                return -1 * sorter(a, b);\n            };\n        }\n\n        for (i = 0; i < rowNodes.length; i += 1) {\n            rows.push(rowNodes[i]);\n            tableBody.removeChild(rowNodes[i]);\n        }\n\n        rows.sort(finalSorter);\n\n        for (i = 0; i < rows.length; i += 1) {\n            tableBody.appendChild(rows[i]);\n        }\n    }\n    // removes sort indicators for current column being sorted\n    function removeSortIndicators() {\n        var col = getNthColumn(currentSort.index),\n            cls = col.className;\n\n        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');\n        col.className = cls;\n    }\n    // adds sort indicators for current column being sorted\n    function addSortIndicators() {\n        getNthColumn(currentSort.index).className += currentSort.desc\n            ? ' sorted-desc'\n            : ' sorted';\n    }\n    // adds event listeners for all sorter widgets\n    function enableUI() {\n        var i,\n            el,\n            ithSorter = function ithSorter(i) {\n                var col = cols[i];\n\n                return function() {\n                    var desc = col.defaultDescSort;\n\n                    if (currentSort.index === i) {\n                        desc = !currentSort.desc;\n                    }\n                    sortByIndex(i, desc);\n                    removeSortIndicators();\n                    currentSort.index = i;\n                    currentSort.desc = desc;\n                    addSortIndicators();\n                };\n            };\n        for (i = 0; i < cols.length; i += 1) {\n            if (cols[i].sortable) {\n                // add the click event handler on the th so users\n                // dont have to click on those tiny arrows\n                el = getNthColumn(i).querySelector('.sorter').parentElement;\n                if (el.addEventListener) {\n                    el.addEventListener('click', ithSorter(i));\n                } else {\n                    el.attachEvent('onclick', ithSorter(i));\n                }\n            }\n        }\n    }\n    // adds sorting functionality to the UI\n    return function() {\n        if (!getTable()) {\n            return;\n        }\n        cols = loadColumns();\n        loadData();\n        addSearchBox();\n        addSortIndicators();\n        enableUI();\n    };\n})();\n\nwindow.addEventListener('load', addSorting);\n"]}

package/dist/eslint.config.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = __importDefault(require("@eslint/js"));
+const typescript_eslint_1 = __importDefault(require("typescript-eslint"));
+const globals_1 = __importDefault(require("globals"));
+exports.default = typescript_eslint_1.default.config(
+// Global ignores (replaces .eslintignore)
+{
+    ignores: ['node_modules/**', 'lib/**', 'coverage/**', 'dist/**'],
+}, 
+// Base ESLint recommended rules
+js_1.default.configs.recommended, 
+// TypeScript recommended rules
+...typescript_eslint_1.default.configs.recommended, 
+// Project-specific configuration
+{
+    files: ['src/**/*.ts'],
+    languageOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        globals: {
+            ...globals_1.default.node,
+            ...globals_1.default.es2021,
+        },
+        parserOptions: {
+            project: true,
+        },
+    },
+    rules: {
+        // Spacing and formatting
+        'indent': 'off',
+        '@typescript-eslint/indent': 'off', // Disabled - using Prettier/WebStorm for formatting
+        'object-curly-spacing': ['error', 'always'],
+        'object-curly-newline': 'off',
+        'padded-blocks': 'off',
+        // TypeScript specific
+        'no-shadow': 'off',
+        '@typescript-eslint/no-shadow': ['error'],
+        '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', caughtErrorsIgnorePattern: '^_' }],
+        '@typescript-eslint/no-explicit-any': 'warn',
+        // Best practices
+        'max-len': ['error', { code: 144, ignoreUrls: true }],
+        'no-plusplus': ['error', { allowForLoopAfterthoughts: true }],
+        'class-methods-use-this': 'off',
+        'no-underscore-dangle': ['error', { allowAfterThis: true }],
+        // Allow certain patterns
+        'no-restricted-syntax': 'off',
+        'arrow-parens': ['error', 'as-needed'],
+        'implicit-arrow-linebreak': 'off',
+        'operator-linebreak': 'off',
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/jest.config.cjs

@@ -0,0 +1,13 @@
+"use strict";
+module.exports = {
+    transform: {
+        '^.+\\.(t|j)s$': 'ts-jest',
+    },
+    testRegex: '(/tests/.*|(\\.|/)(test|spec))\\.(t|j)s$',
+    modulePathIgnorePatterns: ['<rootDir>/dist/'],
+    moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+    moduleNameMapper: {
+        '^@/(.*)$': '<rootDir>/src/$1',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamVzdC5jb25maWcuY2pzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vamVzdC5jb25maWcuY2pzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxNQUFNLENBQUMsT0FBTyxHQUFHO0lBQ2IsU0FBUyxFQUFFO1FBQ1AsZUFBZSxFQUFFLFNBQVM7S0FDN0I7SUFDRCxTQUFTLEVBQUUsMENBQTBDO0lBQ3JELHdCQUF3QixFQUFFLENBQUMsaUJBQWlCLENBQUM7SUFDN0Msb0JBQW9CLEVBQUUsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDbEQsZ0JBQWdCLEVBQUU7UUFDZCxVQUFVLEVBQUUsa0JBQWtCO0tBQ2pDO0NBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIm1vZHVsZS5leHBvcnRzID0ge1xuICAgIHRyYW5zZm9ybToge1xuICAgICAgICAnXi4rXFxcXC4odHxqKXMkJzogJ3RzLWplc3QnLFxuICAgIH0sXG4gICAgdGVzdFJlZ2V4OiAnKC90ZXN0cy8uKnwoXFxcXC58LykodGVzdHxzcGVjKSlcXFxcLih0fGopcyQnLFxuICAgIG1vZHVsZVBhdGhJZ25vcmVQYXR0ZXJuczogWyc8cm9vdERpcj4vZGlzdC8nXSxcbiAgICBtb2R1bGVGaWxlRXh0ZW5zaW9uczogWyd0cycsICdqcycsICdqc29uJywgJ25vZGUnXSxcbiAgICBtb2R1bGVOYW1lTWFwcGVyOiB7XG4gICAgICAgICdeQC8oLiopJCc6ICc8cm9vdERpcj4vc3JjLyQxJyxcbiAgICB9LFxufTtcbiJdfQ==

package/dist/jest.config.js

@@ -0,0 +1,13 @@
+"use strict";
+module.exports = {
+    transform: {
+        '^.+\\.(t|j)s$': 'ts-jest',
+    },
+    testRegex: '(/tests/.*|(\\.|/)(test|spec))\\.(t|j)s$',
+    modulePathIgnorePatterns: ['<rootDir>/dist/'],
+    moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+    moduleNameMapper: {
+        '^@/(.*)$': '<rootDir>/src/$1',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiamVzdC5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9qZXN0LmNvbmZpZy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsTUFBTSxDQUFDLE9BQU8sR0FBRztJQUNiLFNBQVMsRUFBRTtRQUNQLGVBQWUsRUFBRSxTQUFTO0tBQzdCO0lBQ0QsU0FBUyxFQUFFLDBDQUEwQztJQUNyRCx3QkFBd0IsRUFBRSxDQUFDLGlCQUFpQixDQUFDO0lBQzdDLG9CQUFvQixFQUFFLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ2xELGdCQUFnQixFQUFFO1FBQ2QsVUFBVSxFQUFFLGtCQUFrQjtLQUNqQztDQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJtb2R1bGUuZXhwb3J0cyA9IHtcbiAgICB0cmFuc2Zvcm06IHtcbiAgICAgICAgJ14uK1xcXFwuKHR8ailzJCc6ICd0cy1qZXN0JyxcbiAgICB9LFxuICAgIHRlc3RSZWdleDogJygvdGVzdHMvLip8KFxcXFwufC8pKHRlc3R8c3BlYykpXFxcXC4odHxqKXMkJyxcbiAgICBtb2R1bGVQYXRoSWdub3JlUGF0dGVybnM6IFsnPHJvb3REaXI+L2Rpc3QvJ10sXG4gICAgbW9kdWxlRmlsZUV4dGVuc2lvbnM6IFsndHMnLCAnanMnLCAnanNvbicsICdub2RlJ10sXG4gICAgbW9kdWxlTmFtZU1hcHBlcjoge1xuICAgICAgICAnXkAvKC4qKSQnOiAnPHJvb3REaXI+L3NyYy8kMScsXG4gICAgfSxcbn07XG4iXX0=

package/dist/src/api/__tests__/index.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// import nock = require('nock');
+const keezApi_1 = require("../../keezApi");
+describe('Keez API authorisation', () => {
+    let keezApi;
+    beforeAll(() => {
+        keezApi = new keezApi_1.KeezApi({
+            application_id: '123',
+            client_eid: '123',
+            secret: '123',
+            user: '123',
+            live: true,
+        });
+    });
+    /* test('should generate a new token', async () => {
+        const result = await keezApi.createInvoice({
+            amount: 400,
+            currencyCode: 'RON',
+            itemId: '123',
+            partner: {
+                isLegalPerson: false,
+                partnerName: 'Marian Ion',
+                countryName: 'Romania',
+                countryCode: 'RO',
+                countyCode: 'RO.B',
+                countyName: 'Bucuresti',
+                addressDetails: 'Strada Testez nr. 4',
+                cityName: 'Timisoara',
+                identificationNumber: '1234',
+            },
+            paymentType: 10,
+            series: 'PDI',
+        });
+        console.log('result is');
+        console.log(result);
+        expect(result).toBeTruthy();
+    });
+
+    test('should generate a new token', async () => {
+        const result = await keezApi.validateInvoice('f28730f84ed04613a36583e8c2a755c3');
+        console.log('result is');
+        console.log(result);
+        expect(result).toBeTruthy();
+    });  */
+    test('should change the live mode', () => {
+        keezApi.setLive(false);
+        expect(keezApi.getBaseDomain())
+            .toBe('https://staging.keez.ro');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/authorise.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiGenerateToken = apiGenerateToken;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../helpers/logger");
+const KeezError_1 = require("../errors/KeezError");
+const constants_1 = require("../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'GenerateToken' });
+/**
+ * Generate a token for the Keez API
+ * @returns {AuthResponse} - The token response containing the access token and the expiry time
+ * @param params - As defined in the interface
+ */
+async function apiGenerateToken(params) {
+    const url = `${params.baseDomain}/idp/connect/token`;
+    const formData = new URLSearchParams({
+        client_id: `app${params.appId}`,
+        client_secret: params.apiSecret,
+        grant_type: 'client_credentials',
+        scope: 'public-api',
+    });
+    try {
+        const response = await axios_1.default.post(url, formData.toString(), {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        const responseObject = response.data;
+        return {
+            access_token: responseObject.access_token,
+            expires_in: responseObject.expires_in,
+            expires_at: new Date(Date.now() + constants_1.TOKEN_EXPIRY_BUFFER_MS).getTime(),
+            token_type: responseObject.token_type,
+            scope: responseObject.scope,
+        };
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while authenticating: ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezAuthError(`Authentication failed: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/invoices/cancel.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiCancelInvoice = apiCancelInvoice;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+async function apiCancelInvoice(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices/canceled`;
+    const body = {
+        externalId: params.invoiceId,
+    };
+    try {
+        await axios_1.default.post(url, body, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while canceling invoice (${params.invoiceId}): ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to cancel invoice: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/invoices/create.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiCreateInvoice = apiCreateInvoice;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const measureUnit_1 = require("../../config/measureUnit");
+const keezLogger = logger_1.logger.child({
+    _library: 'KeezWrapper',
+    _method: 'Invoices',
+});
+/**
+ * Helper to get current date in YYYYMMDD format
+ */
+function getCurrentDateNumber() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + constants_1.MONTH_INDEX_OFFSET).padStart(constants_1.DATE_PAD_LENGTH, '0');
+    const day = String(now.getDate()).padStart(constants_1.DATE_PAD_LENGTH, '0');
+    return parseInt(`${year}${month}${day}`, constants_1.DECIMAL_RADIX);
+}
+/**
+ * Create an invoice
+ * @param params as defined in the interface
+ * @returns {Promise<string>} - The external ID of the created invoice
+ */
+async function apiCreateInvoice(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices`;
+    const currentDate = getCurrentDateNumber();
+    const body = {
+        series: params.invoice.series,
+        documentDate: params.invoice.documentDate ?? currentDate,
+        dueDate: params.invoice.dueDate ?? currentDate,
+        vatOnCollection: params.invoice.vatOnCollection ?? false,
+        currencyCode: params.invoice.currencyCode,
+        originalNetAmount: params.invoice.amount,
+        originalNetAmountCurrency: params.invoice.amount,
+        originalVatAmount: constants_1.DEFAULT_VAT_AMOUNT,
+        originalVatAmountCurrency: constants_1.DEFAULT_VAT_AMOUNT,
+        netAmount: params.invoice.amount,
+        netAmountCurrency: params.invoice.amount,
+        vatAmount: constants_1.DEFAULT_VAT_AMOUNT,
+        vatAmountCurrency: constants_1.DEFAULT_VAT_AMOUNT,
+        grossAmount: params.invoice.amount,
+        grossAmountCurrency: params.invoice.amount,
+        paymentTypeId: params.invoice.paymentType,
+        partner: {
+            isLegalPerson: params.invoice.partner.isLegalPerson,
+            partnerName: params.invoice.partner.partnerName,
+            countryCode: params.invoice.partner.countryCode,
+            countryName: params.invoice.partner.countryName,
+            countyCode: params.invoice.partner.countyCode,
+            countyName: params.invoice.partner.countyName,
+            cityName: params.invoice.partner.cityName,
+            addressDetails: params.invoice.partner.addressDetails,
+        },
+        invoiceDetails: [
+            {
+                itemExternalId: params.invoice.itemId,
+                measureUnitId: params.invoice.measureUnitId ?? measureUnit_1.MeasureUnit.PIECE,
+                quantity: params.invoice.quantity ?? constants_1.DEFAULT_INVOICE_QUANTITY,
+                unitPrice: params.invoice.amount,
+                originalNetAmount: params.invoice.amount,
+                originalNetAmountCurrency: params.invoice.amount,
+                originalVatAmount: constants_1.DEFAULT_VAT_AMOUNT,
+                originalVatAmountCurrency: constants_1.DEFAULT_VAT_AMOUNT,
+                netAmount: params.invoice.amount,
+                netAmountCurrency: params.invoice.amount,
+                vatAmount: constants_1.DEFAULT_VAT_AMOUNT,
+                vatAmountCurrency: constants_1.DEFAULT_VAT_AMOUNT,
+                grossAmount: params.invoice.amount,
+                grossAmountCurrency: params.invoice.amount,
+            },
+        ],
+    };
+    try {
+        const response = await axios_1.default.post(url, body, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+        return response.data.externalId;
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data?.Message || axiosError.message;
+        keezLogger.error(`Error encountered while creating invoice: ${errorMessage}`);
+        throw new KeezError_1.KeezApiError(`Failed to create invoice: ${errorMessage}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../../src/api/invoices/create.ts"],"names":[],"mappings":"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","sourcesContent":["import axios, { AxiosError } from 'axios';\nimport { logger } from '@/helpers/logger';\nimport { InvoiceRequest } from '@/dto/createInvoiceRequest';\nimport { KeezApiError } from '@/errors/KeezError';\nimport {\n    HTTP_REQUEST_TIMEOUT_MS,\n    DATE_PAD_LENGTH,\n    MONTH_INDEX_OFFSET,\n    DECIMAL_RADIX,\n    DEFAULT_VAT_AMOUNT,\n    DEFAULT_INVOICE_QUANTITY,\n} from '@/config/constants';\nimport { MeasureUnit } from '@/config/measureUnit';\n\nconst keezLogger = logger.child({\n    _library: 'KeezWrapper',\n    _method: 'Invoices',\n});\n\n/**\n * baseDomain - The base domain for the API\n * appId - The application ID\n * appClientId - The application client ID\n * bearerToken - The bearer token obtained at the authentication stage\n * itemId - The item ID\n */\ninterface CreateInvoiceParams {\n    readonly baseDomain: string;\n    readonly appId: string;\n    readonly appClientId: string;\n    readonly bearerToken: string;\n    readonly invoice: InvoiceRequest;\n}\n\n/**\n * Helper to get current date in YYYYMMDD format\n */\nfunction getCurrentDateNumber(): number {\n    const now = new Date();\n    const year = now.getFullYear();\n    const month = String(now.getMonth() + MONTH_INDEX_OFFSET).padStart(DATE_PAD_LENGTH, '0');\n    const day = String(now.getDate()).padStart(DATE_PAD_LENGTH, '0');\n    return parseInt(`${year}${month}${day}`, DECIMAL_RADIX);\n}\n\n/**\n * Create an invoice\n * @param params as defined in the interface\n * @returns {Promise<string>} - The external ID of the created invoice\n */\nexport async function apiCreateInvoice(params: CreateInvoiceParams): Promise<string> {\n    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices`;\n    const currentDate = getCurrentDateNumber();\n\n    const body = {\n        series: params.invoice.series,\n        documentDate: params.invoice.documentDate ?? currentDate,\n        dueDate: params.invoice.dueDate ?? currentDate,\n        vatOnCollection: params.invoice.vatOnCollection ?? false,\n        currencyCode: params.invoice.currencyCode,\n        originalNetAmount: params.invoice.amount,\n        originalNetAmountCurrency: params.invoice.amount,\n        originalVatAmount: DEFAULT_VAT_AMOUNT,\n        originalVatAmountCurrency: DEFAULT_VAT_AMOUNT,\n        netAmount: params.invoice.amount,\n        netAmountCurrency: params.invoice.amount,\n        vatAmount: DEFAULT_VAT_AMOUNT,\n        vatAmountCurrency: DEFAULT_VAT_AMOUNT,\n        grossAmount: params.invoice.amount,\n        grossAmountCurrency: params.invoice.amount,\n        paymentTypeId: params.invoice.paymentType,\n        partner: {\n            isLegalPerson: params.invoice.partner.isLegalPerson,\n            partnerName: params.invoice.partner.partnerName,\n            countryCode: params.invoice.partner.countryCode,\n            countryName: params.invoice.partner.countryName,\n            countyCode: params.invoice.partner.countyCode,\n            countyName: params.invoice.partner.countyName,\n            cityName: params.invoice.partner.cityName,\n            addressDetails: params.invoice.partner.addressDetails,\n        },\n        invoiceDetails: [\n            {\n                itemExternalId: params.invoice.itemId,\n                measureUnitId: params.invoice.measureUnitId ?? MeasureUnit.PIECE,\n                quantity: params.invoice.quantity ?? DEFAULT_INVOICE_QUANTITY,\n                unitPrice: params.invoice.amount,\n                originalNetAmount: params.invoice.amount,\n                originalNetAmountCurrency: params.invoice.amount,\n                originalVatAmount: DEFAULT_VAT_AMOUNT,\n                originalVatAmountCurrency: DEFAULT_VAT_AMOUNT,\n                netAmount: params.invoice.amount,\n                netAmountCurrency: params.invoice.amount,\n                vatAmount: DEFAULT_VAT_AMOUNT,\n                vatAmountCurrency: DEFAULT_VAT_AMOUNT,\n                grossAmount: params.invoice.amount,\n                grossAmountCurrency: params.invoice.amount,\n            },\n        ],\n    };\n\n    try {\n        const response = await axios.post(url, body, {\n            headers: {\n                Authorization: `Bearer ${params.bearerToken}`,\n                'Content-Type': 'application/json',\n            },\n            timeout: HTTP_REQUEST_TIMEOUT_MS,\n        });\n\n        return response.data.externalId;\n    } catch (error) {\n        const axiosError = error as AxiosError<{ Message?: string }>;\n        const errorMessage = axiosError.response?.data?.Message || axiosError.message;\n        keezLogger.error(`Error encountered while creating invoice: ${errorMessage}`);\n        throw new KeezApiError(`Failed to create invoice: ${errorMessage}`, axiosError.response?.status, error);\n    }\n}\n"]}

package/dist/src/api/invoices/delete.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiDeleteInvoice = apiDeleteInvoice;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../helpers/logger");
+const KeezError_1 = require("../../errors/KeezError");
+const constants_1 = require("../../config/constants");
+const keezLogger = logger_1.logger.child({ _library: 'KeezWrapper', _method: 'Invoices' });
+async function apiDeleteInvoice(params) {
+    const url = `${params.baseDomain}/api/v1.0/public-api/${params.appClientId}/invoices`;
+    try {
+        await axios_1.default.delete(url, {
+            headers: {
+                Authorization: `Bearer ${params.bearerToken}`,
+                'Content-Type': 'application/json',
+            },
+            data: {
+                externalId: params.invoiceId,
+            },
+            timeout: constants_1.HTTP_REQUEST_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        const axiosError = error;
+        const errorMessage = axiosError.response?.data || axiosError.message;
+        keezLogger.error(`Error encountered while deleting invoice (${params.invoiceId}): ${JSON.stringify(errorMessage)}`);
+        throw new KeezError_1.KeezApiError(`Failed to delete invoice: ${JSON.stringify(errorMessage)}`, axiosError.response?.status, error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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