Download the PHP package rakhavirgiandi/laravel-apigator without Composer

Laravel Apigator

Auto-generate production-ready CRUD APIs from your database tables — in seconds.

Laravel Apigator is a developer-experience-first package that reads your existing database schema and generates a full, working CRUD API stack: Model, Service, Controller, and Routes — all wired together and ready to use. No more boilerplate. No more copy-paste. Just run one command and your API is live.

It also ships with a powerful runtime query engine that gives every generated endpoint free filtering, sorting, full-text search, pagination, eager loading, and DataTables server-side support — all through query parameters, with zero extra code.

📖 Table of Contents

• Features ✨
• Requirements 📋
• Installation 📦
• Configuration ⚙️
• Quick Start 🚀
• The Generate Command 🛠️
  • Generating a Single Table
  • Generating All Tables
  • Selective Generation
  • Custom Directories
  • Multi-Database Connections
  • Force Overwrite
• Generated Files 📁
  • Model
  • Service
  • Controller
  • Routes
• Runtime Query API 🔍
  • Filtering
  • Sorting
  • Pagination
  • Full-Text Search
  • OR Groups
  • Eager Loading (Relations)
• Schema Customization (mapSchema) 🗺️
  • Defining Fields
  • Adding JOINs
  • Static WHERE Conditions
  • Raw SQL Expressions
• DataTables Integration 📊
• Model Revamping 🔄
• Exception Handling 🚨
• Traits Reference 🧩
• Configuration Reference 🗂️
• License 📄

Features ✨

• One-command API generation — generates Model, Service, Controller, and Routes from any database table
• Generate all tables at once with --table=all, auto-skipping system tables
• Selective generation — only generate what you need (model, service, controller, route)
• Smart validation rules — auto-derived from column types with name-based heuristics (email, phone, uuid, slug, url, coordinates, and more)
• Automatic type casting — $casts populated from database column types
• Soft Delete detection — automatically adds SoftDeletes trait when a deleted_at column is present
• Rich runtime query API — filter, sort, search, and paginate any endpoint with query parameters
• 16 filter operators — from eq/neq to between, in, like, null, date_from, and more
• Eager loading — load Eloquent relations on-the-fly via ?with=relation1,relation2.nested
• DataTables server-side — every generated controller includes a /resource_datatable endpoint
• Schema customization — define custom SELECT columns, JOINs, and static WHERE conditions via mapSchema()
• Model Revamping — surgically update an existing model's casts, rules, and schema when your table changes
• Multi-database connection support — target any configured database connection
• SQL injection safe — all column names are whitelisted and sanitized
• OpenAPI annotations — controller methods pre-annotated for Swagger/L5-Swagger

Requirements 📋

Supported databases: MySQL, MariaDB, PostgreSQL, SQLite, SQL Server.

Installation 📦

Install the package via Composer:

Laravel's auto-discovery will register the service provider automatically. No manual registration is required.

Optionally, publish the configuration file:

This creates config/apigator.php in your project, which you can customize to your liking.

Configuration ⚙️

After publishing, open config/apigator.php:

All settings can also be overridden at runtime via command-line options (see Command Reference).

Quick Start 🚀

Suppose you have a products table. Run:

That's it. Apigator will create:

Your API is now fully functional:

The Generate Command 🛠️

Generating a Single Table

Generates Order, OrderService, OrderController, and appends routes for the orders table.

Generating All Tables

Iterates every table in the database, skipping the ones listed in exclude_tables. Reports generated vs. skipped at the end.

Selective Generation

Use --generate to control which components are created. Accepts a comma-separated list of: model, service, controller, route.

Note: The generator respects dependency order. Generating a controller requires the service file to already exist, and generating a service requires the model to exist.

Custom Directories

Override the default output paths on a per-run basis:

Namespaces are derived automatically from the directory path (e.g. Domain/Users/Models → App\Domain\Users\Models).

Multi-Database Connections

Target any connection defined in config/database.php:

When a non-default connection is specified, the generated model will include a $connection property set to that connection name.

Force Overwrite

By default, Apigator will not overwrite existing files. Add --force to regenerate:

⚠️ This will completely replace existing model, service, and controller files. Any manual customizations will be lost. Consider using --revamp-table to update only specific sections of an existing model.

Generated Files 📁

Model is a fully-featured Eloquent model with:

$fillable — automatically populated with all non-system columns (id, created_at, updated_at, deleted_at are excluded):

$casts — column types are mapped to appropriate PHP types:

Validation rules — both createRules() (for POST) and updateRules() (for PATCH) are auto-generated with smart type + name-based heuristics. See the full Validation Rules table below.

mapSchema() — a customizable method that defines which columns to SELECT, any JOINs to apply, and static WHERE conditions. See Schema Customization.

