GiveLedger

• Shared database, scoped queries — a single MySQL database for all tenants. Every table with tenant-owned data carries a tenant_id column.
• The TenantId is a Value Object in the Domain layer — it validates the UUID format and rejects blank values.
• Every repository method that reads or writes tenant data receives a TenantId argument — no global state.
• The Campaign aggregate validates that an operation comes from the same tenant that owns it — cross-tenant mutation throws a TenantMismatchException.
• The TenantResolver lives in Infrastructure and resolves the tenant from the HTTP subdomain or the X-Tenant-ID header.

Resolution flow

Backend — app/

app/
  Application/
    Campaign/
      CreateCampaignCommand.php
      CreateCampaignHandler.php
      RecordDonationCommand.php
      RecordDonationHandler.php
      CloseCampaignCommand.php
      CloseCampaignHandler.php
  Domain/
    Campaign/
      Campaign.php              ← Aggregate Root
      CampaignId.php            ← Value Object
      CampaignName.php          ← Value Object
      CampaignStatus.php        ← Value Object
      Donation.php              ← Entity
      DonationId.php            ← Value Object
      DonorName.php             ← Value Object
    Shared/
      TenantId.php              ← Value Object (shared)
      Money.php                 ← Value Object (shared)
      TenantMismatchException.php
    Campaign/
      CampaignRepositoryInterface.php
  Infrastructure/
    Application/
      HandlerBus.php
    Domain/
      CampaignRepository.php   ← PDO implementation
    HTTP/
      Controller/Campaign/
        CampaignController.php
      Middleware/
        TenantResolver.php
    Query/
      CampaignFinder.php
    Api/Resource/Campaign/
      CampaignResource.php
config/
  handlers.php
  routes.php
db/
  migrations/
    001_create_campaigns.sql
    002_create_donations.sql

Frontend — frontend/

frontend/
  pages/
    index.vue                  ← campaign list
    campaigns/
      [id].vue                 ← campaign detail
      [id]/
        donate.vue             ← donation form
      new.vue                  ← create campaign
  components/
    CampaignCard.vue
    DonationForm.vue
    ProgressBar.vue
    DonorList.vue
  composables/
    useCampaigns.ts
    useDonation.ts
  queries/
    campaignQueries.ts
  types/
    campaign.ts
    donation.ts
  i18n/
    en.json

Infrastructure — docker/

docker/
  php/
    Dockerfile
    php.ini
  nginx/
    Dockerfile
    nginx.conf
  vue/
    Dockerfile
docker-compose.yml
docker-compose.prod.yml
.env.example
docs/
  deployment.md

final class TenantId
{
    private string $value;

    private function __construct(string $value)
    {
        if (!preg_match(
            '/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/',
            $value
        )) {
            throw new \InvalidArgumentException(
                "Invalid TenantId: {$value}"
            );
        }
        $this->value = $value;
    }

    public static function of(string $value): self
    {
        return new self($value);
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }

    public function value(): string
    {
        return $this->value;
    }
}

All Value Objects required

class Campaign
{
    private CampaignId     $id;
    private TenantId       $tenantId;
    private CampaignName   $name;
    private Money          $goal;
    private Money          $raised;
    private CampaignStatus $status;
    private \DateTimeImmutable $deadline;

    /** @var Donation[] */
    private array $donations = [];

    private function __construct(
        CampaignId $id,
        TenantId $tenantId,
        CampaignName $name,
        Money $goal,
        \DateTimeImmutable $deadline
    ) { /* ... */ }

    public static function create(
        CampaignId $id,
        TenantId $tenantId,
        CampaignName $name,
        Money $goal,
        \DateTimeImmutable $deadline
    ): self { /* ... */ }

    public function recordDonation(
        DonationId $id,
        TenantId $tenantId,
        DonorName $donor,
        Money $amount
    ): void
    {
        $this->guardTenant($tenantId);
        $this->guardOpen();
        // accumulate $raised, append $donations
    }

    public function close(TenantId $tenantId): void
    {
        $this->guardTenant($tenantId);
        $this->guardGoalReached();
        $this->guardDeadlinePassed();
        $this->status = CampaignStatus::closed();
    }

    private function guardTenant(TenantId $t): void
    {
        if (!$this->tenantId->equals($t)) {
            throw new TenantMismatchException();
        }
    }
}

