Download the PHP package easiviotech/fabriq without Composer

Fabriq

Unified Swoole-powered application platform — serves HTTP APIs, per-tenant frontend builds, WebSocket realtime, background jobs, and event bus with first-class multi-tenancy. Built-in CI/CD deploys any frontend framework (React, Vue, Svelte, Angular, etc.) from Git. Optional add-on packages for live streaming and game server.

Brand: Fabrq • Runtime: PHP 8.2+ / Swoole • License: Proprietary

Architecture

Fabriq is a long-running Swoole server that hosts HTTP, frontend static files, WebSocket, queue processors, and event consumers in a single process. Every execution path enforces TenantContext — tenant isolation is guaranteed at the kernel level, including per-tenant frontend builds.

The platform serves both your API and your frontend from a single port — no Nginx or Apache required. Each tenant can have its own frontend build (React, Vue, Svelte, Angular, or any framework), cloned from Git and built automatically via CLI, API, or webhook.

Optional add-on packages extend the platform with live streaming (fabriq/streaming) and a real-time game server (fabriq/gaming) — install only what you need.

Core Packages

These packages are always active and form the foundation of every Fabriq application:

Optional Add-on Packages

These packages are disabled by default and installed separately. Enable them only if your application needs streaming or gaming capabilities:

See Enabling Add-on Packages for setup instructions.

Application Structure

Config Files

Tech Stack

Quick Start (Docker — Recommended)

Note: Swoole does not run natively on Windows. Docker is the recommended way to run Fabriq on all platforms.

1. Create a new project

Linux / macOS:

Windows:

Swoole runs inside Docker — --ignore-platform-req=ext-swoole is safe and expected on Windows/macOS.

Or clone directly: git clone https://github.com/easiviotech/fabriq-skeleton myapp && cd myapp

2. Start the full stack

Container names and ports are controlled by infra/.env:

This builds the app image (PHP 8.3 + Swoole + Redis extension) and starts six containers:

Multiple projects: To run multiple Fabriq-based projects side by side, give each a unique COMPOSE_PROJECT_NAME and different ports in infra/.env. Docker Compose auto-namespaces containers, volumes, and networks — no conflicts.

All application containers (app, processor, scheduler) start automatically. The processor and scheduler have restart: unless-stopped for crash recovery. Wait for MySQL to pass its health check (~15–30 seconds) before the services connect.

4. Verify the server is running

5. Access the database via Adminer

Open http://localhost:8080 and log in with:

6. View logs

7. Create a tenant

Stopping the stack

Quick Start (Local — Linux / macOS only)

Requires PHP 8.2+, Swoole extension, MySQL 8.0+, and Redis 7.x installed locally.

Health check

CLI Commands

Key Features

Frontend Serving & Build Automation (built-in)

Fabriq serves per-tenant frontend builds directly through Swoole — no Nginx or Apache required. Use any frontend framework (React, Vue, Svelte, Angular, Next.js, etc.) and Fabriq handles the rest.

Why serve frontends through Fabriq instead of Nginx, Vercel, or a CDN?

Features:

• Per-tenant builds — Each tenant gets their own frontend at public/{tenant-slug}/, resolved automatically from subdomain, header, JWT, or custom domain
• High performance — Swoole's sendfile() delivers files via zero-copy kernel transfer, no PHP memory allocation
• SPA fallback — Client-side routing works out of the box (index.html served for unmatched paths)
• Smart caching — Fingerprinted assets get immutable/1-year cache; HTML gets no-cache (CDN-ready)
• Custom domains — 3-tier resolution: static domain_map (O(1)), TenantResolver, DB lookup — add a domain by adding a DB row, no server restart
• Built-in CI/CD — Clone a tenant's Git repo, run npm build, deploy atomically with zero downtime
• Three trigger methods — CLI (frontend:build), API (POST /api/tenants/{id}/frontend/deploy), webhook (GitHub/GitLab push)
• Atomic deployments — Old build is swapped out atomically; users never see a half-built state
• Framework agnostic — Tenant A on React, tenant B on Vue, tenant C on plain HTML — all served from the same process
• Fallback directory — public/_default/ serves as the shared frontend (login, marketing) when a tenant has no custom build

See FRONTEND.md for the full guide.

fabriq/streaming — Live Streaming (add-on package)

Install: composer require fabriq/streaming — View on Packagist

• WebRTC signaling — SDP offer/answer and ICE candidate exchange over WebSocket
• FFmpeg transcoding — RTMP → HLS with configurable segment duration and playlist size
• Viewer tracking — Redis-backed concurrent viewer counting with heartbeats
• Chat moderation — Slow mode, word filters, per-stream ban lists
• CDN-ready — HLS segments served with appropriate Cache-Control headers

fabriq/gaming — Game Server (add-on package)

Install: composer require fabriq/gaming — View on Packagist

• Fixed tick-rate game loop — 10 Hz (casual), 30 Hz (realtime), 60 Hz (competitive) via Swoole\Timer
• UDP protocol — Low-latency binary communication using MessagePack
• Matchmaking — Redis ZSET-based skill ranking with expanding search range
• Pre-game lobbies — Ready checks, countdowns, auto-start
• Player reconnection — Configurable grace period preserving session and room state
• Delta state sync — Only changed state is sent to each player

Prometheus Metrics

Exposed at GET /metrics. Core metrics are always available; add-on metrics appear when the package is enabled.

Core metrics:

Streaming metrics (when fabriq/streaming is enabled):

Gaming metrics (when fabriq/gaming is enabled):

Testing

Documentation

Docs Site

The docs-site/ directory contains a full HTML documentation site with syntax-highlighted code examples, search, and navigation:

Packagist Packages

Fabriq's packages are published individually on Packagist. The core packages power every Fabriq application. The add-on packages are optional and installed only when needed.

Core Packages

Package	Packagist	Description
fabriq/kernel		Core container, config, context, server, service providers
fabriq/storage		Connection pools, DbManager, tenant-aware repositories
fabriq/observability		Structured logging, metrics, tracing
fabriq/tenancy		Multi-tenant context, resolution, config caching

Add-on Packages

Package	Packagist	Description
fabriq/streaming		WebRTC signaling, HLS transcoding, viewer tracking, chat
fabriq/gaming		Game loop, matchmaking, lobbies, UDP protocol, state sync

Enabling Add-on Packages

fabriq/streaming:

Then in your project:

1. Set STREAMING_ENABLED=1 environment variable (or 'enabled' => true in config/streaming.php)
2. Uncomment \App\Providers\StreamingServiceProvider::class in config/app.php

fabriq/gaming:

Then in your project:

1. Set GAMING_ENABLED=1 environment variable (or 'enabled' => true in config/gaming.php)
2. Uncomment \App\Providers\GamingServiceProvider::class in config/app.php

Dependency Graph

When you composer require fabriq/streaming, Composer automatically pulls in fabriq/kernel, fabriq/storage, and fabriq/observability.

Safety Rules

• All connections use per-worker pools (never global/shared)
• Context is reset per request/message/job (no state leakage)
• All DB queries enforce tenant_id via repository base class
• No pool-per-tenant (prevents connection explosion)
• Borrow → use → release in same coroutine (no stored connections)
• Streaming and gaming services are tenant-scoped — no cross-tenant data leakage
• Game state is per-worker; cross-worker coordination uses Redis
• FFmpeg child processes are tracked and cleaned up on stream end