11387969511

Committed 17 Oct 2024 03:16PM UTC coverage: 66.507% (-7.9%) from 74.455%

Build Type

push

github

Committed by Gerald Baulig

Commit Message

fix(test): up deps, still tsc build

Run Details

266 of 411 branches covered (64.72%)

Branch coverage included in aggregate %.

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

54 existing lines in 2 files now uncovered.

566 of 840 relevant lines covered (67.38%)

27.82 hits per line

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

77.5

/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[];
  public readonly resourceName: 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
  ) {
    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;
    }

    // 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 {
      let result = [];
      // check if all the required fields are present
      if (this.requiredFields && this.requiredFields[this.resourceName]) {
        const requiredFieldsResult = this.checkRequiredFields(this.requiredFields[this.resourceName],
          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 && _.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 (_.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 (_.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.forEach((document) => {
      requiredFields.forEach((eachField) => {
        const isArray = _.isArray(eachField);
        if (!document[eachField]) {
          result.push({
            error: true,
            errorNum: 400,
            errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
          });
          documents = documents.filter(doc => doc.id != document.id);
        }
        if ((isArray && document[eachField].length == 0)) {
          result.push({
            error: true,
            errorNum: 400,
            errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
          });
          documents = documents.filter(doc => doc.id != document.id);
        }
      });
    });
    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 (!_.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 (_.isArray(modified_to_idValues)) {
              modified_to_idValues = _.sortBy(modified_to_idValues);
            }
            if (_.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 (_.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 (_.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 (_.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;	85✔
28	};
29
30	const setDefaults = async (obj: { meta?: DocumentMetadata;[key: string]: any }, collectionName: string, subject: Subject): Promise<any> => {	1✔
31	const o = obj;	87✔
32
33	if (_.isEmpty(o.meta)) {	87!
UNCOV 34	throw new errors.InvalidArgument('Object does not contain ownership information');	×
35	}
36
37	if (redisClient) {	87!
UNCOV 38	const values = await redisClient.hGetAll(collectionName);	×
39
40	if (values) {	×
41	for (let field in values) {	×
42	const strategy = values[field];	×
UNCOV 43	switch (strategy) {	×
44	case Strategies.INCREMENT:	×
45	const key = collectionName + ':' + field;	×
46	o[field] = await redisClient.get(key);	×
47	await redisClient.incr(key);	×
UNCOV 48	break;	×
49	case Strategies.UUID:
50	o[field] = uuidGen();	×
UNCOV 51	break;	×
52	case Strategies.RANDOM:
53	o[field] = uuidGen();	×
UNCOV 54	break;	×
55	case Strategies.TIMESTAMP:
56	o[field] = await redisClient.time()[0];	×
UNCOV 57	break;	×
58	}
59	}
60	}
61	}
62
63	if (_.isNil(o.meta.created) \|\| o.meta.created === 0) {	87✔
64	o.meta.created = new Date();	8✔
65	}
66	o.meta.created_by = subject?.id;	87✔
67	o.meta.modified_by = subject?.id;	87✔
68	o.meta.modified = new Date();	87✔
69	if (_.isNil(o.id) \|\| o.id === 0 \|\| isEmptyObject(o.id)) {	87✔
70	o.id = uuidGen();	2✔
71	}
72	return o;	87✔
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	public readonly resourceName: string;
100	/**
101	* @constructor
102	* @param {object} db Chassis arangodb provider.
103	* @param {string} collectionName Name of database collection.
104	* @param {any} fieldHandlerConf The collection's field generators configuration.
105	*/
106	constructor(
107	public readonly db: DatabaseProvider,	6✔
108	public readonly collectionName: string,	6✔
109	fieldHandlerConf?: any,
110	public readonly edgeCfg?: any,	6✔
111	public readonly graphName?: string,	6✔
112	public readonly logger?: Logger	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;	2✔
136	}
137
138	// values for Redis hash set
139	for (let field in strategyCfg) {	2✔
UNCOV 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;
UNCOV 146	startingValue = redisClient.get(`${collectionName}:${field}`).then((val) => val);	×
UNCOV 147	if (!startingValue) {	×
148	if (strategyCfg[field].startingValue) {	×
UNCOV 149	startingValue = Number.isNaN(strategyCfg[field].startingValue) ?	×
150	'0' : strategyCfg[field].startingValue;	×
151	}
152	else {
UNCOV 153	startingValue = '0';	×
154	}
UNCOV 155	redisClient.set(`${collectionName}:${field}`, startingValue).then((val) => val);	×
156	}
UNCOV 157	break;	×
158	default:
UNCOV 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	let result = [];	32✔
215	// check if all the required fields are present
216	if (this.requiredFields && this.requiredFields[this.resourceName]) {	32✔
217	const requiredFieldsResult = this.checkRequiredFields(this.requiredFields[this.resourceName],	27✔
218	documents, result);
219	documents = requiredFieldsResult.documents;	27✔
220	result = requiredFieldsResult.result;	27✔
221	}
222
223	documents = await Promise.all(documents.map(async (doc) => {	32✔
224	return await setDefaults(doc, collection, subject);	85✔
225	}));
226
227	if (this.bufferFields && documents?.length > 0) {	32✔
228	documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');	25✔
229	}
230	if (this.timeStampFields && documents?.length > 0) {	32✔
231	// convert Date Object to Number
232	documents = this.encodeOrDecode(documents, this.timeStampFields, 'convertDateObjToMilisec');	25✔
233	}
234	if (this.isGraphDB(this.db)) {	32✔
235	await this.db.createGraphDB(this.graphName);	5✔
236	await this.db.addVertexCollection(collection);	5✔
237	let createVertexResp = await this.db.createVertex(collection, documents);	5✔
238	for (let document of documents) {	5✔
239	if (this.edgeCfg && _.isArray(this.edgeCfg) && this.edgeCfg.length > 0) {	11✔
240	for (let eachEdgeCfg of this.edgeCfg) {	11✔
241	const fromIDkey = eachEdgeCfg.from;	14✔
242	const from_id = document[fromIDkey];	14✔
243	const toIDkey = eachEdgeCfg.to;	14✔
244	const to_id = document[toIDkey];	14✔
245	// edges are created outbound, if it is inbound - check for direction
246	const direction = eachEdgeCfg.direction;	14✔
247	let fromVerticeName = collection;	14✔
248	let toVerticeName = eachEdgeCfg.toVerticeName;	14✔
249	if (direction === 'inbound') {	14!
UNCOV 250	fromVerticeName = eachEdgeCfg.fromVerticeName;	×
UNCOV 251	toVerticeName = collection;	×
252	}
253	if (from_id && to_id) {	14✔
254	if (_.isArray(to_id)) {	10!
UNCOV 255	for (let toID of to_id) {	×
UNCOV 256	await this.db.createEdge(eachEdgeCfg.edgeName, null,	×
257	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
258	}
259	} else {
260	await this.db.createEdge(eachEdgeCfg.edgeName, null,	10✔
261	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
262	}
263	}
264	}
265	}
266	}
267	if (_.isArray(createVertexResp)) {	5!
268	createVertexResp.forEach((eachVertexResp) => result.push(eachVertexResp));	11✔
269	} else {
UNCOV 270	result.push(createVertexResp);	×
271	}
272	if (this.timeStampFields && result?.length > 0) {	5!
273	// convert number to Date Object
UNCOV 274	result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');	×
275	}
276
277	return result;	5✔
278	}
279	else {
280	let checkReqFieldResult = [];	27✔
281	if (!_.isEmpty(result)) {	27✔
282	checkReqFieldResult = result;	2✔
283	}
284	result = await this.db.insert(collection, documents);	27✔
285	if (!_.isEmpty(checkReqFieldResult)) {	27✔
286	checkReqFieldResult.forEach((reqFieldResult) => result.push(reqFieldResult));	4✔
287	}
288	if (this.timeStampFields && result?.length > 0) {	27✔
289	// convert number to Date Object
290	result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');	27✔
291	}
292	return result;	27✔
293	}
294	} catch (error) {
UNCOV 295	this.logger?.error('Error creating documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 296	result.push({	×
297	error: true,
298	errorNum: error?.code,
299	errorMessage: error?.details ? error?.details : error?.message	×
300	});
UNCOV 301	return result;	×
302	}
303	}
304
305	private isGraphDB(db: DatabaseProvider): db is GraphDatabaseProvider {
306	return !!this.edgeCfg;	48✔
307	}
308
309	/**
310	* Check if a resource's required fields are present.
311	* @param requiredFields
312	* @param documents
313	*/
314	checkRequiredFields(requiredFields: string[], documents: any, result: any[]): any {
315	documents.forEach((document) => {	27✔
316	requiredFields.forEach((eachField) => {	78✔
317	const isArray = _.isArray(eachField);	78✔
318	if (!document[eachField]) {	78✔
319	result.push({	4✔
320	error: true,
321	errorNum: 400,
322	errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
323	});
324	documents = documents.filter(doc => doc.id != document.id);	7✔
325	}
326	if ((isArray && document[eachField].length == 0)) {	78!
UNCOV 327	result.push({	×
328	error: true,
329	errorNum: 400,
330	errorMessage: `Field ${eachField} is necessary for ${this.resourceName} for documentID ${document.id}`
331	});
UNCOV 332	documents = documents.filter(doc => doc.id != document.id);	×
333	}
334	});
335	});
336	return { documents, result };	27✔
337	}
338
339	/**
340	* Removes documents found by id.
341	*
342	* @param [array.string] ids List of document IDs.
343	*/
344	async delete(ids: string[]): Promise<any> {
345	let deleteResponse = [];	2✔
346	try {	2✔
347	if (!_.isArray(ids)) {	2!
UNCOV 348	ids = [ids];	×
349	}
350	if (this.isGraphDB(this.db)) {	2✔
351	// Modify the Ids to include documentHandle
352	if (ids.length > 0) {	1✔
353	ids = _.map(ids, (id) => {	1✔
354	return `${this.collectionName}/${id}`;	2✔
355	});
356	deleteResponse = await this.db.removeVertex(this.collectionName, ids);	1✔
357	return deleteResponse;	1✔
358	}
359	}
360	deleteResponse = await this.db.delete(this.collectionName, ids);	1✔
361	return deleteResponse;	1✔
362	}
363	catch (error) {
UNCOV 364	this.logger?.error('Error deleting documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 365	deleteResponse.push({	×
366	error: true,
367	errorNum: error?.code,
368	errorMessage: error?.details ? error?.details : error?.message	×
369	});
UNCOV 370	return deleteResponse;	×
371	}
372	}
373
374	/**
375	* Delete all documents in the collection.
376	*/
377	async deleteCollection(): Promise<Array<any>> {
378	if (this.isGraphDB(this.db)) {	4✔
379	// graph edges are only deleted automatically when a specific vertex is deleted
380	// (`truncate` does not work in this case)
381	const ids = await this.db.find(this.collectionName, {}, {	1✔
382	fields: {
383	id: 1
384	}
385	});
386
387	await this.delete(_.map(ids, (doc) => {	1✔
388	return doc.id;	2✔
389	}));
390	return ids;	1✔
391	} else {
392	const entities = await this.db.find(this.collectionName, {}, { fields: { id: 1 } });	3✔
393	await this.db.truncate(this.collectionName);	3✔
394	return entities;	3✔
395	}
396	}
397
398	/**
399	* Upserts documents.
400	*
401	* @param [array.object] documents
402	*/
403	async upsert(documents: BaseDocument[],
404	events: Topic, resourceName: string, subject: Subject): Promise<BaseDocument[]> {
405	let result = [];	2✔
406	let createDocsResult = [];	2✔
407	let updateDocsResult = [];	2✔
408	try {	2✔
409	let createDocuments = [];	2✔
410	let updateDocuments = [];	2✔
411	if (this.bufferFields && documents) {	2✔
412	documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');	1✔
413	}
414	const dispatch = await Promise.all(documents.map(async (doc) => {	2✔
415	let foundDocs;
416	if (doc && doc.id) {	6✔
417	foundDocs = await this.db.find(this.collectionName, { id: doc.id }, {	6✔
418	fields: {
419	meta: 1
420	}
421	});
422	}
423	let eventName: string;
424	if (_.isEmpty(foundDocs)) {	6✔
425	// insert
426	setDefaults(doc, this.collectionName, subject);	2✔
427	createDocuments.push(doc);	2✔
428	eventName = 'Created';	2✔
429	} else {
430	// convert dateTimeStamp fields
431	if (this.timeStampFields) {	4✔
432	foundDocs = this.encodeOrDecode(foundDocs, this.timeStampFields, 'convertMilisecToDateObj');	2✔
433	}
434	// update
435	const dbDoc = foundDocs[0];	4✔
436	updateMetadata(dbDoc.meta, doc, subject);	4✔
437	updateDocuments.push(doc);	4✔
438	eventName = 'Modified';	4✔
439	}
440	if (events) {	6✔
441	return events.emit(`${resourceName}${eventName}`, doc);	3✔
442	}
443	}));
444
445	if (createDocuments?.length > 0) {	2✔
446	createDocsResult = await this.create(createDocuments, subject);	2✔
447	}
448
449	if (updateDocuments?.length > 0) {	2✔
450	updateDocsResult = await this.update(updateDocuments, subject);	2✔
451	}
452
453	result = _.union(createDocuments, updateDocuments);	2✔
454
455	if (this.timeStampFields && result?.length > 0) {	2✔
456	// convert number to Date Object
457	result = this.encodeOrDecode(result, this.timeStampFields, 'convertMilisecToDateObj');	1✔
458	}
459	await Promise.all(dispatch);	2✔
460
461	if (this.bufferFields && result?.length > 0) {	2✔
462	result = this.encodeOrDecode(result, this.bufferFields, 'encode');	1✔
463	}
464
465	return result;	2✔
466	} catch (error) {
UNCOV 467	this.logger?.error('Error upserting documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 468	result.push({	×
469	error: true,
470	errorNum: error?.code,
471	errorMessage: error?.details ? error?.details : error?.message	×
472	});
UNCOV 473	return result;	×
474	}
475	}
476
477	/**
478	* Finds documents by id and updates them.
479	*
480	* @param [array.object] documents
481	* A list of documents or partial documents. Each document must contain an id field.
482	*/
483	async update(documents: BaseDocument[], subject: Subject): Promise<BaseDocument[]> {
484	let updateResponse = [];	5✔
485	try {	5✔
486	const collectionName = this.collectionName;	5✔
487	if (this.bufferFields && documents) {	5✔
488	documents = this.encodeOrDecode(documents, this.bufferFields, 'decode');	3✔
489	}
490	let docsWithUpMetadata = await Promise.all(documents.map(async (doc) => {	5✔
491	let foundDocs = await this.db.find(	10✔
492	collectionName,
493	{ id: doc.id },
494	{ limit: 1 }
495	);
496	let dbDoc;
497	if (foundDocs && foundDocs.length === 1) {	10✔
498	dbDoc = foundDocs[0];	9✔
499	doc = updateMetadata(dbDoc.meta, doc, subject);	9✔
500	} else {
501	dbDoc = doc; // doc not existing assigning to generate error message in response	1✔
502	}
503
504	if (this.isGraphDB(this.db)) {	10✔
505	const db = this.db;	4✔
506	await Promise.all(this.edgeCfg.map(async (eachEdgeCfg) => {	4✔
507	const toIDkey = eachEdgeCfg.to;	8✔
508	let modified_to_idValues = doc[toIDkey];	8✔
509	let db_to_idValues = dbDoc[toIDkey];	8✔
510	if (_.isArray(modified_to_idValues)) {	8!
UNCOV 511	modified_to_idValues = _.sortBy(modified_to_idValues);	×
512	}
513	if (_.isArray(db_to_idValues)) {	8!
UNCOV 514	db_to_idValues = _.sortBy(db_to_idValues);	×
515	}
516	// delete and recreate only if there is a difference in references
517	if (!_.isEqual(modified_to_idValues, db_to_idValues)) {	8✔
518	// 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)
519	const fromIDkey = eachEdgeCfg.from;	4✔
520	const from_id = doc[fromIDkey];	4✔
521	let fromVerticeName = collectionName;	4✔
522	let toVerticeName = eachEdgeCfg.toVerticeName;	4✔
523	const direction = eachEdgeCfg.direction;	4✔
524	if (direction === 'inbound') {	4!
525	fromVerticeName = eachEdgeCfg.fromVerticeName;	×
UNCOV 526	toVerticeName = collectionName;	×
527	}
528
529	const edgeCollectionName = eachEdgeCfg.edgeName;	4✔
530	let outgoingEdges: any = await db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);	4✔
531	if (_.isArray(outgoingEdges.edges)) {	4✔
532	await Promise.all(outgoingEdges.edges.map((outgoingEdge) => db.removeEdge(edgeCollectionName, outgoingEdge._id)));	4✔
533	}
534	let incomingEdges: any = await db.getInEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);	4✔
535	if (_.isArray(incomingEdges.edges)) {	4✔
536	await Promise.all(incomingEdges.edges.map((incomingEdge) => db.removeEdge(edgeCollectionName, incomingEdge._id)));	4✔
537	}
538	// Create new edges
539	if (from_id && modified_to_idValues) {	4✔
540	if (_.isArray(modified_to_idValues)) {	4!
UNCOV 541	await Promise.all(modified_to_idValues.map((toID) => db.createEdge(eachEdgeCfg.edgeName, null,	×
542	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`)));
543	} else {
544	await db.createEdge(edgeCollectionName, null,	4✔
545	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);
546	}
547	}
548	}
549	}));
550	}
551	return doc;	10✔
552	}));
553
554	if (this.timeStampFields && docsWithUpMetadata?.length > 0) {	5✔
555	docsWithUpMetadata = this.encodeOrDecode(docsWithUpMetadata, this.timeStampFields, 'convertDateObjToMilisec');	3✔
556	}
557	updateResponse = await this.db.update(collectionName, docsWithUpMetadata);	5✔
558	if (this.timeStampFields && updateResponse?.length > 0) {	5✔
559	updateResponse = this.encodeOrDecode(updateResponse, this.timeStampFields, 'convertMilisecToDateObj');	3✔
560	}
561	if (this.bufferFields && updateResponse?.length > 0) {	5✔
562	updateResponse = this.encodeOrDecode(updateResponse, this.bufferFields, 'encode');	3✔
563	}
564	return updateResponse;	5✔
565	} catch (error) {
UNCOV 566	this.logger?.error('Error updating documents', { code: error?.code, message: error?.message, stack: error?.stack });	×
UNCOV 567	updateResponse.push({	×
568	error: true,
569	errorNum: error?.code,
570	errorMessage: error?.message
571	});
UNCOV 572	return updateResponse;	×
573	}
574	}
575
576	private encodeOrDecode(documents: any, fieldPaths: string[], fieldHanlder: string): any {
577	for (let doc of documents) {	134✔
578	for (let fieldPath of fieldPaths) {	353✔
579	doc = fieldHandler(doc, fieldPath, fieldHanlder);	783✔
580	}
581	}
582	return documents;	134✔
583	}
584	}

restorecommerce / resource-base-interface / 11387969511

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