messages
listlengths 2
2
| metadata
dict |
|---|---|
[
{
"content": "Show me Zod validation integrated with shadcn Form for email normalization before storage.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for email normalization before storage:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me how to create a Zod schema for username case-insensitive handling.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How should I structure Zod validation for username case-insensitive handling?",
"role": "user"
},
{
"content": "For username case-insensitive handling, 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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for username case-insensitive handling.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for username case-insensitive handling:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I handle validation errors for email normalization before storage in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for email normalization before storage:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "How do I handle validation errors for username case-insensitive handling in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for username case-insensitive handling:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "I need to validate search query preprocessing. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I need to validate form input sanitization. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for username case-insensitive handling?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for username case-insensitive handling:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "I'm building username case-insensitive handling. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For username case-insensitive handling, 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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "I'm building search query preprocessing. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For search query preprocessing, 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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I use Zod for email normalization before storage in a real application?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for email normalization before storage:\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 Trim/Lowercase",
"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 email normalization before storage?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for email normalization before storage:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How should I structure Zod validation for search query preprocessing?",
"role": "user"
},
{
"content": "For search query preprocessing, 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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I use Zod for form input sanitization in a real application?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for form input sanitization:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "What's the proper way to display Zod errors for form input sanitization?",
"role": "user"
},
{
"content": "Handle Zod validation errors for form input sanitization:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "What's the best way to validate search query preprocessing in TypeScript with Zod?",
"role": "user"
},
{
"content": "For search query preprocessing, 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 Trim/Lowercase",
"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 tag input normalization?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for tag input normalization:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "I need to validate tag input normalization. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"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 email normalization before storage?",
"role": "user"
},
{
"content": "Handle Zod validation errors for email normalization before storage:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "What's the proper way to display Zod errors for tag input normalization?",
"role": "user"
},
{
"content": "Handle Zod validation errors for tag input normalization:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "How do I validate tag input normalization with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me a validation pattern for search query preprocessing using Zod.",
"role": "user"
},
{
"content": "For search query preprocessing, 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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the best way to validate form input sanitization in TypeScript with Zod?",
"role": "user"
},
{
"content": "For form input sanitization, 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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the proper way to display Zod errors for username case-insensitive handling?",
"role": "user"
},
{
"content": "Handle Zod validation errors for username case-insensitive handling:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Show me error handling patterns for Zod validation of tag input normalization.",
"role": "user"
},
{
"content": "Handle Zod validation errors for tag input normalization:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "What's the pattern for Zod + React Hook Form for form input sanitization?",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for form input sanitization:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "I need to validate email normalization before storage. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me how to create a Zod schema for search query preprocessing.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me a validation pattern for form input sanitization using Zod.",
"role": "user"
},
{
"content": "For form input sanitization, 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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "What's the Zod schema for username case-insensitive handling?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for email normalization before storage?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for email normalization before storage:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me Zod validation with React Hook Form for search query preprocessing.",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for search query preprocessing:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "What does Zod integration look like for form input sanitization?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for form input sanitization:\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "Can you help me write a Zod validator for email normalization before storage?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .trim() → .toLowerCase():\n\n```typescript\nimport { z } from \"zod\"\n\nconst normalizedEmail = z.string()\n .trim()\n .toLowerCase()\n .email()\n\n// \" [email protected] \" → \"[email protected]\"\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 Trim/Lowercase",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the Zod schema for event datetime parsing?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for event datetime parsing?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for event datetime 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 DateTime ISO",
"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 log entry timestamp verification?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for log entry timestamp 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",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "What's the best way to validate scheduled task time validation in TypeScript with Zod?",
"role": "user"
},
{
"content": "For scheduled task time 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I validate API timestamp validation with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for API timestamp validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for API timestamp 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 DateTime ISO",
"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 booking datetime validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for booking datetime 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "What does Zod integration look like for API timestamp validation?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for API timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "What's the Zod schema for scheduled task time validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I need to validate API timestamp validation. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me a validation pattern for booking datetime validation using Zod.",
"role": "user"
},
{
"content": "For booking datetime 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for API timestamp validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for API timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me a validation pattern for API timestamp validation using Zod.",
"role": "user"
},
{
"content": "For API timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for booking datetime validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for booking datetime 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I integrate Zod with React Hook Form for scheduled task time validation?",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for scheduled task time 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",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "rhf",
"pattern_name": "String DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Can you help me write a Zod validator for log entry timestamp verification?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me Zod validation with React Hook Form for scheduled task time validation.",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for scheduled task time 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for log entry timestamp verification.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for log entry timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "What does Zod integration look like for scheduled task time validation?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for scheduled task time 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "Show me how to create a Zod schema for log entry timestamp verification.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How do I use Zod for API timestamp validation in a real application?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for API timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "What's the best way to validate log entry timestamp verification in TypeScript with Zod?",
"role": "user"
},
{
"content": "For log entry timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How should I structure Zod validation for log entry timestamp verification?",
"role": "user"
},
{
"content": "For log entry timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for scheduled task time validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for scheduled task time 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me how to create a Zod schema for booking datetime validation.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Can you help me write a Zod validator for event datetime parsing?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I'm building API timestamp validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For API timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "Show me a practical example of Zod validation for API timestamp validation.",
"role": "user"
},
{
"content": "Here's a practical Zod integration for API timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for event datetime parsing?",
"role": "user"
},
{
"content": "Handle Zod validation errors for event datetime 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Show me how to create a Zod schema for event datetime parsing.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How should I structure Zod validation for booking datetime validation?",
"role": "user"
},
{
"content": "For booking datetime 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "I'm building scheduled task time validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For scheduled task time 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I integrate Zod with React Hook Form for API timestamp validation?",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for API timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I validate scheduled task time validation with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"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 log entry timestamp verification?",
"role": "user"
},
{
"content": "Handle Zod validation errors for log entry timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "Show me how to create a Zod schema for scheduled task time validation.",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "Can you help me write a Zod validator for API timestamp validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "I need to validate scheduled task time validation. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the proper way to display Zod errors for log entry timestamp verification?",
"role": "user"
},
{
"content": "Handle Zod validation errors for log entry timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "error_handling"
}
|
[
{
"content": "What's the best way to validate event datetime parsing in TypeScript with Zod?",
"role": "user"
},
{
"content": "For event datetime parsing, 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "validation_pattern"
}
|
[
{
"content": "I need to validate event datetime parsing. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.string() → .datetime():\n\n```typescript\nimport { z } from \"zod\"\n\nconst timestampSchema = z.string().datetime()\n\n// Validates ISO 8601: \"2024-01-15T10:30:00Z\"\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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "schema_definition"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for scheduled task time validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for scheduled task time 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me Zod validation with React Hook Form for booking datetime validation.",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for booking datetime 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for event datetime parsing?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for event datetime 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",
"shadcn",
"react-hook-form"
],
"library_version": "4.1.13",
"license": "MIT (Zod)",
"meta_type": "shadcn",
"pattern_name": "String DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for log entry timestamp verification?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for log entry timestamp 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "meta_example"
}
|
[
{
"content": "Show me a practical example of Zod validation for scheduled task time validation.",
"role": "user"
},
{
"content": "Here's a practical Zod integration for scheduled task time 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 DateTime ISO",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "string",
"template_type": "integration_example"
}
|
[
{
"content": "Can you help me write a Zod validator for rating score validation?",
"role": "user"
},
{
"content": "Define a Zod schema using z.number() → .int():\n\n```typescript\nimport { z } from \"zod\"\n\nconst ageSchema = z.number().int(\"Must be a whole number\")\n\n// Validates: 25\n// Rejects: 25.5\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for pagination page number?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for pagination page number:\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.number(),\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "meta_example"
}
|
[
{
"content": "What's the proper way to display Zod errors for age field validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for age field validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "error_handling"
}
|
[
{
"content": "I'm building age field validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For age field validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "validation_pattern"
}
|
[
{
"content": "How can I get user-friendly error messages from Zod for quantity input validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for quantity input validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "error_handling"
}
|
[
{
"content": "Show me a practical example of Zod validation for age field validation.",
"role": "user"
},
{
"content": "Here's a practical Zod integration for age field validation:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "integration_example"
}
|
[
{
"content": "How do I use Zod for pagination page number in a real application?",
"role": "user"
},
{
"content": "Here's a practical Zod integration for pagination page number:\n\n```typescript\nimport { z } from \"zod\"\n\n// 1. Define schema\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "integration_example"
}
|
[
{
"content": "What's the pattern for combining Zod and shadcn/ui for age field validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for age field 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.number(),\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "meta_example"
}
|
[
{
"content": "How do I validate quantity input validation with Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.number() → .int():\n\n```typescript\nimport { z } from \"zod\"\n\nconst ageSchema = z.number().int(\"Must be a whole number\")\n\n// Validates: 25\n// Rejects: 25.5\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me Zod validation with React Hook Form for rating score validation.",
"role": "user"
},
{
"content": "Here's Zod with React Hook Form for rating score 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.number(),\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "meta_example"
}
|
[
{
"content": "How do I handle validation errors for rating score validation in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for rating score validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "error_handling"
}
|
[
{
"content": "How should I structure Zod validation for inventory count validation?",
"role": "user"
},
{
"content": "For inventory count validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "validation_pattern"
}
|
[
{
"content": "How do I handle validation errors for age field validation in Zod?",
"role": "user"
},
{
"content": "Handle Zod validation errors for age field validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "error_handling"
}
|
[
{
"content": "Show me how to create a Zod schema for inventory count validation.",
"role": "user"
},
{
"content": "Define a Zod schema using z.number() → .int():\n\n```typescript\nimport { z } from \"zod\"\n\nconst ageSchema = z.number().int(\"Must be a whole number\")\n\n// Validates: 25\n// Rejects: 25.5\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "schema_definition"
}
|
[
{
"content": "What's the proper way to display Zod errors for quantity input validation?",
"role": "user"
},
{
"content": "Handle Zod validation errors for quantity input validation:\n\n```typescript\nimport { z } from \"zod\"\n\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "error_handling"
}
|
[
{
"content": "I need to validate age field validation. How do I do this in Zod?",
"role": "user"
},
{
"content": "Define a Zod schema using z.number() → .int():\n\n```typescript\nimport { z } from \"zod\"\n\nconst ageSchema = z.number().int(\"Must be a whole number\")\n\n// Validates: 25\n// Rejects: 25.5\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "schema_definition"
}
|
[
{
"content": "Show me Zod validation integrated with shadcn Form for inventory count validation.",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for inventory count 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.number(),\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "meta_example"
}
|
[
{
"content": "How do I use Zod with shadcn/ui Form for quantity input validation?",
"role": "user"
},
{
"content": "Here's Zod integrated with shadcn/ui Form for quantity 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.number(),\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "meta_example"
}
|
[
{
"content": "I'm building inventory count validation. What Zod pattern should I use?",
"role": "user"
},
{
"content": "For inventory count validation, use this Zod pattern:\n\n```typescript\nimport { z } from \"zod\"\n\n// Define schema\nconst schema = z.number()\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": "Number Integer",
"source": "Zod (v4.1.13) SFT dataset",
"subcategory": "number",
"template_type": "validation_pattern"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.