Invariant guards

Donation entity

class Donation
{
    public function __construct(
        private readonly DonationId $id,
        private readonly DonorName  $donorName,
        private readonly Money      $amount,
        private readonly \DateTimeImmutable $recordedAt
    ) {}

    public function id(): DonationId      { return $this->id; }
    public function donorName(): DonorName { return $this->donorName; }
    public function amount(): Money        { return $this->amount; }
}

final class RecordDonationCommand
{
    public function __construct(
        public readonly string $tenantId,
        public readonly string $campaignId,
        public readonly string $donationId,
        public readonly string $donorName,
        public readonly int    $amountCents,
        public readonly string $currency
    ) {}
}

final class RecordDonationHandler
{
    public function __construct(
        private CampaignRepositoryInterface $campaigns
    ) {}

    public function handle(RecordDonationCommand $command): void
    {
        $tenantId  = TenantId::of($command->tenantId);
        $campaignId = CampaignId::of($command->campaignId);

        $campaign = $this->campaigns->findById($campaignId, $tenantId);

        if ($campaign === null) {
            throw new CampaignNotFoundException($campaignId);
        }

        $campaign->recordDonation(
            DonationId::of($command->donationId),
            $tenantId,
            DonorName::of($command->donorName),
            Money::of($command->amountCents, $command->currency)
        );

        $this->campaigns->save($campaign);
    }
}

All three commands to implement

handlers.php

return [
    CreateCampaignCommand::class  => CreateCampaignHandler::class,
    RecordDonationCommand::class  => RecordDonationHandler::class,
    CloseCampaignCommand::class   => CloseCampaignHandler::class,
];

interface CampaignRepositoryInterface
{
    public function findById(
        CampaignId $id,
        TenantId $tenantId
    ): ?Campaign;

    public function save(Campaign $campaign): void;
}

