@appinit/cli 1.2.0 → 1.3.0

package/dist/templates/backend-express/template/src/__tests__/health.test.ts

@@ -0,0 +1,19 @@
+import request from "supertest";
+
+import { app } from "../app.js";
+
+describe("Health endpoints", () => {
+  it("GET /health should return ok", async () => {
+    const res = await request(app).get("/api/health");
+
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ status: "ok" });
+  });
+
+  it("GET /ready should return ready", async () => {
+    const res = await request(app).get("/api/health/ready");
+
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ ready: true });
+  });
+});

package/dist/templates/backend-express/template/src/__tests__/validation.test.ts

@@ -0,0 +1,36 @@
+import request from "supertest";
+
+import { app } from "../app.js";
+
+describe("Zod validation errors", () => {
+  it("returns 400 with field errors", async () => {
+    const res = await request(app)
+      .post("/api/users")
+      .send({ email: "invalid", password: "123" });
+
+    expect(res.status).toBe(400);
+    expect(res.body).toEqual({
+      error: {
+        code: "VALIDATION_ERROR",
+        message: "Invalid request",
+        fields: {
+          "body.email": ["Invalid email address"],
+          "body.password": [
+            "Too small: expected string to have >=8 characters",
+          ],
+        },
+      },
+    });
+  });
+
+  it("returns 201 with register", async () => {
+    const res = await request(app)
+      .post("/api/users")
+      .send({ email: "abc@gmail.com", password: "12345678" });
+
+    expect(res.status).toBe(201);
+    expect(res.body).toEqual({
+      ok: true,
+    });
+  });
+});

package/dist/templates/backend-express/template/src/app.ts

@@ -0,0 +1,72 @@
+import compression from "compression";
+import cors from "cors";
+import express, { Express } from "express";
+import type { Request, Response } from "express";
+import helmet from "helmet";
+import morgan from "morgan";
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { env } from "./config/env";
+import { notFoundHandler } from "./errors/not-found";
+import { errorHandler } from "./middleware/error-handler";
+import { httpLogger } from "./middleware/http-logger";
+import { healthRouter } from "./routes/health";
+import { userRouter } from "./routes/users";
+
+// Define __dirname for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const app: Express = express();
+
+/**
+ * 1. SECURITY MIDDLEWARE
+ */
+app.use(helmet());
+app.use(cors({ origin: env.corsOrigin }));
+
+/**
+ * 2. PERFORMANCE MIDDLEWARE
+ */
+app.use(compression());
+
+/**
+ * 3. REQUEST PARSING
+ */
+app.use(express.json({ limit: "10kb" }));
+app.use(express.urlencoded({ extended: true, limit: "10kb" }));
+
+/**
+ * 4. LOGGING & STATIC FILES
+ */
+app.use(httpLogger);
+if (process.env.NODE_ENV !== "production") {
+  app.use(morgan("dev"));
+} else {
+  app.use(morgan("combined"));
+}
+
+// Fixed static path for ESM
+app.use(express.static(path.join(__dirname, "../public")));
+
+/**
+ * 5. SETTINGS
+ */
+app.disable("x-powered-by");
+
+// route
+app.get("/", (_req: Request, res: Response) => {
+  res.status(200).json({
+    version: "1.0.0",
+  });
+});
+
+app.use("/api/health", healthRouter);
+app.use("/api/users", userRouter);
+/* 404 */
+app.use(notFoundHandler);
+
+/* error handler (LAST) */
+app.use(errorHandler);
+export { app };

package/dist/templates/backend-express/template/src/config/defaults.ts

@@ -0,0 +1,5 @@
+export const defaults = {
+  port: 3001,
+  logLevel: "info" as const,
+  corsOrigin: "*",
+};

package/dist/templates/backend-express/template/src/config/dev.ts

@@ -0,0 +1,3 @@
+export const developmentConfig = {
+  logLevel: "debug" as const,
+};

