11851025772

Committed 15 Nov 2024 05:47AM UTC coverage: 66.801% (+0.1%) from 66.667%

Build # 11851025772

Build Type

push

github

Committed by

vanthome

Commit Message

chore: upgrade deps

Run Details

267 of 411 branches covered (64.96%)

Branch coverage included in aggregate %.

46 of 59 new or added lines in 5 files covered. (77.97%)

4 existing lines in 2 files now uncovered.

564 of 833 relevant lines covered (67.71%)

27.41 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.09

/src/index.ts

import * as _ from 'lodash';

const filterOperationMap = new Map([
  [0, 'eq'],
  [1, 'lt'],
  [2, 'lte'],
  [3, 'gt'],
  [4, 'gte'],
  [5, 'isEmpty'],
  [6, 'iLike'],
  [7, 'in'],
  [8, 'neq']
]);

const filterOperatorMap = new Map([
  [0, 'and'],
  [1, 'or']
]);

const insertFilterFieldOpValue = (filter, object, key) => {
  let value;
  if (!filter.type || filter.type === 'STRING' || filter.type === 0) {
    value = filter.value;
  } else if ((filter.type === 'NUMBER' || filter.type === 1) && !isNaN(filter.value)) {
    value = Number(filter.value);
  } else if (filter.type === 'BOOLEAN' || filter.type === 2) {
    if (filter.value === 'true') {
      value = true;
    } else if (filter.value === 'false') {
      value = false;
    }
  } else if (filter.type === 'ARRAY' || filter.type === 4) {
    try {
      value = JSON.parse(filter.value);
    } catch (err: any) {
      // to handle JSON string parse error
      if (err.message.indexOf('Unexpected token') > -1) {
        value = JSON.parse(JSON.stringify(filter.value));
      } else {
        throw err;
      }
    }
  } else if (filter.type === 'DATE' || filter.type === 3) {
    value = (new Date(filter.value)).getTime();
  }

  let temp;
  if (key) {
    temp = object[key];
  } else {
    // should be root level filter, if key does not exist
    object = [];
    temp = object;
  }
  if (filter.operation === 'eq' || filter.operation === 0) {
    if (_.isArray(temp)) {
      temp.push({ [filter.field]: value });
    } else {
      temp.push({ [filter.field]: value });
    }
  } else if (filter.operation === 'neq' || filter.operation === 8) {
    if (_.isArray(temp)) {
      temp.push({ [filter.field]: { $not: { $eq: value } } });
    } else {
      temp.push({ [filter.field]: { $not: { $eq: value } } });
    }
  } else {
    let opValue;
    if (typeof filter.operation === 'string' || filter.operation instanceof String) {
      opValue = filter.operation;
    } else if (Number.isInteger(filter.operation)) {
      opValue = filterOperationMap.get(filter.operation);
    }
    const op = `$${opValue}`;
    if (_.isArray(temp)) {
      temp.push({ [filter.field]: { [op]: value } });
    } else {
      temp.push({ [filter.field]: { [op]: value } });
    }
  }
  return object;
};

/**
 * Takes filter object containing field, operation and value and updates the filter in
 * object with operator style understandable by chassis-srv for later to be used for
 * AQL conversion
 * @param object converted filter object
 * @param originalKey operator value
 * @param filter object containing field, operation, value and type
 * @returns object
 */
const convertFilterToObject = (object, operatorKey, filter) => {
  if (object !== null) {
    if (Array.isArray(object)) {
      for (const arrayItem of object) {
        convertFilterToObject(arrayItem, operatorKey, filter);
      }
    } else if (typeof object === 'object') {
      for (const key of Object.keys(object)) {
        // Match found, update object with filter field, operation and value into object
        if (key === operatorKey) {
          object = insertFilterFieldOpValue(filter, object, operatorKey);
        } else {
          convertFilterToObject(object[key], operatorKey, filter);
        }
      }
    }
  }
  if (!operatorKey) {
    // should be root level filter
    object = insertFilterFieldOpValue(filter, object, operatorKey);
    object = object[0];
  }
  return object;
};

/**
 * convertToObject takes input contained in the proto structure defined in resource_base proto
 * and converts it into Object understandable by the underlying DB implementation in chassis-srv
 * @param {*} input Original filter input object
 * @param {*} obj converted filter objected passed recursively
 * @param {*} currentOperator current operatro value passed recursively
 */
