npm - @voltro/cli - Versions diffs - 0.1.0 - Mend

@voltro/cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (626) hide show

package/templates/apps/frontend-static-blog/src/pages/layout.tsx ADDED Viewed

@@ -0,0 +1,63 @@
+// Root layout — wraps every page. Strategy B (URL-prefix i18n): an INNER
+// <I18nProvider> reads the locale FROM THE URL, so `voltro build` pre-renders
+// each page once per locale (en at the bare path, de under /de) with the right
+// catalog baked into the static HTML.
+//
+// The language switcher is a plain <a> per locale — a real browser navigation
+// to the other locale's crawlable URL. That is exactly right for a static
+// content site: the index is `interactive: 'none'` (zero JS) and the post
+// pages hydrate only their island, so there is no client runtime to swap
+// catalogs in place; a hard nav to the pre-rendered variant is the whole point.
+//
+// `<html>`/`<head>`/`<body>` belong to the framework's index.html shell;
+// render only the in-document chrome here.
+import type { ReactNode } from 'react'
+import { I18nProvider, T } from '@voltro/i18n'
+import { useLocation } from '@voltro/web'
+import {
+  CATALOGS,
+  DEFAULT_LOCALE,
+  SUPPORTED_LOCALES,
+  stripLocalePrefix,
+  useUrlLocale,
+  withLocalePrefix,
+} from '../lib/locale'
+import '../globals.css'
+function SiteHeader(): ReactNode {
+  const locale = useUrlLocale()
+  // The path WITHOUT its locale prefix, so switching language keeps you on the
+  // same page (e.g. /de/blog/x → /blog/x, then re-prefixed per locale).
+  const barePath = stripLocalePrefix(useLocation())
+  return (
+    <header className="site-header">
+      <a className="brand" href={withLocalePrefix('/', locale)}>{{capProjectName}}</a>
+      <span className="spacer" />
+      <span className="lang">
+        <span className="label">
+          <T id="nav.language" />:
+        </span>
+        {SUPPORTED_LOCALES.map((code) => (
+          <a
+            key={code}
+            href={withLocalePrefix(barePath, code)}
+            aria-current={code === locale ? 'true' : undefined}
+          >
+            {code.toUpperCase()}
+          </a>
+        ))}
+      </span>
+    </header>
+  )
+}
+export default function Layout({ children }: { readonly children: ReactNode }): ReactNode {
+  const locale = useUrlLocale()
+  return (
+    <I18nProvider locale={locale} messages={CATALOGS[locale]} defaultLocale={DEFAULT_LOCALE}>
+      <SiteHeader />
+      {children}
+    </I18nProvider>
+  )
+}

package/templates/apps/frontend-static-blog/template.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "id": "frontend-static-blog",
+  "kind": "web",
+  "summary": "Static SSG blog: dynamic [slug] routes pre-rendered at build via getStaticPaths from a content source (the CMS→static pattern), per-post meta from loaderData, and ONE island (reading-progress bar) showing selective hydration. No backend.",
+  "tags": ["web", "frontend", "static", "ssg", "blog", "getStaticPaths", "islands", "content"]
+}

package/templates/apps/frontend-static-blog/tsconfig.json ADDED Viewed

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", ".framework"]
+}

package/templates/baselines/bare/.env.example ADDED Viewed

@@ -0,0 +1,37 @@
+# Voltro local env — bare baseline.
+#
+# The Voltro CLI auto-loads .env from each app dir + every ancestor
+# at boot (see voltro/packages/cli/src/bin.ts). Shell exports always
+# override .env values, so CI can set DB_URL via env without touching
+# this file.
+# Postgres connection. Bring your own (host install, docker run,
+# cloud provider URL).
+DB_URL=postgres://app:app@localhost:5432/{{projectName}}
+# Session signing secret. The plugin-auth handlers refuse to mint
+# sessions without it. Rotate before shipping.
+VOLTRO_SESSION_SECRET=dev-only-secret-please-rotate-in-prod
+# ─── Optional backends — ALL OFF by default; uncomment to activate ───────────
+# The cache and the durable KV each run on a zero-infra default (in-process
+# memory / your SQL store). Point either at a RESP server (Redis / Valkey /
+# KeyDB / Dragonfly / Upstash) ONLY when you want cross-instance sharing.
+# Enablement is per concern — a bare REDIS_URL is NOT a master switch; each
+# concern reads its own <NAME>_REDIS_URL first, then a shared REDIS_URL.
+# @voltro/cache → Redis: a distributed query/result cache. `voltro add redis`
+# wires this for you (flips app.config `cache: 'redis'` + adds the infra).
+# CACHE_BACKEND=redis
+# CACHE_REDIS_URL=redis://localhost:6379
+# @voltro/kv → Redis: durable `ctx.kv`. Default backend is `database`
+# (durable, shared across replicas, survives restarts) — leave it unless you
+# specifically want KV on Redis. If you do, use a PERSISTENT redis (AOF/RDB),
+# NOT an ephemeral cache-only one: an eviction/restart is data loss for
+# durable KV. See docs → Caching → Key-value backends.
+# KV_BACKEND=redis
+# KV_REDIS_URL=redis://localhost:6379
+# One server for everything, instead of the per-concern URLs above:
+# REDIS_URL=redis://localhost:6379

