mindee 1.4.0 → 2.0.1

package/src/inputs.js

@@ -0,0 +1,196 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytesInput = exports.StreamInput = exports.Base64Input = exports.PathInput = exports.Input = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const fileType = __importStar(require("file-type"));
+const handler_1 = require("./errors/handler");
+const pdf_lib_1 = require("pdf-lib");
+const node_buffer_1 = require("node:buffer");
+const logger_1 = require("./logger");
+exports.INPUT_TYPE_STREAM = "stream";
+exports.INPUT_TYPE_BASE64 = "base64";
+exports.INPUT_TYPE_BYTES = "bytes";
+exports.INPUT_TYPE_PATH = "path";
+const MIMETYPES = new Map([
+    [".pdf", "application/pdf"],
+    [".heic", "image/heic"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".png", "image/png"],
+    [".tif", "image/tiff"],
+    [".tiff", "image/tiff"],
+    [".webp", "image/webp"],
+]);
+const ALLOWED_INPUT_TYPES = [
+    exports.INPUT_TYPE_STREAM,
+    exports.INPUT_TYPE_BASE64,
+    exports.INPUT_TYPE_BYTES,
+    exports.INPUT_TYPE_PATH,
+];
+class Input {
+    /**
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {Boolean} cutPages
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor({ inputType }) {
+        this.MAX_DOC_PAGES = 3;
+        this.filename = "";
+        this.mimeType = "";
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        // Check if inputType is valid
+        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            handler_1.errorHandler.throw(new Error(`Invalid input type, must be one of ${allowed}.`));
+        }
+        this.inputType = inputType;
+        logger_1.logger.debug(`Loading file from: ${inputType}`);
+    }
+    async init() {
+        throw new Error("not Implemented");
+    }
+    isPdf() {
+        return this.mimeType === "application/pdf";
+    }
+    async checkMimetype() {
+        let mimeType;
+        const fileExt = path.extname(this.filename);
+        if (fileExt) {
+            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+        }
+        else {
+            const guess = await fileType.fromBuffer(this.fileObject);
+            if (guess !== undefined) {
+                mimeType = guess.mime;
+            }
+            else {
+                throw "Could not determine the MIME type of the file";
+            }
+        }
+        if (!mimeType) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            const err = new Error(`Invalid file type, must be one of ${allowed}.`);
+            handler_1.errorHandler.throw(err);
+        }
+        logger_1.logger.debug(`File is of type: ${mimeType}`);
+        return mimeType;
+    }
+    async countPages() {
+        const pdfDocument = await pdf_lib_1.PDFDocument.load(this.fileObject, {
+            ignoreEncryption: true,
+        });
+        return pdfDocument.getPageCount();
+    }
+    /** Merge PDF pages */
+    async cutPdf() {
+        const currentPdf = await pdf_lib_1.PDFDocument.load(this.fileObject, {
+            ignoreEncryption: true,
+        });
+        const pdfLength = currentPdf.getPageCount();
+        if (pdfLength <= this.MAX_DOC_PAGES) {
+            return;
+        }
+        const newPdf = await pdf_lib_1.PDFDocument.create();
+        const pagesNumbers = [0, pdfLength - 2, pdfLength - 1].slice(0, this.MAX_DOC_PAGES);
+        logger_1.logger.debug(`Cutting PDF, keeping pages: ${pagesNumbers}`);
+        const pages = await newPdf.copyPages(currentPdf, pagesNumbers);
+        pages.forEach((page) => newPdf.addPage(page));
+        const data = await newPdf.save();
+        this.fileObject = node_buffer_1.Buffer.from(data);
+    }
+}
+exports.Input = Input;
+class PathInput extends Input {
+    constructor({ inputPath }) {
+        super({
+            inputType: exports.INPUT_TYPE_PATH,
+        });
+        this.inputPath = inputPath;
+        this.filename = path.basename(this.inputPath);
+    }
+    async init() {
+        logger_1.logger.debug(`Loading from: ${this.inputPath}`);
+        this.fileObject = node_buffer_1.Buffer.from(await fs_1.promises.readFile(this.inputPath));
+        this.mimeType = await this.checkMimetype();
+    }
+}
+exports.PathInput = PathInput;
+class Base64Input extends Input {
+    constructor({ inputString, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_BASE64,
+        });
+        this.filename = filename;
+        this.inputString = inputString;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputString = "";
+    }
+}
+exports.Base64Input = Base64Input;
+class StreamInput extends Input {
+    constructor({ inputStream, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_STREAM,
+        });
+        this.filename = filename;
+        this.inputStream = inputStream;
+    }
+    async init() {
+        this.fileObject = await this.stream2buffer(this.inputStream);
+        this.mimeType = await this.checkMimetype();
+    }
+    async stream2buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const _buf = Array();
+            stream.on("data", (chunk) => _buf.push(chunk));
+            stream.on("end", () => resolve(node_buffer_1.Buffer.concat(_buf)));
+            stream.on("error", (err) => reject(`Error converting stream - ${err}`));
+        });
+    }
+}
+exports.StreamInput = StreamInput;
+class BytesInput extends Input {
+    constructor({ inputBytes, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_BYTES,
+        });
+        this.filename = filename;
+        this.inputBytes = inputBytes;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputBytes = "";
+    }
+}
+exports.BytesInput = BytesInput;

