mindee 1.3.0 → 1.3.1

package/dist/inputs.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Input = void 0;
+// const fs = require("fs").promises;
+// const errorHandler = require("./errors/handler");
+// const path = require("path");
+// const { PDFDocument } = require("pdf-lib");
+// const concat = require("concat-stream");
+// const { Base64Encode } = require("base64-stream");
+// const fileType = require("file-type");
+// const ArrayBufferEncode = require("base64-arraybuffer");
+const promises_1 = __importDefault(require("fs/promises"));
+const path = __importStar(require("path"));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const concat = __importStar(require("concat-stream"));
+const base64_stream_1 = require("base64-stream");
+const fileType = __importStar(require("file-type"));
+const ArrayBufferEncode = __importStar(require("base64-arraybuffer"));
+const handler_1 = require("@errors/handler");
+const pdf_lib_1 = require("pdf-lib");
+class Input {
+    /**
+     * @param {(String | Buffer)} file - the file that will be read. Either path or base64 string, or a steam
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {String} filename - File name of the input
+     * @param allowCutPdf
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor(file, inputType, allowCutPdf = true, filename) {
+        this.file = file;
+        this.inputType = inputType;
+        this.allowCutPdf = allowCutPdf;
+        this.filename = filename;
+        this.MIMETYPES = {
+            png: "image/png",
+            jpg: "image/jpg",
+            jpeg: "image/jpeg",
+            webp: "image/webp",
+            pdf: "application/pdf",
+        };
+        this.ALLOWED_INPUT_TYPE = ["base64", "path", "stream", "dummy"];
+        this.CUT_PDF_SIZE = 5;
+        // Check if inputType is valid
+        if (!this.ALLOWED_INPUT_TYPE.includes(inputType)) {
+            handler_1.errorHandler.throw(new Error(`The input type is invalid. It should be \
+          ${this.ALLOWED_INPUT_TYPE.toString()}`));
+        }
+        this.file = file;
+        this.filename = filename;
+        this.inputType = inputType;
+        this.allowCutPdf = allowCutPdf;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.inputType === "base64")
+                yield this.initBase64();
+            else if (this.inputType === "path")
+                yield this.initFile();
+            else if (this.inputType === "stream")
+                yield this.initStream();
+            else
+                this.initDummy();
+        });
+    }
+    initBase64() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fileObject = this.file;
+            this.filepath = undefined;
+            if (this.filename === undefined) {
+                const mimeType = yield fileType.fromBuffer(Buffer.from(this.fileObject, "base64"));
+                if (mimeType !== undefined) {
+                    this.fileExtension = mimeType.mime;
+                    this.filename = `from_${this.inputType}.${mimeType.ext}`;
+                }
+                else {
+                    throw "Could not determine the MIME type. Please specify the 'filename' option.";
+                }
+            }
+            else {
+                const filetype = this.filename.split(".").pop();
+                this.fileExtension = this.MIMETYPES[filetype];
+            }
+            if (this.fileExtension === "application/pdf" && this.allowCutPdf == true) {
+                yield this.cutPdf();
+            }
+        });
+    }
+    initFile() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fileObject = yield promises_1.default.readFile(this.file);
+            this.filepath = this.file;
+            if (typeof this.file === "string") {
+                this.filename = this.filename || path.basename(this.file);
+            }
+            // Check if file type is valid
+            const filetype = (_a = this.filename) === null || _a === void 0 ? void 0 : _a.split(".").pop();
+            if (!filetype || !(filetype in this.MIMETYPES)) {
+                handler_1.errorHandler.throw(new Error(`File type is not allowed. It must be ${Object.keys(this.MIMETYPES).toString()}`));
+            }
+            this.fileExtension = filetype ? this.MIMETYPES[filetype] : "";
+            if (this.fileExtension === "application/pdf" && this.allowCutPdf) {
+                yield this.cutPdf();
+            }
+        });
+    }
+    initStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.file = (yield this.streamToBase64(this.file));
+            this.inputType = "base64";
+            yield this.initBase64();
+        });
+    }
+    initDummy() {
+        this.fileObject = "";
+        this.filename = "";
+        this.filepath = "";
+        this.fileExtension = "";
+    }
+    /**
+     * Convert ReadableStream to Base64 encoded String
+     *
+     * @param {*} stream ReadableStream to encode
+     * @returns Base64 encoded String
+     */
+    streamToBase64(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const base64 = new base64_stream_1.Base64Encode();
+                const cbConcat = (base64) => {
+                    resolve(base64);
+                };
+                stream
+                    .pipe(base64)
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore TO DO : FIX
+                    .pipe(concat(cbConcat))
+                    .on("error", (error) => {
+                    reject(error);
+                });
+            });
+        });
+    }
+    /** Cut PDF if pages > 5 */
+    cutPdf() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // convert document to PDFDocument & cut CUT_PDF_SIZE - 1 first pages and last page
+            const pdfDocument = yield pdf_lib_1.PDFDocument.load(this.fileObject, {
+                ignoreEncryption: true,
+            });
+            const splitedPdfDocument = yield pdf_lib_1.PDFDocument.create();
+            const pdfLength = pdfDocument.getPageCount();
+            if (pdfLength <= this.CUT_PDF_SIZE)
+                return;
+            const pagesNumbers = [
+                ...Array(this.CUT_PDF_SIZE - 1).keys(),
+                pdfLength - 1,
+            ];
+            const pages = yield splitedPdfDocument.copyPages(pdfDocument, pagesNumbers);
+            pages.forEach((page) => splitedPdfDocument.addPage(page));
+            const data = yield splitedPdfDocument.save();
+            if (this.inputType === "path") {
+                this.fileObject = Buffer.from(data);
+            }
+            else if (this.inputType === "base64") {
+                this.fileObject = ArrayBufferEncode.encode(data);
+            }
+        });
+    }
+}
+exports.Input = Input;

