mindee 4.28.0 → 4.29.0-rc1

package/src/clientV2.js

@@ -0,0 +1,155 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ClientV2_instances, _ClientV2_setAsyncParams;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientV2 = void 0;
+const handler_1 = require("./errors/handler");
+const logger_1 = require("./logger");
+const promises_1 = require("node:timers/promises");
+const mindeeApiV2_1 = require("./http/mindeeApiV2");
+const baseClient_1 = require("./baseClient");
+const mindeeError_1 = require("./errors/mindeeError");
+/**
+ * Mindee Client V2 class that centralizes most basic operations.
+ *
+ * @category ClientV2
+ */
+class ClientV2 extends baseClient_1.BaseClient {
+    /**
+     * @param {ClientOptions} options options for the initialization of a client.
+     */
+    constructor({ apiKey, throwOnError, debug } = {
+        apiKey: "",
+        throwOnError: true,
+        debug: false,
+    }) {
+        super();
+        _ClientV2_instances.add(this);
+        this.mindeeApi = new mindeeApiV2_1.MindeeApiV2(apiKey);
+        handler_1.errorHandler.throwOnError = throwOnError ?? true;
+        logger_1.logger.level =
+            debug ?? process.env.MINDEE_DEBUG
+                ? logger_1.LOG_LEVELS["debug"]
+                : logger_1.LOG_LEVELS["warn"];
+        logger_1.logger.debug("ClientV2 initialized");
+    }
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @param inputSource file to parse.
+     * @param params parameters relating to prediction options.
+     * @category Asynchronous
+     * @returns a `Promise` containing the job (queue) corresponding to a document.
+     */
+    async enqueueInference(inputSource, params) {
+        if (inputSource === undefined) {
+            throw new Error("The 'enqueue' function requires an input document.");
+        }
+        return await this.mindeeApi.reqPostInferenceEnqueue(inputSource, params);
+    }
+    /**
+     * Retrieves an inference.
+     *
+     * @param inferenceId id of the queue to poll.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
+     * parsing is complete.
+     */
+    async getInference(inferenceId) {
+        return await this.mindeeApi.reqGetInference(inferenceId);
+    }
+    /**
+     * Get the status of an inference that was previously enqueued.
+     * Can be used for polling.
+     *
+     * @param jobId id of the queue to poll.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
+     * parsing is complete.
+     */
+    async getJob(jobId) {
+        return await this.mindeeApi.reqGetJob(jobId);
+    }
+    /**
+     * Send a document to an endpoint and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     *
+     * @param inputDoc document to parse.
+     * @param params parameters relating to prediction options.
+     *
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    async enqueueAndGetInference(inputDoc, params) {
+        const validatedAsyncParams = __classPrivateFieldGet(this, _ClientV2_instances, "m", _ClientV2_setAsyncParams).call(this, params.pollingOptions);
+        const enqueueResponse = await this.enqueueInference(inputDoc, params);
+        if (enqueueResponse.job.id === undefined || enqueueResponse.job.id.length === 0) {
+            logger_1.logger.error(`Failed enqueueing:\n${enqueueResponse.getRawHttp()}`);
+            throw Error("Enqueueing of the document failed.");
+        }
+        const queueId = enqueueResponse.job.id;
+        logger_1.logger.debug(`Successfully enqueued document with job id: ${queueId}.`);
+        await (0, promises_1.setTimeout)(validatedAsyncParams.initialDelaySec * 1000, undefined, validatedAsyncParams.initialTimerOptions);
+        let retryCounter = 1;
+        let pollResults = await this.getJob(queueId);
+        while (retryCounter < validatedAsyncParams.maxRetries) {
+            if (pollResults.job.status === "Failed") {
+                break;
+            }
+            if (pollResults.job.status === "Processed") {
+                return this.getInference(pollResults.job.id);
+            }
+            logger_1.logger.debug(`Polling server for parsing result with queueId: ${queueId}.
+Attempt n°${retryCounter}/${validatedAsyncParams.maxRetries}.
+Job status: ${pollResults.job.status}.`);
+            await (0, promises_1.setTimeout)(validatedAsyncParams.delaySec * 1000, undefined, validatedAsyncParams.recurringTimerOptions);
+            pollResults = await this.getJob(queueId);
+            retryCounter++;
+        }
+        const error = pollResults.job.error;
+        if (error) {
+            throw new mindeeError_1.MindeeHttpErrorV2(error.status, error.detail);
+        }
+        throw Error("Asynchronous parsing request timed out after " +
+            validatedAsyncParams.delaySec * retryCounter +
+            " seconds");
+    }
+}
+exports.ClientV2 = ClientV2;
+_ClientV2_instances = new WeakSet(), _ClientV2_setAsyncParams = function _ClientV2_setAsyncParams(asyncParams = undefined) {
+    const minDelaySec = 1;
+    const minInitialDelay = 1;
+    const minRetries = 2;
+    let newAsyncParams;
+    if (asyncParams === undefined) {
+        newAsyncParams = {
+            delaySec: 1.5,
+            initialDelaySec: 2,
+            maxRetries: 80
+        };
+    }
+    else {
+        newAsyncParams = { ...asyncParams };
+        if (!newAsyncParams.delaySec ||
+            !newAsyncParams.initialDelaySec ||
+            !newAsyncParams.maxRetries) {
+            throw Error("Invalid polling options.");
+        }
+        if (newAsyncParams.delaySec < minDelaySec) {
+            throw Error(`Cannot set auto-parsing delay to less than ${minDelaySec} second(s).`);
+        }
+        if (newAsyncParams.initialDelaySec < minInitialDelay) {
+            throw Error(`Cannot set initial parsing delay to less than ${minInitialDelay} second(s).`);
+        }
+        if (newAsyncParams.maxRetries < minRetries) {
+            throw Error(`Cannot set retry to less than ${minRetries}.`);
+        }
+    }
+    return newAsyncParams;
+};

package/src/errors/mindeeError.d.ts

@@ -16,3 +16,11 @@ export declare class MindeeImageError extends MindeeError {
 export declare class MindeePdfError extends MindeeError {
     constructor(message: string);
 }
+export declare class MindeeApiV2Error extends MindeeError {
+    constructor(message: string);
+}
+export declare class MindeeHttpErrorV2 extends MindeeError {
+    status: number;
+    detail: string;
+    constructor(status: number, detail: string);
+}

package/src/errors/mindeeError.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MindeePdfError = exports.MindeeImageError = exports.MindeeMimeTypeError = exports.MindeeError = void 0;
+exports.MindeeHttpErrorV2 = exports.MindeeApiV2Error = exports.MindeePdfError = exports.MindeeImageError = exports.MindeeMimeTypeError = exports.MindeeError = void 0;
 /**
  * Main Mindee Error custom class.
  */
@@ -35,3 +35,19 @@ class MindeePdfError extends MindeeError {
     }
 }
 exports.MindeePdfError = MindeePdfError;
