@hy_ong/zod-kit 0.0.1

package/src/i18n/locales/zh-TW.json

@@ -0,0 +1,65 @@
+{
+  "common": {
+    "boolean": {
+      "required": "請輸入 ${label}",
+      "shouldBe": {
+        "true": "${label} 必須為是",
+        "false": "${label} 必須為否"
+      }
+    },
+    "email": {
+      "required": "請輸入 ${label}",
+      "min": "${label} 長度至少 ${min} 字元",
+      "max": "${label} 長度最多 ${max} 字元",
+      "includes": "${label} 必須包含「${includes}」",
+      "invalid": "${label} 格式錯誤",
+      "domain": "${label} 必須為 @${domain} 網域"
+    },
+    "url": {
+      "required": "請輸入 ${label}",
+      "min": "${label} 長度至少 ${min} 字元",
+      "max": "${label} 長度最多 ${max} 字元",
+      "includes": "${label} 必須包含「${includes}」",
+      "invalid": "${label} 格式錯誤"
+    },
+    "password": {
+      "required": "請輸入 ${label}",
+      "min": "${label} 長度至少 ${min} 字元",
+      "max": "${label} 長度最多 ${max} 字元",
+      "uppercase": "${label} 必須包含至少一個大寫字母",
+      "lowercase": "${label} 必須包含至少一個小寫字母",
+      "digits": "${label} 必須包含至少一個數字",
+      "special": "${label} 必須包含至少一個特殊符號"
+    },
+    "number": {
+      "required": "請輸入 ${label}",
+      "min": "${label} 最小值 ${min}",
+      "max": "${label} 最大值 ${max}"
+    },
+    "id": {
+      "required": "請選擇 ${label}",
+      "invalid": "${label} 無效"
+    },
+    "integer": {
+      "required": "請輸入 ${label}",
+      "min": "${label} 最小值 ${min}",
+      "max": "${label} 最大值 ${max}",
+      "integer": "${label} 必須為整數"
+    },
+    "float": {
+      "required": "請輸入 ${label}",
+      "float": "${label} 必須為浮點數",
+      "min": "${label} 最小值 ${min}",
+      "max": "${label} 最大值 ${max}"
+    },
+    "text": {
+      "required": "請輸入 ${label}",
+      "min": "${label} 長度至少 ${min} 字元",
+      "max": "${label} 長度最多 ${max} 字元",
+      "startsWith": "${label} 必須以「${startsWith}」開頭",
+      "endsWith": "${label} 必須以「${endsWith}」結尾",
+      "includes": "${label} 必須包含「${includes}」",
+      "invalid": "${label} 格式錯誤"
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from "./common/boolean"
+export * from "./common/email"
+export * from "./common/url"
+export * from "./common/text"
+export * from "./common/number"
+export * from "./common/password"
+export * from "./common/integer"
+export * from "./config"

package/tests/common/boolean.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { setLocale, boolean, Locale } from "../../src"
+
+const locales = [
+  {
+    locale: "en",
+    messages: {
+      required: "TEST is required",
+      shouldBeTrue: "TEST must be True",
+      shouldBeFalse: "TEST must be False",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "請輸入 TEST",
+      shouldBeTrue: "TEST 必須為是",
+      shouldBeFalse: "TEST 必須為否",
+    },
+  },
+] as const
+
+describe.each(locales)("boolean() locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  it("should parse true values correctly", () => {
+    const schema = boolean({ label: "TEST", required: true })
+    expect(schema.parse(true)).toBe(true)
+    expect(schema.parse("true")).toBe(true)
+    expect(schema.parse(1)).toBe(true)
+  })
+
+  it("should parse false values correctly", () => {
+    const schema = boolean({ label: "TEST", required: true })
+    expect(schema.parse(false)).toBe(false)
+    expect(schema.parse("false")).toBe(false)
+    expect(schema.parse(0)).toBe(false)
+  })
+
+  it("should throw when input is empty and required", () => {
+    const schema = boolean({ label: "TEST", required: true })
+    expect(() => schema.parse(undefined)).toThrow(messages.required)
+    expect(() => schema.parse(null)).toThrow(messages.required)
+    expect(() => schema.parse("")).toThrow(messages.required)
+  })
+
+  it("should return null when not required and empty input", () => {
+    const schema = boolean({ label: "TEST", required: false })
+    expect(schema.parse(undefined)).toBe(null)
+    expect(schema.parse(null)).toBe(null)
+    expect(schema.parse("")).toBe(null)
+  })
+
+  it("should apply defaultValue when required", () => {
+    const schema = boolean({ label: "TEST", required: true, defaultValue: true })
+    expect(schema.parse("")).toBe(true)
+    expect(schema.parse(null)).toBe(true)
+    expect(schema.parse(undefined)).toBe(true)
+
+    const schema2 = boolean({ label: "TEST", required: true, defaultValue: false })
+    expect(schema2.parse("")).toBe(false)
+    expect(schema2.parse(null)).toBe(false)
+    expect(schema2.parse(undefined)).toBe(false)
+  })
+
+  it("should apply defaultValue when not required", () => {
+    const schema = boolean({ label: "TEST", required: false, defaultValue: true })
+    expect(schema.parse("")).toBe(true)
+    expect(schema.parse(null)).toBe(true)
+    expect(schema.parse(undefined)).toBe(true)
+
+    const schema2 = boolean({ label: "TEST", required: false, defaultValue: false })
+    expect(schema2.parse("")).toBe(false)
+    expect(schema2.parse(null)).toBe(false)
+    expect(schema2.parse(undefined)).toBe(false)
+  })
+
+  it("should throw error for invalid string", () => {
+    const schema = boolean({ label: "TEST" })
+    expect(() => schema.parse("yes")).toThrow()
+    expect(() => schema.parse("no")).toThrow()
+  })
+
+  it("should throw error for non-boolean, non-convertible values", () => {
+    const schema = boolean({ label: "TEST" })
+    expect(() => schema.parse({})).toThrow()
+    expect(() => schema.parse([])).toThrow()
+  })
+
+  it("should validate shouldBe: true", () => {
+    const schema = boolean({ label: "TEST", shouldBe: true })
+    expect(schema.parse(true)).toBe(true)
+    expect(schema.parse("true")).toBe(true)
+    expect(() => schema.parse(false)).toThrow(messages.shouldBeTrue)
+    expect(() => schema.parse("false")).toThrow(messages.shouldBeTrue)
+    expect(() => schema.parse(0)).toThrow(messages.shouldBeTrue)
+  })
+
+  it("should validate shouldBe: false", () => {
+    const schema = boolean({ label: "TEST", shouldBe: false })
+    expect(schema.parse(false)).toBe(false)
+    expect(schema.parse("false")).toBe(false)
+    expect(schema.parse(0)).toBe(false)
+    expect(() => schema.parse(true)).toThrow(messages.shouldBeFalse)
+    expect(() => schema.parse("true")).toThrow(messages.shouldBeFalse)
+    expect(() => schema.parse(1)).toThrow(messages.shouldBeFalse)
+  })
+
+  it("should show correct error message when shouldBe is true but value is false", () => {
+    const schema = boolean({ label: "TEST", shouldBe: true })
+    expect(() => schema.parse(false)).toThrow(messages.shouldBeTrue)
+  })
+
+  it("should show correct error message when shouldBe is false but value is true", () => {
+    const schema = boolean({ label: "TEST", shouldBe: false })
+    expect(() => schema.parse(true)).toThrow(messages.shouldBeFalse)
+  })
+})

