@hy_ong/zod-kit 0.1.1 → 0.1.3

package/src/validators/taiwan/postal-code.ts

@@ -16,7 +16,7 @@ import { getLocale, type Locale } from "../../config"
 /**
  * Type definition for postal code validation error messages
  *
- * @interface PostalCodeMessages
+ * @interface TwPostalCodeMessages
  * @property {string} [required] - Message when field is required but empty
  * @property {string} [invalid] - Message when postal code format is invalid
  * @property {string} [invalidFormat] - Message when format doesn't match expected pattern
@@ -26,7 +26,7 @@ import { getLocale, type Locale } from "../../config"
  * @property {string} [format5Only] - Message when only 5-digit format is allowed
  * @property {string} [format6Only] - Message when only 6-digit format is allowed
  */
-export type PostalCodeMessages = {
+export type TwPostalCodeMessages = {
   required?: string
   invalid?: string
   invalidFormat?: string
@@ -42,7 +42,7 @@ export type PostalCodeMessages = {
 /**
  * Postal code format types supported in Taiwan
  *
- * @typedef {"3" | "5" | "6" | "3+5" | "3+6" | "5+6" | "all"} PostalCodeFormat
+ * @typedef {"3" | "5" | "6" | "3+5" | "3+6" | "5+6" | "all"} TwPostalCodeFormatType
  *
  * Available formats:
  * - "3": 3-digit basic postal codes (100-982)
@@ -53,7 +53,7 @@ export type PostalCodeMessages = {
  * - "5+6": Accept both 5-digit and 6-digit formats
  * - "all": Accept all formats (3, 5, and 6 digits)
  */
-export type PostalCodeFormat =
+export type TwPostalCodeFormatType =
   | "3" // 3-digit only
   | "5" // 5-digit only (legacy)
   | "6" // 6-digit only (current)
@@ -67,9 +67,9 @@ export type PostalCodeFormat =
  *
  * @template IsRequired - Whether the field is required (affects return type)
  *
- * @interface PostalCodeOptions
+ * @interface TwPostalCodeOptions
  * @property {IsRequired} [required=true] - Whether the field is required
- * @property {PostalCodeFormat} [format="3+6"] - Which postal code formats to accept
+ * @property {TwPostalCodeFormatType} [format="3+6"] - Which postal code formats to accept
  * @property {boolean} [strictValidation=true] - Enable strict validation against known postal code ranges
  * @property {boolean} [allowDashes=true] - Whether to allow dashes in postal codes (e.g., "100-01" or "100-001")
  * @property {boolean} [warn5Digit=true] - Whether to show warning for 5-digit legacy format
@@ -77,10 +77,10 @@ export type PostalCodeFormat =
  * @property {string[]} [blockedPrefixes] - Specific 3-digit prefixes to block
  * @property {Function} [transform] - Custom transformation function for postal codes
  * @property {string | null} [defaultValue] - Default value when input is empty
- * @property {Record<Locale, PostalCodeMessages>} [i18n] - Custom error messages for different locales
+ * @property {Record<Locale, TwPostalCodeMessages>} [i18n] - Custom error messages for different locales
  */
-export type PostalCodeOptions<IsRequired extends boolean = true> = {
-  format?: PostalCodeFormat
+export type TwPostalCodeOptions<IsRequired extends boolean = true> = {
+  format?: TwPostalCodeFormatType
   strictValidation?: boolean
   allowDashes?: boolean
   warn5Digit?: boolean
@@ -88,7 +88,7 @@ export type PostalCodeOptions<IsRequired extends boolean = true> = {
   blockedPrefixes?: string[]
   transform?: (value: string) => string
   defaultValue?: IsRequired extends true ? string : string | null
-  i18n?: Record<Locale, PostalCodeMessages>
+  i18n?: Record<Locale, TwPostalCodeMessages>
   strictSuffixValidation?: boolean
   deprecate5Digit?: boolean
 }
@@ -97,10 +97,10 @@ export type PostalCodeOptions<IsRequired extends boolean = true> = {
  * Type alias for postal code validation schema based on required flag
  *
  * @template IsRequired - Whether the field is required
- * @typedef PostalCodeSchema
+ * @typedef TwPostalCodeSchema
  * @description Returns ZodString if required, ZodNullable<ZodString> if optional
  */
-export type PostalCodeSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+export type TwPostalCodeSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
 
 /**
  * Valid 3-digit postal code prefixes for Taiwan
@@ -728,7 +728,7 @@ const validate6DigitPostalCode = (value: string, strictValidation: boolean = tru
  * Main validation function for Taiwan postal codes
  *
  * @param {string} value - The postal code to validate
- * @param {PostalCodeFormat} format - Which formats to accept
+ * @param {TwPostalCodeFormatType} format - Which formats to accept
  * @param {boolean} strictValidation - Whether to validate against known postal codes
  * @param {boolean} strictSuffixValidation - Whether to validate suffix ranges
  * @param {boolean} allowDashes - Whether dashes/spaces are allowed and should be removed
@@ -738,7 +738,7 @@ const validate6DigitPostalCode = (value: string, strictValidation: boolean = tru
  */
 const validateTaiwanPostalCode = (
   value: string,
-  format: PostalCodeFormat = "3+6",
+  format: TwPostalCodeFormatType = "3+6",
   strictValidation: boolean = true,
   strictSuffixValidation: boolean = false,
   allowDashes: boolean = true,
@@ -801,8 +801,8 @@ const validateTaiwanPostalCode = (
  * Creates a Zod schema for Taiwan postal code validation
  *
  * @template IsRequired - Whether the field is required (affects return type)
- * @param {PostalCodeOptions<IsRequired>} [options] - Configuration options for postal code validation
- * @returns {PostalCodeSchema<IsRequired>} Zod schema for postal code validation
+ * @param {TwPostalCodeOptions<IsRequired>} [options] - Configuration options for postal code validation
+ * @returns {TwPostalCodeSchema<IsRequired>} Zod schema for postal code validation
  *
  * @description
  * Creates a comprehensive Taiwan postal code validator that supports multiple formats
@@ -822,53 +822,53 @@ const validateTaiwanPostalCode = (
  * @example
  * ```typescript
  * // Accept 3-digit or 6-digit formats (recommended)
- * const modernSchema = postalCode()
+ * const modernSchema = twPostalCode()
  * modernSchema.parse("100")     // ✓ Valid 3-digit
  * modernSchema.parse("100001")  // ✓ Valid 6-digit
  * modernSchema.parse("10001")   // ✗ Invalid (5-digit not allowed)
  *
  * // Accept all formats
- * const flexibleSchema = postalCode(false, { format: "all" })
+ * const flexibleSchema = twPostalCode(false, { format: "all" })
  * flexibleSchema.parse("100")     // ✓ Valid
  * flexibleSchema.parse("10001")   // ✓ Valid
  * flexibleSchema.parse("100001")  // ✓ Valid
  *
  * // Only 6-digit format (current standard)
- * const modernOnlySchema = postalCode(false, { format: "6" })
+ * const modernOnlySchema = twPostalCode(false, { format: "6" })
  * modernOnlySchema.parse("100001") // ✓ Valid
  * modernOnlySchema.parse("100")    // ✗ Invalid
  *
  * // With dashes allowed
- * const dashSchema = postalCode(false, { allowDashes: true })
+ * const dashSchema = twPostalCode(false, { allowDashes: true })
  * dashSchema.parse("100-001")  // ✓ Valid (normalized to "100001")
  * dashSchema.parse("100-01")   // ✓ Valid if 5-digit format allowed
  *
  * // Specific areas only
- * const taipeiSchema = postalCode(false, {
+ * const taipeiSchema = twPostalCode(false, {
  *   allowedPrefixes: ["100", "103", "104", "105", "106"]
  * })
  * taipeiSchema.parse("100001") // ✓ Valid (Taipei area)
  * taipeiSchema.parse("200001") // ✗ Invalid (not in allowlist)
  *
  * // Block specific areas
- * const blockedSchema = postalCode(false, {
+ * const blockedSchema = twPostalCode(false, {
  *   blockedPrefixes: ["999"] // Block test codes
  * })
  *
  * // With warning for legacy format
- * const warnSchema = postalCode(false, {
+ * const warnSchema = twPostalCode(false, {
  *   format: "all",
  *   warn5Digit: true
  * })
  * // Will validate but may show warning for 5-digit codes
  *
  * // Optional with custom transformation
- * const optionalSchema = postalCode(false, {
+ * const optionalSchema = twPostalCode(false, {
  *   transform: (value) => value.replace(/\D/g, '') // Remove non-digits
  * })
  *
  * // Strict suffix validation for real postal codes
- * const strictSchema = postalCode(false, {
+ * const strictSchema = twPostalCode(false, {
  *   format: "6",
  *   strictSuffixValidation: true // Validates suffix range 001-999
  * })
@@ -876,7 +876,7 @@ const validateTaiwanPostalCode = (
  * strictSchema.parse("100000") // ✗ Invalid (suffix 000 not allowed)
  *
  * // Deprecate 5-digit codes entirely
- * const modern2024Schema = postalCode(false, {
+ * const modern2024Schema = twPostalCode(false, {
  *   format: "all",
  *   deprecate5Digit: true // Throws error for any 5-digit code
  * })
@@ -885,11 +885,11 @@ const validateTaiwanPostalCode = (
  * ```
  *
  * @throws {z.ZodError} When validation fails with specific error messages
- * @see {@link PostalCodeOptions} for all available configuration options
- * @see {@link PostalCodeFormat} for supported formats
+ * @see {@link TwPostalCodeOptions} for all available configuration options
+ * @see {@link TwPostalCodeFormatType} for supported formats
  * @see {@link validateTaiwanPostalCode} for validation logic details
  */
-export function postalCode<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<PostalCodeOptions<IsRequired>, 'required'>): PostalCodeSchema<IsRequired> {
+export function twPostalCode<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TwPostalCodeOptions<IsRequired>, 'required'>): TwPostalCodeSchema<IsRequired> {
   const {
     format = "3+6",
     strictValidation = true,
@@ -910,7 +910,7 @@ export function postalCode<IsRequired extends boolean = false>(required?: IsRequ
   const actualDefaultValue = defaultValue ?? (isRequired ? "" : null)
 
   // Helper function to get custom message or fallback to default i18n
-  const getMessage = (key: keyof PostalCodeMessages, params?: Record<string, any>) => {
+  const getMessage = (key: keyof TwPostalCodeMessages, params?: Record<string, any>) => {
     if (i18n) {
       const currentLocale = getLocale()
       const customMessages = i18n[currentLocale]
@@ -949,34 +949,39 @@ export function postalCode<IsRequired extends boolean = false>(required?: IsRequ
 
   const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
 
-  const schema = baseSchema.refine((val) => {
-    if (val === null) return true
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
 
     // Required check
     if (isRequired && (val === "" || val === "null" || val === "undefined")) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
     }
 
-    if (val === null) return true
-    if (!isRequired && val === "") return true
+    if (val === null) return
+    if (!isRequired && val === "") return
 
     // Format-specific validation
     const cleanValue = val.replace(/[-\s]/g, "")
 
     // Check if format matches expected pattern
     if (format === "3" && cleanValue.length !== 3) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("format3Only"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("format3Only") })
+      return
     }
     if (format === "5" && cleanValue.length !== 5) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("format5Only"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("format5Only") })
+      return
     }
     if (format === "6" && cleanValue.length !== 6) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("format6Only"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("format6Only") })
+      return
     }
 
     // Check for deprecated 5-digit format
     if (deprecate5Digit && cleanValue.length === 5) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("deprecated5Digit"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("deprecated5Digit") })
+      return
     }
 
     // Pre-validate suffix for better error messages before main validation
@@ -987,7 +992,8 @@ export function postalCode<IsRequired extends boolean = false>(required?: IsRequ
         const suffixNum = parseInt(suffix, 10)
         const ranges = getPostalCodeRanges(prefix)
         if (suffixNum < ranges.range5[0] || suffixNum > ranges.range5[1]) {
-          throw new z.ZodError([{ code: "custom", message: getMessage("invalidSuffix"), path: [] }])
+          ctx.addIssue({ code: "custom", message: getMessage("invalidSuffix") })
+          return
         }
       } else if (cleanValue.length === 6) {
         const prefix = cleanValue.substring(0, 3)
@@ -995,25 +1001,25 @@ export function postalCode<IsRequired extends boolean = false>(required?: IsRequ
         const suffixNum = parseInt(suffix, 10)
         const ranges = getPostalCodeRanges(prefix)
         if (suffixNum < ranges.range6[0] || suffixNum > ranges.range6[1]) {
-          throw new z.ZodError([{ code: "custom", message: getMessage("invalidSuffix"), path: [] }])
+          ctx.addIssue({ code: "custom", message: getMessage("invalidSuffix") })
+          return
         }
       }
     }
 
     // Main postal code validation (only validates prefix if strictSuffixValidation already passed)
     if (!validateTaiwanPostalCode(val, format, strictValidation, strictSuffixValidation, allowDashes, allowedPrefixes, blockedPrefixes)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+      return
     }
 
     // Warning for 5-digit legacy format (doesn't fail validation)
     if (warn5Digit && cleanValue.length === 5 && format !== "5" && !deprecate5Digit) {
       console.warn(getMessage("legacy5DigitWarning"))
     }
-
-    return true
   })
 
-  return schema as unknown as PostalCodeSchema<IsRequired>
+  return schema as unknown as TwPostalCodeSchema<IsRequired>
 }
 
 /**

package/src/validators/taiwan/tel.ts

@@ -15,12 +15,12 @@ import { getLocale, type Locale } from "../../config"
 /**
  * Type definition for telephone validation error messages
  *
- * @interface TelMessages
+ * @interface TwTelMessages
  * @property {string} [required] - Message when field is required but empty
  * @property {string} [invalid] - Message when telephone number format is invalid
  * @property {string} [notInWhitelist] - Message when telephone number is not in whitelist
  */
-export type TelMessages = {
+export type TwTelMessages = {
   required?: string
   invalid?: string
   notInWhitelist?: string
@@ -31,28 +31,28 @@ export type TelMessages = {
  *
  * @template IsRequired - Whether the field is required (affects return type)
  *
- * @interface TelOptions
+ * @interface TwTelOptions
  * @property {IsRequired} [required=true] - Whether the field is required
  * @property {string[]} [whitelist] - Array of specific telephone numbers that are always allowed
  * @property {Function} [transform] - Custom transformation function for telephone number
  * @property {string | null} [defaultValue] - Default value when input is empty
- * @property {Record<Locale, TelMessages>} [i18n] - Custom error messages for different locales
+ * @property {Record<Locale, TwTelMessages>} [i18n] - Custom error messages for different locales
  */
-export type TelOptions<IsRequired extends boolean = true> = {
+export type TwTelOptions<IsRequired extends boolean = true> = {
   whitelist?: string[]
   transform?: (value: string) => string
   defaultValue?: IsRequired extends true ? string : string | null
-  i18n?: Record<Locale, TelMessages>
+  i18n?: Record<Locale, TwTelMessages>
 }
 
 /**
  * Type alias for telephone validation schema based on required flag
  *
  * @template IsRequired - Whether the field is required
- * @typedef TelSchema
+ * @typedef TwTelSchema
  * @description Returns ZodString if required, ZodNullable<ZodString> if optional
  */
-export type TelSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+export type TwTelSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
 
 /**
  * Validates Taiwan landline telephone number format (Official 2024 rules)
@@ -174,7 +174,7 @@ const validateTaiwanTel = (value: string): boolean => {
  * @template IsRequired - Whether the field is required (affects return type)
  * @param {IsRequired} [required=false] - Whether the field is required
  * @param {Omit<ValidatorOptions<IsRequired>, 'required'>} [options] - Configuration options for validation
- * @returns {TelSchema<IsRequired>} Zod schema for telephone number validation
+ * @returns {TwTelSchema<IsRequired>} Zod schema for telephone number validation
  *
  * @description
  * Creates a comprehensive Taiwan landline telephone number validator with support for
@@ -193,7 +193,7 @@ const validateTaiwanTel = (value: string): boolean => {
  * @example
  * ```typescript
  * // Basic telephone number validation
- * const basicSchema = tel() // optional by default
+ * const basicSchema = twTel() // optional by default
  * basicSchema.parse("0223456789") // ✓ Valid (Taipei)
  * basicSchema.parse(null) // ✓ Valid (optional)
  *
@@ -207,26 +207,26 @@ const validateTaiwanTel = (value: string): boolean => {
  * basicSchema.parse("0812345678") // ✗ Invalid (wrong format for 08)
  *
  * // With whitelist (only specific numbers allowed)
- * const whitelistSchema = tel(false, {
+ * const whitelistSchema = twTel(false, {
  *   whitelist: ["0223456789", "0312345678"]
  * })
  * whitelistSchema.parse("0223456789") // ✓ Valid (in whitelist)
  * whitelistSchema.parse("0287654321") // ✗ Invalid (not in whitelist)
  *
  * // Optional telephone number
- * const optionalSchema = tel(false)
+ * const optionalSchema = twTel(false)
  * optionalSchema.parse("") // ✓ Valid (returns null)
  * optionalSchema.parse("0223456789") // ✓ Valid
  *
  * // With custom transformation (remove separators)
- * const transformSchema = tel(false, {
+ * const transformSchema = twTel(false, {
  *   transform: (value) => value.replace(/[^0-9]/g, '') // Keep only digits
  * })
  * transformSchema.parse("02-2345-6789") // ✓ Valid (separators removed)
  * transformSchema.parse("02 2345 6789") // ✓ Valid (spaces removed)
  *
  * // With custom error messages
- * const customSchema = tel(false, {
+ * const customSchema = twTel(false, {
  *   i18n: {
  *     en: { invalid: "Please enter a valid Taiwan landline number" },
  *     'zh-TW': { invalid: "請輸入有效的台灣市話號碼" }
@@ -235,10 +235,10 @@ const validateTaiwanTel = (value: string): boolean => {
  * ```
  *
  * @throws {z.ZodError} When validation fails with specific error messages
- * @see {@link TelOptions} for all available configuration options
+ * @see {@link TwTelOptions} for all available configuration options
  * @see {@link validateTaiwanTel} for validation logic details
  */
-export function tel<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TelOptions<IsRequired>, 'required'>): TelSchema<IsRequired> {
+export function twTel<IsRequired extends boolean = false>(required?: IsRequired, options?: Omit<TwTelOptions<IsRequired>, 'required'>): TwTelSchema<IsRequired> {
   const { whitelist, transform, defaultValue, i18n } = options ?? {}
 
   const isRequired = required ?? false as IsRequired
@@ -247,7 +247,7 @@ export function tel<IsRequired extends boolean = false>(required?: IsRequired, o
   const actualDefaultValue = defaultValue ?? (isRequired ? "" : null)
 
   // Helper function to get custom message or fallback to default i18n
-  const getMessage = (key: keyof TelMessages, params?: Record<string, any>) => {
+  const getMessage = (key: keyof TwTelMessages, params?: Record<string, any>) => {
     if (i18n) {
       const currentLocale = getLocale()
       const customMessages = i18n[currentLocale]
@@ -290,35 +290,36 @@ export function tel<IsRequired extends boolean = false>(required?: IsRequired, o
 
   const baseSchema = isRequired ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
 
-  const schema = baseSchema.refine((val) => {
-    if (val === null) return true
+  const schema = baseSchema.superRefine((val, ctx) => {
+    if (val === null) return
 
     // Required check
     if (isRequired && (val === "" || val === "null" || val === "undefined")) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("required") })
+      return
     }
 
-    if (val === null) return true
-    if (!isRequired && val === "") return true
+    if (val === null) return
+    if (!isRequired && val === "") return
 
     // Allowlist check (if an allowlist is provided, only allow values in the allowlist)
     if (whitelist && whitelist.length > 0) {
       if (whitelist.includes(val)) {
-        return true
+        return
       }
       // If not in the allowlist, reject regardless of format
-      throw new z.ZodError([{ code: "custom", message: getMessage("notInWhitelist"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("notInWhitelist") })
+      return
     }
 
     // Taiwan telephone format validation (only if no allowlist or allowlist is empty)
     if (!validateTaiwanTel(val)) {
-      throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+      ctx.addIssue({ code: "custom", message: getMessage("invalid") })
+      return
     }
-
-    return true
   })
 
-  return schema as unknown as TelSchema<IsRequired>
+  return schema as unknown as TwTelSchema<IsRequired>
 }
 
 /**

package/tests/common/id.test.ts

@@ -135,8 +135,8 @@ describe.each(locales)("id(true) locale: $locale", ({ locale, messages }) => {
     })
 
     it("should apply transform function", () => {
-      const schema = id(true, { type: "numeric", transform: (val) => val.toUpperCase() })
-      expect(schema.parse("123")).toBe("123")
+      const schema = id(true, { type: "uuid", transform: (val) => val.toUpperCase() })
+      expect(schema.parse("550e8400-e29b-41d4-a716-446655440000")).toBe("550E8400-E29B-41D4-A716-446655440000")
     })
   })
 
@@ -162,7 +162,9 @@ describe.each(locales)("id(true) locale: $locale", ({ locale, messages }) => {
       it("should accept valid numeric IDs", () => {
         const schema = id(true, { type: "numeric" })
         validIds.numeric.forEach((validId) => {
-          expect(schema.parse(validId)).toBe(validId)
+          const result = schema.parse(validId)
+          expect(typeof result).toBe("number")
+          expect(result).toBe(Number(validId))
         })
       })
 
@@ -461,7 +463,8 @@ describe.each(locales)("id(true) locale: $locale", ({ locale, messages }) => {
       expect(schema.parse("")).toBe(null)
       expect(() => schema.parse("ab")).toThrow() // not numeric
       expect(() => schema.parse("12")).toThrow() // too short
-      expect(schema.parse("12345")).toBe("12345")
+      expect(schema.parse("12345")).toBe(12345) // Returns number for numeric type
+      expect(typeof schema.parse("12345")).toBe("number")
     })
 
     it("should handle multiple allowed types with constraints", () => {
@@ -499,4 +502,59 @@ describe.each(locales)("id(true) locale: $locale", ({ locale, messages }) => {
       expect(ID_PATTERNS.objectId.test("507f1f77bcf86cd799439011")).toBe(true)
     })
   })
+
+  describe("numeric type returns number", () => {
+    it("should return number type when type is numeric and required is true", () => {
+      const schema = id(true, { type: "numeric" })
+      const result = schema.parse("123")
+      expect(result).toBe(123)
+      expect(typeof result).toBe("number")
+    })
+
+    it("should return number | null when type is numeric and required is false", () => {
+      const schema = id(false, { type: "numeric" })
+      const result = schema.parse("456")
+      expect(result).toBe(456)
+      expect(typeof result).toBe("number")
+
+      const nullResult = schema.parse(null)
+      expect(nullResult).toBe(null)
+
+      const emptyResult = schema.parse("")
+      expect(emptyResult).toBe(null)
+    })
+
+    it("should use numeric default value for numeric type", () => {
+      const schema = id(true, { type: "numeric", defaultValue: 999 })
+      const result = schema.parse("")
+      expect(result).toBe(999)
+      expect(typeof result).toBe("number")
+    })
+
+    it("should validate numeric ID constraints", () => {
+      const schema = id(true, { type: "numeric", minLength: 3, maxLength: 5 })
+
+      expect(schema.parse("123")).toBe(123)
+      expect(schema.parse("12345")).toBe(12345)
+
+      // Too short
+      expect(() => schema.parse("12")).toThrow()
+
+      // Too long
+      expect(() => schema.parse("123456")).toThrow()
+
+      // Not numeric
+      expect(() => schema.parse("abc")).toThrow()
+    })
+
+    it("should convert string numbers to number type", () => {
+      const schema = id(true, { type: "numeric" })
+
+      expect(schema.parse("0")).toBe(0)
+      expect(schema.parse("999999")).toBe(999999)
+      expect(schema.parse(123)).toBe(123)
+
+      expect(typeof schema.parse("123")).toBe("number")
+    })
+  })
 })