chore: update compare DB script data sorting logics

Author: darcyYe

.scripts/compare-database.js

@@ -8,6 +8,48 @@ const omit = (object, ...keys) =>
 const omitArray = (arrayOfObjects, ...keys) =>
   arrayOfObjects.map((value) => omit(value, ...keys));
 
+// Exported utility functions for testing
+export const autoCompare = (a, b) => {
+  if (typeof a !== typeof b) {
+    return (typeof a).localeCompare(typeof b);
+  }
+
+  if (typeof a === 'object' && a !== null && b !== null) {
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+
+    for (let i = 0; i < Math.min(aKeys.length, bKeys.length); i++) {
+      if (aKeys[i] !== bKeys[i]) {
+        return aKeys[i].localeCompare(bKeys[i]);
+      }
+      const comparison = autoCompare(a[aKeys[i]], b[bKeys[i]]);
+      if (comparison !== 0) {
+        return comparison;
+      }
+    }
+
+    return aKeys.length - bKeys.length;
+  }
+
+  return String(a).localeCompare(String(b));
+};
+
+export const deepSort = (obj) => {
+  if (Array.isArray(obj)) {
+    return obj.map(deepSort).sort(autoCompare);
+  }
+  
+  if (obj && typeof obj === 'object') {
+    const sorted = {};
+    Object.keys(obj).sort().forEach(key => {
+      sorted[key] = deepSort(obj[key]);
+    });
+    return sorted;
+  }
+  
+  return obj;
+};
+
 const schemas = ['cloud', 'public'];
 const schemasArray = `(${schemas.map((schema) => `'${schema}'`).join(', ')})`;
 
@@ -204,53 +246,18 @@ const queryDatabaseManifest = async (database) => {
   };
 };
 
-const [, , database1, database2] = process.argv;
-
-console.log('Compare database manifest between', database1, 'and', database2);
-
-const manifests = [
-  await queryDatabaseManifest(database1),
-  await queryDatabaseManifest(database2),
-];
-
-tryCompare(...manifests);
-
-const autoCompare = (a, b) => {
-  if (typeof a !== typeof b) {
-    return (typeof a).localeCompare(typeof b);
-  }
-
-  if (typeof a === 'object' && a !== null && b !== null) {
-    const aKeys = Object.keys(a).sort();
-    const bKeys = Object.keys(b).sort();
-
-    for (let i = 0; i < Math.min(aKeys.length, bKeys.length); i++) {
-      if (aKeys[i] !== bKeys[i]) {
-        return aKeys[i].localeCompare(bKeys[i]);
-      }
-      const comparison = autoCompare(a[aKeys[i]], b[bKeys[i]]);
-      if (comparison !== 0) {
-        return comparison;
-      }
-    }
-
-    return aKeys.length - bKeys.length;
-  }
-
-  return String(a).localeCompare(String(b));
-};
-
 const buildSortByKeys = (keys) => (a, b) => {
   const found = keys.find((key) => a[key] !== b[key]);
   return found ? autoCompare(a[found], b[found]) : 0;
 };
 