package/dist/templates/backend-express/template/src/config/env.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+import { defaults } from "./defaults";
+import { developmentConfig } from "./dev";
+import { productionConfig } from "./prod";
+import { testConfig } from "./test";
+
+/**
+ * Load dotenv ONLY outside production
+ */
+if (process.env.NODE_ENV !== "production") {
+  await import("dotenv/config");
+}
+
+/**
+ * Raw env schema (what the platform provides)
+ */
+const rawEnvSchema = z.object({
+  NODE_ENV: z
+    .enum(["development", "test", "production"])
+    .default("development"),
+  PORT: z.coerce.number().int().positive().optional(),
+  LOG_LEVEL: z
+    .enum(["fatal", "error", "warn", "info", "debug", "trace"])
+    .optional(),
+  CORS_ORIGIN: z.string().optional(),
+});
+
+/**
+ * Validate process.env
+ */
+const parsed = rawEnvSchema.safeParse(process.env);
+
+if (!parsed.success) {
+  console.error("❌ Invalid environment variables");
+  console.error(parsed.error.format());
+  process.exit(1);
+}
+
+const nodeEnv = parsed.data.NODE_ENV;
+
+/**
+ * Select environment config
+ */
+const envConfigMap = {
+  development: developmentConfig,
+  test: testConfig,
+  production: productionConfig,
+} as const;
+
+const envOverrides = envConfigMap[nodeEnv];
+
+/**
+ * Final resolved config (single export)
+ */
+export const env = {
+  nodeEnv,
+
+  port: parsed.data.PORT ?? defaults.port,
+  logLevel: parsed.data.LOG_LEVEL ?? envOverrides.logLevel ?? defaults.logLevel,
+  corsOrigin: parsed.data.CORS_ORIGIN ?? defaults.corsOrigin,
+} as const;

package/dist/templates/backend-express/template/src/config/prod.ts

@@ -0,0 +1,3 @@
+export const productionConfig = {
+  logLevel: "info" as const,
+};

package/dist/templates/backend-express/template/src/config/test.ts

@@ -0,0 +1,3 @@
+export const testConfig = {
+  logLevel: "silent" as const,
+};

package/dist/templates/backend-express/template/src/errors/app-error.ts

@@ -0,0 +1,20 @@
+export class AppError extends Error {
+  public readonly statusCode: number;
+  public readonly code: string;
+  public readonly isOperational: boolean;
+
+  constructor(
+    message: string,
+    options: {
+      statusCode?: number;
+      code?: string;
+      isOperational?: boolean;
+    } = {},
+  ) {
+    super(message);
+
+    this.statusCode = options.statusCode ?? 500;
+    this.code = options.code ?? "INTERNAL_SERVER_ERROR";
+    this.isOperational = options.isOperational ?? true;
+  }
+}

package/dist/templates/backend-express/template/src/errors/not-found.ts

@@ -0,0 +1,16 @@
+import type { NextFunction, Request, Response } from "express";
+
+import { AppError } from "../errors/app-error.js";
+
+export function notFoundHandler(
+  _req: Request,
+  _res: Response,
+  next: NextFunction,
+) {
+  next(
+    new AppError("Route not found", {
+      statusCode: 404,
+      code: "NOT_FOUND",
+    }),
+  );
+}

package/dist/templates/backend-express/template/src/middleware/error-handler.ts

@@ -0,0 +1,73 @@
+import type { NextFunction, Request, Response } from "express";
+import { ZodError } from "zod";
+
+import { env } from "../config/env.js";
+import { AppError } from "../errors/app-error.js";
+import { logger } from "../utils/logger.js";
+
+export function errorHandler(
+  err: unknown,
+  _req: Request,
+  res: Response,
+  _next: NextFunction,
+) {
+  /**
+   * Zod validation errors (400)
+   */
+  if (err instanceof ZodError) {
+    const fieldErrors: Record<string, string[]> = {};
+
+    for (const issue of err.issues) {
+      const field = issue.path.join(".") || "root";
+      fieldErrors[field] ??= [];
+      fieldErrors[field].push(issue.message);
+    }
+
+    logger.warn({ fieldErrors }, "Request validation failed");
+
+    return res.status(400).json({
+      error: {
+        code: "VALIDATION_ERROR",
+        message: "Invalid request",
+        fields: fieldErrors,
+      },
+    });
+  }
+  // Normalize error
+  const error =
+    err instanceof AppError
+      ? err
+      : new AppError("Internal server error", {
+          statusCode: 500,
+          code: "INTERNAL_SERVER_ERROR",
+          isOperational: false,
+        });
+
+  // Log full error (always)
+  logger.error(
+    {
+      err,
+      statusCode: error.statusCode,
+      code: error.code,
+    },
+    "Unhandled application error",
+  );
+
+  // Response (safe for clients)
+  const response: Record<string, unknown> = {
+    error: {
+      code: error.code,
+      message: error.message,
+    },
+  };
+
+  // Dev-only details
+  if (env.nodeEnv !== "production") {
+    response.error = {
+      ...(response.error ?? {}),
+      details: err instanceof Error ? err.stack : err,
+    };
+  }
+
+  res.status(error.statusCode).json(response);
+}

