mindee 1.3.2 → 2.0.0

package/dist/src/inputs.js

@@ -0,0 +1,223 @@
+"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());
+    });
+};
+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}`);
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("not Implemented");
+        });
+    }
+    isPdf() {
+        return this.mimeType === "application/pdf";
+    }
+    checkMimetype() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let mimeType;
+            const fileExt = path.extname(this.filename);
+            if (fileExt) {
+                mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+            }
+            else {
+                const guess = yield 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;
+        });
+    }
+    countPages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pdfDocument = yield pdf_lib_1.PDFDocument.load(this.fileObject, {
+                ignoreEncryption: true,
+            });
+            return pdfDocument.getPageCount();
+        });
+    }
+    /** Merge PDF pages */
+    cutPdf() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentPdf = yield pdf_lib_1.PDFDocument.load(this.fileObject, {
+                ignoreEncryption: true,
+            });
+            const pdfLength = currentPdf.getPageCount();
+            if (pdfLength <= this.MAX_DOC_PAGES) {
+                return;
+            }
+            const newPdf = yield 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 = yield newPdf.copyPages(currentPdf, pagesNumbers);
+            pages.forEach((page) => newPdf.addPage(page));
+            const data = yield 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);
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.logger.debug(`Loading from: ${this.inputPath}`);
+            this.fileObject = node_buffer_1.Buffer.from(yield fs_1.promises.readFile(this.inputPath));
+            this.mimeType = yield this.checkMimetype();
+        });
+    }
+}
+exports.PathInput = PathInput;
+class Base64Input extends Input {
+    constructor({ inputString, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_BASE64,
+        });
+        this.filename = filename;
+        this.inputString = inputString;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
+            this.mimeType = yield 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;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fileObject = yield this.stream2buffer(this.inputStream);
+            this.mimeType = yield this.checkMimetype();
+        });
+    }
+    stream2buffer(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
+            this.mimeType = yield this.checkMimetype();
+            // clear out the string
+            this.inputBytes = "";
+        });
+    }
+}
+exports.BytesInput = BytesInput;

package/dist/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/dist/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/package.json

@@ -1,51 +1,70 @@
 {
   "name": "mindee",
-  "version": "1.3.2",
+  "version": "2.0.0",
   "description": "Mindee Client Library for Node.js",
-  "main": "mindee/index.js",
+  "main": "src/index.js",
   "license": "MIT",
   "scripts": {
-    "build": "babel mindee -d lib",
-    "test": "npm run build && mocha tests/**/*.js",
-    "lint": "eslint 'mindee/**/*.js' 'tests/*.js' --max-warnings=0 --report-unused-disable-directives && echo '✔  Your .js files look good.'",
-    "documentation": "jsdoc -r mindee -d docs"
+    "build": "tsc --build",
+    "clean": "rm -rf ./dist",
+    "test": "mocha 'tests/**/*.spec.ts'",
+    "lint-fix": "eslint 'src/**/*.ts' --fix",
+    "lint": "eslint 'src/**/*.ts' --report-unused-disable-directives && echo 'Your .ts files look good.'",
+    "docs": "jsdoc -r src -d docs"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">= 14.0.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mindee/mindee-api-nodejs.git"
   },
-  "author": "@techmindee",
+  "author": {
+    "name": "Mindee",
+    "email": "devrel@mindee.com",
+    "url": "https://mindee.com/"
+  },
   "bugs": {
     "url": "https://github.com/mindee/mindee-api-nodejs/issues"
   },
-  "homepage": "https://github.com/mindee/mindee-api-nodejs/#readme",
+  "homepage": "https://mindee.com/",
   "devDependencies": {
-    "@babel/cli": "^7.12.8",
-    "@babel/core": "^7.12.9",
-    "@babel/eslint-parser": "^7.12.1",
-    "@babel/preset-env": "^7.12.7",
-    "@babel/register": "^7.12.1",
-    "chai": "^4.2.0",
-    "eslint": "^7.14.0",
-    "eslint-config-prettier": "^6.15.0",
-    "eslint-plugin-prettier": "^3.1.4",
-    "jsdoc": "^3.6.6",
-    "mocha": "^8.2.1",
-    "prettier": "^2.2.0"
+    "@tsconfig/node16": "^1.0.3",
+    "@types/chai": "^4.3.1",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^17.0.38",
+    "@typescript-eslint/eslint-plugin": "^5.30.0",
+    "@typescript-eslint/parser": "^5.30.0",
+    "chai": "^4.3.6",
+    "eslint": "^8.18.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.1.0",
+    "jsdoc": "^3.6.10",
+    "mocha": "^10.0.0",
+    "prettier": "^2.7.1",
+    "ts-node": "^10.8.1",
+    "typescript": "^4.7.4"
   },
   "dependencies": {
-    "base64-arraybuffer": "^1.0.2",
-    "base64-stream": "^1.0.0",
-    "concat-stream": "^2.0.0",
-    "file-type": "^16.5.3",
+    "commander": "^9.4.0",
+    "file-type": "^16.5.4",
     "form-data": "^3.0.1",
+    "mrz": "^3.1.4",
     "pdf-lib": "^1.17.1"
   },
   "keywords": [
-    "javascript",
+    "typescript",
     "mindee",
     "api",
-    "SDK",
+    "client",
+    "client library",
     "nodejs"
   ]
 }

package/.eslintrc

@@ -1,24 +0,0 @@
-{
-    "env": {
-        "node": true,
-        "es6": true,
-        "mocha": true
-    },
-    "parser": "@babel/eslint-parser",
-    "extends": ["eslint:recommended", "plugin:prettier/recommended"],
-    "globals": {
-        "Promise": true
-    },
-    "rules": {
-        "quotes": [
-            "error",
-            "double",
-            {
-                "avoidEscape": true,
-                "allowTemplateLiterals": false
-            }
-        ],
-        "comma-dangle": [2, "always-multiline"],
-        "no-unused-vars": ["error", { "argsIgnorePattern": "^_" }]
-    }
-}

package/.mocharc.yaml

@@ -1,2 +0,0 @@
-require:
-  - '@babel/register'