@podosoft/podokit 0.17.4 → 1.0.2

package/dist/templates.js

@@ -6,16 +6,16 @@ exports.templateListText = templateListText;
 // Order matters: the first entry is the default and prompts list them in order.
 exports.TEMPLATES = [
     {
-        name: "fullstack-nest-svelte",
-        description: "NestJS + SvelteKit starter — TypeORM wired, Swagger, no domain code (clean)",
+        name: "fullstack",
+        description: "Bun + Elysia + SvelteKit starter — Bun.SQL, OpenAPI, no domain code",
     },
     {
         name: "todo",
-        description: "Fullstack starter plus a Todo CRUD example (DB entity, migration, UI)",
+        description: "Fullstack starter plus a Bun.SQL Todo CRUD example and UI",
     },
     {
         name: "base",
-        description: "Minimal npm workspace to build up from scratch",
+        description: "Minimal Bun workspace to build up from scratch",
     },
 ];
 exports.DEFAULT_TEMPLATE = exports.TEMPLATES[0].name;

package/dist/toolchain.d.ts

@@ -0,0 +1,14 @@
+import type { TemplateVars } from "@podosoft/podokit-template-engine";
+export declare const BUN_VERSION = "1.4.0";
+export type Runtime = "bun";
+export type PackageManager = "bun";
+export interface Toolchain {
+    runtime: Runtime;
+    runtimeVersion: string;
+    packageManager: PackageManager;
+}
+export declare function resolveToolchain(runtime?: string, packageManager?: string): Toolchain;
+export declare function toolchainTemplateVars(toolchain: Toolchain): TemplateVars;
+export declare function isRuntime(value: string): value is Runtime;
+export declare function toolchainMigrationCommand(_toolchain: Toolchain): string[];
+export declare function toolchainWorkerCommand(_toolchain: Toolchain): string[];

package/dist/toolchain.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUN_VERSION = void 0;
+exports.resolveToolchain = resolveToolchain;
+exports.toolchainTemplateVars = toolchainTemplateVars;
+exports.isRuntime = isRuntime;
+exports.toolchainMigrationCommand = toolchainMigrationCommand;
+exports.toolchainWorkerCommand = toolchainWorkerCommand;
+exports.BUN_VERSION = "1.4.0";
+function resolveToolchain(runtime = "bun", packageManager) {
+    if (runtime !== "bun") {
+        throw new Error("PodoKit v1 generates Bun-only applications. Existing Node projects must remain on @podosoft/podokit@0.17.4.");
+    }
+    if (packageManager && packageManager !== "bun") {
+        throw new Error("PodoKit v1 uses Bun as its package manager; remove --pm.");
+    }
+    return { runtime: "bun", runtimeVersion: exports.BUN_VERSION, packageManager: "bun" };
+}
+function toolchainTemplateVars(toolchain) {
+    return {
+        runtime: toolchain.runtime,
+        runtimeVersion: toolchain.runtimeVersion,
+        runtimeCommand: "bun",
+        runtimeBinPrefix: "bunx --bun ",
+        packageManager: "bun",
+        packageExecutor: "bunx --bun",
+        packageExecutorCommand: "bunx",
+        packageExecutorArgs: '"--bun", ',
+        ciSetup: "- uses: oven-sh/setup-bun@v2\n        with:\n          bun-version: 1.4.0",
+        ciInstallCommand: "bun ci",
+        ciLintCommand: "bun run lint",
+        ciTestCommand: "bun run test",
+        profileRuntime: "bun",
+        rootRun: "bun run",
+        apiRun: "bun run --cwd apps/api",
+        apiWorkspaceArg: "",
+        webRun: "bun run --cwd apps/web",
+    };
+}
+function isRuntime(value) {
+    return value === "bun";
+}
+function toolchainMigrationCommand(_toolchain) {
+    return ["bun", "run", "migrate:all"];
+}
+function toolchainWorkerCommand(_toolchain) {
+    return ["bun", "dist/main-worker.js"];
+}

