7nohe/laravel-zodgen

The library lets you generate Zod schemas from Laravel FormRequests

Laravel Zodgen

This is a package that generates Zod schemas from Laravel FormRequests. This allows you to share your validation rules between your Laravel backend and your TypeScript frontend.

Features

• Generate Zod schemas from Laravel FormRequests
• Support Nested arrays and objects

Supported Versions

This library supports the following versions:

• Laravel 9.x and 10.x
• TypeScript 5.0 and above

Installation

$ npm install -D @7nohe/laravel-zodgen

Usage

Edit package.json

{
    "scripts": {
        "zodgen": "laravel-zodgen"
    },
}

$ npm run zodgen

Example

For example, you have the FormRequest class below.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StorePostRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, \Illuminate\Contracts\Validation\Rule|array|string>
     */
    public function rules(): array
    {
        return [
            'title' => 'required|string|max:255',
            'body' => 'required|string',
        ];
    }
}

After running the zodgen command, you will get the following output.

export const StorePostRequest = z.object({
    title: z.string().max(255).nonempty(),
    body: z.string().nonempty()
});

Optionally you can use --coercion option to coerce primitive values.

export const StorePostRequest = z.object({
    title: z.coerce.string().max(255).nonempty(),
    body: z.coerce.string().nonempty()
});

Available options

Usage: laravel-zodgen [options]

Generate Zod schemas from Laravel FormRequests

Options:
  -V, --version         output the version number
  -o, --output <value>  Output directory (default: "resources/js")
  --form-request-path   Path for Laravel's FormRequest classes
  --coercion            Coercion for primitives (default: false)
  -h, --help            display help for command

Inertia Vue Form

This library is an extension of Inertia's useForm(), enabling form validation using Zod. You can directly use the code generated from Laravel Zodgen in this library.

Development

Setup example project

$ cd examples/laravel10-app
$ cp .env.example .env
$ docker run --rm \
    -u "$(id -u):$(id -g)" \
    -v "$(pwd):/var/www/html" \
    -w /var/www/html \
    laravelsail/php81-composer:latest \
    composer install --ignore-platform-reqs
$ ./vendor/bin/sail up -d
$ ./vendor/bin/sail php artisan key:generate
$ ./vendor/bin/sail php artisan migrate --seed
$ ./vendor/bin/sail npm install

Debug

$ pnpm install
$ sh debug.sh

License

MIT

laravel-zodgen's Issues

Support an array of primitive values

The following code does not generate the correct Zod schema.

public function rules()
{
    return [
        'name' => 'required|string|max:255',
        'positions.*.id' => 'required|exists:positions,id',
        'positions.*.name' => 'required|string|max:255',
        'delete_positions.*' => 'required|exists:positions,id',
        'add_positions.*.name' => 'required|string|max:255',
    ];
}

The output will be like this.

export const UpdatePositionGroupRequest = z.object({
    name: z.coerce.string().max(255).nonempty(),
    positions: z.array(z.object({
        id: z.coerce.string().nonempty(),
        name: z.coerce.string().max(255).nonempty()
    })),
    delete_positions: z.object({
        *: z.coerce.string().nonempty()  // <- Wrong
    }),
    add_positions: z.array(z.object({
        name: z.coerce.string().max(255).nonempty()
    }))
});

Support an array of primitive values (arrays of rules)

public function rules()
    {
        return [
            'ids' => [
                'required', 'array'
            ],
            'ids.*' => [
                'integer',
                'exists:posts,id'
            ],
        ];
    }

The output is

export const DestroyPostsRequest = z.object({
    ids: z.object({
        0: z.object({
            name: z.any()
        }),
        1: z.object({
            name: z.any()
        }),
        *: z.number().int().optional()
    })
});

nonempty() is deprecated

Given the following StorePodcastRequest form request rules:

return [
    'title' => 'required|string|max:255',
    'duration' => 'required|number',
];

The generated Zod schema is:

export const StorePodcastRequest = z.object({
    title: z.string().max(255).nonempty(),
    duration: z.string().nonempty()
});

But nonempty has been marked as deprecated here:

https://github.com/colinhacks/zod/blob/master/src/types.ts#L985

Would you be interested in a Pull Request to fix it?