messages
listlengths 2
2
| metadata
dict |
|---|---|
[
{
"content": "How do I use Zod with shadcn/ui Form for contact form email input?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for contact form email input:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me a validation pattern for invite email validation using Zod.",
"role": "user"
},
{
"content": "For invite email validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me a validation pattern for profile email update form using Zod.",
"role": "user"
},
{
"content": "For profile email update form, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "I need to validate contact form email input. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for user registration email validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for user registration email validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me how to create a Zod schema for invite email validation.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How should I structure Zod validation for profile email update form?",
"role": "user"
},
{
"content": "For profile email update form, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What does Zod integration look like for user registration email validation?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for user registration email validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for newsletter signup validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for newsletter signup validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "What's the best way to validate invite email validation in TypeScript with Zod?",
"role": "user"
},
{
"content": "For invite email validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for profile email update form?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for profile email update form:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "rhf",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me how to create a Zod schema for contact form email input.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Can you help me write a Zod validator for user registration email validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I need to validate invite email validation. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for profile email update form?",
"role": "user"
},
{
"content": "Handle Zod validation errors for profile email update form:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "What's the pattern for Zod errors with Tailwind CSS for user registration email validation?",
"role": "user"
},
{
"content": "Here's Zod validation with Tailwind-styled errors for user registration email validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { useState } from \"react\"\n\nconst schema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof schema>\n\nexport function ValidatedForm() {\n const [errors, setErrors] = useState<Record<string, string[]>>({})\n\n const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {\n e.preventDefault()\n const formData = new FormData(e.currentTarget)\n const data = Object.fromEntries(formData)\n\n const result = schema.safeParse(data)\n\n if (!result.success) {\n setErrors(result.error.flatten().fieldErrors)\n return\n }\n\n setErrors({})\n console.log(result.data)\n }\n\n return (\n <form onSubmit={handleSubmit} className=\"space-y-4\">\n <div>\n <input\n name=\"field\"\n className={`\n w-full px-3 py-2 border rounded-md\n ${errors.field \n ? \"border-red-500 focus:ring-red-500\" \n : \"border-gray-300 focus:ring-blue-500\"\n }\n `}\n />\n {errors.field && (\n <p className=\"mt-1 text-sm text-red-600\">\n {errors.field[0]}\n </p>\n )}\n </div>\n <button\n type=\"submit\"\n className=\"px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700\"\n >\n Submit\n </button>\n </form>\n )\n}\n```\n\n**Tailwind + Zod tips:**\n- Use conditional classes for error states\n- `flatten()` provides form-friendly error structure\n- Style error messages with `text-red-*` utilities",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for newsletter signup validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for newsletter signup validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for user registration email validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for user registration email validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me a practical example of Zod validation for newsletter signup validation.",
"role": "user"
},
{
"content": "Here's a practical Zod integration for newsletter signup validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "Show me how to create a Zod schema for newsletter signup validation.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the Zod schema for user registration email validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the Zod schema for contact form email input?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Can you help me write a Zod validator for contact form email input?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How do I use Zod for invite email validation in a real application?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for invite email validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "How do I validate newsletter signup validation with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What does Zod integration look like for invite email validation?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for invite email validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "How do I handle validation errors for invite email validation in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for invite email validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "I'm building contact form email input. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For contact form email input, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "I'm building newsletter signup validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For newsletter signup validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the proper way to display Zod errors for newsletter signup validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for newsletter signup validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for contact form email input.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for contact form email input:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for profile email update form.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for profile email update form:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for newsletter signup validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for newsletter signup validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me how to create a Zod schema for profile email update form.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the best way to validate user registration email validation in TypeScript with Zod?",
"role": "user"
},
{
"content": "For user registration email validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for invite email validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for invite email validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "I'm building invite email validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For invite email validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the proper way to display Zod errors for invite email validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for invite email validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Can you help me write a Zod validator for newsletter signup validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .email():\n\n```typescript\nimport { z } from \"zod\"\n\nconst emailSchema = z.string().email(\"Invalid email address\")\n\n// Usage\nconst result = emailSchema.safeParse(\"[email protected]\")\nif (result.success) {\n console.log(result.data) // string\n}\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me a validation pattern for contact form email input using Zod.",
"role": "user"
},
{
"content": "For contact form email input, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for newsletter signup validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for newsletter signup validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "How do I handle validation errors for newsletter signup validation in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for newsletter signup validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "How do I use Zod for profile email update form in a real application?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for profile email update form:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "How do I integrate Zod with React Hook Form for user registration email validation?",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for user registration email validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { useForm } from \"react-hook-form\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\n\nconst schema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof schema>\n\nexport function MyForm() {\n const {\n register,\n handleSubmit,\n formState: { errors },\n } = useForm<FormData>({\n resolver: zodResolver(schema),\n })\n\n const onSubmit = (data: FormData) => {\n console.log(data)\n }\n\n return (\n <form onSubmit={handleSubmit(onSubmit)}>\n <input {...register(\"field\")} />\n {errors.field && <span>{errors.field.message}</span>}\n <button type=\"submit\">Submit</button>\n </form>\n )\n}\n```\n\n**RHF + Zod benefits:**\n- Automatic validation on blur/change/submit\n- Type-safe form data from Zod schema\n- Error messages from Zod displayed via `errors`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me a validation pattern for newsletter signup validation using Zod.",
"role": "user"
},
{
"content": "For newsletter signup validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How should I structure Zod validation for contact form email input?",
"role": "user"
},
{
"content": "For contact form email input, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String Email",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What does Zod integration look like for callback URL verification?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for callback URL verification:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "What's the best way to validate callback URL verification in TypeScript with Zod?",
"role": "user"
},
{
"content": "For callback URL verification, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How should I structure Zod validation for social media profile link validation?",
"role": "user"
},
{
"content": "For social media profile link validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How should I structure Zod validation for webhook endpoint validation?",
"role": "user"
},
{
"content": "For webhook endpoint validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for image URL validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for image URL validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "rhf",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me a validation pattern for social media profile link validation using Zod.",
"role": "user"
},
{
"content": "For social media profile link validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "I need to validate social media profile link validation. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I'm building image URL validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For image URL validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the best way to validate social media profile link validation in TypeScript with Zod?",
"role": "user"
},
{
"content": "For social media profile link validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for social media profile link validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for social media profile link validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for image URL validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for image URL validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for website URL input validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for website URL input validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me how to create a Zod schema for webhook endpoint validation.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How do I handle validation errors for website URL input validation in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for website URL input validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Show me how to create a Zod schema for website URL input validation.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me a validation pattern for image URL validation using Zod.",
"role": "user"
},
{
"content": "For image URL validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the Zod schema for social media profile link validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the Zod schema for website URL input validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What does Zod integration look like for social media profile link validation?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for social media profile link validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "How do I use Zod for callback URL verification in a real application?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for callback URL verification:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "How do I handle validation errors for callback URL verification in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for callback URL verification:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "I need to validate website URL input validation. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I'm building social media profile link validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For social media profile link validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for callback URL verification?",
"role": "user"
},
{
"content": "Handle Zod validation errors for callback URL verification:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Show me a validation pattern for webhook endpoint validation using Zod.",
"role": "user"
},
{
"content": "For webhook endpoint validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How should I structure Zod validation for callback URL verification?",
"role": "user"
},
{
"content": "For callback URL verification, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for image URL validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for image URL validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "How should I structure Zod validation for image URL validation?",
"role": "user"
},
{
"content": "For image URL validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the Zod schema for image URL validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me a practical example of Zod validation for social media profile link validation.",
"role": "user"
},
{
"content": "Here's a practical Zod integration for social media profile link validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for website URL input validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for website URL input validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for website URL input validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for website URL input validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Show me a practical example of Zod validation for image URL validation.",
"role": "user"
},
{
"content": "Here's a practical Zod integration for image URL validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "How do I validate callback URL verification with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me how to create a Zod schema for callback URL verification.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How should I structure Zod validation for website URL input validation?",
"role": "user"
},
{
"content": "For website URL input validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me a validation pattern for callback URL verification using Zod.",
"role": "user"
},
{
"content": "For callback URL verification, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the proper way to display Zod errors for webhook endpoint validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for webhook endpoint validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for social media profile link validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for social media profile link validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "rhf",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Can you help me write a Zod validator for callback URL verification?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I'm building website URL input validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For website URL input validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for social media profile link validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for social media profile link validation:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I validate webhook endpoint validation with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me a validation pattern for website URL input validation using Zod.",
"role": "user"
},
{
"content": "For website URL input validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I validate image URL validation with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Can you help me write a Zod validator for image URL validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .url():\n\n```typescript\nimport { z } from \"zod\"\n\nconst urlSchema = z.string().url(\"Invalid URL format\")\n\n// Validates: \"https://example.com\"\n// Rejects: \"not-a-url\"\n```\n\n**Key points:**\n- Use `schema.parse(data)` to validate and throw on error\n- Use `schema.safeParse(data)` for error handling without exceptions\n- Extract TypeScript type with `z.infer<typeof schema>`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for callback URL verification?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for callback URL verification:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "rhf",
"pattern_name": "String URL",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I integrate Zod with React Hook Form for correlation ID verification?",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for correlation ID verification:\n\n```tsx\nimport { z } from \"zod\"\nimport { useForm } from \"react-hook-form\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\n\nconst schema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof schema>\n\nexport function MyForm() {\n const {\n register,\n handleSubmit,\n formState: { errors },\n } = useForm<FormData>({\n resolver: zodResolver(schema),\n })\n\n const onSubmit = (data: FormData) => {\n console.log(data)\n }\n\n return (\n <form onSubmit={handleSubmit(onSubmit)}>\n <input {...register(\"field\")} />\n {errors.field && <span>{errors.field.message}</span>}\n <button type=\"submit\">Submit</button>\n </form>\n )\n}\n```\n\n**RHF + Zod benefits:**\n- Automatic validation on blur/change/submit\n- Type-safe form data from Zod schema\n- Error messages from Zod displayed via `errors`",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String UUID",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for unique identifier parsing?",
"role": "user"
},
{
"content": "Handle Zod validation errors for unique identifier parsing:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.string()\n\nfunction validateWithErrors(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n // Method 1: Formatted errors (nested structure)\n const formatted = result.error.format()\n // { fieldName: { _errors: [\"message\"] } }\n\n // Method 2: Flattened errors (form-friendly)\n const flat = result.error.flatten()\n // { formErrors: [], fieldErrors: { field: [\"msg\"] } }\n\n // Method 3: Raw issues array\n result.error.issues.forEach(issue => {\n console.log(`${issue.path.join('.')}: ${issue.message}`)\n })\n\n return { success: false, errors: flat.fieldErrors }\n }\n\n return { success: true, data: result.data }\n}\n```\n\n**Error handling tips:**\n- Use `.flatten()` for form libraries (field-level errors)\n- Use `.format()` for nested object validation\n- Access `.issues` for custom error processing",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String UUID",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "I'm building session token format check. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For session token format check, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String UUID",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the best way to validate session token format check in TypeScript with Zod?",
"role": "user"
},
{
"content": "For session token format check, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String UUID",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What does Zod integration look like for correlation ID verification?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for correlation ID verification:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.string()\n\n// 2. Extract type for TypeScript\ntype SchemaType = z.infer<typeof schema>\n\n// 3. Create validation function\nexport function validate(data: unknown): SchemaType {\n return schema.parse(data)\n}\n\n// 4. Safe validation with error handling\nexport function safeValidate(data: unknown) {\n const result = schema.safeParse(data)\n if (!result.success) {\n throw new Error(result.error.issues[0].message)\n }\n return result.data\n}\n\n// 5. Type guard pattern\nexport function isValid(data: unknown): data is SchemaType {\n return schema.safeParse(data).success\n}\n```\n\n**Integration patterns:**\n- Use `parse()` when you want to throw on invalid data\n- Use `safeParse()` for graceful error handling\n- Create type guards for runtime type checking",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String UUID",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "Show me a validation pattern for resource ID validation using Zod.",
"role": "user"
},
{
"content": "For resource ID validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.string()\n\n// Validate with error handling\nfunction validate(input: unknown) {\n const result = schema.safeParse(input)\n\n if (!result.success) {\n return { success: false, errors: result.error.flatten() }\n }\n\n return { success: true, data: result.data }\n}\n\n// Type-safe usage\ntype ValidatedData = z.infer<typeof schema>\n```\n\n**Pattern benefits:**\n- Type-safe validation with automatic type inference\n- Detailed error messages for user feedback\n- No runtime exceptions with safeParse",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": false,
"libraries": [
"zod"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": null,
"pattern_name": "String UUID",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for unique identifier parsing.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for unique identifier parsing:\n\n```tsx\nimport { z } from \"zod\"\nimport { zodResolver } from \"@hookform/resolvers/zod\"\nimport { useForm } from \"react-hook-form\"\nimport {\n Form,\n FormControl,\n FormField,\n FormItem,\n FormLabel,\n FormMessage,\n} from \"@/components/ui/form\"\nimport { Input } from \"@/components/ui/input\"\nimport { Button } from \"@/components/ui/button\"\n\nconst formSchema = z.object({\n field: z.string(),\n})\n\ntype FormData = z.infer<typeof formSchema>\n\nexport function MyForm() {\n const form = useForm<FormData>({\n resolver: zodResolver(formSchema),\n defaultValues: { field: \"\" },\n })\n\n function onSubmit(data: FormData) {\n console.log(data)\n }\n\n return (\n <Form {...form}>\n <form onSubmit={form.handleSubmit(onSubmit)} className=\"space-y-4\">\n <FormField\n control={form.control}\n name=\"field\"\n render={({ field }) => (\n <FormItem>\n <FormLabel>Field</FormLabel>\n <FormControl>\n <Input {...field} />\n </FormControl>\n <FormMessage />\n </FormItem>\n )}\n />\n <Button type=\"submit\">Submit</Button>\n </form>\n </Form>\n )\n}\n```\n\n**shadcn + Zod pattern:**\n- Use `zodResolver` to connect Zod schema to React Hook Form\n- `FormMessage` automatically displays Zod validation errors\n- Type inference flows from schema to form to submission",
"role": "assistant"
}
] |
{
"category": "primitives",
"generation_date": "2025-12-15",
"has_code": true,
"is_meta_example": true,
"libraries": [
"zod",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "rhf",
"pattern_name": "String UUID",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 12