package/templates/baselines/bare/README.md ADDED Viewed

@@ -0,0 +1,47 @@
+# Bare baseline
+Native Node + pnpm. No containers, no orchestration. You bring your
+own Postgres.
+## What this baseline gives you
+- `.env.example` — the env vars Voltro reads on boot, with sane
+  defaults for a local install.
+- `deploy/voltro.service.example` — a sample systemd unit you can
+  copy to `/etc/systemd/system/voltro.service` on a VPS and adjust.
+- `deploy/README.md` — short notes on rolling-your-own deploy.
+That's it. No `Dockerfile`, no `docker-compose.yml`, no
+`charts/`. By design.
+## What you have to do
+### Local dev
+1. Install Postgres locally (`brew install postgresql@17`,
+   `apt install postgresql-17`, or run a one-off
+   `docker run postgres:17-alpine -p 5432:5432 ...`).
+2. Create the database: `createdb voltro_local`
+3. Copy env: `cp .env.example .env` and edit `DB_URL`.
+4. `pnpm install && pnpm dev`
+### Production deploy
+You're on your own. Common approaches:
+- **systemd on a VPS** — see `deploy/voltro.service.example` for a
+  starting unit. `pnpm voltro build .` per app, copy `dist/` over,
+  enable + start the unit.
+- **PM2 / Forever / Nodemon** — wraps the same `node dist/...`
+  command with auto-restart.
+- **Cloud Run / Fly.io / Render** — these will want a `Dockerfile`
+  anyway. If you're going that route, switch to the **compose**
+  baseline: `voltro baseline set compose`.
+## Switching baselines
+Run `voltro baseline set compose` to add Docker / `voltro baseline
+set helm` to add a Helm chart. The switch writes the new baseline's
+files and backs up your current `.env.example` + any conflicting
+files to `.voltro-baseline-backup/<timestamp>/`. Your application
+code is never touched.

package/templates/baselines/bare/baseline.json ADDED Viewed

@@ -0,0 +1,31 @@
+{
+  "id": "bare",
+  "displayName": "Bare",
+  "summary": "Native Node + pnpm only. No containers, no orchestration. You bring your own Postgres (host install, cloud provider, or external Docker).",
+  "tags": ["native", "minimal", "starter"],
+  "recommendedFor": "Solo devs, prototyping, environments where Docker is unavailable or undesired.",
+  "tradeoffs": {
+    "pros": [
+      "Fastest HMR — native fs.watch (<50ms)",
+      "Lowest memory overhead",
+      "Native TypeScript LSP + debugger",
+      "No image-build step"
+    ],
+    "cons": [
+      "Postgres setup is your problem (brew/apt/docker-on-the-side)",
+      "Onboarding new devs requires per-dev environment setup",
+      "Deploy story = whatever you build (systemd? PM2? rolling-yours?)"
+    ]
+  },
+  "files": [
+    ".env.example",
+    "deploy/README.md",
+    "deploy/voltro.service.example"
+  ],
+  "packageJsonScripts": {
+    "dev":       "turbo run dev",
+    "build":     "turbo run build",
+    "test":      "turbo run test",
+    "typecheck": "turbo run typecheck"
+  }
+}

package/templates/baselines/bare/deploy/README.md ADDED Viewed