Soft Deletes — if a deleted_at column is detected, the SoftDeletes trait is automatically imported and applied.

Validation Rules Reference

Beyond basic type rules, Apigator applies smart name-based heuristics:

Service (app/Services/ProductService.php) provides a clean static API for all CRUD operations. It handles validation, database transactions, and error handling for you.

Every mutating method (createRecord, updateRecord, deleteRecord) runs inside a database transaction and throws an ApigatorException on failure, which Laravel's exception handler renders automatically as a clean JSON response.

Controller (app/Http/Controllers/API/ProductController.php) is a thin layer that delegates to the service and formats responses:

All methods include pre-written OpenAPI / Swagger annotations (@OA\Get, @OA\Post, etc.), ready to be picked up by tools like L5-Swagger.

Routes to your route file (default: routes/api.php) inside a clearly marked block:

The use ProductController; import statement is also injected automatically. Running the command a second time will not duplicate routes — Apigator checks for the marker and skips gracefully.

Runtime Query API 🔍

Every generated endpoint supports a rich query API out of the box, driven entirely by request parameters. No extra code required.

Filtering

Append filter parameters as query strings. The default operator is eq (equality).

Use bracket notation to apply a specific operator:

Available operators:

Security: All column names are validated against a whitelist derived from your schema. Unknown or unallowed columns are silently ignored, preventing SQL injection.

Sorting

Use _sort to specify sort columns. Prefix with - for descending order. Chain multiple columns with commas.

Pagination

The response includes a meta object:

The per_page value is clamped between 1 and 1000. The default is controlled by default_per_page in the config.

Full-Text Search

Use _search to perform a LIKE search across all string-type columns simultaneously:

This generates a WHERE (col1 LIKE '%wireless headphones%' OR col2 LIKE '%wireless headphones%' OR ...) query across every searchable text column defined in your schema.

OR Groups

Combine multiple conditions with OR logic using the _or parameter:

This generates:

You can mix multiple operators within each group:

Eager Loading (Relations)

Load Eloquent relations on-the-fly without modifying the controller:

Apigator validates each relation segment against the model before passing it to ->with(). Invalid or misspelled relations are silently dropped, so a client typo will never cause a 500 error.

Schema Customization (mapSchema) 🗺️

The mapSchema() method is the heart of Apigator's query engine. It lets you control exactly which columns are selected, which tables are joined, and which conditions are always applied — all without touching controller or service logic.

The generated version selects only the table's own columns, but you can freely extend it.

Defining Fields

Each entry in 'field' maps an alias to a column expression:

Field definition keys:

Searchable columns: Only string-type fields are included in _search full-text queries. Set type accurately for correct behavior.

Adding JOINs

Extend the 'join' array to join related tables:

Then add the joined columns to 'field':

Supported join types: left, right, inner (default).

Static WHERE Conditions

Use 'where' to apply conditions that are always active, regardless of request parameters:

Raw SQL Expressions

Set is_raw => true to use any SQL expression as a column:

Dynamic Context in mapSchema

The $params arguments are passed in from the request, allowing you to build dynamic schemas:

DataTables Integration 📊

Every generated controller includes a datatable action that accepts a standard DataTables server-side POST payload:

The response follows the DataTables format:

The endpoint supports:

• Global search across all searchable: true string columns
• Per-column search via the columns[n].search.value field
• Multi-column ordering via the order array
• All dynamic filter parameters from the Runtime Query API, appended alongside DataTables parameters

Model Revamping 🔄

When your database schema changes (new columns added, types changed, columns removed), use --revamp-table to surgically update your existing model without losing any manual customizations:

The revamper only touches three sections of your model file:

Everything else — your Eloquent relations, custom methods, joins, static wheres, and comments — is left completely untouched.

Example workflow for an evolving schema:

Exception Handling 🚨

Apigator ships with two exception classes that integrate with Laravel's exception handler to return consistent JSON error responses automatically.

ApigatorException

A general-purpose HTTP exception. Laravel calls its render() method automatically, so you never need to manually catch it in controllers.

Named constructors for common scenarios:

JSON response shape:

ApigatorValidationException

Extends ApigatorException with field-level validation errors. Always returns HTTP 422.

JSON response shape:

Logging behavior: ApigatorException only logs to your error tracker for 5xx responses. ApigatorValidationException (422) is never logged, keeping your logs clean from expected client errors.

Traits Reference 🧩

ApiModelTrait

Mixed into every generated model. Provides the query engine that powers the runtime API.

You can call buildBaseQuery() directly in your own service methods if you need to build on top of the generated query:

ApiControllerTrait

Mixed into every generated controller. Provides standardized JSON response helpers.

Response shape for successResponse:

Configuration Reference 🗂️

License 📄

This package is open-source software licensed under the MIT License.

Made with ❤️ by Rakha R. Virgiandi