create-jerry 1.0.0 → 2.0.0

package/Templates/db/mysql/ts/db.ts

@@ -0,0 +1,72 @@
+import mysql from 'mysql2/promise';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const pool = mysql.createPool({
+  host: process.env.MYSQL_HOST,
+  user: process.env.MYSQL_USER,
+  password: process.env.MYSQL_PASSWORD,
+  database: process.env.MYSQL_DATABASE
+});
+
+export const connectDB = async (): Promise<void> => {
+  try {
+    await pool.getConnection();
+    console.log('MySQL connected');
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
+  }
+};
+
+interface User {
+  id?: number;
+  name: string;
+  email: string;
+  password: string;
+}
+
+// CRUD
+
+export const getAllUsers = async (): Promise<User[]> => {
+  const [rows] = await pool.query('SELECT * FROM users');
+  return rows as User[];
+};
+
+export const getUserById = async (
+  id: number
+): Promise<User | undefined> => {
+  const [rows] = await pool.query(
+    'SELECT * FROM users WHERE id = ?',
+    [id]
+  );
+  return (rows as User[])[0];
+};
+
+export const createUser = async (
+  data: User
+): Promise<User | undefined> => {
+  const [result]: any = await pool.query(
+    'INSERT INTO users (name, email, password) VALUES (?, ?, ?)',
+    [data.name, data.email, data.password]
+  );
+
+  return getUserById(result.insertId);
+};
+
+export const updateUser = async (
+  id: number,
+  data: Partial<User>
+): Promise<User | undefined> => {
+  await pool.query(
+    'UPDATE users SET name=?, email=?, password=? WHERE id=?',
+    [data.name, data.email, data.password, id]
+  );
+
+  return getUserById(id);
+};
+
+export const deleteUser = async (id: number): Promise<void> => {
+  await pool.query('DELETE FROM users WHERE id=?', [id]);
+};

package/Templates/modules/ai/js/ai.controller.js

@@ -0,0 +1,30 @@
+import { askAI } from './ai.service.js';
+
+export const handleAIChat = async (req, res) => {
+  try {
+    const { prompt } = req.body;
+
+    if (!prompt) {
+      return res.status(400).json({
+        success: false,
+        message: 'Prompt is required'
+      });
+    }
+
+    const response = await askAI(prompt);
+
+    res.status(200).json({
+      success: true,
+      data: response
+    });
+
+  } catch (error) {
+    console.error(error);
+
+    res.status(500).json({
+      success: false,
+      message: 'AI request failed',
+      error: error.message
+    });
+  }
+};

package/Templates/modules/ai/js/ai.provider.js

@@ -0,0 +1,32 @@
+import OpenAI from 'openai';
+
+class AIProvider {
+  constructor() {
+    this.client = null;
+  }
+
+  init() {
+    if (!process.env.OPENAI_API_KEY) {
+      throw new Error('OPENAI_API_KEY is missing in .env');
+    }
+
+    this.client = new OpenAI({
+      apiKey: process.env.OPENAI_API_KEY
+    });
+  }
+
+  async chat(messages) {
+    if (!this.client) {
+      this.init();
+    }
+
+    const response = await this.client.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages
+    });
+
+    return response.choices[0]?.message?.content || '';
+  }
+}
+
+export default new AIProvider();

package/Templates/modules/ai/js/ai.routes.js

@@ -0,0 +1,8 @@
+import express from 'express';
+import { handleAIChat } from './ai.controller.js';
+
+const router = express.Router();
+
+router.post('/chat', handleAIChat);
+
+export default router;

package/Templates/modules/ai/js/ai.service.js

@@ -0,0 +1,16 @@
+import aiProvider from './ai.provider.js';
+
+export const askAI = async (userInput) => {
+  const messages = [
+    {
+      role: 'system',
+      content: 'You are a helpful backend AI assistant.'
+    },
+    {
+      role: 'user',
+      content: userInput
+    }
+  ];
+
+  return await aiProvider.chat(messages);
+};

package/Templates/modules/ai/ts/ai.controller.ts

@@ -0,0 +1,31 @@
+import { Request, Response } from 'express';
+import { askAI } from './ai.service.js';
+
+export const handleAIChat = async (req: Request, res: Response) => {
+  try {
+    const { prompt } = req.body;
+
+    if (!prompt) {
+      return res.status(400).json({
+        success: false,
+        message: 'Prompt is required'
+      });
+    }
+
+    const response = await askAI(prompt);
+
+    res.status(200).json({
+      success: true,
+      data: response
+    });
+
+  } catch (error: any) {
+    console.error(error);
+
+    res.status(500).json({
+      success: false,
+      message: 'AI request failed',
+      error: error.message
+    });
+  }
+};

