@hestia-earth/engine-models 0.76.0 → 0.76.2

package/src/validate-config.spec.ts

@@ -1,29 +1,31 @@
 import { describe, expect, test } from '@jest/globals';
-import { NodeType } from '@hestia-earth/schema';
 
-import { validateConfig } from './validate-config';
+import {
+  validateConfigOrder,
+  validateConfigDuplicates
+} from './validate-config';
+import { allowedTypes } from './config';
 
 describe('validate-config', () => {
-  describe('validateConfig', () => {
-    describe(NodeType.Cycle, () => {
-      test('should be valid', () => {
-        const results = validateConfig(NodeType.Cycle);
-        expect(results).toEqual([]);
+  describe('validateConfigOrder', () => {
+    for (const nodeType of allowedTypes) {
+      describe(nodeType, () => {
+        test('should not have broken dependencies', () => {
+          const results = validateConfigOrder(nodeType);
+          expect(results).toEqual([]);
+        });
       });
-    });
-
-    describe(NodeType.ImpactAssessment, () => {
-      test('should be valid', () => {
-        const results = validateConfig(NodeType.ImpactAssessment);
-        expect(results).toEqual([]);
-      });
-    });
+    }
+  });
 
-    describe(NodeType.Site, () => {
-      test('should be valid', () => {
-        const results = validateConfig(NodeType.Site);
-        expect(results).toEqual([]);
+  describe('validateConfigDuplicates', () => {
+    for (const nodeType of allowedTypes) {
+      describe(nodeType, () => {
+        test('should not have duplicates', () => {
+          const results = validateConfigDuplicates(nodeType);
+          expect(results).toEqual([]);
+        });
       });
-    });
+    }
   });
 });

package/src/validate-config.ts

@@ -57,7 +57,13 @@ const matchDependencies =
     };
   };
 
-export const validateConfig = (nodeType: allowedType) => {
+/**
+ * Use inter-dependencies to detect models that are in the wrong order.
+ *
+ * @param nodeType Cycle, Site, or ImpactAssessment
+ * @returns List of models that have dependencies that could not be found prior to running.
+ */
+export const validateConfigOrder = (nodeType: allowedType) => {
   const config = loadConfig(nodeType);
   // flatten all models to process one by one, starting with the last one
   const models = config.models.flat();
@@ -66,3 +72,32 @@ export const validateConfig = (nodeType: allowedType) => {
 
   return results.filter((r) => r.missing.length > 0);
 };
+
+const findDuplicatedConfigs = (models: IOrchestratorModelConfig[]) => {
+  const modelsByValue = models.reduce(
+    (prev, curr) => ({
+      ...prev,
+      [curr.value]: [...(prev[curr.value] || []), curr]
+    }),
+    {} as Record<string, IOrchestratorModelConfig[]>
+  );
+  return Object.values(modelsByValue)
+    .map((values) => values.filter((v) => !v.mergeArgs?.sameMethodModel))
+    .filter((values) => values.length > 1);
+};
+
+/**
+ * Detect multiple models running in parallel when they should not.
+ * Note: we use the `mergeArgs` to handle special cases when multiple identical models CAN run in parallel
+ *
+ * @param nodeType Cycle, Site, or ImpactAssessment
+ */
+export const validateConfigDuplicates = (nodeType: allowedType) => {
+  const config = loadConfig(nodeType);
+
+  const duplicates = config.models
+    .map((value) => (Array.isArray(value) ? findDuplicatedConfigs(value) : []))
+    .flat(2);
+
+  return duplicates;
+};

package/src/version.ts

@@ -1 +1 @@
-export const ENGINE_VERSION = '0.76.0';
+export const ENGINE_VERSION = '0.76.2';