export const convertToObject = (input: any, obj?: any, currentOperator?: string) => {
  // since toObject method is called recursively we are not adding the typing to input parameter
  let filters;
  if (input && !_.isEmpty(input.filters)) {
    filters = input.filters;
  } else {
    filters = input;
  }
  // by default use 'and' operator if no operator is specified
  if (filters && _.isArray(filters.filters) && !filters.operator) {
    filters.operator = 'and';
  }
  if (!obj) {
    obj = {};
  }
  if (_.isArray(filters)) {
    for (const filterObj of filters) {
      let operatorValue;
      if (typeof filterObj.operator === 'string' || filterObj.operator instanceof String) {
        operatorValue = filterObj.operator;
      } else if (Number.isInteger(filterObj.operator)) {
        operatorValue = filterOperatorMap.get(filterObj.operator);
      }
      // default to and operator
      if (!operatorValue) {
        operatorValue = 'and';
      }
      const newOperator = `$${operatorValue}`;
      if (newOperator && !currentOperator) {
        // insert obj with new operator
        Object.assign(obj, { [newOperator]: [] });
      }
      convertToObject(filterObj, obj, newOperator);
    }
  } else if (filters.field && (filters.operation || filters.operation === 0) && filters.value != undefined) {
    // object contains field, operation and value, update it on obj using convertFilterToObject()
    obj = convertFilterToObject(obj, currentOperator, filters);
  } else if (filters.filters && _.isArray(filters.filters)) {
    for (const filterObj of filters.filters) {
      const operator = filters.operator ? filters.operator : 'and';
      convertToObject(filterObj, obj, operator);
    }
  }
  return obj;
};

/**
 * converts input filters to json object understandable by chassis-srv for AQL conversion
 * @param input input filters object
 * @returns json object understandable by chassiss-rv for AQL conversion
 */
export const toObject = (input) => {
  let filtersArr = input.filters;
  if (!filtersArr) {
    filtersArr = input;
  }
  let finalObj = {};
  if (_.isArray(filtersArr)) {
    if (filtersArr.length > 1) {
      finalObj = [];
    }
    for (const filterArr of filtersArr) {
      const convertedObject = [];
      const filterObj = filterArr?.filters;
      let operatorValue;
      if (typeof filterArr?.operator === 'string' || filterArr?.operator instanceof String) {
        operatorValue = filterArr?.operator;
      } else if (Number.isInteger(filterArr?.operator)) {
        operatorValue = filterOperatorMap.get(filterArr?.operator);
      }
      // default operator is `and`
      if (!operatorValue) {
        operatorValue = 'and';
      }
      if (_.isArray(filterObj)) {
        for (const filter of filterObj) {
          let obj = {};
          obj = convertToObject(filter, obj);
          if (!_.isEmpty(obj)) {
            convertedObject.push(obj);
          }
        }
      }
      if (_.isArray(finalObj) && (!_.isEmpty(convertedObject))) {
        finalObj.push({ [`$${operatorValue}`]: convertedObject });
      } else if (!_.isEmpty(convertedObject)) {
        finalObj[`$${operatorValue}`] = convertedObject;
      }
    }
  }
  return finalObj;
};

export { ResourcesAPIBase } from './core/ResourcesAPI';
export { ServiceBase } from './core/ServiceBase';
export { WorkerBase } from './core/WorkerBase';
export { GraphResourcesServiceBase } from './core/GraphResourcesServiceBase';
export {
  Filter,
  FilterOp,
  FilterOperation,
  FilterValueType,
  GraphFilters,
  GraphFilter,
  OperatorType,
  TraversalOptions,
} from './core/interfaces';

