lapeh 2.2.9 → 2.3.1

package/api-testing-duapuluh-dua/api-testing-duapuluh/api-testing-enambelas/scripts/init-project.js

@@ -0,0 +1,178 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const readline = require("readline");
+
+const rootDir = path.join(__dirname, "..");
+const envExample = path.join(rootDir, ".env.example");
+const envFile = path.join(rootDir, ".env");
+const prismaBaseFile = path.join(rootDir, "prisma", "base.prisma.template");
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+const ask = (query, defaultVal) => {
+  return new Promise((resolve) => {
+    rl.question(`${query} ${defaultVal ? `[${defaultVal}]` : ""}: `, (answer) => {
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+};
+
+const selectOption = async (query, options) => {
+  console.log(query);
+  options.forEach((opt, idx) => {
+    console.log(`   [${opt.key}] ${opt.label}`);
+  });
+  
+  while (true) {
+    const answer = await ask(">", options[0].key); // Default to first option
+    const selected = options.find(o => o.key.toLowerCase() === answer.toLowerCase());
+    if (selected) return selected;
+    
+    // Check if user entered the full name or label
+    const byLabel = options.find(o => o.label.toLowerCase().includes(answer.toLowerCase()));
+    if (byLabel) return byLabel;
+
+    console.log("Pilihan tidak valid. Silakan coba lagi.");
+  }
+};
+
+(async () => {
+  console.log("🚀 Starting project initialization...");
+
+  try {
+    // --- DATABASE SELECTION ---
+    console.log("\n--- Database Configuration ---");
+    const dbType = await selectOption("Database apa yang akan digunakan?", [
+      { key: "pgsql", label: "PostgreSQL", provider: "postgresql", defaultPort: "5432" },
+      { key: "mysql", label: "MySQL", provider: "mysql", defaultPort: "3306" },
+    ]);
+
+    let dbUrl = "";
+    let dbProvider = dbType.provider;
+
+    const host = await ask("Database Host", "localhost");
+    const port = await ask("Database Port", dbType.defaultPort);
+    const user = await ask("Database User", "root");
+    const password = await ask("Database Password", "");
+    const dbName = await ask("Database Name", "lapeh");
+
+    if (dbType.key === "pgsql") {
+      dbUrl = `postgresql://${user}:${password}@${host}:${port}/${dbName}?schema=public`;
+    } else {
+      dbUrl = `mysql://${user}:${password}@${host}:${port}/${dbName}`;
+    }
+
+    // Close readline as we are done with input
+    rl.close();
+
+    // 1. Setup .env
+    console.log("\n📄 Setting up .env...");
+    let envContent = "";
+    if (fs.existsSync(envExample)) {
+      envContent = fs.readFileSync(envExample, "utf8");
+    } else {
+      // Fallback minimal env if example missing
+      envContent = `PORT=4000\nDATABASE_PROVIDER="postgresql"\nDATABASE_URL=""\nJWT_SECRET="replace_this"\n`;
+    }
+
+    // Replace DATABASE_URL and DATABASE_PROVIDER
+    // Regex to replace existing values or append if missing (simplified)
+    if (envContent.includes("DATABASE_URL=")) {
+      envContent = envContent.replace(/DATABASE_URL=".+"/g, `DATABASE_URL="${dbUrl}"`);
+      envContent = envContent.replace(/DATABASE_URL=.+/g, `DATABASE_URL="${dbUrl}"`); // Handle unquoted
+    } else {
+      envContent += `\nDATABASE_URL="${dbUrl}"`;
+    }
+
+    if (envContent.includes("DATABASE_PROVIDER=")) {
+      envContent = envContent.replace(/DATABASE_PROVIDER=".+"/g, `DATABASE_PROVIDER="${dbProvider}"`);
+      envContent = envContent.replace(/DATABASE_PROVIDER=.+/g, `DATABASE_PROVIDER="${dbProvider}"`);
+    } else {
+      envContent += `\nDATABASE_PROVIDER="${dbProvider}"`;
+    }
+
+    fs.writeFileSync(envFile, envContent);
+    console.log("✅ .env updated with database configuration.");
+
+    // 2. Update prisma/base.prisma.template
+    console.log("📄 Updating prisma/base.prisma.template...");
+    if (fs.existsSync(prismaBaseFile)) {
+      let baseContent = fs.readFileSync(prismaBaseFile, "utf8");
+      // Replace provider in datasource block
+      baseContent = baseContent.replace(
+        /(datasource\s+db\s+\{[\s\S]*?provider\s*=\s*")([^"]+)(")/, 
+        `$1${dbProvider}$3`
+      );
+      fs.writeFileSync(prismaBaseFile, baseContent);
+    } else {
+      console.warn("⚠️ prisma/base.prisma.template not found. Skipping.");
+    }
+
+    // 3. Install dependencies
+    console.log("\n📦 Installing dependencies...");
+    execSync("npm install", { stdio: "inherit", cwd: rootDir });
+
+    // 4. Create .vscode/settings.json
+    console.log("\n🛠️ Configuring VS Code...");
+    const vscodeDir = path.join(rootDir, ".vscode");
+    if (!fs.existsSync(vscodeDir)) {
+      fs.mkdirSync(vscodeDir, { recursive: true });
+    }
+    const settingsFile = path.join(vscodeDir, "settings.json");
+    const settingsContent = {
+      "files.associations": {
+        "*.model": "prisma"
+      }
+    };
+    fs.writeFileSync(settingsFile, JSON.stringify(settingsContent, null, 2));
+    console.log("✅ VS Code configured (.model support added).");
+
+    // 5. Generate JWT Secret
+    console.log("\n🔑 Generating JWT Secret...");
+    try {
+        execSync("node scripts/generate-jwt-secret.js", {
+            stdio: "inherit",
+            cwd: rootDir,
+        });
+    } catch (e) {
+        console.warn("⚠️ Failed to generate JWT secret automatically.");
+    }
+
+    // 5. Setup Database (Migrate)
+    console.log("\n🗄️ Setting up database...");
+    try {
+      execSync("node scripts/compile-schema.js", { stdio: "inherit", cwd: rootDir });
+      console.log("⚙️ Generating Prisma Client...");
+      execSync("npx prisma generate", { stdio: "inherit", cwd: rootDir });
+      
+      console.log("🚀 Running Migration...");
+      execSync("npx prisma migrate dev --name init_setup", { stdio: "inherit", cwd: rootDir });
+    } catch (error) {
+      console.warn(
+        '⚠️ Database migration had an issue. Please check your database connection in .env and run "npm run prisma:migrate" manually.'
+      );
+    }
+
+    // 6. Seed Database
+    console.log("\n🌱 Seeding database...");
+    try {
+      execSync("npm run db:seed", { stdio: "inherit", cwd: rootDir });
+    } catch (error) {
+      console.warn(
+        '⚠️ Database seeding had an issue. You might need to run "npm run db:seed" manually.'
+      );
+    }
+
+    console.log("\n✅ Setup complete! You can now run:");
+    console.log("   npm run dev");
+
+  } catch (error) {
+    console.error("\n❌ Setup failed:", error.message);
+    rl.close();
+    process.exit(1);
+  }
+})();

package/api-testing-duapuluh-dua/api-testing-duapuluh/api-testing-enambelas/scripts/make-controller.js

@@ -0,0 +1,205 @@
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const controllerName = args[0];
+const isResource = args.includes('-r') || args.includes('--resource');
+
+if (!controllerName || controllerName.startsWith('-')) {
+  console.error('❌ Please specify the controller name.');
+  console.error('   Usage: npm run make:controller <ControllerName> [-r]');
+  console.error('   Example: npm run make:controller TestController -r');
+  process.exit(1);
+}
+
+const controllersDir = path.join(__dirname, '..', 'src', 'controllers');
+
+// Ensure controllers directory exists
+if (!fs.existsSync(controllersDir)) {
+  fs.mkdirSync(controllersDir, { recursive: true });
+}
+
+let fileName = controllerName;
+if (!fileName.endsWith('.ts')) {
+  fileName += '.ts';
+}
+
+// Capitalize first letter if convention is needed, but usually users provide PascalCase
+// We will just use what user provided but ensure .ts extension
+const filePath = path.join(controllersDir, fileName);
+
+if (fs.existsSync(filePath)) {
+  console.error(`❌ Controller ${fileName} already exists at ${filePath}`);
+  process.exit(1);
+}
+
+let content = '';
+
+if (isResource) {
+  content = `import { Request, Response } from "express";
+import { prisma } from "../core/database";
+import { sendSuccess, sendError } from "../utils/response";
+import { getPagination, buildPaginationMeta } from "../utils/pagination";
+
+/**
+ * Display a listing of the resource.
+ */
+export async function index(req: Request, res: Response) {
+  const { page, perPage, skip, take } = getPagination(req.query);
+  
+  // TODO: Add search logic
+  const where: any = {};
+
+  // TODO: Replace 'model' with your actual model name
+  /*
+  const [data, total] = await Promise.all([
+    prisma.model.findMany({
+      where,
+      skip,
+      take,
+      orderBy: { created_at: "desc" },
+    }),
+    prisma.model.count({ where }),
+  ]);
+
+  const serialized = data.map((item: any) => ({
+    ...item,
+    id: item.id.toString(),
+  }));
+
+  const meta = buildPaginationMeta(page, perPage, total);
+
+  sendSuccess(res, 200, "Data retrieved successfully", {
+    data: serialized,
+    meta,
+  });
+  */
+  
+  sendSuccess(res, 200, "Index method", { message: "Implement me" });
+}
+
+/**
+ * Display the specified resource.
+ */
+export async function show(req: Request, res: Response) {
+  const { id } = req.params;
+  
+  // TODO: Replace 'model' with your actual model name
+  /*
+  const item = await prisma.model.findUnique({
+    where: { id: BigInt(id) },
+  });
+
+  if (!item) {
+    sendError(res, 404, "Data not found");
+    return;
+  }
+
+  sendSuccess(res, 200, "Data retrieved successfully", {
+    ...item,
+    id: item.id.toString(),
+  });
+  */
+  sendSuccess(res, 200, "Show method", { id, message: "Implement me" });
+}
+
+/**
+ * Store a newly created resource in storage.
+ */
+export async function store(req: Request, res: Response) {
+  // TODO: Add validation
+  // const parsed = createSchema.safeParse(req.body);
+  // if (!parsed.success) { ... }
+
+  // TODO: Replace 'model' with your actual model name
+  /*
+  const item = await prisma.model.create({
+    data: {
+      ...req.body,
+      created_at: new Date(),
+      updated_at: new Date(),
+    },
+  });
+
+  sendSuccess(res, 201, "Data created successfully", {
+    ...item,
+    id: item.id.toString(),
+  });
+  */
+  sendSuccess(res, 201, "Store method", { message: "Implement me" });
+}
+
+/**
+ * Update the specified resource in storage.
+ */
+export async function update(req: Request, res: Response) {
+  const { id } = req.params;
+  
+  // TODO: Add validation
+  // const parsed = updateSchema.safeParse(req.body);
+
+  // TODO: Replace 'model' with your actual model name
+  /*
+  const existing = await prisma.model.findUnique({
+    where: { id: BigInt(id) },
+  });
+
+  if (!existing) {
+    sendError(res, 404, "Data not found");
+    return;
+  }
+
+  const updated = await prisma.model.update({
+    where: { id: BigInt(id) },
+    data: {
+      ...req.body,
+      updated_at: new Date(),
+    },
+  });
+
+  sendSuccess(res, 200, "Data updated successfully", {
+    ...updated,
+    id: updated.id.toString(),
+  });
+  */
+  sendSuccess(res, 200, "Update method", { id, message: "Implement me" });
+}
+
+/**
+ * Remove the specified resource from storage.
+ */
+export async function destroy(req: Request, res: Response) {
+  const { id } = req.params;
+  
+  // TODO: Replace 'model' with your actual model name
+  /*
+  const existing = await prisma.model.findUnique({
+    where: { id: BigInt(id) },
+  });
+
+  if (!existing) {
+    sendError(res, 404, "Data not found");
+    return;
+  }
+
+  await prisma.model.delete({
+    where: { id: BigInt(id) },
+  });
+  */
+
+  sendSuccess(res, 200, "Data deleted successfully", null);
+}
+`;
+} else {
+  content = `import { Request, Response } from "express";
+import { sendSuccess, sendError } from "../utils/response";
+
+export async function index(req: Request, res: Response) {
+  sendSuccess(res, 200, "Hello from ${controllerName}", null);
+}
+`;
+}
+
+fs.writeFileSync(filePath, content);
+
+console.log(`✅ Controller created: src/controllers/${fileName}`);

package/api-testing-duapuluh-dua/api-testing-duapuluh/api-testing-enambelas/scripts/make-model.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const path = require('path');
+
+const modelName = process.argv[2];
+
+if (!modelName) {
+  console.error('❌ Please specify the model name.');
+  console.error('   Usage: npm run make:model <ModelName>');
+  console.error('   Example: npm run make:model Product');
+  process.exit(1);
+}
+
+const PascalCaseName = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+const tableName = modelName.toLowerCase() + 's'; // simple pluralization
+
+const modelsDir = path.join(__dirname, '..', 'src', 'models');
+const modelPath = path.join(modelsDir, `${PascalCaseName}.prisma`);
+
+if (fs.existsSync(modelPath)) {
+  console.error(`❌ Model ${PascalCaseName} already exists at ${modelPath}`);
+  process.exit(1);
+}
+
+// Ensure models directory exists
+if (!fs.existsSync(modelsDir)) {
+  fs.mkdirSync(modelsDir, { recursive: true });
+}
+
+const content = `model ${tableName} {
+  id        BigInt    @id @default(autoincrement())
+  name      String
+  createdAt DateTime? @default(now())
+  updatedAt DateTime? @updatedAt
+}
+`;
+
+fs.writeFileSync(modelPath, content);
+
+console.log(`✅ Model created: src/models/${PascalCaseName}.prisma`);
+console.log(`\nNext steps:`);
+console.log(`1. Edit the model file.`);
+console.log(`2. Run 'npm run prisma:migrate' to update the database.`);

package/api-testing-duapuluh-dua/api-testing-duapuluh/api-testing-enambelas/scripts/make-module.js

@@ -0,0 +1,158 @@
+const fs = require('fs');
+const path = require('path');
+
+const moduleName = process.argv[2];
+
+if (!moduleName) {
+  console.error('❌ Please specify the module name.');
+  console.error('   Usage: npm run make:module <name>');
+  console.error('   Example: npm run make:module product');
+  process.exit(1);
+}
+
+// Convert "product" -> "Product" (PascalCase) for Class names
+const PascalCaseName = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+// Convert "product" -> "product" (camelCase) for variables/files
+const camelCaseName = moduleName.toLowerCase();
+
+const srcDir = path.join(__dirname, '..', 'src');
+
+// 1. Create Controller
+const controllerContent = `import { Request, Response } from 'express';
+import { ${PascalCaseName}Service } from '../services/${camelCaseName}Service';
+import { successResponse, errorResponse } from '../utils/response';
+
+export const ${PascalCaseName}Controller = {
+  async getAll(req: Request, res: Response) {
+    try {
+      const data = await ${PascalCaseName}Service.getAll();
+      return successResponse(res, data, '${PascalCaseName}s retrieved successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async getById(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      const data = await ${PascalCaseName}Service.getById(id);
+      if (!data) return errorResponse(res, new Error('${PascalCaseName} not found'), 404);
+      return successResponse(res, data, '${PascalCaseName} retrieved successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async create(req: Request, res: Response) {
+    try {
+      const data = await ${PascalCaseName}Service.create(req.body);
+      return successResponse(res, data, '${PascalCaseName} created successfully', 201);
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async update(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      const data = await ${PascalCaseName}Service.update(id, req.body);
+      return successResponse(res, data, '${PascalCaseName} updated successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  },
+
+  async delete(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      await ${PascalCaseName}Service.delete(id);
+      return successResponse(res, null, '${PascalCaseName} deleted successfully');
+    } catch (error) {
+      return errorResponse(res, error as Error);
+    }
+  }
+};
+`;
+
+// 2. Create Service
+const serviceContent = `// import prisma from '../prisma'; // Uncomment this line if you use Prisma
+
+export const ${PascalCaseName}Service = {
+  async getAll() {
+    // return prisma.${camelCaseName}.findMany();
+    return [{ id: 1, name: 'Sample ${PascalCaseName}' }]; // Placeholder
+  },
+
+  async getById(id: string) {
+    // return prisma.${camelCaseName}.findUnique({ where: { id } });
+    return { id, name: 'Sample ${PascalCaseName}' }; // Placeholder
+  },
+
+  async create(data: any) {
+    // return prisma.${camelCaseName}.create({ data });
+    return { id: Date.now(), ...data }; // Placeholder
+  },
+
+  async update(id: string, data: any) {
+    // return prisma.${camelCaseName}.update({ where: { id }, data });
+    return { id, ...data }; // Placeholder
+  },
+
+  async delete(id: string) {
+    // return prisma.${camelCaseName}.delete({ where: { id } });
+    return true; // Placeholder
+  }
+};
+`;
+
+// 3. Create Route
+const routeContent = `import { Router } from 'express';
+import { ${PascalCaseName}Controller } from '../controllers/${camelCaseName}Controller';
+import { authenticateToken } from '../middleware/auth';
+
+const router = Router();
+
+router.get('/', authenticateToken, ${PascalCaseName}Controller.getAll);
+router.get('/:id', authenticateToken, ${PascalCaseName}Controller.getById);
+router.post('/', authenticateToken, ${PascalCaseName}Controller.create);
+router.put('/:id', authenticateToken, ${PascalCaseName}Controller.update);
+router.delete('/:id', authenticateToken, ${PascalCaseName}Controller.delete);
+
+export default router;
+`;
+
+const paths = {
+  controller: path.join(srcDir, 'controllers', `${camelCaseName}Controller.ts`),
+  service: path.join(srcDir, 'services', `${camelCaseName}Service.ts`),
+  route: path.join(srcDir, 'routes', `${camelCaseName}.ts`),
+};
+
+// Helper to create directory if not exists
+function ensureDir(filePath) {
+  const dirname = path.dirname(filePath);
+  if (!fs.existsSync(dirname)) {
+    fs.mkdirSync(dirname, { recursive: true });
+  }
+}
+
+try {
+  ensureDir(paths.controller);
+  fs.writeFileSync(paths.controller, controllerContent);
+  console.log(`✅ Created Controller: src/controllers/${camelCaseName}Controller.ts`);
+
+  ensureDir(paths.service);
+  fs.writeFileSync(paths.service, serviceContent);
+  console.log(`✅ Created Service: src/services/${camelCaseName}Service.ts`);
+
+  ensureDir(paths.route);
+  fs.writeFileSync(paths.route, routeContent);
+  console.log(`✅ Created Route: src/routes/${camelCaseName}.ts`);
+
+  console.log('\n⚠️  Don\'t forget to register the new route in src/index.ts or src/server.ts!');
+  console.log(`   import ${camelCaseName}Routes from './routes/${camelCaseName}';`);
+  console.log(`   app.use('/${camelCaseName}s', ${camelCaseName}Routes);`);
+
+} catch (error) {
+  console.error('❌ Error creating module:', error);
+  process.exit(1);
+}