11838820957

Committed 14 Nov 2024 02:03PM UTC coverage: 66.667% (+0.1%) from 66.534%

Build # 11838820957

Build Type

push

github

Committed by Gerald Baulig

Commit Message

fix(required_fields): checkRequiredFields can't work like. fixing condition and use better filter

Run Details

267 of 411 branches covered (64.96%)

Branch coverage included in aggregate %.

16 of 16 new or added lines in 2 files covered. (100.0%)

23 existing lines in 1 file now uncovered.

565 of 837 relevant lines covered (67.5%)

28.0 hits per line

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

78.09

/src/core/ResourcesAPI.ts

import * as _ from 'lodash';
import { errors } from '@restorecommerce/chassis-srv';
import { Logger } from '@restorecommerce/logger';
import * as uuid from 'uuid';
import { Topic } from '@restorecommerce/kafka-client';
import { BaseDocument, DocumentMetadata } from './interfaces';
import { DatabaseProvider, GraphDatabaseProvider } from '@restorecommerce/chassis-srv';
import { DeepPartial } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/attribute';
import { Search } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/resource_base';
import { Subject } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/auth';
import { fieldHandler } from './utils';

let redisClient: any;

const Strategies = {
  INCREMENT: 'increment',
  UUID: 'uuid',
  RANDOM: 'random',
  TIMESTAMP: 'timestamp'
};

const uuidGen = (): string => {
  return uuid.v4().replace(/-/g, '');
};

const isEmptyObject = (obj: any): any => {
  return !Object.keys(obj).length;
};

const setDefaults = async (obj: { meta?: DocumentMetadata;[key: string]: any }, collectionName: string, subject: Subject): Promise<any> => {
  const o = obj;

  if (_.isEmpty(o.meta)) {
    throw new errors.InvalidArgument('Object does not contain ownership information');
  }

  if (redisClient) {
    const values = await redisClient.hGetAll(collectionName);

    if (values) {
      for (let field in values) {
        const strategy = values[field];
        switch (strategy) {
          case Strategies.INCREMENT:
            const key = collectionName + ':' + field;
            o[field] = await redisClient.get(key);
            await redisClient.incr(key);
            break;
          case Strategies.UUID:
            o[field] = uuidGen();
            break;
          case Strategies.RANDOM:
            o[field] = uuidGen();
            break;
          case Strategies.TIMESTAMP:
            o[field] = await redisClient.time()[0];
            break;
        }
      }
    }
  }

  if (_.isNil(o.meta.created) || o.meta.created === 0) {
    o.meta.created = new Date();
  }
  o.meta.created_by = subject?.id;
  o.meta.modified_by = subject?.id;
  o.meta.modified = new Date();
  if (_.isNil(o.id) || o.id === 0 || isEmptyObject(o.id)) {
    o.id = uuidGen();
  }
  return o;
};

const updateMetadata = (docMeta: DocumentMetadata, newDoc: BaseDocument, subject: Subject): BaseDocument => {
  if (_.isEmpty(newDoc.meta)) {
    throw new errors.InvalidArgument(`Update request holds no valid metadata for document ${newDoc.id}`);
  }

  if (!_.isEmpty(newDoc.meta?.owners)) {
    // if ownership is meant to be updated
    docMeta.owners = newDoc.meta.owners;
  }

  docMeta.modified_by = subject?.id;
  docMeta.modified = new Date();

  newDoc.meta = docMeta;
  return newDoc;
};

/**
 * Resource API base provides functions for CRUD operations.
 */
export class ResourcesAPIBase {
  public readonly bufferFields: string[];
  public readonly requiredFields: any;
  public readonly timeStampFields: string[];
  /**
   * @constructor
   * @param  {object} db Chassis arangodb provider.
   * @param {string} collectionName Name of database collection.
   * @param {any} fieldHandlerConf The collection's field generators configuration.
  */
  constructor(
    public readonly db: DatabaseProvider,
    public readonly collectionName: string,
    fieldHandlerConf?: any,
    public readonly edgeCfg?: any,
    public readonly graphName?: string,
    public readonly logger?: Logger,
    public readonly resourceName?: string,
  ) {
    this.resourceName ??= collectionName.substring(0, collectionName.length - 1);

    if (!fieldHandlerConf) {
      return;
    }

    const strategyCfg = fieldHandlerConf.strategies;
    if (!redisClient) {
      redisClient = fieldHandlerConf.redisClient;
    }

    if (fieldHandlerConf.bufferFields) {
      this.bufferFields = fieldHandlerConf.bufferFields;
    }

    // config fix to be removed after ts-proto is used
    if (fieldHandlerConf.timeStampFields) {
      this.timeStampFields = fieldHandlerConf.timeStampFields;
    }

    if (fieldHandlerConf.requiredFields) {
      this.requiredFields = fieldHandlerConf.requiredFields[this.resourceName] ?? fieldHandlerConf.requiredFields;
    }

    // values for Redis hash set
    for (let field in strategyCfg) {
      const strategy = strategyCfg[field].strategy;
      redisClient.hSet(collectionName, field, strategy);
      switch (strategy) {
        case Strategies.INCREMENT:
          // check if value already exists in redis
          let startingValue: any;
          startingValue = redisClient.get(`${collectionName}:${field}`).then((val) => val);
          if (!startingValue) {
            if (strategyCfg[field].startingValue) {
              startingValue = Number.isNaN(strategyCfg[field].startingValue) ?
                '0' : strategyCfg[field].startingValue;
            }
            else {
              startingValue = '0';
            }
            redisClient.set(`${collectionName}:${field}`, startingValue).then((val) => val);
          }
          break;
        default:
          break;
      }
    }
  }


