Fixes in NucleoList type

- isolate indexSearch function to its own file

- Create more tests to NucleoLists exploring exploits possibilities

- Improve indexSearch function to work properly with NucleoList types

- Fixes in NucleoList fields validations and serializations

Author: Matheus Marsiglio

package.json

@@ -1,8 +1,9 @@
 {
   "name": "nucleojs",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "author": "Matheus Marsiglio <[email protected]>",
+  "repository": "git://github.com/mtmr0x/nucleo",
   "license": "MIT",
   "repository": "git://github.com/mtmr0x/nucleo",
   "private": false,

src/indexSearch.ts

@@ -0,0 +1,35 @@
+const saveType = (data:any):'rec'|'save' => {
+  if (typeof data === 'object' && !data.length) {
+    return 'rec';
+  }
+
+  return 'save';
+};
+
+const indexSearch = (storeData: any, data: any, newData:any = {}) => {
+  const dataKeys = Object.keys(data);
+  const storeDataKeys = Object.keys(storeData);
+
+  for (let i = 0; storeDataKeys.length > i; i++) {
+    const dataTypeReflection = () => ({
+      'rec': () => {
+        const bufferData = data[storeDataKeys[i]] || storeData[storeDataKeys[i]];
+        newData[storeDataKeys[i]] = {}
+        return indexSearch(storeData[storeDataKeys[i]], bufferData, newData[storeDataKeys[i]]);
+      },
+      'save': () => {
+        if (data[storeDataKeys[i]]) {
+          return newData[storeDataKeys[i]] = data[storeDataKeys[i]];
+        }
+        return newData[storeDataKeys[i]] = storeData[storeDataKeys[i]];
+      }
+    });
+
+    dataTypeReflection()[saveType(storeData[storeDataKeys[i]])]();
+  }
+
+  return newData;
+}
+
+export default indexSearch;
+

src/lawyer.ts

@@ -2,43 +2,14 @@ import NucleoObject from './nucleoTypes/NucleoObject';
 import NucleoList from './nucleoTypes/NucleoList';
 
 import { NucleoObjectType } from './_types/NucleoObjectType';
+import indexSearch from './indexSearch';
 
 const executeListeners = (contractName: string, listeners: Array<Function>) => {
   for (let i = 0; i < listeners.length; i++) {
     listeners[i]({ contractName });
   }
 };
 
-const indexSearch = (contractData: any, data: any, newData:any = {}) => {
-  const dataKeys = Object.keys(data);
-  const contractDataKeys = Object.keys(contractData);
-
-  for (let i = 0; contractDataKeys.length > i; i++) {
-    const dataTypeReflection = () => ({
-      'object': () => {
-        const bufferData = data[contractDataKeys[i]] || contractData[contractDataKeys[i]];
-        newData[contractDataKeys[i]] = {}
-        return indexSearch(contractData[contractDataKeys[i]], bufferData, newData[contractDataKeys[i]]);
-      },
-      'primitive': () => {
-        if (data[contractDataKeys[i]]) {
-          return newData[contractDataKeys[i]] = data[contractDataKeys[i]];
-        }
-        return newData[contractDataKeys[i]] = contractData[contractDataKeys[i]];
-      }
-    });
-
-    if (typeof contractData[contractDataKeys[i]] === 'object') {
-      dataTypeReflection()['object']();
-      continue;
-    }
-
-    dataTypeReflection()['primitive']();
-  }
-
-  return newData;
-}
-
 const saveMethodReflection = (store: any, contractName: string) => ({
   dispatch: (data: any) => {
     return store[contractName] = data;
@@ -73,6 +44,7 @@ export default function lawyer({
 
   for (let i = 0; dataKeys.length > i; i++) {
     const currentDataKey = data[dataKeys[i]];
+
     if (contractFields[dataKeys[i]] instanceof NucleoObject) {
       lawyer({
         contract: contractFields[dataKeys[i]],
@@ -103,6 +75,15 @@ export default function lawyer({
         NucleoObject: () => {
           if (_NucleoItemType instanceof NucleoObject) {
             for (let d = 0; d < currentDataKey.length; d++) {
+              if (Object.keys(currentDataKey[d]).length !== Object.keys(_NucleoItemType.fields).length) {
+                __errors__.push({
+                  contract: _NucleoItemType.name,
+                  error: 'You can not update a NucleoList of NucleoObject without its data according to contract in every level'
+                });
+
+                continue;
+              }
+
               lawyer({
                 contract: _NucleoItemType,
                 data: currentDataKey[d],

src/nucleoTypes/NucleoList.spec.ts

@@ -0,0 +1,127 @@
+import {
+  NucleoString,
+  NucleoNumber,
+  NucleoBoolean,
+  NucleoList,
+  NucleoObject,
+  createStore
+} from './../index'
+import { expect } from 'chai';
+import 'mocha';
+
+describe('NucleoList', () => {
+  const userAccountsType = new NucleoObject({
+    name: 'userAccountsType',
+    fields: {
+      accountType: NucleoString,
+      accountNumber: NucleoNumber
+    }
+  });
+
+  const personalInfoType = new NucleoObject({
+    name: 'personalInfo',
+    fields:  {
+      firstName: NucleoString,
+      lastName: NucleoString,
+      items: new NucleoList(NucleoString),
+      accounts: new NucleoList(userAccountsType)
+    }
+  });
+
+  const userType = new NucleoObject({
+    name: 'user',
+    fields: {
+      personalInfo: personalInfoType,
+      age: NucleoNumber
+    }
+  });
+  const contracts = { user: userType };
+  const store = createStore(contracts);
+  const { dispatch, update, getStore } = store;
+
+  it('should dispatch all data to store', () => {
+    const data = {
+      age: 27,
+      personalInfo: {
+        firstName: 'Joseph',
+        lastName: 'Nor',
+        items: ['a', 'b', 'c'],
+        accounts: [
+          { accountType: 'bank', accountNumber: 1233 },
+          { accountType: 'bank', accountNumber: 9876 }
+        ]
+      }
+    }
+
+    const d = dispatch('user')(data);
+    expect(d.errors.length).to.equal(0);
+  });
+
+  it('should try to update a NucleoList of primitive values succesfully', () => {
+    const u = update('user')({ personalInfo: { items: ['g', 'h', 'j', 'k'] } });
+
+    const { personalInfo } = getStore().user;
+    const { items } = personalInfo;
+
+    expect(personalInfo.firstName).to.equal('Joseph');
+    expect(personalInfo.lastName).to.equal('Nor');
+    expect(items.length).to.equal(4);
+    expect(personalInfo.accounts.length).to.equal(2);
+    expect(items[0]).to.equal('g');
+  });
+
+  it('should try to violate a NucleoList of primitive values with update', () => {
+    const u = update('user')({ personalInfo: { items: ['g', 'h', 'j', 1] } });
+
+    const { personalInfo } = getStore().user;
+    const { items } = personalInfo;
+
+    expect(u.errors.length).to.equal(1);
+    expect(personalInfo.firstName).to.equal('Joseph');
+    expect(personalInfo.lastName).to.equal('Nor');
+    expect(items.length).to.equal(4);
+    expect(personalInfo.accounts.length).to.equal(2);
+    expect(items[3]).to.equal('k');
+  });
+
+  it('should try to update a NucleoList of object values succesfully', () => {
+    const obj = {
+      personalInfo: {
+        accounts: [
+          { accountType: 'service', accountNumber: 1111 },
+          { accountType: 'service', accountNumber: 2222 }
+        ]
+      }
+    };
+
+    const u = update('user')(obj);
+    const { personalInfo } = getStore().user;
+
+    expect(u.errors.length).to.equal(0);
+    expect(personalInfo.accounts[0].accountType).to.equal('service');
+    expect(personalInfo.accounts[1].accountType).to.equal('service');
+    expect(personalInfo.accounts[0].accountNumber).to.equal(1111);
+    expect(personalInfo.accounts[1].accountNumber).to.equal(2222);
+  });
+
+  it('should try to violate a NucleoList of object values with update', () => {
+    const obj = {
+      personalInfo: {
+        accounts: [
+          { accountType: 'service' },
+          { accountType: 'service', accountNumber: '2222' }
+        ]
+      }
+    };
+
+    const u = update('user')(obj);
+
+    const { personalInfo } = getStore().user;
+    expect(u.errors.length).to.equal(2);
+    expect(personalInfo.accounts[0].accountType).to.equal('service');
+    expect(personalInfo.accounts[1].accountType).to.equal('service');
+    expect(personalInfo.accounts[0].accountNumber).to.equal(1111);
+    expect(personalInfo.accounts[1].accountNumber).to.equal(2222);
+  });
+});
+