Kestra

# MISSION: Scaffold "Kestra" Production Architecture
You are an expert Senior Staff Software Architect and Full-Stack Engineer. Your mission is to scaffold and implement a production-grade, highly reliable, and modular codebase following the proven architecture of **Kestra**.
---
## 1. PROJECT SPECIFICATIONS & BENCHMARK
- **Reference Architecture**: Kestra
- **What It Does**: Kestra is an open-source event-driven orchestration and scheduling platform for data and infrastructure pipelines, built on Java and Micronaut with a pluggable JDBC persistence layer (H2, MySQL, or PostgreSQL) that also serves as the message queue, plus a separate Vue 3 web UI.
- **Domain & Category**: Declarative Orchestration & Data Flow Engine
- **Production Scale**: 6-20 people
- **Development Mode**: CLASSIC
- **Architectural Rationale**: Queueing and repository storage run through the same JDBC layer instead of a dedicated broker, so one PostgreSQL (or MySQL/H2) instance is enough to run the scheduler, executor, and worker modules together, while those modules stay separately buildable and scalable.
- **Live Website Reference**: https://kestra.io
- **Source Repository**: https://github.com/kestra-io/kestra
---
## 2. PRODUCTION TECH STACK
- **Full Stack Array**: Java, Micronaut, Vue, TypeScript, PostgreSQL, MySQL, H2, Docker, Helm
- **Primary Language(s)**: Java, TypeScript, Vue, JavaScript
- **License of the reference repo**: Apache-2.0
- **Frontend**: Vue — Web UI for authoring flows, viewing executions, and managing the instance, built as a standalone SPA under ui/.; Vite — Dev server and bundler for the ui/ Vue application.; Storybook — Component development and documentation for the UI, configured under ui/.storybook.
- **Backend & APIs**: Micronaut — Application framework for every JVM module (core, webserver, scheduler, executor, worker), running on Netty.; jOOQ — Typed SQL layer shared by the H2, MySQL, and Postgres JDBC modules for the repository and queue implementations.; Pebble — Templating engine used for rendering flow variables and expressions.
- **Data & persistence**: PostgreSQL — Recommended production backend for the repository, queue, and storage metadata, via the jdbc-postgres module.; MySQL — Alternative JDBC backend for the same repository/queue abstraction as Postgres.; H2 — Embedded JDBC backend used for local development and the executor/scheduler test suites.
- **Infrastructure & deploy**: Docker — Runtime image is built in two layers: a shared kestra-base image plus this thin app layer that copies in plugins.; Helm — Kubernetes charts for a full Kestra deployment and a lighter "starter" variant.
---
## 3. KEY ARCHITECTURAL DECISIONS (audited from https://github.com/kestra-io/kestra @ 2765958)
1. **Repository, queue, and storage metadata all run through one pluggable JDBC layer**: jdbc/build.gradle defines the shared queue/repository abstraction, and jdbc-h2, jdbc-mysql, and jdbc-postgres each implement it via io.micronaut.sql:micronaut-jooq plus their own JDBC driver, so a single relational database can serve as the message queue and metadata store without a separate broker.
2. **Runtime execution is split into dedicated modules instead of one process**: The Gradle multi-project build has separate scheduler, executor, worker, worker-controller, and indexer modules (each with its own build.gradle), all depending on core and jdbc, so scheduling, task dispatch, and task execution can be scaled or deployed independently of each other.
3. **A shared platform module enforces one set of dependency versions across all modules**: Root build.gradle applies annotationProcessor/implementation/api enforcedPlatform(project(":platform")) to every subproject in the allprojects block, keeping the ~20 Gradle modules (core, jdbc-*, queue, scheduler, executor, worker, webserver, cli, …) on consistent library versions.
4. **Docker images are built as a thin app layer on top of a shared base image**: Dockerfile starts from ARG BASE_IMAGE="ghcr.io/kestra-io/kestra-base:latest-slim" and only copies in the docker/ runtime scripts and a plugins/ directory, while Dockerfile.base presumably builds that shared base separately, keeping plugin/runtime updates decoupled from the base JVM image.
5. **The default compose setup points repository and queue config at one Postgres instance**: docker-compose.yml configures KESTRA_CONFIGURATION with repository.type: postgres and queue.type: postgres against the same postgres service, so `docker compose up` runs the whole platform (server standalone mode) off a single database container.
6. **The web UI is a separate Vue 3 + Vite SPA, not server-rendered from the JVM backend**: ui/ has its own package-lock.json, vite.config.js, vitest.config.js, and .storybook directory, building independently of the Gradle backend modules and being served as static assets rather than through a JVM templating engine.
---
## 4. NON-NEGOTIABLE ARCHITECTURAL GUARDRAILS
1. **Monorepo & Modular Separation**:
   - Structure as a Turborepo monorepo with strict package boundaries:
     - `apps/web`: Application UI, routing, layouts, and server endpoints.
     - `packages/ui`: Shared design tokens, CSS variables, and Radix UI primitive components.
     - `packages/db`: Database schemas, client singleton, declarative migrations, and seed scripts.
     - `packages/config`: Shared TypeScript, ESLint, and build configurations.
2. **Strict Type Safety & Zero `any` Policy**:
   - Enable `strict: true`, `noImplicitAny: true`, and `strictNullChecks: true`.
   - Validate ALL external inputs, API request bodies, and query parameters with **Zod** schemas before execution.
3. **Frontend & Rendering Guidelines**:
   - Isolate interactive UI state to leaf components. Keep core pages lightweight and performant.
4. **Design System & Aesthetics**:
   - Keep every color, radius, shadow and font in a single token file (CSS variables) and consume tokens everywhere; never hardcode hex values in components.
   - Prefer crisp 1px borders and one subtle shadow scale over blurry default shadows. Pair one sans-serif for body/headings with one monospace for tags, badges, metrics, and code.
5. **Data Layer & Reliability**:
   - Write declarative schema definitions with foreign keys, composite indexes on queried filters, and automated timestamp triggers.
   - Use connection pooling and prepared statements for serverless database execution.
---
## 5. STEP-BY-STEP SCAFFOLDING ROADMAP
- **Phase 1: Workspace & Root Config**: Initialize package manager, monorepo configuration (`turbo.json`, `tsconfig.base.json`, `package.json`).
- **Phase 2: Database Schema & Client**: Set up the data layer (PostgreSQL, MySQL, H2): client, connection pool, models, and migration scripts.
- **Phase 3: Design Tokens & UI Primitives**: Build accessible `Button`, `Input`, `Card`, `Badge`, and layout wrappers inside `packages/ui`.
- **Phase 4: Core Application Routes & Handlers**: Implement primary authentication, user session handling, and application routes.
- **Phase 5: Quality Assurance & Build Verification**: Run `tsc --noEmit`, ESLint, Prettier, and smoke test suites to ensure zero compilation or runtime errors.
---
## 6. EXECUTION INSTRUCTIONS
1. Review all specifications, architectural guardrails, and stack choices above.
2. Present the full monorepo directory tree structure.
3. Systematically generate the complete, production-ready codebase according to the 5-phase roadmap above — starting with the root workspace setup, followed by the database schema, UI design system package, and full-stack application routes until the repository is fully scaffolded and ready to run.