  /**
   * Finds documents based on provided filters and options
   * @param {object} filter key value filter using mongodb/nedb filter format.
   * @param {number} limit
   * @param {number} offset
   * @param {object} sort key value, key=field value: 1=ASCENDING, -1=DESCENDING, 0=UNSORTED
   * @param {object} field key value, key=field value: 0=exclude, 1=include
   * @returns {an Object that contains an items field}
   */
  async read(
    filter: Object = {},
    limit = 1000,
    offset = 0,
    sort: any = {},
    field: any = {},
    customQueries: string[] = [],
    customArgs: any = {},
    search: DeepPartial<Search>
  ): Promise<BaseDocument[]> {
    const options = {
      limit: Math.min(limit, 1000),
      offset,
      sort,
      fields: field,
      customQueries,
      customArguments: customArgs.value ? JSON.parse(customArgs.value.toString()) : {},
      search
    };
    let entities: BaseDocument[] = await this.db.find(this.collectionName, filter, options);
    if (this.bufferFields && entities?.length > 0) {
      // encode the msg obj back to buffer obj and send it back
      entities = this.encodeOrDecode(entities, this.bufferFields, 'encode');
    }
    if (this.timeStampFields && entities?.length > 0) {
      // convert number to Date Object
      entities = this.encodeOrDecode(entities, this.timeStampFields, 'convertMilisecToDateObj');
    }
    return entities;
  }