package/tests/common/email.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { setLocale, email, Locale } from "../../src"
+
+const locales = [
+  {
+    locale: "en",
+    messages: {
+      required: "TEST is required",
+      min: "TEST must be at least 20 characters",
+      max: "TEST must be at most 10 characters",
+      includes: "TEST must include company",
+      invalid: "TEST is invalid format",
+      domain: "TEST must be under the domain @example.com",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "請輸入 TEST",
+      min: "TEST 長度至少 20 字元",
+      max: "TEST 長度最多 10 字元",
+      includes: "TEST 必須包含「company」",
+      invalid: "TEST 格式錯誤",
+      domain: "TEST 必須為 @example.com 網域",
+    },
+  },
+] as const
+
+describe.each(locales)("email() locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  it("should pass for valid email", () => {
+    const schema = email({ label: "TEST" })
+    expect(schema.parse("test@example.com")).toBe("test@example.com")
+  })
+
+  it("should fail for invalid email format", () => {
+    const schema = email({ label: "TEST" })
+    expect(() => schema.parse("invalid-email")).toThrow(messages.invalid)
+  })
+
+  it("should enforce required when set", () => {
+    const schema = email({ label: "TEST", required: true })
+    expect(() => schema.parse("")).toThrow(messages.required)
+    expect(() => schema.parse(null)).toThrow(messages.required)
+    expect(() => schema.parse(undefined)).toThrow(messages.required)
+  })
+
+  it("should allow null if not required", () => {
+    const schema = email({ label: "TEST", required: false })
+    expect(schema.parse("")).toBe(null)
+    expect(schema.parse(null)).toBe(null)
+    expect(schema.parse(undefined)).toBe(null)
+  })
+
+  it("should enforce max length", () => {
+    const schema = email({ label: "TEST", max: 10 })
+    expect(() => schema.parse("verylongemail@example.com")).toThrow(messages.max)
+  })
+
+  it("should enforce min length", () => {
+    const schema = email({ label: "TEST", min: 20 })
+    expect(() => schema.parse("short@example.com")).toThrow(messages.min)
+  })
+
+  it("should enforce includes", () => {
+    const schema = email({ label: "TEST", includes: "company" })
+    expect(schema.parse("john@company.com")).toBe("john@company.com")
+    expect(() => schema.parse("short@other.com")).toThrow(messages.includes)
+  })
+
+  it("should validate against custom domain", () => {
+    const schema = email({ label: "TEST", domain: "example.com" })
+    expect(schema.parse("test@example.com")).toBe("test@example.com")
+    expect(() => schema.parse("short@notexample.com")).toThrow(messages.domain)
+  })
+})

