@hy_ong/zod-kit 0.0.4 → 0.0.5

package/src/validators/common/number.ts

@@ -0,0 +1,194 @@
+import { z, ZodNullable, ZodNumber } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+export type NumberMessages = {
+  required?: string
+  invalid?: string
+  integer?: string
+  float?: string
+  min?: string
+  max?: string
+  positive?: string
+  negative?: string
+  nonNegative?: string
+  nonPositive?: string
+  multipleOf?: string
+  finite?: string
+  precision?: string
+}
+
+export type NumberOptions<IsRequired extends boolean = true> = {
+  required?: IsRequired
+  min?: number
+  max?: number
+  defaultValue?: IsRequired extends true ? number : number | null
+  type?: "integer" | "float" | "both"
+  positive?: boolean
+  negative?: boolean
+  nonNegative?: boolean
+  nonPositive?: boolean
+  multipleOf?: number
+  precision?: number
+  finite?: boolean
+  transform?: (value: number) => number
+  parseCommas?: boolean // Parse "1,234" as 1234
+  i18n?: Record<Locale, NumberMessages>
+}
+
+export type NumberSchema<IsRequired extends boolean> = IsRequired extends true ? ZodNumber : ZodNullable<ZodNumber>
+
+export function number<IsRequired extends boolean = true>(options?: NumberOptions<IsRequired>): NumberSchema<IsRequired> {
+  const {
+    required = true,
+    min,
+    max,
+    defaultValue,
+    type = "both",
+    positive,
+    negative,
+    nonNegative,
+    nonPositive,
+    multipleOf,
+    precision,
+    finite = true,
+    transform,
+    parseCommas = false,
+    i18n,
+  } = options ?? {}
+
+  // Helper function to get custom message or fallback to default i18n
+  const getMessage = (key: keyof NumberMessages, params?: Record<string, any>) => {
+    if (i18n) {
+      const currentLocale = getLocale()
+      const customMessages = i18n[currentLocale]
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key]!
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "")
+      }
+    }
+    return t(`common.number.${key}`, params)
+  }
+
+  // Set appropriate default value based on required flag
+  const actualDefaultValue = defaultValue ?? null
+
+  const schema = z
+    .preprocess(
+      (val) => {
+        if (val === "" || val === undefined || val === null) {
+          return actualDefaultValue
+        }
+
+        // Handle string input
+        if (typeof val === "string") {
+          let processedVal = val.trim()
+
+          // Parse comma-separated numbers like "1,234.56"
+          if (parseCommas) {
+            processedVal = processedVal.replace(/,/g, "")
+          }
+
+          const parsed = Number(processedVal)
+
+          // Return NaN as is so it can be caught in refine
+          if (isNaN(parsed)) {
+            return parsed
+          }
+
+          if (transform) {
+            return transform(parsed)
+          }
+
+          return parsed
+        }
+
+        // Handle existing numbers (including Infinity)
+        if (typeof val === "number") {
+          if (transform && Number.isFinite(val)) {
+            return transform(val)
+          }
+          return val
+        }
+
+        return val
+      },
+      z.union([z.number(), z.null(), z.nan(), z.custom<number>((val) => val === Infinity || val === -Infinity)])
+    )
+    .refine((val) => {
+      // Required check first
+      if (required && val === null) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+      }
+
+      if (val === null) return true
+
+      // Type validation for invalid inputs (NaN)
+      if (typeof val === "number" && isNaN(val)) {
+        if (type === "integer") {
+          throw new z.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }])
+        } else if (type === "float") {
+          throw new z.ZodError([{ code: "custom", message: getMessage("float"), path: [] }])
+        } else {
+          throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+        }
+      }
+
+      // Invalid number check for non-numbers
+      if (typeof val !== "number") {
+        throw new z.ZodError([{ code: "custom", message: getMessage("invalid"), path: [] }])
+      }
+
+      // Finite check
+      if (finite && !Number.isFinite(val)) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("finite"), path: [] }])
+      }
+
+      // Type validation for valid numbers
+      if (type === "integer" && !Number.isInteger(val)) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("integer"), path: [] }])
+      }
+      if (type === "float" && Number.isInteger(val)) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("float"), path: [] }])
+      }
+
+      // Sign checks (more specific, should come first)
+      if (positive && val <= 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("positive"), path: [] }])
+      }
+      if (negative && val >= 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("negative"), path: [] }])
+      }
+      if (nonNegative && val < 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("nonNegative"), path: [] }])
+      }
+      if (nonPositive && val > 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("nonPositive"), path: [] }])
+      }
+
+      // Range checks
+      if (min !== undefined && val < min) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }])
+      }
+      if (max !== undefined && val > max) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+      }
+
+      // Multiple of check
+      if (multipleOf !== undefined && val % multipleOf !== 0) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("multipleOf", { multipleOf }), path: [] }])
+      }
+
+      // Precision check
+      if (precision !== undefined) {
+        const decimalPlaces = (val.toString().split(".")[1] || "").length
+        if (decimalPlaces > precision) {
+          throw new z.ZodError([{ code: "custom", message: getMessage("precision", { precision }), path: [] }])
+        }
+      }
+
+      return true
+    })
+
+  return schema as unknown as NumberSchema<IsRequired>
+}

