@hy_ong/zod-kit 0.2.0 → 0.2.2

package/tests/common/credit-card.test.ts

@@ -0,0 +1,378 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { creditCard, setLocale, validateCreditCard, detectCardType } from "../../src"
+
+describe("creditCard(true) validator", () => {
+  beforeEach(() => setLocale("en-US"))
+
+  describe("basic functionality", () => {
+    it("should validate correct Luhn numbers", () => {
+      const schema = creditCard(true)
+
+      expect(schema.parse("4111111111111111")).toBe("4111111111111111")
+      expect(schema.parse("4012888888881881")).toBe("4012888888881881")
+      expect(schema.parse("5500000000000004")).toBe("5500000000000004")
+      expect(schema.parse("5105105105105100")).toBe("5105105105105100")
+      expect(schema.parse("378282246310005")).toBe("378282246310005")
+      expect(schema.parse("371449635398431")).toBe("371449635398431")
+      expect(schema.parse("3530111333300000")).toBe("3530111333300000")
+      expect(schema.parse("6011111111111117")).toBe("6011111111111117")
+      expect(schema.parse("6200000000000005")).toBe("6200000000000005")
+    })
+
+    it("should reject invalid Luhn numbers", () => {
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("4111111111111112")).toThrow("Invalid credit card number")
+      expect(() => schema.parse("1234567890123456")).toThrow("Invalid credit card number")
+    })
+  })
+
+  describe("card type detection", () => {
+    it("should detect Visa cards", () => {
+      const schema = creditCard(true, { cardType: "visa" })
+
+      expect(schema.parse("4111111111111111")).toBe("4111111111111111")
+      expect(schema.parse("4012888888881881")).toBe("4012888888881881")
+    })
+
+    it("should detect Mastercard cards", () => {
+      const schema = creditCard(true, { cardType: "mastercard" })
+
+      expect(schema.parse("5500000000000004")).toBe("5500000000000004")
+      expect(schema.parse("5105105105105100")).toBe("5105105105105100")
+    })
+
+    it("should detect AMEX cards", () => {
+      const schema = creditCard(true, { cardType: "amex" })
+
+      expect(schema.parse("378282246310005")).toBe("378282246310005")
+      expect(schema.parse("371449635398431")).toBe("371449635398431")
+    })
+
+    it("should detect JCB cards", () => {
+      const schema = creditCard(true, { cardType: "jcb" })
+
+      expect(schema.parse("3530111333300000")).toBe("3530111333300000")
+    })
+
+    it("should detect Discover cards", () => {
+      const schema = creditCard(true, { cardType: "discover" })
+
+      expect(schema.parse("6011111111111117")).toBe("6011111111111117")
+    })
+
+    it("should detect UnionPay cards", () => {
+      const schema = creditCard(true, { cardType: "unionpay" })
+
+      expect(schema.parse("6200000000000005")).toBe("6200000000000005")
+    })
+  })
+
+  describe("card type filtering", () => {
+    it("should reject cards not matching the required type", () => {
+      const visaOnly = creditCard(true, { cardType: "visa" })
+
+      expect(() => visaOnly.parse("5500000000000004")).toThrow("Invalid credit card number")
+      expect(() => visaOnly.parse("378282246310005")).toThrow("Invalid credit card number")
+      expect(() => visaOnly.parse("3530111333300000")).toThrow("Invalid credit card number")
+    })
+
+    it("should accept multiple card types", () => {
+      const visaOrMc = creditCard(true, { cardType: ["visa", "mastercard"] })
+
+      expect(visaOrMc.parse("4111111111111111")).toBe("4111111111111111")
+      expect(visaOrMc.parse("5500000000000004")).toBe("5500000000000004")
+      expect(() => visaOrMc.parse("378282246310005")).toThrow("Invalid credit card number")
+    })
+
+    it("should accept any card type when 'any' is specified", () => {
+      const anyType = creditCard(true, { cardType: "any" })
+
+      expect(anyType.parse("4111111111111111")).toBe("4111111111111111")
+      expect(anyType.parse("5500000000000004")).toBe("5500000000000004")
+      expect(anyType.parse("378282246310005")).toBe("378282246310005")
+      expect(anyType.parse("3530111333300000")).toBe("3530111333300000")
+      expect(anyType.parse("6011111111111117")).toBe("6011111111111117")
+      expect(anyType.parse("6200000000000005")).toBe("6200000000000005")
+    })
+
+    it("should accept any card type when 'any' is included in array", () => {
+      const withAny = creditCard(true, { cardType: ["any", "visa"] })
+
+      expect(withAny.parse("5500000000000004")).toBe("5500000000000004")
+      expect(withAny.parse("378282246310005")).toBe("378282246310005")
+    })
+  })
+
+  describe("whitelist", () => {
+    it("should accept whitelisted card numbers", () => {
+      const schema = creditCard(true, { whitelist: ["4111111111111111", "5500000000000004"] })
+
+      expect(schema.parse("4111111111111111")).toBe("4111111111111111")
+      expect(schema.parse("5500000000000004")).toBe("5500000000000004")
+    })
+
+    it("should reject non-whitelisted card numbers", () => {
+      const schema = creditCard(true, { whitelist: ["4111111111111111"] })
+
+      expect(() => schema.parse("5500000000000004")).toThrow("Credit card number is not in the allowed list")
+    })
+
+    it("should normalize whitelist entries by stripping spaces and hyphens", () => {
+      const schema = creditCard(true, { whitelist: ["4111-1111-1111-1111"] })
+
+      expect(schema.parse("4111111111111111")).toBe("4111111111111111")
+    })
+  })
+
+  describe("required/optional behavior", () => {
+    it("should handle required=true", () => {
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse(null)).toThrow()
+      expect(() => schema.parse(undefined)).toThrow()
+    })
+
+    it("should handle required=false", () => {
+      const schema = creditCard(false)
+
+      expect(schema.parse("")).toBe(null)
+      expect(schema.parse(null)).toBe(null)
+      expect(schema.parse(undefined)).toBe(null)
+      expect(schema.parse("4111111111111111")).toBe("4111111111111111")
+    })
+
+    it("should use default values", () => {
+      const requiredSchema = creditCard(true, { defaultValue: "4111111111111111" })
+      const optionalSchema = creditCard(false, { defaultValue: "4111111111111111" })
+
+      expect(requiredSchema.parse("")).toBe("4111111111111111")
+      expect(optionalSchema.parse("")).toBe("4111111111111111")
+    })
+  })
+
+  describe("transform function", () => {
+    it("should apply custom transform before validation", () => {
+      const schema = creditCard(true, {
+        transform: (val) => val.toUpperCase(),
+      })
+
+      expect(schema.parse("4111111111111111")).toBe("4111111111111111")
+    })
+
+    it("should apply transform on the stripped value", () => {
+      const transformed: string[] = []
+      const schema = creditCard(true, {
+        transform: (val) => {
+          transformed.push(val)
+          return val
+        },
+      })
+
+      schema.parse("4111 1111 1111 1111")
+      expect(transformed[0]).toBe("4111111111111111")
+    })
+  })
+
+  describe("input preprocessing", () => {
+    it("should strip spaces from input", () => {
+      const schema = creditCard(true)
+
+      expect(schema.parse("4111 1111 1111 1111")).toBe("4111111111111111")
+      expect(schema.parse("  4111 1111 1111 1111  ")).toBe("4111111111111111")
+    })
+
+    it("should strip hyphens from input", () => {
+      const schema = creditCard(true)
+
+      expect(schema.parse("4111-1111-1111-1111")).toBe("4111111111111111")
+      expect(schema.parse("5500-0000-0000-0004")).toBe("5500000000000004")
+    })
+
+    it("should handle mixed spaces and hyphens", () => {
+      const schema = creditCard(true)
+
+      expect(schema.parse("4111 - 1111 - 1111 - 1111")).toBe("4111111111111111")
+    })
+
+    it("should handle string conversion from numbers", () => {
+      const schema = creditCard(true)
+
+      expect(schema.parse(4111111111111111)).toBe("4111111111111111")
+    })
+  })
+
+  describe("i18n support", () => {
+    it("should use English messages by default", () => {
+      setLocale("en-US")
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse("4111111111111112")).toThrow("Invalid credit card number")
+    })
+
+    it("should use Chinese messages when locale is zh-TW", () => {
+      setLocale("zh-TW")
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("")).toThrow("必填")
+      expect(() => schema.parse("4111111111111112")).toThrow("無效的信用卡號碼")
+    })
+
+    it("should support custom i18n messages", () => {
+      const schema = creditCard(true, {
+        i18n: {
+          "en-US": {
+            required: "Card number is required",
+            invalid: "Card number is invalid",
+            notInWhitelist: "Card not allowed",
+          },
+          "zh-TW": {
+            required: "請輸入信用卡號",
+            invalid: "信用卡號格式錯誤",
+            notInWhitelist: "此卡號不允許使用",
+          },
+        },
+      })
+
+      setLocale("en-US")
+      expect(() => schema.parse("")).toThrow("Card number is required")
+      expect(() => schema.parse("4111111111111112")).toThrow("Card number is invalid")
+
+      setLocale("zh-TW")
+      expect(() => schema.parse("")).toThrow("請輸入信用卡號")
+      expect(() => schema.parse("4111111111111112")).toThrow("信用卡號格式錯誤")
+    })
+
+    it("should use custom notInWhitelist message", () => {
+      const schema = creditCard(true, {
+        whitelist: ["4111111111111111"],
+        i18n: {
+          "en-US": {
+            notInWhitelist: "This card is not accepted",
+          },
+        },
+      })
+
+      expect(() => schema.parse("5500000000000004")).toThrow("This card is not accepted")
+    })
+  })
+
+  describe("edge cases", () => {
+    it("should reject numbers that are too short", () => {
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("411111111111")).toThrow("Invalid credit card number")
+      expect(() => schema.parse("41111")).toThrow("Invalid credit card number")
+      expect(() => schema.parse("1")).toThrow("Invalid credit card number")
+    })
+
+    it("should reject numbers that are too long", () => {
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("41111111111111111111")).toThrow("Invalid credit card number")
+    })
+
+    it("should reject non-numeric input", () => {
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("abcdefghijklmnop")).toThrow("Invalid credit card number")
+      expect(() => schema.parse("4111-ABCD-1111-1111")).toThrow("Invalid credit card number")
+      expect(() => schema.parse("41111111111111xx")).toThrow("Invalid credit card number")
+    })
+
+    it("should handle 'null' and 'undefined' string values as required", () => {
+      const schema = creditCard(true)
+
+      expect(() => schema.parse("null")).toThrow("Required")
+      expect(() => schema.parse("undefined")).toThrow("Required")
+    })
+
+    it("should handle empty and whitespace inputs", () => {
+      const schema = creditCard(true)
+      const optionalSchema = creditCard(false)
+
+      expect(() => schema.parse("")).toThrow("Required")
+      expect(() => schema.parse("   ")).toThrow("Required")
+
+      expect(optionalSchema.parse("")).toBe(null)
+      expect(optionalSchema.parse("   ")).toBe(null)
+    })
+  })
+
+  describe("utility functions", () => {
+    describe("validateCreditCard", () => {
+      it("should return true for valid Luhn numbers", () => {
+        expect(validateCreditCard("4111111111111111")).toBe(true)
+        expect(validateCreditCard("4012888888881881")).toBe(true)
+        expect(validateCreditCard("5500000000000004")).toBe(true)
+        expect(validateCreditCard("5105105105105100")).toBe(true)
+        expect(validateCreditCard("378282246310005")).toBe(true)
+        expect(validateCreditCard("371449635398431")).toBe(true)
+        expect(validateCreditCard("3530111333300000")).toBe(true)
+        expect(validateCreditCard("6011111111111117")).toBe(true)
+        expect(validateCreditCard("6200000000000005")).toBe(true)
+      })
+
+      it("should return false for invalid Luhn numbers", () => {
+        expect(validateCreditCard("4111111111111112")).toBe(false)
+        expect(validateCreditCard("1234567890123456")).toBe(false)
+      })
+
+      it("should return false for non-numeric strings", () => {
+        expect(validateCreditCard("abcdefghijklmnop")).toBe(false)
+        expect(validateCreditCard("")).toBe(false)
+      })
+
+      it("should return false for wrong-length strings", () => {
+        expect(validateCreditCard("41111")).toBe(false)
+        expect(validateCreditCard("41111111111111111111")).toBe(false)
+      })
+
+      it("should handle strings with spaces and hyphens", () => {
+        expect(validateCreditCard("4111 1111 1111 1111")).toBe(true)
+        expect(validateCreditCard("4111-1111-1111-1111")).toBe(true)
+      })
+    })
+
+    describe("detectCardType", () => {
+      it("should detect Visa", () => {
+        expect(detectCardType("4111111111111111")).toBe("visa")
+        expect(detectCardType("4012888888881881")).toBe("visa")
+      })
+
+      it("should detect Mastercard", () => {
+        expect(detectCardType("5500000000000004")).toBe("mastercard")
+        expect(detectCardType("5105105105105100")).toBe("mastercard")
+      })
+
+      it("should detect AMEX", () => {
+        expect(detectCardType("378282246310005")).toBe("amex")
+        expect(detectCardType("371449635398431")).toBe("amex")
+      })
+
+      it("should detect JCB", () => {
+        expect(detectCardType("3530111333300000")).toBe("jcb")
+      })
+
+      it("should detect Discover", () => {
+        expect(detectCardType("6011111111111117")).toBe("discover")
+      })
+
+      it("should detect UnionPay", () => {
+        expect(detectCardType("6200000000000005")).toBe("unionpay")
+      })
+
+      it("should return 'any' for unrecognized prefixes", () => {
+        expect(detectCardType("9999999999999999")).toBe("any")
+        expect(detectCardType("1111111111111111")).toBe("any")
+      })
+
+      it("should handle strings with spaces and hyphens", () => {
+        expect(detectCardType("4111 1111 1111 1111")).toBe("visa")
+        expect(detectCardType("5500-0000-0000-0004")).toBe("mastercard")
+      })
+    })
+  })
+})