-const queryDatabaseData = async (database) => {
+const queryDatabaseData = async (database, manifests) => {
   const pool = new pg.Pool({
     database,
     user: 'postgres',
     password: 'postgres',
   });
+
   const result = await Promise.all(
     manifests[0].tables.map(async ({ table_schema, table_name }) => {
       const { rows } = await pool.query(
@@ -262,7 +269,7 @@ const queryDatabaseData = async (database) => {
         const data = omitArray(rows, 'value');
         return [
           table_name,
-          data.sort(buildSortByKeys(Object.keys(data[0] ?? {}))),
+          data.map(deepSort).sort(buildSortByKeys(Object.keys(data[0] ?? {}))),
         ];
       }
 
@@ -281,16 +288,30 @@ const queryDatabaseData = async (database) => {
         'add_on_sku_id'
       );
 
-      return [table_name, data.sort(buildSortByKeys(Object.keys(data[0] ?? {})))];
+      return [table_name, data.map(deepSort).sort(buildSortByKeys(Object.keys(data[0] ?? {})))];
     })
   );
 
   return Object.fromEntries(result);
 };
 
-console.log('Compare database data between', database1, 'and', database2);
+// Only run the main logic when this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [, , database1, database2] = process.argv;
+
+  console.log('Compare database manifest between', database1, 'and', database2);
+
+  const manifests = [
+    await queryDatabaseManifest(database1),
+    await queryDatabaseManifest(database2),
+  ];
 
-tryCompare(
-  await queryDatabaseData(database1),
-  await queryDatabaseData(database2)
-);
+  tryCompare(...manifests);
+
+  console.log('Compare database data between', database1, 'and', database2);
+
+  tryCompare(
+    await queryDatabaseData(database1, manifests),
+    await queryDatabaseData(database2, manifests)
+  );
+}

.scripts/compare-database.test.js

@@ -0,0 +1,183 @@
+/**
+ * Test file for deepSort and autoCompare functions from compare-database.js
+ * 
+ * Usage: node .scripts/compare-database.test.js
+ * 
+ * This file tests the deep sorting functionality that ensures consistent
+ * ordering of arrays and objects in database comparison operations.
+ */
+
+import assert from 'node:assert';
+import { autoCompare, deepSort } from './compare-database.js';
+
+// Test helper function
+const runTest = (testName, testFn) => {
+  try {
+    testFn();
+    console.log(`✅ ${testName}`);
+  } catch (error) {
+    console.error(`❌ ${testName}: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+// Test cases for autoCompare function
+runTest('autoCompare - different types', () => {
+  assert.strictEqual(autoCompare('string', 123) > 0, true); // string > number
+  assert.strictEqual(autoCompare(123, 'string') < 0, true); // number < string
+});
+
+runTest('autoCompare - same primitive types', () => {
+  assert.strictEqual(autoCompare('apple', 'banana') < 0, true);
+  assert.strictEqual(autoCompare('banana', 'apple') > 0, true);
+  assert.strictEqual(autoCompare('apple', 'apple'), 0);
+  assert.strictEqual(autoCompare(1, 2) < 0, true);
+  assert.strictEqual(autoCompare(2, 1) > 0, true);
+  assert.strictEqual(autoCompare(1, 1), 0);
+});
+
+runTest('autoCompare - objects', () => {
+  const obj1 = { a: 1, b: 2 };
+  const obj2 = { a: 1, b: 2 };
+  const obj3 = { a: 1, b: 3 };
+  
+  assert.strictEqual(autoCompare(obj1, obj2), 0);
+  assert.strictEqual(autoCompare(obj1, obj3) < 0, true);
+  assert.strictEqual(autoCompare(obj3, obj1) > 0, true);
+});
+
+// Test cases for deepSort function
+runTest('deepSort - primitive values', () => {
+  assert.strictEqual(deepSort('hello'), 'hello');
+  assert.strictEqual(deepSort(123), 123);
+  assert.strictEqual(deepSort(null), null);
+  assert.strictEqual(deepSort(undefined), undefined);
+});
+
+runTest('deepSort - simple arrays', () => {
+  const input = [3, 1, 2];
+  const expected = [1, 2, 3];
+  const result = deepSort(input);
+  
+  assert.deepStrictEqual(result, expected);
+});
+
+runTest('deepSort - string arrays', () => {
+  const input = ['banana', 'apple', 'cherry'];
+  const expected = ['apple', 'banana', 'cherry'];
+  const result = deepSort(input);
+  
+  assert.deepStrictEqual(result, expected);
+});
+
+runTest('deepSort - nested arrays', () => {
+  const input = [[3, 1], [2, 4], [1, 2]];
+  const expected = [[1, 2], [1, 3], [2, 4]];
+  const result = deepSort(input);
+  
+  assert.deepStrictEqual(result, expected);
+});
+
+runTest('deepSort - simple objects', () => {
+  const input = { c: 3, a: 1, b: 2 };
+  const expected = { a: 1, b: 2, c: 3 };
+  const result = deepSort(input);
+  
+  assert.deepStrictEqual(result, expected);
+});
+
+runTest('deepSort - objects with arrays', () => {
+  const input = {
+    name: 'test',
+    items: [3, 1, 2],
+    tags: ['beta', 'alpha']
+  };
+  const expected = {
+    items: [1, 2, 3],
+    name: 'test',
+    tags: ['alpha', 'beta']
+  };
+  const result = deepSort(input);
+  
+  assert.deepStrictEqual(result, expected);
+});
+
+runTest('deepSort - arrays with objects', () => {
+  const input = [
+    { name: 'Bob', age: 25 },
+    { name: 'Alice', age: 30 },
+    { name: 'Charlie', age: 20 }
+  ];
+  // Objects are sorted by their keys and values in lexicographic order
+  // First by 'age' key, then by 'name' key
+  const expected = [
+    { age: 20, name: 'Charlie' },
+    { age: 25, name: 'Bob' },
+    { age: 30, name: 'Alice' }
+  ];
+  const result = deepSort(input);
+  
+  assert.deepStrictEqual(result, expected);
+});
+
+runTest('deepSort - complex nested structure', () => {
+  const input = {
+    users: [
+      {
+        name: 'Bob',
+        roles: ['admin', 'user'],
+        metadata: { created: '2023-01-01', active: true }
+      },
+      {
+        name: 'Alice',
+        roles: ['user', 'editor'],
+        metadata: { created: '2023-01-02', active: false }
+      }
+    ],
+    config: {
+      version: '1.0',
+      features: ['auth', 'logging', 'api']
+    }
+  };
+  
+  const expected = {
+    config: {
+      features: ['api', 'auth', 'logging'],
+      version: '1.0'
+    },
+    users: [
+      {
+        metadata: { active: false, created: '2023-01-02' },
+        name: 'Alice',
+        roles: ['editor', 'user']
+      },
+      {
+        metadata: { active: true, created: '2023-01-01' },
+        name: 'Bob',
+        roles: ['admin', 'user']
+      }
+    ]
+  };
+  
+  const result = deepSort(input);
+  assert.deepStrictEqual(result, expected);
+});
+
+runTest('deepSort - empty structures', () => {
+  assert.deepStrictEqual(deepSort([]), []);
+  assert.deepStrictEqual(deepSort({}), {});
+  // Empty array comes before empty object in autoCompare logic
+  assert.deepStrictEqual(deepSort([[], {}]), [[], {}]);
+});
+
+runTest('deepSort - mixed types in array', () => {
+  const input = [{ b: 2 }, 'string', 1, { a: 1 }];
+  // Type order in autoCompare: number < object < string
+  // Objects are sorted by their content
+  const expected = [1, { a: 1 }, { b: 2 }, 'string'];
+  const result = deepSort(input);
+  
+  assert.deepStrictEqual(result, expected);
+});
+
+console.log('\n🎉 All tests passed!');