Scaffolding#

One command. Six files. A working CRUD feature with routes, templates, tests, and Swagger docs -- ready to run.

That is Tina4's scaffolding system. It generates the boilerplate you write by hand in every project: models, migrations, routes, forms, views, and tests. You describe what you want. The generators produce it.

The CRUD Generator#

This is the generator most developers reach for first. It creates everything a feature needs in one shot.

tina4php generate crud Product --fields "name:string,price:float"

That single command creates six files:

What Each File Contains#

The model maps the product table to a PHP class:

<?php​use Tina4\ORM;​class Product extends ORM{    public string $tableName = "product";    public ?int $id = null;    public ?string $name = null;    public ?float $price = null;    public ?string $createdAt = null;    public ?string $updatedAt = null;}

The migration creates the table:

-- migrations/20260401_create_product.sqlCREATE TABLE product (    id INTEGER PRIMARY KEY AUTOINCREMENT,    name VARCHAR(255),    price FLOAT,    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP);

The down migration reverses it:

-- migrations/20260401_create_product.down.sqlDROP TABLE IF EXISTS product;

The routes file wires up five endpoints with Swagger docs:

<?php​use Tina4\Router;​Router::get("/api/products", function ($request, $response) {    $products = (new Product())->select();    return $response($products);})->swagger(['summary' => 'List all products', 'tags' => ['products']]);​Router::get("/api/products/{id}", function ($request, $response) {    $product = new Product();    $product->id = $request->params["id"];    $product->load();    return $response($product);})->swagger(['summary' => 'Get a product by ID', 'tags' => ['products']]);​Router::post("/api/products", function ($request, $response) {    $product = new Product($request->body);    $product->save();    return $response($product, 201);})->swagger(['summary' => 'Create a product', 'tags' => ['products']]);​Router::put("/api/products/{id}", function ($request, $response) {    $product = new Product($request->body);    $product->id = $request->params["id"];    $product->save();    return $response($product);})->swagger(['summary' => 'Update a product', 'tags' => ['products']]);​Router::delete("/api/products/{id}", function ($request, $response) {    $product = new Product();    $product->id = $request->params["id"];    $product->delete();    return $response(null, 204);})->swagger(['summary' => 'Delete a product', 'tags' => ['products']]);

The route handler signature is function ($request, $response), $request first, $response second. Use ->swagger([...]) for OpenAPI metadata; the keys are pass-through to the generator (summary, tags, description, parameters, etc.).

The form template renders typed inputs with CSRF protection:

<form method="POST" action="/api/products">    <input type="hidden" name="form_token" value="{{ form_token }}">    <label>Name</label>    <input type="text" name="name" required>    <label>Price</label>    <input type="number" step="0.01" name="price" required>    <button type="submit">Save</button></form>

The test file stubs out CRUD assertions:

<?php​use PHPUnit\Framework\TestCase;use Tina4\App;​class ProductTest extends TestCase{    private $client;​    protected function setUp(): void    {        $app = new App();        $this->client = $app->testClient();    }​    public function testCreateProduct(): void    {        $response = $this->client->post("/api/products", ["name" => "Widget", "price" => 9.99]);        $this->assertEquals(201, $response->statusCode);    }​    public function testListProducts(): void    {        $response = $this->client->get("/api/products");        $this->assertEquals(200, $response->statusCode);    }​    public function testGetProduct(): void    {        $response = $this->client->get("/api/products/1");        $this->assertEquals(200, $response->statusCode);    }​    public function testUpdateProduct(): void    {        $response = $this->client->put("/api/products/1", ["name" => "Updated Widget"]);        $this->assertEquals(200, $response->statusCode);    }​    public function testDeleteProduct(): void    {        $response = $this->client->delete("/api/products/1");        $this->assertEquals(204, $response->statusCode);    }}

Run It#

After generating, run the migration and start the server:

tina4php migratetina4php serve

Open Swagger UI at http://localhost:7145/swagger and test every endpoint. The scaffolded code works out of the box.

Individual Generators#

The CRUD generator calls several smaller generators under the hood. You can call each one directly when you need a single piece.

Model#

tina4php generate model Product --fields "name:string,price:float"

Creates three files: the ORM model (src/orm/Product.php), the UP migration, and the DOWN migration. No routes, no templates, no tests.

Route#

tina4php generate route products --model Product