package/tests/common/integer.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { setLocale, integer, Locale } from "../../src"
+
+const locales = [
+  {
+    locale: "en",
+    messages: {
+      required: "TEST is required",
+      min: "TEST must be at least 3",
+      max: "TEST must be at most 10",
+      integer: "TEST must be an integer",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "請輸入 TEST",
+      min: "TEST 最小值 3",
+      max: "TEST 最大值 10",
+      integer: "TEST 必須為整數",
+    },
+  },
+] as const
+
+describe.each(locales)("integer() locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  it("should pass with valid integer", () => {
+    const schema = integer({ label: "TEST" })
+    expect(schema.parse(42)).toBe(42)
+  })
+
+  it("should parse string number as integer", () => {
+    const schema = integer({ label: "TEST" })
+    expect(schema.parse("100")).toBe(100)
+  })
+
+  it("should fail for decimal value", () => {
+    const schema = integer({ label: "TEST" })
+    expect(() => schema.parse(3.14)).toThrow(messages.integer)
+  })
+
+  it("should fail for non-numeric string", () => {
+    const schema = integer({ label: "TEST" })
+    expect(() => schema.parse("abc")).toThrow(messages.integer)
+    expect(() => schema.parse("10a")).toThrow(messages.integer)
+  })
+
+  it("should allow null if not required", () => {
+    const schema = integer({ label: "TEST", required: false })
+    expect(schema.parse("")).toBe(null)
+    expect(schema.parse(null)).toBe(null)
+    expect(schema.parse(undefined)).toBe(null)
+  })
+
+  it("should fail when required and input is empty", () => {
+    const schema = integer({ label: "TEST", required: true })
+    expect(() => schema.parse("")).toThrow(messages.required)
+    expect(() => schema.parse(null)).toThrow(messages.required)
+    expect(() => schema.parse(undefined)).toThrow(messages.required)
+  })
+
+  it("should apply default value even when required", () => {
+    const schema = integer({ label: "TEST", required: true, defaultValue: 5 })
+    expect(schema.parse("")).toBe(5)
+    expect(schema.parse(null)).toBe(5)
+    expect(schema.parse(undefined)).toBe(5)
+  })
+
+  it("should apply default value even when required", () => {
+    const schema = integer({ label: "TEST", required: false, defaultValue: 5 })
+    expect(schema.parse("")).toBe(5)
+    expect(schema.parse(null)).toBe(5)
+    expect(schema.parse(undefined)).toBe(5)
+  })
+
+  it("should enforce min", () => {
+    const schema = integer({ label: "TEST", min: 3 })
+    expect(schema.parse(3)).toBe(3)
+    expect(() => schema.parse(2)).toThrow(messages.min)
+    expect(() => schema.parse("2")).toThrow(messages.min)
+  })
+
+  it("should enforce max", () => {
+    const schema = integer({ label: "TEST", max: 10 })
+    expect(schema.parse(10)).toBe(10)
+    expect(() => schema.parse(11)).toThrow(messages.max)
+    expect(() => schema.parse("11")).toThrow(messages.max)
+  })
+})

