zet-lib 1.5.13 → 1.5.14

package/lib/connection.js

@@ -324,7 +324,7 @@ connection.delete = async (obj) => {
   }
   wherequery = arr.length ? wherequery.join(' AND ') : ''
   const wheres = arr.length ? ' WHERE ' + wherequery : ''
-  const sql = `DELETE FROM "${table}" ${wheres}`
+  const sql = `DELETE FROM "${table}" ${wheres} RETURNING *`
   /*console.log(sql);
     console.log(arr)*/
   try {
@@ -337,14 +337,114 @@ connection.delete = async (obj) => {
   }
 }
 
+connection.insertData = async(tableName, data) => {
+  let pgPool;
+  try {
+    // Validasi input
+    if (!data || typeof data !== 'object') {
+      throw new Error('Invalid data provided for insert');
+    }
+
+    pgPool = new Pool(configPG);
+    
+    const columns = Object.keys(data);
+    if (columns.length === 0) {
+      throw new Error('No columns found in the data object');
+    }
+
+    const placeholders = columns.map((_, index) => `$${index + 1}`).join(',');
+    const insertQuery = `
+            INSERT INTO "${tableName}" (${columns.map(col => `"${col}"`).join(',')})
+            VALUES (${placeholders})
+            RETURNING *
+        `;
+    const values = columns.map(col => data[col]);
+    const result = await pgPool.query(insertQuery, values);
+    console.log(`Successfully inserted 1 record into ${tableName}`);
+    return result.rows[0];
+  } catch (error) {
+    console.error(`Error inserting record into ${tableName}:`, error);
+    throw error;
+  } finally {
+    if (pgPool) {
+      await pgPool.end();
+    }
+  }
+}
+
+connection.deleteData = async(tableName, where) => {
+  let pgPool;
+  try {
+    // Validasi input
+    if (!where || typeof where !== 'object') {
+      throw new Error('Invalid where clause provided for delete');
+    }
+
+    pgPool = new Pool(configPG);
+    
+    const whereColumns = Object.keys(where);
+    if (whereColumns.length === 0) {
+      throw new Error('No where conditions provided for delete');
+    }
+
+    const whereConditions = whereColumns.map((col, index) => `"${col}" = $${index + 1}`).join(' AND ');
+    const deleteQuery = `
+            DELETE FROM "${tableName}"
+            WHERE ${whereConditions}
+            RETURNING *
+        `;
+    const values = whereColumns.map(col => where[col]);
+    const result = await pgPool.query(deleteQuery, values);
+    console.log(`Successfully deleted ${result.rowCount} records from ${tableName}`);
+    return result.rowCount;
+  } catch (error) {
+    console.error(`Error deleting records from ${tableName}:`, error);
+    throw error;
+  } finally {
+    if (pgPool) {
+      await pgPool.end();
+    }
+  }
+}
+
 connection.insertMultipleRecords = async(tableName,records) => {
   let pgPool;
   try {
+    // Validasi input
+    if (!records || !Array.isArray(records) || records.length === 0) {
+      console.warn(`No records to insert into ${tableName}`);
+      return [];
+    }
+
     pgPool = new Pool(configPG);
-    const columns = Object.keys(records[0]);
+    
+    // Validasi bahwa semua records memiliki struktur yang sama
+    const firstRecord = records[0];
+    if (!firstRecord || typeof firstRecord !== 'object') {
+      throw new Error('First record is invalid or empty');
+    }
+    
+    const columns = Object.keys(firstRecord);
+    if (columns.length === 0) {
+      throw new Error('No columns found in the first record');
+    }
+
+    // Validasi bahwa semua records memiliki kolom yang sama
+    for (let i = 1; i < records.length; i++) {
+      const record = records[i];
+      if (!record || typeof record !== 'object') {
+        throw new Error(`Record at index ${i} is invalid`);
+      }
+      const recordColumns = Object.keys(record);
+      if (recordColumns.length !== columns.length || !recordColumns.every(col => columns.includes(col))) {
+        throw new Error(`Record at index ${i} has different structure than the first record`);
+      }
+    }
+
     const placeholders = records.map((_, rowIndex) =>
         `(${columns.map((_, colIndex) => `$${rowIndex * columns.length + colIndex + 1}`).join(',')})`
     ).join(',');
+    
     // Create the INSERT query
     const insertQuery = `
             INSERT INTO "${tableName}" (${columns.map(col => `"${col}"`).join(',')})
@@ -353,7 +453,7 @@ connection.insertMultipleRecords = async(tableName,records) => {
         `;
     const values = records.flatMap(record => columns.map(col => record[col]));
     const result = await pgPool.query(insertQuery, values);
-    //console.log(`Successfully inserted ${records.length} records into ${tableName}`);
+    console.log(`Successfully inserted ${records.length} records into ${tableName}`);
     return result.rows;
   } catch (error) {
     console.error(`Error inserting multiple records into ${tableName}:`, error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zet-lib",
-  "version": "1.5.13",
+  "version": "1.5.14",
   "description": "zet is a library that part of zet generator.",
   "engines": {
     "node": ">=18"