PHP code example of protoframework / proto

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

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

    

protoframework / proto example snippets

 declare(strict_types=1);
ze();

 declare(strict_types=1);
 declare(strict_types=1);
namespace Modules\User;

use Proto\Module\Module;
use Modules\User\Auth\Gates\RoleGate;

/**
 * UserModule
 *
 * This module handles user-related functionality.
 *
 * @package Modules\User
 */
class UserModule extends Module
{
	/**
	 * This will activate the module.
	 *
	 * @return void
	 */
	public function activate(): void
	{
		$this->setConfigs();
		$this->setAuthGates();
	}

	/**
	 * Set the .env configs for the module
	 * to the global configs registry.
	 *
	 * @return void
	 */
	private function setConfigs(): void
	{
		setEnv('settingName', 'value');

		// also read from the global configs
		// $domain = env('domain');
	}

	/**
	 * This will set the authentication gates.
	 *
	 * @return void
	 */
	private function setAuthGates(): void
	{
		$auth = auth();

		/**
		 * This will register the role gate globally to be
		 * consumed by all modules.
		 */
		$auth->role = new RoleGate();
	}

	/**
	 * Add module events to the global events pub sub.
	 *
	 * @return void
	 */
	protected function addEvents(): void
	{
		/**
		 * Add an event for when a ticket is added.
		 */
		$this->event('Ticket:add', function(object $ticket): void
		{
			var_dump($ticket);
		});
	}
}

 declare(strict_types=1);
namespace Modules\Example\Gateway;

/**
 * Gateway
 *
 * Gateways provide a public interface for module methods. They allow other modules to call functionality without exposing the internal workings of the module. Gateways can support
 * versioning for backward compatibility.
 *
 * @package Modules\Example\Gateway
 */
class Gateway
{
	/**
	 * Add a new example.
	 *
	 * @return void
	 */
	public function add(): void
	{
		// Implementation for adding an example.
	}

	/**
	 * Get the v1 gateway.
	 *
	 * @return V1\Gateway
	 */
	public function v1(): V1\Gateway
	{
		return new V1\Gateway();
	}

	/**
	 * Get the v2 gateway.
	 *
	 * @return V2\Gateway
	 */
	public function v2(): V2\Gateway
	{
		return new V2\Gateway();
	}
}

modules()->user()->add($data);


// In another module anywhere. Usually in a controller
modules()->example()->add();

// To use versioned methods:
modules()->example()->v1()->add();
modules()->example()->v2()->add();

 declare(strict_types=1);
namespace Modules\Auth\Controllers;

use Proto\Controllers\Controller;
use Proto\Http\Router\Request;

/**
 * AuthController
 *
 * This controller handles authentication-related actions.
 *
 * @package Modules\Auth\Controllers
 */
class AuthController extends Controller
{
	/**
	 * Register a new user.
	 *
	 * @return object
	 */
    public function register(): object
    {
		// Call the user module to add a new user.
        $result = modules()->user()->add();
		// do more things
    }
}

 declare(strict_types=1);
namespace Modules\User\Api;

use Modules\User\Controllers\UserController;
use Proto\Http\Middleware\CrossSiteProtectionMiddleware;

/**
 * User API Routes
 *
 * This file contains the API routes for the User module.
 */
router()
	->middleware([
		CrossSiteProtectionMiddleware::class
	])
	->resource('user', UserController::class);

 declare(strict_types=1);
namespace Modules\User\Api\Account;

use Modules\User\Controllers\UserController;

/**
 * User API Routes for Accounts
 *
 * This file handles API routes for user accounts.
 */
router()
	->resource('user/:userId/account', UserController::class);

 declare(strict_types=1);
namespace Modules\Auth\Api;

use Modules\Auth\Controllers\AuthController;
use Modules\Auth\Controllers\PasswordController;
use Proto\Http\Middleware\CrossSiteProtectionMiddleware;
use Proto\Http\Middleware\DomainMiddleware;
use Proto\Http\Middleware\ThrottleMiddleware;
use Proto\Http\Router\Router;

/**
 * Auth API Routes
 *
 * This file defines the API routes for user authentication, including
 * login, logout, registration, MFA, and CSRF token retrieval.
 */
router()
	->middleware(([ // add CSRF protection to all auth routes
		CrossSiteProtectionMiddleware::class
	]))

	// this will individually add routes by method
	->post('auth/pulse', [AuthController::class, 'pulse'])
	->post('auth/register', [AuthController::class, 'register'])

	// this will add a route and add a middleware to the route
	->get('auth/csrf-token', [AuthController::class, 'getToken'], [
		DomainMiddleware::class
	]);