package/tests/common/number.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { setLocale, number, Locale } from "../../src"
+
+const locales = [
+  {
+    locale: "en",
+    messages: {
+      required: "TEST is required",
+      min: "TEST must be at least 5",
+      max: "TEST must be at most 10",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "請輸入 TEST",
+      min: "TEST 最小值 5",
+      max: "TEST 最大值 10",
+    },
+  },
+] as const
+
+describe.each(locales)("number() locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  it("should pass with valid number", () => {
+    const schema = number({ label: "TEST" })
+    expect(schema.parse(42)).toBe(42)
+  })
+
+  it("should parse string number", () => {
+    const schema = number({ label: "TEST" })
+    expect(schema.parse("123")).toBe(123)
+  })
+
+  it("should fail for empty string when required", () => {
+    const schema = number({ label: "TEST", required: true })
+    expect(() => schema.parse("")).toThrow(messages.required)
+    expect(() => schema.parse(null)).toThrow(messages.required)
+    expect(() => schema.parse(undefined)).toThrow(messages.required)
+  })
+
+  it("should allow null if not required", () => {
+    const schema = number({ label: "TEST", required: false })
+    expect(schema.parse("")).toBe(null)
+    expect(schema.parse(null)).toBe(null)
+    expect(schema.parse(undefined)).toBe(null)
+  })
+
+  it("should apply default value with not required", () => {
+    const schema = number({ label: "TEST", required: false, defaultValue: 42 })
+    expect(schema.parse("")).toBe(42)
+    expect(schema.parse(null)).toBe(42)
+    expect(schema.parse(undefined)).toBe(42)
+  })
+
+  it("should apply default value with required", () => {
+    const schema = number({ label: "TEST", required: true, defaultValue: 42 })
+    expect(schema.parse("")).toBe(42)
+    expect(schema.parse(null)).toBe(42)
+    expect(schema.parse(undefined)).toBe(42)
+  })
+
+  it("should enforce min", () => {
+    const schema = number({ label: "TEST", min: 5 })
+    expect(schema.parse(5)).toBe(5)
+    expect(() => schema.parse(2)).toThrow(messages.min)
+    expect(() => schema.parse("2")).toThrow(messages.min)
+  })
+
+  it("should enforce max", () => {
+    const schema = number({ label: "TEST", max: 10 })
+    expect(schema.parse(10)).toBe(10)
+    expect(() => schema.parse(11)).toThrow(messages.max)
+    expect(() => schema.parse("11")).toThrow(messages.max)
+  })
+})