package/Templates/modules/ai/ts/ai.provider.ts

@@ -0,0 +1,30 @@
+import OpenAI from 'openai';
+
+class AIProvider {
+  private client: OpenAI | null = null;
+
+  private init() {
+    if (!process.env.OPENAI_API_KEY) {
+      throw new Error('OPENAI_API_KEY is missing in .env');
+    }
+
+    this.client = new OpenAI({
+      apiKey: process.env.OPENAI_API_KEY
+    });
+  }
+
+  async chat(messages: OpenAI.Chat.ChatCompletionMessageParam[]) {
+    if (!this.client) {
+      this.init();
+    }
+
+    const response = await this.client!.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages
+    });
+
+    return response.choices[0]?.message?.content || '';
+  }
+}
+
+export default new AIProvider();

package/Templates/modules/ai/ts/ai.routes.ts

@@ -0,0 +1,8 @@
+import express from 'express';
+import { handleAIChat } from './ai.controller.js';
+
+const router = express.Router();
+
+router.post('/chat', handleAIChat);
+
+export default router;

package/Templates/modules/ai/ts/ai.service.ts

@@ -0,0 +1,16 @@
+import aiProvider from './ai.provider.js';
+
+export const askAI = async (userInput: string): Promise<string> => {
+  const messages = [
+    {
+      role: 'system',
+      content: 'You are a helpful backend AI assistant.'
+    },
+    {
+      role: 'user',
+      content: userInput
+    }
+  ];
+
+  return await aiProvider.chat(messages);
+};

package/Templates/modules/user/js/user.controller.js

@@ -0,0 +1,46 @@
+import * as userService from './user.service.js';
+
+export const getUsers = async (req, res) => {
+  try {
+    const users = await userService.getUsers();
+    res.json({ success: true, data: users });
+  } catch (err) {
+    res.status(500).json({ success: false, message: err.message });
+  }
+};
+
+export const getUser = async (req, res) => {
+  try {
+    const user = await userService.getUserById(req.params.id);
+    res.json({ success: true, data: user });
+  } catch (err) {
+    res.status(500).json({ success: false, message: err.message });
+  }
+};
+
+export const createUser = async (req, res) => {
+  try {
+    const user = await userService.createUser(req.body);
+    res.status(201).json({ success: true, data: user });
+  } catch (err) {
+    res.status(500).json({ success: false, message: err.message });
+  }
+};
+
+export const updateUser = async (req, res) => {
+  try {
+    const user = await userService.updateUser(req.params.id, req.body);
+    res.json({ success: true, data: user });
+  } catch (err) {
+    res.status(500).json({ success: false, message: err.message });
+  }
+};
+
+export const deleteUser = async (req, res) => {
+  try {
+    await userService.deleteUser(req.params.id);
+    res.json({ success: true, message: 'User deleted' });
+  } catch (err) {
+    res.status(500).json({ success: false, message: err.message });
+  }
+};

package/Templates/modules/user/js/user.provider.js

@@ -0,0 +1,25 @@
+import * as db from '../../config/db.js';
+
+class UserProvider {
+  async getAll() {
+    return await db.getAllUsers();
+  }
+
+  async getById(id) {
+    return await db.getUserById(id);
+  }
+
+  async create(data) {
+    return await db.createUser(data);
+  }
+
+  async update(id, data) {
+    return await db.updateUser(id, data);
+  }
+
+  async delete(id) {
+    return await db.deleteUser(id);
+  }
+}
+
+export default new UserProvider();

package/Templates/modules/user/js/user.routes.js

@@ -0,0 +1,12 @@
+import express from 'express';
+import * as userController from './user.controller.js';
+
+const router = express.Router();
+
+router.get('/', userController.getUsers);
+router.get('/:id', userController.getUser);
+router.post('/', userController.createUser);
+router.put('/:id', userController.updateUser);
+router.delete('/:id', userController.deleteUser);
+
+export default router;

package/Templates/modules/user/js/user.service.js

@@ -0,0 +1,21 @@
+import userProvider from './user.provider.js';
+
+export const getUsers = async () => {
+  return await userProvider.getAll();
+};
+
+export const getUserById = async (id) => {
+  return await userProvider.getById(id);
+};
+
+export const createUser = async (data) => {
+  return await userProvider.create(data);
+};
+
+export const updateUser = async (id, data) => {
+  return await userProvider.update(id, data);
+};
+
+export const deleteUser = async (id) => {
+  return await userProvider.delete(id);
+};

