kontas-express 1.0.7 → 1.0.9

package/dist/index.js

@@ -3,89 +3,136 @@
 var generateMongoRepository = (name, pluralName) => `import { ObjectId } from "mongodb"
 import { connectToDatabase, getDatabaseCollection } from "../../config"
 import type { Create${name}, Update${name}, ${pluralName}, ${name}Id } from "./${name.toLowerCase()}.schema"
+import { ${name} } from "./${name.toLowerCase()}.schema"
 
 type ${name}Response<T> = {
-    success: boolean
+    success: true
     message?: string
     value: T
+} | {
+    success: false
+    message: string
+    error: unknown
+    value: null
 }
 
 export class ${name}Repository {
-    private collectionName = "${pluralName}"
+    private readonly collectionName = "${pluralName}"
+    private collection: ReturnType<typeof getDatabaseCollection> | null = null
     
-    async connect() {
-        await connectToDatabase()
-        return getDatabaseCollection(this.collectionName)
+    private async getCollection() {
+        if (!this.collection) {
+            await connectToDatabase()
+            this.collection = getDatabaseCollection(this.collectionName)
+        }
+        return this.collection
     }
     
-    async create(data: Create${name}): Promise<${name}Response<${pluralName}>> {
-        const collection = await this.connect()
-        
-        const doc = {
-            ...data,
-            createdAt: new Date(),
-            updatedAt: new Date()
-        }
-        
-        const result = await collection.insertOne(doc)
-        return {
-            success: true,
-            message: "${name} berhasil dibuat",
-            value: { ...doc, _id: result.insertedId } as ${pluralName}
+    async create(data: Readonly<Create${name}>): Promise<${name}Response<${pluralName}>> {
+        try {
+            const collection = await this.getCollection()
+            
+            const doc = {
+                ...data,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            } as const
+            
+            const result = await collection.insertOne(doc)
+            return {
+                success: true,
+                message: "${name} created successfully",
+                value: new ${name}({ ...doc, _id: result.insertedId }) as ${pluralName}
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to create ${name.toLowerCase()}",
+                error,
+                value: null
+            }
         }
     }
     
-    async findAll(): Promise<${name}Response<${pluralName}[]>> {
-        const collection = await this.connect()
-        const docs = await collection.find({}).toArray()
+    async findAll(): Promise<${name}Response<${name}[]>> {
+        const collection = await this.getCollection()
+        const docs = await collection.find({}).toArray() as ${pluralName}[]
         return {
             success: true,
-            value: docs as ${pluralName}[]
+            value: docs.map(doc => new ${name}(doc))
         }
     }
     
-    async findById({ id }: ${name}Id): Promise<${name}Response<${pluralName} | null>> {
-        const collection = await this.connect()
-        const doc = await collection.findOne({ _id: new ObjectId(id) })
-        return {
-            success: true,
-            value: doc as ${pluralName} | null
+    async findById({ id }: Readonly<${name}Id>): Promise<${name}Response<${name} | null>> {
+        try {
+            const collection = await this.getCollection()
+            const doc = await collection.findOne({ _id: new ObjectId(id) }) as ${pluralName} | null
+            return {
+                success: true,
+                value: doc ? new ${name}(doc) : null
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to find ${name.toLowerCase()}",
+                error,
+                value: null
+            }
         }
     }
     
-    async update({ id }: ${name}Id, data: Update${name}): Promise<${name}Response<${pluralName} | null>> {
-        const collection = await this.connect()
-        
-        const result = await collection.findOneAndUpdate(
-            { _id: new ObjectId(id) },
-            { 
-                $set: {
-                    ...data,
-                    updatedAt: new Date()
-                }
-            },
-            { returnDocument: 'after' }
-        )
-        
-        return {
-            success: true,
-            message: result ? "${name} berhasil diupdate" : "${name} tidak ditemukan",
-            value: result as ${pluralName} | null
+    async update({ id }: Readonly<${name}Id>, data: Readonly<Update${name}>): Promise<${name}Response<${pluralName} | null>> {
+        try {
+            const collection = await this.getCollection()
+            
+            const result = await collection.findOneAndUpdate(
+                { _id: new ObjectId(id) },
+                { 
+                    $set: {
+                        ...data,
+                        updatedAt: new Date()
+                    }
+                },
+                { returnDocument: 'after' }
+            )
+            
+            return {
+                success: true,
+                message: result ? "${name} updated successfully" : "${name} not found",
+                value: result ? new ${name}(result) as ${pluralName} : null
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to update ${name.toLowerCase()}",
+                error,
+                value: null
+            }
         }
     }
     
-    async delete({ id }: ${name}Id): Promise<${name}Response<void>> {
-        const collection = await this.connect()
+    async delete({ id }: ${name}Id): Promise<${name}Response<${pluralName} | null>> {
+        const collection = await this.getCollection()
+        
+        const doc = await collection.findOne({ _id: new ObjectId(id) })
+        if (!doc) {
+            return {
+                success: true,
+                message: "${name} not found",
+                value: null
+            }
+        }
+
         await collection.deleteOne({ _id: new ObjectId(id) })
         return {
             success: true,
-            message: "${name} berhasil dihapus",
-            value: undefined
+            message: "${name} deleted successfully",
+            value: new ${name}(doc) as ${pluralName}
         }
     }
 }
 
-export const ${name.toLowerCase()}Repository = new ${name}Repository()`;
+export const ${name.toLowerCase()} = new ${name}Repository()`;
 export {
   generateMongoRepository
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kontas-express",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "main": "dist/index.js",
   "scripts": {
     "build": "bun build ./index.js --outdir ./dist --target bun",