15849467065

Committed 24 Jun 2025 11:41AM UTC coverage: 72.685% (+0.3%) from 72.363%

Build Type

push

github

Committed by Gerald Baulig

Commit Message

fix(graph): add country edges, improve error handling

Coverage Stats

69 of 90 branches covered (76.67%)

Branch coverage included in aggregate %.

6 of 45 new or added lines in 4 files covered. (13.33%)

873 of 1206 relevant lines covered (72.39%)

3.02 hits per line

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

16.79

/src/commandInterface.ts

import * as _ from 'lodash-es';
import { RedisClientType } from 'redis';
import {
  CommandInterface, Server, GraphDatabaseProvider
} from '@restorecommerce/chassis-srv';
import { Events } from '@restorecommerce/kafka-client';

export class ResourceCommandInterface extends CommandInterface {
  edgeCfg: any;
  // graphName: any;
  constructor(server: Server, cfg: any, logger: any, events: Events, redisClient: RedisClientType<any, any>) {
    super(server, cfg, logger, events, redisClient);
    const graphCfg = cfg.get('graph');
    if (graphCfg && graphCfg.vertices) {
      this.edgeCfg = graphCfg.vertices;
      // this.graphName = cfg.graph.graphName;
    }
  }

  override makeResourcesRestoreSetup(db: GraphDatabaseProvider, resource: string, collectionName?: string): any {
    const decodeBufferField = this.decodeBufferField;
    const edgeCfg = this.edgeCfg;
    collectionName ??= `${resource}s`;
    return {
      [`${resource}Created`]: async function restoreCreated(
        message: any,
        context: any,
        config: any,
        eventName: string
      ): Promise<any> {
        decodeBufferField(message, resource);
        if (edgeCfg[collectionName]) {
          const result = await db.findByID(collectionName, message.id);
          if (result?.length > 0) {
            return {};
          }
          await db.createVertex(collectionName, message);
          // Based on graphCfg create the necessary edges
          for (const eachEdgeCfg of edgeCfg[collectionName]) {
            const fromIDkey = eachEdgeCfg?.from;
            const from_id = message[fromIDkey];
            const toIDkey = eachEdgeCfg?.to;
            const to_id = message[toIDkey];
            const fromVerticeName = collectionName;
            const toVerticeName = eachEdgeCfg?.toVerticeName;
            if (fromVerticeName && toVerticeName) {
              await db.addEdgeDefinition(eachEdgeCfg.edgeName, [fromVerticeName],
                [toVerticeName]);
            }
            if (from_id && to_id) {
              if (_.isArray(to_id)) {
                for (const toID of to_id) {
                  await db.createEdge(eachEdgeCfg.edgeName, undefined as any,
                    `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
                }
                continue;
              }
              await db.createEdge(eachEdgeCfg.edgeName, undefined as any,
                `${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);
            }
          }
        } else {
          await db.insert(collectionName, message);
        }
        return {};
      },
      [`${resource}Modified`]: async function restoreModified(
        message: any,
        context: any,
        config: any,
        eventName: string
      ): Promise<any> {
        decodeBufferField(message, resource);
        // Based on graphcfg update necessary edges
        if (edgeCfg[collectionName]) {
          const foundDocs = await db.find(collectionName, { id: message.id });
          const dbDoc = foundDocs[0];
          for (const eachEdgeCfg of edgeCfg[collectionName]) {
            const toIDkey = eachEdgeCfg?.to;
            let modified_to_idValues = message[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)) {
              const fromIDkey = eachEdgeCfg?.from;
              const from_id = message[fromIDkey];
              const fromVerticeName = collectionName;
              const toVerticeName = eachEdgeCfg?.toVerticeName;

              const edgeCollectionName = eachEdgeCfg?.edgeName;
              const outgoingEdges: any = await db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);
              for (const outgoingEdge of outgoingEdges) {
                const removedEdge = await db.removeEdge(edgeCollectionName, outgoingEdge._id);
              }
              // Create new edges
              if (from_id && modified_to_idValues) {
                if (_.isArray(modified_to_idValues)) {
                  for (const toID of modified_to_idValues) {
                    await db.createEdge(eachEdgeCfg?.edgeName, undefined as any,
                      `${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);
                  }
                  continue;
                }
                await db.createEdge(edgeCollectionName, undefined as any,
                  `${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);
              }
            }
          }
        }
        message = _.omitBy(message, _.isNil);
        await db.update(collectionName, message);
        return {};
      },
      [`${resource}Deleted`]: async function restoreDeleted(
        message: any,
        context: any,
        config: any,
        eventName: string
      ): Promise<any> {
        if (edgeCfg[collectionName]) {
          // Modify the Ids to include documentHandle
          await db.removeVertex(collectionName, `${collectionName}/${message.id}`);
        } else {
          await db.delete(collectionName, [message.id]);
        }
        return {};
      }
    };
  }
}

1	import * as _ from 'lodash-es';	1✔
2	import { RedisClientType } from 'redis';	1✔
3	import {	1✔
4	CommandInterface, Server, GraphDatabaseProvider	1✔
5	} from '@restorecommerce/chassis-srv';	1✔
6	import { Events } from '@restorecommerce/kafka-client';	1✔
7		1✔
8	export class ResourceCommandInterface extends CommandInterface {	1✔
9	edgeCfg: any;	2✔
10	// graphName: any;	2✔
11	constructor(server: Server, cfg: any, logger: any, events: Events, redisClient: RedisClientType<any, any>) {	2✔
12	super(server, cfg, logger, events, redisClient);	2✔
13	const graphCfg = cfg.get('graph');	2✔
14	if (graphCfg && graphCfg.vertices) {	2✔
15	this.edgeCfg = graphCfg.vertices;	2✔
16	// this.graphName = cfg.graph.graphName;	2✔
17	}	2✔
18	}	2✔
19		2✔
20	override makeResourcesRestoreSetup(db: GraphDatabaseProvider, resource: string, collectionName?: string): any {	2✔
21	const decodeBufferField = this.decodeBufferField;	×
22	const edgeCfg = this.edgeCfg;	×
NEW 23	collectionName ??= `${resource}s`;	×
24	return {	×
NEW 25	[`${resource}Created`]: async function restoreCreated(	×
NEW 26	message: any,	×
NEW 27	context: any,	×
NEW 28	config: any,	×
NEW 29	eventName: string	×
NEW 30	): Promise<any> {	×
31	decodeBufferField(message, resource);	×
32	if (edgeCfg[collectionName]) {	×
33	const result = await db.findByID(collectionName, message.id);	×
34	if (result?.length > 0) {	×
35	return {};	×
36	}	×
37	await db.createVertex(collectionName, message);	×
38	// Based on graphCfg create the necessary edges	×
39	for (const eachEdgeCfg of edgeCfg[collectionName]) {	×
40	const fromIDkey = eachEdgeCfg?.from;	×
41	const from_id = message[fromIDkey];	×
42	const toIDkey = eachEdgeCfg?.to;	×
43	const to_id = message[toIDkey];	×
44	const fromVerticeName = collectionName;	×
45	const toVerticeName = eachEdgeCfg?.toVerticeName;	×
46	if (fromVerticeName && toVerticeName) {	×
47	await db.addEdgeDefinition(eachEdgeCfg.edgeName, [fromVerticeName],	×
48	[toVerticeName]);	×
49	}	×
50	if (from_id && to_id) {	×
51	if (_.isArray(to_id)) {	×
52	for (const toID of to_id) {	×
53	await db.createEdge(eachEdgeCfg.edgeName, undefined as any,	×
54	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);	×
55	}	×
56	continue;	×
57	}	×
58	await db.createEdge(eachEdgeCfg.edgeName, undefined as any,	×
59	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${to_id}`);	×
60	}	×
61	}	×
62	} else {	×
63	await db.insert(collectionName, message);	×
64	}	×
65	return {};	×
66	},	×
NEW 67	[`${resource}Modified`]: async function restoreModified(	×
NEW 68	message: any,	×
NEW 69	context: any,	×
NEW 70	config: any,	×
NEW 71	eventName: string	×
NEW 72	): Promise<any> {	×
73	decodeBufferField(message, resource);	×
74	// Based on graphcfg update necessary edges	×
75	if (edgeCfg[collectionName]) {	×
76	const foundDocs = await db.find(collectionName, { id: message.id });	×
77	const dbDoc = foundDocs[0];	×
78	for (const eachEdgeCfg of edgeCfg[collectionName]) {	×
79	const toIDkey = eachEdgeCfg?.to;	×
80	let modified_to_idValues = message[toIDkey];	×
81	let db_to_idValues = dbDoc[toIDkey];	×
82	if (_.isArray(modified_to_idValues)) {	×
83	modified_to_idValues = _.sortBy(modified_to_idValues);	×
84	}	×
85	if (_.isArray(db_to_idValues)) {	×
86	db_to_idValues = _.sortBy(db_to_idValues);	×
87	}	×
88	// delete and recreate only if there is a difference in references	×
89	if (!_.isEqual(modified_to_idValues, db_to_idValues)) {	×
90	const fromIDkey = eachEdgeCfg?.from;	×
91	const from_id = message[fromIDkey];	×
92	const fromVerticeName = collectionName;	×
93	const toVerticeName = eachEdgeCfg?.toVerticeName;	×
94		×
95	const edgeCollectionName = eachEdgeCfg?.edgeName;	×
96	const outgoingEdges: any = await db.getOutEdges(edgeCollectionName, `${collectionName}/${dbDoc.id}`);	×
97	for (const outgoingEdge of outgoingEdges) {	×
98	const removedEdge = await db.removeEdge(edgeCollectionName, outgoingEdge._id);	×
99	}	×
100	// Create new edges	×
101	if (from_id && modified_to_idValues) {	×
102	if (_.isArray(modified_to_idValues)) {	×
103	for (const toID of modified_to_idValues) {	×
104	await db.createEdge(eachEdgeCfg?.edgeName, undefined as any,	×
105	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${toID}`);	×
106	}	×
107	continue;	×
108	}	×
109	await db.createEdge(edgeCollectionName, undefined as any,	×
110	`${fromVerticeName}/${from_id}`, `${toVerticeName}/${modified_to_idValues}`);	×
111	}	×
112	}	×
113	}	×
114	}	×
115	message = _.omitBy(message, _.isNil);	×
116	await db.update(collectionName, message);	×
117	return {};	×
118	},	×
NEW 119	[`${resource}Deleted`]: async function restoreDeleted(	×
NEW 120	message: any,	×
NEW 121	context: any,	×
NEW 122	config: any,	×
NEW 123	eventName: string	×
NEW 124	): Promise<any> {	×
125	if (edgeCfg[collectionName]) {	×
126	// Modify the Ids to include documentHandle	×
127	await db.removeVertex(collectionName, `${collectionName}/${message.id}`);	×
128	} else {	×
129	await db.delete(collectionName, [message.id]);	×
130	}	×
131	return {};	×
132	}	×
133	};	×
134	}	×
135	}	2✔

restorecommerce / resource-srv / 15849467065

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