kontas-express 1.0.8 → 1.0.10

package/dist/index.js

@@ -3,79 +3,116 @@
 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} {
-    private collectionName = "${pluralName}"
+export class ${name}Repository {
+    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} created successfully",
-            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} updated successfully" : "${name} not found",
-            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<${pluralName} | null>> {
-        const collection = await this.connect()
+        const collection = await this.getCollection()
         
         const doc = await collection.findOne({ _id: new ObjectId(id) })
         if (!doc) {
@@ -90,12 +127,164 @@ export class ${name} {
         return {
             success: true,
             message: "${name} deleted successfully",
-            value: doc as ${pluralName}
+            value: new ${name}(doc) as ${pluralName}
+        }
+    }
+}
+
+export const ${name.toLowerCase()} = new ${name}Repository()`;
+// src/database/postgresql/repository.template.js
+var generatePostgresRepository = (name, pluralName) => `import { getPool } 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: true
+    message?: string
+    value: T
+} | {
+    success: false
+    message: string
+    error: unknown
+    value: null
+}
+
+export class ${name}Repository {
+    private readonly tableName = "${pluralName.toLowerCase()}"
+    
+    async create(data: Readonly<Create${name}>): Promise<${name}Response<${pluralName}>> {
+        try {
+            const pool = await getPool()
+            
+            const fields = Object.keys(data)
+            const values = Object.values(data)
+            const placeholders = values.map((_, i) => \`$\${i + 1}\`).join(', ')
+            
+            const query = \`
+                INSERT INTO \${this.tableName} 
+                (\${fields.join(', ')}, created_at, updated_at)
+                VALUES (\${placeholders}, NOW(), NOW())
+                RETURNING *
+            \`
+            
+            const result = await pool.query(query, values)
+            return {
+                success: true,
+                message: "${name} created successfully",
+                value: new ${name}(result.rows[0]) as ${pluralName}
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to create ${name.toLowerCase()}",
+                error,
+                value: null
+            }
+        }
+    }
+    
+    async findAll(): Promise<${name}Response<${name}[]>> {
+        try {
+            const pool = await getPool()
+            const result = await pool.query(\`SELECT * FROM \${this.tableName}\`)
+            
+            return {
+                success: true,
+                value: result.rows.map(row => new ${name}(row))
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to fetch ${pluralName.toLowerCase()}",
+                error,
+                value: null
+            }
+        }
+    }
+    
+    async findById({ id }: Readonly<${name}Id>): Promise<${name}Response<${name} | null>> {
+        try {
+            const pool = await getPool()
+            const result = await pool.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = $1\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                value: result.rows[0] ? new ${name}(result.rows[0]) : null
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to find ${name.toLowerCase()}",
+                error,
+                value: null
+            }
+        }
+    }
+    
+    async update({ id }: Readonly<${name}Id>, data: Readonly<Update${name}>): Promise<${name}Response<${pluralName} | null>> {
+        try {
+            const pool = await getPool()
+            
+            const fields = Object.keys(data)
+            const values = Object.values(data)
+            const setClause = fields
+                .map((field, i) => \`\${field} = $\${i + 1}\`)
+                .join(', ')
+            
+            const query = \`
+                UPDATE \${this.tableName}
+                SET \${setClause}, updated_at = NOW()
+                WHERE id = $\${values.length + 1}
+                RETURNING *
+            \`
+            
+            const result = await pool.query(query, [...values, id])
+            
+            return {
+                success: true,
+                message: result.rows[0] ? "${name} updated successfully" : "${name} not found",
+                value: result.rows[0] ? new ${name}(result.rows[0]) 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<${pluralName} | null>> {
+        try {
+            const pool = await getPool()
+            
+            const result = await pool.query(
+                \`DELETE FROM \${this.tableName} WHERE id = $1 RETURNING *\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                message: result.rows[0] ? "${name} deleted successfully" : "${name} not found",
+                value: result.rows[0] ? new ${name}(result.rows[0]) as ${pluralName} : null
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to delete ${name.toLowerCase()}",
+                error,
+                value: null
+            }
         }
     }
 }
 
-export const ${name.toLowerCase()} = new ${name}()`;
+export const ${name.toLowerCase()} = new ${name}Repository()`;
 export {
+  generatePostgresRepository,
   generateMongoRepository
 };

package/package.json

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