package/tests/common/id.test.ts

@@ -11,6 +11,9 @@ const locales = [
       maxLength: "Must be at most 10 characters",
       numeric: "Must be a numeric ID",
       uuid: "Must be a valid UUID",
+      uuidv1: "Must be a valid UUID v1",
+      uuidv4: "Must be a valid UUID v4",
+      uuidv7: "Must be a valid UUID v7",
       objectId: "Must be a valid MongoDB ObjectId",
       nanoid: "Must be a valid Nano ID",
       snowflake: "Must be a valid Snowflake ID",
@@ -33,6 +36,9 @@ const locales = [
       maxLength: "長度最多 10 字元",
       numeric: "必須為數字 ID",
       uuid: "必須為有效的 UUID",
+      uuidv1: "必須為有效的 UUID v1",
+      uuidv4: "必須為有效的 UUID v4",
+      uuidv7: "必須為有效的 UUID v7",
       objectId: "必須為有效的 MongoDB ObjectId",
       nanoid: "必須為有效的 Nano ID",
       snowflake: "必須為有效的 Snowflake ID",
@@ -51,7 +57,20 @@ const locales = [
 // Valid test IDs for different formats
 const validIds = {
   numeric: ["1", "123", "999999", "0"],
-  uuid: ["550e8400-e29b-41d4-a716-446655440000", "6ba7b810-9dad-11d1-80b4-00c04fd430c8", "f47ac10b-58cc-4372-a567-0e02b2c3d479"],
+  uuid: [
+    "550e8400-e29b-41d4-a716-446655440000", // v4
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8", // v1
+    "f47ac10b-58cc-4372-a567-0e02b2c3d479", // v4
+    "01939fee-4b0b-7da3-a9e4-79fb4c267eb8", // v7
+    "320c3d4d-cc00-875b-8ec9-32d5f69181c0", // v8
+  ],
+  uuidv1: ["6ba7b810-9dad-11d1-80b4-00c04fd430c8", "f47ac10b-58cc-1372-a567-0e02b2c3d479"],
+  uuidv3: ["a3bb189e-8bf9-3888-9912-ace4e6543002"],
+  uuidv4: ["550e8400-e29b-41d4-a716-446655440000", "f47ac10b-58cc-4372-a567-0e02b2c3d479"],
+  uuidv5: ["886313e1-3b8a-5372-9b90-0c9aee199e5d"],
+  uuidv6: ["1ef21d2f-1207-6b90-8b50-a2e4100c5480"],
+  uuidv7: ["01939fee-4b0b-7da3-a9e4-79fb4c267eb8", "018fce07-42dc-7dc0-ba2c-9f7e777caee3"],
+  uuidv8: ["320c3d4d-cc00-875b-8ec9-32d5f69181c0"],
   objectId: ["507f1f77bcf86cd799439011", "507f191e810c19729de860ea", "5a9427648b0beebeb69579cc"],
   nanoid: ["V1StGXR8_Z5jdHi6B-myT", "3IBBoOd_b1YSlnKdvQ8fK", "9_xnJ2QZt8vKl3_Kj5f7N"],
   snowflake: ["1234567890123456789", "9876543210987654321", "5555555555555555555"],
@@ -65,11 +84,19 @@ const invalidIds = {
   numeric: ["abc", "12a", ""],
   uuid: [
     "550e8400-e29b-41d4-a716-44665544000", // too short
-    "550e8400-e29b-41d4-a716-44665544000g", // too long
-    "550e8400-e29b-61d4-a716-446655440000", // wrong version (6 instead of 1-5)
+    "550e8400-e29b-41d4-a716-44665544000g", // invalid character
+    "550e8400-e29b-91d4-a716-446655440000", // wrong version (9)
     "550e8400-e29b-41d4-c716-446655440000", // wrong variant (c instead of 8,9,a,b)
     "not-a-uuid-at-all",
   ],
+  uuidv4: [
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8", // v1, not v4
+    "01939fee-4b0b-7da3-a9e4-79fb4c267eb8", // v7, not v4
+  ],
+  uuidv7: [
+    "550e8400-e29b-41d4-a716-446655440000", // v4, not v7
+    "6ba7b810-9dad-11d1-80b4-00c04fd430c8", // v1, not v7
+  ],
   objectId: [
     "507f1f77bcf86cd79943901", // too short
     "507f1f77bcf86cd799439011g", // invalid character
@@ -192,6 +219,44 @@ describe.each(locales)("id(true) locale: $locale", ({ locale, messages }) => {
       })
     })
 
+    describe("UUID version-specific validation", () => {
+      it("should accept valid UUIDv4 and reject other versions", () => {
+        const schema = id(true, { type: "uuidv4" })
+        validIds.uuidv4.forEach((v) => expect(schema.parse(v)).toBe(v))
+        invalidIds.uuidv4.forEach((v) => expect(() => schema.parse(v)).toThrow(messages.uuidv4))
+      })
+
+      it("should accept valid UUIDv7 and reject other versions", () => {
+        const schema = id(true, { type: "uuidv7" })
+        validIds.uuidv7.forEach((v) => expect(schema.parse(v)).toBe(v))
+        invalidIds.uuidv7.forEach((v) => expect(() => schema.parse(v)).toThrow(messages.uuidv7))
+      })
+
+      it("should accept valid UUIDv1", () => {
+        const schema = id(true, { type: "uuidv1" })
+        validIds.uuidv1.forEach((v) => expect(schema.parse(v)).toBe(v))
+      })
+
+      it("should accept valid UUIDv6", () => {
+        const schema = id(true, { type: "uuidv6" })
+        validIds.uuidv6.forEach((v) => expect(schema.parse(v)).toBe(v))
+      })
+
+      it("should accept any version with generic uuid type", () => {
+        const schema = id(true, { type: "uuid" })
+        // All version-specific IDs should pass generic uuid validation
+        ;[...validIds.uuidv1, ...validIds.uuidv4, ...validIds.uuidv7, ...validIds.uuidv8].forEach((v) => expect(schema.parse(v)).toBe(v))
+      })
+
+      it("should work with allowedTypes for specific versions", () => {
+        const schema = id(true, { allowedTypes: ["uuidv4", "uuidv7"] })
+        validIds.uuidv4.forEach((v) => expect(schema.parse(v)).toBe(v))
+        validIds.uuidv7.forEach((v) => expect(schema.parse(v)).toBe(v))
+        // v1 should be rejected
+        expect(() => schema.parse("6ba7b810-9dad-11d1-80b4-00c04fd430c8")).toThrow()
+      })
+    })
+
     describe("ObjectId validation", () => {
       it("should accept valid ObjectIds", () => {
         const schema = id(true, { type: "objectId" })