@@ -0,0 +1,43 @@
+# Deploy notes — bare baseline
+You are running native Node, so deploy is "ship the built `dist/`
+to a host that has Node 24 + pnpm".
+## systemd on a Linux VPS
+1. Build on a build host (or in CI):
+   ```sh
+   pnpm install --frozen-lockfile
+   pnpm voltro build .   # per app
+   ```
+2. Rsync the project to the target host.
+3. Install Postgres on the host (or point `DB_URL` at a managed
+   service like RDS / Supabase / Neon).
+4. Copy `deploy/voltro.service.example` to
+   `/etc/systemd/system/voltro-{{appName}}.service`, adjust the
+   `WorkingDirectory` and `EnvironmentFile`, then:
+   ```sh
+   sudo systemctl daemon-reload
+   sudo systemctl enable --now voltro-{{appName}}
+   sudo systemctl status voltro-{{appName}}
+   ```
+Per-app you'll want one unit. systemd handles restarts, env file
+loading, journald log capture.
+## PM2
+```sh
+pm2 start "pnpm voltro start ." --name {{appName}} --cwd apps/{{appName}}
+pm2 save
+pm2 startup
+```
+Easier than systemd, more moving parts.
+## When to switch to compose
+If your deploy story includes more than one app + a Postgres, and
+you're going to want CI to build images, switch to the **compose**
+baseline. The native deploy story stays the same as a fallback
+either way — switching baselines doesn't ban Node-native runs.

package/templates/baselines/bare/deploy/voltro.service.example ADDED Viewed

@@ -0,0 +1,36 @@
+# systemd unit example for a Voltro app on a Linux VPS.
+#
+# Copy to /etc/systemd/system/voltro-<appName>.service and adjust
+# the paths + User + EnvironmentFile to match your install.
+#
+#   sudo cp deploy/voltro.service.example \
+#     /etc/systemd/system/voltro-{{appName}}.service
+#   sudo systemctl daemon-reload
+#   sudo systemctl enable --now voltro-{{appName}}
+#   sudo journalctl -u voltro-{{appName}} -f
+[Unit]
+Description=Voltro app: {{appName}}
+After=network-online.target postgresql.service
+Wants=network-online.target
+[Service]
+Type=simple
+User=voltro
+Group=voltro
+WorkingDirectory=/opt/{{projectName}}/apps/{{appName}}
+EnvironmentFile=/opt/{{projectName}}/apps/{{appName}}/.env
+ExecStart=/usr/bin/pnpm voltro start .
+Restart=on-failure
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+# Hardening — adjust as your host allows
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/opt/{{projectName}}
+[Install]
+WantedBy=multi-user.target

package/templates/baselines/compose/.env.example ADDED Viewed

@@ -0,0 +1,46 @@
+# Voltro local env — compose baseline.
+#
+# The Voltro CLI auto-loads .env from each app dir + every ancestor
+# at boot (see voltro/packages/cli/src/bin.ts). Shell exports always
+# override .env values, so CI can set DB_URL via env without touching
+# this file.
+# Postgres connection — points at the postgres service in
+# docker-compose.yml (port 5433 to avoid clashing with a host pg on 5432).
+# When you run inside the docker network (dev:docker / prod:up), the
+# host is `postgres`. When you run native (pnpm dev with pnpm db:up),
+# the host is `localhost` and port stays 5433.
+DB_URL=postgres://app:app@localhost:5433/{{projectName}}
+# Used by prod:up — required, no dev fallback.
+VOLTRO_SESSION_SECRET=dev-only-secret-please-rotate-in-prod
+# Used by docker-compose.prod.yml — the prod postgres uses a
+# different password from dev (intentional: avoid `db:reset` blowing
+# away the prod-shape dataset by accident).
+POSTGRES_PASSWORD=change-me-in-prod
+# ─── Optional backends — ALL OFF by default; uncomment to activate ───────────
+# The cache and the durable KV each run on a zero-infra default (in-process
+# memory / your SQL store). Point either at a RESP server (Redis / Valkey /
+# KeyDB / Dragonfly / Upstash) ONLY when you want cross-instance sharing.
+# Enablement is per concern — a bare REDIS_URL is NOT a master switch; each
+# concern reads its own <NAME>_REDIS_URL first, then a shared REDIS_URL.
+# @voltro/cache → Redis: a distributed query/result cache. Easiest path:
+# `voltro add redis` uncomments these AND injects a `redis` service into
+# docker-compose.yml; then `docker compose up -d redis` and reboot.
+# CACHE_BACKEND=redis
+# CACHE_REDIS_URL=redis://localhost:6379
+# @voltro/kv → Redis: durable `ctx.kv`. Default backend is `database`
+# (durable, shared across replicas, survives restarts) — leave it unless you
+# specifically want KV on Redis. If you do, use a PERSISTENT redis (AOF/RDB),
+# NOT the ephemeral cache service `voltro add redis` provisions: an
+# eviction/restart is data loss for durable KV. See docs → Caching → Key-value
+# backends.
+# KV_BACKEND=redis
+# KV_REDIS_URL=redis://localhost:6379
+# One server for everything, instead of the per-concern URLs above:
+# REDIS_URL=redis://localhost:6379

