mindee 1.0.4 → 1.0.9

package/mindee/index.js

@@ -0,0 +1,36 @@
+const errorHandler = require("./errors/handler");
+const logger = require("./logger");
+const APIReceipt = require("./api/receipt");
+const APIInvoice = require("./api/invoice");
+const 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({
+    receiptToken = undefined,
+    invoiceToken = undefined,
+    throwOnError = true,
+    debug = undefined,
+  } = {}) {
+    this.receiptToken = receiptToken || process.env.MINDEE_RECEIPT_TOKEN;
+    this.invoiceToken = invoiceToken || process.env.MINDEE_INVOICE_TOKEN;
+    errorHandler.throwOnError = throwOnError;
+    logger.level = 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
+    );
+  }
+}
+
+exports.Client = Client;
+exports.documents = require("./documents");
+exports.api = require("./api");
+exports.inputs = require("./inputs");

package/mindee/inputs.js

@@ -0,0 +1,155 @@
+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");
+
+class Input {
+  MIMETYPES = {
+    png: "image/png",
+    jpg: "image/jpg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    pdf: "application/pdf",
+  };
+  ALLOWED_INPUT_TYPE = ["base64", "path", "stream", "dummy"];
+  CUT_PDF_SIZE = 5;
+
+  /**
+   * @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 {Boolean} cut_pdf: Automatically reconstruct pdf with more than 4 pages
+   * NB: Because of async calls, init() should be called after creating the object
+   */
+  constructor({ file, filename = undefined, inputType, allowCutPdf = true }) {
+    // Check if inputType is valid
+    if (!this.ALLOWED_INPUT_TYPE.includes(inputType)) {
+      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;
+  }
+
+  async init() {
+    if (this.inputType === "base64") await this.initBase64();
+    else if (this.inputType === "path") await this.initFile();
+    else if (this.inputType === "stream") await this.initStream();
+    else this.initDummy();
+  }
+
+  async initBase64() {
+    this.fileObject = this.file;
+    this.filepath = undefined;
+    this.fileExtension = undefined;
+
+    if (this.allowCutPdf == true) {
+      const typeOfFile = await fileType.fromBuffer(
+        Buffer.from(this.fileObject, "base64")
+      );
+
+      if (typeOfFile === undefined) {
+        console.error(`Cannot detect mime type of: ${this.fileObject}`);
+      } else if (typeOfFile.mime === "application/pdf") {
+        await this.cutPdf();
+      }
+    }
+  }
+
+  async initFile() {
+    this.fileObject = await fs.readFile(this.file);
+    this.filepath = this.file;
+    this.filename = this.filename || path.basename(this.file);
+
+    // Check if file type is valid
+    const filetype = this.filename.split(".").pop();
+    if (!(filetype in this.MIMETYPES)) {
+      errorHandler.throw(
+        new Error(
+          `File type is not allowed. It must be ${Object.keys(
+            this.MIMETYPES
+          ).toString()}`
+        )
+      );
+    }
+    this.fileExtension = this.MIMETYPES[filetype];
+
+    if (this.fileExtension === "application/pdf" && this.allowCutPdf == true) {
+      await this.cutPdf();
+    }
+  }
+
+  async initStream() {
+    const file = await this.streamToBase64(this.file);
+
+    this.file = file;
+    this.inputType = "base64";
+    await 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
+   */
+  async streamToBase64(stream) {
+    return new Promise((resolve, reject) => {
+      const base64 = new Base64Encode();
+
+      const cbConcat = (base64) => {
+        resolve(base64);
+      };
+
+      stream
+        .pipe(base64)
+        .pipe(concat(cbConcat))
+        .on("error", (error) => {
+          reject(error);
+        });
+    });
+  }
+
+  /** Cut PDF if pages > 5 */
+  async cutPdf() {
+    // convert document to PDFDocument & cut CUT_PDF_SIZE - 1 first pages and last page
+    let pdfDocument = await PDFDocument.load(this.fileObject, {
+      ignoreEncryption: true,
+    });
+    const splitedPdfDocument = await 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 = await splitedPdfDocument.copyPages(pdfDocument, pagesNumbers);
+    pages.forEach((page) => splitedPdfDocument.addPage(page));
+    const data = await splitedPdfDocument.save();
+    if (this.inputType === "path") {
+      this.fileObject = Buffer.from(data);
+    } else if (this.inputType === "base64") {
+      this.fileObject = ArrayBufferEncode.encode(data);
+    }
+  }
+}
+
+module.exports = Input;

package/mindee/logger.js

@@ -0,0 +1,33 @@
+const LOGGER_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+class Logger {
+  constructor(level = "debug") {
+    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);
+  }
+}
+
+const logger = new Logger();
+
+module.exports = logger;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "mindee",
-  "version": "1.0.4",
+  "version": "1.0.9",
   "description": "Mindee API SDK for Node.js",
-  "main": "lib/index.js",
+  "main": "mindee/index.js",
   "license": "GPL-3.0",
   "scripts": {
     "build": "babel mindee -d lib",
@@ -34,6 +34,10 @@
     "prettier": "^2.2.0"
   },
   "dependencies": {
+    "base64-arraybuffer": "^1.0.1",
+    "base64-stream": "^1.0.0",
+    "concat-stream": "^2.0.0",
+    "file-type": "^16.5.3",
     "form-data": "^3.0.0",
     "pdf-lib": "^1.13.0"
   },