  /**
  * Inserts documents to the database.
  *
  * @param {array.object} documents
  */
  async create(documents: BaseDocument[], subject: Subject): Promise<any> {
    const collection = this.collectionName;
    let result = [];
    try {
      // check if all the required fields are present
      if (this.requiredFields) {
        const requiredFieldsResult = this.checkRequiredFields(
          this.requiredFields,
          documents,
          result
        );
        documents = requiredFieldsResult.documents;
        result = requiredFieldsResult.result;
      }

      documents = await Promise.all(documents.map(async (doc) => {
        return await setDefaults(doc, collection, subject);
      }));

      if (this.bufferFields && documents?.length > 0) {
        documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
      }
      if (this.timeStampFields && documents?.length > 0) {
        // convert Date Object to Number
        documents = this.encodeOrDecode(documents, this.timeStampFields, 'convertDateObjToMilisec');
      }
      if (this.isGraphDB(this.db)) {
        await this.db.createGraphDB(this.graphName);
        await this.db.addVertexCollection(collection);
        let createVertexResp = await this.db.createVertex(collection, documents);
        for (let document of documents) {
          if (this.edgeCfg && Array.isArray(this.edgeCfg) && this.edgeCfg.length > 0) {
            for (let eachEdgeCfg of this.edgeCfg) {
              const fromIDkey = eachEdgeCfg.from;
              const from_id = document[fromIDkey];
              const toIDkey = eachEdgeCfg.to;
              const to_id = document[toIDkey];
              // edges are created outbound, if it is inbound - check for direction
              const direction = eachEdgeCfg.direction;
              let fromVerticeName = collection;
              let toVerticeName = eachEdgeCfg.toVerticeName;
              if (direction === 'inbound') {
                fromVerticeName = eachEdgeCfg.fromVerticeName;
                toVerticeName = collection;
              }
              if (from_id && to_id) {
                if (Array.isArray(to_id)) {
                  for (let toID of to_id) {
                    await this.db.createEdge(eachEdgeCfg.edgeName, null,
                      `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
                  }
                } else {
                  await this.db.createEdge(eachEdgeCfg.edgeName, null,
                    `${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
                }
              }
            }
          }
        }
        if (Array.isArray(createVertexResp)) {
          createVertexResp.forEach((eachVertexResp) => result.push(eachVertexResp));
        } else {
          result.push(createVertexResp);
        }
        if (this.timeStampFields && result?.length > 0) {
          // convert number to Date Object
          result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
        }

        return result;
      }
      else {
        let checkReqFieldResult = [];
        if (!_.isEmpty(result)) {
          checkReqFieldResult = result;
        }
        result = await this.db.insert(collection, documents);
        if (!_.isEmpty(checkReqFieldResult)) {
          checkReqFieldResult.forEach((reqFieldResult) => result.push(reqFieldResult));
        }
        if (this.timeStampFields && result?.length > 0) {
          // convert number to Date Object
          result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
        }
        return result;
      }
    } catch (error) {
      this.logger?.error('Error creating documents', { code: error?.code, message: error?.message, stack: error?.stack });
      result.push({
        error: true,
        errorNum: error?.code,
        errorMessage: error?.details ? error?.details : error?.message
      });
      return result;
    }
  }

  private isGraphDB(db: DatabaseProvider): db is GraphDatabaseProvider {
    return !!this.edgeCfg;
  }

  /**
   * Check if a resource's required fields are present.
   * @param requiredFields
   * @param documents
   */
  checkRequiredFields(requiredFields: string[], documents: any[], result: any[]): any {
    documents = documents.filter((document) => {
      return requiredFields.every((eachField) => {
        if (document[eachField] === undefined || (Array.isArray(document[eachField]) && document[eachField].length === 0)) {
          result.push({
            error: true,
            errorNum: 400,
            errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
          });
          return false;
        }
        return true;
      });
    });
    return { documents, result };
  }

  /**
   * Removes documents found by id.
   *
   * @param [array.string] ids List of document IDs.
   */
  async delete(ids: string[]): Promise<any> {
    let deleteResponse = [];
    try {
      if (!Array.isArray(ids)) {
        ids = [ids];
      }
      if (this.isGraphDB(this.db)) {
        // Modify the Ids to include documentHandle
        if (ids.length > 0) {
          ids = _.map(ids, (id) => {
            return `${this.collectionName}/${id}`;
          });
          deleteResponse = await this.db.removeVertex(this.collectionName, ids);
          return deleteResponse;
        }
      }
      deleteResponse = await this.db.delete(this.collectionName, ids);
      return deleteResponse;
    }
    catch (error) {
      this.logger?.error('Error deleting documents', { code: error?.code, message: error?.message, stack: error?.stack });
      deleteResponse.push({
        error: true,
        errorNum: error?.code,
        errorMessage: error?.details ? error?.details : error?.message
      });
      return deleteResponse;
    }
  }

  /**
   * Delete all documents in the collection.
   */
  async deleteCollection(): Promise<Array<any>> {
    if (this.isGraphDB(this.db)) {
      // graph edges are only deleted automatically when a specific vertex is deleted
      // (`truncate` does not work in this case)
      const ids = await this.db.find(this.collectionName, {}, {
        fields: {
          id: 1
        }
      });

      await this.delete(_.map(ids, (doc) => {
        return doc.id;
      }));
      return ids;
    } else {
      const entities = await this.db.find(this.collectionName, {}, { fields: { id: 1 } });
      await this.db.truncate(this.collectionName);
      return entities;
    }
  }

  /**
   * Upserts documents.
   *
   * @param [array.object] documents
   */
  async upsert(documents: BaseDocument[],
    events: Topic, resourceName: string, subject: Subject): Promise<BaseDocument[]> {
    let result = [];
    let createDocsResult = [];
    let updateDocsResult = [];
    try {
      let createDocuments = [];
      let updateDocuments = [];
      if (this.bufferFields && documents) {
        documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
      }
      const dispatch = await Promise.all(documents.map(async (doc) => {
        let foundDocs;
        if (doc && doc.id) {
          foundDocs = await this.db.find(this.collectionName, { id: doc.id }, {
            fields: {
              meta: 1
            }
          });
        }
        let eventName: string;
        if (_.isEmpty(foundDocs)) {
          // insert
          setDefaults(doc, this.collectionName, subject);
          createDocuments.push(doc);
          eventName = 'Created';
        } else {
          // convert dateTimeStamp fields
          if (this.timeStampFields) {
            foundDocs = this.encodeOrDecode(foundDocs, this.timeStampFields, 'convertMilisecToDateObj');
          }
          // update
          const dbDoc = foundDocs[0];
          updateMetadata(dbDoc.meta, doc, subject);
          updateDocuments.push(doc);
          eventName = 'Modified';
        }
        if (events) {
          return events.emit(`${resourceName}${eventName}`, doc);
        }
      }));

      if (createDocuments?.length > 0) {
        createDocsResult = await this.create(createDocuments, subject);
      }

      if (updateDocuments?.length > 0) {
        updateDocsResult = await this.update(updateDocuments, subject);
      }

      result = _.union(createDocuments, updateDocuments);

      if (this.timeStampFields && result?.length > 0) {
        // convert number to Date Object
        result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');
      }
      await Promise.all(dispatch);

      if (this.bufferFields && result?.length > 0) {
        result = this.encodeOrDecode(result, this.bufferFields, 'encode');
      }

      return result;
    } catch (error) {
      this.logger?.error('Error upserting documents', { code: error?.code, message: error?.message, stack: error?.stack });
      result.push({
        error: true,
        errorNum: error?.code,
        errorMessage: error?.details ? error?.details : error?.message
      });
      return result;
    }
  }

  /**
   * Finds documents by id and updates them.
   *
   * @param [array.object] documents
   * A list of documents or partial documents. Each document must contain an id field.
   */
  async update(documents: BaseDocument[], subject: Subject): Promise<BaseDocument[]> {
    let updateResponse = [];
    try {
      const collectionName = this.collectionName;
      if (this.bufferFields && documents) {
        documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');
      }
      let docsWithUpMetadata = await Promise.all(documents.map(async (doc) => {
        let foundDocs = await this.db.find(
          collectionName,
          { id: doc.id },
          { limit: 1 }
        );
        let dbDoc;
        if (foundDocs && foundDocs.length === 1) {
          dbDoc = foundDocs[0];
          doc = updateMetadata(dbDoc.meta, doc, subject);
        } else {
          dbDoc = doc; // doc not existing assigning to generate error message in response
        }

        if (this.isGraphDB(this.db)) {
          const db = this.db;
          await Promise.all(this.edgeCfg.map(async (eachEdgeCfg) => {
            const toIDkey = eachEdgeCfg.to;
            let modified_to_idValues = doc[toIDkey];
            let db_to_idValues = dbDoc[toIDkey];
            if (Array.isArray(modified_to_idValues)) {
              modified_to_idValues = _.sortBy(modified_to_idValues);
            }
            if (Array.isArray(db_to_idValues)) {
              db_to_idValues = _.sortBy(db_to_idValues);
            }
            // delete and recreate only if there is a difference in references
            if (!_.isEqual(modified_to_idValues, db_to_idValues)) {
              // delete and recreate the edge (since there is no way to update the edge as we dont add id to the edge as for doc)
              const fromIDkey = eachEdgeCfg.from;
              const from_id = doc[fromIDkey];
              let fromVerticeName = collectionName;
              let toVerticeName = eachEdgeCfg.toVerticeName;
              const direction = eachEdgeCfg.direction;
              if (direction === 'inbound') {
                fromVerticeName = eachEdgeCfg.fromVerticeName;
                toVerticeName = collectionName;
              }

              const edgeCollectionName = eachEdgeCfg.edgeName;
              let outgoingEdges: any = await db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
              if (Array.isArray(outgoingEdges.edges)) {
                await Promise.all(outgoingEdges.edges.map((outgoingEdge) => db.removeEdge(edgeCollectionName, outgoingEdge._id)));
              }
              let incomingEdges: any = await db.getInEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
              if (Array.isArray(incomingEdges.edges)) {
                await Promise.all(incomingEdges.edges.map((incomingEdge) => db.removeEdge(edgeCollectionName, incomingEdge._id)));
              }
              // Create new edges
              if (from_id && modified_to_idValues) {
                if (Array.isArray(modified_to_idValues)) {
                  await Promise.all(modified_to_idValues.map((toID) => db.createEdge(eachEdgeCfg.edgeName, null,
                    `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`)));
                } else {
                  await db.createEdge(edgeCollectionName, null,
                    `${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);
                }
              }
            }
          }));
        }
        return doc;
      }));

      if (this.timeStampFields && docsWithUpMetadata?.length > 0) {
        docsWithUpMetadata = this.encodeOrDecode(docsWithUpMetadata, this.timeStampFields, 'convertDateObjToMilisec');
      }
      updateResponse = await this.db.update(collectionName, docsWithUpMetadata);
      if (this.timeStampFields && updateResponse?.length > 0) {
        updateResponse = this.encodeOrDecode(updateResponse, this.timeStampFields, 'convertMilisecToDateObj');
      }
      if (this.bufferFields && updateResponse?.length > 0) {
        updateResponse = this.encodeOrDecode(updateResponse, this.bufferFields, 'encode');
      }
      return updateResponse;
    } catch (error) {
      this.logger?.error('Error updating documents', { code: error?.code, message: error?.message, stack: error?.stack });
      updateResponse.push({
        error: true,
        errorNum: error?.code,
        errorMessage: error?.message
      });
      return updateResponse;
    }
  }

  private encodeOrDecode(documents: any, fieldPaths: string[], fieldHanlder: string): any {
    for (let doc of documents) {
      for (let fieldPath of fieldPaths) {
        doc = fieldHandler(doc, fieldPath, fieldHanlder);
      }
    }
    return documents;
  }
}

1	import * as _ from 'lodash';	1✔
2	import { errors } from '@restorecommerce/chassis-srv';	1✔
3	import { Logger } from '@restorecommerce/logger';
4	import * as uuid from 'uuid';	1✔
5	import { Topic } from '@restorecommerce/kafka-client';
6	import { BaseDocument, DocumentMetadata } from './interfaces';
7	import { DatabaseProvider, GraphDatabaseProvider } from '@restorecommerce/chassis-srv';
8	import { DeepPartial } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/attribute';
9	import { Search } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/resource_base';
10	import { Subject } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/auth';
11	import { fieldHandler } from './utils';	1✔
12
13	let redisClient: any;
14
15	const Strategies = {	1✔
16	INCREMENT: 'increment',
17	UUID: 'uuid',
18	RANDOM: 'random',
19	TIMESTAMP: 'timestamp'
20	};
21
22	const uuidGen = (): string => {	1✔
23	return uuid.v4().replace(/-/g, '');	2✔
24	};
25
26	const isEmptyObject = (obj: any): any => {	1✔
27	return !Object.keys(obj).length;	86✔
28	};
29
30	const setDefaults = async (obj: { meta?: DocumentMetadata;[key: string]: any }, collectionName: string, subject: Subject): Promise<any> => {	1✔
31	const o = obj;	88✔
32
33	if (_.isEmpty(o.meta)) {	88!
34	throw new errors.InvalidArgument('Object does not contain ownership information');	×
35	}
36
37	if (redisClient) {	88!
38	const values = await redisClient.hGetAll(collectionName);	×
39
40	if (values) {	×
41	for (let field in values) {	×
42	const strategy = values[field];	×
43	switch (strategy) {	×
44	case Strategies.INCREMENT:	×
45	const key = collectionName + ':' + field;	×
46	o[field] = await redisClient.get(key);	×
47	await redisClient.incr(key);	×
48	break;	×
49	case Strategies.UUID:
50	o[field] = uuidGen();	×
51	break;	×
52	case Strategies.RANDOM:
53	o[field] = uuidGen();	×
54	break;	×
55	case Strategies.TIMESTAMP:
56	o[field] = await redisClient.time()[0];	×
57	break;	×
58	}
59	}
60	}
61	}
62
63	if (_.isNil(o.meta.created) \|\| o.meta.created === 0) {	88✔
64	o.meta.created = new Date();	8✔
65	}
66	o.meta.created_by = subject?.id;	88✔
67	o.meta.modified_by = subject?.id;	88✔
68	o.meta.modified = new Date();	88✔
69	if (_.isNil(o.id) \|\| o.id === 0 \|\| isEmptyObject(o.id)) {	88✔
70	o.id = uuidGen();	2✔
71	}
72	return o;	88✔
73	};
74
75	const updateMetadata = (docMeta: DocumentMetadata, newDoc: BaseDocument, subject: Subject): BaseDocument => {	1✔
76	if (_.isEmpty(newDoc.meta)) {	13!
77	throw new errors.InvalidArgument(`Update request holds no valid metadata for document ${newDoc.id}`);	×
78	}
79
80	if (!_.isEmpty(newDoc.meta?.owners)) {	13✔
81	// if ownership is meant to be updated
82	docMeta.owners = newDoc.meta.owners;	7✔
83	}
84
85	docMeta.modified_by = subject?.id;	13✔
86	docMeta.modified = new Date();	13✔
87
88	newDoc.meta = docMeta;	13✔
89	return newDoc;	13✔
90	};
91
92	/**
93	* Resource API base provides functions for CRUD operations.
94	*/
95	export class ResourcesAPIBase {	1✔
96	public readonly bufferFields: string[];
97	public readonly requiredFields: any;
98	public readonly timeStampFields: string[];
99	/**
100	* @constructor
101	* @param {object} db Chassis arangodb provider.
102	* @param {string} collectionName Name of database collection.
103	* @param {any} fieldHandlerConf The collection's field generators configuration.
104	*/
105	constructor(
106	public readonly db: DatabaseProvider,	6✔
107	public readonly collectionName: string,	6✔
108	fieldHandlerConf?: any,
109	public readonly edgeCfg?: any,	6✔
110	public readonly graphName?: string,	6✔
111	public readonly logger?: Logger,	6✔
112	public readonly resourceName?: string,	6✔
113	) {
114	this.resourceName ??= collectionName.substring(0, collectionName.length - 1);	6✔
115
116	if (!fieldHandlerConf) {	6✔
117	return;	4✔
118	}
119
120	const strategyCfg = fieldHandlerConf.strategies;	2✔
121	if (!redisClient) {	2✔
122	redisClient = fieldHandlerConf.redisClient;	2✔
123	}
124
125	if (fieldHandlerConf.bufferFields) {	2✔
126	this.bufferFields = fieldHandlerConf.bufferFields;	2✔
127	}
128
129	// config fix to be removed after ts-proto is used
130	if (fieldHandlerConf.timeStampFields) {	2✔
131	this.timeStampFields = fieldHandlerConf.timeStampFields;	2✔
132	}
133
134	if (fieldHandlerConf.requiredFields) {	2✔
135	this.requiredFields = fieldHandlerConf.requiredFields[this.resourceName] ?? fieldHandlerConf.requiredFields;	2✔
136	}
137
138	// values for Redis hash set
139	for (let field in strategyCfg) {	2✔
140	const strategy = strategyCfg[field].strategy;	×
141	redisClient.hSet(collectionName, field, strategy);	×
142	switch (strategy) {	×
143	case Strategies.INCREMENT:	×
144	// check if value already exists in redis
145	let startingValue: any;
146	startingValue = redisClient.get(`${collectionName}:${field}`).then((val) => val);	×
147	if (!startingValue) {	×
148	if (strategyCfg[field].startingValue) {	×
149	startingValue = Number.isNaN(strategyCfg[field].startingValue) ?	×
150	'0' : strategyCfg[field].startingValue;	×
151	}
152	else {
153	startingValue = '0';	×
154	}
155	redisClient.set(`${collectionName}:${field}`, startingValue).then((val) => val);	×
156	}
157	break;	×
158	default:
159	break;	×
160	}
161	}
162	}
163
164
165	/**
166	* Finds documents based on provided filters and options
167	* @param {object} filter key value filter using mongodb/nedb filter format.
168	* @param {number} limit
169	* @param {number} offset
170	* @param {object} sort key value, key=field value: 1=ASCENDING, -1=DESCENDING, 0=UNSORTED
171	* @param {object} field key value, key=field value: 0=exclude, 1=include
172	* @returns {an Object that contains an items field}
173	*/
174	async read(
175	filter: Object = {},	×
176	limit = 1000,	21✔
177	offset = 0,	21✔
178	sort: any = {},	21✔
179	field: any = {},	×
180	customQueries: string[] = [],	21✔
181	customArgs: any = {},	×
182	search: DeepPartial<Search>
183	): Promise<BaseDocument[]> {
184	const options = {	22✔
185	limit: Math.min(limit, 1000),
186	offset,
187	sort,
188	fields: field,
189	customQueries,
190	customArguments: customArgs.value ? JSON.parse(customArgs.value.toString()) : {},	22✔
191	search
192	};
193	let entities: BaseDocument[] = await this.db.find(this.collectionName, filter, options);	22✔
194	if (this.bufferFields && entities?.length > 0) {	22✔
195	// encode the msg obj back to buffer obj and send it back
196	entities = this.encodeOrDecode(entities, this.bufferFields, 'encode');	20✔
197	}
198	if (this.timeStampFields && entities?.length > 0) {	22✔
199	// convert number to Date Object
200	entities = this.encodeOrDecode(entities, this.timeStampFields, 'convertMilisecToDateObj');	20✔
201	}
202	return entities;	22✔
203	}
204
205	/**
206	* Inserts documents to the database.
207	*
208	* @param {array.object} documents
209	*/
210	async create(documents: BaseDocument[], subject: Subject): Promise<any> {
211	const collection = this.collectionName;	32✔
212	let result = [];	32✔
213	try {	32✔
214	// check if all the required fields are present
215	if (this.requiredFields) {	32✔
216	const requiredFieldsResult = this.checkRequiredFields(	27✔
217	this.requiredFields,
218	documents,
219	result
220	);
221	documents = requiredFieldsResult.documents;	27✔
222	result = requiredFieldsResult.result;	27✔
223	}
224
225	documents = await Promise.all(documents.map(async (doc) => {	32✔
226	return await setDefaults(doc, collection, subject);	86✔
227	}));
228
229	if (this.bufferFields && documents?.length > 0) {	32✔
230	documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');	26✔
231	}
232	if (this.timeStampFields && documents?.length > 0) {	32✔
233	// convert Date Object to Number
234	documents = this.encodeOrDecode(documents, this.timeStampFields, 'convertDateObjToMilisec');	26✔
235	}
236	if (this.isGraphDB(this.db)) {	32✔
237	await this.db.createGraphDB(this.graphName);	5✔
238	await this.db.addVertexCollection(collection);	5✔
239	let createVertexResp = await this.db.createVertex(collection, documents);	5✔
240	for (let document of documents) {	5✔
241	if (this.edgeCfg && Array.isArray(this.edgeCfg) && this.edgeCfg.length > 0) {	11✔
242	for (let eachEdgeCfg of this.edgeCfg) {	11✔
243	const fromIDkey = eachEdgeCfg.from;	14✔
244	const from_id = document[fromIDkey];	14✔
245	const toIDkey = eachEdgeCfg.to;	14✔
246	const to_id = document[toIDkey];	14✔
247	// edges are created outbound, if it is inbound - check for direction
248	const direction = eachEdgeCfg.direction;	14✔
249	let fromVerticeName = collection;	14✔
250	let toVerticeName = eachEdgeCfg.toVerticeName;	14✔
251	if (direction === 'inbound') {	14!
UNCOV 252	fromVerticeName = eachEdgeCfg.fromVerticeName;	×
UNCOV 253	toVerticeName = collection;	×
254	}
255	if (from_id && to_id) {	14✔
256	if (Array.isArray(to_id)) {	10!
UNCOV 257	for (let toID of to_id) {	×
UNCOV 258	await this.db.createEdge(eachEdgeCfg.edgeName, null,	×
259	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
260	}
261	} else {
262	await this.db.createEdge(eachEdgeCfg.edgeName, null,	10✔
263	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
264	}
265	}
266	}
267	}
268	}
269	if (Array.isArray(createVertexResp)) {	5!
270	createVertexResp.forEach((eachVertexResp) => result.push(eachVertexResp));	11✔
271	} else {
UNCOV 272	result.push(createVertexResp);	×
273	}
274	if (this.timeStampFields && result?.length > 0) {	5!
275	// convert number to Date Object
UNCOV 276	result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');	×
277	}
278
279	return result;	5✔
280	}
281	else {
282	let checkReqFieldResult = [];	27✔
283	if (!_.isEmpty(result)) {	27✔
284	checkReqFieldResult = result;	1✔
285	}
286	result = await this.db.insert(collection, documents);	27✔
287	if (!_.isEmpty(checkReqFieldResult)) {	27✔
288	checkReqFieldResult.forEach((reqFieldResult) => result.push(reqFieldResult));	3✔
289	}
290	if (this.timeStampFields && result?.length > 0) {	27✔
291	// convert number to Date Object
292	result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');	27✔
293	}
294	return result;	27✔
295	}
296	} catch (error) {
UNCOV 297	this.logger?.error('Error creating documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 298	result.push({	×
299	error: true,
300	errorNum: error?.code,
301	errorMessage: error?.details ? error?.details : error?.message	×
302	});
UNCOV 303	return result;	×
304	}
305	}
306
307	private isGraphDB(db: DatabaseProvider): db is GraphDatabaseProvider {
308	return !!this.edgeCfg;	48✔
309	}
310
311	/**
312	* Check if a resource's required fields are present.
313	* @param requiredFields
314	* @param documents
315	*/
316	checkRequiredFields(requiredFields: string[], documents: any[], result: any[]): any {
317	documents = documents.filter((document) => {	27✔
318	return requiredFields.every((eachField) => {	78✔
319	if (document[eachField] === undefined \|\| (Array.isArray(document[eachField]) && document[eachField].length === 0)) {	78!
320	result.push({	3✔
321	error: true,
322	errorNum: 400,
323	errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
324	});
325	return false;	3✔
326	}
327	return true;	75✔
328	});
329	});
330	return { documents, result };	27✔
331	}
332
333	/**
334	* Removes documents found by id.
335	*
336	* @param [array.string] ids List of document IDs.
337	*/
338	async delete(ids: string[]): Promise<any> {
339	let deleteResponse = [];	2✔
340	try {	2✔
341	if (!Array.isArray(ids)) {	2!
UNCOV 342	ids = [ids];	×
343	}
344	if (this.isGraphDB(this.db)) {	2✔
345	// Modify the Ids to include documentHandle
346	if (ids.length > 0) {	1✔
347	ids = _.map(ids, (id) => {	1✔
348	return `${this.collectionName}/${id}`;	2✔
349	});
350	deleteResponse = await this.db.removeVertex(this.collectionName, ids);	1✔
351	return deleteResponse;	1✔
352	}
353	}
354	deleteResponse = await this.db.delete(this.collectionName, ids);	1✔
355	return deleteResponse;	1✔
356	}
357	catch (error) {
UNCOV 358	this.logger?.error('Error deleting documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 359	deleteResponse.push({	×
360	error: true,
361	errorNum: error?.code,
362	errorMessage: error?.details ? error?.details : error?.message	×
363	});
UNCOV 364	return deleteResponse;	×
365	}
366	}
367
368	/**
369	* Delete all documents in the collection.
370	*/
371	async deleteCollection(): Promise<Array<any>> {
372	if (this.isGraphDB(this.db)) {	4✔
373	// graph edges are only deleted automatically when a specific vertex is deleted
374	// (`truncate` does not work in this case)
375	const ids = await this.db.find(this.collectionName, {}, {	1✔
376	fields: {
377	id: 1
378	}
379	});
380
381	await this.delete(_.map(ids, (doc) => {	1✔
382	return doc.id;	2✔
383	}));
384	return ids;	1✔
385	} else {
386	const entities = await this.db.find(this.collectionName, {}, { fields: { id: 1 } });	3✔
387	await this.db.truncate(this.collectionName);	3✔
388	return entities;	3✔
389	}
390	}
391
392	/**
393	* Upserts documents.
394	*
395	* @param [array.object] documents
396	*/
397	async upsert(documents: BaseDocument[],
398	events: Topic, resourceName: string, subject: Subject): Promise<BaseDocument[]> {
399	let result = [];	2✔
400	let createDocsResult = [];	2✔
401	let updateDocsResult = [];	2✔
402	try {	2✔
403	let createDocuments = [];	2✔
404	let updateDocuments = [];	2✔
405	if (this.bufferFields && documents) {	2✔
406	documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');	1✔
407	}
408	const dispatch = await Promise.all(documents.map(async (doc) => {	2✔
409	let foundDocs;
410	if (doc && doc.id) {	6✔
411	foundDocs = await this.db.find(this.collectionName, { id: doc.id }, {	6✔
412	fields: {
413	meta: 1
414	}
415	});
416	}
417	let eventName: string;
418	if (_.isEmpty(foundDocs)) {	6✔
419	// insert
420	setDefaults(doc, this.collectionName, subject);	2✔
421	createDocuments.push(doc);	2✔
422	eventName = 'Created';	2✔
423	} else {
424	// convert dateTimeStamp fields
425	if (this.timeStampFields) {	4✔
426	foundDocs = this.encodeOrDecode(foundDocs, this.timeStampFields, 'convertMilisecToDateObj');	2✔
427	}
428	// update
429	const dbDoc = foundDocs[0];	4✔
430	updateMetadata(dbDoc.meta, doc, subject);	4✔
431	updateDocuments.push(doc);	4✔
432	eventName = 'Modified';	4✔
433	}
434	if (events) {	6✔
435	return events.emit(`${resourceName}${eventName}`, doc);	3✔
436	}
437	}));
438
439	if (createDocuments?.length > 0) {	2✔
440	createDocsResult = await this.create(createDocuments, subject);	2✔
441	}
442
443	if (updateDocuments?.length > 0) {	2✔
444	updateDocsResult = await this.update(updateDocuments, subject);	2✔
445	}
446
447	result = _.union(createDocuments, updateDocuments);	2✔
448
449	if (this.timeStampFields && result?.length > 0) {	2✔
450	// convert number to Date Object
451	result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');	1✔
452	}
453	await Promise.all(dispatch);	2✔
454
455	if (this.bufferFields && result?.length > 0) {	2✔
456	result = this.encodeOrDecode(result, this.bufferFields, 'encode');	1✔
457	}
458
459	return result;	2✔
460	} catch (error) {
UNCOV 461	this.logger?.error('Error upserting documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 462	result.push({	×
463	error: true,
464	errorNum: error?.code,
465	errorMessage: error?.details ? error?.details : error?.message	×
466	});
UNCOV 467	return result;	×
468	}
469	}
470
471	/**
472	* Finds documents by id and updates them.
473	*
474	* @param [array.object] documents
475	* A list of documents or partial documents. Each document must contain an id field.
476	*/
477	async update(documents: BaseDocument[], subject: Subject): Promise<BaseDocument[]> {
478	let updateResponse = [];	5✔
479	try {	5✔
480	const collectionName = this.collectionName;	5✔
481	if (this.bufferFields && documents) {	5✔
482	documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');	3✔
483	}
484	let docsWithUpMetadata = await Promise.all(documents.map(async (doc) => {	5✔
485	let foundDocs = await this.db.find(	10✔
486	collectionName,
487	{ id: doc.id },
488	{ limit: 1 }
489	);
490	let dbDoc;
491	if (foundDocs && foundDocs.length === 1) {	10✔
492	dbDoc = foundDocs[0];	9✔
493	doc = updateMetadata(dbDoc.meta, doc, subject);	9✔
494	} else {
495	dbDoc = doc; // doc not existing assigning to generate error message in response	1✔
496	}
497
498	if (this.isGraphDB(this.db)) {	10✔
499	const db = this.db;	4✔
500	await Promise.all(this.edgeCfg.map(async (eachEdgeCfg) => {	4✔
501	const toIDkey = eachEdgeCfg.to;	8✔
502	let modified_to_idValues = doc[toIDkey];	8✔
503	let db_to_idValues = dbDoc[toIDkey];	8✔
504	if (Array.isArray(modified_to_idValues)) {	8!
505	modified_to_idValues = _.sortBy(modified_to_idValues);	×
506	}
507	if (Array.isArray(db_to_idValues)) {	8!
UNCOV 508	db_to_idValues = _.sortBy(db_to_idValues);	×
509	}
510	// delete and recreate only if there is a difference in references
511	if (!_.isEqual(modified_to_idValues, db_to_idValues)) {	8✔
512	// delete and recreate the edge (since there is no way to update the edge as we dont add id to the edge as for doc)
513	const fromIDkey = eachEdgeCfg.from;	4✔
514	const from_id = doc[fromIDkey];	4✔
515	let fromVerticeName = collectionName;	4✔
516	let toVerticeName = eachEdgeCfg.toVerticeName;	4✔
517	const direction = eachEdgeCfg.direction;	4✔
518	if (direction === 'inbound') {	4!
UNCOV 519	fromVerticeName = eachEdgeCfg.fromVerticeName;	×
UNCOV 520	toVerticeName = collectionName;	×
521	}
522
523	const edgeCollectionName = eachEdgeCfg.edgeName;	4✔
524	let outgoingEdges: any = await db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);	4✔
525	if (Array.isArray(outgoingEdges.edges)) {	4✔
526	await Promise.all(outgoingEdges.edges.map((outgoingEdge) => db.removeEdge(edgeCollectionName, outgoingEdge._id)));	4✔
527	}
528	let incomingEdges: any = await db.getInEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);	4✔
529	if (Array.isArray(incomingEdges.edges)) {	4✔
530	await Promise.all(incomingEdges.edges.map((incomingEdge) => db.removeEdge(edgeCollectionName, incomingEdge._id)));	4✔
531	}
532	// Create new edges
533	if (from_id && modified_to_idValues) {	4✔
534	if (Array.isArray(modified_to_idValues)) {	4!
UNCOV 535	await Promise.all(modified_to_idValues.map((toID) => db.createEdge(eachEdgeCfg.edgeName, null,	×
536	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`)));
537	} else {
538	await db.createEdge(edgeCollectionName, null,	4✔
539	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);
540	}
541	}
542	}
543	}));
544	}
545	return doc;	10✔
546	}));
547
548	if (this.timeStampFields && docsWithUpMetadata?.length > 0) {	5✔
549	docsWithUpMetadata = this.encodeOrDecode(docsWithUpMetadata, this.timeStampFields, 'convertDateObjToMilisec');	3✔
550	}
551	updateResponse = await this.db.update(collectionName, docsWithUpMetadata);	5✔
552	if (this.timeStampFields && updateResponse?.length > 0) {	5✔
553	updateResponse = this.encodeOrDecode(updateResponse, this.timeStampFields, 'convertMilisecToDateObj');	3✔
554	}
555	if (this.bufferFields && updateResponse?.length > 0) {	5✔
556	updateResponse = this.encodeOrDecode(updateResponse, this.bufferFields, 'encode');	3✔
557	}
558	return updateResponse;	5✔
559	} catch (error) {
UNCOV 560	this.logger?.error('Error updating documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 561	updateResponse.push({	×
562	error: true,
563	errorNum: error?.code,
564	errorMessage: error?.message
565	});
UNCOV 566	return updateResponse;	×
567	}
568	}
569
570	private encodeOrDecode(documents: any, fieldPaths: string[], fieldHanlder: string): any {
571	for (let doc of documents) {	136✔
572	for (let fieldPath of fieldPaths) {	357✔
573	doc = fieldHandler(doc, fieldPath, fieldHanlder);	791✔
574	}
575	}
576	return documents;	136✔
577	}
578	}

restorecommerce / resource-base-interface / 11838820957

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