package/templates/baselines/compose/README.md ADDED Viewed

@@ -0,0 +1,69 @@
+# Compose baseline
+Three docker-compose files + two Dockerfiles. Postgres included.
+Two flavours: dev with volume-mounted HMR, prod with built images.
+## Layout
+```
+.
+├── docker/
+│   ├── api.Dockerfile        # multi-stage: deps + builder + prod
+│   ├── web.Dockerfile        # multi-stage: deps + builder + prod
+│   └── .dockerignore
+├── docker-compose.yml        # postgres only — the "infra" file
+├── docker-compose.dev.yml    # postgres + apps in dev mode
+└── docker-compose.prod.yml   # postgres + apps in prod (built images)
+```
+## Common flows
+### Daily dev — fastest
+```sh
+pnpm db:up      # boot postgres only
+pnpm dev        # turbo run dev, native node, HMR <50ms
+```
+### Daily dev — full-docker (slower HMR but zero host install)
+```sh
+pnpm dev:docker        # boots postgres + all apps in containers
+pnpm dev:docker:down   # stop everything
+```
+### Production smoke-test on localhost
+```sh
+pnpm prod:build      # build all images (slow first run, ~5 min)
+pnpm prod:up         # boot the prod stack
+pnpm prod:down       # tear down
+```
+## When to add apps
+The shipped compose files cover ONE api + ONE web by default. As you
+add apps to `apps/`, mirror the pattern in both `docker-compose.dev.yml`
+and `docker-compose.prod.yml`: copy a service block, change its
+`working_dir` / `APP_PATH` / port.
+A future `voltro baseline sync` will auto-regenerate the service
+blocks from your `project.json` / `app.config.ts` files. Until then,
+hand-edit.
+## What's NOT in here
+- No CI configs (GitHub Actions / GitLab CI). Each provider's syntax
+  is different; we don't pick a winner.
+- No reverse proxy (Traefik / nginx / Caddy). If you need one in
+  prod, add it as a service in `docker-compose.prod.yml`.
+- No Redis, S3-emulator, or other infra. Add as needed.
+## Switching baselines
+`voltro baseline set helm` → swaps to Helm chart + Kustomize overlays.
+`voltro baseline set bare` → removes docker-compose entirely.
+Either switch backs up the current docker-compose files + Dockerfiles
+to `.voltro-baseline-backup/<timestamp>/`. Application code is never
+touched.

package/templates/baselines/compose/baseline.json ADDED Viewed

