feat(migration-scripts) add core_store cleanup

Author: FotisVasilopoulos

sql-blueprinting/index.js

@@ -1,6 +1,6 @@
-import mysql from "mysql2";
-import chalk from "chalk";
-import { config } from "dotenv";
+import mysql from 'mysql2';
+import chalk from 'chalk';
+import { config } from 'dotenv';
 
 config();
 
@@ -18,12 +18,12 @@ const connection = mysql.createConnection({
 connection.connect((err) => {
   if (err) throw err;
 
-  console.log("Connected to database!");
+  console.log('Connected to database!');
 
   const getTables = (db) => {
     return new Promise((resolve, reject) => {
       connection.query(
-        "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?",
+        'SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?',
         [db],
         (err, tables) => {
           if (err) reject(err);
@@ -33,23 +33,21 @@ connection.connect((err) => {
     });
   };
 
-  const dropTable = (table) => {
+  const dropTable = (db, table) => {
     return new Promise((resolve, reject) => {
-      connection.query(
-        `DROP TABLE IF EXISTS ${db2}.??`,
-        [table],
-        (err, res) => {
-          if (err) reject(err);
-          return resolve(res);
-        }
-      );
+      connection.query(`DROP TABLE IF EXISTS ??.??`, [db, table], (err, res) => {
+        if (err) reject(err);
+        return resolve(
+          `The table ${chalk.bold.redBright(table)} does not exists in both databases. Dropping...`
+        );
+      });
     });
   };
 
   const getColumns = (db, table) => {
     return new Promise((resolve, reject) => {
       connection.query(
-        "SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?",
+        'SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?',
         [db, table],
         (err, columns) => {
           if (err) reject(err);
@@ -59,53 +57,46 @@ connection.connect((err) => {
     });
   };
 
-  const dropColumn = (table, column) => {
-    console.log("droping column: " + column + " from table" + table);
+  const dropColumn = (db, table, column) => {
     return new Promise((resolve, reject) => {
-      connection.query(
-        `ALTER TABLE ${db2}.?? DROP COLUMN ??`,
-        [table, column],
-        (err, res) => {
-          if (err) reject(err);
-          return resolve(res);
-        }
-      );
+      connection.query(`ALTER TABLE ??.?? DROP COLUMN ??`, [db, table, column], (err, res) => {
+        if (err) reject(err);
+        return resolve(
+          `The column ${chalk.bold.redBright(
+            column
+          )} does not exists in both ${chalk.bold.redBright(table)} tables. Dropping...`
+        );
+      });
     });
   };
 
-  const getData = (targetTableName) => {
+  const dropRow = (db, table, column, value) => {
     return new Promise((resolve, reject) => {
-      connection.query(
-        `SELECT * FROM ${db2}.?`,
-        [targetTableName],
-        (err, columns) => {
-          if (err) reject(err);
-          return resolve(columns);
-        }
-      );
+      connection.query(`DELETE FROM ??.?? WHERE ?? = ?`, [db, table, column, value], (err, res) => {
+        if (err) reject(err);
+        return resolve(
+          `The row ${chalk.bold.redBright(value)} does not exists in both ${chalk.bold.redBright(
+            table
+          )} tables. Dropping...`
+        );
+      });
     });
   };
 
-  const setData = (columns, targetTableName) => {
+  const toggleForeignKeyCheck = (state) => {
     return new Promise((resolve, reject) => {
-      columns.forEach((entry) => {
-        connection.query(
-          `INSERT INTO ${db1}.? VALUES (?) `,
-          [targetTableName, entry],
-          (err, results) => {
-            if (err) reject(err);
-            return resolve(results);
-          }
-        );
+      connection.query(`SET FOREIGN_KEY_CHECKS = ${state}`, (err, results) => {
+        if (err) reject(err);
+        return resolve('Foreign Key Check is set to ' + state + '!');
       });
     });
   };
 
-  const toggleForeignKeyCheck = (state) => {
+  const getCoreStore = (db) => {
     return new Promise((resolve, reject) => {
-      connection.query(`SET FOREIGN_KEY_CHECKS = ${state}`, (err, results) => {
+      connection.query('SELECT * FROM ??.core_store', [db], (err, coreStore) => {
         if (err) reject(err);
-        return resolve("Foreign Key Check is set to " + state + "!");
+        return resolve(coreStore);
       });
     });
   };
@@ -123,66 +114,63 @@ connection.connect((err) => {
         tableNames_db2.forEach(async (table_db2, tableIndex) => {
           let tableExistanceFlag = false;
           let targetTableName = table_db2.TABLE_NAME;
-
           tableNames_db1.forEach((table_db1) => {
             if (targetTableName === table_db1.TABLE_NAME) {
               tableExistanceFlag = true;
             }
           });
-          if (tableExistanceFlag) {
+          if (tableExistanceFlag && targetTableName !== 'core_store') {
+            console.log(
+              `The table ${chalk.bold.greenBright(targetTableName)} exists in both databases.`
+            );
             const columns_db1 = await getColumns(db1, targetTableName);
             const columns_db2 = await getColumns(db2, targetTableName);
-            let columnsCountEquality = false;
-            if (columns_db1.length === columns_db2.length) {
-              columnsCountEquality = true;
-            } else {
-              columns_db2.forEach(async (column_db2) => {
-                let columnExistanceFlag = false;
-                let columnNameDB2 = column_db2.COLUMN_NAME;
+            columns_db2.forEach(async (column_db2) => {
+              let columnExistanceFlag = false;
+              let columnNameDB2 = column_db2.COLUMN_NAME;
 
-                columns_db1.forEach((column_db1) => {
-                  if (columnNameDB2 === column_db1.COLUMN_NAME) {
-                    columnExistanceFlag = true;
-                  }
-                });
-                if (!columnExistanceFlag) {
-                  await dropColumn(targetTableName, columnNameDB2);
+              columns_db1.forEach((column_db1) => {
+                if (columnNameDB2 === column_db1.COLUMN_NAME) {
+                  columnExistanceFlag = true;
                 }
               });
-            }
-            console.log(
-              `The table ${chalk.bold.greenBright(
-                targetTableName
-              )} exists in both databases ${
-                columnsCountEquality
-                  ? "and columns count " +
-                    chalk.bold.greenBright("is equal") +
-                    "."
-                  : "but columns count " +
-                    chalk.bold.redBright("is not equal") +
-                    "."
-              }`
-            );
+              if (!columnExistanceFlag) {
+                const dropColumnMsg = await dropColumn(db2, targetTableName, columnNameDB2);
+                console.log(dropColumnMsg);
+              }
+            });
+          } else if (targetTableName === 'core_store') {
+            const coreStore1 = await getCoreStore(db1);
+            const coreStore2 = await getCoreStore(db2);
+            coreStore2.forEach(async (coreStore2Item) => {
+              let coreStoreExistanceFlag = false;
+              let coreStore2ItemKey = coreStore2Item.key;
+              coreStore1.forEach((coreStore1Item) => {
+                if (coreStore2ItemKey === coreStore1Item.key) {
+                  coreStoreExistanceFlag = true;
+                }
+              });
+              if (!coreStoreExistanceFlag) {
+                const dropRowMsg = await dropRow(db2, targetTableName, 'key', coreStore2ItemKey);
+                console.log(dropRowMsg);
+              }
+            });
           } else {
-            console.log(
-              `The table ${chalk.bold.redBright(
-                targetTableName
-              )} does not exists in both databases`
-            );
-            await dropTable(targetTableName);
+            const dropTableMsg = await dropTable(db2, targetTableName);
+            console.log(dropTableMsg);
           }
           if (tableIndex === tableNames_db2.length - 1) {
             resolve();
           }
         });
       });
       foreignKeyCheckState = 1;
-      toggleForeignKeyCheck(foreignKeyCheckState).then((res) =>
-        console.log(chalk.bold.yellowBright(res))
-      );
-
-      console.log("Database cleanup is done, closing connection...");
-      connection.end();
+      toggleForeignKeyCheck(foreignKeyCheckState)
+        .then((res) => console.log(chalk.bold.yellowBright(res)))
+        .then(() => {
+          console.log('Database cleanup is done, closing connection...');
+          connection.end();
+        });
     } catch (err) {
       console.log(err);
     }