package/tests/common/password.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it, beforeEach } from "vitest"
+import { Locale, setLocale, password } from "../../src"
+
+const locales = [
+  {
+    locale: "en",
+    messages: {
+      required: "TEST is required",
+      min: "TEST must be at least 5 characters",
+      max: "TEST must be at most 5 characters",
+      uppercase: "TEST must include at least one uppercase letter",
+      lowercase: "TEST must include at least one lowercase letter",
+      digits: "TEST must include at least one digit",
+      special: "TEST must include at least one special character",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "請輸入 TEST",
+      min: "TEST 長度至少 5 字元",
+      max: "TEST 長度最多 5 字元",
+      uppercase: "TEST 必須包含至少一個大寫字母",
+      lowercase: "TEST 必須包含至少一個小寫字母",
+      digits: "TEST 必須包含至少一個數字",
+      special: "TEST 必須包含至少一個特殊符號",
+    },
+  },
+] as const
+
+describe.each(locales)("password() locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  it("should pass with valid string", () => {
+    const schema = password({ label: "TEST" })
+    expect(schema.parse("hello")).toBe("hello")
+  })
+
+  it("should fail with empty string when required", () => {
+    const schema = password({ label: "TEST" })
+    expect(() => schema.parse("")).toThrow(messages.required)
+    expect(() => schema.parse(null)).toThrow(messages.required)
+    expect(() => schema.parse(undefined)).toThrow(messages.required)
+  })
+
+  it("should pass with null when not required", () => {
+    const schema = password({ label: "TEST", required: false })
+    expect(schema.parse("")).toBe(null)
+    expect(schema.parse(null)).toBe(null)
+    expect(schema.parse(undefined)).toBe(null)
+  })
+
+  it("should fail with string shorter than min", () => {
+    const schema = password({ label: "TEST", min: 5 })
+    expect(() => schema.parse("hi")).toThrow(messages.min)
+    expect(() => schema.parse("")).toThrow(messages.min)
+    expect(() => schema.parse(null)).toThrow(messages.min)
+    expect(() => schema.parse(undefined)).toThrow(messages.min)
+  })
+
+  it("should fail with string longer than max", () => {
+    const schema = password({ label: "TEST", max: 5 })
+    expect(() => schema.parse("hello world")).toThrow(messages.max)
+  })
+
+  it("should enforce uppercase requirement", () => {
+    const schema = password({ label: "TEST", uppercase: true })
+    expect(() => schema.parse("lowercase1!")).toThrow(messages.uppercase)
+    expect(schema.parse("Hello1!")).toBe("Hello1!")
+  })
+
+  it("should enforce lowercase requirement", () => {
+    const schema = password({ label: "TEST", lowercase: true })
+    expect(() => schema.parse("UPPERCASE1!")).toThrow(messages.lowercase)
+    expect(schema.parse("Test1!")).toBe("Test1!")
+  })
+
+  it("should enforce digit requirement", () => {
+    const schema = password({ label: "TEST", digits: true })
+    expect(() => schema.parse("NoDigits!")).toThrow(messages.digits)
+    expect(schema.parse("With1!")).toBe("With1!")
+  })
+
+  it("should enforce special character requirement", () => {
+    const schema = password({ label: "TEST", special: true })
+    expect(() => schema.parse("NoSpecial1")).toThrow(messages.special)
+    expect(schema.parse("Valid1!")).toBe("Valid1!")
+  })
+})

