README.md

@@ -225,11 +225,128 @@ Only the columns specified in the `structure` object will be exported from the `
 
     export() // get the joined data from the Nodule
 
-## GroupByNodule
+## GroupByNodule (Experimental)
 
-The `GroupByNodule` class can take in `Table`s and a single value of `groupByValue` to group rows by a table header. On `export()` this will return an object with keys representing an array of objects (or `rows`)
+<small>This Nodule is experimental and subject to frequent changes.</small>
 
-The `asTable()` method is overloaded and actually returns an array of new `Table` instances, operating differently than the `Nodule` base class `asTable()`
+The `GroupByNodule` is a sub-class from `Nodule` and can take in `Table`s and a single string value of `groupByValue` to group rows by a table header. Lets use this `Table` and this `Nodule` as our example input data:
+
+```
+const table = new Table({
+  id: 'XYZ',
+  label: 'Test Table',
+  rows: [
+    { id: 'abc', data: 'row', contractor: 'AshBritt' },
+    { id: 'qwe', data: 'lh', contractor: 'AshBritt' },
+    { id: 'XYZ', data: 'row', contractor: 'AshBritt' },
+    { id: 'XYZ', data: 'row', contractor: 'HeyDay' },
+  ]
+})
+
+const groupByNodule = new GroupByNodule({
+  id: 'ABC',
+  label: 'Test Group By',
+  tables: [table],
+  groupByValue: 'contractor'
+})
+```
+
+### GroupByNodule Methods
+
+The `Nodule` base class declares an `abstract export () : tableRows`, as well as a base method `asTable (): Table`, yet the `GroupByNodule` subclass does not implement these methods the same as other derivatives of `Nodule`. 
+
+In this subclass, there is no return for these methods and an error is thrown. The way data is mutated is a fundamental deviation from other nodules. The `GroupByNodule` is for categorically separating data out, therefore a single set of `rows` or a singular `Table` is not a sufficient return type.
+
+Instead, either groups of `rows` or multiple `Table`s are exported. Two new methods are implemented in this subclass to function in a similar way.
+
+
+#### exportRowGroups()
+```
+// TS Types
+type tableRow = Record<string, unknown>
+type groupedByRows = Record<string, tableRow[]>
+exportRowGroups (): groupedByRows
+
+// JS implementation
+const groupedRows = groupByNodule.exportRowGroups()
+
+/* 
+expected output based on example above:
+{
+  AshBritt: [
+    { id: 'abc', data: 'row', contractor: 'AshBritt' },
+    { id: 'qwe', data: 'lh', contractor: 'AshBritt' },
+    { id: 'XYZ', data: 'row', contractor: 'AshBritt' }
+  ],
+  HeyDay: [
+    { id: 'XYZ', data: 'row', contractor: 'HeyDay' }
+  ]
+}
+*/
+
+```
+
+#### asTables()
+```
+// TS Type
+asTables = (): Table[]
+
+// JS implementation
+const groupedTables = groupByNodule.asTables()
+
+/*
+expected output based on example above:
+
+    {
+      id: 'ABC-AshBritt',
+      label: 'Test Group by AshBritt',
+      rows: [
+        { id: 'abc', data: 'row', contractor: 'AshBritt' },
+        { id: 'qwe', data: 'lh', contractor: 'AshBritt' },
+        { id: 'XYZ', data: 'row', contractor: 'AshBritt' }
+      ],
+      headers: [ 'id', 'data', 'contractor' ],
+      type: 'Table',
+      isValid: true
+    },
+    {
+      id: 'ABC-HeyDay',
+      label: 'Test Group by HeyDay',
+      rows: [
+        { id: 'XYZ', data: 'row', contractor: 'HeyDay' }
+      ],
+      headers: [ 'id', 'data', 'contractor' ],
+      type: 'Table',
+      isValid: true
+    }
+  ]
+*/
+
+```
+
+## SortNodule (Experimental)
+<small>This Nodule is experimental and subject to frequent changes.</small>
+
+The `SortNodule` does one simple task, sort rows based off on particular property/header.
+
+This nodule takes in three new props on top of the properties of the base class:
+
+`sortValueType: 'ALPHABETIC' | 'NUMERIC'` is used to determine if the sorting is based on number or letters.
+
+`sortDirection: 'ASCENDING' | 'DESCENDING'` is used to determine the order of the sorting.
+
+`sortKey: string` is which property/header tha the sorting will be performed on.
+
+```
+const sortNodule = new SortNodule({
+  id: 'ABC',
+  label: 'Test Nodule',
+  tables: [table],
+  sortValueType: 'ALPHABETIC',
+  sortDirection: 'DESCENDING',
+  sortKey: 'contractor'
+})
+```
 
 ## Constant Values
 
@@ -237,15 +354,32 @@ A set of declared constant variables has been provided for safer typing. Althoug
 
 Filter types for the `FilterNodule` can be one of only these five string values.
 
-    {
+```
+const filterTypes = {
   EQUAL: 'EQUAL',
   GREATER: 'GREATER',
   GREATEREQUAL: 'GREATEREQUAL',
   LESSER: 'LESSER',
   LESSEREQUAL: 'LESSEREQUAL',
-    }
+}
+
+```
+
+`SortNodule` constants are as follows:
+
+```
+const sortDirections = {
+  ASCENDING: 'ASCENDING',
+  DESCENDING: 'DESCENDING'
+}
+
+const sortValueTypes = {
+  NUMERIC: 'NUMERIC',
+  ALPHABETIC: 'ALPHABETIC'
+}
+```
 
 # Notes
-This library is in its early stages, and improvements are to come. The main priority being speed and readability when using the options in these classes. Extra features are not the priority, but will be worked on. Adding features is agains the philosophy of this project however. Lovelacejs is to be a powerful building block to making dynamic and programatic data mutation. It is to be a tool to help craft software, not a wall that gets in the way of work.
+This library is in its early stages, and improvements are to come. The main priority currently is readability. Experimental features, which are labeled as such, will likely change functionality and naming.
 
-If you have any questions or issues please open one up or reach out to me at `joshua@jshoemaker.dev`
+Goals moving forward are to finalize the experimental features and try to move the core of the code base to WASM with Go and a JS/TS api.

lib/constants/sortTypes.d.ts

@@ -0,0 +1,9 @@
+declare const sortDirections: {
+    ASCENDING: string;
+    DESCENDING: string;
+};
+declare const sortValueTypes: {
+    NUMERIC: string;
+    ALPHABETIC: string;
+};
+export { sortDirections, sortValueTypes };

lib/constants/sortTypes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortValueTypes = exports.sortDirections = void 0;
+const sortDirections = {
+    ASCENDING: 'ASCENDING',
+    DESCENDING: 'DESCENDING'
+};
+exports.sortDirections = sortDirections;
+const sortValueTypes = {
+    NUMERIC: 'NUMERIC',
+    ALPHABETIC: 'ALPHABETIC'
+};
+exports.sortValueTypes = sortValueTypes;

lib/entities/nodules/FilterNodule.d.ts

@@ -5,7 +5,7 @@ declare class FilterNodule extends Nodule {
     filterParams: filterParams;
     constructor(props: filterNoduleConstructionProps);
     addFilter: (params: filterParams) => void;
-    setFilterType: (filterType: filterType) => void;
+    setFilterType: (filterType: string) => void;
     export: () => import("../../types/tableTypes").tableRow[];
     private createFilterMethods;
     private validateFilters;

lib/entities/nodules/GroupByNodule.d.ts

@@ -7,7 +7,7 @@ declare class GroupByNodule extends Nodule {
     asTables: () => Table[];
     asTable: () => never;
     export: () => never;
-    exportTables: () => groupedByRows;
+    exportRowGroups: () => groupedByRows;
     setGroupByValue: (value: string) => void;
     private validateGroupByValue;
 }

lib/entities/nodules/GroupByNodule.js

@@ -10,7 +10,7 @@ class GroupByNodule extends Nodule_1.default {
             this.setGroupByValue(props.groupByValue);
     }
     asTables = () => {
-        const exports = this.exportTables();
+        const exports = this.exportRowGroups();
         const tables = [];
         for (let key in exports) {
             const newTableProps = {
@@ -29,7 +29,7 @@ class GroupByNodule extends Nodule_1.default {
     export = () => {
         throw new Error('"export()" can not be called by GroupByNodule. Call "exportTables()"');
     };
-    exportTables = () => {
+    exportRowGroups = () => {
         const { groupByValue } = this;
         const rows = this.tables.map(t => t.export()).flat();
         const groupedByRows = rows.reduce((groups, r) => {

lib/entities/nodules/SortNodule.d.ts

@@ -0,0 +1,11 @@
+import { sortDirection, sortKey, sortNoduleConstructorProps, sortValueType } from '../../types/noduleTypes';
+import { tableRow } from '../../types/tableTypes';
+import Nodule from '../Nodule';
+declare class SortNodule extends Nodule {
+    sortValueType: sortValueType;
+    sortDirection: sortDirection;
+    sortKey: sortKey;
+    constructor(props: sortNoduleConstructorProps);
+    export: () => tableRow[];
+}
+export default SortNodule;

lib/entities/nodules/SortNodule.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sortTypes_1 = require("../../constants/sortTypes");
+const Nodule_1 = require("../Nodule");
+class SortNodule extends Nodule_1.default {
+    sortValueType = sortTypes_1.sortValueTypes.ALPHABETIC;
+    sortDirection = sortTypes_1.sortDirections.ASCENDING;
+    sortKey = '';
+    constructor(props) {
+        super(props);
+        const { sortValueType, sortDirection, sortKey } = props;
+        if (sortValueType)
+            this.sortValueType = sortValueType;
+        if (sortDirection)
+            this.sortDirection = sortDirection;
+        if (sortKey)
+            this.sortKey = sortKey;
+    }
+    export = () => {
+        const { sortValueType, sortDirection, sortKey } = this;
+        const { NUMERIC } = sortTypes_1.sortValueTypes;
+        const { DESCENDING } = sortTypes_1.sortDirections;
+        let sortMethod;
+        if (sortValueType === NUMERIC)
+            sortMethod = (a, b) => {
+                const aValue = a[sortKey];
+                const bValue = b[sortKey];
+                return aValue - bValue;
+            };
+        else
+            sortMethod = (a, b) => {
+                const aValue = a[sortKey];
+                const bValue = b[sortKey];
+                return aValue.toLowerCase().localeCompare(bValue.toLowerCase());
+            };
+        let rows = this.tables.map(t => t.export()).flat().sort(sortMethod);
+        if (sortDirection === DESCENDING)
+            rows = rows.reverse();
+        return rows;
+    };
+}
+exports.default = SortNodule;

lib/entities/nodules/TransformNodule.js

@@ -30,7 +30,7 @@ class TransformNodule extends Nodule_1.default {
         const err = {
             status: 'ERR',
             error: {
-                label: 'Ptructure Parameters are not valid',
+                label: 'Structure Parameters are not valid',
                 messages: []
             }
         };

lib/types/noduleTypes.d.ts

@@ -1,3 +1,5 @@
+import filterTypes from "../constants/filterTypes";
+import { sortValueTypes, sortDirections } from "../constants/sortTypes";
 import Table from "../entities/Table";
 import { tableRow } from "./tableTypes";
 declare type noduleConstructorProps = {
@@ -6,7 +8,9 @@ declare type noduleConstructorProps = {
     type?: 'Nodule';
     tables?: Table[];
 };
-declare type filterType = 'EQUAL' | 'GREATER' | 'GREATEREQUAL' | 'LESSER' | 'LESSEREQUAL';
+declare type filterKeys = keyof typeof filterTypes;
+declare type filterValues = typeof filterTypes[filterKeys];
+declare type filterType = filterValues;
 declare type filterParams = Record<string, string | number>;
 declare type filterNoduleConstructionProps = noduleConstructorProps & {
     filterType: filterType;
@@ -33,4 +37,16 @@ declare type groupByNoduleConstructorProps = noduleConstructorProps & {
     groupByValue: string;
 };
 declare type groupedByRows = Record<string, tableRow[]>;
-export { noduleConstructorProps, filterNoduleConstructionProps, filterType, filterParams, joinParam, joinBy, joinNoduleConstructionProps, transformStruct, transformNoduleConstructionProps, groupByNoduleConstructorProps, groupedByRows };
+declare type sortDirectionKeys = keyof typeof sortDirections;
+declare type sortDirectionValues = typeof sortDirections[sortDirectionKeys];
+declare type sortDirection = sortDirectionValues;
+declare type sortValueTypeKeys = keyof typeof sortValueTypes;
+declare type sortValueTypeValues = typeof sortValueTypes[sortValueTypeKeys];
+declare type sortValueType = sortValueTypeValues;
+declare type sortKey = string;
+declare type sortNoduleConstructorProps = noduleConstructorProps & {
+    sortDirection: sortDirection;
+    sortValueType: sortValueType;
+    sortKey: sortKey;
+};
+export { noduleConstructorProps, filterNoduleConstructionProps, filterType, filterParams, joinParam, joinBy, joinNoduleConstructionProps, transformStruct, transformNoduleConstructionProps, groupByNoduleConstructorProps, groupedByRows, sortDirection, sortValueType, sortKey, sortNoduleConstructorProps, };

src/constants/sortTypes.ts

@@ -0,0 +1,11 @@
+const sortDirections = {
+  ASCENDING: 'ASCENDING',
+  DESCENDING: 'DESCENDING'
+}
+
+const sortValueTypes = {
+  NUMERIC: 'NUMERIC',
+  ALPHABETIC: 'ALPHABETIC'
+}
+
+export { sortDirections, sortValueTypes }

src/entities/nodules/GroupByNodule.ts

@@ -13,7 +13,7 @@ class GroupByNodule extends Nodule {
   }
 
   asTables = (): Table[] => {
-    const exports = this.exportTables()
+    const exports = this.exportRowGroups()
     const tables = []
     for (let key in exports) {
       const newTableProps: tableConstructorProps = {
@@ -35,7 +35,7 @@ class GroupByNodule extends Nodule {
     throw new Error('"export()" can not be called by GroupByNodule. Call "exportTables()"')
   }
 
-  exportTables = (): groupedByRows => {
+  exportRowGroups = (): groupedByRows => {
     const { groupByValue } = this
     const rows = this.tables.map(t => t.export() ).flat()
     const groupedByRows = rows.reduce((groups: groupedByRows, r) => {

src/entities/nodules/SortNodule.ts

@@ -0,0 +1,44 @@
+import { sortDirections, sortValueTypes } from '../../constants/sortTypes'
+import { sortDirection, sortKey, sortNoduleConstructorProps, sortValueType } from '../../types/noduleTypes'
+import { tableRow } from '../../types/tableTypes'
+import Nodule from '../Nodule'
+
+class SortNodule extends Nodule {
+  sortValueType: sortValueType = sortValueTypes.ALPHABETIC
+  sortDirection: sortDirection = sortDirections.ASCENDING
+  sortKey: sortKey = ''
+
+  constructor (props: sortNoduleConstructorProps) {
+    super(props)
+    const { sortValueType, sortDirection, sortKey } = props
+    if (sortValueType) this.sortValueType = sortValueType
+    if (sortDirection) this.sortDirection = sortDirection
+    if (sortKey) this.sortKey = sortKey
+  }
+  
+  export = () => {
+    const { sortValueType, sortDirection, sortKey } = this
+    const { NUMERIC } = sortValueTypes
+    const { DESCENDING } = sortDirections
+
+    let sortMethod
+    if (sortValueType === NUMERIC) sortMethod = (a: tableRow, b: tableRow) => {
+      const aValue = a[sortKey] as number
+      const bValue = b[sortKey] as number
+      return aValue - bValue
+    }
+    else sortMethod = (a: tableRow, b: tableRow) => {
+      const aValue = a[sortKey] as string
+      const bValue = b[sortKey] as string
+      return aValue.toLowerCase().localeCompare(bValue.toLowerCase())
+    }
+
+    let rows = this.tables.map(t => t.export()).flat().sort(sortMethod)
+
+    if (sortDirection === DESCENDING) rows = rows.reverse()
+
+    return rows
+  }
+}
+
+export default SortNodule

src/entities/nodules/TransformNodule.ts

@@ -34,7 +34,7 @@ class TransformNodule extends Nodule {
     const err: errType = {
       status: 'ERR',
       error: {
-        label: 'Ptructure Parameters are not valid',
+        label: 'Structure Parameters are not valid',
         messages: []
       }
     }

src/types/noduleTypes.ts

@@ -1,4 +1,5 @@
 import filterTypes from "../constants/filterTypes"
+import { sortValueTypes, sortDirections } from "../constants/sortTypes"
 import Table from "../entities/Table"
 import { tableRow } from "./tableTypes"
 
@@ -26,6 +27,17 @@ type groupByNoduleConstructorProps = noduleConstructorProps & { groupByValue: st
 
 type groupedByRows = Record<string, tableRow[]>
 
+type sortDirectionKeys = keyof typeof sortDirections
+type sortDirectionValues = typeof sortDirections[sortDirectionKeys]
+type sortDirection = sortDirectionValues
+
+type sortValueTypeKeys = keyof typeof  sortValueTypes
+type sortValueTypeValues = typeof sortValueTypes[sortValueTypeKeys]
+type sortValueType = sortValueTypeValues
+type sortKey = string
+
+type sortNoduleConstructorProps = noduleConstructorProps & { sortDirection: sortDirection, sortValueType: sortValueType, sortKey: sortKey }
+
 export {
   noduleConstructorProps,
   filterNoduleConstructionProps,
@@ -37,5 +49,9 @@ export {
   transformStruct,
   transformNoduleConstructionProps,
   groupByNoduleConstructorProps,
-  groupedByRows
+  groupedByRows,
+  sortDirection,
+  sortValueType,
+  sortKey,
+  sortNoduleConstructorProps,
 }

tests/core/nodules/groupByNoduleTests.js

@@ -42,7 +42,7 @@ const groupByTest = () => {
     return false
   }
 
-  const groupedRows = groupByNodule.exportTables()
+  const groupedRows = groupByNodule.exportRowGroups()
   if (JSON.stringify(groupedRows) === JSON.stringify(expectedOutput)) {
     return true
   } else {

tests/core/nodules/sortNoduleTests.js

@@ -0,0 +1,198 @@
+import SortNodule from '../../../src/entities/nodules/SortNodule'
+import Table from '../../../src/entities/Table'
+
+const sortNumericAscending = () => {
+  const expectedOutput = [
+    { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+    { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+    { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+    { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+  ]
+
+  let table = {}
+  try {
+    table = new Table({
+      id: 'XYZ',
+      label: 'Test Table',
+      rows: [
+        { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+        { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+        { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+        { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+      ]
+    })
+  } catch (err) {
+    return false
+  }
+
+  let sortNodule = {}
+  try {
+    sortNodule = new SortNodule({
+      id: 'ABC',
+      label: 'Test Nodule',
+      tables: [table],
+      sortValueType: 'NUMERIC',
+      sortDirection: 'ASCENDING',
+      sortKey: 'someNumber'
+    })
+  } catch (err) {
+    console.log(err)
+    return false
+  }
+
+  const sortedRows = sortNodule.export()
+  if (JSON.stringify(sortedRows) === JSON.stringify(expectedOutput)) {
+    return true
+  } else {
+    return false
+  }
+}
+
+const sortNumericDesscending = () => {
+  const expectedOutput = [
+    { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+    { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+    { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+    { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+  ]
+
+  let table = {}
+  try {
+    table = new Table({
+      id: 'XYZ',
+      label: 'Test Table',
+      rows: [
+        { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+        { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+        { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+        { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+      ]
+    })
+  } catch (err) {
+    return false
+  }
+
+  let sortNodule = {}
+  try {
+    sortNodule = new SortNodule({
+      id: 'ABC',
+      label: 'Test Nodule',
+      tables: [table],
+      sortValueType: 'NUMERIC',
+      sortDirection: 'DESCENDING',
+      sortKey: 'someNumber'
+    })
+  } catch (err) {
+    console.log(err)
+    return false
+  }
+
+  const sortedRows = sortNodule.export()
+  if (JSON.stringify(sortedRows) === JSON.stringify(expectedOutput)) {
+    return true
+  } else {
+    return false
+  }
+}
+
+const sortAlphabeticAscending = () => {
+  const expectedOutput = [
+    { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+    { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+    { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+    { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+  ]
+
+  let table = {}
+  try {
+    table = new Table({
+      id: 'XYZ',
+      label: 'Test Table',
+      rows: [
+        { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+        { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+        { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+        { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+      ]
+    })
+  } catch (err) {
+    return false
+  }
+
+  let sortNodule = {}
+  try {
+    sortNodule = new SortNodule({
+      id: 'ABC',
+      label: 'Test Nodule',
+      tables: [table],
+      sortValueType: 'ALPHABETIC',
+      sortDirection: 'ASCENDING',
+      sortKey: 'contractor'
+    })
+  } catch (err) {
+    console.log(err)
+    return false
+  }
+
+  const sortedRows = sortNodule.export()
+  if (JSON.stringify(sortedRows) === JSON.stringify(expectedOutput)) {
+    return true
+  } else {
+    return false
+  }
+}
+
+
+const sortAlphabeticDescending = () => {
+  const expectedOutput = [
+    { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+    { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+    { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+    { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+  ]
+
+  let table = {}
+  try {
+    table = new Table({
+      id: 'XYZ',
+      label: 'Test Table',
+      rows: [
+        { id: 'abc', data: 'row', contractor: 'AshBritt', someNumber: 9 },
+        { id: 'qwe', data: 'lh', contractor: 'AshBritt',  someNumber: 11 },
+        { id: 'XYZ', data: 'row', contractor: 'HeyDay',  someNumber: 4 },
+        { id: 'XYZ', data: 'row', contractor: 'AshBritt',  someNumber: 1 },
+      ]
+    })
+  } catch (err) {
+    return false
+  }
+
+  let sortNodule = {}
+  try {
+    sortNodule = new SortNodule({
+      id: 'ABC',
+      label: 'Test Nodule',
+      tables: [table],
+      sortValueType: 'ALPHABETIC',
+      sortDirection: 'DESCENDING',
+      sortKey: 'contractor'
+    })
+  } catch (err) {
+    console.log(err)
+    return false
+  }
+
+  const sortedRows = sortNodule.export()
+  if (JSON.stringify(sortedRows) === JSON.stringify(expectedOutput)) {
+    return true
+  } else {
+    return false
+  }
+}
+
+export default [
+  { name: 'Entities | Sort Nodule Numeric Ascending', test: sortNumericAscending },
+  { name: 'Entities | Sort Nodule Numeric Descending', test: sortNumericDesscending },
+  { name: 'Entities | Sort Nodule Alphabetic Ascending', test: sortAlphabeticAscending },
+  { name: 'Entities | Sort Nodule Alphabetic Descending', test: sortAlphabeticDescending },
+]

tests/index.ts

@@ -6,6 +6,7 @@ import filterNoduleTests from './core/nodules/filterNoduleTests.js'
 import joinNoduleTests from './core/nodules/joinNoduleTests.js'
 import transformNoduleTests from './core/nodules/transformNoduleTests.js'
 import groupByNoduleTests from './core/nodules/groupByNoduleTests.js'
+import sortNoduleTests from './core/nodules/sortNoduleTests.js'
 
 type unitTest = { name: string, test: Function }
 
@@ -38,7 +39,8 @@ const testsArray = [
   filterNoduleTests,
   joinNoduleTests,
   transformNoduleTests,
-  groupByNoduleTests
+  groupByNoduleTests,
+  sortNoduleTests,
 ]
 
 init (testsArray.flat())