A comprehensive project skeleton for enterprise applications with integrated support for essential development services, following Domain-Driven Design (DDD) principles and Clean Architecture.

• Features
• Requirements
• Quick Start
• Frameworks
• Project Structure
• Architecture
• Infrastructure Components
• Development Tools
• Configuration
• Environment Variables
• Database Migrations
• Testing
• Troubleshooting
• Contributing
• License

• Modern PHP 8.5 with strict typing (declare(strict_types=1))
• Multiple web servers (Nginx, Apache)
• SQL databases (PostgreSQL, MySQL)
• NoSQL databases (MongoDB, Cassandra)
• Caching solutions (Redis, Memcached)
• Message brokers (RabbitMQ, Kafka)
• Search engines (Elasticsearch, Solr)
• Monitoring tools (Grafana, Zabbix, Prometheus)
• Mail testing (MailHog, Papercut)
• Logging systems (Kibana, Graylog, ELK stack)
• API documentation (Swagger/OpenAPI)
• Task scheduling (Cron)
• CQRS pattern with separate command/query/event buses
• Event Sourcing with Outbox pattern
• Request tracking with UUID v4

1. Clone the repository:

git clone https://github.com/your-org/enterprise-skeleton.git
cd enterprise-skeleton

2. Copy configuration:

make copy-config

3. Configure environment:
   • Edit infrastructure/config/cs-config to customize services
   • Uncomment what you need:

server=nginx            # Web Server: nginx, apache
database=postgres       # Database Service: postgres, mysql
;nosql=mongodb          # NoSQL Database Service: mongodb, cassandra
cache=redis             # Cache Service: redis, memcached
;search=elasticsearch   # Search: elasticsearch, solr
;message=kafka          # Message Broker: rabbitmq, kafka
docs=swagger            # API Documentation: swagger
;mailer=mailhog         # Mail Sandbox: mailhog, papercut
;monitoring=grafana     # Monitoring: grafana, zabbix
;logs=kibana            # Log Management: kibana, graylog
;job=cron               # Scheduling Jobs: cron

4. Install and start:

make install

5. Access the application:
   • HTTP: http://localhost:1000
   • HTTPS: https://localhost:1001
   • API Docs: http://localhost:1002

Switch between frameworks:

# Switch to Laravel framework
make framework laravel

# Switch to Symfony framework
make framework symfony

enterprise-skeleton/
├── code/                   # Application source code
│   ├── src/                # Domain modules
│   ├── config/             # Framework configuration
│   ├── migrations/         # Database migrations
│   └── tests/              # Test suite
├── infrastructure/         # Docker and infrastructure
│   ├── containers/         # Container configurations
│   ├── config/             # Infrastructure config
│   ├── scripts/            # Build scripts
│   └── docker-compose.yml  # Service composition
└── tools/                  # Development tools
    ├── postman/            # API test collections
    └── .php-cs-fixer.php   # Code style configuration

For detailed documentation:

• Application: See code/README.md for architecture, domains, and code organization
• Infrastructure: See infrastructure/README.md for Docker services and deployment

The application follows a layered DDD architecture:

src/
└── YourDomain/
    ├── Application/
    │   └── UseCases/
    │       ├── Query/
    │       └── Command/
    ├── DomainModel/
    │   ├── Model/
    │   ├── Repository/
    │   └── Service/
    ├── Infrastructure/
    │   ├── Persistence/
    │   └── Clients/
    ├── Presentation/
    │   ├── Api/
    │   ├── Console/
    │   └── Web/
    ├── Resources/
    │   └── Config/
    └── Tests/
        ├── Unit/
        └── Integration/

Three separate message buses handle different concerns:

Reliable event publishing using transactional outbox ensures events are persisted in the same transaction as domain changes:

Transaction Start
├── Save Domain Entity
├── Save Event to Outbox Table
Transaction Commit

Background Process
├── Read Outbox Events
├── Publish to Message Broker
└── Mark as Processed

The Shared/ module provides cross-cutting components:

