allow parsing by response class

Author: ianardee

README.md

@@ -18,12 +18,12 @@ Finally, Node.js away!
 ```ts
 import { Client, InvoiceResponse } from "mindee";
 
-// Init a new client and configure the Invoice API
-const mindeeClient = new Client({apiKey: "my-api-key"}).configInvoice({});
+// Init a new client
+const mindeeClient = new Client({apiKey: "my-api-key"});
 
 // Load a file from disk and parse it
-const pathDoc = mindeeClient.docFromPath("/path/to/the/invoice.pdf");
-const invoiceResponse = pathDoc.parse(InvoiceResponse, { docType: "invoice" });
+const invoiceResponse = mindeeClient.docFromPath("/path/to/the/invoice.pdf")
+  .parse(InvoiceResponse);
 
 // Print a brief summary of the parsed data
 invoiceResponse.then((resp) => {
@@ -36,10 +36,11 @@ invoiceResponse.then((resp) => {
 ```ts
 import { Client, CustomResponse } from "mindee";
 
-// Init a new client and configure your custom document
-const mindeeClient = new Client({apiKey: "my-api-key"}).configCustomDoc({
-  accountName: "john",
-  documentType: "wsnine",
+// Init a new client and add your document endpoint
+const mindeeClient = new Client({apiKey: "my-api-key"})
+  .addEndpoint({
+    accountName: "john",
+    documentType: "wsnine",
 });
 
 // Load a file from disk and parse it

src/api/endpoint.ts

@@ -13,7 +13,7 @@ const USER_AGENT = `mindee-api-nodejs@v${sdkVersion} nodejs-${
   process.version
 } ${os.type().toLowerCase()}`;
 
-export const OTS_OWNER = "mindee";
+export const STANDARD_API_OWNER = "mindee";
 export const API_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
 
 export class Endpoint {
@@ -129,19 +129,19 @@ export class Endpoint {
 
 export class InvoiceEndpoint extends Endpoint {
   constructor(apiKey: string) {
-    super(OTS_OWNER, "invoices", "3", apiKey, "invoice");
+    super(STANDARD_API_OWNER, "invoices", "3", apiKey, "invoice");
   }
 }
 
 export class ReceiptEndpoint extends Endpoint {
   constructor(apiKey: string) {
-    super(OTS_OWNER, "expense_receipts", "3", apiKey, "receipt");
+    super(STANDARD_API_OWNER, "expense_receipts", "3", apiKey, "receipt");
   }
 }
 
 export class PassportEndpoint extends Endpoint {
   constructor(apiKey: string) {
-    super(OTS_OWNER, "passport", "1", apiKey);
+    super(STANDARD_API_OWNER, "passport", "1", apiKey);
   }
 }
 

src/api/index.ts

@@ -2,7 +2,7 @@ export {
   Response,
   InvoiceResponse,
   ReceiptResponse,
-  FinancialResponse,
+  FinancialDocResponse,
   PassportResponse,
   CustomResponse,
 } from "./response";
@@ -12,6 +12,6 @@ export {
   ReceiptEndpoint,
   PassportEndpoint,
   CustomEndpoint,
-  OTS_OWNER,
+  STANDARD_API_OWNER,
   API_KEY_ENVVAR_NAME,
 } from "./endpoint";

src/api/response.ts

@@ -49,7 +49,7 @@ export class Response<DocType extends Document> {
 }
 
 /**
- * Class for all custom endpoint responses.
+ * Class for all constructed (API Builder) endpoint responses.
  */
 export class CustomResponse extends Response<CustomDocument> {
   constructor(params: ResponseProps) {
@@ -79,7 +79,7 @@ export class CustomResponse extends Response<CustomDocument> {
   }
 }
 
-type OtsDocumentSig<DocType extends Document> = {
+type StandardDocumentSig<DocType extends Document> = {
   new ({
     apiPrediction,
     inputFile,
@@ -89,12 +89,17 @@ type OtsDocumentSig<DocType extends Document> = {
 };
 
 /**
- * Generic class for all OTS endpoint responses.
+ * Generic class for all standard (Off-the-Shelf) endpoint responses.
  */
-export class OtsResponse<DocType extends Document> extends Response<DocType> {
-  documentClass: OtsDocumentSig<DocType>;
+export class StandardProductResponse<
+  DocType extends Document
+> extends Response<DocType> {
+  documentClass: StandardDocumentSig<DocType>;
 
-  constructor(documentClass: OtsDocumentSig<DocType>, params: ResponseProps) {
+  constructor(
+    documentClass: StandardDocumentSig<DocType>,
+    params: ResponseProps
+  ) {
     super(params);
     this.documentClass = documentClass;
     if (!params.error) {
@@ -122,25 +127,25 @@ export class OtsResponse<DocType extends Document> extends Response<DocType> {
   }
 }
 
-export class InvoiceResponse extends OtsResponse<Invoice> {
+export class InvoiceResponse extends StandardProductResponse<Invoice> {
   constructor(params: ResponseProps) {
     super(Invoice, params);
   }
 }
 
-export class ReceiptResponse extends OtsResponse<Receipt> {
+export class ReceiptResponse extends StandardProductResponse<Receipt> {
   constructor(params: ResponseProps) {
     super(Receipt, params);
   }
 }
 
-export class FinancialResponse extends OtsResponse<FinancialDocument> {
+export class FinancialDocResponse extends StandardProductResponse<FinancialDocument> {
   constructor(params: ResponseProps) {
     super(FinancialDocument, params);
   }
 }
 
-export class PassportResponse extends OtsResponse<Passport> {
+export class PassportResponse extends StandardProductResponse<Passport> {
   constructor(params: ResponseProps) {
     super(Passport, params);
   }

src/cli.ts

@@ -1,137 +1,98 @@
 import { Command } from "commander";
-import { Client } from "./index";
 import {
   DOC_TYPE_INVOICE,
   DOC_TYPE_RECEIPT,
   DOC_TYPE_PASSPORT,
   DOC_TYPE_FINANCIAL,
-  Document,
+  DOC_TYPE_CUSTOM,
 } from "./documents";
 import {
-  Response,
-  FinancialResponse,
+  CustomResponse,
+  FinancialDocResponse,
   InvoiceResponse,
   PassportResponse,
   ReceiptResponse,
-  CustomResponse,
+  STANDARD_API_OWNER,
 } from "./api";
+import { Client } from "./client";
+import { ProductConfigs, ProductConfig } from "./constants";
 
 const program = new Command();
 
-interface OtsCliConfig {
-  help: string;
-  docType: string;
-  responseClass: typeof Response<Document>;
-  fullText: boolean;
-}
-
 const COMMAND_INVOICE = "invoice";
 const COMMAND_RECEIPT = "receipt";
 const COMMAND_PASSPORT = "passport";
 const COMMAND_FINANCIAL = "financial";
 const COMMAND_CUSTOM = "custom";
 
-const OTS_DOCUMENTS = new Map<string, OtsCliConfig>([
-  [
-    COMMAND_INVOICE,
-    {
-      help: "Invoice",
-      docType: DOC_TYPE_INVOICE,
-      responseClass: InvoiceResponse,
-      fullText: true,
-    },
-  ],
-  [
-    COMMAND_RECEIPT,
-    {
-      help: "Expense Receipt",
-      docType: DOC_TYPE_RECEIPT,
-      responseClass: ReceiptResponse,
-      fullText: true,
-    },
-  ],
-  [
-    COMMAND_PASSPORT,
-    {
-      help: "Passport",
-      docType: DOC_TYPE_PASSPORT,
-      responseClass: PassportResponse,
-      fullText: false,
-    },
-  ],
-  [
-    COMMAND_FINANCIAL,
-    {
-      help: "Financial Document (receipt or invoice)",
-      docType: DOC_TYPE_FINANCIAL,
-      responseClass: FinancialResponse,
-      fullText: true,
-    },
-  ],
-  [
-    COMMAND_CUSTOM,
-    {
-      help: "A custom document",
-      docType: "",
-      responseClass: CustomResponse,
-      fullText: false,
-    },
-  ],
+const CLI_COMMAND_CONFIG = new Map<string, ProductConfig>([
+  [COMMAND_INVOICE, ProductConfigs.getByDocType(DOC_TYPE_INVOICE)],
+  [COMMAND_RECEIPT, ProductConfigs.getByDocType(DOC_TYPE_RECEIPT)],
+  [COMMAND_PASSPORT, ProductConfigs.getByDocType(DOC_TYPE_PASSPORT)],
+  [COMMAND_FINANCIAL, ProductConfigs.getByDocType(DOC_TYPE_FINANCIAL)],
+  [COMMAND_CUSTOM, ProductConfigs.getByDocType(DOC_TYPE_CUSTOM)],
 ]);
 
 async function predictCall(command: string, inputPath: string, options: any) {
-  const info = OTS_DOCUMENTS.get(command);
-  if (!info) {
+  const conf = CLI_COMMAND_CONFIG.get(command);
+  if (conf === undefined) {
     throw new Error(`Invalid document type ${command}`);
   }
   const mindeeClient = new Client({
     apiKey: options.apiKey,
-    debug: options.verbose,
+    debug: options.debug,
   });
+  if (command === COMMAND_CUSTOM) {
+    mindeeClient.addEndpoint({
+      accountName: options.user,
+      documentType: options.documentType,
+    });
+  }
+  const doc = mindeeClient.docFromPath(inputPath);
+  const params = {
+    docType: command === COMMAND_CUSTOM ? options.documentType : conf.docType,
+    username: command === COMMAND_CUSTOM ? options.user : STANDARD_API_OWNER,
+    cutPages: options.cutPages,
+    fullText: options.fullText,
+  };
+  // Tried setting the response by using the responseClass property in constants.PRODUCTS_CONFIG
+  // This compiled, but threw an exception:
+  //   TypeError: responseType is not a constructor
+  //
+  // So using a switch to explicitly set the response class parameter. Ugly, but works.
+  // Improvements welcome!
+  let response;
   switch (command) {
-    case COMMAND_INVOICE: {
-      mindeeClient.configInvoice();
+    case COMMAND_INVOICE:
+      response = await doc.parse(InvoiceResponse, params);
       break;
-    }
-    case COMMAND_RECEIPT: {
-      mindeeClient.configReceipt();
+    case COMMAND_RECEIPT:
+      response = await doc.parse(ReceiptResponse, params);
       break;
-    }
-    case COMMAND_PASSPORT: {
-      mindeeClient.configPassport();
+    case COMMAND_FINANCIAL:
+      response = await doc.parse(FinancialDocResponse, params);
       break;
-    }
-    case COMMAND_FINANCIAL: {
-      mindeeClient.configFinancialDoc();
+    case COMMAND_PASSPORT:
+      response = await doc.parse(PassportResponse, params);
       break;
-    }
-    case COMMAND_CUSTOM: {
-      mindeeClient.addEndpoint({
-        accountName: options.user,
-        endpointName: options.documentType,
-      });
+    case COMMAND_CUSTOM:
+      response = await doc.parse(CustomResponse, params);
       break;
-    }
+    default:
+      throw `Unhandled command: ${command}`;
   }
-  const doc = mindeeClient.docFromPath(inputPath);
-  const result = await doc.parse(info.responseClass, {
-    docType: info.docType || options.documentType,
-    username: options.user || "mindee",
-    cutPages: options.cutPages,
-    fullText: options.fullText,
-  });
-  if (result.document) {
-    console.log(`\n${result.document}`);
+  if (response.document) {
+    console.log(`\n${response.document}`);
   }
 }
 
 export function cli() {
   program.name("mindee");
-  program.option("-v, --verbose", "high verbosity mode");
+  program.option("-d, --debug", "high verbosity mode");
 
-  OTS_DOCUMENTS.forEach((info, name) => {
+  CLI_COMMAND_CONFIG.forEach((info, name) => {
     const prog = program.command(name);
-    prog.description(info.help);
+    prog.description(info.description);
 
     prog.option("-k, --api-key <api_key>", "API key for document endpoint");
     prog.option("-C, --no-cut-pages", "Don't cut document pages");
@@ -143,6 +104,10 @@ export function cli() {
         "-u, --user <username>",
         "API account name for the endpoint"
       );
+      prog.option(
+        "-v, --version <version>",
+        "API account name for the endpoint"
+      );
       prog.argument("<endpoint_name>", "API endpoint name");
     }
     prog.argument("<input_path>", "Full path to the file");
@@ -157,7 +122,7 @@ export function cli() {
           const allOptions = {
             ...program.opts(),
             ...options,
-            endpointName: endpointName,
+            documentType: endpointName,
           };
           predictCall(command.name(), inputPath, allOptions);
         }