/**
 * A group of routes that 

 declare(strict_types=1);
namespace Modules\User\Controllers;

use Modules\User\Models\User;
use Proto\Controllers\ModelController;

class UserController extends ModelController
{
}

 declare(strict_types=1);
namespace Modules\User\Controllers;

use Modules\User\Models\User;
use Proto\Controllers\ResourceController;
use Proto\Http\Router\Request;

class UserController extends ResourceController
{
	public function __construct(
		protected ?string $model = User::class
	)
	{
		parent::__construct();
	}

	/**
	 * Override the add method to  already taken.');
		}

		return $this->addItem($data);
	}
}

 declare(strict_types=1);
namespace Modules\User\Controllers;

use Proto\Controllers\ApiController;
use Proto\Http\Router\Request;

class SummaryController extends ApiController
{
	/**
	 * Get user summary data.
	 *
	 * @param Request $request
	 * @return object
	 */
	public function getSummary(Request $request): object
	{
		$userId = $request->params()->userId ?? null;
		if (!$userId)
		{
			return $this->error('User ID is 

// Success response with data
return $this->success(['items' => $data], 200);

// Error response with message
return $this->error('No user was found', 404);

// Generic response wrapper (handles null checks)
return $this->response($result, 'Custom message');

// Single row
protected function getByName(string $name): object
{
	$row = $this->model::getBy(['name' => $name]);
	if ($row === null)
	{
		return $this->error('No user was found');
	}

	return $this->response($row);
}

// Multiple rows
protected function getAllActive(): object
{
	$rows = $this->model::fetchWhere(['status' => 'active']);
	if (empty($rows))
	{
		return $this->error('No users were found');
	}

	return $this->success(['items' => $rows]);
}

// Custom query
protected function getRecentByName(string $name): object
{
	$rows = $this->model::where(['name' => $name])
		->orderBy('id DESC')
		->groupBy('id')
		->limit(10)
		->fetch();

	if (empty($rows))
	{
		return $this->error('No users were found');
	}

	return $this->response($rows);
}

public function resetPassword(Request $request): object
{
	$data = $this->getRequestItem($request);

	// Validate 
	}

	// Create a model instance with the provided data
	$model = $this->model($data);

	// Process the password reset action via the model
	$result = $model->resetPassword();
	return (!$result) ? $this->error('Password reset failed.') : $this->response($result);
}

public function add(Request $request): object
{
	// Get the request item (by default looks for 'item' key)
	$user = $this->getRequestItem($request);

	// Or access request data directly
	$username = $request->input('username');
	$email = $request->input('email');
	$status = $request->getInt('status');
	$save = $request->getBool('save');
	$user = $request->json('user');

	// Params
	$userId = $request->params()->userId;

	// Do something with the data
}

class UserController extends ResourceController
{
	// Override default 'item' key
	protected string $item = 'user';

	public function add(Request $request): object
	{
		// Now looks for 'user' key in request
		$user = $this->getRequestItem($request);
	}
}

/**
 * Validation rules for this controller.
 */
protected function validate(): array
{
	return [
		'id' => 'int|website' => 'url',
		'age' => 'int'
	];
}

public function addUser(Request $request): object
{
	// Validate using custom rules
	$data = $this->validateRules(
		$this->getRequestItem($request),
		[
			'username' => 'string:50|a);
}

public function updateStatus(Request $request): object
{
	$id = $this->getResourceId($request);
	$status = $request->input('status');

	if ($id === null || $status === null)
	{
		return $this->error('ID and status are 

// Create a model instance with data
$model = $this->model($data);
$result = $model->update();

// Access model storage directly for complex queries
$users = $this->storage()->findAll(function($sql, &$params) {
	$params[] = 'active';
	$sql->where('status = ?')
		->orderBy('created_at DESC')
		->groupBy('user_id')
		->limit(50);
});

// Single row with custom query
$user = $this->storage()->find(function($sql, &$params) {
	$params[] = '[email protected]';
	$sql->where('email = ?')
		->limit(1);
});

// If UserController doesn't define getUsersByRole(),
// it will automatically call User::getUsersByRole() and wrap the response
$result = $controller->getUsersByRole('admin');

// Get raw result without response wrapper
$result = static::$controllerType::methodName();

protected bool $qualifyFilters = true;

protected array $currentUserFlags = [
	'liked' => ['model' => PostLike::class, 'foreignKey' => 'postId']
];

protected array $enrichments = [
	'commentCount' => [
		'type' => 'count',
		'model' => Comment::class,
		'foreignKey' => 'postId',
		'

protected array $allowedIncludes = ['author', 'stats'];
protected array $defaultIncludes = [];

protected array $lookupKeys = ['id', 'guid', 'slug'];

$since = Filter::sinceLiteral('a', (string)$updatedAfter, ['updatedAt', 'createdAt']);
if ($since !== null)
{
	$sql->orWhere($since);
}

// the structure of the api folder
User/
  Api/
    Account/
      api.php (nested account file)
	api.php (root api file)