PHP code example of chevere / parameter

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

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

    

chevere / parameter example snippets

use function Chevere\Parameter\int;

$id = int(min: 1);
$id(5);    // returns 5
$id(-1);   // throws InvalidArgumentException

use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

$userSchema = arrayp(
    id: int(min: 1),
    name: string('/^[A-Z][a-z]+$/'),
);
$userSchema([
    'id' => 1,
    'name' => 'Rodolfo',
]);

use Chevere\Parameter\Attributes\_float;
use Chevere\Parameter\Attributes\_int;
use Chevere\Parameter\Attributes\_return;
use function Chevere\Parameter\validated;

#[_return(
    new _float(min: 0, max: 2400)
)]
function wageWeekWA(
    #[_int(min: 1628)]
    int $cents,
    #[_float(min: 0, max: 40)]
    float $hours,
): float {
    return $cents * $hours / 100;
}

$wage = validated('wageWeekWA', 1628, 40.0);

use function Chevere\Parameter\int;

$param = int(min: 0, max: 255);
$param->schema();
// ['type' => 'int', 'min' => 0, 'max' => 255]

use function Chevere\Parameter\nullInt;

$maybeId = nullInt(min: 1);
$maybeId(42);   // 42
$maybeId(null); // null

use function Chevere\Parameter\int;

// All three are independent instances
$base = int(min: 0);
$small = $base->withMax(100);
$large = $base->withMax(10000);

$parameter->withDescription('A human-readable label');
$parameter->withIsSensitive(true); // marks value as sensitive (omitted from error messages)
$parameter->withDefault($defaultValue); // sets a default value used when the parameter is optional and not provided

use function Chevere\Parameter\string;
use function Chevere\Parameter\int;

string('/^[a-z]+$/')->schema();
// ['type' => 'string', 'regex' => '/^[a-z]+$/']

int(min: 0, max: 100)->schema();
// ['type' => 'int', 'min' => 0, 'max' => 100]

use function Chevere\Parameter\string;

// Any string
$string = string();

// String matching "bin-" followed by digits
$string = string('/^bin-[\d]+$/');
$string('bin-123'); // 'bin-123'

// With a default value
$string = string(default: 'hello');

use Chevere\Parameter\Attributes\_string;

#[_string('/^bin-[\d]+$/')]

use function Chevere\Parameter\enum;

$status = enum('active', 'inactive', 'pending');
$status('active');  // 'active'
$status('deleted'); // throws

use Chevere\Parameter\Attributes\_enum;

#[_enum('active', 'inactive', 'pending')]

use function Chevere\Parameter\intString;

$int = intString();
$int('100'); // '100'
$int('abc'); // throws

use function Chevere\Parameter\boolString;

$bool = boolString();
$bool('0'); // '0'
$bool('1'); // '1'

use function Chevere\Parameter\date;

$date = date();
$date('2025-01-15'); // '2025-01-15'

use function Chevere\Parameter\time;

$time = time();
$time('14:30:00'); // '14:30:00'

use function Chevere\Parameter\datetime;

$datetime = datetime();
$datetime('2025-01-15 14:30:00');

// With fractional seconds (up to 6 digits)
$precise = datetime(precision: 6);
$precise('2025-01-15 14:30:00.123456');

use function Chevere\Parameter\int;

// Any integer
$int = int();
$int(42);

// Ranged
$int = int(min: 0, max: 100);
$int(50);  // 50
$int(200); // throws

// Whitelist
$int = int(accept: [1, 2, 3]);
$int(2);  // 2
$int(4);  // throws

// Blacklist
$int = int(reject: [0, -1]);
$int(5);  // 5
$int(0);  // throws

use Chevere\Parameter\Attributes\_int;

#[_int(min: 0, max: 100)]

use function Chevere\Parameter\boolInt;

$flag = boolInt();
$flag(0); // 0
$flag(1); // 1
$flag(2); // throws

use function Chevere\Parameter\float;

// Ranged
$price = float(min: 0.0, max: 9999.99);
$price(19.95); // 19.95

// Whitelist
$rate = float(accept: [0.5, 1.0, 1.5]);
$rate(1.0); // 1.0

// Blacklist
$score = float(reject: [0.0]);
$score(3.14); // 3.14

use Chevere\Parameter\Attributes\_float;

#[_float(min: 0, max: 100)]

use function Chevere\Parameter\bool;

$flag = bool();
$flag(true);  // true
$flag(false); // false

use Chevere\Parameter\Attributes\_bool;

#[_bool]

use function Chevere\Parameter\null;

$null = null();
$null(null); // null

use Chevere\Parameter\Attributes\_null;