1	import * as _ from 'lodash';	1✔
2
3	const filterOperationMap = new Map([	1✔
4	[0, 'eq'],
5	[1, 'lt'],
6	[2, 'lte'],
7	[3, 'gt'],
8	[4, 'gte'],
9	[5, 'isEmpty'],
10	[6, 'iLike'],
11	[7, 'in'],
12	[8, 'neq']
13	]);
14
15	const filterOperatorMap = new Map([	1✔
16	[0, 'and'],
17	[1, 'or']
18	]);
19
20	const insertFilterFieldOpValue = (filter, object, key) => {	1✔
21	let value;
22	if (!filter.type \|\| filter.type === 'STRING' \|\| filter.type === 0) {	19✔
23	value = filter.value;	13✔
24	} else if ((filter.type === 'NUMBER' \|\| filter.type === 1) && !isNaN(filter.value)) {	6✔
25	value = Number(filter.value);	1✔
26	} else if (filter.type === 'BOOLEAN' \|\| filter.type === 2) {	5✔
27	if (filter.value === 'true') {	2!
28	value = true;	2✔
29	} else if (filter.value === 'false') {	×
30	value = false;	×
31	}
32	} else if (filter.type === 'ARRAY' \|\| filter.type === 4) {	3✔
33	try {	2✔
34	value = JSON.parse(filter.value);	2✔
35	} catch (err: any) {
36	// to handle JSON string parse error
37	if (err.message.indexOf('Unexpected token') > -1) {	×
38	value = JSON.parse(JSON.stringify(filter.value));	×
39	} else {
40	throw err;	×
41	}
42	}
43	} else if (filter.type === 'DATE' \|\| filter.type === 3) {	1!
44	value = (new Date(filter.value)).getTime();	1✔
45	}
46
47	let temp;
48	if (key) {	19✔
49	temp = object[key];	8✔
50	} else {
51	// should be root level filter, if key does not exist
52	object = [];	11✔
53	temp = object;	11✔
54	}
55	if (filter.operation === 'eq' \|\| filter.operation === 0) {	19✔
56	if (_.isArray(temp)) {	10!
57	temp.push({ [filter.field]: value });	10✔
58	} else {
59	temp.push({ [filter.field]: value });	×
60	}
61	} else if (filter.operation === 'neq' \|\| filter.operation === 8) {	9✔
62	if (_.isArray(temp)) {	2!
63	temp.push({ [filter.field]: { $not: { $eq: value } } });	2✔
64	} else {
65	temp.push({ [filter.field]: { $not: { $eq: value } } });	×
66	}
67	} else {
68	let opValue;
69	if (typeof filter.operation === 'string' \|\| filter.operation instanceof String) {	7!
70	opValue = filter.operation;	7✔
71	} else if (Number.isInteger(filter.operation)) {	×
72	opValue = filterOperationMap.get(filter.operation);	×
73	}
74	const op = `$${opValue}`;	7✔
75	if (_.isArray(temp)) {	7!
76	temp.push({ [filter.field]: { [op]: value } });	7✔
77	} else {
78	temp.push({ [filter.field]: { [op]: value } });	×
79	}
80	}
81	return object;	19✔
82	};
83
84	/**
85	* Takes filter object containing field, operation and value and updates the filter in
86	* object with operator style understandable by chassis-srv for later to be used for
87	* AQL conversion
88	* @param object converted filter object
89	* @param originalKey operator value
90	* @param filter object containing field, operation, value and type
91	* @returns object
92	*/
93	const convertFilterToObject = (object, operatorKey, filter) => {	1✔
94	if (object !== null) {	19✔
95	if (Array.isArray(object)) {	19!
96	for (const arrayItem of object) {	×
97	convertFilterToObject(arrayItem, operatorKey, filter);	×
98	}
99	} else if (typeof object === 'object') {	19✔
100	for (const key of Object.keys(object)) {	19✔
101	// Match found, update object with filter field, operation and value into object
102	if (key === operatorKey) {	8!
103	object = insertFilterFieldOpValue(filter, object, operatorKey);	8✔
104	} else {
105	convertFilterToObject(object[key], operatorKey, filter);	×
106	}
107	}
108	}
109	}
110	if (!operatorKey) {	19✔
111	// should be root level filter
112	object = insertFilterFieldOpValue(filter, object, operatorKey);	11✔
113	object = object[0];	11✔
114	}
115	return object;	19✔
116	};
117
118	/**
119	* convertToObject takes input contained in the proto structure defined in resource_base proto
120	* and converts it into Object understandable by the underlying DB implementation in chassis-srv
121	* @param {*} input Original filter input object
122	* @param {*} obj converted filter objected passed recursively
123	* @param {*} currentOperator current operatro value passed recursively
124	*/
125	export const convertToObject = (input: any, obj?: any, currentOperator?: string) => {	1✔
126	// since toObject method is called recursively we are not adding the typing to input parameter
127	let filters;
128	if (input && !_.isEmpty(input.filters)) {	25✔
129	filters = input.filters;	6✔
130	} else {
131	filters = input;	19✔
132	}
133	// by default use 'and' operator if no operator is specified
134	if (filters && _.isArray(filters.filters) && !filters.operator) {	25!
135	filters.operator = 'and';	×
136	}
137	if (!obj) {	25!
138	obj = {};	×
139	}
140	if (_.isArray(filters)) {	25✔
141	for (const filterObj of filters) {	6✔
142	let operatorValue;
143	if (typeof filterObj.operator === 'string' \|\| filterObj.operator instanceof String) {	11✔
144	operatorValue = filterObj.operator;	3✔
145	} else if (Number.isInteger(filterObj.operator)) {	8!
146	operatorValue = filterOperatorMap.get(filterObj.operator);	×
147	}
148	// default to and operator
149	if (!operatorValue) {	11✔
150	operatorValue = 'and';	8✔
151	}
152	const newOperator = `$${operatorValue}`;	11✔
153	if (newOperator && !currentOperator) {	11✔
154	// insert obj with new operator
155	Object.assign(obj, { [newOperator]: [] });	3✔
156	}
157	convertToObject(filterObj, obj, newOperator);	11✔
158	}
159	} else if (filters.field && (filters.operation \|\| filters.operation === 0) && filters.value != undefined) {	19!
160	// object contains field, operation and value, update it on obj using convertFilterToObject()
161	obj = convertFilterToObject(obj, currentOperator, filters);	19✔
162	} else if (filters.filters && _.isArray(filters.filters)) {	×
NEW 163	for (const filterObj of filters.filters) {	×
NEW 164	const operator = filters.operator ? filters.operator : 'and';	×
UNCOV 165	convertToObject(filterObj, obj, operator);	×
166	}
167	}
168	return obj;	25✔
169	};
170
171	/**
172	* converts input filters to json object understandable by chassis-srv for AQL conversion
173	* @param input input filters object
174	* @returns json object understandable by chassiss-rv for AQL conversion
175	*/
176	export const toObject = (input) => {	1✔
177	let filtersArr = input.filters;	9✔
178	if (!filtersArr) {	9✔
179	filtersArr = input;	6✔
180	}
181	let finalObj = {};	9✔
182	if (_.isArray(filtersArr)) {	9✔
183	if (filtersArr.length > 1) {	9✔
184	finalObj = [];	1✔
185	}
186	for (const filterArr of filtersArr) {	9✔
187	const convertedObject = [];	10✔
188	const filterObj = filterArr?.filters;	10✔
189	let operatorValue;
190	if (typeof filterArr?.operator === 'string' \|\| filterArr?.operator instanceof String) {	10✔
191	operatorValue = filterArr?.operator;	4✔
192	} else if (Number.isInteger(filterArr?.operator)) {	6!
193	operatorValue = filterOperatorMap.get(filterArr?.operator);	×
194	}
195	// default operator is `and`
196	if (!operatorValue) {	10✔
197	operatorValue = 'and';	6✔
198	}
199	if (_.isArray(filterObj)) {	10✔
200	for (const filter of filterObj) {	10✔
201	let obj = {};	14✔
202	obj = convertToObject(filter, obj);	14✔
203	if (!_.isEmpty(obj)) {	14✔
204	convertedObject.push(obj);	14✔
205	}
206	}
207	}
208	if (_.isArray(finalObj) && (!_.isEmpty(convertedObject))) {	10✔
209	finalObj.push({ [`$${operatorValue}`]: convertedObject });	2✔
210	} else if (!_.isEmpty(convertedObject)) {	8✔
211	finalObj[`$${operatorValue}`] = convertedObject;	8✔
212	}
213	}
214	}
215	return finalObj;	9✔
216	};
217
218	export { ResourcesAPIBase } from './core/ResourcesAPI';	7✔
219	export { ServiceBase } from './core/ServiceBase';	7✔
220	export { WorkerBase } from './core/WorkerBase';	1✔
221	export { GraphResourcesServiceBase } from './core/GraphResourcesServiceBase';	2✔
222	export {	1✔
223	Filter,
224	FilterOp,
225	FilterOperation,	1✔
226	FilterValueType,	1✔
227	GraphFilters,
228	GraphFilter,
229	OperatorType,	1✔
230	TraversalOptions,
231	} from './core/interfaces';

restorecommerce / resource-base-interface / 11851025772

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous