PHP download

PHP code example of studiokaizen / framework

1. Go to this page and download the library: Download studiokaizen/framework library. Choose the download type require.

2. Extract the ZIP file and open the index.php.

3. Add this code to the index.php.

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

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

studiokaizen / framework example snippets


use Zen\Http\Request;
use Zen\Http\Response;

$app->get('/', function (Request $request, Response $response) use ($app): Response {
    return $app->view('home');
});

$app->post('/users', function (Request $request, Response $response) use ($app): Response {
    // ...
});

$app->put('/users/:id', function (Request $request, Response $response) use ($app): Response {
    $id = (int) $request->getRouteParam('id');
    // ...
});

$app->patch('/users/:id', function (Request $request, Response $response) use ($app): Response { /* ... */ });
$app->delete('/users/:id', function (Request $request, Response $response) use ($app): Response { /* ... */ });


$app->get('/posts/:id/comments/:commentId', function (Request $request, Response $response): Response {
    $postId    = (int) $request->getRouteParam('id');
    $commentId = (int) $request->getRouteParam('commentId');
    // ...
});


$app->get('/dashboard', $handler)->middleware('csrf', 'auth');
$app->post('/api/items', $handler)->middleware('token', 'throttle:60,1');


$app->group('/admin', function () use ($app): void {
    $app->get('/', $handler);
    $app->get('/users', $handler);
}, ['csrf', 'auth']);


$request->all();                          // all input (body + query)
$request->input('name');                  // single input value
$request->input('role', 'user');          // with default
$request->only('name', 'email');          // whitelist
$request->query('page', 1);              // query string value
$request->getRouteParam('id');            // route parameter
$request->getHeader('Authorization');     // request header
$request->isJson();                       // Content-Type: application/json
$request->isAjax();                       // X-Requested-With: XMLHttpRequest
$request->getMethod();                    // GET, POST, etc.
$request->getUri();                       // /path?query
$request->getIp();                        // client IP


return $app->view('template', $data);          // render a view (on $app, not $response)
return $response->json($data);                 // JSON response (200)
return $response->json($data, 201);            // JSON with status
return $response->redirect('/path');           // 302 redirect
return $response->status(404)->body('Not found.');
return $response->header('X-Custom', 'value')->json($data);


// resources/views/layout.php
<!DOCTYPE html>
<html>
<head>
    <title><?= $this->e($this->yield('title', 'App'))


// resources/views/home.php
 $this->extend('layout');


// Render from a route handler
return $app->view('home', ['name' => 'World']);


use Zen\Validation\ValidationException;

try {
    $data = $app->validator($request->all(), [
        'name'     => 'er|min:18',
        'website'  => 'url',
        'role'     => 'in:admin,editor,viewer',
    ])->validate();
} catch (ValidationException $e) {
    $e->errors(); // ['field' => ['message', ...]]
}


// Select
$users = $app['db']->table('users')->get();
$user  = $app['db']->table('users')->find(1);
$user  = $app['db']->table('users')->where('email', '[email protected]')->first();

// Chaining
$results = $app['db']->table('posts')
    ->where('user_id', $userId)
    ->where('published', 1)
    ->orderBy('created_at', 'DESC')
    ->limit(10)
    ->get();

// Insert / Update / Delete
$id = $app['db']->table('users')->insert(['name' => 'Alice', 'email' => '[email protected]']);
$app['db']->table('users')->where('id', $id)->update(['name' => 'Alice Smith']);
$app['db']->table('users')->where('id', $id)->delete();

// Aggregates
$count = $app['db']->table('users')->count();
$count = $app['db']->table('users')->where('active', 1)->count();

// Raw queries
$rows = $app['db']->select('SELECT * FROM posts WHERE user_id = ?', [$userId]);
$row  = $app['db']->selectOne('SELECT COUNT(*) AS total FROM users');
$app['db']->statement('UPDATE users SET active = 1 WHERE id = ?', [$id]);


$total = (int) $app['db']->selectOne('SELECT COUNT(*) AS n FROM posts')->n;
$items = $app['db']->select('SELECT * FROM posts ORDER BY id DESC LIMIT ? OFFSET ?', [$perPage, ($page - 1) * $perPage]);

$paginator = new \Zen\Database\Paginator($items, $total, $perPage, $page);

$paginator->items();
$paginator->total();
$paginator->currentPage();
$paginator->lastPage();
$paginator->hasMorePages();
$paginator->nextPage();
$paginator->previousPage();
$paginator->toArray();


// Login
$app['auth']->attempt($email, $password); // returns bool
$app['auth']->login($userId);
$app['auth']->logout();

// Current user
$app['auth']->check();         // bool
$app['auth']->id();            // int|null
$app['auth']->user();          // array|null


// Create a token for a user
$token = $app['tokens']->create($userId, 'api-token');

// Revoke
$app['tokens']->revoke($tokenId);

// Current token (inside a 'token' middleware route)
$app['auth']->token();


$app->registerMiddlewareAlias('custom', function ($app) {
    return new \App\Middleware\CustomMiddleware();
});


->middleware('csrf', 'auth')
->middleware('throttle:60,1')   // 60 requests per 1 minute


use Zen\Middleware\MiddlewareInterface;
use Zen\Http\Request;
use Zen\Http\Response;

class CustomMiddleware implements MiddlewareInterface
{
    public function handle(Request $request, Response $response, callable $next): Response
    {
        // before
        $response = $next($request, $response);
        // after
        return $response;
    }
}


$app['cache']->set('key', $value, $ttlSeconds);
$app['cache']->get('key');
$app['cache']->get('key', $default);
$app['cache']->has('key');
$app['cache']->forget('key');

// Compute and cache
$value = $app['cache']->remember('key', 300, function () {
    return expensiveOperation();
});


use Zen\Events\Event;

class UserRegistered extends Event
{
    public function __construct(
        public readonly int    $userId,
        public readonly string $email,
    ) {}
}


// Dispatch
$app['events']->dispatch(new UserRegistered($id, $email));

// Listen
$app['events']->addListener(UserRegistered::class, function (UserRegistered $event) use ($app): void {
    $app['logger']->info("New user #{$event->userId}");
});


use Zen\Queue\Job;

class SendWelcomeEmail extends Job
{
    public function __construct(
        public readonly string $name,
        public readonly string $email,
    ) {}

    public function handle(): void
    {
        // send email
    }
}


// Dispatch
$app['queue']->dispatch(new SendWelcomeEmail($name, $email));

// Dispatch to a named queue
$app['queue']->dispatch(new SendWelcomeEmail($name, $email), queue: 'emails');


// In AppServiceProvider::boot()
$app['scheduler']->call(function () use ($app): void {
    // task logic
})->daily();

$app['scheduler']->call(fn () => /* ... */)->hourly();
$app['scheduler']->call(fn () => /* ... */)->everyFifteenMinutes();
$app['scheduler']->call(fn () => /* ... */)->cron('0 9 * * 1'); // every Monday at 9am


use Zen\Mail\Message;

$app['mailer']->send(function (Message $message): void {
    $message->to('[email protected]', 'Alice')
            ->subject('Welcome!')
            ->text('Thanks for signing up.')
            ->html('<p>Thanks for signing up.</p>');
});

// Or pass a Message instance directly
$message = (new Message())
    ->to('[email protected]', 'Alice')
    ->subject('Welcome!')
    ->text('Thanks for signing up.');

$app['mailer']->send($message);


$app['session']->start();
$app['session']->set('key', $value);
$app['session']->get('key');
$app['session']->get('key', $default);
$app['session']->has('key');
$app['session']->forget('key');
$app['session']->flash('success', 'Saved!');   // one-time message
$app['session']->flash('success');              // read and clear
$app['session']->regenerate();
$app['session']->destroy();


// Encryption (app['encrypter']->encrypt('secret');
$plain     = $app['encrypter']->decrypt($encrypted);

// Hashing
$hash    = $app['hasher']->make($password);
$isValid = $app['hasher']->verify($password, $hash);


$app['storage']->disk('local')->put('file.txt', 'contents');
$app['storage']->disk('local')->get('file.txt');
$app['storage']->disk('local')->exists('file.txt');
$app['storage']->disk('local')->delete('file.txt');
$app['storage']->disk('local')->files('/');         // list files


$app['logger']->info('User logged in', ['id' => $userId]);
$app['logger']->warning('Disk space low');
$app['logger']->error('Payment failed', ['order' => $orderId]);


// Register a service (resolved lazily on first access)
$app['myService'] = fn ($app) => new MyService($app['db']);

// Register a raw value
$app['apiKey'] = 'abc123';

// Protect a closure so it is stored as-is, not invoked as a factory
$app['myCallback'] = $app->protect(fn ($value) => strtolower($value));

// Decorate an existing service
$app->extend('mailer', function ($mailer, $app) {
    $mailer->setLogger($app['logger']);
    return $mailer;
});

// Resolve
$service = $app['myService'];

// Check existence
isset($app['myService']);

// Retrieve the original factory closure (before resolution)
$factory = $app->raw('myService');


use Zen\DependencyInjection\ServiceProviderInterface;
use Zen\DependencyInjection\BootableProviderInterface;

class MyServiceProvider implements ServiceProviderInterface, BootableProviderInterface
{
    public function register(Application $app): void
    {
        $app['myService'] = fn ($app) => new MyService();
    }

    public function boot(Application $app): void
    {
        // runs after all providers are registered
    }
}


$app->registerProviders([new MyServiceProvider()]);


use Zen\Support\Str;

Str::slug('Hello World');           // hello-world
Str::camel('hello_world');          // helloWorld
Str::studly('hello_world');         // HelloWorld
Str::snake('helloWorld');           // hello_world
Str::contains('foobar', 'oba');     // true
Str::startsWith('foobar', 'foo');   // true
Str::endsWith('foobar', 'bar');     // true
Str::limit('Long text...', 10);     // 'Long text…'
Str::random(32);                    // random alphanumeric string


use Zen\Support\Arr;

Arr::get($array, 'user.address.city', 'Unknown');
Arr::set($array, 'user.name', 'Alice');
Arr::has($array, 'user.email');
Arr::forget($array, 'user.password');
Arr::only($array, ['name', 'email']);
Arr::except($array, ['password']);
Arr::flatten($array);
Arr::pluck($array, 'name');


use Zen\Support\Collection;

$col = new Collection([1, 2, 3, 4, 5]);

$col->map(fn ($n) => $n * 2);
$col->filter(fn ($n) => $n > 2);
$col->reduce(fn ($carry, $n) => $carry + $n, 0);
$col->first();
$col->last();
$col->count();
$col->toArray();


use Zen\Console\Command;

class GreetCommand extends Command
{
    public function name(): string
    {
        return 'greet';
    }

    public function description(): string
    {
        return 'Greet someone by name.';
    }

    public function handle(array $args, array $options): int
    {
        $name = $args[0] ?? 'World';
        $this->line('Hello, ' . $name . '!');
        return 0;
    }
}


$app['console']->add(new GreetCommand());

bash
php zen key:generate

bash
php zen migrate

bash
php zen make:migration create_posts_table
php zen migrate
php zen migrate:rollback
php zen migrate:fresh --seed
php zen migrate:status

bash
php zen queue:work
php zen queue:work --queue=emails
php zen queue:work --max-jobs=10