package/dist/templates/backend-express/template/src/middleware/http-logger.ts

@@ -0,0 +1,5 @@
+import pinoHttp from "pino-http";
+
+import { logger } from "../utils/logger.js";
+
+export const httpLogger = pinoHttp({ logger });

package/dist/templates/backend-express/template/src/middleware/validate.ts

@@ -0,0 +1,17 @@
+import type { NextFunction, Request, Response } from "express";
+import type { ZodSchema } from "zod";
+
+export const validate =
+  <T>(schema: ZodSchema<T>) =>
+  (req: Request, _res: Response, next: NextFunction) => {
+    try {
+      schema.parse({
+        body: req.body,
+        query: req.query,
+        params: req.params,
+      });
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };

package/dist/templates/backend-express/template/src/routes/health.ts

@@ -0,0 +1,13 @@
+import { Router } from "express";
+
+export const router = Router();
+
+router.get("/", (_req, res) => {
+  res.status(200).json({ status: "ok" });
+});
+
+router.get("/ready", (_req, res) => {
+  res.status(200).json({ ready: true });
+});
+
+export { router as healthRouter };

package/dist/templates/backend-express/template/src/routes/users.ts

@@ -0,0 +1,12 @@
+import { Router } from "express";
+
+import { validate } from "../middleware/validate";
+import { createUserSchema } from "../schema/create-user.schema";
+
+const router = Router();
+
+router.post("/", validate(createUserSchema), (_req, res) => {
+  res.status(201).json({ ok: true });
+});
+
+export { router as userRouter };

package/dist/templates/backend-express/template/src/schema/create-user.schema.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const createUserSchema = z.object({
+  body: z.object({
+    email: z.email(),
+    password: z.string().min(8),
+  }),
+});

package/dist/templates/backend-express/template/src/server.ts

@@ -0,0 +1,54 @@
+import { app } from "./app";
+import { logger } from "./utils/logger";
+
+// Assuming the Pino logger from before
+
+const PORT = process.env.PORT || 3001;
+
+const server = app.listen(PORT, () => {
+  logger.info(`🚀 Server version 1.0.0 started`);
+  logger.info(`📡 Listening on http://localhost:${PORT}`);
+  logger.info(`🌍 Environment: ${process.env.NODE_ENV || "development"}`);
+});
+
+/**
+ * GRACEFUL SHUTDOWN LOGIC
+ * Ensures the server closes existing connections before exiting.
+ */
+const shutdown = (signal: string) => {
+  logger.info(`${signal} received. Starting graceful shutdown...`);
+
+  server.close(() => {
+    logger.info("⛔ HTTP server closed.");
+
+    // Close database connections here (e.g., prisma.$disconnect() or mongoose.connection.close())
+
+    process.exit(0);
+  });
+
+  // Force close after 10 seconds if graceful shutdown fails
+  setTimeout(() => {
+    logger.error(
+      "Could not close connections in time, forcefully shutting down",
+    );
+    process.exit(1);
+  }, 10000);
+};
+
+// Listen for termination signals
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+
+/**
+ * UNHANDLED REJECTION/EXCEPTION CATCHING
+ * Prevents the process from crashing silently.
+ */
+process.on("unhandledRejection", (reason, promise) => {
+  logger.fatal({ promise, reason }, "Unhandled Rejection at Promise");
+  throw reason; // Let uncaughtException handle it
+});
+
+process.on("uncaughtException", (error) => {
+  logger.fatal(error, "Uncaught Exception thrown");
+  process.exit(1);
+});

package/dist/templates/backend-express/template/src/utils/logger.ts

@@ -0,0 +1,21 @@
+import pino from "pino";
+
+import { env } from "../config/env.js";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+export const logger = pino({
+  level: env.logLevel,
+  // Redact sensitive data from logs for security
+  redact: ["req.headers.authorization", "password", "confirmPassword"],
+  transport: isProduction
+    ? undefined // In production, output raw JSON for Datadog/ELK
+    : {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname",
+        },
+      },
+});