package/src/validators/common/password.ts

@@ -0,0 +1,214 @@
+import { z, ZodNullable, ZodString } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+export type PasswordMessages = {
+  required?: string
+  min?: string
+  max?: string
+  uppercase?: string
+  lowercase?: string
+  digits?: string
+  special?: string
+  noRepeating?: string
+  noSequential?: string
+  noCommonWords?: string
+  minStrength?: string
+  excludes?: string
+  includes?: string
+  invalid?: string
+}
+
+export type PasswordStrength = "weak" | "medium" | "strong" | "very-strong"
+
+export type PasswordOptions<IsRequired extends boolean = true> = {
+  required?: IsRequired
+  min?: number
+  max?: number
+  uppercase?: boolean
+  lowercase?: boolean
+  digits?: boolean
+  special?: boolean
+  noRepeating?: boolean
+  noSequential?: boolean
+  noCommonWords?: boolean
+  minStrength?: PasswordStrength
+  excludes?: string | string[]
+  includes?: string
+  regex?: RegExp
+  transform?: (value: string) => string
+  defaultValue?: IsRequired extends true ? string : string | null
+  i18n?: Record<Locale, PasswordMessages>
+}
+
+export type PasswordSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+
+// Common weak passwords to check against
+const COMMON_PASSWORDS = [
+  "password",
+  "123456",
+  "123456789",
+  "12345678",
+  "12345",
+  "1234567",
+  "admin",
+  "qwerty",
+  "abc123",
+  "password123",
+  "letmein",
+  "welcome",
+  "monkey",
+  "dragon",
+  "sunshine",
+  "princess",
+]
+
+// Helper function to calculate password strength
+const calculatePasswordStrength = (password: string): PasswordStrength => {
+  let score = 0
+
+  // Length bonus
+  if (password.length >= 8) score += 1
+  if (password.length >= 12) score += 1
+  if (password.length >= 16) score += 1
+
+  // Character variety
+  if (/[a-z]/.test(password)) score += 1
+  if (/[A-Z]/.test(password)) score += 1
+  if (/[0-9]/.test(password)) score += 1
+  if (/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password)) score += 1
+
+  // Deductions
+  if (/(.)\1{2,}/.test(password)) score -= 1 // Repeating characters
+  if (/(?:abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i.test(password)) score -= 1 // Sequential
+
+  if (score <= 2) return "weak"
+  if (score <= 4) return "medium"
+  if (score <= 6) return "strong"
+  return "very-strong"
+}
+
+export function password<IsRequired extends boolean = true>(options?: PasswordOptions<IsRequired>): PasswordSchema<IsRequired> {
+  const {
+    required = true,
+    min,
+    max,
+    uppercase,
+    lowercase,
+    digits,
+    special,
+    noRepeating,
+    noSequential,
+    noCommonWords,
+    minStrength,
+    excludes,
+    includes,
+    regex,
+    transform,
+    defaultValue,
+    i18n,
+  } = options ?? {}
+
+  // Set appropriate default value based on required flag
+  const actualDefaultValue = defaultValue ?? (required ? "" : null)
+
+  // Helper function to get custom message or fallback to default i18n
+  const getMessage = (key: keyof PasswordMessages, params?: Record<string, any>) => {
+    if (i18n) {
+      const currentLocale = getLocale()
+      const customMessages = i18n[currentLocale]
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key]!
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "")
+      }
+    }
+    return t(`common.password.${key}`, params)
+  }
+
+  // Preprocessing function
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return actualDefaultValue
+    }
+
+    let processed = String(val)
+    if (transform) {
+      processed = transform(processed)
+    }
+
+    return processed
+  }
+
+  const baseSchema = required ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
+
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true
+
+    // Required check
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+    }
+
+    // Length checks
+    if (val !== null && min !== undefined && val.length < min) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("min", { min }), path: [] }])
+    }
+    if (val !== null && max !== undefined && val.length > max) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("max", { max }), path: [] }])
+    }
+
+    // Character requirements
+    if (val !== null && uppercase && !/[A-Z]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("uppercase"), path: [] }])
+    }
+    if (val !== null && lowercase && !/[a-z]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("lowercase"), path: [] }])
+    }
+    if (val !== null && digits && !/[0-9]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("digits"), path: [] }])
+    }
+    if (val !== null && special && !/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("special"), path: [] }])
+    }
+
+    // Advanced security checks
+    if (val !== null && noRepeating && /(.)\1{2,}/.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("noRepeating"), path: [] }])
+    }
+    if (val !== null && noSequential && /(?:abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("noSequential"), path: [] }])
+    }
+    if (val !== null && noCommonWords && COMMON_PASSWORDS.some((common) => val.toLowerCase().includes(common.toLowerCase()))) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("noCommonWords"), path: [] }])
+    }
+    if (val !== null && minStrength) {
+      const strength = calculatePasswordStrength(val)
+      const strengthLevels = ["weak", "medium", "strong", "very-strong"]
+      const currentLevel = strengthLevels.indexOf(strength)
+      const requiredLevel = strengthLevels.indexOf(minStrength)
+      if (currentLevel < requiredLevel) {
+        throw new z.ZodError([{ code: "custom", message: getMessage("minStrength", { minStrength }), path: [] }])
+      }
+    }
+
+    // Content checks
+    if (val !== null && includes !== undefined && !val.includes(includes)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }])
+    }
+    if (val !== null && excludes !== undefined) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes]
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }])
+        }
+      }
+    }
+    if (val !== null && regex !== undefined && !regex.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("invalid", { regex }), path: [] }])
+    }
+
+    return true
+  })
+
+  return schema as unknown as PasswordSchema<IsRequired>
+}