package/dist/logger.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const LOGGER_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+class Logger {
+    constructor(level = "debug") {
+        this.level = level;
+        if (!(level in LOGGER_LEVELS))
+            level = "debug";
+        this.level = LOGGER_LEVELS[level];
+    }
+    debug(...args) {
+        if (this.level <= LOGGER_LEVELS["debug"])
+            console.debug(args);
+    }
+    info(...args) {
+        if (this.level <= LOGGER_LEVELS["info"])
+            console.info(args);
+    }
+    warn(...args) {
+        if (this.level <= LOGGER_LEVELS["warn"])
+            console.warn(args);
+    }
+    error(...args) {
+        if (this.level <= LOGGER_LEVELS["error"])
+            console.error(args);
+    }
+}
+exports.logger = new Logger();

package/lib/index.js

@@ -1,39 +1,38 @@
 "use strict";
 
-var errorHandler = require("./errors/handler");
-
-var logger = require("./logger");
-
-var APIReceipt = require("./api/receipt");
-
-var APIInvoice = require("./api/invoice");
-
-var APIFinancialDocument = require("./api/financialDocument");
-
-class Client {
-  /**
-   * @param {string} receiptToken - Receipt Expense Token from Mindee dashboard
-   * @param {string} invoiceToken - Invoice Token from Mindee dashboard
-   * @param {boolean} throwOnError - Throw if an error is send from the API / SDK (true by default)
-   * @param {boolean} debug - Enable debug logging (disable by default)
-   */
-  constructor() {
-    var {
-      receiptToken = undefined,
-      invoiceToken = undefined,
-      throwOnError = true,
-      debug = undefined
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+exports.__esModule = true;
+exports.Client = void 0;
+
+var handler_1 = require("@errors/handler");
+
+var logger_1 = require("@mindee/logger");
+
+var receipt_1 = require("@mindee/api/receipt");
+
+var invoice_1 = require("@mindee/api/invoice");
+
+var financialDocument_1 = require("@mindee/api/financialDocument");
+
+var Client =
+/** @class */
+function () {
+  function Client(_a) {
+    var receiptToken = _a.receiptToken,
+        invoiceToken = _a.invoiceToken,
+        _b = _a.throwOnError,
+        throwOnError = _b === void 0 ? true : _b,
+        debug = _a.debug;
     this.receiptToken = receiptToken || process.env.MINDEE_RECEIPT_TOKEN;
     this.invoiceToken = invoiceToken || process.env.MINDEE_INVOICE_TOKEN;
-    errorHandler.throwOnError = throwOnError;
-    logger.level = (debug !== null && debug !== void 0 ? debug : process.env.MINDEE_DEBUG) ? "debug" : "warn";
-    this.receipt = new APIReceipt(this.receiptToken);
-    this.invoice = new APIInvoice(this.invoiceToken);
-    this.financialDocument = new APIFinancialDocument(this.invoiceToken, this.receiptToken);
+    handler_1.errorHandler.throwOnError = throwOnError;
+    logger_1.logger.level = (debug !== null && debug !== void 0 ? debug : process.env.MINDEE_DEBUG) ? "debug" : "warn";
+    this.receipt = new receipt_1.APIReceipt(this.receiptToken);
+    this.invoice = new invoice_1.APIInvoice(this.invoiceToken);
+    this.financialDocument = new financialDocument_1.APIFinancialDocument(this.invoiceToken, this.receiptToken);
   }
 
-}
+  return Client;
+}();
 
 exports.Client = Client;
 exports.documents = require("./documents");

package/mindee/api/request.js

@@ -50,7 +50,7 @@ const request = (url, method, headers, input, includeWords = false) => {
             data: JSON.parse(responseBody),
           });
         } catch (error) {
-          console.log(responseBody, error);
+          console.error(responseBody, error);
         }
       });
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindee",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Mindee Client Library for Node.js",
   "main": "mindee/index.js",
   "license": "MIT",