package/dist/update.d.ts

@@ -1,4 +1,6 @@
+import { type TemplateVars } from "@podosoft/podokit-template-engine";
 import { type Tier } from "./lockfile";
+import type { Toolchain } from "./toolchain";
 /**
  * `podo update` planner. For now it produces a dry-run plan only: it assembles
  * the new-version tree from the installed CLI's templates and compares it to the
@@ -26,12 +28,27 @@ export interface UpdatePlan {
  * Build the update plan. `templatesDir` is the installed CLI's template set (the
  * new version); the lock records what PodoKit last wrote (to detect user edits).
  */
-export declare function planUpdate(projectRoot: string, templatesDir: string): UpdatePlan;
+export interface PlanOptions {
+    /** Replay variables for a toolchain conversion instead of the current answers. */
+    targetAnswers?: TemplateVars;
+    /** Treat normally owned runtime scaffolding as managed for this operation. */
+    forceManagedPaths?: string[];
+    /** Restrict planning to selected paths, used by focused conversions. */
+    onlyPaths?: string[];
+}
+export declare function planUpdate(projectRoot: string, templatesDir: string, options?: PlanOptions): UpdatePlan;
 export interface ApplyOptions {
     /** Templates for the version the project is currently on, for 3-way merges. */
     oldTemplatesDir?: string;
     /** Preinstalled previous external modules. Primarily useful for offline updates. */
     oldExternalModulesRoot?: string;
+    /** Replay variables and manifest value used by a runtime conversion. */
+    targetAnswers?: TemplateVars;
+    targetToolchain?: Toolchain;
+    forceManagedPaths?: string[];
+    onlyPaths?: string[];
+    /** Refuse to write anything when a 3-way merge would leave conflict markers. */
+    abortOnConflict?: boolean;
 }
 export interface ApplyResult {
     written: string[];

package/dist/update.js

@@ -97,11 +97,7 @@ function targetOwnedGlobs(projectRoot, templatesDir, modules, current) {
     }
     return [...owned];
 }