package/Templates/modules/user/ts/user.controller.ts

@@ -0,0 +1,27 @@
+import { Request, Response } from 'express';
+import * as userService from './user.service.js';
+
+export const getUsers = async (req: Request, res: Response) => {
+  const users = await userService.getUsers();
+  res.json({ success: true, data: users });
+};
+
+export const getUser = async (req: Request, res: Response) => {
+  const user = await userService.getUserById(req.params.id);
+  res.json({ success: true, data: user });
+};
+
+export const createUser = async (req: Request, res: Response) => {
+  const user = await userService.createUser(req.body);
+  res.status(201).json({ success: true, data: user });
+};
+
+export const updateUser = async (req: Request, res: Response) => {
+  const user = await userService.updateUser(req.params.id, req.body);
+  res.json({ success: true, data: user });
+};
+
+export const deleteUser = async (req: Request, res: Response) => {
+  await userService.deleteUser(req.params.id);
+  res.json({ success: true });
+};

package/Templates/modules/user/ts/user.provider.ts

@@ -0,0 +1,25 @@
+import * as db from '../../config/db.js';
+
+class UserProvider {
+  async getAll() {
+    return await db.getAllUsers();
+  }
+
+  async getById(id: string) {
+    return await db.getUserById(id);
+  }
+
+  async create(data: any) {
+    return await db.createUser(data);
+  }
+
+  async update(id: string, data: any) {
+    return await db.updateUser(id, data);
+  }
+
+  async delete(id: string) {
+    return await db.deleteUser(id);
+  }
+}
+
+export default new UserProvider();

package/Templates/modules/user/ts/user.routes.ts

@@ -0,0 +1,12 @@
+import express from 'express';
+import * as userController from './user.controller.js';
+
+const router = express.Router();
+
+router.get('/', userController.getUsers);
+router.get('/:id', userController.getUser);
+router.post('/', userController.createUser);
+router.put('/:id', userController.updateUser);
+router.delete('/:id', userController.deleteUser);
+
+export default router;

package/Templates/modules/user/ts/user.service.ts

@@ -0,0 +1,21 @@
+import userProvider from './user.provider.js';
+
+export const getUsers = async () => {
+  return await userProvider.getAll();
+};
+
+export const getUserById = async (id: string) => {
+  return await userProvider.getById(id);
+};
+
+export const createUser = async (data: any) => {
+  return await userProvider.create(data);
+};
+
+export const updateUser = async (id: string, data: any) => {
+  return await userProvider.update(id, data);
+};
+
+export const deleteUser = async (id: string) => {
+  return await userProvider.delete(id);
+};

package/fileCreator.js

@@ -1,49 +1,158 @@
-import { fileURLToPath } from 'url';
 import path from 'path';
-import * as fs from 'node:fs/promises';
+import * as fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// Stable reference to your Templates folder in scaff/
 const templateDir = path.join(__dirname, 'Templates');
 
