appinit-templates 1.0.0

package/base/typescript/eslint.config.js.ejs

@@ -0,0 +1,29 @@
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    files: ["**/*.ts"],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: "module",
+      parser: tseslint.parser,
+      parserOptions: {
+        project: "./tsconfig.json",
+      },
+    },
+    rules: {
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+        },
+      ],
+      "no-console": "off",
+    },
+  },
+);

package/base/typescript/src/config/db.ts.ejs

@@ -0,0 +1,38 @@
+<%_ if (database === 'mongo') { _%>
+import mongoose from "mongoose";
+
+const connectDb = async (): Promise<void> => {
+  try {
+    if (mongoose.connection.readyState >= 1) return;
+    const conn = await mongoose.connect(process.env.MONGODB_URI);
+    console.log(`MongoDB Connected: ${conn.connection.host}`);
+  } catch (error) {
+    console.error(
+      `MongoDB Connection Error: ${error instanceof Error ? error.message : error}`
+    );
+    process.exit(1);
+  }
+};
+
+export default connectDb;
+<%_ } else if (database === 'postgresql_prisma') { _%>
+import { PrismaClient } from "../../generated/prisma/client";
+
+declare global {
+  var prisma: PrismaClient | undefined;
+}
+
+const prisma = global.prisma ?? new PrismaClient();
+
+if (process.env.NODE_ENV !== "production") {
+  global.prisma = prisma;
+}
+
+const connectDb = async (): Promise<void> => {
+  await prisma.$connect();
+  console.log("PostgreSQL Connected");
+};
+
+export { prisma, connectDb };
+export default prisma;
+<%_ } _%>

package/base/typescript/src/config/env.ts.ejs

@@ -0,0 +1,37 @@
+import dotenv from "dotenv";
+import { z } from "zod";
+
+dotenv.config();
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+  PORT: z.coerce.number().default(3000),
+  <%_ if (database === 'mongo') { _%>
+  MONGODB_URI: z.string().min(1, "MongoDB URI is required"),
+  <%_ } else if (database === 'postgresql_prisma') { _%>
+  DATABASE_URL: z.string().min(1, "Database URL is required"),
+  <%_ } _%>
+  JWT_SECRET: z.string().min(1, "JWT secret is required"),
+  JWT_EXPIRES_IN: z.string().default("7d"),
+});
+
+const parsed = envSchema.safeParse(process.env);
+
+if (!parsed.success) {
+  console.error("Invalid environment variables:", parsed.error.format());
+  process.exit(1);
+}
+
+export const config = {
+  nodeEnv: parsed.data.NODE_ENV,
+  port: parsed.data.PORT,
+  <%_ if (database === 'mongo') { _%>
+  mongoUri: parsed.data.MONGODB_URI,
+  <%_ } else if (database === 'postgresql_prisma') { _%>
+  databaseUrl: parsed.data.DATABASE_URL,
+  <%_ } _%>
+  jwt: {
+    secret: parsed.data.JWT_SECRET,
+    expiresIn: parsed.data.JWT_EXPIRES_IN,
+  },
+};

package/base/typescript/src/controllers/health.controller.ts.ejs

@@ -0,0 +1,50 @@
+import type { Request, Response, NextFunction } from "express";
+<%_ if (database === 'mongo') { _%>
+import mongoose from "mongoose";
+<%_ } else if (database === 'postgresql_prisma') { _%>
+import prisma from "../config/db";
+<%_ } _%>
+
+/**
+ * Health Check Controller
+ * Checks the status of the server and the <%= database %> connection
+ */
+export const getHealth = async (_req: Request, res: Response, next: NextFunction): Promise<void> => {
+  try {
+    const uptime = process.uptime();
+    <%_ if (database === 'none') { _%>
+    const dbStatus: "disconnected" = "disconnected";
+    const isHealthy = true;
+    <%_ } else { _%>
+    let dbStatus: "connected" | "disconnected" | "error" = "disconnected";
+
+    <%_ if (database === 'mongo') { _%>
+    // Check Mongoose connection state (1 = connected)
+    dbStatus = mongoose.connection.readyState === 1 ? "connected" : "disconnected";
+    
+    <%_ } else if (database === 'postgresql_prisma') { _%>
+    try {
+      await prisma.$queryRaw`SELECT 1`;
+      dbStatus = "connected";
+    } catch (error) {
+      dbStatus = "error";
+    }
+    <%_ } _%>
+
+    const isHealthy = dbStatus === "connected";
+    <%_ } _%>
+
+    res.status(isHealthy ? 200 : 503).json({
+      success: true,
+      data: {
+        status: "ok",
+        timestamp: new Date().toISOString(),
+        uptime: `${Math.floor(uptime)}s`,
+        database: dbStatus,
+      },
+    });
+  } catch (error) {
+    // Since we removed asyncHandler, we manually pass the error to the global handler
+    next(error);
+  }
+};

