kontas-express 1.0.10 → 1.0.12

package/dist/index.js

@@ -1,7 +1,7 @@
 // @bun
 // src/database/mongodb/repository.template.js
 var generateMongoRepository = (name, pluralName) => `import { ObjectId } from "mongodb"
-import { connectToDatabase, getDatabaseCollection } from "../../config"
+import { db } from "../../config"
 import type { Create${name}, Update${name}, ${pluralName}, ${name}Id } from "./${name.toLowerCase()}.schema"
 import { ${name} } from "./${name.toLowerCase()}.schema"
 
@@ -18,27 +18,16 @@ type ${name}Response<T> = {
 
 export class ${name}Repository {
     private readonly collectionName = "${pluralName}"
-    private collection: ReturnType<typeof getDatabaseCollection> | null = null
-    
-    private async getCollection() {
-        if (!this.collection) {
-            await connectToDatabase()
-            this.collection = getDatabaseCollection(this.collectionName)
-        }
-        return this.collection
-    }
     
     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)
+            const result = await db.collection(this.collectionName).insertOne(doc)
             return {
                 success: true,
                 message: "${name} created successfully",
@@ -55,18 +44,25 @@ export class ${name}Repository {
     }
     
     async findAll(): Promise<${name}Response<${name}[]>> {
-        const collection = await this.getCollection()
-        const docs = await collection.find({}).toArray() as ${pluralName}[]
-        return {
-            success: true,
-            value: docs.map(doc => new ${name}(doc))
+        try {
+            const docs = await db.collection(this.collectionName).find({}).toArray() as ${pluralName}[]
+            return {
+                success: true,
+                value: docs.map(doc => new ${name}(doc))
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to find ${name.toLowerCase()}s",
+                error,
+                value: 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
+            const doc = await db.collection(this.collectionName).findOne({ _id: new ObjectId(id) }) as ${pluralName} | null
             return {
                 success: true,
                 value: doc ? new ${name}(doc) : null
@@ -83,9 +79,7 @@ export class ${name}Repository {
     
     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(
+            const result = await db.collection(this.collectionName).findOneAndUpdate(
                 { _id: new ObjectId(id) },
                 { 
                     $set: {
@@ -112,29 +106,36 @@ export class ${name}Repository {
     }
     
     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) {
+        try {
+            const doc = await db.collection(this.collectionName).findOne({ _id: new ObjectId(id) })
+            if (!doc) {
+                return {
+                    success: true,
+                    message: "${name} not found",
+                    value: null
+                }
+            }
+
+            await db.collection(this.collectionName).deleteOne({ _id: new ObjectId(id) })
             return {
                 success: true,
-                message: "${name} not found",
+                message: "${name} deleted successfully",
+                value: new ${name}(doc) as ${pluralName}
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to delete ${name.toLowerCase()}",
+                error,
                 value: null
             }
         }
-
-        await collection.deleteOne({ _id: new ObjectId(id) })
-        return {
-            success: true,
-            message: "${name} deleted successfully",
-            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"
+var generatePostgresRepository = (name, pluralName) => `import { db } from "../../config"
 import type { Create${name}, Update${name}, ${pluralName}, ${name}Id } from "./${name.toLowerCase()}.schema"
 import { ${name} } from "./${name.toLowerCase()}.schema"
 
