PHP code example of mohamed-amine-sayagh / zec

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

mohamed-amine-sayagh / zec example snippets

    use function Zec\Utils\z;

    // Define the user profile schema
    $userProfileParser = z()->options([
        'name' => z()->string()->min(3)->max(50),  // Name must be a string between 3 and 50 characters
        'age' => z()->number()->min(18),           // Age must be a number and at least 18
        'email' => z()->email(),                   // Email must be a valid email address
        'address' => z()->options([               
            'street' => z()->string(),             
            'city' => z()->string()                
        ]),
        'hobbies' => z()->each(z()->string()),     // Hobbies must be an array of strings
        'metadata' => z()->optional()->each(z()->options([  // Metadata is optional and must be an array of objects
            'key' => z()->string(),                // Each object must have a key as a string
            'value' => z()->string()               // Each object must have a value as a string
        ]))
    ]);

    // Parse and validate user data
    $userData = [
        'name' => 'Jane Doe',
        'age' => 1, // 1 is not a valid age
        'email' => 'jane.doe@examplecom', // missing dot
        'address' => [
            'street' => '123 Elm St',
            'city' => 3 // city is not a string
        ],
        'hobbies' => ['photography', 'traveling', 'reading', 5], // 5 is not a string     
        'metadata' => [
            ['key' => 'memberSince', 'value' => '2019'],
            ['key' => 'newsletter', 'value' => 'true']
        ]
    ];

    try {
        $userProfileParser->parseOrThrow($userData); // Throws an error
        echo "User data is valid\n";
    } catch (\Zec\ZecError $e) {
        echo "User data is invalid: ";
        $e->log(); // Log the error
    }

    use function Zec\Utils\z;
    $my_schema = z()->string();
    
    $response_valid = $my_schema->parse("Hello, World!"); // Returns Zec data object
    $value = $response_valid->value; // Returns "Hello, World!"

    $response_invalid = $my_schema->parse(123); // Returns Zec data object
    $errors = $response_invalid->errors; // Returns an array of ZecError object an exception extends class

    $is_valid = $my_schema->parse("Hello, World!")->isValid(); // Returns true
    $is_invalid = $my_schema->parse(123)->isValid(); // Returns false

    try {
        $response = $my_schema->parseOrThrow(123); // Throws ZecError
    } catch (ZecError $error) {
        $error_message = $error->message; // Returns "Invalid type: expected string, received integer"
        $error->log(); // Logs the error
    }

    use function Zec\z;

    $user_schema = z()->options([
        'name' => z()->string()->min(3)->max(50),
        'email' => z()->email(),
        'age' => z()->number()->min(18),
        'isActive' => z()->boolean(),
        'registrationDate' => z()->date()
    ]);

    // Parsing a valid user object
    $valid_user = $user_schema->parse([
        'name' => 'John Doe',
        'email' => '[email protected]',
        'age' => 30,
        'isActive' => true,
        'registrationDate' => '2021-01-01'
    ]);

    // Parsing an invalid user object
    $invalid_user = $user_schema->parse([
        'name' => 'JD', // Too short
        'email' => 'john.doe@', // Invalid email format
        'age' => 17, // Below minimum age 

    use function Zec\z;

    // Define a configurable email schema
    $my_configurable_email_schema = z()->string([
        'message' => 'Invalid string data'
    ])->min([
        'min' => 3,
        'message' => 'String data must be at least 3 characters long' // Custom message
    ])->max([
        'max' => 10,
        'message' => 'String {{value}} must be at most ((max)) characters long' // Custom message with value interpolation
    ]).email([
        'message' => 'Invalid email',
        'domain' => ['gmail.com', 'yahoo.com'] // Custom domain validation rules
    ]);

    // Define a user schema using the configurable email schema
    $my_user = z()->options([
        'email' => $my_configurable_email_schema->

    use function Zec\z;

    // Define a user schema with various data validation rules
    $user_parser = z()->options([
        'name' => z()-> => z()->number(),
        'friends' => z()->each(
            function ($user) {
                return $user->nullable();
            } // Each friend is a user object (nullable)
        ),
        'password' => z()->optional()->options([
            'password' => z()->string(),  // Path: 'password.password'
            'confirm_password' => z()->string(),
            'created_at' => z()->date(),
        ]),
        'created_at' => z()->date(),
        'updated_at' => z()->date(),
        'document' => z()->union([
            z()->options([
                'type' => z()->enum(['student']),
                'content' => z()->options([
                    'school' => z()->string(),
                    'grade' => z()->number(),
                ]),
            ]),
            z()->options([
                'type' => z()->enum(['teacher']),
                'content' => z()->options([
                    'school' => z()->string(),
                    'subject' => z()->string(),
                ]),
            ]),
        ]) // Union type for document, can be student or teacher document
    ]);

    // Parse a valid user object
    $user = $user_parser->parse([
        'name' => 'John Doe',
        'email' => '[email protected]',
        'age' => 25,
        'friends' => [
            [
                'name' => 'Jane Doe',
                'email' => '[email protected]',
                'age' => 30,
            ],
        ],
        'password' => [
            'password' => 'password',
            'confirm_password' => 'password',
            'created_at' => '2021-10-10'
        ],
        'created_at' => '2021-10-10',
        'updated_at' => '2021-10-10',
        'document' => [
            'type' => 'student',
            'content' => [
                'school' => 'School',
                'grade' => 10,
            ]
        ]
    ]); // Returns a Zec object

    // Validate the parsed data
    if ($user->isValid()) {
        echo 'User is valid.';
        var_dump($user->getValue()); // Outputs the validated data
    } else {
        echo 'User is invalid.';
        var_dump($user->errors()); // Outputs validation errors
    }

    use function Zec\z;
    use function Zec\bundler;
    use Zec\FIELD as FK;

    $custom_size_parser = parser_build()
        ->name('size')
        ->prioritize('string', 'number', 'array') // Prioritize the parser for string, number, and array types
        ->argument('message', 'Invalid size', function (Zec\Zec $z) {
            return $z->e'];
            $message = $args['message'];

            if (is_array($value)) {
                $actual_size = count($value);
            } elseif (is_string($value)) {
                $actual_size = strlen($value);
            } elseif (is_numeric($value)) {
                $actual_size = $value;
            } else {
                return $message ?? 'Invalid data type';
            }

            if ($actual_size === $expected_size) {
                return true;
            }
            return $message ?? 'Invalid size';
        })->priority(4); // priority of the parser, the default priority of parser is 10, parser with 5 as priority will override before parser with 10 as priority if they have the same parser name
        ->build(); // Build the parser

    bundler->addParser($custom_size_parser);

    $my_schema = z()->options([
        'username' => z()->string()->size(5), // Username must be a string of length 5
        'favorite_numbers' => z()->array()->size(5), // Favorite numbers must be an array of length 5
        'lucky_number' => z()->number()->size(5), // Lucky number must be 5
    ]);

    $user_data = [
        'username' => 'admin',
        'favorite_numbers' => [1, 2, 3, 4, 5],
        'lucky_number' => 5
    ]; // Valid data

    $parsed_data = $my_schema->parse($user_data); // Returns a Zec object

    // Validate the parsed data
    if ($parsed_data->isValid()) { // Returns true if data is valid
        echo 'All data is valid.';
    } else {
        echo 'Data validation failed. Errors: ';
        var_dump($parsed_data->errors()); // Outputs validation errors
    }