-/**
- * Build the update plan. `templatesDir` is the installed CLI's template set (the
- * new version); the lock records what PodoKit last wrote (to detect user edits).
- */
-function planUpdate(projectRoot, templatesDir) {
+function planUpdate(projectRoot, templatesDir, options = {}) {
     const manifest = (0, lockfile_1.readManifest)(projectRoot);
     const lock = (0, lockfile_1.readFilesLock)(projectRoot);
     if (!manifest || !lock)
@@ -110,7 +106,7 @@ function planUpdate(projectRoot, templatesDir) {
     const newTree = (0, assemble_1.assembleProject)({
         templatesDir,
         template: manifest.template,
-        answers: manifest.answers,
+        answers: options.targetAnswers ?? (0, lockfile_1.manifestTemplateVars)(manifest),
         modules,
         projectRoot,
     });
@@ -139,6 +135,8 @@ function planUpdate(projectRoot, templatesDir) {
     for (const path of [...paths].sort()) {
         if (movedSources.has(path) || movedTargets.has(path))
             continue;
+        if (options.onlyPaths && !options.onlyPaths.some((glob) => (0, lockfile_1.matchGlob)(path, glob)))
+            continue;
         const locked = lock.files[path];
         const newText = treeText(newTree, path);
         const disk = diskContent(projectRoot, path);
@@ -146,10 +144,15 @@ function planUpdate(projectRoot, templatesDir) {
         // particular, an exact path recorded by `podo eject` must keep winning over
         // a module's managed override, while managed overrides may still reclaim a
         // path covered only by a broad owned glob.
+        const forceManaged = options.forceManagedPaths?.some((glob) => (0, lockfile_1.matchGlob)(path, glob)) ?? false;
         const controlledByTarget = managedOverrides.some((glob) => (0, lockfile_1.matchGlob)(path, glob)) ||
             ownedGlobs.some((glob) => (0, lockfile_1.matchGlob)(path, glob));
         const classified = (0, lockfile_1.classifyTier)(path, newText ?? disk ?? "", ownedGlobs, managedOverrides);
-        const tier = controlledByTarget ? classified : locked?.tier ?? classified;
+        const tier = forceManaged
+            ? "managed"
+            : controlledByTarget
+                ? classified
+                : locked?.tier ?? classified;
         if (tier === "owned") {
             // A file introduced by a newer template or module has no previous lock
             // entry. Seed it once when the application has not already claimed that
@@ -264,9 +267,17 @@ function writeFile(projectRoot, path, content) {
  * Files that are neither in the assembled tree nor explicitly owned stay out of
  * the lock instead of being accidentally adopted as managed files.
  */
-function updatedFilesLock(projectRoot, newTree, previous, ownedGlobs, managedOverrides) {
+function updatedFilesLock(projectRoot, newTree, previous, ownedGlobs, managedOverrides, onlyPaths) {
     const next = (0, lockfile_1.computeFilesLock)(projectRoot, ownedGlobs, managedOverrides);
     for (const [path, entry] of Object.entries(next.files)) {
+        if (onlyPaths && !onlyPaths.some((glob) => (0, lockfile_1.matchGlob)(path, glob))) {
+            const previousEntry = previous.files[path];
+            if (previousEntry)
+                next.files[path] = previousEntry;
+            else
+                delete next.files[path];
+            continue;
+        }
         const newText = treeText(newTree, path);
         if (newText !== null) {
             if (entry.tier !== "owned") {
@@ -317,12 +328,16 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
     const previousLock = (0, lockfile_1.readFilesLock)(projectRoot);
     if (!manifest || !previousLock)
         throw new inspect_1.NotAProjectError();
-    const plan = planUpdate(projectRoot, templatesDir);
+    const plan = planUpdate(projectRoot, templatesDir, {
+        targetAnswers: options.targetAnswers,
+        forceManagedPaths: options.forceManagedPaths,
+        onlyPaths: options.onlyPaths,
+    });
     const modules = targetModules(projectRoot, templatesDir, manifest.modules);
     const newTree = (0, assemble_1.assembleProject)({
         templatesDir,
         template: manifest.template,
-        answers: manifest.answers,
+        answers: options.targetAnswers ?? (0, lockfile_1.manifestTemplateVars)(manifest),
         modules,
         projectRoot,
     });
@@ -349,7 +364,7 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
             oldTree = (0, assemble_1.assembleProject)({
                 templatesDir: options.oldTemplatesDir,
                 template: manifest.template,
-                answers: manifest.answers,
+                answers: (0, lockfile_1.manifestTemplateVars)(manifest),
                 modules: manifest.modules,
                 projectRoot: previousModules.root,
             });
@@ -359,6 +374,27 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
                 (0, node_fs_1.rmSync)(previousModules.root, { recursive: true, force: true });
         }
     }
+    if (options.abortOnConflict) {
+        const unresolved = [];
+        for (const change of plan.changes) {
+            if (change.action !== "conflict")
+                continue;
+            const next = treeText(newTree, change.path);
+            const base = oldTree ? treeText(oldTree, change.path) : null;
+            const current = diskContent(projectRoot, change.path)?.toString("utf8") ?? null;
+            if (next === null || base === null || current === null) {
+                unresolved.push(change.path);
+                continue;
+            }
+            if ((0, podokit_template_engine_1.threeWayMerge)(base, current, next).conflicts > 0)
+                unresolved.push(change.path);
+        }
+        if (unresolved.length) {
+            throw new Error(`Runtime conversion would conflict with local edits:\n${unresolved
+                .map((path) => `  - ${path}`)
+                .join("\n")}`);
+        }
+    }
     const result = {
         written: [],
         moved: (0, module_migrations_1.applyModuleMigrations)(projectRoot, migrationPlan),
@@ -395,7 +431,7 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
     // Keep the assembled target as the managed baseline. A merged working file
     // intentionally remains drifted so a future update performs another 3-way
     // merge instead of treating the user's lines as clean generated output.
-    (0, lockfile_1.writeFilesLock)(projectRoot, updatedFilesLock(projectRoot, newTree, previousLock, migratedOwnedGlobs, migratedManagedOverrides));
+    (0, lockfile_1.writeFilesLock)(projectRoot, updatedFilesLock(projectRoot, newTree, previousLock, migratedOwnedGlobs, migratedManagedOverrides, options.onlyPaths));
     const modulesDir = (0, node_path_1.join)(templatesDir, "modules");
     const appliedMigrations = new Map();
     for (const pending of pendingMigrations) {
@@ -424,6 +460,8 @@ function applyUpdate(projectRoot, templatesDir, options = {}) {
     });
     (0, lockfile_1.writeManifest)(projectRoot, {
         ...manifest,
+        answers: options.targetAnswers ?? (0, lockfile_1.manifestTemplateVars)(manifest),
+        toolchain: options.targetToolchain ?? manifest.toolchain,
         ownedGlobs: migratedOwnedGlobs,
         managedOverrides: migratedManagedOverrides,
         modules: refreshedModules,

package/dist/websocket-paths.d.ts

@@ -0,0 +1 @@
+export declare function parseExactWebSocketPaths(value: unknown, field: string): string[];

package/dist/websocket-paths.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExactWebSocketPaths = parseExactWebSocketPaths;
+const MAX_PATHS = 32;
+const MAX_PATH_LENGTH = 2_048;
+const SAFE_PATH = /^\/[A-Za-z0-9._~!$&'()+,;=:@/-]*$/;
+function parseExactWebSocketPaths(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Configuration field "${field}" must be an array of exact URL paths.`);
+    }
+    if (value.length > MAX_PATHS) {
+        throw new Error(`Configuration field "${field}" must contain at most ${MAX_PATHS} paths.`);
+    }
+    const paths = [];
+    const seen = new Set();
+    for (const path of value) {
+        if (typeof path !== "string" ||
+            path === "/" ||
+            path.length > MAX_PATH_LENGTH ||
+            !SAFE_PATH.test(path) ||
+            path.includes("//") ||
+            path.split("/").some((segment) => segment === "." || segment === "..")) {
+            throw new Error(`Configuration field "${field}" must contain only static absolute paths such as "/events/ws". Root, patterns, queries, fragments, encoded separators, and traversal segments are not allowed.`);
+        }
+        if (seen.has(path)) {
+            throw new Error(`Configuration field "${field}" contains duplicate path "${path}".`);
+        }
+        seen.add(path);
+        paths.push(path);
+    }
+    return paths;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@podosoft/podokit",
-  "version": "0.17.4",
-  "description": "An opinionated but extensible starter toolkit and CLI for full-stack TypeScript apps with NestJS, SvelteKit, TailwindCSS, shadcn-svelte, Docker, and k3s.",
+  "version": "1.0.2",
+  "description": "An opinionated Bun and Elysia full-stack TypeScript starter toolkit and CLI with SvelteKit, TailwindCSS, shadcn-svelte, Docker, and k3s.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -9,7 +9,8 @@
     "directory": "packages/cli"
   },
   "keywords": [
-    "nestjs",
+    "elysia",
+    "bun",
     "sveltekit",
     "starter",
     "cli",
@@ -39,7 +40,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && node scripts/copy-templates.mjs",
+    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.json && node scripts/copy-templates.mjs",
     "lint": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run"
   },

package/dist/templates/fullstack-nest-svelte/Dockerfile.dev

@@ -1,58 +0,0 @@
-# Development image for the PodoKit monorepo (web + api).
-# Dependencies and source are baked in; `docker compose watch` syncs your
-# edits into the running container so the native file watchers fire.
-
-# Every workspace manifest, collected rather than listed.
-#
-# Listing them by hand only works for the workspaces this template starts with. A
-# project that adds `packages/*` then has workspace manifests that never reach the
-# image, so npm does not know those names are local and goes looking for them on the
-# public registry — `npm error 404 '@scope/thing' is not in this registry`, from an
-# install that succeeds on the developer's own machine. The production images
-# collect manifests for exactly this reason; this one was the exception until a
-# generated project with shared packages could not start its dev stack at all.
-FROM node:22-bookworm-slim AS manifests
-WORKDIR /src
-COPY . .
-RUN mkdir -p /app \
-    && cp package.json /app/ \
-    && find . -name package.json -not -path "*/node_modules/*" \
-         -exec sh -c 'mkdir -p "/app/$(dirname "$1")" && cp "$1" "/app/$1"' _ {} \;
-
-FROM node:22-bookworm-slim
-
-# git for the toolchain (editors, AI agents); build tools for native modules.
-RUN apt-get update \
-  && apt-get install -y --no-install-recommends git python3 make g++ ca-certificates \
-  && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-# Install workspace dependencies (cached unless a package.json changes).
-# NB: the host package-lock.json is intentionally NOT copied — a lockfile
-# generated on macOS/Windows prunes platform-specific optional deps and can drop
-# packages (e.g. @swc/cli) on linux. Resolving fresh in-container avoids that.
-COPY --from=manifests /app ./
-ARG PODOKIT_NPM_REGISTRY=""
-RUN if [ -n "$PODOKIT_NPM_REGISTRY" ]; then npm config set registry "$PODOKIT_NPM_REGISTRY"; fi \
-  && npm install
-
-# Baked source (kept in sync during development by `docker compose watch`).
-COPY . .
-
-# Workspace packages compile before the apps that import them. Apps import them by
-# their published entry point (`dist/index.js`), so without this the API starts and
-# dies on MODULE_NOT_FOUND for a package whose symlink is right there — the link
-# resolves, the built file behind it does not exist. `--if-present` keeps a project
-# with no packages, or one whose packages need no build, working unchanged.
-#
-# `docker compose watch` syncs app source only, so a change under packages/* needs
-# this image rebuilt rather than a container restart.
-RUN if [ -d packages ]; then \
-      for manifest in packages/*/package.json; do \
-        [ -e "$manifest" ] || continue; \
-        npm run build --if-present --workspace "$(dirname "$manifest")"; \
-      done; \
-    fi
-
-EXPOSE 5001 5002

package/dist/templates/fullstack-nest-svelte/apps/api/Dockerfile

@@ -1,88 +0,0 @@
-# syntax=docker/dockerfile:1
-
-# The npm that reads package-lock.json must be the major that wrote it. node:22
-# bundles npm 10, and a lockfile written by npm 11 records platform-specific
-# packages as extraneous with no `optional` flag; npm 10 rejects those with
-# EBADPLATFORM instead of skipping them, so `npm ci` fails inside the image while
-# `npm install` on the developer's machine is fine. Keep this in step with the npm
-# the project is developed with.
-ARG NPM_VERSION=11.17.0
-
-# Every workspace manifest, and nothing else.
-#
-# Listing them by hand only works for the workspaces this template starts with: npm
-# does NOT fail when a workspace's package.json is absent, it silently installs a
-# tree without that package's dependencies. A project that adds packages/* then
-# builds against different versions than it resolves locally, and only inside the
-# image. Collecting them keeps `npm ci` correct whatever the workspace layout is,
-# and the stages below still cache on the manifests' content.
-FROM node:22-alpine AS manifests
-WORKDIR /src
-COPY . .
-RUN mkdir -p /app \
-    && cp package.json package-lock.json /app/ \
-    && find . -name package.json -not -path "*/node_modules/*" \
-         -exec sh -c 'mkdir -p "/app/$(dirname "$1")" && cp "$1" "/app/$1"' _ {} \;
-
-FROM node:22-alpine AS deps
-WORKDIR /app
-COPY --from=manifests /app ./
-ARG NPM_VERSION
-RUN npm i -g "npm@${NPM_VERSION}"
-RUN npm ci --no-audit --no-fund
-
-# Production dependencies only, resolved from the same lockfile. The runtime stage
-# copies node_modules from here and never from deps or build, so the shipped image
-# does not carry the TypeScript compiler, Vite, or the test tooling.
-FROM node:22-alpine AS prod-deps
-WORKDIR /app
-COPY --from=manifests /app ./
-ARG NPM_VERSION
-RUN npm i -g "npm@${NPM_VERSION}"
-# The runtime tree for this image only.
-#
-# Scoping to the one workspace matters: --omit=dev at the root still installs the
-# union of every workspace's production dependencies, so the API image carried Vite
-# and the web image carried Nest. Measured on a generated project, this is 198
-# packages instead of 283. TypeScript stays either way -- typeorm depends on ts-node,
-# which depends on it, so it is a production dependency and not bloat.
-RUN npm ci --omit=dev --no-audit --no-fund --workspace=apps/api --include-workspace-root
-
-FROM node:22-alpine AS build
-WORKDIR /app
-# Everything npm ci produced, not just the root node_modules: npm nests any
-# dependency it cannot hoist, and copying only the root directory leaves a workspace
-# package compiling against the wrong version of it.
-COPY --from=deps /app ./
-COPY . .
-# Local workspace packages compile before the app that imports them. Apps import
-# them by their published entry points and .dockerignore excludes dist, so nothing
-# here has compiled output until it is compiled here.
-RUN if [ -d packages ]; then \
-      for manifest in packages/*/package.json; do \
-        [ -e "$manifest" ] || continue; \
-        npm run build --if-present --workspace "$(dirname "$manifest")"; \
-      done; \
-    fi
-RUN npm run build --workspace=apps/api
-# The runtime needs the real workspace package directories, not just the symlinks
-# npm leaves in node_modules pointing at them. Without this the image boots and
-# dies on "Cannot find module <package>" -- a dangling link, at runtime only.
-# mkdir keeps the COPY valid for a project that has no packages/ at all.
-RUN mkdir -p /app/packages
-
-FROM node:22-alpine AS runtime
-WORKDIR /app
-ENV NODE_ENV=production
-RUN addgroup -S -g 101 app && adduser -S -D -H -u 100 -G app app
-COPY --from=prod-deps /app/node_modules ./node_modules
-COPY --from=manifests /app/apps/api ./apps/api
-COPY --from=build /app/packages ./packages
-COPY --from=build /app/apps/api/dist ./apps/api/dist
-COPY --from=build /app/apps/api/scripts ./apps/api/scripts
-WORKDIR /app/apps/api
-USER 100:101
-EXPOSE 3000
-HEALTHCHECK --interval=10s --timeout=5s --start-period=30s --retries=6 \
-  CMD node -e "fetch('http://127.0.0.1:3000/health/ready').then((r) => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
-CMD ["node", "dist/main"]

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

@@ -1,5 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/nest-cli",
-  "collection": "@nestjs/schematics",
-  "sourceRoot": "src"
-}

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

@@ -1,66 +0,0 @@
-{
-  "name": "{{projectName}}-api",
-  "version": "0.0.0",
-  "private": true,
-  "scripts": {
-    "dev": "nest start --watch --builder swc",
-    "build": "nest build",
-    "start": "node dist/main",
-    "lint": "tsc -p tsconfig.json --noEmit",
-    "test": "jest --passWithNoTests",
-    "migrate:all": "node dist/database/migrate",
-    "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": {
-    "@podosoft/podokit-contracts": "^0.4.0",
-    "@nestjs/common": "^11.1.27",
-    "@nestjs/config": "^4.0.4",
-    "@nestjs/core": "^11.1.27",
-    "@nestjs/platform-express": "^11.1.27",
-    "@nestjs/swagger": "^11.4.5",
-    "@nestjs/typeorm": "^11.0.3",
-    "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",
-    "typeorm": "^0.3.20",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@nestjs/cli": "^11.0.23",
-    "@nestjs/testing": "^11.1.27",
-    "@types/express": "^5.0.1",
-    "@types/node": "^20.17.0",
-    "@types/supertest": "^6.0.2",
-    "jest": "^29.7.0",
-    "supertest": "^7.0.0",
-    "ts-jest": "^29.2.5",
-    "ts-node": "^10.9.2",
-    "typescript": "^6.0.3",
-    "@swc/core": "^1.7.0",
-    "@swc/cli": "^0.4.0"
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": "src",
-    "testRegex": ".*\\.spec\\.ts$",
-    "transform": {
-      "^.+\\.ts$": [
-        "ts-jest",
-        {
-          "tsconfig": "tsconfig.json"
-        }
-      ]
-    },
-    "testEnvironment": "node"
-  }
-}

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

@@ -1,21 +0,0 @@
-import type { DynamicModule, Provider, Type } from "@nestjs/common";
-
-// Owned extension slot for the Nest app. This file is yours — PodoKit never
-// writes to it, so `podo update` leaves it alone. Use it to add your own modules
-// or providers, or to override a PodoKit-provided provider without editing
-// managed code. Because these are spread in *after* the module-wired providers,
-// an override here takes precedence.
-//
-// Example — swap the mailer transport for your own implementation:
-//   import { Mailer } from "./mailer/mailer";
-//   import { MyMailer } from "./my-mailer";
-//   export const extensionProviders: Provider[] = [
-//     { provide: Mailer, useClass: MyMailer },
-//   ];
-
-/** Extra modules to import into AppModule (or DynamicModule overrides). */
-export const extensionImports: (Type | DynamicModule)[] = [];
-
-/** Extra or overriding providers for AppModule. Same-token providers listed here
- *  win over the ones PodoKit modules registered. */
-export const extensionProviders: Provider[] = [];

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

@@ -1,26 +0,0 @@
-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";
-import { extensionImports, extensionProviders } from "./app.extensions";
-// podokit:begin:imports
-// podokit:end:imports
-
-@Module({
-  imports: [
-    ConfigModule.forRoot({ isGlobal: true, validate: validateEnv }),
-    TypeOrmModule.forRoot(dataSourceOptions),
-    HealthModule,
-    // podokit:begin:module-imports
-    // podokit:end:module-imports
-    ...extensionImports,
-  ],
-  providers: [
-    // podokit:begin:providers
-    // podokit:end:providers
-    ...extensionProviders,
-  ],
-})
-export class AppModule {}

package/dist/templates/fullstack-nest-svelte/apps/api/src/common/all-exceptions.filter.ts

@@ -1,43 +0,0 @@
-import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from "@nestjs/common";
-import type { Request, Response } from "express";
-import { AppException } from "./app-exception";
-
-interface ErrorBody {
-  success: false;
-  error: {
-    code: string;
-    message: string;
-    statusCode: number;
-    path: string;
-    timestamp: string;
-  };
-}
-
-@Catch()
-export class AllExceptionsFilter implements ExceptionFilter {
-  catch(exception: unknown, host: ArgumentsHost): void {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
-    const request = ctx.getRequest<Request>();
-
-    let statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
-    let code = "INTERNAL_ERROR";
-    let message = "Internal server error";
-
-    if (exception instanceof AppException) {
-      statusCode = exception.statusCode;
-      code = exception.code;
-      message = exception.message;
-    } else if (exception instanceof HttpException) {
-      statusCode = exception.getStatus();
-      code = "HTTP_ERROR";
-      message = exception.message;
-    }
-
-    const body: ErrorBody = {
-      success: false,
-      error: { code, message, statusCode, path: request.url, timestamp: new Date().toISOString() },
-    };
-    response.status(statusCode).json(body);
-  }
-}