package/dist/templates/backend-express/template/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    /* Language & runtime */
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+
+    /* Project structure */
+    "rootDir": "src",
+    "outDir": "dist",
+
+    /* Interop & correctness */
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+
+    /* Safety */
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "noEmitOnError": true,
+
+    /* DX & production debugging */
+    "sourceMap": true,
+
+    /* Node environment */
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "__tests__"]
+}

package/dist/templates/backend-express/template/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    globals: true,
+    clearMocks: true,
+    restoreMocks: true,
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html"],
+      exclude: ["dist", "node_modules"],
+    },
+  },
+});

package/dist/templates/backend-express/template.config.ts

@@ -0,0 +1,36 @@
+export const config = {
+  // Canonical template identity
+  id: "backend.backend-express.basic",
+  version: "0.1.0",
+
+  // ATS contract
+  appinitSpec: "1.0",
+  atsVersion: "1.0",
+
+  // Classification
+  category: "backend",
+  language: "ts",
+  // Rendering
+  engine: "none", // liquid | none, default is none
+
+  // Output
+  output: {
+    dir: ".",
+  },
+
+  // Metadata
+  name: "backend-express",
+  description: "Backend template (Express, Fastify, etc.)",
+
+  tags: ["backend", "api", "server"],
+
+  license: "MIT",
+  postInstall: [],
+  author: {
+    name: "AppInit",
+  },
+
+  paths: {
+    template: "./template",
+  },
+};

package/dist/templates/backend-express/variables/defaults.json

@@ -0,0 +1,7 @@
+{
+  "projectName": "my-express-app",
+  "description": "Backend API built with AppInit",
+  "author": "",
+  "licenseType": "MIT",
+  "port": 3001
+}

package/dist/templates/backend-express/variables/defaults.ts

@@ -0,0 +1,4 @@
+export const defaults = {
+  projectName: "my-express-app",
+  port: 3001,
+};

package/dist/templates/backend-express/variables/schema.json

@@ -0,0 +1,22 @@
+{
+  "projectName": {
+    "type": "string",
+    "required": true,
+    "minLength": 1
+  },
+  "description": {
+    "type": "string"
+  },
+  "author": {
+    "type": "string"
+  },
+  "licenseType": {
+    "type": "string",
+    "enum": [
+      "MIT",
+      "Apache-2.0",
+      "ISC",
+      "UNLICENSED"
+    ]
+  }
+}

package/dist/templates/backend-express/variables/schema.ts

@@ -0,0 +1,11 @@
+export const schema = {
+	projectName: {
+		type: "string",
+		required: true,
+		message: "Project name",
+	},
+	port: {
+		type: "number",
+		default: 3001,
+	},
+};

package/dist/templates/backend-express/variables/transform.ts

@@ -0,0 +1,6 @@
+export function transform(vars: any) {
+	return {
+		...vars,
+		safeName: vars.projectName.replace(/\s+/g, "-").toLowerCase(),
+	};
+}

package/dist/templates/backend-fastify/.appinit-generate/project/.appinit/project.json

@@ -0,0 +1,6 @@
+{
+  "name": "project",
+  "createdAt": "2025-12-18T14:47:09.961Z",
+  "cliVersion": "unknown",
+  "ats": "1.0"
+}

package/dist/templates/backend-fastify/.appinit-generate/project/.appinit/template.json

@@ -0,0 +1,6 @@
+{
+  "id": "backend.fastify.basic",
+  "version": "1.0.0",
+  "source": "builtin",
+  "installedAt": "2025-12-18T14:47:09.963Z"
+}

package/dist/templates/backend-fastify/.appinit-generate/project/README.md

@@ -0,0 +1,26 @@
+# ⚛️ backend-fastify
+
+This project was generated using **AppInit 1.0**.
+
+## 🚀 Quick Start
+
+```bash
+pnpm install
+pnpm dev
+```
+
+## 🛠️ Stack Configuration
+
+- **Framework**: React 18+ (Vite)
+- **Engine Used**:
+- **Generated At**:
+
+## 📂 Project Structure
+
+- `src/`: Your React components and logic.
+- `public/`: Static assets (images, icons).
+- `tailwind.config.js`: Styling configuration.
+
+---
+
+_Built with speed using the AppInit Scaffolding Engine._

package/dist/templates/backend-fastify/.appinit-generate/project/nodemon.json

@@ -0,0 +1,8 @@
+{
+  "watch": ["src"],
+  "ext": "ts",
+  "ignore": ["dist", "node_modules"],
+  "exec": "tsx src/server.ts",
+  "signal": "SIGTERM",
+  "delay": "100"
+}