#[_null]

use function Chevere\Parameter\object;

$object = object(stdClass::class);
$object(new stdClass()); // stdClass instance

use function Chevere\Parameter\mixed;

$any = mixed();
$any(1);
$any('hello');
$any(null);

use Chevere\Parameter\Attributes\_mixed;

#[_mixed]

use function Chevere\Parameter\union;
use function Chevere\Parameter\int;
use function Chevere\Parameter\null;
use function Chevere\Parameter\intString;
use function Chevere\Parameter\string;

// Nullable string
$union = union(string(), null());
$union('hello'); // 'hello'
$union(null);    // null

// Accept both digit strings and integers
$union = union(intString(), int());
$union('100'); // '100'
$union(100);   // 100

use function Chevere\Parameter\unionNull;
use function Chevere\Parameter\int;

$maybeInt = unionNull(int(min: 1));
$maybeInt(5);    // 5
$maybeInt(null); // null

use Chevere\Parameter\Attributes\_null;
use Chevere\Parameter\Attributes\_int;

#[_unionNull(
    new _int()
)]

use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

// Empty array
$array = arrayp();
$array([]); // []

// Required keys
$user = arrayp(
    id: int(min: 1),
    name: string('/^[A-Z][a-z]+$/'),
);
$user(['id' => 1, 'name' => 'Rodolfo']);

use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\float;
use function Chevere\Parameter\int;

$order = arrayp(
    id: int(min: 0),
    item: arrayp(
        sku: int(min: 0),
        price: float(min: 0),
    ),
);
$order([
    'id' => 1,
    'item' => [
        'sku' => 25,
        'price' => 16.50,
    ],
]);

use Chevere\Parameter\Attributes\_arrayp;
use Chevere\Parameter\Attributes\_float;
use Chevere\Parameter\Attributes\_int;

#[_arrayp(
    id: new _int(),
    item: new _arrayp(
        sku: new _int(),
        price: new _float(),
    ),
)]

$array = $array->withRequired(
    username: string(),
    email: string(),
);

$array = $array->withOptional(
    address: string(),
);

$array = $array->withModify(
    username: string('/^\w+$/'),
);

$array = $array->withMakeOptional('username');

$array = $array->withMakeRequired('email');

$array = $array->without('address');

$array = $array->withOptionalMinimum(1);

use function Chevere\Parameter\arrayString;
use function Chevere\Parameter\string;

$headers = arrayString(
    accept: string('/^application\/json$/'),
);
$headers(['accept' => 'application/json']);

use function Chevere\Parameter\file;
use function Chevere\Parameter\string;

// Default $_FILES shape validation
$upload = file();
$upload([
    'name' => 'report.pdf',
    'type' => 'application/pdf',
    'tmp_name' => '/tmp/phpABC123',
    'error' => 0,
    'size' => 4096,
]);

// With custom rules
$upload = file(
    name: string('/\.csv$/'),
    contents: string('/^id,name/'),
);

use function Chevere\Parameter\int;
use function Chevere\Parameter\iterable;

// List of non-negative integers
$ids = iterable(int(min: 0));
$ids([0, 1, 2, 3]);

use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;
use function Chevere\Parameter\iterable;
use function Chevere\Parameter\string;

$roster = iterable(
    V: arrayp(
        id: int(min: 0),
        name: string('/^[\w]{1,255}$/'),
    ),
    K: string(),
);
$roster([
    'player1' => [
        'id' => 1,
        'name' => 'OscarGangas',
    ],
    'player2' => [
        'id' => 2,
        'name' => 'BomboFica',
    ],
]);

use Chevere\Parameter\Attributes\_int;
use Chevere\Parameter\Attributes\_iterable;

#[_iterable(
    new _int(min: 0),
)]

use function Chevere\Parameter\string;
use function Chevere\Parameter\int;
use function Chevere\Parameter\float;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\iterable;
use function Chevere\Parameter\union;
use function Chevere\Parameter\null;

// String starting with "a"
string('/^a.+/')('ahhh');

// Integer in range
int(min: 1, max: 100)(50);

// Integer whitelist
int(accept: [1, 2, 3])(2);

// Float blacklist
float(reject: [1.1, 2.1])(3.14);

// Structured array
arrayp(
    id: int(min: 1),
    name: string('/^[A-Z]{1}\w+$/'),
)(['id' => 1, 'name' => 'Pepe']);

// Iterable with key rules
iterable(
    K: string('/ila$/'),
    V: int(min: 1),
)(['unila' => 1, 'dorila' => 2, 'tirifila' => 3]);

// Nullable integer
union(int(), null())(null);