+class MindeeApiV2Error extends MindeeError {
+    constructor(message) {
+        super(message);
+        this.name = "MindeeApiV2Error";
+    }
+}
+exports.MindeeApiV2Error = MindeeApiV2Error;
+class MindeeHttpErrorV2 extends MindeeError {
+    constructor(status, detail) {
+        super(`HTTP ${status} - ${detail}`);
+        this.status = status;
+        this.detail = detail;
+        this.name = "MindeeHttpErrorV2";
+    }
+}
+exports.MindeeHttpErrorV2 = MindeeHttpErrorV2;

package/src/http/apiSettings.d.ts

@@ -1,18 +1,12 @@
+import { BaseSettings, MindeeApiConstructorProps } from "./baseSettings";
 export declare const API_KEY_ENVVAR_NAME: string;
 export declare const API_HOST_ENVVAR_NAME: string;
 export declare const STANDARD_API_OWNER: string;
 export declare const TIMEOUT_DEFAULT: number;
-interface MindeeApiConstructorProps {
-    apiKey: string;
-}
-export declare class ApiSettings {
+export declare class ApiSettings extends BaseSettings {
     apiKey: string;
     baseHeaders: Record<string, string>;
-    hostname: string;
-    timeout: number;
     constructor({ apiKey, }: MindeeApiConstructorProps);
-    protected getUserAgent(): string;
     protected apiKeyFromEnv(): string;
     protected hostnameFromEnv(): string;
 }
-export {};

package/src/http/apiSettings.js

@@ -1,40 +1,17 @@
 "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.ApiSettings = exports.TIMEOUT_DEFAULT = exports.STANDARD_API_OWNER = exports.API_HOST_ENVVAR_NAME = exports.API_KEY_ENVVAR_NAME = void 0;
 /* eslint-disable @typescript-eslint/naming-convention */
 const logger_1 = require("../logger");
-const package_json_1 = require("../../package.json");
-const os = __importStar(require("os"));
+const baseSettings_1 = require("./baseSettings");
 exports.API_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
 exports.API_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
 exports.STANDARD_API_OWNER = "mindee";
 exports.TIMEOUT_DEFAULT = 120;
 const DEFAULT_MINDEE_API_HOST = "api.mindee.net";
-class ApiSettings {
+class ApiSettings extends baseSettings_1.BaseSettings {
     constructor({ apiKey = "", }) {
+        super();
         if (!apiKey || apiKey.length === 0) {
             this.apiKey = this.apiKeyFromEnv();
         }
@@ -49,21 +26,6 @@ class ApiSettings {
             "User-Agent": this.getUserAgent(),
             Authorization: `Token ${this.apiKey}`,
         };
-        this.hostname = this.hostnameFromEnv();
-        this.timeout = process.env.MINDEE_REQUEST_TIMEOUT ? parseInt(process.env.MINDEE_REQUEST_TIMEOUT) : exports.TIMEOUT_DEFAULT;
-    }
-    getUserAgent() {
-        let platform = os.type().toLowerCase();
-        if (platform.includes("darwin")) {
-            platform = "macos";
-        }
-        else if (platform.includes("window")) {
-            platform = "windows";
-        }
-        else if (platform.includes("bsd")) {
-            platform = "bsd";
-        }
-        return `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${platform}`;
     }
     apiKeyFromEnv() {
         const envVarValue = process.env[exports.API_KEY_ENVVAR_NAME];

package/src/http/apiSettingsV2.d.ts

@@ -0,0 +1,10 @@
+import { BaseSettings, MindeeApiConstructorProps } from "./baseSettings";
+export declare const API_V2_KEY_ENVVAR_NAME: string;
+export declare const API_V2_HOST_ENVVAR_NAME: string;
+export declare class ApiSettingsV2 extends BaseSettings {
+    apiKey: string;
+    baseHeaders: Record<string, string>;
+    constructor({ apiKey, }: MindeeApiConstructorProps);
+    protected apiKeyFromEnv(): string;
+    protected hostnameFromEnv(): string;
+}

package/src/http/apiSettingsV2.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSettingsV2 = exports.API_V2_HOST_ENVVAR_NAME = exports.API_V2_KEY_ENVVAR_NAME = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+const logger_1 = require("../logger");
+const baseSettings_1 = require("./baseSettings");
+const mindeeError_1 = require("../errors/mindeeError");
+exports.API_V2_KEY_ENVVAR_NAME = "MINDEE_V2_API_KEY";
+exports.API_V2_HOST_ENVVAR_NAME = "MINDEE_V2_API_HOST";
+const DEFAULT_MINDEE_API_HOST = "api-v2.mindee.net";
+class ApiSettingsV2 extends baseSettings_1.BaseSettings {
+    constructor({ apiKey = "", }) {
+        super();
+        if (!apiKey || apiKey.length === 0) {
+            this.apiKey = this.apiKeyFromEnv();
+        }
+        else {
+            this.apiKey = apiKey;
+        }
+        if (!this.apiKey || this.apiKey.length === 0) {
+            throw new mindeeError_1.MindeeApiV2Error("Your API V2 key could not be set, check your Client Configuration\n."
+                + `You can set this using the ${exports.API_V2_KEY_ENVVAR_NAME} environment variable.`);
+        }
+        this.baseHeaders = {
+            "User-Agent": this.getUserAgent(),
+            Authorization: `${apiKey}`,
+        };
+    }
+    apiKeyFromEnv() {
+        const envVarValue = process.env[exports.API_V2_KEY_ENVVAR_NAME];
+        if (envVarValue) {
+            logger_1.logger.debug(`Set API key from environment: ${exports.API_V2_KEY_ENVVAR_NAME}`);
+            return envVarValue;
+        }
+        return "";
+    }
+    hostnameFromEnv() {
+        const envVarValue = process.env[exports.API_V2_HOST_ENVVAR_NAME];
+        if (envVarValue) {
+            logger_1.logger.debug(`Set the API hostname to ${envVarValue}`);
+            return envVarValue;
+        }
+        return DEFAULT_MINDEE_API_HOST;
+    }
+}
+exports.ApiSettingsV2 = ApiSettingsV2;

package/src/http/baseEndpoint.d.ts

@@ -22,7 +22,7 @@ export declare abstract class BaseEndpoint {
      * @param inputDoc input document.
      * @param pageOptions page cutting options.
      */
-    protected cutDocPages(inputDoc: InputSource, pageOptions: PageOptions): Promise<void>;
+    static cutDocPages(inputDoc: InputSource, pageOptions: PageOptions): Promise<void>;
     /**
      * Reads a response from the API and processes it.
      * @param options options related to the request itself.
@@ -30,5 +30,5 @@ export declare abstract class BaseEndpoint {
      * @param reject promise rejection reason.
      * @returns the processed request.
      */
-    protected readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
+    static readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
 }

package/src/http/baseEndpoint.js

@@ -17,9 +17,9 @@ class BaseEndpoint {
      * @param inputDoc input document.
      * @param pageOptions page cutting options.
      */
-    async cutDocPages(inputDoc, pageOptions) {
+    static async cutDocPages(inputDoc, pageOptions) {
         if (inputDoc instanceof input_1.LocalInputSource && inputDoc.isPdf()) {
-            await inputDoc.cutPdf(pageOptions);
+            await inputDoc.applyPageOptions(pageOptions);
         }
     }
     /**
@@ -29,7 +29,7 @@ class BaseEndpoint {
      * @param reject promise rejection reason.
      * @returns the processed request.
      */
-    readResponse(options, resolve, reject) {
+    static readResponse(options, resolve, reject) {
         logger_1.logger.debug(`${options.method}: https://${options.hostname}${options.path}`);
         const req = (0, https_1.request)(options, function (res) {
             // when the encoding is set, data chunks will be strings

package/src/http/baseSettings.d.ts

@@ -0,0 +1,11 @@
+export interface MindeeApiConstructorProps {
+    apiKey?: string;
+}
+export declare abstract class BaseSettings {
+    hostname: string;
+    timeout: number;
+    protected constructor();
+    protected getUserAgent(): string;
+    protected abstract apiKeyFromEnv(): string;
+    protected abstract hostnameFromEnv(): string;
+}

package/src/http/baseSettings.js

@@ -0,0 +1,59 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSettings = void 0;
+const package_json_1 = require("../../package.json");
+const os = __importStar(require("os"));
+const apiSettings_1 = require("./apiSettings");
+class BaseSettings {
+    constructor() {
+        this.hostname = this.hostnameFromEnv();
+        this.timeout = process.env.MINDEE_REQUEST_TIMEOUT ? parseInt(process.env.MINDEE_REQUEST_TIMEOUT) : apiSettings_1.TIMEOUT_DEFAULT;
+    }
+    getUserAgent() {
+        let platform = os.type().toLowerCase();
+        if (platform.includes("darwin")) {
+            platform = "macos";
+        }
+        else if (platform.includes("window")) {
+            platform = "windows";
+        }
+        else if (platform.includes("bsd")) {
+            platform = "bsd";
+        }
+        return `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${platform}`;
+    }
+}
+exports.BaseSettings = BaseSettings;

package/src/http/endpoint.js

@@ -44,7 +44,7 @@ class Endpoint extends baseEndpoint_1.BaseEndpoint {
     async predict(params) {
         await params.inputDoc.init();
         if (params.pageOptions !== undefined) {
-            await super.cutDocPages(params.inputDoc, params.pageOptions);
+            await baseEndpoint_1.BaseEndpoint.cutDocPages(params.inputDoc, params.pageOptions);
         }
         const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper);
         if (!(0, responseValidation_1.isValidSyncResponse)(response)) {
@@ -62,7 +62,7 @@ class Endpoint extends baseEndpoint_1.BaseEndpoint {
     async predictAsync(params) {
         await params.inputDoc.init();
         if (params.pageOptions !== undefined) {
-            await super.cutDocPages(params.inputDoc, params.pageOptions);
+            await baseEndpoint_1.BaseEndpoint.cutDocPages(params.inputDoc, params.pageOptions);
         }
         const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictAsyncReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper, params.rag, params.workflowId);
         if (!(0, responseValidation_1.isValidAsyncResponse)(response)) {
@@ -181,7 +181,7 @@ class Endpoint extends baseEndpoint_1.BaseEndpoint {
                 path: path,
                 timeout: this.settings.timeout,
             };
-            const req = this.readResponse(options, resolve, reject);
+            const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
             form.pipe(req);
             // potential ECONNRESET if we don't end the request.
             req.end();
@@ -211,7 +211,7 @@ input, includeWords = false, fullText = false, cropper = false, rag = false, wor
             hostname: this.settings.hostname,
             path: `${this.urlRoot}/documents/queue/${queueId}`,
         };
-        const req = this.readResponse(options, resolve, reject);
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
         // potential ECONNRESET if we don't end the request.
         req.end();
     });
@@ -223,7 +223,7 @@ input, includeWords = false, fullText = false, cropper = false, rag = false, wor
             hostname: this.settings.hostname,
             path: `${this.urlRoot}/documents/${documentId}`,
         };
-        const req = this.readResponse(options, resolve, reject);
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
         // potential ECONNRESET if we don't end the request.
         req.end();
     });
@@ -235,7 +235,7 @@ input, includeWords = false, fullText = false, cropper = false, rag = false, wor
             hostname: this.settings.hostname,
             path: `/v1/documents/${documentId}/feedback`,
         };
-        const req = this.readResponse(options, resolve, reject);
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
         req.write(JSON.stringify(feedback));
         // potential ECONNRESET if we don't end the request.
         req.end();

package/src/http/mindeeApiV2.d.ts

@@ -0,0 +1,34 @@
+import { ApiSettingsV2 } from "./apiSettingsV2";
+import { InferenceParameters } from "../clientV2";
+import { InferenceResponse, JobResponse } from "../parsing/v2";
+import { LocalInputSource } from "../input";
+export declare class MindeeApiV2 {
+    #private;
+    settings: ApiSettingsV2;
+    constructor(apiKey?: string);
+    /**
+     * Sends a file to the inference queue.
+     * @param inputDoc Local file loaded as an input.
+     * @param params {InferenceParameters} parameters relating to the enqueueing options.
+     * @category V2
+     * @throws Error if the server's response contains one.
+     * @returns a `Promise` containing a job response.
+     */
+    reqPostInferenceEnqueue(inputDoc: LocalInputSource, params: InferenceParameters): Promise<JobResponse>;
+    /**
+     * Requests the job of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param inferenceId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    reqGetInference(inferenceId: string): Promise<InferenceResponse>;
+    /**
+     * Requests the results of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param jobId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    reqGetJob(jobId: string): Promise<JobResponse>;
+}

package/src/http/mindeeApiV2.js

@@ -0,0 +1,120 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _MindeeApiV2_instances, _MindeeApiV2_processResponse, _MindeeApiV2_documentEnqueuePost, _MindeeApiV2_inferenceResultReqGet;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindeeApiV2 = void 0;
+const apiSettingsV2_1 = require("./apiSettingsV2");
+const v2_1 = require("../parsing/v2");
+const form_data_1 = __importDefault(require("form-data"));
+const baseEndpoint_1 = require("./baseEndpoint");
+const mindeeError_1 = require("../errors/mindeeError");
+const logger_1 = require("../logger");
+class MindeeApiV2 {
+    constructor(apiKey) {
+        _MindeeApiV2_instances.add(this);
+        this.settings = new apiSettingsV2_1.ApiSettingsV2({ apiKey: apiKey });
+    }
+    /**
+     * Sends a file to the inference queue.
+     * @param inputDoc Local file loaded as an input.
+     * @param params {InferenceParameters} parameters relating to the enqueueing options.
+     * @category V2
+     * @throws Error if the server's response contains one.
+     * @returns a `Promise` containing a job response.
+     */
+    async reqPostInferenceEnqueue(inputDoc, params) {
+        await inputDoc.init();
+        if (params.modelId === undefined || params.modelId === null || params.modelId === "") {
+            throw new Error("Model ID must be provided");
+        }
+        const result = await __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_documentEnqueuePost).call(this, inputDoc, params);
+        if (result.data.error?.code !== undefined) {
+            throw new mindeeError_1.MindeeHttpErrorV2(result.data.error.code, result.data.error.message ?? "Unknown error.");
+        }
+        return __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_processResponse).call(this, result, v2_1.JobResponse);
+    }
+    /**
+     * Requests the job of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param inferenceId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    async reqGetInference(inferenceId) {
+        const queueResponse = await __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_inferenceResultReqGet).call(this, inferenceId, "inferences");
+        return __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_processResponse).call(this, queueResponse, v2_1.InferenceResponse);
+    }
+    /**
+     * Requests the results of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param jobId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    async reqGetJob(jobId) {
+        const queueResponse = await __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_inferenceResultReqGet).call(this, jobId, "jobs");
+        return __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_processResponse).call(this, queueResponse, v2_1.JobResponse);
+    }
+}
+exports.MindeeApiV2 = MindeeApiV2;
+_MindeeApiV2_instances = new WeakSet(), _MindeeApiV2_processResponse = function _MindeeApiV2_processResponse(result, responseType) {
+    if (result.messageObj?.statusCode && (result.messageObj?.statusCode > 399 || result.messageObj?.statusCode < 200)) {
+        if (result.data?.status !== null) {
+            throw new mindeeError_1.MindeeHttpErrorV2(result.data?.status, result.data?.detail ?? "Unknown error.");
+        }
+        throw new mindeeError_1.MindeeHttpErrorV2(result.messageObj?.statusCode ?? -1, result.data?.statusMessage ?? "Unknown error.");
+    }
+    try {
+        return new responseType(result.data);
+    }
+    catch (e) {
+        logger_1.logger.error(`Raised '${e}' Couldn't deserialize response object:\n${JSON.stringify(result.data)}`);
+        throw new mindeeError_1.MindeeApiV2Error("Couldn't deserialize response object.");
+    }
+}, _MindeeApiV2_documentEnqueuePost = function _MindeeApiV2_documentEnqueuePost(inputDoc, params) {
+    const form = new form_data_1.default();
+    form.append("model_id", params.modelId);
+    if (params.rag) {
+        form.append("rag", "true");
+    }
+    if (params.webhookIds && params.webhookIds.length > 0) {
+        form.append("webhook_ids", params.webhookIds.join(","));
+    }
+    form.append("file", inputDoc.fileObject, {
+        filename: inputDoc.filename,
+    });
+    const path = "/v2/inferences/enqueue";
+    const headers = { ...this.settings.baseHeaders, ...form.getHeaders() };
+    const options = {
+        method: "POST",
+        headers: headers,
+        hostname: this.settings.hostname,
+        path: path,
+        timeout: this.settings.timeout,
+    };
+    return new Promise((resolve, reject) => {
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
+        form.pipe(req);
+        // potential ECONNRESET if we don't end the request.
+        req.end();
+    });
+}, _MindeeApiV2_inferenceResultReqGet = function _MindeeApiV2_inferenceResultReqGet(queueId, slug) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            method: "GET",
+            headers: this.settings.baseHeaders,
+            hostname: this.settings.hostname,
+            path: `/v2/${slug}/${queueId}`,
+        };
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
+        // potential ECONNRESET if we don't end the request.
+        req.end();
+    });
+};