Enterprise Pattern

fjall create app --name api --type enterprise

┌─────────────────────────────────────────────────────────┐
│  VPC (3 AZs, 3 NAT Gateways)                           │
│                                                         │
│  ┌─────────────────────────────────────────────┐        │
│  │  ALB (Application Load Balancer)             │        │
│  └──────────────┬──────────────────────────────┘        │
│                 │                                        │
│  ┌──────────────▼──────────────────────────────┐        │
│  │  ECS Fargate (2048 CPU / 4096 MiB)           │        │
│  │  6 tasks (scales to 100)                     │        │
│  └──────────────┬──────────────────────────────┘        │
│                 │                                        │
│  ┌──────────────▼──────────────────────────────┐        │
│  │  RDS Proxy (TLS required)                    │        │
│  └──────────────┬──────────────────────────────┘        │
│                 │                                        │
│  ┌──────────────▼──────────────────────────────┐        │
│  │  Aurora (2 readers, KMS, 35-day backup)      │        │
│  │  Advanced Database Insights (KMS encrypted)  │        │
│  └─────────────────────────────────────────────┘        │
│                                                         │
│  VPC Endpoints: ECR, Secrets Manager, KMS, CloudWatch   │
│  Flow Logs: S3 (365-day retention)                      │
└─────────────────────────────────────────────────────────┘

import {
  App,
  DatabaseFactory,
  ComputeFactory,
  getConfig,
} from "@fjall/components-infrastructure";

const appName = "api";
const app = App.getApp(appName, {
  network: {
    maxAzs: 3,
    natGateways: { count: 3 },
    flowLogs: { destination: "s3", retentionDays: 365 },
    vpcEndpoints: {
      interface: {
        ecr: true,
        secretsManager: true,
        kms: true,
        cloudwatchLogs: true,
      },
    },
  },
  backup: { tier: "enterprise" },
});

const apiDatabase = app.addDatabase(
  DatabaseFactory.build("api", {
    vpc: app.getVpc(),
    type: "Aurora",
    databaseName: "api",
    encryption: { storageKey: { useCMK: true } },
    databaseInsights: {
      mode: "advanced",
      encryptionKey: { useCMK: true },
    },
    proxy: { requireTLS: true },
    readers: { count: 2 },
    backupRetention: 35,
  }),
);

app.addCompute(
  ComputeFactory.build("ApiCompute", {
    type: "ecs",
    ecrRepository: app.getDefaultContainerRegistry(),
    services: [
      {
        name: "api",
        capacityProvider: "FARGATE",
        containers: [
          {
            port: 3000,
            environment: {
              ENVIRONMENT: getConfig().environment,
              DATABASE_HOST: apiDatabase.getHostEndpoint(),
              DATABASE_PORT: `${apiDatabase.getHostPort()}`,
              DATABASE_NAME: apiDatabase.getDatabaseName(),
            },
            secretsImport: {
              DATABASE_PASSWORD: apiDatabase
                .getCredentials()
                .getImport("password"),
            },
          },
        ],
        cpu: 2048,
        memoryLimitMiB: 4096,
        desiredCount: 6,
        scaling: { minCapacity: 6, maxCapacity: 100 },
        connections: [apiDatabase],
      },
    ],
  }),
);