kontas-express 1.0.1 → 1.0.3

package/dist/index.js

@@ -0,0 +1,3 @@
+// @bun
+// index.js
+console.log("Kontas Express Framework");

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "kontas-express",
-  "version": "1.0.1",
-  "main": "index.js",
+  "version": "1.0.3",
+  "main": "dist/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "bun build ./index.js --outdir ./dist --target bun",
+    "prepublishOnly": "bun run build"
   },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "kontas",
+    "express",
+    "framework"
+  ],
   "author": "Hens MSN",
   "license": "ISC",
-  "description": "",
+  "description": "Kontas Express Framework",
   "devDependencies": {
     "@types/bun": "latest"
   },

package/index.js

@@ -1 +0,0 @@
-export { default as templates } from './templates/index.js' 

package/jsconfig.json

@@ -1,27 +0,0 @@
-{
-  "compilerOptions": {
-    // Enable latest features
-    "lib": ["ESNext", "DOM"],
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}

package/templates/files/config/mongodb-config.js

@@ -1,45 +0,0 @@
-export default `import { MongoClient } from "mongodb"
-import config from "./mongodb.json"
-
-// Mendapatkan environment yang sedang berjalan (default: development)
-const env = process.env.NODE_ENV || "development"
-const { uri: configUri, name } = config[env as keyof typeof config]
-
-// Menggunakan URI dari environment variable jika tersedia, jika tidak menggunakan dari config
-const uri = process.env.MONGODB_URI || configUri
-
-// Inisialisasi MongoDB Client
-const client = new MongoClient(uri)
-
-/**
- * Membuat koneksi ke MongoDB
- * @throws {Error} Jika koneksi gagal
- */
-export async function connect() {
-    try {
-        await client.connect()
-        // console.log("✅ Berhasil terhubung ke MongoDB")
-    } catch (error) {
-        console.error("❌ Gagal terhubung ke MongoDB:", error)
-        await client.close() // Menutup koneksi jika terjadi kegagalan
-        throw error // Re-throw error untuk handling di level aplikasi
-    }
-}
-
-/**
- * Mendapatkan instance database
- * @returns {Promise<Db>} Instance database MongoDB
- */
-export async function getDb() {
-    return client.db(name)
-}
-
-/**
- * Mendapatkan collection dari database
- * @param {string} collectionName - Nama collection yang ingin diakses
- * @returns {Promise<Collection>} Instance collection MongoDB
- */
-export async function getCollection(collectionName: string) {
-    const db = await getDb()
-    return db.collection(collectionName)
-}` 

package/templates/files/config/mongodb-json.js

@@ -1,14 +0,0 @@
-export default (uri, dbName) => `{
-    "development": {
-        "uri": "${uri}",
-        "name": "${dbName}"
-    },
-    "test": {
-        "uri": "${uri}",
-        "name": "${dbName}_test"
-    },
-    "production": {
-        "uri": "${uri}",
-        "name": "${dbName}_prod"
-    }
-}` 

package/templates/files/error-handler.js

@@ -1,54 +0,0 @@
-export default `import type { Request, Response, NextFunction } from 'express'
-import { z } from 'zod'
-
-export const errorHandler = (
-    err: Error, 
-    req: Request, 
-    res: Response, 
-    next: NextFunction
-): void => {
-    // console.error('🔥 Error:', err)
-
-    // Zod validation errors
-    if (err instanceof z.ZodError) {
-        res.status(422).json({
-            success: false,
-            status: 422,
-            error: err.issues.map(issue => ({
-                field: issue.path.join('.'),
-                message: issue.message
-            }))
-        })
-        return
-    }
-
-    // Known errors
-    if (err instanceof Error) {
-        let status = 400
-        let message = err.message
-
-        if (err.message.includes('not found')) {
-            status = 404
-        } else if (err.message.includes('unauthorized')) {
-            status = 401
-        } else if (err.message.includes('forbidden')) {
-            status = 403
-        } else if (err.message.includes('already exists')) {
-            status = 409
-        }
-
-        res.status(status).json({
-            success: false,
-            status,
-            error: message
-        })
-        return
-    }
-
-    // Unknown errors
-    res.status(500).json({
-        success: false,
-        status: 500,
-        error: 'Internal Server Error'
-    })
-}` 

package/templates/files/home-controller.js

@@ -1,7 +0,0 @@
-export default `import type { Request, Response } from 'express'
-
-export async function GET(req: Request, res: Response) {
-    res.json({ 
-        message: \`Selamat datang di KONTAS XROUTES\`,
-    })
-}` 

package/templates/files/index.js

@@ -1,129 +0,0 @@
-export default `import dotenv from 'dotenv'
-import express from 'express'
-import { XRoutes, XMiddleware } from 'kontas-xroutes'
-import { connect } from '@config/mongodb'
-
-// Load environment variables
-dotenv.config()
-
-/*
- * 📚 Tutorial Express + XRoutes:
- * 
- * 🔥 XRoutes Features:
- * - Auto-routing dari folder structure (mirip NextJS)
- * - Wajib pake nama controller.ts (bkn route.ts)
- * - Support middleware per route/global
- * - Compatible dgn Express & Bun
- * 
- * 📁 Struktur Route:
- * src/
- *  ├─ products/
- *  │   ├─ [id]/
- *  │   │   └─ controller.ts    => /products/:id
- *  │   └─ controller.ts        => /products
- *  ├─ users/
- *  │   ├─ [id]/
- *  │   │   └─ controller.ts    => /users/:id
- *  │   └─ controller.ts        => /users
- *  └─ auth/
- *      └─ controller.ts        => /auth
- * 
- * 🔐 Route Middleware Examples:
- * - '/products/*': Semua route /products
- * - '/users': Exact route /users
- * - '/users/*': Route yg ada /users/ didalamnya
- */
-
-const app = express()
-const port = process.env.PORT || 3000
-
-/*
- * 🛠️ Content-Length Fix untuk Bun:
- * Reset content-length pada:
- * 1. GET requests
- * 2. OPTIONS (CORS)
- * 3. Non-JSON requests
- */
-app.use((req, res, next) => {
-    if (
-        req.method === 'GET' || 
-        req.method === 'OPTIONS' ||
-        !req.is('application/json')
-    ) {
-        req.headers['content-length'] = undefined;
-    }
-    next();
-});
-
-// Basic middleware
-app.use(express.json())
-app.use(express.urlencoded({ extended: true }))
-
-// Setup simple logging middleware
-XMiddleware.setup({
-    // Global middleware
-    global: [
-        async (req, res, next) => {
-            console.log(\`🚀 \${req.method} \${req.path}\`)
-            next()
-        }
-    ],
-    
-    // Route specific middleware
-    /*
-    routes: {
-        '/products/*': [
-            async (req, res, next) => {
-                console.log('📦 Products Route accessed')
-                next()
-            }
-        ],
-        
-        '/users': [
-            async (req, res, next) => {
-                console.log('👥 Users Route accessed!')
-                next()
-            }
-        ],
-        
-        '/users/*': [
-            async (req, res, next) => {
-                console.log('👤 User Detail Route accessed!')
-                next()
-            }
-        ]
-    }
-    */
-
-    // Jika pakai middleware dari file lain
-    // Import dulu middlewarenya di paling atas
-    /*
-    routes: {
-        '/products/*': [
-            authMiddleware,
-            loggerMiddleware,
-            multerMiddleware
-        ]
-    }
-    */
-})
-
-// Start server dgn auto-routing
-await XRoutes.createServer(app, { dir: 'src' })
-
-// Test MongoDB connection before starting server
-let isMongoConnected = false
-try {
-    await connect()
-    isMongoConnected = true
-} catch (error: unknown) {
-    console.error('❌ MongoDB Connection Error:', (error as Error).message)
-}
-
-app.listen(port, () => {
-    console.log(\`🚀 Server is running on:
-   - Port: http://localhost:\${port}
-   - Environment: \${process.env.NODE_ENV || 'development'}
-   - MongoDB: \${isMongoConnected ? 'Connected' : 'Failed to connect'}\`)
-})
-` 

package/templates/files/model-seeder.js

@@ -1,43 +0,0 @@
-export default `import fs from "fs/promises";
-import { getCollection } from "@config/mongodb";
-import { ObjectId } from "mongodb";
-import type { {{MODEL}} } from "@modules/{{MODEL_LC}}/{{MODEL_LC}}.schema";
-
-/* 
- * 📚 Tutorial Model Seeder:
- * 1. Template ini bikin seeder utk masing2 model
- * 2. Dia baca data dari file JSON di src/data/
- * 3. Nambahin field yg dibutuhin kyk _id, createdAt, updatedAt
- * 4. Masukin data ke MongoDB
- */
-
-const collectionName = "{{MODEL_PLURAL}}"
-
-export const seed{{MODEL_PLURAL}} = async () => {
-    /* 
-     * 🔄 Langkah2 Seeding:
-     * 1. Ambil referensi collection
-     * 2. Baca data JSON
-     * 3. Ubah data (tambahin ID & timestamp)
-     * 4. Masukin ke database
-     */
-    try {
-        const {{MODEL_LC}}Collection = await getCollection(collectionName);
-
-        const {{MODEL_LC_PLURAL}} = JSON.parse(
-            await fs.readFile("./src/data/{{MODEL_LC_PLURAL}}.json", "utf-8")
-        );
-
-        {{MODEL_LC_PLURAL}}.map((el: {{MODEL}}) => {
-            el._id = new ObjectId();
-            el.createdAt = new Date();
-            el.updatedAt = new Date();
-            return el;
-        });
-
-        await {{MODEL_LC}}Collection.insertMany({{MODEL_LC_PLURAL}});
-        console.log("{{MODEL}} seeding completed successfully.");
-    } catch (error) {
-        console.error("Error seeding {{MODEL_LC_PLURAL}}:", error);
-    }
-}` 

package/templates/files/repository.js

@@ -1,47 +0,0 @@
-export default `import { getCollection } from "../../config/mongodb"
-import { ObjectId } from "mongodb"
-
-import type { 
-    Create{{MODEL}}, 
-    {{MODEL}},
-    {{MODEL}}Id,
-    Update{{MODEL}} 
-} from "./{{MODEL_LC}}.schema"
-
-const {{MODEL_LC_PLURAL}} = await getCollection("{{MODEL_PLURAL}}")
-
-export const {{MODEL_LC}}Repository = {
-    
-    create: async (data: Create{{MODEL}}) => {
-        const result = await {{MODEL_LC_PLURAL}}.insertOne({
-            ...data,
-            createdAt: new Date(),
-            updatedAt: new Date()
-        })
-        return { _id: result.insertedId, ...data } as {{MODEL}}
-    },
-
-    findAll: async () => {
-        return await {{MODEL_LC_PLURAL}}.find().toArray() as {{MODEL}}[]
-    },
-
-    findById: async ({ id }: {{MODEL}}Id) => {
-        return await {{MODEL_LC_PLURAL}}.findOne(
-            { _id: new ObjectId(id) }
-        ) as {{MODEL}} | null
-    },
-
-    update: async ({ id }: {{MODEL}}Id, data: Update{{MODEL}}) => {
-        return await {{MODEL_LC_PLURAL}}.findOneAndUpdate(
-            { _id: new ObjectId(id) },
-            { $set: { ...data, updatedAt: new Date() } },
-            { returnDocument: "after" }
-        )
-    },
-
-    delete: async ({ id }: {{MODEL}}Id) => {
-        return await {{MODEL_LC_PLURAL}}.findOneAndDelete(
-            { _id: new ObjectId(id) }
-        )
-    }
-}` 

package/templates/files/route-controller.js

@@ -1,53 +0,0 @@
-export const routeController = (MODEL, MODEL_PLURAL, MODEL_LC_PLURAL) => `import type { Request, Response, NextFunction } from 'express'
-import { ${MODEL}Service } from "@modules/${MODEL.toLowerCase()}/${MODEL.toLowerCase()}.service"
-
-export async function GET(req: Request, res: Response, next: NextFunction) {
-    try {
-        const ${MODEL_LC_PLURAL} = await ${MODEL}Service.getAll${MODEL_PLURAL}()
-        res.status(${MODEL_LC_PLURAL}.status).json(${MODEL_LC_PLURAL})
-    } catch (error) {
-        next(error)
-    }
-}
-
-export async function POST(req: Request, res: Response, next: NextFunction) {
-    try {
-        const ${MODEL.toLowerCase()} = await ${MODEL}Service.create${MODEL}(req.body)
-        res.status(${MODEL.toLowerCase()}.status).json(${MODEL.toLowerCase()})
-    } catch (error) {
-        next(error)
-    }
-}`
-
-export const routeIdController = (MODEL) => `import type { Request, Response, NextFunction } from 'express'
-import { ${MODEL}Service } from "@modules/${MODEL.toLowerCase()}/${MODEL.toLowerCase()}.service"
-
-export async function GET(req: Request, res: Response, next: NextFunction) {
-    try {
-        const { id } = req.params
-        const ${MODEL.toLowerCase()} = await ${MODEL}Service.get${MODEL}ById({ id })
-        res.status(${MODEL.toLowerCase()}.status).json(${MODEL.toLowerCase()})
-    } catch (error) {
-        next(error)
-    }
-}
-
-export async function PUT(req: Request, res: Response, next: NextFunction) {
-    try {
-        const { id } = req.params
-        const ${MODEL.toLowerCase()} = await ${MODEL}Service.update${MODEL}({ id }, req.body)
-        res.status(${MODEL.toLowerCase()}.status).json(${MODEL.toLowerCase()})
-    } catch (error) {
-        next(error)
-    }
-}
-
-export async function DELETE(req: Request, res: Response, next: NextFunction) {
-    try {
-        const { id } = req.params
-        const ${MODEL.toLowerCase()} = await ${MODEL}Service.delete${MODEL}({ id })
-        res.status(${MODEL.toLowerCase()}.status).json(${MODEL.toLowerCase()})
-    } catch (error) {
-        next(error)
-    }
-}` 

package/templates/files/schema.js

@@ -1,53 +0,0 @@
-export default `import { z } from "zod"
-import { ObjectId } from "mongodb"
-
-/*
- * 📚 Quick Zod Guide:
- * 
- * Contoh validasi dgn message:
- * const userSchema = z.object({
- *    name: z.string().min(2, "Minimal 2 karakter"),
- *    email: z.string().email("Email tidak valid"),
- *    age: z.number().min(17, "Minimal umur 17 tahun")
- * })
- */
-
-// Base schema yg shared di semua operations
-const {{MODEL}}BaseSchema = z.object({
-{{FIELDS}}
-})
-
-const WithIdSchema = z.object({
-    _id: z.instanceof(ObjectId)
-})
-
-const TimestampSchema = z.object({
-    createdAt: z.date(),
-    updatedAt: z.date()
-})
-
-const {{MODEL}}IdSchema = z.object({
-    id: z.string().regex(/^[0-9a-fA-F]{24}$/)
-})
-
-const Create{{MODEL}}Schema = {{MODEL}}BaseSchema
-
-const {{MODEL}}Schema = {{MODEL}}BaseSchema
-    .merge(WithIdSchema)
-    .merge(TimestampSchema)
-
-const Update{{MODEL}}Schema = {{MODEL}}BaseSchema.partial()
-
-// Export types
-export type Create{{MODEL}} = z.infer<typeof Create{{MODEL}}Schema>
-export type {{MODEL}} = z.infer<typeof {{MODEL}}Schema>
-export type Update{{MODEL}} = z.infer<typeof Update{{MODEL}}Schema>
-export type {{MODEL}}Id = z.infer<typeof {{MODEL}}IdSchema>
-
-// Export schemas
-export {
-    Create{{MODEL}}Schema,
-    {{MODEL}}Schema,
-    Update{{MODEL}}Schema,
-    {{MODEL}}IdSchema
-}` 

package/templates/files/seeder-index.js

@@ -1,62 +0,0 @@
-export default `import { connect, getDb } from "@config/mongodb";
-{{IMPORTS}}
-
-/*
- * 📚 Tutorial: Proses Seeding
- * 1. File ini adalah seeder utama yg ngatur semua operasi seeding
- * 2. Pertama, dia bakal drop collection yg udh ada biar datanya bersih
- * 3. Trus jalanin semua seeder secara bersamaan pake Promise.all
- */
-
-async function dropCollections() {
-    /* 
-     * 🔍 Gmn cara kerja dropCollections:
-     * - Dapetin koneksi database
-     * - Coba drop tiap collection
-     * - Handle kasus klo collection blm ada
-     */
-    try {
-        const db = await getDb();
-        
-        const collections = [{{COLLECTIONS}}];
-
-        for (const collectionName of collections) {
-            try {
-                await db.collection(collectionName).drop();
-            } catch {
-                console.log(\`⚠️ \${collectionName} collection not found, skipping...\`);
-            }
-        }
-
-        console.log("✨ Successfully dropped all collections!");
-    } catch (error) {
-        console.error("❌ Failed to drop collections:", error);
-        throw error;
-    }
-}
-
-async function seed() {
-    /* 
-     * 🌱 Langkah2 Proses Seeding:
-     * 1. Konek ke MongoDB
-     * 2. Drop collection yg udh ada
-     * 3. Jalanin semua seeder barengan
-     * 4. Exit process klo udh selesai
-     */
-    try {
-        await connect();
-        await dropCollections();
-
-        await Promise.all([
-            {{SEEDERS}}
-        ]);
-
-        console.log("🌱 Seeding completed successfully!");
-    } catch (error) {
-        console.error("❌ Seeding failed:", error);
-    } finally {
-        process.exit(0);
-    }
-}
-
-seed();` 

package/templates/files/service.js

@@ -1,103 +0,0 @@
-export default `import { {{MODEL_LC}}Repository } from "./{{MODEL_LC}}.repository"
-import type { Create{{MODEL}}, {{MODEL}}Id, Update{{MODEL}} } from "./{{MODEL_LC}}.schema"
-import { Create{{MODEL}}Schema, {{MODEL}}IdSchema, Update{{MODEL}}Schema } from "./{{MODEL_LC}}.schema"
-
-export class {{MODEL}}Service {
-
-    static async create{{MODEL}}({{MODEL_LC}}: Create{{MODEL}}) {
-        try {
-            const validated = Create{{MODEL}}Schema.parse({{MODEL_LC}})
-            const result = await {{MODEL_LC}}Repository.create(validated)
-
-            return { 
-                success: true, 
-                status: 201, 
-                data: result 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async getAll{{MODEL_PLURAL}}() {
-        try {
-            const {{MODEL_LC_PLURAL}} = await {{MODEL_LC}}Repository.findAll()
-
-            if ({{MODEL_LC_PLURAL}}.length === 0) {
-                throw new Error("No {{MODEL_LC_PLURAL}} found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: {{MODEL_LC_PLURAL}} 
-            }
-            
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async get{{MODEL}}ById(params: {{MODEL}}Id) {
-        try {
-            const { id } = {{MODEL}}IdSchema.parse(params)
-            const {{MODEL_LC}} = await {{MODEL_LC}}Repository.findById({ id })
-
-            if (!{{MODEL_LC}}) {
-                throw new Error("{{MODEL}} not found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: {{MODEL_LC}} 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async update{{MODEL}}(params: {{MODEL}}Id, data: Update{{MODEL}}) {
-        try {
-            const { id } = {{MODEL}}IdSchema.parse(params)
-            const validated = Update{{MODEL}}Schema.parse(data)
-            
-            const result = await {{MODEL_LC}}Repository.update({ id }, validated)
-            
-            if (!result) {
-                throw new Error("{{MODEL}} not found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: result 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async delete{{MODEL}}(params: {{MODEL}}Id) {
-        try {
-            const { id } = {{MODEL}}IdSchema.parse(params)
-            const result = await {{MODEL_LC}}Repository.delete({ id })
-
-            if (!result) {
-                throw new Error("{{MODEL}} not found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: result 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-}` 

package/templates/files/user/auth-service.js

@@ -1,72 +0,0 @@
-export default `import { {{MODEL_LC}}Repository } from "./{{MODEL_LC}}.repository"
-import type { Create{{MODEL}} } from "./{{MODEL_LC}}.schema"
-import { Create{{MODEL}}Schema } from "./{{MODEL_LC}}.schema"
-import { hash, compare } from "@utils/bcrypt"
-import { createToken } from "@utils/jwt"
-
-export class Auth{{MODEL}}Service {
-    static async login(email: string, password: string) {
-        try {
-            const user = await {{MODEL_LC}}Repository.findByEmail(email)
-            
-            if (!user) {
-                throw new Error("Invalid credentials")
-            }
-
-            const isValidPassword = await compare(password, user.password)
-            
-            if (!isValidPassword) {
-                throw new Error("Invalid credentials")
-            }
-
-            const token = await createToken({
-                userId: user._id.toString(),
-                email: user.email
-            })
-
-            // Remove password from response
-            const { password: _, ...userWithoutPassword } = user
-
-            return {
-                success: true,
-                status: 200,
-                data: { user: userWithoutPassword, token }
-            }
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async register(data: Create{{MODEL}}) {
-        try {
-            const validated = Create{{MODEL}}Schema.parse(data)
-            
-            // Check if email already exists
-            const existing = await {{MODEL_LC}}Repository.findByEmail(validated.email)
-            if (existing) {
-                throw new Error("Email already registered")
-            }
-            
-            // Hash password
-            validated.password = await hash(validated.password)
-            
-            const result = await {{MODEL_LC}}Repository.create(validated)
-            const token = await createToken({
-                userId: result._id.toString(),
-                email: result.email
-            })
-
-            // Remove password from response
-            const { password: _, ...userWithoutPassword } = result
-
-            return { 
-                success: true, 
-                status: 201, 
-                data: { user: userWithoutPassword, token } 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-}` 

package/templates/files/user/controller.js

@@ -1,21 +0,0 @@
-export default `import type { Request, Response, NextFunction } from 'express'
-import { {{MODEL}}Service } from "@modules/{{MODEL_LC}}/{{MODEL_LC}}.service"
-
-export async function GET(req: Request, res: Response, next: NextFunction) {
-    try {
-        const result = await {{MODEL}}Service.getAll{{MODEL}}s()
-        res.status(result.status).json(result)
-    } catch (error) {
-        next(error)
-    }
-}
-
-// Create user (admin only)
-export async function POST(req: Request, res: Response, next: NextFunction) {
-    try {
-        const result = await {{MODEL}}Service.create{{MODEL}}(req.body)
-        res.status(result.status).json(result)
-    } catch (error) {
-        next(error)
-    }
-}` 

package/templates/files/user/id-controller.js

@@ -1,32 +0,0 @@
-export default `import type { Request, Response, NextFunction } from 'express'
-import { {{MODEL}}Service } from "@modules/{{MODEL_LC}}/{{MODEL_LC}}.service"
-
-export async function GET(req: Request, res: Response, next: NextFunction) {
-    try {
-        const { id } = req.params
-        const result = await {{MODEL}}Service.get{{MODEL}}ById({ id })
-        res.status(result.status).json(result)
-    } catch (error) {
-        next(error)
-    }
-}
-
-export async function PUT(req: Request, res: Response, next: NextFunction) {
-    try {
-        const { id } = req.params
-        const result = await {{MODEL}}Service.update{{MODEL}}({ id }, req.body)
-        res.status(result.status).json(result)
-    } catch (error) {
-        next(error)
-    }
-}
-
-export async function DELETE(req: Request, res: Response, next: NextFunction) {
-    try {
-        const { id } = req.params
-        const result = await {{MODEL}}Service.delete{{MODEL}}({ id })
-        res.status(result.status).json(result)
-    } catch (error) {
-        next(error)
-    }
-}` 

package/templates/files/user/register-controller.js

@@ -1,11 +0,0 @@
-export default `import type { Request, Response, NextFunction } from 'express'
-import { Auth{{MODEL}}Service } from "@modules/{{MODEL_LC}}/auth.service"
-
-export async function POST(req: Request, res: Response, next: NextFunction) {
-    try {
-        const result = await Auth{{MODEL}}Service.register(req.body)
-        res.status(result.status).json(result)
-    } catch (error) {
-        next(error)
-    }
-}` 

package/templates/files/user/repository.js

@@ -1,59 +0,0 @@
-export default `import { getCollection } from "../../config/mongodb"
-import { ObjectId } from "mongodb"
-
-import type { 
-    Create{{MODEL}}, 
-    {{MODEL}},
-    {{MODEL}}Id,
-    Update{{MODEL}} 
-} from "./{{MODEL_LC}}.schema"
-
-const {{MODEL_LC}}s = await getCollection("{{MODEL}}s")
-
-export const {{MODEL_LC}}Repository = {
-    
-    create: async (data: Create{{MODEL}}) => {
-        const result = await {{MODEL_LC}}s.insertOne({
-            ...data,
-            createdAt: new Date(),
-            updatedAt: new Date()
-        })
-        return { _id: result.insertedId, ...data } as {{MODEL}}
-    },
-
-    findAll: async () => {
-        return await {{MODEL_LC}}s.find({}, { projection: { password: 0 } }).toArray() as {{MODEL}}[]
-    },
-
-    findById: async ({ id }: {{MODEL}}Id) => {
-        return await {{MODEL_LC}}s.findOne(
-            { _id: new ObjectId(id) },
-            { projection: { password: 0 } }
-        ) as {{MODEL}} | null
-    },
-
-    // Khusus User: findByEmail (tetap include password utk login)
-    findByEmail: async (email: string) => {
-        return await {{MODEL_LC}}s.findOne({ email }) as {{MODEL}} | null
-    },
-
-    update: async ({ id }: {{MODEL}}Id, data: Update{{MODEL}}) => {
-        const result = await {{MODEL_LC}}s.findOneAndUpdate(
-            { _id: new ObjectId(id) },
-            { $set: { ...data, updatedAt: new Date() } },
-            { 
-                returnDocument: "after",
-                projection: { password: 0 }
-            }
-        )
-        return result
-    },
-
-    delete: async ({ id }: {{MODEL}}Id) => {
-        const result = await {{MODEL_LC}}s.findOneAndDelete(
-            { _id: new ObjectId(id) },
-            { projection: { password: 0 } }
-        )
-        return result
-    }
-}` 

package/templates/files/user/seeder.js

@@ -1,33 +0,0 @@
-export default `import fs from "fs/promises"
-import { getCollection } from "@config/mongodb"
-import { ObjectId } from "mongodb"
-import type { User } from "@modules/user/user.schema"
-import { hash } from "@utils/bcrypt"
-
-const collectionName = "Users"
-
-export const seedUsers = async () => {
-    try {
-        const userCollection = await getCollection(collectionName)
-
-        const users = JSON.parse(
-            await fs.readFile("./src/data/users.json", "utf-8")
-        )
-
-        // Hash passwords before inserting
-        const usersWithHashedPasswords = await Promise.all(
-            users.map(async (el: User) => {
-                el._id = new ObjectId()
-                el.password = await hash(el.password)
-                el.createdAt = new Date()
-                el.updatedAt = new Date()
-                return el
-            })
-        )
-
-        await userCollection.insertMany(usersWithHashedPasswords)
-        console.log("User seeding completed successfully.")
-    } catch (error) {
-        console.error("Error seeding users:", error)
-    }
-}` 

package/templates/files/user/service.js

@@ -1,173 +0,0 @@
-export default `import { {{MODEL_LC}}Repository } from "./{{MODEL_LC}}.repository"
-import type { Create{{MODEL}}, {{MODEL}}Id, Update{{MODEL}} } from "./{{MODEL_LC}}.schema"
-import { Create{{MODEL}}Schema, {{MODEL}}IdSchema, Update{{MODEL}}Schema } from "./{{MODEL_LC}}.schema"
-import { hash, compare } from "@utils/bcrypt"
-import { createToken } from "@utils/jwt"
-
-export class {{MODEL}}Service {
-    static async create{{MODEL}}({{MODEL_LC}}: Create{{MODEL}}) {
-        try {
-            const validated = Create{{MODEL}}Schema.parse({{MODEL_LC}})
-            
-            // Hash password before saving
-            validated.password = await hash(validated.password)
-            
-            const result = await {{MODEL_LC}}Repository.create(validated)
-
-            return { 
-                success: true, 
-                status: 201, 
-                data: result
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async getAll{{MODEL}}s() {
-        try {
-            const {{MODEL_LC}}s = await {{MODEL_LC}}Repository.findAll()
-
-            if ({{MODEL_LC}}s.length === 0) {
-                throw new Error("No {{MODEL_LC}}s found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: {{MODEL_LC}}s 
-            }
-            
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async get{{MODEL}}ById(params: {{MODEL}}Id) {
-        try {
-            const { id } = {{MODEL}}IdSchema.parse(params)
-            const {{MODEL_LC}} = await {{MODEL_LC}}Repository.findById({ id })
-
-            if (!{{MODEL_LC}}) {
-                throw new Error("{{MODEL}} not found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: {{MODEL_LC}} 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async update{{MODEL}}(params: {{MODEL}}Id, data: Update{{MODEL}}) {
-        try {
-            const { id } = {{MODEL}}IdSchema.parse(params)
-            const validated = Update{{MODEL}}Schema.parse(data)
-            
-            // Hash password if it's being updated
-            if (validated.password) {
-                validated.password = await hash(validated.password)
-            }
-            
-            const result = await {{MODEL_LC}}Repository.update({ id }, validated)
-            
-            if (!result) {
-                throw new Error("{{MODEL}} not found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: result 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async delete{{MODEL}}(params: {{MODEL}}Id) {
-        try {
-            const { id } = {{MODEL}}IdSchema.parse(params)
-            const result = await {{MODEL_LC}}Repository.delete({ id })
-
-            if (!result) {
-                throw new Error("{{MODEL}} not found")
-            }
-
-            return { 
-                success: true, 
-                status: 200, 
-                data: result 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-
-    // Auth methods
-    static async login(email: string, password: string) {
-        try {
-            const user = await {{MODEL_LC}}Repository.findByEmail(email)
-            
-            if (!user) {
-                throw new Error("Invalid credentials")
-            }
-
-            const isValidPassword = await compare(password, user.password)
-            
-            if (!isValidPassword) {
-                throw new Error("Invalid credentials")
-            }
-
-            const token = await createToken({
-                userId: user._id.toString(),
-                email: user.email
-            })
-
-            return {
-                success: true,
-                status: 200,
-                data: { user, token }
-            }
-        } catch (error) {
-            throw error
-        }
-    }
-
-    static async register(data: Create{{MODEL}}) {
-        try {
-            const validated = Create{{MODEL}}Schema.parse(data)
-            
-            // Check if email already exists
-            const existing = await {{MODEL_LC}}Repository.findByEmail(validated.email)
-            if (existing) {
-                throw new Error("Email already registered")
-            }
-            
-            // Hash password
-            validated.password = await hash(validated.password)
-            
-            const result = await {{MODEL_LC}}Repository.create(validated)
-            const token = await createToken({
-                userId: result._id.toString(),
-                email: result.email
-            })
-
-            return { 
-                success: true, 
-                status: 201, 
-                data: { user: result, token } 
-            }
-
-        } catch (error) {
-            throw error
-        }
-    }
-}`

package/templates/files/user/sessions-controller.js

@@ -1,24 +0,0 @@
-export default `import type { Request, Response, NextFunction } from 'express'
-import { Auth{{MODEL}}Service } from "@modules/{{MODEL_LC}}/auth.service"
-
-export async function POST(req: Request, res: Response, next: NextFunction) {
-    try {
-        const { email, password } = req.body
-        const result = await Auth{{MODEL}}Service.login(email, password)
-        res.status(result.status).json(result)
-    } catch (error) {
-        next(error)
-    }
-}
-
-export async function DELETE(req: Request, res: Response, next: NextFunction) {
-    try {
-        // Handle logout (invalidate token, clear cookie etc)
-        res.status(200).json({
-            success: true,
-            message: "Logged out successfully"
-        })
-    } catch (error) {
-        next(error)
-    }
-}` 

package/templates/files/utils/bcrypt.js

@@ -1,15 +0,0 @@
-export default `import bcrypt from "bcryptjs"
-
-export const hash = async (
-    password: string,
-    saltRounds: number = 10
-): Promise<string> => {
-    return await bcrypt.hash(password, saltRounds)
-}
-
-export const compare = async (
-    password: string, 
-    hash: string
-): Promise<boolean> => {
-    return await bcrypt.compare(password, hash)
-}` 

package/templates/files/utils/jwt.js

@@ -1,33 +0,0 @@
-export default `import jwt from "jsonwebtoken"
-
-interface TokenPayload {
-    userId: string
-    email: string
-    role?: string
-}
-
-const JWT_SECRET = process.env.JWT_SECRET || "your-secret-key"
-const JWT_EXPIRES_IN = "24h"
-
-export const createToken = async (payload: TokenPayload): Promise<string> => {
-    return new Promise((resolve, reject) => {
-        jwt.sign(
-            payload,
-            JWT_SECRET,
-            { expiresIn: JWT_EXPIRES_IN },
-            (error, token) => {
-                if (error) reject(error)
-                resolve(token as string)
-            }
-        )
-    })
-}
-
-export const verifyToken = async (token: string): Promise<TokenPayload> => {
-    return new Promise((resolve, reject) => {
-        jwt.verify(token, JWT_SECRET, (error, decoded) => {
-            if (error) reject(error)
-            resolve(decoded as TokenPayload)
-        })
-    })
-}`

package/templates/index.js

@@ -1,60 +0,0 @@
-import repository from './files/repository.js'
-import schema from './files/schema.js'
-import service from './files/service.js'
-import rootIndex from './files/index.js'
-import homeController from './files/home-controller.js'
-import mongodbConfig from './files/config/mongodb-config.js'
-import mongodbJson from './files/config/mongodb-json.js'
-import seederIndex from './files/seeder-index.js'
-import modelSeeder from './files/model-seeder.js'
-import errorHandler from './files/error-handler.js'
-import { routeController, routeIdController } from './files/route-controller.js'
-
-// User specific templates
-import bcryptUtil from './files/utils/bcrypt.js'
-import jwtUtil from './files/utils/jwt.js'
-import userRepository from './files/user/repository.js'
-import userService from './files/user/service.js'
-import userController from './files/user/controller.js'
-import userIdController from './files/user/id-controller.js'
-import userSessionsController from './files/user/sessions-controller.js'
-import userRegisterController from './files/user/register-controller.js'
-import userSeeder from './files/user/seeder.js'
-import userAuthService from './files/user/auth-service.js'
-
-const gitignoreContent = `node_modules
-.env
-.DS_Store
-dist
-.turbo`
-
-const templates = {
-    // Standard templates
-    repository,
-    schema,
-    service,
-    rootIndex,
-    homeController,
-    mongodbConfig,
-    mongodbJson,
-    gitignore: gitignoreContent,
-    seederIndex,
-    modelSeeder,
-    errorHandler,
-    routeController,
-    routeIdController,
-
-    // User specific templates
-    bcryptUtil,
-    jwtUtil,
-    userRepository,
-    userService,
-    userController,
-    userIdController,
-    userSessionsController,
-    userRegisterController,
-    userSeeder,
-    userAuthService
-}
-
-export default templates