-// 🟡 Create empty .env
-export const writeEnvFile = async () => {
-  const envPath = path.join(process.cwd(), 'src', 'config', '.env');
+if (!existsSync(templateDir)) {
+  throw new Error(`Templates folder missing at ${templateDir}`);
+}
+
+// ---------------- HELPERS ----------------
+
+const copyFile = async (src, dest) => {
+  const content = await fs.readFile(src);
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  await fs.writeFile(dest, content);
+};
+
+const copyDir = async (srcDir, destDir) => {
   try {
-    await fs.writeFile(envPath, '', 'utf-8');
-    console.log('✅ .env file created in src/config');
-  } catch (error) {
-    console.error('❌ Failed to create .env file:', error);
+    const entries = await fs.readdir(srcDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const src = path.join(srcDir, entry.name);
+      const dest = path.join(destDir, entry.name);
+
+      if (entry.isDirectory()) {
+        await copyDir(src, dest);
+      } else {
+        await copyFile(src, dest);
+      }
+    }
+  } catch {
+    throw new Error(`Template missing or invalid: ${srcDir}`);
   }
 };
 
-// 🔵 Generate db.js from template
-export const writeDbFiles = async (dbchoice) => {
-  const dbfile = dbchoice === 'MySQL' ? 'db-sql.js' : 'db-mongo.js';
-  const dbTemplatePath = path.join(templateDir, dbfile);
-  const targetPath = path.join(process.cwd(), 'src', 'models', 'db.js');
+// ---------------- CORE ----------------
 
-  try {
-    const content = await fs.readFile(dbTemplatePath, 'utf-8');
-    await fs.writeFile(targetPath, content);
-    console.log('✅ db.js created successfully');
-  } catch (error) {
-    console.error('❌ Failed to create db.js:', error);
+export const writeCoreFiles = async (langchoice) => {
+  const variant = langchoice.includes('Typescript') ? 'ts' : 'js';
+
+  const basePath = path.join(templateDir, 'base', variant);
+
+  // copy base project directly into src
+  await copyDir(
+    basePath,
+    path.join(process.cwd(), 'src')
+  );
+
+  // tsconfig (only TS)
+  if (variant === 'ts') {
+    const tsconfigPath = path.join(basePath, 'tsconfig.json');
+
+    if (existsSync(tsconfigPath)) {
+      await copyFile(
+        tsconfigPath,
+        path.join(process.cwd(), 'tsconfig.json')
+      );
+    }
   }
 };
 
-// 🟢 Generate app.js from express.js
-export const writeServerFiles = async () => {
-  const serverTemplatePath = path.join(templateDir, 'express.js');
-  const targetPath = path.join(process.cwd(), 'app.js');
+// ---------------- USER MODULE ----------------
+
+export const writeUserModule = async (langchoice) => {
+  const variant = langchoice.includes('Typescript') ? 'ts' : 'js';
+
+  const src = path.join(templateDir, 'modules/user', variant);
+  const dest = path.join(process.cwd(), 'src/modules/user');
+
+  await copyDir(src, dest);
+};
+
+// ---------------- AI MODULE ----------------
+
+export const writeAIModule = async (langchoice) => {
+  const variant = langchoice.includes('Typescript') ? 'ts' : 'js';
+
+  const src = path.join(templateDir, 'modules/ai', variant);
+  const dest = path.join(process.cwd(), 'src/modules/ai');
+
+  await copyDir(src, dest);
+};
+
+// ---------------- DB (LEGACY SAFE) ----------------
+
+export const writeDbFiles = async (dbchoice, langchoice) => {
+  const variant = langchoice.includes('Typescript') ? 'ts' : 'js';
+  const db = dbchoice === 'MongoDB' ? 'mongodb' : 'mysql';
+
+  await copyDir(
+    path.join(templateDir, 'db', db, variant),
+    path.join(process.cwd(), 'src/config')
+  );
+};
+
+// ---------------- ENV ----------------
+
+export const writeEnvFile = async () => {
+  const content = `PORT=3000
+
+# MongoDB
+MONGO_URI=
+
+# MySQL
+MYSQL_HOST=
+MYSQL_USER=
+MYSQL_PASSWORD=
+MYSQL_DATABASE=
+
+# AI
+OPENAI_API_KEY=
+`;
+
+  await fs.writeFile(path.join(process.cwd(), '.env'), content);
+};
+
+// ---------------- ROUTE INJECTION ----------------
+
+export const injectRoutes = async (langchoice, injections = []) => {
+  const ext = langchoice.includes('Typescript') ? 'ts' : 'js';
+
+  const filePath = path.join(process.cwd(), `src/routes/index.${ext}`);
 
   try {
-    const content = await fs.readFile(serverTemplatePath, 'utf-8');
-    await fs.writeFile(targetPath, content);
-    console.log('✅ app.js created successfully');
-  } catch (error) {
-    console.error('❌ Failed to create app.js:', error);
+    await fs.stat(filePath);
+  } catch {
+    throw new Error(`Routes file not found: ${filePath}`);
   }
-};
+
+  let content = await fs.readFile(filePath, 'utf-8');
+
+  if (
+    !content.includes('// [IMPORT_ROUTES]') ||
+    !content.includes('// [USE_ROUTES]')
+  ) {
+    throw new Error('Route placeholders missing in base template');
+  }
+
+  for (const inject of injections) {
+    content = content.replace(
+      '// [IMPORT_ROUTES]',
+      `${inject.import}\n// [IMPORT_ROUTES]`
+    );
+
+    content = content.replace(
+      '// [USE_ROUTES]',
+      `${inject.use}\n// [USE_ROUTES]`
+    );
+  }
+
+  await fs.writeFile(filePath, content);
+};

package/folderCreator.js

@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+
+export const createProjectDir = (rawProjectName) => {
+  const projectDir = path.join(process.cwd(), rawProjectName);
+
+  if (fs.existsSync(projectDir)) {
+    throw new Error(`Folder "${rawProjectName}" already exists`);
+  }
+
+  fs.mkdirSync(projectDir);
+  console.log(`📁 Project root created: ${rawProjectName}`);
+
+  process.chdir(projectDir);
+};