@@ -154,8 +155,6 @@ export class ${name}Repository {
     
     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(', ')
@@ -167,7 +166,7 @@ export class ${name}Repository {
                 RETURNING *
             \`
             
-            const result = await pool.query(query, values)
+            const result = await db.query(query, values)
             return {
                 success: true,
                 message: "${name} created successfully",
@@ -185,12 +184,11 @@ export class ${name}Repository {
     
     async findAll(): Promise<${name}Response<${name}[]>> {
         try {
-            const pool = await getPool()
-            const result = await pool.query(\`SELECT * FROM \${this.tableName}\`)
+            const result = await db.query(\`SELECT * FROM \${this.tableName}\`)
             
             return {
                 success: true,
-                value: result.rows.map(row => new ${name}(row))
+                value: result.rows.map((row: ${pluralName}) => new ${name}(row))
             }
         } catch (error) {
             return {
@@ -204,8 +202,7 @@ export class ${name}Repository {
     
     async findById({ id }: Readonly<${name}Id>): Promise<${name}Response<${name} | null>> {
         try {
-            const pool = await getPool()
-            const result = await pool.query(
+            const result = await db.query(
                 \`SELECT * FROM \${this.tableName} WHERE id = $1\`,
                 [id]
             )
@@ -226,8 +223,6 @@ export class ${name}Repository {
     
     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
@@ -241,7 +236,7 @@ export class ${name}Repository {
                 RETURNING *
             \`
             
-            const result = await pool.query(query, [...values, id])
+            const result = await db.query(query, [...values, id])
             
             return {
                 success: true,
@@ -260,9 +255,7 @@ export class ${name}Repository {
     
     async delete({ id }: ${name}Id): Promise<${name}Response<${pluralName} | null>> {
         try {
-            const pool = await getPool()
-            
-            const result = await pool.query(
+            const result = await db.query(
                 \`DELETE FROM \${this.tableName} WHERE id = $1 RETURNING *\`,
                 [id]
             )
@@ -284,7 +277,484 @@ export class ${name}Repository {
 }
 
 export const ${name.toLowerCase()} = new ${name}Repository()`;
+// src/database/postgresql/migration.template.js
+var generatePostgresMigration = (name, pluralName, fields) => {
+  const pgTypes = {
+    string: "VARCHAR(255)",
+    number: "INTEGER",
+    boolean: "BOOLEAN",
+    date: "TIMESTAMP"
+  };
+  const columns = fields.map((field) => {
+    const pgType = pgTypes[field.type] || "VARCHAR(255)";
+    return `    ${field.name} ${pgType}`;
+  }).join(`,
+`);
+  return `import { db } from "../../config"
+
+export async function up() {
+    await db.query(\`
+        CREATE TABLE IF NOT EXISTS ${pluralName.toLowerCase()} (
+            id SERIAL PRIMARY KEY,
+${columns},
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    \`)
+    
+    console.log('\u2705 Migration ${name} created successfully')
+}
+
+export async function down() {
+    await db.query(\`
+        DROP TABLE IF EXISTS ${pluralName.toLowerCase()}
+    \`)
+    
+    console.log('\u2705 Migration ${name} dropped successfully')
+}
+
+// Jalankan migration
+if (process.argv[2] === 'up') {
+    up()
+        .catch(console.error)
+        .finally(() => process.exit())
+}
+
+if (process.argv[2] === 'down') {
+    down()
+        .catch(console.error)
+        .finally(() => process.exit())
+}`;
+};
+// src/database/mariadb/repository.template.js
+var generateMariadbRepository = (name, pluralName) => `import { db } 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 fields = Object.keys(data)
+            const values = Object.values(data)
+            const placeholders = values.map(() => '?').join(', ')
+            
+            const query = \`
+                INSERT INTO \${this.tableName} 
+                (\${fields.join(', ')}, created_at, updated_at)
+                VALUES (\${placeholders}, NOW(), NOW())
+            \`
+            
+            const result = await db.query(query, values)
+            const [newData] = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = ?\`, 
+                [result.insertId]
+            )
+            
+            return {
+                success: true,
+                message: "${name} created successfully",
+                value: new ${name}(newData) as ${pluralName}
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to create ${name.toLowerCase()}",
+                error,
+                value: null
+            }
+        }
+    }
+    
+    async findAll(): Promise<${name}Response<${name}[]>> {
+        try {
+            const result = await db.query(\`SELECT * FROM \${this.tableName}\`)
+            
+            return {
+                success: true,
+                value: result.map((row: ${pluralName}) => 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 [result] = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                value: result ? new ${name}(result) : 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 fields = Object.keys(data)
+            const values = Object.values(data)
+            const setClause = fields
+                .map(field => \`\${field} = ?\`)
+                .join(', ')
+            
+            const query = \`
+                UPDATE \${this.tableName}
+                SET \${setClause}, updated_at = NOW()
+                WHERE id = ?
+            \`
+            
+            await db.query(query, [...values, id])
+            const [updated] = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                message: updated ? "${name} updated successfully" : "${name} not found",
+                value: updated ? new ${name}(updated) 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 [existing] = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            if (!existing) {
+                return {
+                    success: true,
+                    message: "${name} not found",
+                    value: null
+                }
+            }
+
+            await db.query(
+                \`DELETE FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                message: "${name} deleted successfully",
+                value: new ${name}(existing) as ${pluralName}
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to delete ${name.toLowerCase()}",
+                error,
+                value: null
+            }
+        }
+    }
+}
+
+export const ${name.toLowerCase()} = new ${name}Repository()`;
+// src/database/mariadb/migration.template.js
+var generateMariadbMigration = (name, pluralName, fields) => {
+  const mariaTypes = {
+    string: "VARCHAR(255)",
+    number: "INT",
+    boolean: "BOOLEAN",
+    date: "DATETIME"
+  };
+  const columns = fields.map((field) => {
+    const mariaType = mariaTypes[field.type] || "VARCHAR(255)";
+    return `    ${field.name} ${mariaType}`;
+  }).join(`,
+`);
+  return `import { db } from "../../config"
+
+export async function up() {
+    await db.query(\`
+        CREATE TABLE IF NOT EXISTS ${pluralName.toLowerCase()} (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+${columns},
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+        )
+    \`)
+    
+    console.log('\u2705 Migration ${name} created successfully')
+}
+
+export async function down() {
+    await db.query(\`
+        DROP TABLE IF EXISTS ${pluralName.toLowerCase()}
+    \`)
+    
+    console.log('\u2705 Migration ${name} dropped successfully')
+}
+
+// Jalankan migration
+if (process.argv[2] === 'up') {
+    up()
+        .catch(console.error)
+        .finally(() => process.exit())
+}
+
+if (process.argv[2] === 'down') {
+    down()
+        .catch(console.error)
+        .finally(() => process.exit())
+}`;
+};
+// src/database/sqlite/repository.template.js
+var generateSqliteRepository = (name, pluralName) => `import { db } 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 fields = Object.keys(data)
+            const values = Object.values(data)
+            const placeholders = values.map(() => '?').join(', ')
+            
+            const query = \`
+                INSERT INTO \${this.tableName} 
+                (\${fields.join(', ')}, created_at, updated_at)
+                VALUES (\${placeholders}, datetime('now'), datetime('now'))
+            \`
+            
+            await db.query(query, values)
+            const result = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = last_insert_rowid()\`
+            )
+            
+            return {
+                success: true,
+                message: "${name} created successfully",
+                value: new ${name}(result[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 result = await db.query(\`SELECT * FROM \${this.tableName}\`)
+            
+            return {
+                success: true,
+                value: result.map((row: ${pluralName}) => 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 result = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                value: result[0] ? new ${name}(result[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 fields = Object.keys(data)
+            const values = Object.values(data)
+            const setClause = fields
+                .map(field => \`\${field} = ?\`)
+                .join(', ')
+            
+            const query = \`
+                UPDATE \${this.tableName}
+                SET \${setClause}, updated_at = datetime('now')
+                WHERE id = ?
+            \`
+            
+            await db.query(query, [...values, id])
+            const result = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                message: result[0] ? "${name} updated successfully" : "${name} not found",
+                value: result[0] ? new ${name}(result[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 existing = await db.query(
+                \`SELECT * FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            if (!existing[0]) {
+                return {
+                    success: true,
+                    message: "${name} not found",
+                    value: null
+                }
+            }
+
+            await db.query(
+                \`DELETE FROM \${this.tableName} WHERE id = ?\`,
+                [id]
+            )
+            
+            return {
+                success: true,
+                message: "${name} deleted successfully",
+                value: new ${name}(existing[0]) as ${pluralName}
+            }
+        } catch (error) {
+            return {
+                success: false,
+                message: "Failed to delete ${name.toLowerCase()}",
+                error,
+                value: null
+            }
+        }
+    }
+}
+
+export const ${name.toLowerCase()} = new ${name}Repository()`;
+// src/database/sqlite/migration.template.js
+var generateSqliteMigration = (name, pluralName, fields) => {
+  const sqliteTypes = {
+    string: "TEXT",
+    number: "INTEGER",
+    boolean: "INTEGER",
+    date: "TEXT"
+  };
+  const columns = fields.map((field) => {
+    const sqliteType = sqliteTypes[field.type] || "TEXT";
+    return `    ${field.name} ${sqliteType}`;
+  }).join(`,
+`);
+  return `import { db } from "../../config"
+
+export async function up() {
+    await db.query(\`
+        CREATE TABLE IF NOT EXISTS ${pluralName.toLowerCase()} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+${columns},
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now'))
+        )
+    \`)
+    
+    console.log('\u2705 Migration ${name} created successfully')
+}
+
+export async function down() {
+    await db.query(\`
+        DROP TABLE IF EXISTS ${pluralName.toLowerCase()}
+    \`)
+    
+    console.log('\u2705 Migration ${name} dropped successfully')
+}
+
+// Jalankan migration
+if (process.argv[2] === 'up') {
+    up()
+        .catch(console.error)
+        .finally(() => process.exit())
+}
+
+if (process.argv[2] === 'down') {
+    down()
+        .catch(console.error)
+        .finally(() => process.exit())
+}`;
+};
 export {
+  generateSqliteRepository,
+  generateSqliteMigration,
   generatePostgresRepository,
-  generateMongoRepository
+  generatePostgresMigration,
+  generateMongoRepository,
+  generateMariadbRepository,
+  generateMariadbMigration
 };

package/package.json

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