@unloq/unloq-code-validtor 1.0.0

package/dist/__tests__/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/index.test.js

@@ -0,0 +1,151 @@
+import { validateUnloqDiscountCode } from '../index';
+import { Reason } from '../interface/reason';
+import { getSHA256Hash } from '../utils/hash';
+describe('validateGiftCardCode', () => {
+    const tests = [
+        {
+            name: "invalid fealtyx code, first 2 of last 4 characters don't match last 2",
+            domain: "example.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "FLX1234ABCD",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null
+        },
+        {
+            name: "invalid fealtyx code - missing prefix",
+            domain: "example.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "123415EG",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null
+        },
+        {
+            name: "invalid fealtyx code - short code",
+            domain: "example.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "FL1",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null
+        },
+        {
+            name: "valid fealtyx code - domain mismatch",
+            domain: "example2.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "FLX123415EG",
+            orderAmount: 100.0,
+            is_applicable: false,
+            is_unloq_discount_code: true,
+            reason: Reason.VoucherNotEligible
+        },
+        {
+            name: "valid fealtyx code - phone mismatch",
+            domain: "example.com",
+            phoneNumber: "777777",
+            giftCardCode: "FLX123415EG",
+            orderAmount: 100.0,
+            is_applicable: false,
+            is_unloq_discount_code: true,
+            reason: Reason.VoucherNotEligible
+        },
+        {
+            name: "valid fealtyx code with FLX prefix",
+            domain: "example.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "FLX123415EG",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: true,
+            reason: null
+        },
+        {
+            name: "valid fealtyx code with UNQ prefix",
+            domain: "example.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "UNQ123415EG",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: true,
+            reason: null
+        },
+        {
+            name: "valid fealtyx code with hashed phone",
+            domain: "example.com",
+            phoneNumber: getSHA256Hash("+918989898989"),
+            giftCardCode: "FLX123415EG",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: true,
+            reason: null
+        },
+        {
+            name: "valid fealtyx code with non hashed phone",
+            domain: "example.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "FLX123415EG",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: true,
+            reason: null
+        },
+        {
+            name: "valid fealtyx code with hashed phone but no order amount",
+            domain: "example.com",
+            phoneNumber: getSHA256Hash("+918989898989"),
+            giftCardCode: "FLX123415EG",
+            orderAmount: 0,
+            is_applicable: true,
+            is_unloq_discount_code: true,
+            reason: null
+        },
+        {
+            name: "valid fealtyx code with hashed phone but empty domain",
+            domain: "",
+            phoneNumber: getSHA256Hash("+918989898989"),
+            giftCardCode: "FLX123415EG",
+            orderAmount: 100.0,
+            is_applicable: false,
+            is_unloq_discount_code: true,
+            reason: Reason.InvalidDomain
+        },
+        {
+            name: "valid fealtyx code with hashed phone but invalid domain",
+            domain: "example\x00.com",
+            phoneNumber: getSHA256Hash("+918989898989"),
+            giftCardCode: "FLX123415EG",
+            orderAmount: 100.0,
+            is_applicable: false,
+            is_unloq_discount_code: true,
+            reason: Reason.InvalidDomain
+        },
+        {
+            name: "non-fealtyx code",
+            domain: "example.com",
+            phoneNumber: "+918989898989",
+            giftCardCode: "ABCD1234EFGH",
+            orderAmount: 100.0,
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null
+        },
+    ];
+    tests.forEach(testCase => {
+        it(testCase.name, () => {
+            const result = validateUnloqDiscountCode(testCase.domain, testCase.phoneNumber, testCase.giftCardCode, testCase.orderAmount);
+            expect(result.is_applicable).toBe(testCase.is_applicable);
+            expect(result.is_unloq_discount_code).toBe(testCase.is_unloq_discount_code);
+            // Handle both string and Reason enum comparison
+            if (testCase.reason === null) {
+                expect(result.reason).toBeNull();
+            }
+            else {
+                expect(result.reason).toBe(testCase.reason);
+            }
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { Reason } from "./interface/reason";
+export type ValidationResult = {
+    is_applicable: boolean;
+    is_unloq_discount_code: boolean;
+    reason: Reason | null;
+};
+export declare function validateUnloqDiscountCode(domain: string, phoneNumber: string, giftCardCode: string, orderAmount: number): ValidationResult;

package/dist/index.js

@@ -0,0 +1,128 @@
+import { Reason } from "./interface/reason";
+import { getSHA256Hash, getPhoneNumberHash } from "./utils/hash";
+import { hexCharToByte } from "./utils/string";
+export function validateUnloqDiscountCode(domain, phoneNumber, giftCardCode, orderAmount) {
+    // First, clean the gift card code
+    giftCardCode = giftCardCode.toLowerCase().trim();
+    // If gift card code is too short, return
+    if (!giftCardCode || giftCardCode.length < 4) {
+        return {
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null,
+        };
+    }
+    // Check if gift card code starts with "flx" or "unq"
+    if (!giftCardCode.startsWith("flx") && !giftCardCode.startsWith("unq")) {
+        return {
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null,
+        };
+    }
+    // Get last 4 characters of the code
+    const last4 = giftCardCode.slice(-4);
+    if (last4.length !== 4) {
+        return {
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null,
+        };
+    }
+    const first2 = last4.slice(0, 2);
+    const actualLast2 = last4.slice(2);
+    // Step 1: Check if this is an Fealtyx gift card by checking if the last 2 characters match the expected last 2 characters
+    const expectedLast2 = generateLast2FromFirst2(first2);
+    if (actualLast2 !== expectedLast2) {
+        // If the last 2 don't match the expected pattern, the gift card is not a Fealtyx gift card
+        return {
+            is_applicable: true,
+            is_unloq_discount_code: false,
+            reason: null,
+        };
+    }
+    // Sanitize domain
+    const { result: sanitizedDomain, error: err } = sanitizeDomain(domain);
+    if (err !== null) {
+        return {
+            is_applicable: false,
+            is_unloq_discount_code: true,
+            reason: Reason.InvalidDomain,
+        };
+    }
+    // Step 2: Verify full code - generate expected suffix
+    const expectedSuffix = getGiftCardCodeIdentifier(sanitizedDomain, phoneNumber).toLowerCase();
+    // Case-insensitive match
+    const valid = expectedSuffix.toLowerCase() === last4.toLowerCase();
+    if (!valid) {
+        return {
+            is_applicable: false,
+            is_unloq_discount_code: true,
+            reason: Reason.VoucherNotEligible,
+        };
+    }
+    return {
+        is_applicable: true,
+        is_unloq_discount_code: true,
+        reason: null,
+    };
+}
+// Helper function to generate last 2 characters from first 2 characters
+function generateLast2FromFirst2(first2) {
+    const alphanum = "abcdefghijklmnopqrstuvwxyz0123456789";
+    const charsetLen = alphanum.length;
+    if (first2.length !== 2) {
+        return "";
+    }
+    // Convert hex characters to numeric byte values
+    const c1 = first2[0];
+    const c2 = first2[1];
+    const b1 = hexCharToByte(c1);
+    const b2 = hexCharToByte(c2);
+    // Get XOR and sum of first 2 characters
+    const xor = b1 ^ b2;
+    const sum = b1 + b2;
+    // Map XOR and sum results to character set
+    const idx1 = xor % charsetLen;
+    const idx2 = sum % charsetLen;
+    return alphanum[idx1] + alphanum[idx2];
+}
+function getGiftCardCodeIdentifier(partnerEntityId, phoneNumber) {
+    let hashedPhoneNumber;
+    hashedPhoneNumber = getPhoneNumberHash(phoneNumber);
+    const alphanum = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const charsetLen = alphanum.length;
+    let input = (partnerEntityId + hashedPhoneNumber).toLowerCase();
+    const hash = getSHA256Hash(input);
+    const c1 = hash[0];
+    const c2 = hash[1];
+    const b1 = hexCharToByte(c1);
+    const b2 = hexCharToByte(c2);
+    const xor = b1 ^ b2;
+    const idx1 = xor % charsetLen;
+    const idx2 = (b1 + b2) % charsetLen;
+    return `${c1}${c2}${alphanum[idx1]}${alphanum[idx2]}`;
+}
+function sanitizeDomain(input) {
+    input = input.trim();
+    // Add scheme if missing to make it a valid URL
+    if (!input.includes('://')) {
+        input = 'https://' + input;
+    }
+    let parsed;
+    try {
+        parsed = new URL(input);
+    }
+    catch (err) {
+        return {
+            result: '',
+            error: new Error(`invalid domain: ${err instanceof Error ? err.message : String(err)}`)
+        };
+    }
+    // Extract host and convert to lowercase
+    const domain = parsed.hostname.toLowerCase();
+    if (!domain) {
+        return { result: '', error: new Error('empty domain') };
+    }
+    return { result: domain, error: null };
+}

package/dist/interface/reason.d.ts

@@ -0,0 +1,14 @@
+export declare enum Reason {
+    CodeTooShort = "Code Too Short",
+    InvalidDomain = "Invalid Domain",
+    VoucherNotEligible = "Voucher Not Eligible For The User",
+    InvalidPhone = "Invalid Phone Number",
+    InvalidOrderAmount = "Invalid Order Amount"
+}
+export declare namespace Reason {
+    /**
+     * Returns the string representation of a Reason.
+     * If the input is empty/undefined/null, returns Reason.Unknown.
+     */
+    function String(r?: Reason | string | null): string | null;
+}

package/dist/interface/reason.js

@@ -0,0 +1,21 @@
+export var Reason;
+(function (Reason) {
+    Reason["CodeTooShort"] = "Code Too Short";
+    Reason["InvalidDomain"] = "Invalid Domain";
+    Reason["VoucherNotEligible"] = "Voucher Not Eligible For The User";
+    Reason["InvalidPhone"] = "Invalid Phone Number";
+    Reason["InvalidOrderAmount"] = "Invalid Order Amount";
+})(Reason || (Reason = {}));
+(function (Reason) {
+    /**
+     * Returns the string representation of a Reason.
+     * If the input is empty/undefined/null, returns Reason.Unknown.
+     */
+    function String(r) {
+        if (r === undefined || r === null || r === "") {
+            return null;
+        }
+        return String(r);
+    }
+    Reason.String = String;
+})(Reason || (Reason = {}));

package/dist/utils/hash.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns the SHA-256 hash of the input string.
+ * If the input string is already hashed, returns the string as it is.
+ * @param s - The string to hash
+ * @returns The SHA-256 hash of the input string
+ */
+export declare function getSHA256Hash(s: string): string;
+/**
+ * Checks if the input string is a SHA-256 hash.
+ * @param s - The string to check
+ * @returns True if the string is a SHA-256 hash, false otherwise
+ */
+export declare function isSHA256Hash(s: string): boolean;
+/**
+ * Generates SHA256 hash for phone number.
+ * If the phone number doesn't start with +91, adds +91.
+ * If the phone number is already hashed, returns the string as it is.
+ * @param phoneNum - The phone number to hash
+ * @returns The SHA-256 hash of the phone number
+ */
+export declare function getPhoneNumberHash(phoneNum: string): string;

package/dist/utils/hash.js

@@ -0,0 +1,44 @@
+import * as crypto from 'crypto';
+/**
+ * Returns the SHA-256 hash of the input string.
+ * If the input string is already hashed, returns the string as it is.
+ * @param s - The string to hash
+ * @returns The SHA-256 hash of the input string
+ */
+export function getSHA256Hash(s) {
+    if (s === '' || isSHA256Hash(s)) {
+        return s;
+    }
+    // Create a new SHA-256 hash
+    const hash = crypto.createHash('sha256');
+    // Update the hash with the input string
+    hash.update(s);
+    // Get the hash as a hexadecimal string
+    return hash.digest('hex');
+}
+/**
+ * Checks if the input string is a SHA-256 hash.
+ * @param s - The string to check
+ * @returns True if the string is a SHA-256 hash, false otherwise
+ */
+export function isSHA256Hash(s) {
+    // SHA-256 hash: 64-character hexadecimal string
+    const sha256Regex = /^[a-fA-F0-9]{64}$/;
+    return sha256Regex.test(s);
+}
+/**
+ * Generates SHA256 hash for phone number.
+ * If the phone number doesn't start with +91, adds +91.
+ * If the phone number is already hashed, returns the string as it is.
+ * @param phoneNum - The phone number to hash
+ * @returns The SHA-256 hash of the phone number
+ */
+export function getPhoneNumberHash(phoneNum) {
+    if (phoneNum === '' || isSHA256Hash(phoneNum)) {
+        return phoneNum;
+    }
+    if (phoneNum.startsWith('+91')) {
+        return getSHA256Hash(phoneNum);
+    }
+    return getSHA256Hash('+91' + phoneNum);
+}

package/dist/utils/string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a hex character ('0'-'9', 'a'-'f', 'A'-'F') to a number between 0-15
+ * @param c - The hex character to convert
+ * @returns A number between 0-15 representing the hex value, or 0 if the character is invalid
+ */
+export declare function hexCharToByte(c: string): number;

package/dist/utils/string.js

@@ -0,0 +1,21 @@
+/**
+ * Converts a hex character ('0'-'9', 'a'-'f', 'A'-'F') to a number between 0-15
+ * @param c - The hex character to convert
+ * @returns A number between 0-15 representing the hex value, or 0 if the character is invalid
+ */
+export function hexCharToByte(c) {
+    // Ensure we only process the first character if a longer string is passed
+    const char = c.charAt(0);
+    if (char >= '0' && char <= '9') {
+        return char.charCodeAt(0) - '0'.charCodeAt(0);
+    }
+    else if (char >= 'a' && char <= 'f') {
+        return char.charCodeAt(0) - 'a'.charCodeAt(0) + 10;
+    }
+    else if (char >= 'A' && char <= 'F') {
+        return char.charCodeAt(0) - 'A'.charCodeAt(0) + 10;
+    }
+    else {
+        return 0;
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@unloq/unloq-code-validtor",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fealtyx/unloq-nodejs"
+  },
+  "homepage": "https://github.com/fealtyx/unloq-nodejs",
+  "bugs": {
+    "url": "https://github.com/fealtyx/unloq-nodejs/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+     "test": "jest",
+        "test:watch": "jest --watch"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "dependencies": {
+    "crypto": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.10.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.5"
+  }
+}