@henrylabs-interview/payment-processor 0.1.6 → 0.1.8

package/dist/index.js

@@ -1,487 +1,17 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  default: () => HenryPaymentProcessorSDK
-});
-module.exports = __toCommonJS(exports_src);
-
-// src/utils/store.ts
-var path = new URL("../db-store/history.json", "file:///Users/aaroncassar/Projects/take-home/src/utils/store.ts");
-async function readHistory() {
-  const file = Bun.file(path);
-  if (!await file.exists()) {
-    return [];
-  }
-  const text = await file.text();
-  if (!text)
-    return [];
-  try {
-    return JSON.parse(text);
-  } catch {
-    return [];
-  }
-}
-
-// src/utils/crypto.ts
-var import_crypto = __toESM(require("crypto"));
-function generateID(length = 12) {
-  const digits = [];
-  const bytes = import_crypto.default.randomBytes(length);
-  for (let i = 0;i < length; i++) {
-    digits.push((bytes[i] ?? 0) % 10);
-  }
-  return parseInt(digits.join(""));
-}
-function hashToNumber(input, length = 12) {
-  if (length > 16) {
-    throw new Error("Length is greater than max length of 16!");
-  }
-  const hash = import_crypto.default.createHash("sha256").update(input).digest("hex");
-  return parseInt(hash.slice(0, length), 16);
-}
-function signPayload(payload, secret) {
-  return import_crypto.default.createHmac("sha256", secret).update(payload).digest("hex");
-}
-
-// src/utils/async.ts
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-// src/resources/webhooks.ts
-var INTERNAL_WEBHOOKS = [];
-
-class Webhooks {
-  async createEndpoint(params) {
-    for (const event of params.events) {
-      await sleep(Math.random() * 100);
-      INTERNAL_WEBHOOKS.push({
-        url: params.url,
-        event,
-        secret: params.secret
-      });
-    }
-    return true;
-  }
-}
-
-// src/resources/checkout.ts
-var INTERNAL_CHECKOUTS = {};
-var INTERNAL_CARDS = {};
-
-class Checkout {
-  async create(params) {
-    await sleep(Math.random() * 100);
-    const hashId = this.buildHistoryHash(params);
-    const history = await readHistory();
-    const sameRecords = history.filter((v) => v.id === hashId);
-    const validationFailure = this.validateCreate(params);
-    const response = validationFailure ?? this.processCreateDecision(params, hashId, sameRecords.length);
-    this.scheduleCreateWebhook(hashId, response);
-    await sleep(Math.random() * 2000);
-    return response;
-  }
-  async confirm(params) {
-    await sleep(Math.random() * 100);
-    const validationFailure = await this.validateConfirm(params);
-    const response = validationFailure ?? await this.processConfirmDecision(params);
-    this.scheduleConfirmWebhook(params, response);
-    await sleep(Math.random() * 2000);
-    return response;
-  }
-  validateCreate(params) {
-    if (params.amount <= 0) {
-      return {
-        status: "failure",
-        substatus: "500-error",
-        code: 500,
-        message: "Invalid amount"
-      };
-    }
-    if (params.currency === "JPY") {
-      return {
-        status: "failure",
-        substatus: "501-not-supported",
-        code: 501,
-        message: "This currency is currently not supported, please convert first."
-      };
-    }
-    if (Math.random() > 0.85) {
-      return {
-        status: "failure",
-        substatus: "500-error",
-        code: 500,
-        message: "An internal error occurred when creating checkout"
-      };
-    }
-    return null;
-  }
-  processCreateDecision(params, hashId, duplicateCount) {
-    const resCase = this.determineResponseCase(params.amount, duplicateCount);
-    if (resCase === "failure-retry") {
-      return {
-        status: "failure",
-        substatus: "503-retry",
-        code: 503,
-        message: "Server is busy, please retry the request"
-      };
-    }
-    if (resCase === "failure-fraud") {
-      return {
-        status: "failure",
-        substatus: "502-fraud",
-        code: 502,
-        message: "Potential fraud detected with this purchase"
-      };
-    }
-    const checkoutId = this.createCheckoutRecord(hashId);
-    if (resCase === "success-deferred") {
-      return {
-        status: "success",
-        substatus: "202-deferred",
-        code: 202,
-        message: "Authorizing, checkout information will likely be returned via webhook"
-      };
-    }
-    return {
-      status: "success",
-      substatus: "201-immediate",
-      code: 201,
-      message: "Approved",
-      data: {
-        checkoutId,
-        paymentMethodOptions: ["embedded", "raw-card"]
-      }
-    };
-  }
-  createCheckoutRecord(hashId) {
-    const checkoutId = generateID();
-    INTERNAL_CHECKOUTS[checkoutId] = {
-      historyRecordId: hashId
-    };
-    return checkoutId;
-  }
-  scheduleCreateWebhook(hashId, response) {
-    const webhookDelay = Math.random() * 3000;
-    setTimeout(() => {
-      if (response.status === "success" && response.substatus === "202-deferred") {
-        const isSuccess = Math.random() > 0.35;
-        if (isSuccess) {
-          const checkoutId = this.createCheckoutRecord(hashId);
-          this.sendWebhookResponse("checkout.create", {
-            status: "success",
-            substatus: "201-immediate",
-            code: 201,
-            message: "Approved",
-            data: {
-              checkoutId,
-              paymentMethodOptions: ["embedded", "raw-card"]
-            }
-          });
-        } else {
-          this.sendWebhookResponse("checkout.create", {
-            status: "failure",
-            substatus: "502-fraud",
-            code: 502,
-            message: "Potential fraud detected with this purchase"
-          });
+import { Checkout } from './resources/checkout';
+import { Webhooks } from './resources/webhooks';
+export default class HenryPaymentProcessorSDK {
+    checkout;
+    webhooks;
+    VALID_API_KEYS = ['824c951e-dfac-4342-8e03', '3f67e17a-880a-463b-a667', '78254d40-623a-48c5-b83f'];
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('Henry: apiKey is required');
         }
-        return;
-      }
-      this.sendWebhookResponse("checkout.create", response);
-    }, webhookDelay);
-  }
-  buildHistoryHash(params) {
-    return hashToNumber(JSON.stringify({
-      type: "HISTORY_RECORD",
-      amount: params.amount,
-      currency: params.currency,
-      customerId: params.customerId
-    }));
-  }
-  async validateConfirm(params) {
-    if (!INTERNAL_CHECKOUTS[params.checkoutId]) {
-      return {
-        status: "failure",
-        substatus: "500-error",
-        code: 500,
-        message: "Invalid checkout ID"
-      };
-    }
-    if (params.type === "embedded") {
-      const stored = INTERNAL_CARDS[params.data.paymentToken];
-      if (!stored) {
-        return {
-          status: "failure",
-          substatus: "500-error",
-          code: 500,
-          message: "Invalid payment token"
-        };
-      }
-    }
-    if (params.type === "raw-card") {
-      const { number, expMonth, expYear, cvc } = params.data;
-      if (!this.isValidCardNumber(number)) {
-        return {
-          status: "failure",
-          substatus: "502-fraud",
-          code: 502,
-          message: "Invalid card number"
-        };
-      }
-      if (!this.isValidExpiry(expMonth, expYear)) {
-        return {
-          status: "failure",
-          substatus: "503-retry",
-          code: 503,
-          message: "Card expired"
-        };
-      }
-      if (!/^\d{3,4}$/.test(cvc)) {
-        return {
-          status: "failure",
-          substatus: "502-fraud",
-          code: 502,
-          message: "Invalid CVC"
-        };
-      }
-    }
-    return null;
-  }
-  async processConfirmDecision(params) {
-    const decision = Math.random();
-    if (decision > 0.85) {
-      return {
-        status: "failure",
-        substatus: "502-fraud",
-        code: 502,
-        message: "Potential fraud detected with this purchase"
-      };
-    }
-    if (decision > 0.65) {
-      return {
-        status: "failure",
-        substatus: "503-retry",
-        code: 503,
-        message: "Server is busy, please retry the request"
-      };
-    }
-    if (decision > 0.35) {
-      return {
-        status: "success",
-        substatus: "202-deferred",
-        code: 202,
-        message: "Authorizing, purchase information will likely be returned via webhook"
-      };
-    }
-    return this.buildInstantConfirmSuccess(params.checkoutId);
-  }
-  async buildInstantConfirmSuccess(checkoutId) {
-    const { historyRecordId } = INTERNAL_CHECKOUTS[checkoutId] ?? {};
-    if (!historyRecordId) {
-      return {
-        status: "failure",
-        substatus: "500-error",
-        code: 500,
-        message: "Missing history record"
-      };
-    }
-    const history = await readHistory();
-    const record = history.find((v) => v.id === historyRecordId);
-    if (!record) {
-      return {
-        status: "failure",
-        substatus: "500-error",
-        code: 500,
-        message: "Missing history record"
-      };
-    }
-    const confirmationId = hashToNumber(JSON.stringify({
-      type: "CONFIRMATION_ID",
-      amount: record.amount,
-      currency: record.currency,
-      customerId: record.customerId
-    }));
-    return {
-      status: "success",
-      substatus: "201-immediate",
-      code: 201,
-      message: "Approved",
-      data: {
-        confirmationId,
-        amount: record.amount,
-        currency: record.currency,
-        customerId: record.customerId ?? undefined
-      }
-    };
-  }
-  scheduleConfirmWebhook(params, response) {
-    const webhookDelay = Math.random() * 3000;
-    setTimeout(() => {
-      if (response.status === "success" && response.substatus === "202-deferred") {
-        const isSuccess = Math.random() > 0.35;
-        if (isSuccess) {
-          this.buildInstantConfirmSuccess(params.checkoutId).then((finalResponse) => {
-            this.sendWebhookResponse("checkout.confirm", finalResponse);
-          });
-        } else {
-          this.sendWebhookResponse("checkout.confirm", {
-            status: "failure",
-            substatus: "502-fraud",
-            code: 502,
-            message: "Potential fraud detected with this purchase"
-          });
+        if (!this.VALID_API_KEYS.includes(config.apiKey)) {
+            throw new Error('Henry: Invalid apiKey provided');
         }
-        return;
-      }
-      this.sendWebhookResponse("checkout.confirm", response);
-    }, webhookDelay);
-  }
-  isValidCardNumber(number) {
-    if (number === "4242424242424242")
-      return true;
-    if (!/^\d{13,19}$/.test(number))
-      return false;
-    let sum = 0;
-    let shouldDouble = false;
-    for (let i = number.length - 1;i >= 0; i--) {
-      let digit = parseInt(number[i] ?? "");
-      if (shouldDouble) {
-        digit *= 2;
-        if (digit > 9)
-          digit -= 9;
-      }
-      sum += digit;
-      shouldDouble = !shouldDouble;
-    }
-    return sum % 10 === 0;
-  }
-  isValidExpiry(month, year) {
-    if (month < 1 || month > 12)
-      return false;
-    const now = new Date;
-    const expiry = new Date(year, month - 1);
-    return expiry > now;
-  }
-  determineResponseCase(amount, sameRecords) {
-    let immediateWeight = 65;
-    let deferredWeight = 20;
-    let retryWeight = 10;
-    let fraudWeight = 5;
-    immediateWeight -= sameRecords * 10;
-    deferredWeight += sameRecords * 5;
-    retryWeight += sameRecords * 5;
-    fraudWeight += sameRecords * 5;
-    if (amount > 1000) {
-      deferredWeight += 10;
-      retryWeight += 5;
-    }
-    if (amount > 5000) {
-      immediateWeight -= 10;
-      retryWeight += 10;
-      fraudWeight += 10;
-    }
-    if (amount > 1e4) {
-      fraudWeight += 20;
-    }
-    immediateWeight = Math.max(0, immediateWeight);
-    deferredWeight = Math.max(0, deferredWeight);
-    retryWeight = Math.max(0, retryWeight);
-    fraudWeight = Math.max(0, fraudWeight);
-    const total = immediateWeight + deferredWeight + retryWeight + fraudWeight;
-    const rand = Math.random() * total;
-    if (rand < immediateWeight) {
-      return "success-immediate";
-    }
-    if (rand < immediateWeight + deferredWeight) {
-      return "success-deferred";
-    }
-    if (rand < immediateWeight + deferredWeight + retryWeight) {
-      return "failure-retry";
-    }
-    return "failure-fraud";
-  }
-  async sendWebhookResponse(baseType, response) {
-    const statusSuffix = response.status === "success" ? "success" : "failure";
-    const eventType = `${baseType}.${statusSuffix}`;
-    const matchingTypes = ["checkout", baseType, eventType];
-    const hooks = INTERNAL_WEBHOOKS.filter((w) => matchingTypes.includes(w.event));
-    const event = {
-      id: crypto.randomUUID(),
-      type: eventType,
-      createdAt: Date.now(),
-      data: response
-    };
-    const payload = JSON.stringify(event);
-    await Promise.allSettled(hooks.map(async (hook) => {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (hook.secret) {
-        headers["webhook-signature"] = signPayload(payload, hook.secret);
-      }
-      await fetch(hook.url, {
-        method: "POST",
-        headers,
-        body: payload
-      });
-    }));
-    return true;
-  }
-}
-
-// src/index.ts
-class HenryPaymentProcessorSDK {
-  checkout;
-  webhooks;
-  VALID_API_KEYS = ["824c951e-dfac-4342-8e03", "3f67e17a-880a-463b-a667", "78254d40-623a-48c5-b83f"];
-  constructor(config) {
-    if (!config.apiKey) {
-      throw new Error("Henry: apiKey is required");
-    }
-    if (!this.VALID_API_KEYS.includes(config.apiKey)) {
-      throw new Error("Henry: Invalid apiKey provided");
+        this.checkout = new Checkout();
+        this.webhooks = new Webhooks();
     }
-    this.checkout = new Checkout;
-    this.webhooks = new Webhooks;
-  }
 }

package/dist/resources/checkout.js

@@ -0,0 +1,416 @@
+import { readHistory } from '../utils/store';
+import { generateID, hashToNumber, signPayload } from '../utils/crypto';
+import { INTERNAL_WEBHOOKS } from './webhooks';
+import { sleep } from '../utils/async';
+// checkoutId -> { historyRecordId }
+const INTERNAL_CHECKOUTS = {};
+// paymentToken -> card details
+const INTERNAL_CARDS = {};
+export class Checkout {
+    /**
+     * Create a new checkout session
+     * @param amount - The amount for the checkout
+     * @param currency - The curreny type (note: not all are supported atm)
+     * @param customerId - Optional customer ID, used for unique customer identification
+     * @returns The response from the checkout creation
+     */
+    async create(params) {
+        await sleep(Math.random() * 100);
+        const hashId = this.buildHistoryHash(params);
+        const history = await readHistory();
+        const sameRecords = history.filter((v) => v.id === hashId);
+        // ---------------------------------------
+        // Phase 1: Validation
+        // ---------------------------------------
+        const validationFailure = this.validateCreate(params);
+        // ---------------------------------------
+        // Phase 2: Business Logic
+        // ---------------------------------------
+        const response = validationFailure ?? this.processCreateDecision(params, hashId, sameRecords.length);
+        // ---------------------------------------
+        // Phase 3: Webhook Scheduling
+        // ---------------------------------------
+        this.scheduleCreateWebhook(hashId, response);
+        // Simulate API latency
+        await sleep(Math.random() * 2000);
+        return response;
+    }
+    /**
+     * Confirm a checkout session
+     * @param params - Either embedded or raw card checkout confirmation parameters
+     * @returns - The response from the checkout confirmation
+     */
+    async confirm(params) {
+        await sleep(Math.random() * 100);
+        // ---------------------------------------
+        // Phase 1: Validation (no early returns)
+        // ---------------------------------------
+        const validationFailure = await this.validateConfirm(params);
+        // ---------------------------------------
+        // Phase 2: Business Logic
+        // ---------------------------------------
+        const response = validationFailure ?? (await this.processConfirmDecision(params));
+        // ---------------------------------------
+        // Phase 3: Async Webhook Emission
+        // ---------------------------------------
+        this.scheduleConfirmWebhook(params, response);
+        // Simulate response delay
+        await sleep(Math.random() * 2000);
+        return response;
+    }
+    validateCreate(params) {
+        if (params.amount <= 0) {
+            return {
+                status: 'failure',
+                substatus: '500-error',
+                code: 500,
+                message: 'Invalid amount',
+            };
+        }
+        if (params.currency === 'JPY') {
+            return {
+                status: 'failure',
+                substatus: '501-not-supported',
+                code: 501,
+                message: 'This currency is currently not supported, please convert first.',
+            };
+        }
+        // Simulated random internal failure
+        if (Math.random() > 0.85) {
+            return {
+                status: 'failure',
+                substatus: '500-error',
+                code: 500,
+                message: 'An internal error occurred when creating checkout',
+            };
+        }
+        return null;
+    }
+    processCreateDecision(params, hashId, duplicateCount) {
+        const resCase = this.determineResponseCase(params.amount, duplicateCount);
+        if (resCase === 'failure-retry') {
+            return {
+                status: 'failure',
+                substatus: '503-retry',
+                code: 503,
+                message: 'Server is busy, please retry the request',
+            };
+        }
+        if (resCase === 'failure-fraud') {
+            return {
+                status: 'failure',
+                substatus: '502-fraud',
+                code: 502,
+                message: 'Potential fraud detected with this purchase',
+            };
+        }
+        const checkoutId = this.createCheckoutRecord(hashId);
+        if (resCase === 'success-deferred') {
+            return {
+                status: 'success',
+                substatus: '202-deferred',
+                code: 202,
+                message: 'Authorizing, checkout information will likely be returned via webhook',
+            };
+        }
+        return {
+            status: 'success',
+            substatus: '201-immediate',
+            code: 201,
+            message: 'Approved',
+            data: {
+                checkoutId,
+                paymentMethodOptions: ['embedded', 'raw-card'],
+            },
+        };
+    }
+    createCheckoutRecord(hashId) {
+        const checkoutId = generateID();
+        INTERNAL_CHECKOUTS[checkoutId] = {
+            historyRecordId: hashId,
+        };
+        return checkoutId;
+    }
+    scheduleCreateWebhook(hashId, response) {
+        const webhookDelay = Math.random() * 3000;
+        setTimeout(() => {
+            // Deferred flow resolves later
+            if (response.status === 'success' && response.substatus === '202-deferred') {
+                const isSuccess = Math.random() > 0.35;
+                if (isSuccess) {
+                    const checkoutId = this.createCheckoutRecord(hashId);
+                    this.sendWebhookResponse('checkout.create', {
+                        status: 'success',
+                        substatus: '201-immediate',
+                        code: 201,
+                        message: 'Approved',
+                        data: {
+                            checkoutId,
+                            paymentMethodOptions: ['embedded', 'raw-card'],
+                        },
+                    });
+                }
+                else {
+                    this.sendWebhookResponse('checkout.create', {
+                        status: 'failure',
+                        substatus: '502-fraud',
+                        code: 502,
+                        message: 'Potential fraud detected with this purchase',
+                    });
+                }
+                return;
+            }
+            // Immediate success or failure
+            this.sendWebhookResponse('checkout.create', response);
+        }, webhookDelay);
+    }
+    buildHistoryHash(params) {
+        return hashToNumber(JSON.stringify({
+            type: 'HISTORY_RECORD',
+            amount: params.amount,
+            currency: params.currency,
+            customerId: params.customerId,
+        }));
+    }
+    ///
+    async validateConfirm(params) {
+        if (!INTERNAL_CHECKOUTS[params.checkoutId]) {
+            return {
+                status: 'failure',
+                substatus: '500-error',
+                code: 500,
+                message: 'Invalid checkout ID',
+            };
+        }
+        if (params.type === 'embedded') {
+            const stored = INTERNAL_CARDS[params.data.paymentToken];
+            if (!stored) {
+                return {
+                    status: 'failure',
+                    substatus: '500-error',
+                    code: 500,
+                    message: 'Invalid payment token',
+                };
+            }
+        }
+        if (params.type === 'raw-card') {
+            const { number, expMonth, expYear, cvc } = params.data;
+            if (!this.isValidCardNumber(number)) {
+                return {
+                    status: 'failure',
+                    substatus: '502-fraud',
+                    code: 502,
+                    message: 'Invalid card number',
+                };
+            }
+            if (!this.isValidExpiry(expMonth, expYear)) {
+                return {
+                    status: 'failure',
+                    substatus: '503-retry',
+                    code: 503,
+                    message: 'Card expired',
+                };
+            }
+            if (!/^\d{3,4}$/.test(cvc)) {
+                return {
+                    status: 'failure',
+                    substatus: '502-fraud',
+                    code: 502,
+                    message: 'Invalid CVC',
+                };
+            }
+        }
+        return null;
+    }
+    async processConfirmDecision(params) {
+        const decision = Math.random();
+        if (decision > 0.85) {
+            return {
+                status: 'failure',
+                substatus: '502-fraud',
+                code: 502,
+                message: 'Potential fraud detected with this purchase',
+            };
+        }
+        if (decision > 0.65) {
+            return {
+                status: 'failure',
+                substatus: '503-retry',
+                code: 503,
+                message: 'Server is busy, please retry the request',
+            };
+        }
+        if (decision > 0.35) {
+            return {
+                status: 'success',
+                substatus: '202-deferred',
+                code: 202,
+                message: 'Authorizing, purchase information will likely be returned via webhook',
+            };
+        }
+        return this.buildInstantConfirmSuccess(params.checkoutId);
+    }
+    async buildInstantConfirmSuccess(checkoutId) {
+        const { historyRecordId } = INTERNAL_CHECKOUTS[checkoutId] ?? {};
+        if (!historyRecordId) {
+            return {
+                status: 'failure',
+                substatus: '500-error',
+                code: 500,
+                message: 'Missing history record',
+            };
+        }
+        const history = await readHistory();
+        const record = history.find((v) => v.id === historyRecordId);
+        if (!record) {
+            return {
+                status: 'failure',
+                substatus: '500-error',
+                code: 500,
+                message: 'Missing history record',
+            };
+        }
+        const confirmationId = hashToNumber(JSON.stringify({
+            type: 'CONFIRMATION_ID',
+            amount: record.amount,
+            currency: record.currency,
+            customerId: record.customerId,
+        }));
+        return {
+            status: 'success',
+            substatus: '201-immediate',
+            code: 201,
+            message: 'Approved',
+            data: {
+                confirmationId,
+                amount: record.amount,
+                currency: record.currency,
+                customerId: record.customerId ?? undefined,
+            },
+        };
+    }
+    scheduleConfirmWebhook(params, response) {
+        const webhookDelay = Math.random() * 3000;
+        setTimeout(() => {
+            if (response.status === 'success' && response.substatus === '202-deferred') {
+                const isSuccess = Math.random() > 0.35;
+                if (isSuccess) {
+                    this.buildInstantConfirmSuccess(params.checkoutId).then((finalResponse) => {
+                        this.sendWebhookResponse('checkout.confirm', finalResponse);
+                    });
+                }
+                else {
+                    this.sendWebhookResponse('checkout.confirm', {
+                        status: 'failure',
+                        substatus: '502-fraud',
+                        code: 502,
+                        message: 'Potential fraud detected with this purchase',
+                    });
+                }
+                return;
+            }
+            this.sendWebhookResponse('checkout.confirm', response);
+        }, webhookDelay);
+    }
+    //
+    isValidCardNumber(number) {
+        // Test card is valid
+        if (number === '4242424242424242')
+            return true;
+        // Cards must be 13-19 digits
+        if (!/^\d{13,19}$/.test(number))
+            return false;
+        // Luhn check
+        let sum = 0;
+        let shouldDouble = false;
+        for (let i = number.length - 1; i >= 0; i--) {
+            let digit = parseInt(number[i] ?? '');
+            if (shouldDouble) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            shouldDouble = !shouldDouble;
+        }
+        return sum % 10 === 0;
+    }
+    isValidExpiry(month, year) {
+        if (month < 1 || month > 12)
+            return false;
+        const now = new Date();
+        const expiry = new Date(year, month - 1);
+        return expiry > now;
+    }
+    determineResponseCase(amount, sameRecords) {
+        // --- Base probabilities ---
+        let immediateWeight = 65;
+        let deferredWeight = 20;
+        let retryWeight = 10;
+        let fraudWeight = 5;
+        // --- Adjust based on repeated attempts ---
+        immediateWeight -= sameRecords * 10;
+        deferredWeight += sameRecords * 5;
+        retryWeight += sameRecords * 5;
+        fraudWeight += sameRecords * 5;
+        // --- Adjust based on amount ---
+        if (amount > 1000) {
+            deferredWeight += 10;
+            retryWeight += 5;
+        }
+        if (amount > 5000) {
+            immediateWeight -= 10;
+            retryWeight += 10;
+            fraudWeight += 10;
+        }
+        if (amount > 10000) {
+            fraudWeight += 20;
+        }
+        // Ensure no negative weights
+        immediateWeight = Math.max(0, immediateWeight);
+        deferredWeight = Math.max(0, deferredWeight);
+        retryWeight = Math.max(0, retryWeight);
+        fraudWeight = Math.max(0, fraudWeight);
+        // --- Weighted random selection ---
+        const total = immediateWeight + deferredWeight + retryWeight + fraudWeight;
+        const rand = Math.random() * total;
+        if (rand < immediateWeight) {
+            return 'success-immediate';
+        }
+        if (rand < immediateWeight + deferredWeight) {
+            return 'success-deferred';
+        }
+        if (rand < immediateWeight + deferredWeight + retryWeight) {
+            return 'failure-retry';
+        }
+        return 'failure-fraud';
+    }
+    async sendWebhookResponse(baseType, response) {
+        const statusSuffix = response.status === 'success' ? 'success' : 'failure';
+        const eventType = `${baseType}.${statusSuffix}`;
+        // Build all matching event types hierarchically
+        const matchingTypes = ['checkout', baseType, eventType];
+        const hooks = INTERNAL_WEBHOOKS.filter((w) => matchingTypes.includes(w.event));
+        const event = {
+            id: crypto.randomUUID(),
+            type: eventType,
+            createdAt: Date.now(),
+            data: response,
+        };
+        const payload = JSON.stringify(event);
+        await Promise.allSettled(hooks.map(async (hook) => {
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (hook.secret) {
+                headers['webhook-signature'] = signPayload(payload, hook.secret);
+            }
+            await fetch(hook.url, {
+                method: 'POST',
+                headers,
+                body: payload,
+            });
+        }));
+        return true;
+    }
+}

package/dist/resources/webhooks.js

@@ -0,0 +1,20 @@
+import { sleep } from '../utils/async';
+export const INTERNAL_WEBHOOKS = [];
+export class Webhooks {
+    /**
+     * Registers a new webhook endpoint for the specified events
+     * @param params - The webhook parameters including URL, events, and optional secret
+     * @returns A promise that resolves to a boolean indicating successful registration
+     */
+    async createEndpoint(params) {
+        for (const event of params.events) {
+            await sleep(Math.random() * 100);
+            INTERNAL_WEBHOOKS.push({
+                url: params.url,
+                event: event,
+                secret: params.secret,
+            });
+        }
+        return true;
+    }
+}

package/dist/utils/async.js

@@ -0,0 +1 @@
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/dist/utils/crypto.js

@@ -0,0 +1,19 @@
+import crypto from 'crypto';
+export function generateID(length = 12) {
+    const digits = [];
+    const bytes = crypto.randomBytes(length);
+    for (let i = 0; i < length; i++) {
+        digits.push((bytes[i] ?? 0) % 10);
+    }
+    return parseInt(digits.join(''));
+}
+export function hashToNumber(input, length = 12) {
+    if (length > 16) {
+        throw new Error('Length is greater than max length of 16!');
+    }
+    const hash = crypto.createHash('sha256').update(input).digest('hex');
+    return parseInt(hash.slice(0, length), 16);
+}
+export function signPayload(payload, secret) {
+    return crypto.createHmac('sha256', secret).update(payload).digest('hex');
+}

package/dist/utils/store.js

@@ -0,0 +1,32 @@
+const path = new URL('../db-store/history.json', import.meta.url);
+/**
+ * Reads all history records from the JSON store.
+ */
+export async function readHistory() {
+    const file = Bun.file(path);
+    if (!(await file.exists())) {
+        return [];
+    }
+    const text = await file.text();
+    if (!text)
+        return [];
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Writes a new record to the JSON store.
+ */
+export async function writeHistory(params) {
+    const history = await readHistory();
+    const newRecord = {
+        updatedAt: new Date().getTime(),
+        ...params,
+    };
+    history.push(newRecord);
+    await Bun.write(path, JSON.stringify(history, null, 2));
+    return newRecord;
+}

package/package.json

@@ -1,22 +1,20 @@
 {
 	"name": "@henrylabs-interview/payment-processor",
-	"version": "0.1.6",
+	"version": "0.1.8",
 	"type": "module",
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.mjs",
+	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
-			"import": "./dist/index.mjs",
-			"require": "./dist/index.cjs"
+			"default": "./dist/index.js"
 		}
 	},
 	"files": [
 		"dist"
 	],
 	"scripts": {
-		"build": "bun run build.ts && bunx tsc -p tsconfig.build.json",
+		"build": "rm -rf dist && bunx tsc -p tsconfig.build.json",
 		"dev": "bun run src/index.ts",
 		"publish": "bun run build && npm publish --access public"
 	},