use Chevere\Parameter\Attributes\_int;
use Chevere\Parameter\Attributes\_return;
use Chevere\Parameter\Attributes\_string;
use function Chevere\Parameter\validated;

#[_return(
    new String('/ok$/')
)]
function process(
    #[Int(min: 1, max: 10)]
    int $var,
): string {
    return 'done ok';
}

$result = validated('process', 5); // 'done ok'

use ReflectionFunction;
use function Chevere\Parameter\reflectionToParameters;
use function Chevere\Parameter\reflectionToReturn;

$reflection = new ReflectionFunction('process');
$parameters = reflectionToParameters($reflection);
$return = reflectionToReturn($reflection);

$parameters(...$args);               // validate arguments
$result = process(...$args);          // call
$return($result);                     // validate return

use Chevere\Parameter\Attributes\_enum;
use Chevere\Parameter\Attributes\_float;
use function Chevere\Parameter\Attributes\assertArguments;

function myEnum(
    #[_enum('Hugo', 'Paco', 'Luis')]
    string $name,
    #[_float(min: 1000)]
    float $money,
): void {
    // Validate all arguments
    assertArguments();
    // Or validate specific ones
    assertArguments('name');
    assertArguments('money');
}

myEnum('Paco', 1000.50);

use Chevere\Parameter\Attributes\_int;
use Chevere\Parameter\Attributes\_return;
use function Chevere\Parameter\Attributes\assertReturn;

#[_return(
    new _int(min: 0, max: 5)
)]
function clamp(): int
{
    $result = 3;

    return assertReturn($result);
}

use Chevere\Parameter\Attributes\_return;
use Chevere\Parameter\Attributes\_string;

#[_return(
    new _string('/ok$/')
)]
function myFunction(): string
{
    return 'done ok';
}

use Chevere\Parameter\Interfaces\ParameterInterface;
use Chevere\Parameter\Attributes\_callable;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\string;

function contactSchema(): ParameterInterface
{
    return arrayp(
        email: string(),
    )->withOptional(
        name: string(),
    );
}

function saveContact(
    #[_callable('contactSchema')]
    array $contact,
): void {
    // ...
}

use SensitiveParameter;
use Chevere\Parameter\Attributes\_int;

function authenticate(
    #[SensitiveParameter]
    #[_int(min: 1)]
    int $token,
): void {
    // $token value will be omitted from error messages
}

use function Chevere\Parameter\parameters;
use function Chevere\Parameter\arguments;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

$parameters = parameters(
    id: int(min: 1),
    name: string('/^[A-Z]{1}\w+$/'),
)->withOptional(
    email: string(),
);

$arguments = arguments($parameters, [
    'id' => 1,
    'name' => 'Pepe',
]);

// Check existence
$arguments->has('id');    // true
$arguments->has('nope');  // false

// Get as mixed
$id = $arguments->get('id'); // 1

// Get with type safety
$id = $arguments->

$arguments = $arguments->withPut('email', '[email protected]');

// Only provided arguments
$array = $arguments->toArray();

// Including optional parameters filled with a default
$array = $arguments->toArrayFill(null);

use function Chevere\Parameter\parameters;
use function Chevere\Parameter\arguments;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\string;

$parameters = parameters(
    meta: arrayp(
        custom_data: arrayp(
            product: string(),
            product_id_external: string(),
        ),
    ),
);
$data = [
    'meta' => [
        'custom_data' => [
            'product' => 'Book',
            'product_id_external' => 'book_987654321',
        ],
    ],
];
$arguments = arguments($parameters, $data);
$product = $arguments
    ->nested('meta', 'custom_data')
    ->

use function Chevere\Parameter\typed;

$data = ['user' => ['age' => 30]];
$age = typed($data, 'user', 'age')->int(); // 30

use function Chevere\Parameter\castArguments;
use function Chevere\Parameter\parameters;
use function Chevere\Parameter\int;
use function Chevere\Parameter\bool;

$parameters = parameters(
    page: int(min: 1),
    active: bool(),
);
$arguments = castArguments($parameters, [
    'page' => '3',     // cast to int
    'active' => '1',   // cast to bool
]);

use function Chevere\Parameter\castValues;

$values = castValues($parameters, ['page' => '3', 'active' => '1']);
// ['page' => 3, 'active' => true]

use function Chevere\Parameter\parameters;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

// Required parameters via named arguments
$params = parameters(
    id: int(min: 1),
    name: string(),
);

// Add optional parameters
$params = $params->withOptional('email', string());

// Make a ams = $params->withMakeRequired('email');

// Remove a parameter
$params = $params->without('email');

// Merge with another Parameters instance
$params = $params->withMerge($otherParameters);