@@ -0,0 +1,51 @@
+{
+  "id": "compose",
+  "displayName": "Docker Compose",
+  "summary": "Full stack via docker-compose: separate dev (volume-mounted HMR) and prod (built images) variants. Postgres included.",
+  "tags": ["docker", "compose", "dev", "prod"],
+  "recommendedFor": "Teams without k8s; VPS or self-hosted deploys; reproducible onboarding for new devs.",
+  "tradeoffs": {
+    "pros": [
+      "Zero-host-install: docker + git is all you need to run the stack",
+      "Prod-parity smoke-tests locally via `prod:up`",
+      "Onboarding new devs is `pnpm dev:docker` after clone",
+      "Postgres, Redis, S3-emulators etc. are trivial additions"
+    ],
+    "cons": [
+      "HMR through volumes is slower than native (200-2000ms vs <50ms, esp. on macOS)",
+      "Requires per-app Dockerfile maintenance",
+      "Docker Desktop adds ~3GB memory overhead on macOS/Windows",
+      "First-time image build for prod variant is slow (5+ minutes)"
+    ]
+  },
+  "files": [
+    ".env.example",
+    "docker/api.Dockerfile",
+    "docker/web.Dockerfile",
+    "docker/dev.Dockerfile",
+    "docker/.dockerignore",
+    "docker-compose.yml",
+    "docker-compose.dev.yml",
+    "docker-compose.prod.yml"
+  ],
+  "packageJsonScripts": {
+    "dev":             "turbo run dev",
+    "dev:hybrid":      "docker compose up -d --wait postgres && turbo run dev",
+    "dev:docker":      "HOST_UID=$(id -u) HOST_GID=$(id -g) docker compose -f docker-compose.dev.yml up",
+    "dev:docker:bg":   "HOST_UID=$(id -u) HOST_GID=$(id -g) docker compose -f docker-compose.dev.yml up -d",
+    "dev:docker:down": "docker compose -f docker-compose.dev.yml down",
+    "dev:docker:logs": "docker compose -f docker-compose.dev.yml logs -f",
+    "build":           "turbo run build",
+    "test":            "turbo run test",
+    "typecheck":       "turbo run typecheck",
+    "db:up":           "docker compose up -d --wait postgres",
+    "db:down":         "docker compose stop postgres",
+    "db:reset":        "docker compose down -v postgres && docker compose up -d --wait postgres",
+    "db:logs":         "docker compose logs -f postgres",
+    "db:psql":         "docker compose exec postgres psql -U app -d {{projectNameSnake}}",
+    "prod:build":      "docker compose -f docker-compose.prod.yml build",
+    "prod:up":         "docker compose -f docker-compose.prod.yml up -d",
+    "prod:down":       "docker compose -f docker-compose.prod.yml down",
+    "prod:logs":       "docker compose -f docker-compose.prod.yml logs -f"
+  }
+}

package/templates/baselines/compose/docker/.dockerignore ADDED Viewed

@@ -0,0 +1,38 @@
+# Build context excludes — keep image size sane.
+#
+# Most of these are obvious noise. Customize per project if you
+# have additional generated dirs to exclude.
+**/node_modules
+**/dist
+**/.turbo
+**/.next
+**/.vite
+**/.cache
+**/coverage
+**/.env
+**/.env.local
+**/.env.*.local
+**/.voltro
+**/.voltro-baseline-backup
+**/.git
+**/.gitignore.local
+**/.vscode
+**/.idea
+**/*.swp
+**/*.swo
+**/*.log
+**/npm-debug.log*
+**/yarn-debug.log*
+**/yarn-error.log*
+**/.DS_Store
+**/Thumbs.db
+**/Dockerfile*
+**/docker-compose*.yml
+**/.dockerignore

package/templates/baselines/compose/docker/api.Dockerfile ADDED Viewed

@@ -0,0 +1,57 @@
+# API service Dockerfile for {{projectName}}'s Node-based api apps.
+#
+# Build context = project root (where pnpm-workspace.yaml lives).
+# The `.dockerignore` next to this file aggressively excludes noise.
+#
+# Build args:
+#   APP_PATH  — path relative to context where the api lives.
+#               e.g. apps/{{projectName}}/api
+#
+# Targets:
+#   prod  — production image (this file's only target; dev uses
+#           node:24-alpine directly via docker-compose.dev.yml so
+#           code mounts work without an image-build step).
+#
+# Build:
+#   docker build \
+#     -f docker/api.Dockerfile \
+#     --build-arg APP_PATH=apps/{{projectName}}/api \
+#     -t {{projectName}}-api:latest \
+#     .
+ARG NODE_VERSION=24-alpine
+ARG PNPM_VERSION=10.25.0
+ARG APP_PATH=apps/{{projectName}}/api
+# ---------- deps stage ----------
+FROM node:${NODE_VERSION} AS deps
+ARG PNPM_VERSION
+RUN corepack enable && corepack prepare pnpm@${PNPM_VERSION} --activate
+WORKDIR /workspace
+# Copy ONLY what pnpm install needs — lockfile + workspace manifests.
+COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
+COPY apps apps
+COPY packages packages
+RUN pnpm install --frozen-lockfile
+# ---------- builder stage ----------
+FROM deps AS builder
+ARG APP_PATH
+WORKDIR /workspace/${APP_PATH}
+RUN pnpm voltro codegen . || true
+# ---------- prod runner ----------
+FROM node:${NODE_VERSION} AS prod
+ARG PNPM_VERSION
+ARG APP_PATH
+RUN corepack enable && corepack prepare pnpm@${PNPM_VERSION} --activate
+WORKDIR /workspace
+COPY --from=builder /workspace /workspace
+WORKDIR /workspace/${APP_PATH}
+EXPOSE 4000
+ENV NODE_ENV=production
+CMD ["pnpm", "voltro", "start", "."]

