@podosoft/podokit 0.1.0 → 0.2.0

package/README.md

@@ -0,0 +1,98 @@
+# @podosoft/podokit
+
+**PodoKit** is an opinionated but extensible starter toolkit and CLI for building full-stack TypeScript applications with **NestJS**, **SvelteKit**, **TailwindCSS**, **shadcn-svelte**, **Docker**, and **k3s**.
+
+Stop rewriting the same backend bootstrap, frontend setup, environment config, health checks, Docker Compose, and CI every time you start a project. `podo create` gives you a consistent, production-minded foundation in seconds.
+
+## Quick start
+
+```bash
+npx @podosoft/podokit create my-app
+cd my-app
+npm install
+cp .env.example .env
+npm run dev
+```
+
+- API: http://localhost:3000 (health at `/health`)
+- Web: http://localhost:5173
+
+When run in a terminal, `podo create` lists the templates with descriptions and asks which one (and which package manager) to use. Pass flags (or `--yes`) to skip the prompts.
+
+The `todo` template (`--template todo`) generates a working todo app (SvelteKit UI + NestJS API + PostgreSQL) with Swagger docs:
+
+![Generated todo app](https://raw.githubusercontent.com/podosoft-dev/podokit/main/docs/images/todo-app.png)
+
+## Usage
+
+```
+podo create <name> [options]
+
+Options:
+  --template <t>   Template to scaffold (default: fullstack-nest-svelte)
+                     - fullstack-nest-svelte : clean NestJS + SvelteKit starter
+                     - todo                  : fullstack + a Todo CRUD example
+                     - base                  : minimal npm workspace
+  --dir <path>     Target directory (default: ./<name>)
+  --pm <name>      Package manager: npm | pnpm | yarn (default: npm)
+  -y, --yes        Skip prompts and accept defaults
+  -h, --help       Show help
+```
+
+Examples:
+
+```bash
+# Interactive
+npx @podosoft/podokit create my-app
+
+# Non-interactive, explicit choices
+npx @podosoft/podokit create my-app --template fullstack-nest-svelte --pm pnpm --yes
+
+# Minimal workspace
+npx @podosoft/podokit create my-lib --template base --yes
+```
+
+## Add features with modules
+
+```bash
+cd my-app
+npx @podosoft/podokit add auth-jwt   # JWT auth: register, login, guard, /auth/me
+```
+
+`podo add <module>` overlays files, merges dependencies, appends env vars, and wires the module into the NestJS app. Run `podo add` with no argument to list available modules.
+
+## What you get (`fullstack-nest-svelte`)
+
+```
+my-app/
+├── apps/
+│   ├── api/           # NestJS: config validation, /health, global
+│   │   └── src/       # ValidationPipe, standard error envelope
+│   └── web/           # SvelteKit: Tailwind v4, shadcn-svelte,
+│       └── src/       # typesafe-i18n, server-side API proxy
+├── infra/
+│   ├── docker/        # docker-compose (PostgreSQL, Redis)
+│   └── k3s/           # namespace, deployments, service, ingress, secret example
+├── .env.example
+├── package.json       # npm workspace
+└── README.md
+```
+
+Highlights of the generated app:
+
+- **Backend (NestJS)** — bootstrap with a global `ValidationPipe` and exception filter, typed environment validation, a `/health` endpoint, and a stable `{ success, error: { code, ... } }` response envelope.
+- **Frontend (SvelteKit)** — TailwindCSS v4 (config-less), **shadcn-svelte components preinstalled** (button, input, card, checkbox, label), a typesafe-i18n scaffold, and a **server-side proxy** so the browser never calls the API directly.
+- **Infra** — Docker Compose for local PostgreSQL and Redis, plus example k3s manifests (standard `Ingress`, `secret.example.yaml`).
+
+## Status
+
+PodoKit is early (`0.x`). The CLI and templates work end-to-end, but APIs and templates may change before `1.0`. Feedback and issues are welcome.
+
+## Links
+
+- Repository & issues: https://github.com/podosoft-dev/podokit
+- Changelog: https://github.com/podosoft-dev/podokit/blob/main/CHANGELOG.md
+
+## License
+
+[Apache-2.0](https://github.com/podosoft-dev/podokit/blob/main/LICENSE)

package/dist/add.d.ts

@@ -0,0 +1,40 @@
+interface Injection {
+    file: string;
+    marker: string;
+    text: string;
+}
+export interface ModuleManifest {
+    name: string;
+    description: string;
+    requires?: string[];
+    targetApp: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    env?: string[];
+    inject?: Injection[];
+    instructions?: string[];
+}
+export interface AddOptions {
+    projectRoot: string;
+    module: string;
+    modulesDir: string;
+}
+export interface AddResult {
+    module: string;
+    instructions: string[];
+    /** Required modules that were auto-added because they were missing. */
+    added: string[];
+}
+/** List modules available under `modulesDir` (each has a module.manifest.json). */
+export declare function listModules(modulesDir: string): {
+    name: string;
+    description: string;
+}[];
+/**
+ * Apply a module to an existing generated project: overlay files, merge the
+ * target app's package.json dependencies and scripts, append env example lines,
+ * and inject wiring at markers. Missing required modules are added first.
+ */
+export declare function addModule(options: AddOptions): AddResult;
+export {};

package/dist/add.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listModules = listModules;
+exports.addModule = addModule;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const podokit_template_engine_1 = require("@podosoft/podokit-template-engine");
+/** List modules available under `modulesDir` (each has a module.manifest.json). */
+function listModules(modulesDir) {
+    if (!(0, node_fs_1.existsSync)(modulesDir))
+        return [];
+    return (0, node_fs_1.readdirSync)(modulesDir)
+        .filter((name) => (0, node_fs_1.existsSync)((0, node_path_1.join)(modulesDir, name, "module.manifest.json")))
+        .map((name) => {
+        const manifest = readManifest((0, node_path_1.join)(modulesDir, name));
+        return { name, description: manifest.description };
+    });
+}
+function readManifest(moduleDir) {
+    return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(moduleDir, "module.manifest.json"), "utf8"));
+}
+function readJson(path) {
+    return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+}
+function projectName(projectRoot) {
+    const pkg = readJson((0, node_path_1.join)(projectRoot, "package.json"));
+    return typeof pkg.name === "string" ? pkg.name : "app";
+}
+function appendEnv(projectRoot, lines) {
+    const file = (0, node_path_1.join)(projectRoot, ".env.example");
+    if (!(0, node_fs_1.existsSync)(file))
+        return;
+    const current = (0, node_fs_1.readFileSync)(file, "utf8");
+    const missing = lines.filter((line) => !current.split("\n").includes(line));
+    if (missing.length === 0)
+        return;
+    const separator = current.endsWith("\n") ? "" : "\n";
+    (0, node_fs_1.writeFileSync)(file, `${current}${separator}\n${missing.join("\n")}\n`);
+}
+/** Heuristic: is `module` already applied to the project? */
+function isApplied(projectRoot, modulesDir, module) {
+    const manifestPath = (0, node_path_1.join)(modulesDir, module, "module.manifest.json");
+    if (!(0, node_fs_1.existsSync)(manifestPath))
+        return false;
+    const manifest = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, "utf8"));
+    const firstInject = manifest.inject?.[0];
+    if (firstInject) {
+        const target = (0, node_path_1.join)(projectRoot, firstInject.file);
+        return (0, node_fs_1.existsSync)(target) && (0, node_fs_1.readFileSync)(target, "utf8").includes(firstInject.text);
+    }
+    return false;
+}
+/**
+ * Apply a module to an existing generated project: overlay files, merge the
+ * target app's package.json dependencies and scripts, append env example lines,
+ * and inject wiring at markers. Missing required modules are added first.
+ */
+function addModule(options) {
+    return applyModule(options.projectRoot, options.module, options.modulesDir, new Set());
+}
+function applyModule(projectRoot, module, modulesDir, applied) {
+    const moduleDir = (0, node_path_1.join)(modulesDir, module);
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(moduleDir, "module.manifest.json"))) {
+        const available = listModules(modulesDir).map((m) => m.name);
+        throw new Error(`Unknown module "${module}".${available.length ? ` Available: ${available.join(", ")}.` : ""}`);
+    }
+    const manifest = readManifest(moduleDir);
+    const appPkgPath = (0, node_path_1.join)(projectRoot, "apps", manifest.targetApp, "package.json");
+    if (!(0, node_fs_1.existsSync)(appPkgPath)) {
+        throw new Error(`This does not look like a PodoKit project: ${(0, node_path_1.join)("apps", manifest.targetApp, "package.json")} not found. Run inside a generated project.`);
+    }
+    applied.add(module);
+    // 0) apply required modules first (auto-add if missing)
+    const added = [];
+    for (const required of manifest.requires ?? []) {
+        if (applied.has(required) || isApplied(projectRoot, modulesDir, required))
+            continue;
+        const result = applyModule(projectRoot, required, modulesDir, applied);
+        added.push(required, ...result.added);
+    }
+    const appName = projectName(projectRoot);
+    const vars = { projectName: appName };
+    // 1) overlay files
+    const filesDir = (0, node_path_1.join)(moduleDir, "files");
+    if ((0, node_fs_1.existsSync)(filesDir)) {
+        (0, podokit_template_engine_1.copyTemplate)(filesDir, projectRoot, vars);
+    }
+    // 2) merge dependencies and scripts into the target app
+    if (manifest.dependencies || manifest.devDependencies || manifest.scripts) {
+        const overlay = {};
+        if (manifest.dependencies)
+            overlay.dependencies = manifest.dependencies;
+        if (manifest.devDependencies)
+            overlay.devDependencies = manifest.devDependencies;
+        if (manifest.scripts)
+            overlay.scripts = manifest.scripts;
+        const merged = (0, podokit_template_engine_1.mergePackageJson)(readJson(appPkgPath), overlay);
+        (0, node_fs_1.writeFileSync)(appPkgPath, `${JSON.stringify(merged, null, 2)}\n`);
+    }
+    // 3) append env example lines
+    if (manifest.env?.length) {
+        appendEnv(projectRoot, manifest.env);
+    }
+    // 4) inject wiring at markers
+    for (const injection of manifest.inject ?? []) {
+        const target = (0, node_path_1.join)(projectRoot, injection.file);
+        if (!(0, node_fs_1.existsSync)(target)) {
+            throw new Error(`Cannot wire module: ${injection.file} not found.`);
+        }
+        (0, node_fs_1.writeFileSync)(target, (0, podokit_template_engine_1.insertAtMarker)((0, node_fs_1.readFileSync)(target, "utf8"), injection.marker, injection.text));
+    }
+    const instructions = (manifest.instructions ?? []).map((line) => line.replace(/<app>/g, appName));
+    return { module, instructions, added };
+}