Creates one file: src/routes/products.php with CRUD endpoints and Swagger annotations. The model must exist first.

Migration#

tina4php generate migration add_category_to_product

Creates two files: migrations/20260401_add_category_to_product.sql and migrations/20260401_add_category_to_product.down.sql. Both are empty stubs. You write the SQL.

Middleware#

tina4php generate middleware AuthLog

Creates one file with before and after stubs:

<?php​use Tina4\Middleware;​Middleware::add("AuthLogBefore", function ($request) {    echo "Request: {$request->method} {$request->url}\n";    return $request;}, true); // before​Middleware::add("AuthLogAfter", function ($request, $response) {    echo "Response: {$response->statusCode}\n";    return $response;}, false); // after

Test#

tina4php generate test products --model Product

Creates one file: tests/ProductTest.php with PHPUnit CRUD stubs.

Form#

tina4php generate form Product --fields "name:string,price:float"

Creates one file: src/templates/products/form.html with typed inputs and form_token.

View#

tina4php generate view Product --fields "name:string,price:float"

Creates two templates: a list view and a detail view in src/templates/products/.

CRUD#

tina4php generate crud Product --fields "name:string,price:float"

Shorthand for running all generators at once: model, migration, route, form, view, and test.

Auth#

tina4php generate auth

Generates the full authentication scaffold: User model, migrations, login/register/logout routes, templates, and tests.

AutoCRUD#

AutoCRUD automatically generates REST API endpoints from your ORM models:

• GET /api/{table}, List with pagination (?limit=10&offset=0)
• GET /api/{table}/{id}, Get single record
• POST /api/{table}, Create record
• PUT /api/{table}/{id}, Update record
• DELETE /api/{table}/{id}, Delete record

Usage#

$crud = new AutoCrud($db, '/api');$crud->register(User::class);$crud->generateRoutes();

AutoCrud::register() wires up a single model class. generateRoutes() mounts the five standard endpoints automatically, no route files needed.

The Auth Generator#

Authentication needs more than one file. The auth generator creates seven:

tina4php generate auth

The generated routes handle password hashing, JWT token creation, and session management. The templates include CSRF tokens. The tests cover registration, login, invalid credentials, and logout.

Run the migration, start the server, and you have working auth:

tina4php migratetina4php serve

Field Types#

Generators accept these field types. Each type maps to a specific column type in migrations, input type in forms, and display format in views.

Table Naming Convention#

Tina4 uses singular table names. The model name Product maps to the table product. The model name OrderItem maps to order_item. The generator handles the conversion.

Combining Generators#

Sometimes you want a model with routes but no form. Or a model with a migration but no test. The --with flags let you compose:

tina4php generate model Product --fields "name:string,price:float" --with-route --with-migration

Available flags:

The generate crud command is equivalent to using all --with flags at once.

Exercise: Scaffold a Blog#

Build a blog with three resources using generators.

Step 1: Generate the auth system.

tina4php generate auth

Step 2: Scaffold the Post resource.

tina4php generate crud Post --fields "title:string,body:text,published:bool"

Step 3: Scaffold the Category resource.

tina4php generate crud Category --fields "name:string,description:text"

Step 4: Add a migration to link posts to categories.

tina4php generate migration add_category_id_to_post

Edit the migration to add the foreign key:

ALTER TABLE post ADD COLUMN category_id INTEGER REFERENCES category(id);

Step 5: Run all migrations and start the server.

tina4php migratetina4php serve

You now have a working blog with authentication, posts, categories, and Swagger documentation. Total commands: five. Total hand-written SQL: one line.

Gotchas#

Generators Do Not Overwrite#

If a file exists, the generator skips it and prints a warning. This protects your edits. To regenerate, delete the file first.

Run Migrate After Generate#

The model generator creates migration files. Those files do nothing until you run tina4php migrate. Generate and migrate are separate steps by design.

File Naming Matters#

The generator derives file names from the model name. Product becomes Product.php for the model and products.php for routes. Do not rename generated files unless you update all imports.

Field Changes Need New Migrations#

Changing --fields and re-running the generator does not update existing migrations. Create a new migration with generate migration and write the ALTER TABLE by hand.

Singular Table Names#

Tina4 uses singular table names: product, not products. The route paths use plural (/api/products), but the table stays singular. The generator handles this split.