package/base/typescript/src/index.ts.ejs

@@ -0,0 +1,54 @@
+// typescript index file
+import express, { type Request, type Response, type NextFunction } from "express";
+import helmet from "helmet";
+import cors from "cors";
+import routes from "./routes/index";
+import errorHandler from "./middleware/errorHandler";
+import { logger } from "./utils/logger";
+import { config } from "./config/env";
+
+<%_ if (database === 'postgresql_prisma') { _%>
+// Prisma note: in prisma/schema.prisma use:
+// provider = "prisma-client-js"
+// output = "../../generated/prisma"
+<%_ } _%>
+
+const app = express();
+const port = config.port;
+
+app.use(express.json());
+app.use(helmet());
+app.use(cors());
+app.use(express.urlencoded({ extended: true }));
+
+// Call connectDb() from ./config/db to connect to your database.
+
+// logger middleware
+app.use((req: Request, res: Response, next: NextFunction) => {
+  logger.info({
+    ip: req.ip,
+    method: req.method,
+    path: req.path,
+  });
+  next();
+});
+
+app.use("/api", routes);
+
+app.use(errorHandler);
+
+app.listen(port, () => {
+  logger.info(`Server running on port ${port}`);
+  logger.info(`Environment: ${config.nodeEnv}`);
+});
+
+process.on("SIGINT", () => {
+  console.log("SIGINT received, forcefully stopping the server");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.log("SIGTERM received, gracefully stopping the server");
+  process.exit(0);
+});
+
+export default app;

package/base/typescript/src/middleware/errorHandler.ts.ejs

@@ -0,0 +1,20 @@
+import type { NextFunction, Request, Response } from "express";
+import ApiError from "../utils/ApiError";
+
+type ErrorWithStatus = ApiError | (Error & { statusCode?: number });
+
+const errorHandler = (
+  err: ErrorWithStatus,
+  _req: Request,
+  res: Response,
+  _next: NextFunction,
+) => {
+  const statusCode = err.statusCode || 500;
+  const message = err.message || "Internal Server Error";
+
+  res.status(statusCode).json({
+    success: false,
+    message: message,
+  });
+};
+export default errorHandler;

package/base/typescript/src/routes/health.routes.ts.ejs

@@ -0,0 +1 @@
+<%- await include("../../../common/src/routes/health.routes.ejs") %>

package/base/typescript/src/routes/index.ts.ejs

@@ -0,0 +1,7 @@
+<%_ if (database === 'postgresql_prisma') { _%>
+// Prisma note: in prisma/schema.prisma use:
+// provider = "prisma-client-js"
+// output = "../generated/prisma"
+<%_ } _%>
+
+<%- await include("../../../common/src/routes/index.ejs") %>

package/base/typescript/src/utils/ApiError.ts.ejs

@@ -0,0 +1,12 @@
+class ApiError extends Error {
+  statusCode: number;
+  success: boolean;
+
+  constructor(statusCode: number, message: string) {
+    super(message);
+    this.statusCode = statusCode;
+    this.success = false;
+  }
+}
+
+export default ApiError;

package/base/typescript/src/utils/logger.ts.ejs

@@ -0,0 +1 @@
+<%- await include("../../../common/src/utils/logger.ejs") %>

package/base/websockets/socket.io/javascript/index.js.ejs

@@ -0,0 +1,87 @@
+import express from "express";
+import helmet from "helmet";
+import cors from "cors";
+import { createServer } from "http";
+import { Server } from "socket.io";
+import routes from "./src/routes/index.js";
+import errorHandler from "./src/middleware/errorHandler.js";
+import { logger } from "./src/utils/logger.js";
+import { config } from "./src/config/env.js";
+
+<%_ if (database === 'postgresql_prisma') { _%>
+// Prisma note: in prisma/schema.prisma use:
+// provider = "prisma-client-js"
+// output = "../generated/prisma"
+<%_ } _%>
+
+const app = express();
+const port = config.port;
+
+// 1. Create the HTTP Server
+const http_server = createServer(app);
+
+// 2. Initialize Socket.io on the HTTP Server
+const socket_io_server = new Server(http_server, {
+  cors: {
+    origin: "*", 
+  }
+});
+
+// Middleware
+app.use(express.json());
+app.use(helmet());
+app.use(cors());
+app.use(express.urlencoded({ extended: true }));
+
+app.use((req, res, next) => {
+  logger.info({
+    method: req.method,
+    path: req.path,
+    ip: req.ip,
+  });
+  next();
+});
+
+// Routes
+app.use("/api", routes);
+app.use(errorHandler);
+
+// 3. Socket.io Event Handling
+socket_io_server.on("connection", (socket) => {
+  console.log(`Client connected: ${socket.id}`);
+
+  // 'data' is already an object here—no JSON.parse needed
+  socket.on("message", (data) => {
+    if (data.type === "ping") {
+      // No JSON.stringify needed
+      socket.send({ type: "pong" });
+    }
+  });
+
+  socket.on("disconnect", () => {
+    console.log(`Client disconnected: ${socket.id}`);
+  });
+
+  socket.on("error", (err) => {
+    console.error("Socket Error:", err);
+  });
+});
+
+// 4. Start the server using http_server
+http_server.listen(port, () => {
+  logger.info(`Server running on port ${port}`);
+  logger.info(`Environment: ${config.nodeEnv}`);
+});
+
+// Graceful Shutdown
+const shutdown = () => {
+  console.log("Stopping server...");
+  http_server.close(() => {
+    process.exit(0);
+  });
+};
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+export default http_server;