package/src/validators/common/text.ts

@@ -0,0 +1,151 @@
+import { z, ZodNullable, ZodString } from "zod"
+import { t } from "../../i18n"
+import { getLocale, type Locale } from "../../config"
+
+export type TextMessages = {
+  required?: string
+  notEmpty?: string
+  minLength?: string
+  maxLength?: string
+  startsWith?: string
+  endsWith?: string
+  includes?: string
+  excludes?: string
+  invalid?: string
+}
+
+export type TextOptions<IsRequired extends boolean = true> = {
+  required?: IsRequired
+  minLength?: number
+  maxLength?: number
+  startsWith?: string
+  endsWith?: string
+  includes?: string
+  excludes?: string | string[]
+  regex?: RegExp
+  trimMode?: "trim" | "trimStart" | "trimEnd" | "none"
+  casing?: "upper" | "lower" | "title" | "none"
+  transform?: (value: string) => string
+  notEmpty?: boolean
+  defaultValue?: IsRequired extends true ? string : string | null
+  i18n?: Record<Locale, TextMessages>
+}
+
+export type TextSchema<IsRequired extends boolean> = IsRequired extends true ? ZodString : ZodNullable<ZodString>
+
+export function text<IsRequired extends boolean = true>(options?: TextOptions<IsRequired>): TextSchema<IsRequired> {
+  const { required = true, minLength, maxLength, startsWith, endsWith, includes, excludes, regex, trimMode = "trim", casing = "none", transform, notEmpty, defaultValue, i18n } = options ?? {}
+
+  // Set appropriate default value based on required flag
+  const actualDefaultValue = defaultValue ?? (required ? "" : null)
+
+  // Helper function to get custom message or fallback to default i18n
+  const getMessage = (key: keyof TextMessages, params?: Record<string, any>) => {
+    if (i18n) {
+      const currentLocale = getLocale()
+      const customMessages = i18n[currentLocale]
+      if (customMessages && customMessages[key]) {
+        const template = customMessages[key]!
+        return template.replace(/\$\{(\w+)}/g, (_, k) => params?.[k] ?? "")
+      }
+    }
+    return t(`common.text.${key}`, params)
+  }
+
+  // Helper functions to apply trimming based on the mode
+  const applyTrim = (str: string): string => {
+    switch (trimMode) {
+      case "trimStart":
+        return str.trimStart()
+      case "trimEnd":
+        return str.trimEnd()
+      case "none":
+        return str
+      default:
+        return str.trim()
+    }
+  }
+
+  // Helper function to apply casing
+  const applyCasing = (str: string): string => {
+    switch (casing) {
+      case "upper":
+        return str.toUpperCase()
+      case "lower":
+        return str.toLowerCase()
+      case "title":
+        return str.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase())
+      default:
+        return str
+    }
+  }
+
+  // Preprocessing function with optimized transformations
+  const preprocessFn = (val: unknown) => {
+    if (val === "" || val === null || val === undefined) {
+      return actualDefaultValue
+    }
+
+    let processed = String(val)
+    processed = applyTrim(processed)
+    processed = applyCasing(processed)
+
+    if (transform) {
+      processed = transform(processed)
+    }
+
+    return processed
+  }
+
+  const baseSchema = required ? z.preprocess(preprocessFn, z.string()) : z.preprocess(preprocessFn, z.string().nullable())
+
+  // Single refine with all validations for better performance
+  const schema = baseSchema.refine((val) => {
+    if (val === null) return true
+
+    // Required check
+    if (required && (val === "" || val === "null" || val === "undefined")) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("required"), path: [] }])
+    }
+
+    // Not empty check (different from required - checks whitespace)
+    // For notEmpty, we need to check if the original string (before processing) was only whitespace
+    if (notEmpty && val !== null && val.trim() === "") {
+      throw new z.ZodError([{ code: "custom", message: getMessage("notEmpty"), path: [] }])
+    }
+
+    // Length checks
+    if (val !== null && minLength !== undefined && val.length < minLength) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("minLength", { minLength }), path: [] }])
+    }
+    if (val !== null && maxLength !== undefined && val.length > maxLength) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("maxLength", { maxLength }), path: [] }])
+    }
+
+    // String content checks
+    if (val !== null && startsWith !== undefined && !val.startsWith(startsWith)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("startsWith", { startsWith }), path: [] }])
+    }
+    if (val !== null && endsWith !== undefined && !val.endsWith(endsWith)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("endsWith", { endsWith }), path: [] }])
+    }
+    if (val !== null && includes !== undefined && !val.includes(includes)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("includes", { includes }), path: [] }])
+    }
+    if (val !== null && excludes !== undefined) {
+      const excludeList = Array.isArray(excludes) ? excludes : [excludes]
+      for (const exclude of excludeList) {
+        if (val.includes(exclude)) {
+          throw new z.ZodError([{ code: "custom", message: getMessage("excludes", { excludes: exclude }), path: [] }])
+        }
+      }
+    }
+    if (val !== null && regex !== undefined && !regex.test(val)) {
+      throw new z.ZodError([{ code: "custom", message: getMessage("invalid", { regex }), path: [] }])
+    }
+
+    return true
+  })
+
+  return schema as unknown as TextSchema<IsRequired>
+}