package/dist/create.d.ts

@@ -1,5 +1,6 @@
+import { DEFAULT_TEMPLATE } from "./templates";
 export type PackageManager = "npm" | "pnpm" | "yarn";
-export declare const DEFAULT_TEMPLATE = "fullstack-nest-svelte";
+export { DEFAULT_TEMPLATE };
 export interface CreateOptions {
     /** Project name; also the default directory name. */
     name: string;

package/dist/create.js

@@ -6,7 +6,8 @@ exports.create = create;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const podokit_template_engine_1 = require("@podosoft/podokit-template-engine");
-exports.DEFAULT_TEMPLATE = "fullstack-nest-svelte";
+const templates_1 = require("./templates");
+Object.defineProperty(exports, "DEFAULT_TEMPLATE", { enumerable: true, get: function () { return templates_1.DEFAULT_TEMPLATE; } });
 const NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-._]*[a-z0-9])?$/i;
 /** Validate a project name: no path separators, npm-friendly characters. */
 function assertValidName(name) {
@@ -24,7 +25,7 @@ function isEmptyDir(dir) {
 function create(options) {
     const { name, templatesDir } = options;
     assertValidName(name);
-    const template = options.template ?? exports.DEFAULT_TEMPLATE;
+    const template = options.template ?? templates_1.DEFAULT_TEMPLATE;
     const packageManager = options.packageManager ?? "npm";
     const projectDir = options.targetDir
         ? (0, node_path_1.isAbsolute)(options.targetDir)

package/dist/index.js

@@ -6,20 +6,28 @@ const node_path_1 = require("node:path");
 const promises_1 = require("node:readline/promises");
 const create_1 = require("./create");
 const prompt_1 = require("./prompt");
+const templates_1 = require("./templates");
+const add_1 = require("./add");
 const HELP = `podo — PodoKit project generator
 
 Usage:
   podo create <name> [options]
+  podo add <module>
 
 Options:
-  --template <t> Template: fullstack-nest-svelte | base (default: fullstack-nest-svelte)
+  --template <t> Template to scaffold (see below)
   --dir <path>   Target directory (default: ./<name>)
   --pm <name>    Package manager: npm | pnpm | yarn (default: npm)
   -y, --yes      Skip prompts and accept defaults
   -h, --help     Show this help
 
+Templates:
+${(0, templates_1.templateListText)()}
+
 Example:
   npx @podosoft/podokit create my-app
+  npx @podosoft/podokit create my-app --template todo
+  cd my-app && npx @podosoft/podokit add auth-jwt
 `;
 function parseArgs(argv) {
     const parsed = { help: false, yes: false };
@@ -59,6 +67,32 @@ async function main(argv) {
         process.stdout.write(HELP);
         return;
     }
+    const modulesDir = (0, node_path_1.join)(__dirname, "templates", "modules");
+    if (args.command === "add") {
+        const moduleName = args.name;
+        if (!moduleName) {
+            const available = (0, add_1.listModules)(modulesDir);
+            const list = available.length
+                ? available.map((m) => `  ${m.name}  ${m.description}`).join("\n")
+                : "  (none available)";
+            process.stdout.write(`Usage: podo add <module>\n\nModules:\n${list}\n`);
+            return;
+        }
+        try {
+            const result = (0, add_1.addModule)({ projectRoot: process.cwd(), module: moduleName, modulesDir });
+            if (result.added.length) {
+                process.stdout.write(`\nAlso added required module(s): ${result.added.join(", ")}\n`);
+            }
+            process.stdout.write(`\nAdded ${result.module}.\n`);
+            if (result.instructions.length) {
+                process.stdout.write(`\nNext steps:\n${result.instructions.map((i) => `  ${i}`).join("\n")}\n`);
+            }
+        }
+        catch (err) {
+            fail(err.message);
+        }
+        return;
+    }
     if (args.command !== "create") {
         fail(`Unknown command "${args.command}". Run "podo --help".`);
     }
@@ -74,6 +108,10 @@ async function main(argv) {
     const interactive = Boolean(process.stdin.isTTY) && !args.yes;
     const rl = interactive ? (0, promises_1.createInterface)({ input: process.stdin, output: process.stdout }) : undefined;
     const ask = async (question) => (rl ? (await rl.question(question)).trim() : "");
+    // Show the template menu with descriptions before prompting for one.
+    if (interactive && !args.template) {
+        process.stdout.write(`\nTemplates:\n${(0, templates_1.templateListText)()}\n\n`);
+    }
     const templatesDir = (0, node_path_1.join)(__dirname, "templates");
     try {
         const resolved = await (0, prompt_1.resolveCreateOptions)({ template: args.template, pm: args.pm }, ask, interactive);

package/dist/prompt.d.ts

@@ -1,5 +1,4 @@
 import { type PackageManager } from "./create";
-export declare const TEMPLATES: readonly ["fullstack-nest-svelte", "base"];
 export declare const PACKAGE_MANAGERS: PackageManager[];
 /** Asks a single question and resolves to the trimmed answer (empty if skipped). */
 export type Ask = (question: string) => Promise<string>;

package/dist/prompt.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PACKAGE_MANAGERS = exports.TEMPLATES = void 0;
+exports.PACKAGE_MANAGERS = void 0;
 exports.resolveCreateOptions = resolveCreateOptions;
-const create_1 = require("./create");
-exports.TEMPLATES = ["fullstack-nest-svelte", "base"];
+const templates_1 = require("./templates");
 exports.PACKAGE_MANAGERS = ["npm", "pnpm", "yarn"];
 function isPackageManager(value) {
     return exports.PACKAGE_MANAGERS.includes(value);
@@ -18,12 +17,12 @@ function isPackageManager(value) {
 async function resolveCreateOptions(args, ask, interactive) {
     let template = args.template;
     if (!template && interactive) {
-        const answer = await ask(`Template (${exports.TEMPLATES.join(" / ")}) [${create_1.DEFAULT_TEMPLATE}]: `);
+        const answer = await ask(`Template [${templates_1.DEFAULT_TEMPLATE}]: `);
         template = answer || undefined;
     }
-    template = template ?? create_1.DEFAULT_TEMPLATE;
-    if (!exports.TEMPLATES.includes(template)) {
-        throw new Error(`Unknown template "${template}". Choose one of: ${exports.TEMPLATES.join(", ")}.`);
+    template = template ?? templates_1.DEFAULT_TEMPLATE;
+    if (!(0, templates_1.isKnownTemplate)(template)) {
+        throw new Error(`Unknown template "${template}". Choose one of: ${templates_1.TEMPLATE_NAMES.join(", ")}.`);
     }
     let pm = args.pm;
     if (!pm && interactive) {

package/dist/templates/fullstack-nest-svelte/README.md

@@ -1,29 +1,41 @@
 # {{projectName}}
 
-Full-stack TypeScript app generated with [PodoKit](https://github.com/podosoft-dev/podokit).
+Full-stack TypeScript starter generated with [PodoKit](https://github.com/podosoft-dev/podokit).
 
-- `apps/api` — NestJS API (config validation, health checks, standard error envelope)
-- `apps/web` — SvelteKit app (TailwindCSS v4, shadcn-svelte, typesafe-i18n) that talks to the API through a server-side proxy
-- `infra/` — Docker Compose and k3s manifests
+- `apps/api` — NestJS API: schema-validated env (zod), `/health` + `/health/ready`, Swagger docs at `/api-docs`, a standard error envelope, and TypeORM + PostgreSQL wired up (no domain entities yet — add your own).
+- `apps/web` — SvelteKit app (TailwindCSS v4, shadcn-svelte, typesafe-i18n) that talks to the API through a server-side proxy.
+- `infra/` — Docker Compose (PostgreSQL, Redis) and k3s manifests.
 
 ## Getting started
 
 ```bash
 {{packageManager}} install
 cp .env.example .env
+
+# start local PostgreSQL + Redis
+docker compose -f infra/docker/docker-compose.yml up -d
+
 {{packageManager}} run dev
 ```
 
-- API: http://localhost:3000 (health at `/health`)
+- API: http://localhost:3000 — health at `/health`, docs at `/api-docs`
 - Web: http://localhost:5173
 
-## Local services
+## Database & migrations
+
+The API uses TypeORM with PostgreSQL and ships no domain entities yet. Add an
+entity under `apps/api/src`, register it in `src/database/data-source.ts`, then
+generate and run a migration:
 
 ```bash
-docker compose -f infra/docker/docker-compose.yml up -d
+{{packageManager}} run migration:generate -w {{projectName}}-api -- src/migrations/Init
+{{packageManager}} run migration:run -w {{projectName}}-api
 ```
 
+Want a worked example? Generate the `todo` template instead:
+`npx @podosoft/podokit create my-app --template todo`.
+
 ## Deploy
 
-Docker Compose manifests live in `infra/docker`; example k3s manifests in `infra/k3s`
+Docker Compose in `infra/docker`; example k3s manifests in `infra/k3s`
 (use `secret.example.yaml` as a template — never commit real secrets).

package/dist/templates/fullstack-nest-svelte/apps/api/package.json

@@ -7,16 +7,27 @@
     "build": "nest build",
     "start": "node dist/main",
     "lint": "tsc -p tsconfig.json --noEmit",
-    "test": "jest"
+    "test": "jest",
+    "typeorm": "typeorm-ts-node-commonjs -d src/database/data-source.ts",
+    "migration:run": "npm run typeorm -- migration:run",
+    "migration:revert": "npm run typeorm -- migration:revert",
+    "migration:generate": "npm run typeorm -- migration:generate"
   },
   "dependencies": {
     "@nestjs/common": "^10.4.0",
+    "@nestjs/config": "^3.2.3",
     "@nestjs/core": "^10.4.0",
     "@nestjs/platform-express": "^10.4.0",
+    "@nestjs/swagger": "^7.4.0",
+    "@nestjs/typeorm": "^10.0.2",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "dotenv": "^16.4.5",
+    "pg": "^8.12.0",
     "reflect-metadata": "^0.2.2",
-    "rxjs": "^7.8.1"
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.20",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@nestjs/cli": "^10.4.0",
@@ -27,6 +38,7 @@
     "jest": "^29.7.0",
     "supertest": "^7.0.0",
     "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
     "typescript": "^5.6.3"
   }
 }

package/dist/templates/fullstack-nest-svelte/apps/api/src/app.module.ts

@@ -1,7 +1,17 @@
 import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
+import { TypeOrmModule } from "@nestjs/typeorm";
+import { validateEnv } from "./config/env.validation";
+import { dataSourceOptions } from "./database/data-source";
 import { HealthModule } from "./health/health.module";
+// podokit:imports
 
 @Module({
-  imports: [HealthModule],
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true, validate: validateEnv }),
+    TypeOrmModule.forRoot(dataSourceOptions),
+    HealthModule,
+    // podokit:module-imports
+  ],
 })
 export class AppModule {}

package/dist/templates/fullstack-nest-svelte/apps/api/src/config/env.validation.ts

@@ -1,18 +1,23 @@
-// Minimal typed environment validation. Extend as the app grows.
-export interface AppEnv {
-  nodeEnv: string;
-  port: number;
-  corsOrigin: string | undefined;
-}
+import { z } from "zod";
+
+// Schema-validated environment. Fails fast at boot if something is wrong.
+const schema = z.object({
+  NODE_ENV: z.string().default("development"),
+  PORT: z.coerce.number().default(3000),
+  CORS_ORIGIN: z.string().optional(),
+  POSTGRES_HOST: z.string().default("localhost"),
+  POSTGRES_PORT: z.coerce.number().default(5432),
+  POSTGRES_USER: z.string().default("podokit"),
+  POSTGRES_PASSWORD: z.string().default("podokit"),
+  POSTGRES_DB: z.string().default("podokit"),
+});
+
+export type AppEnv = z.infer<typeof schema>;
 
-export function validateEnv(env: NodeJS.ProcessEnv = process.env): AppEnv {
-  const port = Number(env.PORT ?? 3000);
-  if (Number.isNaN(port)) {
-    throw new Error(`Invalid PORT: ${env.PORT}`);
+export function validateEnv(config: Record<string, unknown>): AppEnv {
+  const parsed = schema.safeParse(config);
+  if (!parsed.success) {
+    throw new Error(`Invalid environment:\n${parsed.error.toString()}`);
   }
-  return {
-    nodeEnv: env.NODE_ENV ?? "development",
-    port,
-    corsOrigin: env.CORS_ORIGIN,
-  };
+  return parsed.data;
 }

package/dist/templates/fullstack-nest-svelte/apps/api/src/database/data-source.ts

@@ -0,0 +1,19 @@
+import "dotenv/config";
+import { join } from "node:path";
+import { DataSource, type DataSourceOptions } from "typeorm";
+
+export const dataSourceOptions: DataSourceOptions = {
+  type: "postgres",
+  host: process.env.POSTGRES_HOST ?? "localhost",
+  port: Number(process.env.POSTGRES_PORT ?? 5432),
+  username: process.env.POSTGRES_USER ?? "podokit",
+  password: process.env.POSTGRES_PASSWORD ?? "podokit",
+  database: process.env.POSTGRES_DB ?? "podokit",
+  // Entities are auto-discovered by file name (*.entity.ts / .js).
+  entities: [join(__dirname, "..", "**", "*.entity{.ts,.js}")],
+  migrations: [join(__dirname, "..", "migrations", "*{.ts,.js}")],
+  synchronize: false,
+};
+
+// Used by the TypeORM CLI for migrations (see package.json scripts).
+export default new DataSource(dataSourceOptions);

package/dist/templates/fullstack-nest-svelte/apps/api/src/health/health.controller.ts

@@ -1,13 +1,23 @@
 import { Controller, Get } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { DataSource } from "typeorm";
 
 @Controller("health")
 export class HealthController {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
   @Get()
   liveness(): { status: string; uptime: number; timestamp: string } {
-    return {
-      status: "ok",
-      uptime: process.uptime(),
-      timestamp: new Date().toISOString(),
-    };
+    return { status: "ok", uptime: process.uptime(), timestamp: new Date().toISOString() };
+  }
+
+  @Get("ready")
+  async readiness(): Promise<{ status: string; db: string }> {
+    try {
+      await this.dataSource.query("SELECT 1");
+      return { status: "ready", db: "up" };
+    } catch {
+      return { status: "degraded", db: "down" };
+    }
   }
 }

package/dist/templates/fullstack-nest-svelte/apps/api/src/main.ts

@@ -1,5 +1,6 @@
 import { NestFactory } from "@nestjs/core";
 import { ValidationPipe } from "@nestjs/common";
+import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
 import { AppModule } from "./app.module";
 import { AllExceptionsFilter } from "./common/all-exceptions.filter";
 
@@ -14,6 +15,13 @@ async function bootstrap(): Promise<void> {
   const corsOrigin = process.env.CORS_ORIGIN?.split(",").map((o) => o.trim());
   app.enableCors({ origin: corsOrigin ?? true, credentials: true });
 
+  const config = new DocumentBuilder()
+    .setTitle("{{projectName}} API")
+    .setDescription("Generated with PodoKit")
+    .setVersion("0.0.0")
+    .build();
+  SwaggerModule.setup("api-docs", app, SwaggerModule.createDocument(app, config));
+
   const port = Number(process.env.PORT ?? 3000);
   await app.listen(port);
 }

package/dist/templates/fullstack-nest-svelte/apps/web/components.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://shadcn-svelte.com/schema.json",
-  "style": "new-york",
+  "style": "nova",
   "tailwind": {
     "css": "src/app.css",
     "baseColor": "zinc"

package/dist/templates/fullstack-nest-svelte/apps/web/package.json

@@ -11,7 +11,13 @@
     "test": "echo \"add Playwright tests here\" && exit 0"
   },
   "dependencies": {
-    "mode-watcher": "^0.5.0"
+    "mode-watcher": "^0.5.0",
+    "bits-ui": "^2.18.1",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^3.6.0",
+    "tailwind-variants": "^3.2.2",
+    "@lucide/svelte": "^1.23.0",
+    "@internationalized/date": "^3.12.2"
   },
   "devDependencies": {
     "@sveltejs/adapter-node": "^5.2.0",
@@ -23,6 +29,7 @@
     "tailwindcss": "^4.0.0",
     "typesafe-i18n": "^5.26.2",
     "typescript": "^5.6.3",
-    "vite": "^5.4.0"
+    "vite": "^5.4.0",
+    "tw-animate-css": "^1.4.0"
   }
 }