@msn-control/liftoff 0.2.0 → 0.3.0

package/dist/standard-templates.js

@@ -0,0 +1,797 @@
+const stackBuilders = {
+    'python-fastapi': addPythonArtifacts,
+    'node-fastify': addNodeArtifacts,
+    'go-huma': addGoArtifacts
+};
+const sourceString = (value) => JSON.stringify(value);
+const escapeHtml = (value) => value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+const localPostgresUrl = (host, database) => `postgresql:${'//'}postgres:postgres@${host}:5432/${database}`;
+export function addStandardStackArtifacts(add, plan) {
+    stackBuilders[plan.apiStack.id](add, plan);
+}
+export function renderStandardDockerfile(plan) {
+    switch (plan.apiStack.id) {
+        case 'python-fastapi':
+            return `FROM python:3.12-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app
+
+COPY backend/pyproject.toml /app/backend/pyproject.toml
+RUN pip install --no-cache-dir /app/backend
+
+COPY backend /app/backend
+COPY database /app/database
+
+EXPOSE 8000
+CMD ["uvicorn", "backend.apis.main:app", "--host", "0.0.0.0", "--port", "8000"]
+`;
+        case 'node-fastify':
+            return `FROM node:20-alpine AS build
+
+WORKDIR /app/backend
+COPY backend/package*.json ./
+RUN npm install
+COPY backend ./
+RUN npm run build
+
+FROM node:20-alpine AS runtime
+WORKDIR /app/backend
+ENV NODE_ENV=production
+COPY backend/package*.json ./
+RUN npm install --omit=dev
+COPY --from=build /app/backend/dist ./dist
+COPY database /app/database
+
+EXPOSE 8000
+CMD ["node", "dist/server.js"]
+`;
+        case 'go-huma':
+            return `FROM golang:1.23-alpine AS build
+
+WORKDIR /src/backend
+      COPY backend/go.mod ./
+RUN go mod download
+COPY backend ./
+RUN CGO_ENABLED=0 GOOS=linux go build -o /out/api ./cmd/api
+
+FROM alpine:3.20
+RUN adduser -D -u 10001 liftoff
+USER liftoff
+WORKDIR /app
+COPY --from=build /out/api /app/api
+COPY database /app/database
+
+EXPOSE 8000
+CMD ["/app/api"]
+`;
+    }
+}
+export function renderStandardEnv(plan, environment = 'dev') {
+    const local = environment === 'dev';
+    const databaseUrl = localPostgresUrl('postgres', plan.safeProjectName.replace(/-/g, '_'));
+    return `APP_ENV=${environment}
+APP_NAME=${plan.safeProjectName}
+API_STACK=${plan.apiStack.id}
+CLOUD_PROVIDER=${plan.provider.id}
+AZURE_REGION=${plan.region.slug}
+DATABASE_URL=${databaseUrl}
+REDIS_URL=redis://redis:6379/0
+MESSAGING_TRANSPORT=${local ? 'redis-streams' : 'azure-service-bus'}
+BLOB_ENDPOINT=${local ? 'http://azurite:10000/devstoreaccount1' : ''}
+`;
+}
+function addPythonArtifacts(add, plan) {
+    add('backend-pyproject', 'backend', ['backend', 'pyproject.toml'], renderPythonPyproject(plan));
+    add('backend-package', 'backend', ['backend', '__init__.py'], '');
+    add('backend-api-package', 'backend', ['backend', 'apis', '__init__.py'], '');
+    add('backend-main', 'backend', ['backend', 'apis', 'main.py'], renderPythonMain(plan));
+    add('backend-health-routes', 'backend', ['backend', 'apis', 'routes', 'health.py'], renderPythonHealthRoutes());
+    add('backend-routes-package', 'backend', ['backend', 'apis', 'routes', '__init__.py'], '');
+    add('backend-auth-dependency', 'backend', ['backend', 'apis', 'dependencies', 'auth.py'], renderPythonAuthDependency());
+    add('backend-config-package', 'backend', ['backend', 'config', '__init__.py'], '');
+    add('backend-settings', 'backend', ['backend', 'config', 'settings.py'], renderPythonSettings(plan));
+    add('backend-observability', 'backend', ['backend', 'observability', 'logging.py'], renderPythonLogging());
+    add('backend-observability-package', 'backend', ['backend', 'observability', '__init__.py'], '');
+    add('backend-test-health', 'backend-test', ['backend', 'tests', 'test_health.py'], renderPythonHealthTest());
+    add('database-alembic-ini', 'database', ['database', 'alembic.ini'], renderAlembicIni());
+    add('database-alembic-env', 'database', ['database', 'migrations', 'env.py'], renderAlembicEnv());
+    add('database-initial-migration', 'database', ['database', 'migrations', 'versions', '0001_initial.py'], renderPythonMigration());
+    add('database-schema', 'database', ['database', 'models', 'schema.sql'], renderStandardSchema(plan));
+}
+function renderPythonPyproject(plan) {
+    return `[project]
+name = "${plan.safeProjectName}-backend"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+  "fastapi>=0.111",
+  "uvicorn[standard]>=0.30",
+  "pydantic>=2.7",
+  "pydantic-settings>=2.3",
+  "scalar-fastapi>=1.0",
+  "sqlalchemy[asyncio]>=2.0",
+  "asyncpg>=0.29",
+  "psycopg[binary]>=3.2",
+  "alembic>=1.13",
+  "redis>=5.0",
+  "azure-servicebus>=7.12",
+  "azure-storage-blob>=12.20",
+  "azure-communication-email>=1.0"
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8.2", "httpx>=0.27"]
+
+[build-system]
+requires = ["setuptools>=70"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = []
+
+[tool.pytest.ini_options]
+pythonpath = [".."]
+testpaths = ["tests"]
+`;
+}
+function renderPythonMain(plan) {
+    return `from fastapi import FastAPI
+
+try:
+    from scalar_fastapi import get_scalar_api_reference
+except ImportError:  # pragma: no cover - dependency is present in generated runtime
+    get_scalar_api_reference = None
+
+from backend.apis.routes import health
+from backend.config.settings import get_settings
+
+
+settings = get_settings()
+app = FastAPI(title=settings.app_name, version="0.1.0")
+app.include_router(health.router)
+
+
+@app.get("/scalar", include_in_schema=False)
+def scalar_reference():
+    if get_scalar_api_reference is None:
+        return {"message": "Install scalar-fastapi to enable the Scalar developer portal."}
+    return get_scalar_api_reference(openapi_url=app.openapi_url, title=f"{app.title} API")
+
+
+@app.get("/api")
+def api_root():
+    return {"name": ${sourceString(plan.projectName)}, "stack": "python-fastapi"}
+`;
+}
+function renderPythonHealthRoutes() {
+    return `from fastapi import APIRouter
+
+router = APIRouter(tags=["operations"])
+
+
+@router.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@router.get("/ready")
+def ready():
+    return {"status": "ready"}
+`;
+}
+function renderPythonAuthDependency() {
+    return `from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CurrentUser:
+    subject: str = "local-developer"
+
+
+async def get_current_user() -> CurrentUser:
+    return CurrentUser()
+`;
+}
+function renderPythonSettings(plan) {
+    return `from functools import lru_cache
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    app_name: str = ${sourceString(plan.projectName)}
+    app_env: str = "dev"
+    api_stack: str = "python-fastapi"
+    cloud_provider: str = "${plan.provider.id}"
+    azure_region: str = "${plan.region.slug}"
+    database_url: str
+    redis_url: str
+    messaging_transport: str = "redis-streams"
+    blob_endpoint: str | None = None
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+`;
+}
+function renderPythonLogging() {
+    return `import logging
+
+
+def configure_logging() -> None:
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
+`;
+}
+function renderPythonHealthTest() {
+    return `from fastapi.testclient import TestClient
+
+from backend.apis.main import app
+
+
+def test_health():
+    response = TestClient(app).get("/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ok"
+
+
+def test_ready():
+    response = TestClient(app).get("/ready")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ready"
+`;
+}
+function renderAlembicIni() {
+    return `[alembic]
+script_location = %(here)s/migrations
+sqlalchemy.url =
+`;
+}
+function renderAlembicEnv() {
+    return `import os
+
+from alembic import context
+from sqlalchemy import create_engine
+
+config = context.config
+target_metadata = None
+
+
+def run_migrations_online():
+    database_url = os.environ.get("DATABASE_URL")
+    if not database_url:
+        raise RuntimeError("DATABASE_URL is required to run migrations")
+    database_url = database_url.replace("postgresql+asyncpg://", "postgresql+psycopg://", 1)
+    database_url = database_url.replace("postgresql://", "postgresql+psycopg://", 1)
+    connectable = create_engine(database_url)
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+run_migrations_online()
+`;
+}
+function renderPythonMigration() {
+    return `from alembic import op
+import sqlalchemy as sa
+
+revision = "0001_initial"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        "app_records",
+        sa.Column("id", sa.Integer(), primary_key=True),
+        sa.Column("name", sa.String(length=255), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+    )
+
+
+def downgrade():
+    op.drop_table("app_records")
+`;
+}
+function addNodeArtifacts(add, plan) {
+    add('node-backend-package', 'backend', ['backend', 'package.json'], renderNodePackage(plan));
+    add('node-backend-tsconfig', 'backend', ['backend', 'tsconfig.json'], renderNodeTsconfig());
+    add('node-backend-drizzle-config', 'backend', ['backend', 'drizzle.config.ts'], renderNodeDrizzleConfig());
+    add('node-backend-config', 'backend', ['backend', 'src', 'config.ts'], renderNodeConfig(plan));
+    add('node-backend-app', 'backend', ['backend', 'src', 'app.ts'], renderNodeApp(plan));
+    add('node-backend-server', 'backend', ['backend', 'src', 'server.ts'], renderNodeServer());
+    add('node-backend-database', 'backend', ['backend', 'src', 'database.ts'], renderNodeDatabase());
+    add('node-backend-schema', 'backend', ['backend', 'src', 'db', 'schema.ts'], renderNodeSchema());
+    add('node-backend-test-health', 'backend-test', ['backend', 'test', 'health.test.ts'], renderNodeHealthTest());
+    add('database-node-migration', 'database', ['database', 'migrations', '0000_initial.sql'], renderNodeMigration());
+    add('database-node-migration-journal', 'database', ['database', 'migrations', 'meta', '_journal.json'], renderNodeMigrationJournal());
+    add('database-node-migration-snapshot', 'database', ['database', 'migrations', 'meta', '0000_snapshot.json'], renderNodeMigrationSnapshot());
+    add('database-schema', 'database', ['database', 'models', 'schema.sql'], renderStandardSchema(plan));
+}
+function renderNodePackage(plan) {
+    return JSON.stringify({
+        name: `${plan.safeProjectName}-backend`,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        engines: { node: '>=20' },
+        scripts: {
+            dev: 'tsx watch src/server.ts',
+            build: 'tsc -p tsconfig.json',
+            start: 'node dist/server.js',
+            test: 'vitest run',
+            'db:generate': 'drizzle-kit generate',
+            'db:migrate': 'drizzle-kit migrate'
+        },
+        dependencies: {
+            '@fastify/swagger': '^9.4.0',
+            'drizzle-orm': '^0.44.0',
+            fastify: '^5.4.0',
+            pg: '^8.16.0'
+        },
+        devDependencies: {
+            '@types/node': '^20.14.10',
+            '@types/pg': '^8.15.0',
+            'drizzle-kit': '^0.31.0',
+            tsx: '^4.20.0',
+            typescript: '^5.5.4',
+            vitest: '^4.1.9'
+        }
+    }, null, 2);
+}
+function renderNodeTsconfig() {
+    return JSON.stringify({
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'NodeNext',
+            moduleResolution: 'NodeNext',
+            rootDir: 'src',
+            outDir: 'dist',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true
+        },
+        include: ['src/**/*.ts']
+    }, null, 2);
+}
+function renderNodeDrizzleConfig() {
+    const fallbackUrl = localPostgresUrl('localhost', 'postgres');
+    return `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  dialect: 'postgresql',
+  schema: './src/db/schema.ts',
+  out: '../database/migrations',
+  dbCredentials: {
+    url: process.env.DATABASE_URL ?? ${sourceString(fallbackUrl)}
+  }
+});
+`;
+}
+function renderNodeConfig(plan) {
+    return `export interface AppConfig {
+  appName: string;
+  appEnv: string;
+  port: number;
+    cloudProvider: string;
+    azureRegion: string;
+    databaseUrl: string;
+    redisUrl: string;
+    messagingTransport: string;
+    blobEndpoint?: string;
+  }
+
+export function loadConfig(env: NodeJS.ProcessEnv = process.env): AppConfig {
+  const databaseUrl = env.DATABASE_URL;
+  const redisUrl = env.REDIS_URL;
+  if (!databaseUrl || !redisUrl) {
+    throw new Error('DATABASE_URL and REDIS_URL are required.');
+  }
+  return {
+    appName: env.APP_NAME ?? ${sourceString(plan.projectName)},
+    appEnv: env.APP_ENV ?? 'dev',
+    port: Number.parseInt(env.PORT ?? '8000', 10),
+    cloudProvider: env.CLOUD_PROVIDER ?? '${plan.provider.id}',
+    azureRegion: env.AZURE_REGION ?? '${plan.region.slug}',
+    databaseUrl,
+    redisUrl,
+    messagingTransport: env.MESSAGING_TRANSPORT ?? 'redis-streams',
+    blobEndpoint: env.BLOB_ENDPOINT || undefined
+  };
+}
+`;
+}
+function renderNodeApp(plan) {
+    const scalarPage = `<!doctype html><html><head><title>${escapeHtml(plan.projectName)} API</title></head><body><script id="api-reference" data-url="/openapi.json"></script><script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script></body></html>`;
+    return `import swagger from '@fastify/swagger';
+import Fastify from 'fastify';
+
+const scalarPage = ${sourceString(scalarPage)};
+
+export async function buildApp() {
+  const app = Fastify({ logger: true });
+  await app.register(swagger, {
+    openapi: {
+      info: { title: ${sourceString(`${plan.projectName} API`)}, version: '0.1.0' }
+    }
+  });
+
+  const statusSchema = {
+    response: {
+      200: {
+        type: 'object',
+        required: ['status'],
+        properties: { status: { type: 'string' } }
+      }
+    }
+  } as const;
+
+  app.get('/health', { schema: statusSchema }, async () => ({ status: 'ok' }));
+  app.get('/ready', { schema: statusSchema }, async () => ({ status: 'ready' }));
+  app.get('/api', async () => ({ name: ${sourceString(plan.projectName)}, stack: 'node-fastify' }));
+  app.get('/openapi.json', async () => app.swagger());
+  app.get('/scalar', async (_request, reply) => reply.type('text/html').send(scalarPage));
+  return app;
+}
+`;
+}
+function renderNodeServer() {
+    return `import { buildApp } from './app.js';
+import { loadConfig } from './config.js';
+
+const config = loadConfig();
+const app = await buildApp();
+
+try {
+  await app.listen({ host: '0.0.0.0', port: config.port });
+} catch (error) {
+  app.log.error(error);
+  process.exitCode = 1;
+}
+`;
+}
+function renderNodeDatabase() {
+    return `import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import { loadConfig } from './config.js';
+
+const pool = new Pool({ connectionString: loadConfig().databaseUrl });
+export const database = drizzle(pool);
+`;
+}
+function renderNodeSchema() {
+    return `import { integer, pgTable, timestamp, varchar } from 'drizzle-orm/pg-core';
+
+export const appRecords = pgTable('app_records', {
+  id: integer('id').primaryKey().generatedAlwaysAsIdentity(),
+  name: varchar('name', { length: 255 }).notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull()
+});
+`;
+}
+function renderNodeHealthTest() {
+    return `import { describe, expect, it } from 'vitest';
+import { buildApp } from '../src/app.js';
+
+describe('health endpoints', () => {
+  it('reports healthy and ready', async () => {
+    const app = await buildApp();
+    const health = await app.inject({ method: 'GET', url: '/health' });
+    const ready = await app.inject({ method: 'GET', url: '/ready' });
+    expect(health.json()).toEqual({ status: 'ok' });
+    expect(ready.json()).toEqual({ status: 'ready' });
+    await app.close();
+  });
+});
+`;
+}
+function renderNodeMigration() {
+    return `CREATE TABLE app_records (
+  id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  name varchar(255) NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+`;
+}
+function renderNodeMigrationJournal() {
+    return JSON.stringify({
+        version: '7',
+        dialect: 'postgresql',
+        entries: [
+            {
+                idx: 0,
+                version: '7',
+                when: 0,
+                tag: '0000_initial',
+                breakpoints: true
+            }
+        ]
+    }, null, 2);
+}
+function renderNodeMigrationSnapshot() {
+    return JSON.stringify({
+        id: '00000000-0000-4000-8000-000000000001',
+        prevId: '00000000-0000-0000-0000-000000000000',
+        version: '7',
+        dialect: 'postgresql',
+        tables: {
+            'public.app_records': {
+                name: 'app_records',
+                schema: '',
+                columns: {
+                    id: {
+                        name: 'id',
+                        type: 'integer',
+                        primaryKey: true,
+                        notNull: true,
+                        identity: {
+                            type: 'always',
+                            name: 'app_records_id_seq',
+                            schema: 'public',
+                            increment: '1',
+                            startWith: '1',
+                            minValue: '1',
+                            maxValue: '2147483647',
+                            cache: '1',
+                            cycle: false
+                        }
+                    },
+                    name: {
+                        name: 'name',
+                        type: 'varchar(255)',
+                        primaryKey: false,
+                        notNull: true
+                    },
+                    created_at: {
+                        name: 'created_at',
+                        type: 'timestamp with time zone',
+                        primaryKey: false,
+                        notNull: true,
+                        default: 'now()'
+                    }
+                },
+                indexes: {},
+                foreignKeys: {},
+                compositePrimaryKeys: {},
+                uniqueConstraints: {},
+                policies: {},
+                checkConstraints: {},
+                isRLSEnabled: false
+            }
+        },
+        enums: {},
+        schemas: {},
+        sequences: {},
+        roles: {},
+        policies: {},
+        views: {},
+        _meta: {
+            columns: {},
+            schemas: {},
+            tables: {}
+        }
+    }, null, 2);
+}
+function addGoArtifacts(add, plan) {
+    add('go-backend-module', 'backend', ['backend', 'go.mod'], renderGoModule(plan));
+    add('go-backend-makefile', 'backend', ['backend', 'Makefile'], renderGoMakefile());
+    add('go-backend-main', 'backend', ['backend', 'cmd', 'api', 'main.go'], renderGoMain(plan));
+    add('go-backend-api', 'backend', ['backend', 'internal', 'api', 'api.go'], renderGoApi(plan));
+    add('go-backend-config', 'backend', ['backend', 'internal', 'config', 'config.go'], renderGoConfig(plan));
+    add('go-backend-database', 'backend', ['backend', 'internal', 'database', 'database.go'], renderGoDatabase());
+    add('go-backend-test-health', 'backend-test', ['backend', 'internal', 'api', 'api_test.go'], renderGoHealthTest(plan));
+    add('database-go-migration', 'database', ['database', 'migrations', '0001_initial.sql'], renderGoMigration());
+    add('database-schema', 'database', ['database', 'models', 'schema.sql'], renderStandardSchema(plan));
+}
+function goModule(plan) {
+    return `example.com/${plan.packageName}/backend`;
+}
+function renderGoModule(plan) {
+    return `module ${goModule(plan)}
+
+go 1.23
+
+require (
+	github.com/danielgtaylor/huma/v2 v2.27.0
+	github.com/go-chi/chi/v5 v5.2.1
+	github.com/jackc/pgx/v5 v5.7.2
+)
+`;
+}
+function renderGoMakefile() {
+    return `GOOSE_VERSION := v3.24.1
+
+.PHONY: test migrate
+
+test:
+	go test ./...
+
+migrate:
+	go run github.com/pressly/goose/v3/cmd/goose@$(GOOSE_VERSION) -dir ../database/migrations postgres "$(DATABASE_URL)" up
+`;
+}
+function renderGoMain(plan) {
+    return `package main
+
+import (
+	"log"
+	"net/http"
+
+	"${goModule(plan)}/internal/api"
+	"${goModule(plan)}/internal/config"
+)
+
+func main() {
+	cfg, err := config.Load()
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Printf("%s listening on :%s", cfg.AppName, cfg.Port)
+	log.Fatal(http.ListenAndServe(":"+cfg.Port, api.New(cfg.AppName)))
+}
+`;
+}
+function renderGoApi(plan) {
+    return `package api
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/danielgtaylor/huma/v2"
+	"github.com/danielgtaylor/huma/v2/adapters/humachi"
+	"github.com/go-chi/chi/v5"
+)
+
+type statusOutput struct {
+	Body struct {
+		Status string \`json:"status"\`
+	}
+}
+
+func New(name string) http.Handler {
+	router := chi.NewRouter()
+	config := huma.DefaultConfig(name+" API", "0.1.0")
+	config.OpenAPIPath = "/openapi"
+	config.DocsPath = ""
+	api := humachi.New(router, config)
+
+	huma.Get(api, "/health", func(context.Context, *struct{}) (*statusOutput, error) {
+		output := &statusOutput{}
+		output.Body.Status = "ok"
+		return output, nil
+	})
+	huma.Get(api, "/ready", func(context.Context, *struct{}) (*statusOutput, error) {
+		output := &statusOutput{}
+		output.Body.Status = "ready"
+		return output, nil
+	})
+
+	router.Get("/api", func(response http.ResponseWriter, _ *http.Request) {
+		response.Header().Set("Content-Type", "application/json")
+		fmt.Fprint(response, ${sourceString(JSON.stringify({ name: plan.projectName, stack: 'go-huma' }))})
+	})
+	router.Get("/scalar", scalarReference)
+	return router
+}
+
+func scalarReference(response http.ResponseWriter, _ *http.Request) {
+	response.Header().Set("Content-Type", "text/html; charset=utf-8")
+	fmt.Fprint(response, \`<!doctype html><html><head><title>API Reference</title></head><body><script id="api-reference" data-url="/openapi.json"></script><script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script></body></html>\`)
+}
+`;
+}
+function renderGoConfig(plan) {
+    return `package config
+
+import (
+	"fmt"
+	"os"
+)
+
+type Config struct {
+	AppName            string
+	AppEnv             string
+	Port               string
+	CloudProvider      string
+	AzureRegion        string
+	DatabaseURL        string
+	RedisURL           string
+	MessagingTransport string
+	BlobEndpoint       string
+}
+
+func Load() (Config, error) {
+	databaseURL := os.Getenv("DATABASE_URL")
+	redisURL := os.Getenv("REDIS_URL")
+	if databaseURL == "" || redisURL == "" {
+		return Config{}, fmt.Errorf("DATABASE_URL and REDIS_URL are required")
+	}
+	return Config{
+		AppName:            value("APP_NAME", ${sourceString(plan.projectName)}),
+		AppEnv:             value("APP_ENV", "dev"),
+		Port:               value("PORT", "8000"),
+		CloudProvider:      value("CLOUD_PROVIDER", "${plan.provider.id}"),
+		AzureRegion:        value("AZURE_REGION", "${plan.region.slug}"),
+		DatabaseURL:        databaseURL,
+		RedisURL:           redisURL,
+		MessagingTransport: value("MESSAGING_TRANSPORT", "redis-streams"),
+		BlobEndpoint:       os.Getenv("BLOB_ENDPOINT"),
+	}, nil
+}
+
+func value(name, fallback string) string {
+	if current := os.Getenv(name); current != "" {
+		return current
+	}
+	return fallback
+}
+`;
+}
+function renderGoDatabase() {
+    return `package database
+
+import (
+	"context"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func Open(ctx context.Context, databaseURL string) (*pgxpool.Pool, error) {
+	return pgxpool.New(ctx, databaseURL)
+}
+`;
+}
+function renderGoHealthTest(plan) {
+    return `package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestHealthAndReady(t *testing.T) {
+	handler := New(${sourceString(plan.projectName)})
+	for _, path := range []string{"/health", "/ready"} {
+		request := httptest.NewRequest(http.MethodGet, path, nil)
+		response := httptest.NewRecorder()
+		handler.ServeHTTP(response, request)
+		if response.Code != http.StatusOK {
+			t.Fatalf("%s returned %d", path, response.Code)
+		}
+	}
+}
+`;
+}
+function renderGoMigration() {
+    return `-- +goose Up
+CREATE TABLE app_records (
+  id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  name varchar(255) NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+
+-- +goose Down
+DROP TABLE app_records;
+`;
+}
+function renderStandardSchema(plan) {
+    return `-- ${plan.safeProjectName} standard application schema
+CREATE TABLE IF NOT EXISTS app_records (
+  id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  name varchar(255) NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+`;
+}
+//# sourceMappingURL=standard-templates.js.map