@tamtamchik/app-store-receipt-parser 2.1.1 → 2.2.0

package/dist/index.js

@@ -34,10 +34,14 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/parser.ts
+// src/ReceiptParser.ts
 var ASN1 = __toESM(require("asn1js"));
 
-// src/mappings.ts
+// src/constants.ts
+var IN_APP = 17;
+var CONTENT_ID = "pkcs7_content";
+var FIELD_TYPE_ID = "FieldType";
+var FIELD_VALUE_ID = "FieldTypeOctetString";
 var RECEIPT_FIELDS_MAP = /* @__PURE__ */ new Map([
   [0, "ENVIRONMENT"],
   [2, "BUNDLE_ID"],
@@ -58,143 +62,166 @@ var RECEIPT_FIELDS_MAP = /* @__PURE__ */ new Map([
   [1712, "IN_APP_CANCELLATION_DATE"]
 ]);
 
-// src/constants.ts
-var IN_APP = 17;
-var CONTENT_ID = "pkcs7_content";
-var FIELD_TYPE_ID = "FieldType";
-var FIELD_VALUE_ID = "FieldTypeOctetString";
-
-// src/verifications.ts
+// src/ReceiptVerifier.ts
 var import_asn1js = require("asn1js");
-var receiptSchema = new import_asn1js.Sequence({
-  value: [
-    new import_asn1js.ObjectIdentifier(),
-    new import_asn1js.Constructed({
-      idBlock: { tagClass: 3, tagNumber: 0 },
+var ReceiptVerifier = class {
+  receiptSchema;
+  fieldSchema;
+  constructor() {
+    this.receiptSchema = new import_asn1js.Sequence({
       value: [
-        new import_asn1js.Sequence({
+        new import_asn1js.ObjectIdentifier(),
+        new import_asn1js.Constructed({
+          idBlock: { tagClass: 3, tagNumber: 0 },
           value: [
-            new import_asn1js.Integer(),
-            new import_asn1js.Set({
-              value: [
-                new import_asn1js.Sequence({
-                  value: [new import_asn1js.ObjectIdentifier(), new import_asn1js.Any()]
-                })
-              ]
-            }),
             new import_asn1js.Sequence({
               value: [
-                new import_asn1js.ObjectIdentifier(),
-                new import_asn1js.Constructed({
-                  idBlock: { tagClass: 3, tagNumber: 0 },
-                  value: [new import_asn1js.OctetString({ name: CONTENT_ID })]
+                new import_asn1js.Integer(),
+                new import_asn1js.Set({
+                  value: [
+                    new import_asn1js.Sequence({
+                      value: [new import_asn1js.ObjectIdentifier(), new import_asn1js.Any()]
+                    })
+                  ]
+                }),
+                new import_asn1js.Sequence({
+                  value: [
+                    new import_asn1js.ObjectIdentifier(),
+                    new import_asn1js.Constructed({
+                      idBlock: { tagClass: 3, tagNumber: 0 },
+                      value: [new import_asn1js.OctetString({ name: CONTENT_ID })]
+                    })
+                  ]
                 })
               ]
             })
           ]
         })
       ]
-    })
-  ]
-});
-var fieldSchema = new import_asn1js.Sequence({
-  value: [
-    new import_asn1js.Integer({ name: FIELD_TYPE_ID }),
-    new import_asn1js.Integer(),
-    new import_asn1js.OctetString({ name: FIELD_VALUE_ID })
-  ]
-});
-function verifyReceiptSchema(receipt) {
-  const receiptVerification = (0, import_asn1js.verifySchema)(Buffer.from(receipt, "base64"), receiptSchema);
-  if (!receiptVerification.verified) {
-    throw new Error("Receipt verification failed.");
+    });
+    this.fieldSchema = new import_asn1js.Sequence({
+      value: [
+        new import_asn1js.Integer({ name: FIELD_TYPE_ID }),
+        new import_asn1js.Integer(),
+        new import_asn1js.OctetString({ name: FIELD_VALUE_ID })
+      ]
+    });
   }
-  return receiptVerification;
-}
-function verifyFieldSchema(sequence) {
-  const fieldVerification = (0, import_asn1js.verifySchema)(sequence.toBER(), fieldSchema);
-  if (!fieldVerification.verified) {
-    return null;
+  verifyReceiptSchema(receipt) {
+    const receiptVerification = (0, import_asn1js.verifySchema)(Buffer.from(receipt, "base64"), this.receiptSchema);
+    if (!receiptVerification.verified) {
+      throw new Error("Receipt verification failed.");
+    }
+    return receiptVerification;
   }
-  return fieldVerification;
-}
-
-// src/parser.ts
-var uniqueArrayValues = (array) => Array.from(new Set(array));
-function isReceiptFieldKey(value) {
-  return Boolean(typeof value === "number" && RECEIPT_FIELDS_MAP.has(value));
-}
-function isParsedReceiptContentComplete(data) {
-  for (const fieldKey of RECEIPT_FIELDS_MAP.values()) {
-    if (!(fieldKey in data)) {
-      return false;
+  verifyFieldSchema(sequence) {
+    const fieldVerification = (0, import_asn1js.verifySchema)(sequence.toBER(), this.fieldSchema);
+    if (!fieldVerification.verified) {
+      return null;
     }
+    return fieldVerification;
   }
-  return true;
-}
-function extractFieldValue(field) {
-  const [fieldValue] = field.valueBlock.value;
-  if (fieldValue instanceof ASN1.IA5String || fieldValue instanceof ASN1.Utf8String) {
-    return fieldValue.valueBlock.value;
+};
+
+// src/ReceiptParser.ts
+var ReceiptParser = class {
+  parsed;
+  receiptVerifier;
+  constructor() {
+    this.receiptVerifier = new ReceiptVerifier();
+    this.parsed = this.createInitialParsedReceipt();
   }
-  return field.toJSON().valueBlock.valueHex;
-}
-function appendField(parsed, name, value) {
-  if (name === "IN_APP_ORIGINAL_TRANSACTION_ID") {
-    parsed.IN_APP_ORIGINAL_TRANSACTION_IDS.push(value);
+  parseReceipt(receipt) {
+    if (receipt.trim() === "") {
+      throw new Error("Receipt must be a non-empty string.");
+    }
+    const rootSchemaVerification = this.receiptVerifier.verifyReceiptSchema(receipt);
+    const content = rootSchemaVerification.result[CONTENT_ID];
+    this.parseReceiptContent(content);
+    this.validateParsedFields();
+    this.deduplicateArrayFields();
+    return this.parsed;
   }
-  if (name === "IN_APP_TRANSACTION_ID") {
-    parsed.IN_APP_TRANSACTION_IDS.push(value);
+  createInitialParsedReceipt() {
+    return {
+      ENVIRONMENT: "Production",
+      IN_APP_ORIGINAL_TRANSACTION_IDS: [],
+      IN_APP_TRANSACTION_IDS: []
+    };
   }
-  parsed[name] = value;
-}
-function processField(parsed, fieldKey, fieldValue) {
-  if (fieldKey === IN_APP) {
-    parseOctetStringContent(parsed, fieldValue);
-    return;
+  parseReceiptContent(content) {
+    const sequences = this.extractSequencesFromContent(content);
+    sequences.forEach(this.processSequence.bind(this));
   }
-  if (!isReceiptFieldKey(fieldKey)) {
-    return;
+  extractSequencesFromContent(content) {
+    const [contentSet] = content.valueBlock.value;
+    return contentSet.valueBlock.value.filter((v) => v instanceof ASN1.Sequence);
   }
-  const name = RECEIPT_FIELDS_MAP.get(fieldKey);
-  appendField(parsed, name, extractFieldValue(fieldValue));
-}
-function parseOctetStringContent(parsed, content) {
-  const [contentSet] = content.valueBlock.value;
-  const contentSetSequences = contentSet.valueBlock.value.filter((v) => v instanceof ASN1.Sequence);
-  for (const sequence of contentSetSequences) {
-    const verifiedSequence = verifyFieldSchema(sequence);
+  processSequence(sequence) {
+    const verifiedSequence = this.receiptVerifier.verifyFieldSchema(sequence);
     if (verifiedSequence) {
-      const fieldKey = verifiedSequence.result[FIELD_TYPE_ID].valueBlock.valueDec;
-      const fieldValueOctetString = verifiedSequence.result[FIELD_VALUE_ID];
-      processField(parsed, fieldKey, fieldValueOctetString);
+      this.handleVerifiedSequence(verifiedSequence);
     }
   }
-}
-function postprocessParsedReceipt(parsed) {
-  parsed.IN_APP_ORIGINAL_TRANSACTION_IDS = uniqueArrayValues(parsed.IN_APP_ORIGINAL_TRANSACTION_IDS);
-  parsed.IN_APP_TRANSACTION_IDS = uniqueArrayValues(parsed.IN_APP_TRANSACTION_IDS);
-}
-function parseReceipt(receipt) {
-  const rootSchemaVerification = verifyReceiptSchema(receipt);
-  const content = rootSchemaVerification.result[CONTENT_ID];
-  const parsed = {
-    ENVIRONMENT: "Production",
-    IN_APP_ORIGINAL_TRANSACTION_IDS: [],
-    IN_APP_TRANSACTION_IDS: []
-  };
-  parseOctetStringContent(parsed, content);
-  if (!isParsedReceiptContentComplete(parsed)) {
-    const missingProps = [];
-    for (const fieldKey of RECEIPT_FIELDS_MAP.values()) {
-      if (!(fieldKey in parsed)) {
-        missingProps.push(fieldKey);
-      }
+  handleVerifiedSequence(verifiedSequence) {
+    const fieldKey = verifiedSequence.result[FIELD_TYPE_ID].valueBlock.valueDec;
+    const fieldValue = verifiedSequence.result[FIELD_VALUE_ID];
+    const handler = this.getFieldHandler(fieldKey);
+    handler(fieldValue);
+  }
+  getFieldHandler(fieldKey) {
+    if (fieldKey === IN_APP) {
+      return this.parseReceiptContent.bind(this);
+    }
+    if (this.isValidReceiptFieldKey(fieldKey)) {
+      const name = RECEIPT_FIELDS_MAP.get(fieldKey);
+      return (fieldValue) => {
+        this.addFieldToReceipt(name, this.extractStringValue(fieldValue));
+      };
     }
-    throw new Error(`Missing required fields: ${missingProps.join(", ")}`);
+    return () => {
+    };
   }
-  postprocessParsedReceipt(parsed);
-  return parsed;
+  isValidReceiptFieldKey(value) {
+    return typeof value === "number" && RECEIPT_FIELDS_MAP.has(value);
+  }
+  extractStringValue(field) {
+    const [fieldValue] = field.valueBlock.value;
+    if (fieldValue instanceof ASN1.IA5String || fieldValue instanceof ASN1.Utf8String) {
+      return fieldValue.valueBlock.value;
+    }
+    return field.toJSON().valueBlock.valueHex;
+  }
+  addFieldToReceipt(name, value) {
+    this.addToArrayFieldIfApplicable(name, value);
+    this.parsed[name] = value;
+  }
+  addToArrayFieldIfApplicable(name, value) {
+    const arrayFields = {
+      "IN_APP_ORIGINAL_TRANSACTION_ID": "IN_APP_ORIGINAL_TRANSACTION_IDS",
+      "IN_APP_TRANSACTION_ID": "IN_APP_TRANSACTION_IDS"
+    };
+    const arrayFieldName = arrayFields[name];
+    if (arrayFieldName) {
+      this.parsed[arrayFieldName].push(value);
+    }
+  }
+  validateParsedFields() {
+    const missingFields = Array.from(RECEIPT_FIELDS_MAP.values()).filter((fieldKey) => !(fieldKey in this.parsed));
+    if (missingFields.length > 0) {
+      throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+    }
+  }
+  deduplicateArrayFields() {
+    this.parsed.IN_APP_ORIGINAL_TRANSACTION_IDS = this.removeDuplicates(this.parsed.IN_APP_ORIGINAL_TRANSACTION_IDS);
+    this.parsed.IN_APP_TRANSACTION_IDS = this.removeDuplicates(this.parsed.IN_APP_TRANSACTION_IDS);
+  }
+  removeDuplicates(array) {
+    return [...new Set(array)];
+  }
+};
+function parseReceipt(receipt) {
+  return new ReceiptParser().parseReceipt(receipt);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -1,7 +1,11 @@
-// src/parser.ts
+// src/ReceiptParser.ts
 import * as ASN1 from "asn1js";
 
-// src/mappings.ts
+// src/constants.ts
+var IN_APP = 17;
+var CONTENT_ID = "pkcs7_content";
+var FIELD_TYPE_ID = "FieldType";
+var FIELD_VALUE_ID = "FieldTypeOctetString";
 var RECEIPT_FIELDS_MAP = /* @__PURE__ */ new Map([
   [0, "ENVIRONMENT"],
   [2, "BUNDLE_ID"],
@@ -22,143 +26,166 @@ var RECEIPT_FIELDS_MAP = /* @__PURE__ */ new Map([
   [1712, "IN_APP_CANCELLATION_DATE"]
 ]);
 
-// src/constants.ts
-var IN_APP = 17;
-var CONTENT_ID = "pkcs7_content";
-var FIELD_TYPE_ID = "FieldType";
-var FIELD_VALUE_ID = "FieldTypeOctetString";
-
-// src/verifications.ts
+// src/ReceiptVerifier.ts
 import { Any, Constructed, Integer, ObjectIdentifier, OctetString, Sequence, Set as Set2, verifySchema } from "asn1js";
-var receiptSchema = new Sequence({
-  value: [
-    new ObjectIdentifier(),
-    new Constructed({
-      idBlock: { tagClass: 3, tagNumber: 0 },
+var ReceiptVerifier = class {
+  receiptSchema;
+  fieldSchema;
+  constructor() {
+    this.receiptSchema = new Sequence({
       value: [
-        new Sequence({
+        new ObjectIdentifier(),
+        new Constructed({
+          idBlock: { tagClass: 3, tagNumber: 0 },
           value: [
-            new Integer(),
-            new Set2({
-              value: [
-                new Sequence({
-                  value: [new ObjectIdentifier(), new Any()]
-                })
-              ]
-            }),
             new Sequence({
               value: [
-                new ObjectIdentifier(),
-                new Constructed({
-                  idBlock: { tagClass: 3, tagNumber: 0 },
-                  value: [new OctetString({ name: CONTENT_ID })]
+                new Integer(),
+                new Set2({
+                  value: [
+                    new Sequence({
+                      value: [new ObjectIdentifier(), new Any()]
+                    })
+                  ]
+                }),
+                new Sequence({
+                  value: [
+                    new ObjectIdentifier(),
+                    new Constructed({
+                      idBlock: { tagClass: 3, tagNumber: 0 },
+                      value: [new OctetString({ name: CONTENT_ID })]
+                    })
+                  ]
                 })
               ]
             })
           ]
         })
       ]
-    })
-  ]
-});
-var fieldSchema = new Sequence({
-  value: [
-    new Integer({ name: FIELD_TYPE_ID }),
-    new Integer(),
-    new OctetString({ name: FIELD_VALUE_ID })
-  ]
-});
-function verifyReceiptSchema(receipt) {
-  const receiptVerification = verifySchema(Buffer.from(receipt, "base64"), receiptSchema);
-  if (!receiptVerification.verified) {
-    throw new Error("Receipt verification failed.");
-  }
-  return receiptVerification;
-}
-function verifyFieldSchema(sequence) {
-  const fieldVerification = verifySchema(sequence.toBER(), fieldSchema);
-  if (!fieldVerification.verified) {
-    return null;
+    });
+    this.fieldSchema = new Sequence({
+      value: [
+        new Integer({ name: FIELD_TYPE_ID }),
+        new Integer(),
+        new OctetString({ name: FIELD_VALUE_ID })
+      ]
+    });
   }
-  return fieldVerification;
-}
-
-// src/parser.ts
-var uniqueArrayValues = (array) => Array.from(new Set(array));
-function isReceiptFieldKey(value) {
-  return Boolean(typeof value === "number" && RECEIPT_FIELDS_MAP.has(value));
-}
-function isParsedReceiptContentComplete(data) {
-  for (const fieldKey of RECEIPT_FIELDS_MAP.values()) {
-    if (!(fieldKey in data)) {
-      return false;
+  verifyReceiptSchema(receipt) {
+    const receiptVerification = verifySchema(Buffer.from(receipt, "base64"), this.receiptSchema);
+    if (!receiptVerification.verified) {
+      throw new Error("Receipt verification failed.");
     }
+    return receiptVerification;
   }
-  return true;
-}
-function extractFieldValue(field) {
-  const [fieldValue] = field.valueBlock.value;
-  if (fieldValue instanceof ASN1.IA5String || fieldValue instanceof ASN1.Utf8String) {
-    return fieldValue.valueBlock.value;
+  verifyFieldSchema(sequence) {
+    const fieldVerification = verifySchema(sequence.toBER(), this.fieldSchema);
+    if (!fieldVerification.verified) {
+      return null;
+    }
+    return fieldVerification;
   }
-  return field.toJSON().valueBlock.valueHex;
-}
-function appendField(parsed, name, value) {
-  if (name === "IN_APP_ORIGINAL_TRANSACTION_ID") {
-    parsed.IN_APP_ORIGINAL_TRANSACTION_IDS.push(value);
+};
+
+// src/ReceiptParser.ts
+var ReceiptParser = class {
+  parsed;
+  receiptVerifier;
+  constructor() {
+    this.receiptVerifier = new ReceiptVerifier();
+    this.parsed = this.createInitialParsedReceipt();
   }
-  if (name === "IN_APP_TRANSACTION_ID") {
-    parsed.IN_APP_TRANSACTION_IDS.push(value);
+  parseReceipt(receipt) {
+    if (receipt.trim() === "") {
+      throw new Error("Receipt must be a non-empty string.");
+    }
+    const rootSchemaVerification = this.receiptVerifier.verifyReceiptSchema(receipt);
+    const content = rootSchemaVerification.result[CONTENT_ID];
+    this.parseReceiptContent(content);
+    this.validateParsedFields();
+    this.deduplicateArrayFields();
+    return this.parsed;
   }
-  parsed[name] = value;
-}
-function processField(parsed, fieldKey, fieldValue) {
-  if (fieldKey === IN_APP) {
-    parseOctetStringContent(parsed, fieldValue);
-    return;
+  createInitialParsedReceipt() {
+    return {
+      ENVIRONMENT: "Production",
+      IN_APP_ORIGINAL_TRANSACTION_IDS: [],
+      IN_APP_TRANSACTION_IDS: []
+    };
   }
-  if (!isReceiptFieldKey(fieldKey)) {
-    return;
+  parseReceiptContent(content) {
+    const sequences = this.extractSequencesFromContent(content);
+    sequences.forEach(this.processSequence.bind(this));
   }
-  const name = RECEIPT_FIELDS_MAP.get(fieldKey);
-  appendField(parsed, name, extractFieldValue(fieldValue));
-}
-function parseOctetStringContent(parsed, content) {
-  const [contentSet] = content.valueBlock.value;
-  const contentSetSequences = contentSet.valueBlock.value.filter((v) => v instanceof ASN1.Sequence);
-  for (const sequence of contentSetSequences) {
-    const verifiedSequence = verifyFieldSchema(sequence);
+  extractSequencesFromContent(content) {
+    const [contentSet] = content.valueBlock.value;
+    return contentSet.valueBlock.value.filter((v) => v instanceof ASN1.Sequence);
+  }
+  processSequence(sequence) {
+    const verifiedSequence = this.receiptVerifier.verifyFieldSchema(sequence);
     if (verifiedSequence) {
-      const fieldKey = verifiedSequence.result[FIELD_TYPE_ID].valueBlock.valueDec;
-      const fieldValueOctetString = verifiedSequence.result[FIELD_VALUE_ID];
-      processField(parsed, fieldKey, fieldValueOctetString);
+      this.handleVerifiedSequence(verifiedSequence);
     }
   }
-}
-function postprocessParsedReceipt(parsed) {
-  parsed.IN_APP_ORIGINAL_TRANSACTION_IDS = uniqueArrayValues(parsed.IN_APP_ORIGINAL_TRANSACTION_IDS);
-  parsed.IN_APP_TRANSACTION_IDS = uniqueArrayValues(parsed.IN_APP_TRANSACTION_IDS);
-}
-function parseReceipt(receipt) {
-  const rootSchemaVerification = verifyReceiptSchema(receipt);
-  const content = rootSchemaVerification.result[CONTENT_ID];
-  const parsed = {
-    ENVIRONMENT: "Production",
-    IN_APP_ORIGINAL_TRANSACTION_IDS: [],
-    IN_APP_TRANSACTION_IDS: []
-  };
-  parseOctetStringContent(parsed, content);
-  if (!isParsedReceiptContentComplete(parsed)) {
-    const missingProps = [];
-    for (const fieldKey of RECEIPT_FIELDS_MAP.values()) {
-      if (!(fieldKey in parsed)) {
-        missingProps.push(fieldKey);
-      }
+  handleVerifiedSequence(verifiedSequence) {
+    const fieldKey = verifiedSequence.result[FIELD_TYPE_ID].valueBlock.valueDec;
+    const fieldValue = verifiedSequence.result[FIELD_VALUE_ID];
+    const handler = this.getFieldHandler(fieldKey);
+    handler(fieldValue);
+  }
+  getFieldHandler(fieldKey) {
+    if (fieldKey === IN_APP) {
+      return this.parseReceiptContent.bind(this);
+    }
+    if (this.isValidReceiptFieldKey(fieldKey)) {
+      const name = RECEIPT_FIELDS_MAP.get(fieldKey);
+      return (fieldValue) => {
+        this.addFieldToReceipt(name, this.extractStringValue(fieldValue));
+      };
     }
-    throw new Error(`Missing required fields: ${missingProps.join(", ")}`);
+    return () => {
+    };
   }
-  postprocessParsedReceipt(parsed);
-  return parsed;
+  isValidReceiptFieldKey(value) {
+    return typeof value === "number" && RECEIPT_FIELDS_MAP.has(value);
+  }
+  extractStringValue(field) {
+    const [fieldValue] = field.valueBlock.value;
+    if (fieldValue instanceof ASN1.IA5String || fieldValue instanceof ASN1.Utf8String) {
+      return fieldValue.valueBlock.value;
+    }
+    return field.toJSON().valueBlock.valueHex;
+  }
+  addFieldToReceipt(name, value) {
+    this.addToArrayFieldIfApplicable(name, value);
+    this.parsed[name] = value;
+  }
+  addToArrayFieldIfApplicable(name, value) {
+    const arrayFields = {
+      "IN_APP_ORIGINAL_TRANSACTION_ID": "IN_APP_ORIGINAL_TRANSACTION_IDS",
+      "IN_APP_TRANSACTION_ID": "IN_APP_TRANSACTION_IDS"
+    };
+    const arrayFieldName = arrayFields[name];
+    if (arrayFieldName) {
+      this.parsed[arrayFieldName].push(value);
+    }
+  }
+  validateParsedFields() {
+    const missingFields = Array.from(RECEIPT_FIELDS_MAP.values()).filter((fieldKey) => !(fieldKey in this.parsed));
+    if (missingFields.length > 0) {
+      throw new Error(`Missing required fields: ${missingFields.join(", ")}`);
+    }
+  }
+  deduplicateArrayFields() {
+    this.parsed.IN_APP_ORIGINAL_TRANSACTION_IDS = this.removeDuplicates(this.parsed.IN_APP_ORIGINAL_TRANSACTION_IDS);
+    this.parsed.IN_APP_TRANSACTION_IDS = this.removeDuplicates(this.parsed.IN_APP_TRANSACTION_IDS);
+  }
+  removeDuplicates(array) {
+    return [...new Set(array)];
+  }
+};
+function parseReceipt(receipt) {
+  return new ReceiptParser().parseReceipt(receipt);
 }
 export {
   parseReceipt

package/eslint.config.mjs

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import globals from "globals";
+import stylisticTs from '@stylistic/eslint-plugin-ts'
+import tsParser from "@typescript-eslint/parser";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+});
+
+export default [
+    ...compat.extends("plugin:@typescript-eslint/recommended"),
+
+    {
+        plugins: {
+            "@stylistic/ts": stylisticTs,
+        },
+    },
+
+    {
+        languageOptions: {
+            globals: {
+            ...globals.node,
+            ...globals.jest,
+        },
+
+        parser: tsParser,
+        ecmaVersion: 2021,
+        sourceType: "module",
+    },
+
+    rules: {
+        indent: ["error", 2, {
+            SwitchCase: 1,
+        }],
+
+        semi: "off",
+        quotes: "off",
+        "object-curly-spacing": "off",
+
+        "@typescript-eslint/array-type": ["error", {
+            default: "array",
+        }],
+
+        "@stylistic/ts/ban-ts-comment": 0,
+        "@stylistic/ts/comma-dangle": ["error", "always-multiline"],
+        "@stylistic/ts/quotes": ["error", "single"],
+        "@stylistic/ts/semi": ["error", "never"],
+        "@stylistic/ts/object-curly-spacing": ["error", "always"],
+    },
+}];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamtamchik/app-store-receipt-parser",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "A lightweight TypeScript library for extracting transaction IDs from Apple's ASN.1 encoded receipts.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -31,18 +31,22 @@
     }
   },
   "dependencies": {
-    "asn1js": "3.0.5"
+    "asn1js": "^3.0.5"
   },
   "devDependencies": {
-    "@types/jest": "29.5.12",
-    "@types/node": "^20.12.8",
-    "@typescript-eslint/eslint-plugin": "^7.8.0",
-    "@typescript-eslint/parser": "^7.8.0",
-    "eslint": "8.57.0",
-    "jest": "29.7.0",
-    "ts-jest": "29.1.2",
-    "tsup": "8.0.2",
-    "typescript": "5.4.5"
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.11.1",
+    "@stylistic/eslint-plugin-ts": "^2.8.0",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.7.1",
+    "@typescript-eslint/eslint-plugin": "^8.7.0",
+    "@typescript-eslint/parser": "^8.7.0",
+    "eslint": "^9.11.1",
+    "globals": "^15.9.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
   },
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --clean",

package/src/ReceiptParser.ts

@@ -0,0 +1,145 @@
+import * as ASN1 from 'asn1js'
+
+import {
+  CONTENT_ID,
+  FIELD_TYPE_ID,
+  FIELD_VALUE_ID,
+  IN_APP,
+  RECEIPT_FIELDS_MAP,
+  ReceiptFieldsKeyNames, ReceiptFieldsKeyValues,
+} from './constants'
+
+import { ReceiptVerifier } from './ReceiptVerifier'
+
+export type Environment = 'Production' | 'ProductionSandbox' | string
+
+export type ParsedReceipt = Partial<Record<ReceiptFieldsKeyNames, string>> & {
+  ENVIRONMENT: Environment
+  IN_APP_ORIGINAL_TRANSACTION_IDS: string[]
+  IN_APP_TRANSACTION_IDS: string[]
+}
+
+class ReceiptParser {
+  private readonly parsed: ParsedReceipt
+  private readonly receiptVerifier: ReceiptVerifier
+
+  constructor() {
+    this.receiptVerifier = new ReceiptVerifier()
+    this.parsed = this.createInitialParsedReceipt()
+  }
+
+  public parseReceipt(receipt: string): ParsedReceipt {
+    if (receipt.trim() === '') {
+      throw new Error('Receipt must be a non-empty string.')
+    }
+
+    const rootSchemaVerification = this.receiptVerifier.verifyReceiptSchema(receipt)
+    const content = rootSchemaVerification.result[CONTENT_ID] as ASN1.OctetString
+
+    this.parseReceiptContent(content)
+    this.validateParsedFields()
+    this.deduplicateArrayFields()
+
+    return this.parsed
+  }
+
+  private createInitialParsedReceipt(): ParsedReceipt {
+    return {
+      ENVIRONMENT: 'Production',
+      IN_APP_ORIGINAL_TRANSACTION_IDS: [],
+      IN_APP_TRANSACTION_IDS: [],
+    }
+  }
+
+  private parseReceiptContent(content: ASN1.OctetString): void {
+    const sequences = this.extractSequencesFromContent(content)
+    sequences.forEach(this.processSequence.bind(this))
+  }
+
+  private extractSequencesFromContent(content: ASN1.OctetString): ASN1.Sequence[] {
+    const [contentSet] = content.valueBlock.value as ASN1.Set[]
+    return contentSet.valueBlock.value
+      .filter(v => v instanceof ASN1.Sequence) as ASN1.Sequence[]
+  }
+
+  private processSequence(sequence: ASN1.Sequence): void {
+    const verifiedSequence = this.receiptVerifier.verifyFieldSchema(sequence)
+    if (verifiedSequence) {
+      this.handleVerifiedSequence(verifiedSequence)
+    }
+  }
+
+  private handleVerifiedSequence(verifiedSequence: ASN1.CompareSchemaSuccess): void {
+    const fieldKey = (verifiedSequence.result[FIELD_TYPE_ID] as ASN1.Integer).valueBlock.valueDec
+    const fieldValue = verifiedSequence.result[FIELD_VALUE_ID] as ASN1.OctetString
+
+    const handler = this.getFieldHandler(fieldKey)
+    handler(fieldValue)
+  }
+
+  private getFieldHandler(fieldKey: number): (fieldValue: ASN1.OctetString) => void {
+    if (fieldKey === IN_APP) {
+      return this.parseReceiptContent.bind(this)
+    }
+    if (this.isValidReceiptFieldKey(fieldKey)) {
+      const name = RECEIPT_FIELDS_MAP.get(fieldKey)!
+      return (fieldValue: ASN1.OctetString) => {
+        this.addFieldToReceipt(name, this.extractStringValue(fieldValue))
+      }
+    }
+    return () => {}
+  }
+
+  private isValidReceiptFieldKey(value: unknown): value is ReceiptFieldsKeyValues {
+    return typeof value === 'number' && RECEIPT_FIELDS_MAP.has(value as ReceiptFieldsKeyValues)
+  }
+
+  private extractStringValue(field: ASN1.OctetString): string {
+    const [fieldValue] = field.valueBlock.value
+
+    if (fieldValue instanceof ASN1.IA5String || fieldValue instanceof ASN1.Utf8String) {
+      return fieldValue.valueBlock.value
+    }
+
+    return field.toJSON().valueBlock.valueHex
+  }
+
+  private addFieldToReceipt(name: ReceiptFieldsKeyNames, value: string): void {
+    this.addToArrayFieldIfApplicable(name, value)
+    this.parsed[name] = value
+  }
+
+  private addToArrayFieldIfApplicable(name: ReceiptFieldsKeyNames, value: string): void {
+    const arrayFields: Record<string, keyof ParsedReceipt> = {
+      'IN_APP_ORIGINAL_TRANSACTION_ID': 'IN_APP_ORIGINAL_TRANSACTION_IDS',
+      'IN_APP_TRANSACTION_ID': 'IN_APP_TRANSACTION_IDS',
+    }
+
+    const arrayFieldName = arrayFields[name]
+    if (arrayFieldName) {
+      (this.parsed[arrayFieldName] as string[]).push(value)
+    }
+  }
+
+  private validateParsedFields(): void {
+    const missingFields = Array.from(RECEIPT_FIELDS_MAP.values())
+      .filter(fieldKey => !(fieldKey in this.parsed))
+
+    if (missingFields.length > 0) {
+      throw new Error(`Missing required fields: ${missingFields.join(', ')}`)
+    }
+  }
+
+  private deduplicateArrayFields(): void {
+    this.parsed.IN_APP_ORIGINAL_TRANSACTION_IDS = this.removeDuplicates(this.parsed.IN_APP_ORIGINAL_TRANSACTION_IDS)
+    this.parsed.IN_APP_TRANSACTION_IDS = this.removeDuplicates(this.parsed.IN_APP_TRANSACTION_IDS)
+  }
+
+  private removeDuplicates(array: string[]): string[] {
+    return [...new Set(array)]
+  }
+}
+
+export function parseReceipt(receipt: string): ParsedReceipt {
+  return new ReceiptParser().parseReceipt(receipt)
+}

package/src/ReceiptVerifier.ts

@@ -0,0 +1,69 @@
+import { Any, Constructed, Integer, ObjectIdentifier, OctetString, Sequence, Set, verifySchema } from 'asn1js'
+
+import { CONTENT_ID, FIELD_TYPE_ID, FIELD_VALUE_ID } from './constants'
+
+export class ReceiptVerifier {
+  private readonly receiptSchema: Sequence
+  private readonly fieldSchema: Sequence
+
+  constructor() {
+    this.receiptSchema = new Sequence({
+      value: [
+        new ObjectIdentifier(),
+        new Constructed({
+          idBlock: { tagClass: 3, tagNumber: 0 },
+          value: [
+            new Sequence({
+              value: [
+                new Integer(),
+                new Set({
+                  value: [
+                    new Sequence({
+                      value: [new ObjectIdentifier(), new Any()],
+                    }),
+                  ],
+                }),
+                new Sequence({
+                  value: [
+                    new ObjectIdentifier(),
+                    new Constructed({
+                      idBlock: { tagClass: 3, tagNumber: 0 },
+                      value: [new OctetString({ name: CONTENT_ID })],
+                    }),
+                  ],
+                }),
+              ],
+            }),
+          ],
+        }),
+      ],
+    })
+
+    this.fieldSchema = new Sequence({
+      value: [
+        new Integer({ name: FIELD_TYPE_ID }),
+        new Integer(),
+        new OctetString({ name: FIELD_VALUE_ID }),
+      ],
+    })
+  }
+
+  public verifyReceiptSchema(receipt: string) {
+    const receiptVerification = verifySchema(Buffer.from(receipt, 'base64'), this.receiptSchema)
+    if (!receiptVerification.verified) {
+      throw new Error('Receipt verification failed.')
+    }
+
+    return receiptVerification
+  }
+
+  public verifyFieldSchema(sequence: Sequence) {
+    const fieldVerification = verifySchema(sequence.toBER(), this.fieldSchema)
+    if (!fieldVerification.verified) {
+      // Return null if the field schema verification fails, so we can skip the field
+      return null
+    }
+
+    return fieldVerification
+  }
+}

package/src/constants.ts

@@ -9,3 +9,65 @@ export const FIELD_TYPE_ID: string = 'FieldType'
 
 /** Identifies field value information encoded as Octet string */
 export const FIELD_VALUE_ID: string = 'FieldTypeOctetString'
+
+export type ReceiptFieldsKeyValues =
+  | 0     // Environment
+  | 2     // Bundle ID
+  | 3     // App version
+  | 4     // Opaque value
+  | 5     // SHA-1 hash
+  | 12    // Receipt creation date
+  | 18    // Original purchase date
+  | 19    // Original app version
+  | 1701  // In-app quantity
+  | 1702  // In-app product ID
+  | 1703  // In-app transaction ID
+  | 1704  // In-app purchase date
+  | 1705  // In-app original transaction ID
+  | 1706  // In-app original purchase date
+  | 1708  // In-app expires date
+  | 1711  // In-app web order line item ID
+  | 1712  // In-app cancellation date
+
+export type ReceiptFieldsKeyNames =
+  | 'ENVIRONMENT'
+  | 'BUNDLE_ID'
+  | 'APP_VERSION'
+  | 'OPAQUE_VALUE'
+  | 'SHA1_HASH'
+  | 'RECEIPT_CREATION_DATE'
+  | 'ORIGINAL_PURCHASE_DATE'
+  | 'ORIGINAL_APP_VERSION'
+  | 'IN_APP_QUANTITY'
+  | 'IN_APP_PRODUCT_ID'
+  | 'IN_APP_TRANSACTION_ID'
+  | 'IN_APP_PURCHASE_DATE'
+  | 'IN_APP_ORIGINAL_TRANSACTION_ID'
+  | 'IN_APP_ORIGINAL_PURCHASE_DATE'
+  | 'IN_APP_EXPIRES_DATE'
+  | 'IN_APP_WEB_ORDER_LINE_ITEM_ID'
+  | 'IN_APP_CANCELLATION_DATE'
+
+/**
+ * Receipt fields
+ * @see https://developer.apple.com/library/archive/releasenotes/General/ValidateAppStoreReceipt/Chapters/ReceiptFields.html
+ */
+export const RECEIPT_FIELDS_MAP: ReadonlyMap<ReceiptFieldsKeyValues, ReceiptFieldsKeyNames> = new Map([
+  [0, 'ENVIRONMENT'],
+  [2, 'BUNDLE_ID'],
+  [3, 'APP_VERSION'],
+  [4, 'OPAQUE_VALUE'],
+  [5, 'SHA1_HASH'],
+  [12, 'RECEIPT_CREATION_DATE'],
+  [18, 'ORIGINAL_PURCHASE_DATE'],
+  [19, 'ORIGINAL_APP_VERSION'],
+  [1701, 'IN_APP_QUANTITY'],
+  [1702, 'IN_APP_PRODUCT_ID'],
+  [1703, 'IN_APP_TRANSACTION_ID'],
+  [1704, 'IN_APP_PURCHASE_DATE'],
+  [1705, 'IN_APP_ORIGINAL_TRANSACTION_ID'],
+  [1706, 'IN_APP_ORIGINAL_PURCHASE_DATE'],
+  [1708, 'IN_APP_EXPIRES_DATE'],
+  [1711, 'IN_APP_WEB_ORDER_LINE_ITEM_ID'],
+  [1712, 'IN_APP_CANCELLATION_DATE'],
+])

package/src/index.ts

@@ -1,2 +1,2 @@
-export type { ParsedReceipt } from './parser'
-export { parseReceipt } from './parser'
+export type { ParsedReceipt } from './ReceiptParser'
+export { parseReceipt } from './ReceiptParser'

package/tsconfig.json

@@ -6,7 +6,7 @@
     "esModuleInterop": true,
     "declaration": true,
     "outDir": "./dist",
-    "rootDir": "./src",
+    "rootDir": ".",
     "moduleResolution": "node"
   },
   "include": [

package/src/mappings.ts

@@ -1,61 +0,0 @@
-export type ReceiptFieldsKeyValues =
-  | 0     // Environment
-  | 2     // Bundle ID
-  | 3     // App version
-  | 4     // Opaque value
-  | 5     // SHA-1 hash
-  | 12    // Receipt creation date
-  | 18    // Original purchase date
-  | 19    // Original app version
-  | 1701  // In-app quantity
-  | 1702  // In-app product ID
-  | 1703  // In-app transaction ID
-  | 1704  // In-app purchase date
-  | 1705  // In-app original transaction ID
-  | 1706  // In-app original purchase date
-  | 1708  // In-app expires date
-  | 1711  // In-app web order line item ID
-  | 1712  // In-app cancellation date
-
-export type ReceiptFieldsKeyNames =
-  | 'ENVIRONMENT'
-  | 'BUNDLE_ID'
-  | 'APP_VERSION'
-  | 'OPAQUE_VALUE'
-  | 'SHA1_HASH'
-  | 'RECEIPT_CREATION_DATE'
-  | 'ORIGINAL_PURCHASE_DATE'
-  | 'ORIGINAL_APP_VERSION'
-  | 'IN_APP_QUANTITY'
-  | 'IN_APP_PRODUCT_ID'
-  | 'IN_APP_TRANSACTION_ID'
-  | 'IN_APP_PURCHASE_DATE'
-  | 'IN_APP_ORIGINAL_TRANSACTION_ID'
-  | 'IN_APP_ORIGINAL_PURCHASE_DATE'
-  | 'IN_APP_EXPIRES_DATE'
-  | 'IN_APP_WEB_ORDER_LINE_ITEM_ID'
-  | 'IN_APP_CANCELLATION_DATE'
-
-/**
- * Receipt fields
- * @see https://developer.apple.com/library/archive/releasenotes/General/ValidateAppStoreReceipt/Chapters/ReceiptFields.html
- */
-export const RECEIPT_FIELDS_MAP: ReadonlyMap<ReceiptFieldsKeyValues, ReceiptFieldsKeyNames> = new Map([
-  [0, 'ENVIRONMENT'],
-  [2, 'BUNDLE_ID'],
-  [3, 'APP_VERSION'],
-  [4, 'OPAQUE_VALUE'],
-  [5, 'SHA1_HASH'],
-  [12, 'RECEIPT_CREATION_DATE'],
-  [18, 'ORIGINAL_PURCHASE_DATE'],
-  [19, 'ORIGINAL_APP_VERSION'],
-  [1701, 'IN_APP_QUANTITY'],
-  [1702, 'IN_APP_PRODUCT_ID'],
-  [1703, 'IN_APP_TRANSACTION_ID'],
-  [1704, 'IN_APP_PURCHASE_DATE'],
-  [1705, 'IN_APP_ORIGINAL_TRANSACTION_ID'],
-  [1706, 'IN_APP_ORIGINAL_PURCHASE_DATE'],
-  [1708, 'IN_APP_EXPIRES_DATE'],
-  [1711, 'IN_APP_WEB_ORDER_LINE_ITEM_ID'],
-  [1712, 'IN_APP_CANCELLATION_DATE'],
-])

package/src/parser.ts

@@ -1,116 +0,0 @@
-import * as ASN1 from 'asn1js'
-
-import { RECEIPT_FIELDS_MAP, ReceiptFieldsKeyNames, ReceiptFieldsKeyValues } from './mappings'
-import { CONTENT_ID, FIELD_TYPE_ID, FIELD_VALUE_ID, IN_APP } from './constants'
-import { verifyFieldSchema, verifyReceiptSchema } from './verifications'
-
-export type Environment = 'Production' | 'ProductionSandbox' | string
-
-const uniqueArrayValues = (array: string[]) => Array.from(new Set(array))
-
-export type ParsedReceipt = Partial<Record<ReceiptFieldsKeyNames, string>> & {
-  ENVIRONMENT: Environment
-  IN_APP_ORIGINAL_TRANSACTION_IDS: string[]
-  IN_APP_TRANSACTION_IDS: string[]
-}
-
-function isReceiptFieldKey (value: unknown): value is ReceiptFieldsKeyValues {
-  return Boolean(typeof value === 'number' && RECEIPT_FIELDS_MAP.has(value as ReceiptFieldsKeyValues))
-}
-
-function isParsedReceiptContentComplete (data: ParsedReceipt): data is ParsedReceipt {
-  for (const fieldKey of RECEIPT_FIELDS_MAP.values()) {
-    if (!(fieldKey in data)) {
-      return false
-    }
-  }
-
-  return true
-}
-
-function extractFieldValue (field: ASN1.OctetString): string {
-  const [fieldValue] = field.valueBlock.value
-
-  if (fieldValue instanceof ASN1.IA5String || fieldValue instanceof ASN1.Utf8String) {
-    return fieldValue.valueBlock.value
-  }
-
-  return field.toJSON().valueBlock.valueHex
-}
-
-function appendField (parsed: ParsedReceipt, name: ReceiptFieldsKeyNames, value: string) {
-  if (name === 'IN_APP_ORIGINAL_TRANSACTION_ID') {
-    parsed.IN_APP_ORIGINAL_TRANSACTION_IDS.push(value)
-  }
-
-  if (name === 'IN_APP_TRANSACTION_ID') {
-    parsed.IN_APP_TRANSACTION_IDS.push(value)
-  }
-
-  parsed[name] = value
-}
-
-function processField (parsed: ParsedReceipt, fieldKey: number, fieldValue: ASN1.OctetString) {
-  if (fieldKey === IN_APP) {
-    parseOctetStringContent(parsed, fieldValue)
-    return
-  }
-
-  if (!isReceiptFieldKey(fieldKey)) {
-    return
-  }
-
-  const name = RECEIPT_FIELDS_MAP.get(fieldKey)!
-  appendField(parsed, name, extractFieldValue(fieldValue))
-}
-
-function parseOctetStringContent (parsed: ParsedReceipt, content: ASN1.OctetString) {
-  const [contentSet] = content.valueBlock.value as ASN1.Set[]
-  const contentSetSequences = contentSet.valueBlock.value
-    .filter(v => v instanceof ASN1.Sequence) as ASN1.Sequence[]
-
-  for (const sequence of contentSetSequences) {
-    const verifiedSequence = verifyFieldSchema(sequence)
-    if (verifiedSequence) {
-      // We are confident to use "as" assertion because Integer type is guaranteed by positive verification above
-      const fieldKey = (verifiedSequence.result[FIELD_TYPE_ID] as ASN1.Integer).valueBlock.valueDec
-      const fieldValueOctetString = verifiedSequence.result[FIELD_VALUE_ID] as ASN1.OctetString
-
-      processField(parsed, fieldKey, fieldValueOctetString)
-    }
-  }
-}
-
-function postprocessParsedReceipt (parsed: ParsedReceipt) {
-  parsed.IN_APP_ORIGINAL_TRANSACTION_IDS = uniqueArrayValues(parsed.IN_APP_ORIGINAL_TRANSACTION_IDS)
-  parsed.IN_APP_TRANSACTION_IDS = uniqueArrayValues(parsed.IN_APP_TRANSACTION_IDS)
-}
-
-export function parseReceipt (receipt: string): ParsedReceipt {
-  const rootSchemaVerification = verifyReceiptSchema(receipt)
-
-  const content = rootSchemaVerification.result[CONTENT_ID] as ASN1.OctetString
-  const parsed: ParsedReceipt = {
-    ENVIRONMENT: 'Production',
-    IN_APP_ORIGINAL_TRANSACTION_IDS: [],
-    IN_APP_TRANSACTION_IDS: [],
-  }
-
-  parseOctetStringContent(parsed, content)
-
-  // Verify if the parsed content contains all the required fields
-  if (!isParsedReceiptContentComplete(parsed)) {
-    const missingProps = []
-    for (const fieldKey of RECEIPT_FIELDS_MAP.values()) {
-      if (!(fieldKey in parsed)) {
-        missingProps.push(fieldKey)
-      }
-    }
-
-    throw new Error(`Missing required fields: ${missingProps.join(', ')}`)
-  }
-
-  postprocessParsedReceipt(parsed)
-
-  return parsed as ParsedReceipt
-}

package/src/utils.ts

@@ -1 +0,0 @@
-

package/src/verifications.ts

@@ -1,62 +0,0 @@
-import { Any, Constructed, Integer, ObjectIdentifier, OctetString, Sequence, Set, verifySchema } from 'asn1js'
-
-import { CONTENT_ID, FIELD_TYPE_ID, FIELD_VALUE_ID } from './constants'
-
-const receiptSchema = new Sequence({
-  value: [
-    new ObjectIdentifier(),
-    new Constructed({
-      idBlock: { tagClass: 3, tagNumber: 0 },
-      value: [
-        new Sequence({
-          value: [
-            new Integer(),
-            new Set({
-              value: [
-                new Sequence({
-                  value: [new ObjectIdentifier(), new Any()],
-                }),
-              ],
-            }),
-            new Sequence({
-              value: [
-                new ObjectIdentifier(),
-                new Constructed({
-                  idBlock: { tagClass: 3, tagNumber: 0 },
-                  value: [new OctetString({ name: CONTENT_ID })],
-                }),
-              ],
-            }),
-          ],
-        }),
-      ],
-    }),
-  ],
-})
-
-const fieldSchema = new Sequence({
-  value: [
-    new Integer({ name: FIELD_TYPE_ID }),
-    new Integer(),
-    new OctetString({ name: FIELD_VALUE_ID }),
-  ],
-})
-
-export function verifyReceiptSchema (receipt: string) {
-  const receiptVerification = verifySchema(Buffer.from(receipt, 'base64'), receiptSchema)
-  if (!receiptVerification.verified) {
-    throw new Error('Receipt verification failed.')
-  }
-
-  return receiptVerification
-}
-
-export function verifyFieldSchema (sequence: Sequence) {
-  const fieldVerification = verifySchema(sequence.toBER(), fieldSchema)
-  if (!fieldVerification.verified) {
-    // Return null if the field schema verification fails, so we can skip the field
-    return null
-  }
-
-  return fieldVerification
-}