// Require at least n optional parameters
$params = $params->withOptionalMinimum(1);

$params->has('id');          // true
$params->ce<string>
$params->optionalMinimum();  // int
$params->get('id');          // ParameterInterface

$arguments = $params(id: 1, name: 'Rodolfo');

use function Chevere\Parameter\toParameter;

$param = toParameter('int'); // IntParameter

use function Chevere\Parameter\toUnionParameter;

$param = toUnionParameter('int', 'string'); // UnionParameter

use function Chevere\Parameter\assertNamedArgument;
use function Chevere\Parameter\int;

assertNamedArgument(
    name: 'age',
    parameter: int(min: 0),
    argument: 25,
);

use function Chevere\Parameter\arrayFrom;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

$source = arrayp(
    id: int(),
    name: string(),
    email: string(),
    age: int(),
);
$subset = arrayFrom($source, 'name', 'id');

use function Chevere\Parameter\takeKeys;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;

$keys = takeKeys(arrayp(id: int(), size: int()));
// ['id', 'size']

use function Chevere\Parameter\takeOne;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

$array = arrayp(
    id: int(min: 0),
    size: int(min: 100),
    name: string(),
);
$parameter = takeOne($array, 'size');

use function Chevere\Parameter\takeFrom;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

$array = arrayp(
    id: int(min: 0),
    size: int(min: 100),
    name: string(),
);
$iterator = takeFrom($array, 'size', 'name');

use function Chevere\Parameter\parametersFrom;
use function Chevere\Parameter\arrayp;
use function Chevere\Parameter\int;
use function Chevere\Parameter\string;

$array = arrayp(
    id: int(min: 0),
    size: int(min: 100),
    name: string(),
);
$parameters = parametersFrom($array, 'size', 'name');

use function Chevere\Parameter\getParameters;

$parameters = getParameters($object);

use function Chevere\Parameter\getType;

getType(1);     // 'int'
getType(true);  // 'bool'
getType(1.5);   // 'float'
getType(null);  // 'null'

use function Chevere\Parameter\parameterAttribute;
use Chevere\Parameter\Attributes\_string;

function myFunction(
    #[_string('/^bin-[\d]+$/')]
    string $foo,
): void {
    // ...
}

$attr = parameterAttribute('foo', 'myFunction');
$attr('bin-123'); // validates

use function Chevere\Parameter\reflectionToParameter;
;
$parameter = reflectionToParameter($reflection);

use function Chevere\Parameter\reflectionToParameters;

$parameters = reflectionToParameters($reflection);

$violations = [];
$parameters = reflectionToParameters($reflection, $violations);
// [
//     [
//         'parameter' => 'the_parameter',
//         'message' => 'Error message',
//     ],
// ]

use function Chevere\Parameter\reflectionToReturn;

$return = reflectionToReturn($reflection);

use function Chevere\Parameter\validated;

$result = validated('myFunction', $arg1, $arg2);

use Chevere\Parameter\Attributes\_arrayp;
use Chevere\Parameter\Attributes\_int;
use Chevere\Parameter\Attributes\_string;
use Chevere\Parameter\Attributes\_iterable;
use function Chevere\Parameter\Attributes\assertArguments;

function createUser(
    #[_arrayp(
        id: new _int(min: 1),
        role: new _arrayp(
            mask: new _int(accept: [64, 128, 256]),
            name: new _string('/[a-z]+/'),
            tenants: new _iterable(
                new _int(min: 1)
            ),
        ),
    )]
    array $user,
): void {
    assertArguments();
}

createUser([
    'id' => 10,
    'role' => [
        'mask' => 128,
        'name' => 'admin',
        'tenants' => [1, 2, 3, 4, 5],
    ],
]);

use Chevere\Parameter\Attributes\_arrayp;
use Chevere\Parameter\Attributes\_int;
use Chevere\Parameter\Attributes\_string;
use Chevere\Parameter\Attributes\_return;
use function Chevere\Parameter\Attributes\assertReturn;

#[_return(
    new _arrayp(
        id: new _int(min: 0),
        name: new _string(),
    )
)]
function fetchUser(): array
{
    $result = [
        'id' => 1,
        'name' => 'Peoples Hernandez',
    ];

    return assertReturn($result);
}

use ReflectionMethod;
use Chevere\Parameter\Attributes\_int;
use function Chevere\Parameter\reflectionToParameters;

$class = new class() {
    public function score(
        #[_int(accept: [1, 10, 100])]
        int $base,
    ): void {
    }
};

$reflection = new ReflectionMethod($class, 'score');
$parameters = reflectionToParameters($reflection);
$parameters(base: 10); // validates