chore: add the categorizeChanges function (#24)

* fix previous types

* refactor types

* add categorizer function

* fix code smell

* change type name

* fix conflicts

* change types name

Author: aayushmau5

src/categorizeChanges.ts

@@ -0,0 +1,27 @@
+import classifier from './classifier';
+import { Output, DiffOutput, DiffOutputItem } from './types';
+
+/**
+ * Categorize the changes
+ * @param standard The standard object
+ * @param diffs The array of diff changes
+ * @returns The final output containing the diff changes as well as the type of change
+ */
+export default function categorizeChanges(
+  standard: any,
+  diffs: DiffOutput[]
+): Output {
+  // the final output
+  const output: Output = {
+    changes: [],
+  };
+
+  for (const diff of diffs) {
+    const newDiffObject = { ...diff } as DiffOutputItem;
+    const classifierObject = classifier(standard, diff.path);
+    newDiffObject.type = classifierObject[diff.action] || 'unclassified';
+    output.changes.push(newDiffObject);
+  }
+
+  return output;
+}

src/classifier.ts

@@ -3,18 +3,7 @@
 // Also, since we are just using this object to access properties, its safe to disable security check for now.
 
 import { generateClassifierPath } from './helpers/ClassifierHelpers';
-
-const breaking = 'breaking';
-const nonBreaking = 'non-breaking';
-const unclassified = 'unclassified';
-
-type ChangeTypes = typeof breaking | typeof nonBreaking | typeof unclassified;
-
-interface Classifier {
-  add: ChangeTypes;
-  remove: ChangeTypes;
-  edit: ChangeTypes;
-}
+import { Classifier } from './types';
 
 /**
  * Gets the classifier object from the standard object using the provided path
@@ -26,9 +15,9 @@ export default function classifier(standard: any, path: string): Classifier {
   const classifierPath = generateClassifierPath(standard, path);
   if (!classifierPath) {
     return {
-      add: unclassified,
-      remove: unclassified,
-      edit: unclassified,
+      add: 'unclassified',
+      remove: 'unclassified',
+      edit: 'unclassified',
     };
   }
   return standard[classifierPath];

src/helpers/DiffHelpers.ts

@@ -1,18 +1,18 @@
 import { Operation, getValueByPointer } from 'fast-json-patch';
 
-import { DiffOutput, ValueOperation } from '../types';
+import { DiffOutput, ValueOperation, ActionType } from '../types';
 
 /**
  * Formats the action to have one of `add`, `remove` or `edit` values
  * @param {String} action The action performed by the diff library
  * @returns {String} The formatted action output
  */
-export function formatAction(action: string): string {
+export function formatAction(action: string): ActionType {
   if (action === 'replace') {
     return 'edit';
   }
   // since `add` and `remove` are already provided by the library, we don't need to change that.
-  return action;
+  return action as ActionType;
 }
 
 /**

src/types.ts

@@ -1,21 +1,33 @@
 import { ReplaceOperation, AddOperation } from 'fast-json-patch';
 
-type ChangeType = 'breaking' | 'non-breaking' | 'unclassified';
+export type ActionType = 'add' | 'remove' | 'edit';
+
+export type ChangeType = 'breaking' | 'non-breaking' | 'unclassified';
+
+export interface Classifier {
+  add: ChangeType;
+  remove: ChangeType;
+  edit: ChangeType;
+}
+
+export interface OverrideObject {
+  [key: string]: Classifier;
+}
 
 export interface DiffOutput {
-  action: string;
+  action: ActionType;
   path: string;
   isArrayIndex?: boolean;
   before?: any;
   after?: any;
 }
 
-export type OverrideObject = {
-  [key: string]: {
-    add: ChangeType;
-    remove: ChangeType;
-    edit: ChangeType;
-  };
+export type DiffOutputItem = DiffOutput & {
+  type: ChangeType;
 };
 
+export interface Output {
+  changes: DiffOutputItem[];
+}
+
 export type ValueOperation = ReplaceOperation<any> | AddOperation<any>;

test/categorizeChanges.spec.ts

@@ -0,0 +1,23 @@
+import categorizeChanges from '../src/categorizeChanges';
+import { DiffOutput } from '../src/types';
+
+import {
+  standard,
+  inputDiffOutput,
+  finalDiffOutput,
+  finalDiffOutputAsUnclassified,
+} from './fixtures/categorizeChanges.fixtures';
+
+describe('categorizeChanges', () => {
+  test('checks the final output', () => {
+    expect(
+      categorizeChanges(standard, inputDiffOutput as DiffOutput[])
+    ).toStrictEqual(finalDiffOutput);
+  });
+
+  test('returns unclassified when passed with empty standard', () => {
+    expect(
+      categorizeChanges({}, inputDiffOutput as DiffOutput[])
+    ).toStrictEqual(finalDiffOutputAsUnclassified);
+  });
+});

test/fixtures/categorizeChanges.fixtures.ts

@@ -0,0 +1,34 @@
+export const standard = {
+  '/servers': {
+    add: 'non-breaking',
+    remove: 'breaking',
+    edit: 'breaking',
+  },
+};
+
+export const inputDiffOutput = [
+  {
+    action: 'remove',
+    path: '/servers',
+  },
+];
+
+export const finalDiffOutput = {
+  changes: [
+    {
+      action: 'remove',
+      path: '/servers',
+      type: 'breaking',
+    },
+  ],
+};
+
+export const finalDiffOutputAsUnclassified = {
+  changes: [
+    {
+      action: 'remove',
+      path: '/servers',
+      type: 'unclassified',
+    },
+  ],
+};