package/src/logger.d.ts

@@ -0,0 +1,20 @@
+interface LoggerLevels {
+    [index: string]: number;
+}
+interface LoggerInterface {
+    debug(level: any[]): void;
+    info(level: any[]): void;
+    warn(level: any[]): void;
+    error(level: any[]): void;
+}
+export declare const LOG_LEVELS: LoggerLevels;
+declare class Logger implements LoggerInterface {
+    level: string | number;
+    constructor(level?: string | number);
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+export declare const logger: Logger;
+export {};

package/src/logger.js

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

package/mindee/api/financialDocument.js

@@ -1,47 +0,0 @@
-const APIObject = require("./object");
-const Input = require("../inputs");
-
-class APIFinancialDocument extends APIObject {
-  constructor(invoiceToken, receiptToken) {
-    super(undefined, "financialDocument");
-    this.invoiceToken = invoiceToken;
-    this.receiptToken = receiptToken;
-  }
-
-  /**
-   * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
-   * @param {String} inputType: String in {'path', 'stream', 'base64'}
-   * @param {Boolean} includeWords: extract all words into http_response
-   * @param {String} version: expense_receipt api version
-   * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
-   * @returns {Response} Wrapped response with Receipts objects parsed
-   */
-  async parse({
-    input,
-    inputType = "path",
-    filename = undefined,
-    version = "3",
-    cutPdf = true,
-    includeWords = false,
-  }) {
-    const inputFile = new Input({
-      file: input,
-      inputType: inputType,
-      filename: filename,
-      allowCutPdf: cutPdf,
-    });
-    await inputFile.init();
-    this.apiToken =
-      inputFile.fileExtension === "application/pdf"
-        ? this.invoiceToken
-        : this.receiptToken;
-    const url =
-      inputFile.fileExtension === "application/pdf"
-        ? `/invoices/v${version}/predict`
-        : `/expense_receipts/v${version}/predict`;
-    super.parse();
-    return super._request(url, inputFile, includeWords);
-  }
-}
-
-module.exports = APIFinancialDocument;

package/mindee/api/index.js

@@ -1,5 +0,0 @@
-exports.APIObject = require("./object");
-exports.APIReceipt = require("./receipt");
-exports.Response = require("./response");
-exports.Request = require("./response");
-exports.Invoice = require("./invoice");

package/mindee/api/invoice.js

@@ -1,53 +0,0 @@
-const APIObject = require("./object");
-const Input = require("../inputs");
-
-class APIInvoice extends APIObject {
-  constructor(apiToken = undefined) {
-    super(apiToken, "invoice");
-    this.baseUrl = `${this.baseUrl}/invoices/`;
-  }
-
-  /**
-   * @param {Boolean} includeWords: , extract all words into http_response
-   * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
-   * @param {String} inputType: String in {'path', 'stream', 'base64'}
-   * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
-   * @param {String} version: expense_receipt api version
-   * @returns {Response} Wrapped response with Receipts objects parsed
-   */
-  async parse({
-    input,
-    inputType = "path",
-    filename = undefined,
-    version = "3",
-    cutPdf = true,
-    includeWords = false,
-  }) {
-    super.parse();
-    const inputFile = new Input({
-      file: input,
-      inputType: inputType,
-      filename: filename,
-      allowCutPdf: cutPdf,
-    });
-    await inputFile.init();
-    const url = `v${version}/predict`;
-    return await super._request(url, inputFile, includeWords);
-  }
-
-  /** 
-    @param {String} inputFile - Input object
-    @param {} response - HTTP response
-    @param {Document} documentType - Document class in {"Receipt", "Invoice", "Financial_document"}
-    @returns {Response}
-  */
-  wrapResponse(inputFile, response, documentType) {
-    let result = super.wrapResponse(inputFile, response, documentType);
-    result.documentType =
-      result.httpResponse.data?.predictions?.[0]?.document_type?.value?.toLowerCase() ||
-      result.documentType;
-    return result;
-  }
-}
-
-module.exports = APIInvoice;

package/mindee/api/object.js

@@ -1,82 +0,0 @@
-const Response = require("./response");
-const errorHandler = require("../errors/handler");
-const request = require("./request");
-
-/**
- * Base class for APIs (APIReceipt & APIInvoice)
- *  @param {String} apiToken - Token of the API used for parsing document
- *  @param {String} apiName - Name of the API used for parsing document
- */
-class APIObject {
-  constructor(apiToken = undefined, apiName = "") {
-    this.apiToken = apiToken;
-    this.baseUrl = "https://api.mindee.net/v1/products/mindee";
-    this.apiName = apiName;
-  }
-
-  /**
-   */
-  parse() {
-    if (!this.apiToken) {
-      errorHandler.throw({
-        error: new Error(
-          `Missing API token for ${this.apiName}. \
-          Have you create a mindee Client with a ${this.apiName}Token in parameters ?`
-        ),
-      });
-    }
-  }
-
-  /** 
-    @param {String} url - API url for request
-    @param {Input} inputFile - input file for API
-    @param {Boolean} includeWords - Include Mindee vision words in Response
-    @returns {Response}
-  */
-  async _request(url, inputFile, includeWords = false) {
-    const headers = {
-      "X-Inferuser-Token": this.apiToken,
-    };
-    const response = await request(
-      `${this.baseUrl}${url}`,
-      "POST",
-      headers,
-      inputFile,
-      includeWords
-    );
-    return this.wrapResponse(inputFile, response, this.apiName);
-  }
-
-  /** 
-    @param {String} inputFile - Input object
-    @param {} response - HTTP response
-    @param {Document} documentType - Document class in {"Receipt", "Invoice", "Financial_document"}
-    @returns {Response}
-  */
-  wrapResponse(inputFile, response, documentType) {
-    if (response.statusCode > 201) {
-      const errorMessage = JSON.stringify(response.data, null, 4);
-      errorHandler.throw(
-        new Error(
-          `${this.apiName} API ${response.statusCode} HTTP error: ${errorMessage}`
-        ),
-        false
-      );
-      return new Response({
-        httpResponse: response,
-        documentType: documentType,
-        document: undefined,
-        input: inputFile,
-        error: true,
-      });
-    }
-    return new Response({
-      httpResponse: response,
-      documentType: documentType,
-      document: inputFile,
-      input: inputFile,
-    });
-  }
-}
-
-module.exports = APIObject;

package/mindee/api/receipt.js

@@ -1,39 +0,0 @@
-const APIObject = require("./object");
-const Input = require("../inputs");
-
-class APIReceipt extends APIObject {
-  constructor(apiToken = undefined) {
-    super(apiToken, "receipt");
-    this.baseUrl = `${this.baseUrl}/expense_receipts/`;
-  }
-
-  /**
-   * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
-   * @param {String} inputType: String in {'path', 'stream', 'base64'}
-   * @param {Boolean} includeWords: extract all words into http_response
-   * @param {String} version: expense_receipt api version
-   * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
-   * @returns {Response} Wrapped response with Receipts objects parsed
-   */
-  async parse({
-    input,
-    inputType = "path",
-    filename = undefined,
-    version = "3",
-    cutPdf = true,
-    includeWords = false,
-  }) {
-    super.parse();
-    const inputFile = new Input({
-      file: input,
-      inputType: inputType,
-      filename: filename,
-      allowCutPdf: cutPdf,
-    });
-    await inputFile.init();
-    const url = `v${version}/predict`;
-    return await super._request(url, inputFile, includeWords);
-  }
-}
-
-module.exports = APIReceipt;

package/mindee/api/request.js

@@ -1,72 +0,0 @@
-const https = require("https");
-const { version: sdkVersion } = require("../../package.json");
-const { URL } = require("url");
-const FormData = require("form-data");
-const os = require("os");
-
-const request = (url, method, headers, input, includeWords = false) => {
-  return new Promise(function (resolve, reject) {
-    let form = new FormData();
-
-    headers["User-Agent"] = `mindee-api-nodejs@v${sdkVersion} nodejs-${
-      process.version
-    } ${os.type().toLowerCase()}`;
-
-    const fileParams = { filename: input.filename };
-
-    if (input.inputType === "base64") {
-      form.append(
-        "document",
-        Buffer.from(input.fileObject, "base64"),
-        fileParams
-      );
-    } else {
-      form.append("document", input.fileObject, fileParams);
-    }
-    if (includeWords) {
-      form.append("include_mvision", "true");
-    }
-    headers = { ...headers, ...form.getHeaders() };
-
-    const uri = new URL(url);
-    const options = {
-      method: method,
-      headers: headers,
-      hostname: uri.hostname,
-      path: `${uri.pathname}${uri.search}`,
-    };
-
-    const req = https.request(options, function (res) {
-      let responseBody = [];
-
-      res.on("data", function (chunk) {
-        responseBody += chunk;
-      });
-
-      res.on("end", function () {
-        try {
-          resolve({
-            ...res,
-            data: JSON.parse(responseBody),
-          });
-        } catch (error) {
-          reject(error);
-        }
-      });
-    });
-
-    req.on("error", (err) => {
-      reject(err);
-    });
-
-    if (["path", "stream"].includes(input.inputType)) {
-      form.pipe(req);
-    }
-
-    if (input.inputType === "base64") {
-      form.pipe(req);
-    }
-  });
-};
-
-module.exports = request;

package/mindee/api/response.js

@@ -1,80 +0,0 @@
-const Receipt = require("../documents").receipt;
-const Invoice = require("../documents").invoice;
-const FinancialDocument = require("../documents").financialDocument;
-const fs = require("fs").promises;
-
-class Response {
-  constructor({
-    httpResponse,
-    documentType,
-    input,
-    error,
-    reconsctruted = false,
-    ...args
-  }) {
-    this.httpResponse = httpResponse;
-    this.documentType = documentType;
-    this.input = input;
-    if (!error && !reconsctruted) this.formatResponse();
-    if (reconsctruted === true) {
-      Object.assign(this, args);
-    }
-  }
-
-  async dump(path) {
-    return await fs.writeFile(path, JSON.stringify(Object.entries(this)));
-  }
-
-  static async load(path) {
-    const file = fs.readFile(path);
-    const args = JSON.parse(file);
-    return new Response({ reconsctruted: true, ...args });
-  }
-
-  formatResponse() {
-    let http_data_document = this.httpResponse.data.document;
-    const constructors = {
-      receipt: (params) => new Receipt(params),
-      invoice: (params) => new Invoice(params),
-      financialDocument: (params) => new FinancialDocument(params),
-    };
-
-    const predictions = http_data_document.inference.pages.entries();
-    this[`${this.documentType}s`] = [];
-    let document_words_content = [];
-
-    // Create a list of Document (Receipt, Invoice...) for each page of the input document
-    for (const [pageNumber, prediction] of predictions) {
-      let page_words_content = [];
-      if (
-        "ocr" in http_data_document &&
-        Object.keys(http_data_document.ocr).length > 0
-      ) {
-        page_words_content =
-          http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words;
-        document_words_content.push(
-          ...http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words
-        );
-      }
-      this[`${this.documentType}s`].push(
-        constructors[this.documentType]({
-          apiPrediction: prediction.prediction,
-          inputFile: this.input,
-          pageNumber: pageNumber,
-          words: page_words_content,
-        })
-      );
-    }
-
-    // Merge the list of Document into a unique Document
-    this[this.documentType] = constructors[this.documentType]({
-      apiPrediction: http_data_document.inference.prediction,
-      inputFile: this.input,
-      pageNumber: http_data_document.n_pages,
-      level: "document",
-      words: document_words_content,
-    });
-  }
-}
-
-module.exports = Response;