Presentation layer follows the ADR pattern for clean request handling:

• Action - Receives HTTP request, calls use case
• Domain - Business logic (UseCase)
• Responder - Formats and returns response

PHP container is built automatically based on selected services.

1. Install GELF PHP package:

composer require graylog2/gelf-php

2. Configure UDP Input:
   • Access http://localhost:9400
   • Navigate to System -> Inputs
   • Add "GELF UDP" input on port 12201

1. Create index:

curl -X PUT http://localhost:9200/logs \
  -H "Content-Type: application/json" \
  -d '{
    "settings": {
      "number_of_shards": 1,
      "number_of_replicas": 0
    },
    "mappings": {
      "properties": {
        "@timestamp": {"type": "date"},
        "message": {"type": "text"},
        "level": {"type": "keyword"},
        "channel": {"type": "keyword"},
        "context": {"type": "object"}
      }
    }
  }'

2. Reload Logstash:

docker compose -f infrastructure/docker-compose-tools.yml --profile elk restart logstash

• Development certificates included for local HTTPS
• HTTP to HTTPS redirect supported
• TLS 1.2/1.3 support
• Custom certificates: place in infrastructure/containers/nginx/ssl/ or infrastructure/containers/apache/ssl/

Key environment variables in infrastructure/.env:

See infrastructure/.env for complete configuration options.

Run migrations using Doctrine:

# Run all pending migrations
docker compose exec php bin/console doctrine:migrations:migrate

# Check migration status
docker compose exec php bin/console doctrine:migrations:status

# Generate new migration
docker compose exec php bin/console doctrine:migrations:diff

# Rollback last migration
docker compose exec php bin/console doctrine:migrations:migrate prev

Or use Make commands:

make migrate          # Run migrations
make migrate-status   # Check status

# Run all unit tests
make test-php

# Run with coverage
docker compose exec php ./vendor/bin/phpunit --coverage-html var/coverage

# Run Postman collection
make test-postman

Postman collections are located in tools/postman/.

Test service connectivity:

# Test database connections
docker compose exec php bin/console healthcheck:postgres
docker compose exec php bin/console healthcheck:mysql

# Test cache services
docker compose exec php bin/console healthcheck:redis
docker compose exec php bin/console healthcheck:memcache

# Test message brokers
docker compose exec php bin/console healthcheck:rabbitmq
docker compose exec php bin/console healthcheck:kafka

All commands return:

• 0 (Success): Service is available and functioning
• 1 (Failure): Connection issues or service malfunction

If ports are already in use, modify infrastructure/.env:

NGINX_HTTP_PORT=8080
NGINX_HTTPS_PORT=8443
POSTGRES_PORT=5433
REDIS_PORT=6380

# Fix volume permissions
sudo chown -R 1000:1000 infrastructure/data/

# Check logs
docker compose logs <service-name>

# Rebuild container
docker compose build --no-cache <service-name>

# Full rebuild
make rebuild

The PHP container automatically builds with extensions based on selected services. If an extension is missing:

# Rebuild PHP container
docker compose build --no-cache php

1. Verify the database container is running:

docker compose ps

2. Check database logs:

docker compose logs postgres  # or mysql

3. Test connection from PHP container:

docker compose exec php bin/console healthcheck:postgres

# Clear application cache
docker compose exec php bin/console cache:clear

# Clear Redis
docker compose exec redis redis-cli FLUSHALL

We welcome contributions to the Enterprise Skeleton project!

• Sentry Integration: Error tracking and monitoring
• RoadRunner Integration: High-performance PHP application server
• New Framework Integrations: Yii, Slim, or other PHP frameworks

1. Fork the repository
2. Create a new branch for your feature or fix
3. Make your changes following our coding standards (PSR-12)
4. Write or update tests if necessary
5. Submit a Pull Request with a clear description
6. Ensure all checks pass (PHPStan, Psalm, CS-Fixer, etc.)

This project is licensed under the MIT License.

Dykyi Roman