final class CampaignRepository
    implements CampaignRepositoryInterface
{
    public function __construct(private \PDO $pdo) {}

    public function findById(
        CampaignId $id,
        TenantId $tenantId
    ): ?Campaign
    {
        $stmt = $this->pdo->prepare(
            'SELECT * FROM campaigns
             WHERE id = :id
               AND tenant_id = :tenant_id
             LIMIT 1'
        );
        $stmt->execute([
            'id'        => $id->value(),
            'tenant_id' => $tenantId->value(),
        ]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $row ? $this->hydrate($row) : null;
    }
}

CampaignFinder — read path

final class CampaignFinder
{
    public function __construct(private \PDO $pdo) {}

    /** @return array> */
    public function allForTenant(string $tenantId): array
    {
        $stmt = $this->pdo->prepare(
            'SELECT
               c.id, c.name, c.goal_cents,
               c.currency, c.status, c.deadline,
               COALESCE(SUM(d.amount_cents), 0) AS raised_cents
             FROM campaigns c
             LEFT JOIN donations d ON d.campaign_id = c.id
             WHERE c.tenant_id = :tenant_id
             GROUP BY c.id
             ORDER BY c.created_at DESC'
        );
        $stmt->execute(['tenant_id' => $tenantId]);
        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }
}

Database schema

CREATE TABLE campaigns (
  id         CHAR(36) PRIMARY KEY,
  tenant_id  CHAR(36) NOT NULL,
  name       VARCHAR(100) NOT NULL,
  goal_cents INT UNSIGNED NOT NULL,
  currency   CHAR(3) NOT NULL,
  status     ENUM('open','closed') DEFAULT 'open',
  deadline   DATE NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  INDEX idx_tenant (tenant_id)
);

CREATE TABLE donations (
  id          CHAR(36) PRIMARY KEY,
  campaign_id CHAR(36) NOT NULL,
  donor_name  VARCHAR(80) NOT NULL,
  amount_cents INT UNSIGNED NOT NULL,
  recorded_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  FOREIGN KEY (campaign_id) REFERENCES campaigns(id)
);

final class TenantResolver
{
    public function __construct(private \PDO $pdo) {}

    public function resolve(\Psr\Http\Message\ServerRequestInterface $request): string
    {
        // Option A: subdomain
        $host     = $request->getHeaderLine('Host');
        $parts    = explode('.', $host);
        $slug     = count($parts) >= 3 ? $parts[0] : null;

        // Option B: explicit header (useful for local dev)
        $header   = $request->getHeaderLine('X-Tenant-ID');

        $tenantId = $header ?: $this->lookupSlug($slug);

        if ($tenantId === null) {
            throw new TenantNotFoundException();
        }

        return $tenantId;
    }

    private function lookupSlug(?string $slug): ?string
    {
        if ($slug === null) return null;

        $stmt = $this->pdo->prepare(
            'SELECT id FROM tenants WHERE slug = :slug LIMIT 1'
        );
        $stmt->execute(['slug' => $slug]);
        $row = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $row['id'] ?? null;
    }
}

Tenants table

CREATE TABLE tenants (
  id         CHAR(36) PRIMARY KEY,
  slug       VARCHAR(50) UNIQUE NOT NULL,
  name       VARCHAR(100) NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

-- Seed two tenants for local dev
INSERT INTO tenants VALUES
  ('11111111-1111-4111-a111-111111111111', 'grace-church', 'Grace Church'),
  ('22222222-2222-4222-a222-222222222222', 'hope-chapel',  'Hope Chapel');

How the Controller uses it

final class CampaignController
{
    public function __construct(
        private HandlerBus      $bus,
        private TenantResolver  $resolver,
        private CampaignFinder  $finder
    ) {}

    public function index(Request $request): JsonResponse
    {
        $tenantId = $this->resolver->resolve($request);

        return new JsonResponse(
            $this->finder->allForTenant($tenantId)
        );
    }

    public function store(Request $request): JsonResponse
    {
        $tenantId = $this->resolver->resolve($request);
        $body     = $request->getParsedBody();

        $this->bus->dispatch(new CreateCampaignCommand(
            tenantId:  $tenantId,
            campaignId: Uuid::v4(),
            name:      $body['name'],
            goalCents: (int) $body['goal_cents'],
            currency:  $body['currency'],
            deadline:  $body['deadline'],
        ));

        return new JsonResponse(null, 201);
    }
}

Services in docker-compose.yml

FROM composer:2 AS deps
WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --optimize-autoloader

FROM php:8.3-fpm AS runtime
WORKDIR /app
COPY --from=deps /app/vendor ./vendor
COPY . .
RUN chown -R www-data:www-data /app
USER www-data
CMD ["php-fpm"]

FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine AS runtime
COPY --from=build /app/.output/public /usr/share/nginx/html
COPY docker/nginx/vue.conf /etc/nginx/conf.d/default.conf

Option A — AWS Free Tier

• Use the AWS Free Tier EC2 t2.micro (750 hours/month)
• MySQL runs inside Docker — no RDS needed to stay in free tier
• Use the EC2 public IP or a free domain (e.g. nip.io) for the live URL
• Configure tenant slugs to resolve by X-Tenant-ID header if no custom domain is available

Option B — Google Cloud Free Tier

• GCE e2-micro is always free in qualifying regions — no credit card charge
• Use the VM's external IP for the live URL
• Advanced option: split PHP and Vue into two Cloud Run services + use Cloud SQL (90-day trial credits)

Domain & Architecture

• TenantId rejects invalid UUIDs with a domain exception
• Donation on a closed campaign throws inside the aggregate — not the controller
• Closing a campaign before goal is reached throws inside the aggregate
• Cross-tenant mutation throws TenantMismatchException
• Zero framework imports inside Domain/ — grep verifiable
• All Commands carry only scalar fields (string, int, bool)
• CampaignRepositoryInterface defined in Domain/, implemented in Infrastructure/
• CampaignFinder returns plain arrays — never entities or Value Objects
• Every SQL query in repository and finder is parameterized — no string interpolation
• TenantResolver fails with a 404 response for unknown tenant slugs

Frontend

• tsc --strict --noEmit passes with zero errors
• No any type anywhere in frontend/
• Every user-facing string goes through $t() — no hardcoded English in templates
• Donor list on detail page uses a Lodash _.chain() pipeline
• No withDefaults(), no mixed quotes, no function declarations
• CVA bound directly in template — never inside computed()

Infrastructure & Deployment

• docker-compose up boots the full app including migrations
• Multi-stage Dockerfiles — prod image has no dev deps, no source volumes
• A working public URL is submitted with the project
• docs/deployment.md is complete and the URL is reproducible
• No secrets committed to the repository

Evaluation weights