Generated Zod Schemas

/**
 * Article Zod Schemas
 * Blog article with author and categories
 * Generated by strapi2front
 */

import { z } from 'zod';

/**
 * Schema for creating a new Article
 */
export const articleCreateSchema = z.object({
  title: z.string().min(1).max(255),
  slug: z.string(),
  content: z.array(
    z.discriminatedUnion('type', [
      z.object({
        type: z.literal('paragraph'),
        children: z.array(z.object({
          type: z.literal('text'),
          text: z.string(),
        })),
      }),
      z.object({
        type: z.literal('heading'),
        level: z.number().int().min(1).max(6),
        children: z.array(z.object({
          type: z.literal('text'),
          text: z.string(),
        })),
      }),
      z.object({
        type: z.literal('list'),
        format: z.enum(['ordered', 'unordered']),
        children: z.array(z.object({
          type: z.literal('list-item'),
          children: z.array(z.object({
            type: z.literal('text'),
            text: z.string(),
          })),
        })),
      }),
    ])
  ),
  excerpt: z.string().optional(),
  coverImage: z.number().int().positive().nullable(),
  status: z.enum(['draft', 'published', 'archived']),
  views: z.number().int(),
  readingTime: z.number().int().optional(),
  featured: z.boolean().default(false),
  author: z.string().nullable(),  // documentId in v5
  categories: z.array(z.string()).default([]),  // array of documentIds
});

/**
 * Schema for updating an Article
 * All fields are optional for partial updates
 */
export const articleUpdateSchema = z.object({
  title: z.string().min(1).max(255).optional(),
  slug: z.string().optional(),
  content: z.array(z.any()).optional(),
  excerpt: z.string().optional(),
  coverImage: z.number().int().positive().nullable().optional(),
  status: z.enum(['draft', 'published', 'archived']).optional(),
  views: z.number().int().optional(),
  readingTime: z.number().int().optional(),
  featured: z.boolean().optional(),
  author: z.string().nullable().optional(),
  categories: z.array(z.string()).optional(),
});

// Type inference helpers
export type ArticleCreateInput = z.infer<typeof articleCreateSchema>;
export type ArticleUpdateInput = z.infer<typeof articleUpdateSchema>;

import { useForm } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { articleCreateSchema, type ArticleCreateInput } from '@/strapi/collections/article/schemas';
import { articleService } from '@/strapi/collections/article/service';

export function ArticleForm() {
  const { register, handleSubmit, formState: { errors } } = useForm<ArticleCreateInput>({
    resolver: zodResolver(articleCreateSchema),
  });
  
  const onSubmit = async (data: ArticleCreateInput) => {
    const article = await articleService.create(data);
    console.log('Created:', article);
  };
  
  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <div>
        <label>Title</label>
        <input {...register('title')} />
        {errors.title && <span>{errors.title.message}</span>}
      </div>
      
      <div>
        <label>Slug</label>
        <input {...register('slug')} />
        {errors.slug && <span>{errors.slug.message}</span>}
      </div>
      
      <div>
        <label>Status</label>
        <select {...register('status')}>
          <option value="draft">Draft</option>
          <option value="published">Published</option>
          <option value="archived">Archived</option>
        </select>
        {errors.status && <span>{errors.status.message}</span>}
      </div>
      
      <button type="submit">Create Article</button>
    </form>
  );
}

import { defineAction } from 'astro:actions';
import { articleCreateSchema } from '@/strapi/collections/article/schemas';
import { articleService } from '@/strapi/collections/article/service';

export const createArticle = defineAction({
  accept: 'form',
  input: articleCreateSchema,
  handler: async (input) => {
    const article = await articleService.create(input);
    return { success: true, article };
  },
});

import { useState } from 'react';
import { articleCreateSchema } from '@/strapi/collections/article/schemas';
import type { ArticleCreateInput } from '@/strapi/collections/article/schemas';
import { articleService } from '@/strapi/collections/article/service';

// Split schema into steps
const step1Schema = articleCreateSchema.pick({
  title: true,
  slug: true,
  excerpt: true,
});

const step2Schema = articleCreateSchema.pick({
  content: true,
  coverImage: true,
});

const step3Schema = articleCreateSchema.pick({
  status: true,
  author: true,
  categories: true,
});

export function CreateArticleWizard() {
  const [step, setStep] = useState(1);
  const [formData, setFormData] = useState<Partial<ArticleCreateInput>>({});
  
  const validateStep = (stepNum: number, data: unknown) => {
    const schemas = [step1Schema, step2Schema, step3Schema];
    return schemas[stepNum - 1].safeParse(data);
  };
  
  const handleNext = (stepData: unknown) => {
    const result = validateStep(step, stepData);
    
    if (result.success) {
      setFormData({ ...formData, ...result.data });
      setStep(step + 1);
    } else {
      console.error(result.error.errors);
    }
  };
  
  const handleSubmit = async (finalStepData: unknown) => {
    const finalData = { ...formData, ...finalStepData };
    const result = articleCreateSchema.safeParse(finalData);
    
    if (result.success) {
      await articleService.create(result.data);
    } else {
      console.error(result.error.errors);
    }
  };
  
  return (
    <div>
      {step === 1 && <Step1Form onNext={handleNext} />}
      {step === 2 && <Step2Form onNext={handleNext} />}
      {step === 3 && <Step3Form onSubmit={handleSubmit} />}
    </div>
  );
}