package/templates/baselines/compose/docker/dev.Dockerfile ADDED Viewed

@@ -0,0 +1,35 @@
+# Dev runtime image for {{projectName}}'s node/vite services.
+#
+# Why this exists (vs `image: node:24-alpine` directly in compose):
+#
+# Compose's `user: "${HOST_UID}:${HOST_GID}"` directive runs the
+# container process as the host's UID/GID so files written into the
+# bind-mounted workspace land owned by the host user, not root.
+# That kills the "root-owned .framework/.vite/deps blocks native vite"
+# bug that bites every dev who alternates between full-docker and
+# native pnpm dev.
+#
+# But it also means:
+#   - The container has no `/etc/passwd` entry for that numeric UID,
+#     so HOME resolves to `/` (read-only for non-root).
+#   - `corepack enable` writes to `/usr/local/bin/` (root-owned in the
+#     stock node image), which a non-root container can't do.
+#
+# So we PREBAKE pnpm here as root at build time. /usr/local/bin/pnpm
+# becomes world-executable (mode 755) → the non-root runtime user can
+# exec it. HOME=/tmp gives pnpm/npm a writable home for state files.
+#
+# Build:
+#   docker build -f docker/dev.Dockerfile -t {{projectName}}-dev .
+# (compose's `build:` does this automatically on first `up`)
+FROM node:24-alpine
+RUN corepack enable && corepack prepare pnpm@10.25.0 --activate
+ENV HOME=/tmp
+ENV PATH=/tmp/.local/bin:$PATH
+# Don't pin a USER directive here — that would FREEZE the image to a
+# specific UID. Compose's `user: "${HOST_UID}:${HOST_GID}"` is the
+# right place to do that, dynamic per-host.

package/templates/baselines/compose/docker/web.Dockerfile ADDED Viewed

@@ -0,0 +1,59 @@
+# Web (Vite) Dockerfile for {{projectName}}'s React apps.
+#
+# Build context = project root (where pnpm-workspace.yaml lives).
+# The `.dockerignore` next to this file aggressively excludes noise.
+#
+# Build args:
+#   APP_PATH  — path relative to context where the web app lives.
+#               e.g. apps/{{projectName}}/web
+#   APP_PORT  — the port the app's `voltro start` listens on.
+#               Must match the app's app.config.ts `port` field.
+#
+# Targets:
+#   prod  — production image (`voltro build .` then `voltro start .`)
+#
+# Build:
+#   docker build \
+#     -f docker/web.Dockerfile \
+#     --build-arg APP_PATH=apps/{{projectName}}/web \
+#     --build-arg APP_PORT=5173 \
+#     -t {{projectName}}-web:latest \
+#     .
+ARG NODE_VERSION=24-alpine
+ARG PNPM_VERSION=10.25.0
+ARG APP_PATH=apps/{{projectName}}/web
+ARG APP_PORT=5173
+# ---------- deps stage ----------
+FROM node:${NODE_VERSION} AS deps
+ARG PNPM_VERSION
+RUN corepack enable && corepack prepare pnpm@${PNPM_VERSION} --activate
+WORKDIR /workspace
+COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
+COPY apps apps
+COPY packages packages
+RUN pnpm install --frozen-lockfile
+# ---------- builder stage ----------
+FROM deps AS builder
+ARG APP_PATH
+WORKDIR /workspace/${APP_PATH}
+RUN pnpm voltro build .
+# ---------- prod runner ----------
+FROM node:${NODE_VERSION} AS prod
+ARG PNPM_VERSION
+ARG APP_PATH
+ARG APP_PORT
+RUN corepack enable && corepack prepare pnpm@${PNPM_VERSION} --activate
+WORKDIR /workspace
+COPY --from=builder /workspace /workspace
+WORKDIR /workspace/${APP_PATH}
+EXPOSE ${APP_PORT}
+ENV NODE_ENV=production
+CMD ["pnpm", "voltro", "start", "."]