package/base/websockets/socket.io/typescript/index.ts.ejs

@@ -0,0 +1,81 @@
+// typescript index file with a socket.io server
+import express, { type Request, type Response, type NextFunction } from "express";
+import helmet from "helmet";
+import cors from "cors";
+import routes from "./routes/index";
+import errorHandler from "./middleware/errorHandler";
+import { logger } from "./utils/logger";
+import { config } from "./config/env";
+import { createServer } from "http";
+import { Server } from "socket.io";
+
+<%_ if (database === 'postgresql_prisma') { _%>
+// Prisma note: in prisma/schema.prisma use:
+// provider = "prisma-client-js"
+// output = "../generated/prisma"
+<%_ } _%>
+
+const app = express();
+const port = config.port;
+const http_server = createServer(app);
+const socket_io_server = new Server(http_server, {
+  cors: {
+    origin: "*", 
+  }
+});
+
+app.use(express.json());
+app.use(helmet());
+app.use(cors());
+app.use(express.urlencoded({ extended: true }));
+
+// logger middleware
+app.use((req: Request, res: Response, next: NextFunction) => {
+  logger.info({
+    ip: req.ip,
+    method: req.method,
+    path: req.path,
+  });
+  next();
+});
+
+app.use("/api", routes);
+
+app.use(errorHandler);
+
+http_server.listen(port, () => {
+  logger.info(`Server running on port ${port}`);
+  logger.info(`Environment: ${config.nodeEnv}`);
+});
+
+socket_io_server.on("connection", (socket) => {
+  logger.info(`Client connected: ${socket.id}`);
+
+  // Socket.io auto-parses incoming JSON into an object
+  socket.on("message", (data) => {
+    if (data.type === "ping") {
+      // Socket.io auto-stringifies outgoing objects
+      socket.emit("message", { type: "pong" });
+    }
+  });
+
+  socket.on("error", (err) => {
+    logger.error(`Socket error: ${err.message}`);
+  });
+
+  socket.on("disconnect", (reason) => {
+    logger.info(`Client disconnected: ${socket.id} (Reason: ${reason})`);
+  });
+});
+
+process.on("SIGINT", () => {
+  console.log("SIGINT received, forcefully stopping the server");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.log("SIGTERM received, gracefully stopping the server");
+  process.exit(0);
+});
+
+
+export default http_server;

package/base/websockets/ws/javascript/index.js.ejs

@@ -0,0 +1,86 @@
+// javascript index file with WebSocketServer
+import express from "express";
+import helmet from "helmet";
+import cors from "cors";
+import router from "./src/routes/index.js";
+import errorHandler from "./src/middleware/errorHandler.js";
+import { logger } from "./src/utils/logger.js";
+import { config } from "./src/config/env.js";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+
+<%_ if (database === 'postgresql_prisma') { _%>
+// Prisma note: in prisma/schema.prisma use:
+// provider = "prisma-client-js"
+// output = "../generated/prisma"
+<%_ } _%>
+
+const app = express();
+const port = config.port;
+const http_server = createServer(app);
+const wss = new WebSocketServer({ server: http_server });
+
+app.use(express.json());
+app.use(helmet());
+app.use(cors());
+app.use(express.urlencoded({ extended: true }));
+// Call connectDb() from ./src/config/db.js to connect to your database and also update the env vars with database url
+
+// logger middleware
+app.use((req, res, next) => {
+  logger.info({
+    method: req.method,
+    path: req.path,
+    ip: req.ip,
+  });
+  next();
+});
+
+app.use("/api", router);
+
+app.use(errorHandler);
+
+http_server.listen(port, () => {
+  logger.info(`Server running on port ${port}`);
+  logger.info(`Environment: ${config.nodeEnv}`);
+});
+
+process.on("SIGINT", () => {
+  console.log("SIGINT received, forcefully stopping the server");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.log("SIGTERM received, gracefully stopping the server");
+  process.exit(0);
+});
+
+wss.on("connection", (socket) => {
+  socket.on("message", (data) => {
+    const message = data.toString();
+    try {
+      const msg = JSON.parse(message);
+      if (msg.type === "ping") {
+        socket.send(
+          JSON.stringify({
+            type: "Pong",
+          }),
+        );
+        return;
+      }
+    } catch (error) {
+      socket.send(
+        JSON.stringify({
+          type: "error",
+          message:
+            "incorrect format for sending message, Only use Json for messages",
+        }),
+      );
+      socket.close();
+      return;
+    }
+  });
+  socket.on("error", console.error);
+  socket.on("close", () => console.log(`client disconnected`));
+});
+
+export default http_server;