package/tests/common/text.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it, beforeEach } from "vitest"
+import { Locale, setLocale, text } from "../../src"
+
+const locales = [
+  {
+    locale: "en",
+    messages: {
+      required: "TEST is required",
+      min: "TEST must be at least 5 characters",
+      max: "TEST must be at most 5 characters",
+      startsWith: "TEST must start with pre",
+      endsWith: "TEST must end with xyz",
+      includes: "TEST must include foo",
+      invalid: "TEST is invalid format",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "請輸入 TEST",
+      min: "TEST 長度至少 5 字元",
+      max: "TEST 長度最多 5 字元",
+      startsWith: "TEST 必須以「pre」開頭",
+      endsWith: "TEST 必須以「xyz」結尾",
+      includes: "TEST 必須包含「foo」",
+      invalid: "TEST 格式錯誤",
+    },
+  },
+] as const
+
+describe.each(locales)("text() locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  it("should pass with valid string", () => {
+    const schema = text({ label: "TEST" })
+    expect(schema.parse("hello")).toBe("hello")
+  })
+
+  it("should fail with empty string when required", () => {
+    const schema = text({ label: "TEST" })
+    expect(() => schema.parse("")).toThrow(messages.required)
+    expect(() => schema.parse(null)).toThrow(messages.required)
+    expect(() => schema.parse(undefined)).toThrow(messages.required)
+  })
+
+  it("should pass with null when not required", () => {
+    const schema = text({ label: "TEST", required: false })
+    expect(schema.parse("")).toBe(null)
+    expect(schema.parse(null)).toBe(null)
+    expect(schema.parse(undefined)).toBe(null)
+  })
+
+  it("should fail with string shorter than min", () => {
+    const schema = text({ label: "TEST", min: 5 })
+    expect(() => schema.parse("hi")).toThrow(messages.min)
+    expect(() => schema.parse("")).toThrow(messages.min)
+    expect(() => schema.parse(null)).toThrow(messages.min)
+    expect(() => schema.parse(undefined)).toThrow(messages.min)
+  })
+
+  it("should fail with string longer than max", () => {
+    const schema = text({ label: "TEST", max: 5 })
+    expect(() => schema.parse("hello world")).toThrow(messages.max)
+  })
+
+  it("should fail if does not start with specified string", () => {
+    const schema = text({ label: "TEST", startsWith: "pre" })
+    expect(schema.parse("prepaid")).toBe("prepaid")
+    expect(() => schema.parse("hello world")).toThrow(messages.startsWith)
+  })
+
+  it("should fail if does not end with specified string", () => {
+    const schema = text({ label: "TEST", endsWith: "xyz" })
+    expect(schema.parse("hello xyz")).toBe("hello xyz")
+    expect(() => schema.parse("hello world")).toThrow(messages.endsWith)
+  })
+
+  it("should fail if does not include specified substring", () => {
+    const schema = text({ label: "TEST", includes: "foo" })
+    expect(schema.parse("hello foo")).toBe("hello foo")
+    expect(() => schema.parse("hello world")).toThrow(messages.includes)
+  })
+
+  it("should fail if does not match regex", () => {
+    const schema = text({ label: "TEST", regex: /^[A-Z]+$/ })
+    expect(schema.parse("HELLO")).toBe("HELLO")
+    expect(() => schema.parse("hello")).toThrow(messages.invalid)
+  })
+})

package/tests/common/url.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach } from "vitest"
+import { setLocale, url, Locale } from "../../src"
+
+const locales = [
+  {
+    locale: "en",
+    messages: {
+      required: "TEST is required",
+      min: "TEST must be at least 20 characters",
+      max: "TEST must be at most 10 characters",
+      includes: "TEST must include company",
+      invalid: "TEST is invalid format",
+    },
+  },
+  {
+    locale: "zh-TW",
+    messages: {
+      required: "請輸入 TEST",
+      min: "TEST 長度至少 20 字元",
+      max: "TEST 長度最多 10 字元",
+      includes: "TEST 必須包含「company」",
+      invalid: "TEST 格式錯誤",
+    },
+  },
+] as const
+
+describe.each(locales)("url() locale: $locale", ({ locale, messages }) => {
+  beforeEach(() => setLocale(locale as Locale))
+
+  it("should pass for valid url", () => {
+    const schema = url({ label: "TEST" })
+    expect(schema.parse("https://example.com")).toBe("https://example.com")
+  })
+
+  it("should fail for invalid url format", () => {
+    const schema = url({ label: "TEST" })
+    expect(() => schema.parse("invalid-url")).toThrow(messages.invalid)
+  })
+
+  it("should enforce required when set", () => {
+    const schema = url({ label: "TEST", required: true })
+    expect(() => schema.parse("")).toThrow(messages.required)
+    expect(() => schema.parse(null)).toThrow(messages.required)
+    expect(() => schema.parse(undefined)).toThrow(messages.required)
+  })
+
+  it("should allow null if not required", () => {
+    const schema = url({ label: "TEST", required: false })
+    expect(schema.parse("")).toBe(null)
+    expect(schema.parse(null)).toBe(null)
+    expect(schema.parse(undefined)).toBe(null)
+  })
+
+  it("should enforce max length", () => {
+    const schema = url({ label: "TEST", max: 10 })
+    expect(() => schema.parse("https://verylongurl.com")).toThrow(messages.max)
+  })
+
+  it("should enforce min length", () => {
+    const schema = url({ label: "TEST", min: 20 })
+    expect(() => schema.parse("https://short.co")).toThrow(messages.min)
+  })
+
+  it("should enforce includes", () => {
+    const schema = url({ label: "TEST", includes: "company" })
+    expect(schema.parse("https://company.com")).toBe("https://company.com")
+    expect(() => schema.parse("https://other.com")).toThrow(messages.includes)
+  })
+})