package/base/websockets/ws/typescript/index.ts.ejs

@@ -0,0 +1,88 @@
+// typescript index file with a websocket server
+import express, { type Request, type Response, type NextFunction } from "express";
+import helmet from "helmet";
+import cors from "cors";
+import routes from "./routes/index";
+import errorHandler from "./middleware/errorHandler";
+import { logger } from "./utils/logger";
+import { config } from "./config/env";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+
+<%_ if (database === 'postgresql_prisma') { _%>
+// Prisma note: in prisma/schema.prisma use:
+// provider = "prisma-client-js"
+// output = "../generated/prisma"
+<%_ } _%>
+
+const app = express();
+const port = config.port;
+const http_server = createServer(app);
+const wss = new WebSocketServer({ server: http_server });
+app.use(express.json());
+app.use(helmet());
+app.use(cors());
+app.use(express.urlencoded({ extended: true }));
+
+// logger middleware
+app.use((req: Request, res: Response, next: NextFunction) => {
+  logger.info({
+    ip: req.ip,
+    method: req.method,
+    path: req.path,
+  });
+  next();
+});
+
+app.use("/api", routes);
+
+app.use(errorHandler);
+
+http_server.listen(port, () => {
+  logger.info(`Server running on port ${port}`);
+  logger.info(`Environment: ${config.nodeEnv}`);
+});
+
+wss.on("connection", (socket) => {
+  console.log("Client connected");
+  // Basic Error Handling for the socket
+  socket.on("error", console.error);
+  socket.on("message", (message: string) => {
+    try {
+      const msg = JSON.parse(message);
+      if (msg.type === "ping") {
+        socket.send(
+          JSON.stringify({
+            type: "pong",
+          }),
+        );
+        return;  
+      }
+    } catch (error) {
+      socket.send(
+        JSON.stringify({
+          type: "error",
+          message:
+            "Incorrect format for sending message, Only use Json_Format for sending messages",
+        }),
+      );
+      socket.close();
+      console.log(error);
+    }
+  });
+  socket.on("close", () => {
+    console.log("Client Disconnected");
+  });
+});
+
+process.on("SIGINT", () => {
+  console.log("SIGINT received, forcefully stopping the server");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  console.log("SIGTERM received, gracefully stopping the server");
+  process.exit(0);
+});
+
+
+export default http_server;

package/features/docker/base/javascript/Dockerfile.ejs

@@ -0,0 +1,19 @@
+FROM node:22-alpine AS builder
+WORKDIR /app
+COPY ./package*.json ./
+RUN npm install
+COPY . .
+
+RUN npm prune --omit=dev 
+
+FROM node:22-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+
+COPY --from=builder /app/package*.json ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app ./
+
+EXPOSE 3000
+
+CMD [ "node","./index.js" ]

package/features/docker/base/typescript/Dockerfile.ejs

@@ -0,0 +1,41 @@
+# --- Stage 1: Build Stage ---
+FROM node:22-alpine AS builder
+WORKDIR /app
+
+# 1. Install dependencies first (for better caching)
+COPY package*.json ./
+RUN npm install
+
+# 2. Copy source and tsconfig
+COPY . .
+
+# 3. Build the TypeScript code (assumes 'build' script runs 'tsc')
+RUN npm run build
+
+# 4. Prune devDependencies (removes tsc and @types)
+RUN npm prune --production
+
+
+# --- Stage 2: Production Runner ---
+FROM node:22-alpine AS runner
+WORKDIR /app
+
+# Set production environment
+ENV NODE_ENV=production
+
+# 1. Copy only the production node_modules from builder
+COPY --from=builder /app/node_modules ./node_modules
+
+# 2. Copy the compiled JS files (usually from a 'dist' or 'build' folder)
+COPY --from=builder /app/dist ./dist
+
+# 3. Copy package.json (needed for "type": "module" and start scripts)
+COPY --from=builder /app/package*.json ./
+
+# 4. Security: Run as non-root user
+USER node
+
+EXPOSE 4000
+
+# 5. Run the compiled code
+CMD ["node", "dist/index.js"]

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "appinit-templates",
+  "version": "1.0.0",
+  "type": "module",
+  "files": [
+    "base",
+    "features"
+  ]
+}