fix: Rollback missing resources status feature

Author: m-pizarro

src/rules-engine/data-processors/dgraph-data-processor.ts

@@ -145,12 +145,12 @@ export default class DgraphDataProcessor implements DataProcessor {
 
   private prepareEntitiesMutations(findings: RuleFinding[]): RuleFinding[] {
     // Group Findings by schema type
-    const { manual: manualData = [], missing: missingData = [], ...processedRules } = groupBy(
+    const { manual: manualData = [], ...processedRules } = groupBy(
       findings,
       'typename'
     )
 
-    const mutations = [...manualData, ...missingData]
+    const mutations = [...manualData]
     for (const findingType in processedRules) {
       if (!isEmpty(findingType)) {
         // Group Findings by resource

src/rules-engine/evaluators/base-evaluator.ts

@@ -6,9 +6,9 @@ import {
   RuleFinding,
   Result,
 } from '../types'
-import BaseEvaluator from './base-evaluator'
+import { RuleEvaluator } from './rule-evaluator'
 
-export default class JsEvaluator extends BaseEvaluator<JsRule> {
+export default class JsEvaluator implements RuleEvaluator<JsRule> {
   canEvaluate(rule: Rule | JsRule): boolean {
     return 'check' in rule
   }

src/rules-engine/evaluators/js-evaluator.ts

@@ -12,9 +12,9 @@ import {
 } from '../types'
 import AdditionalOperators from '../operators'
 import ComparisonOperators from '../operators/comparison'
-import BaseEvaluator from './base-evaluator'
+import { RuleEvaluator } from './rule-evaluator'
 
-export default class JsonEvaluator extends BaseEvaluator<JsonRule> {
+export default class JsonEvaluator implements RuleEvaluator<JsonRule> {
   canEvaluate(rule: JsonRule): boolean {
     return 'conditions' in rule
   }

src/rules-engine/evaluators/json-evaluator.ts

@@ -1,7 +1,7 @@
 import { JsonRule, Result, Rule, RuleFinding } from '../types'
-import BaseEvaluator from './base-evaluator'
+import { RuleEvaluator } from './rule-evaluator'
 
-export default class ManualEvaluator extends BaseEvaluator<JsonRule> {
+export default class ManualEvaluator implements RuleEvaluator<JsonRule> {
   canEvaluate(rule: Rule): boolean {
     return !('gql' in rule) && !('conditions' in rule) && !('resource' in rule)
   }

src/rules-engine/evaluators/manual-evaluator.ts

@@ -3,5 +3,4 @@ import { ResourceData, Rule, RuleFinding } from '../types'
 export interface RuleEvaluator<K extends Rule> {
   canEvaluate: (rule: K) => boolean
   evaluateSingleResource: (rule: K, data?: ResourceData) => Promise<RuleFinding>
-  evaluateMissingResource: (rule: K) => Promise<RuleFinding>
 }

src/rules-engine/evaluators/rule-evaluator.ts

@@ -103,12 +103,6 @@ export default class RulesProvider implements Engine {
       return res
     }
 
-    if (isEmpty(resourcePaths)) {
-      // Returned Missing Resource Rule Response   
-      res.push(await evaluator.evaluateMissingResource(rule))
-      return res
-    }
-
     // @NOTE: here we can evaluate things such as Data being empty (may imply rule to pass)
     // or if we have no resources, or none pass, we can decide on that rule (+ some rule field)
     for (let i = 0; i < resourcePaths.length; i++) {

src/rules-engine/index.ts

@@ -66,25 +66,4 @@ describe('JsEvaluator', () => {
     )
     expect(passedRule.result).toEqual(Result.PASS)
   })
-
-  test('should return missing as result', async () => {
-    const finding = await evaluator.evaluateMissingResource(
-      { id: cuid() } as never
-    )
-    expect(finding.result).toEqual(Result.MISSING)
-  })
-
-  test('should contain "missing" at the id', async () => {
-    const finding = await evaluator.evaluateMissingResource(
-      { id: cuid() } as any
-    )
-    expect(finding.id.includes('missing')).toEqual(true)
-  })
-
-  test('should return the resource path at the resourceId', async () => {
-    const finding = await evaluator.evaluateMissingResource(
-      { id: cuid(), resource: 'resourcePath[*]'} as any
-    )
-    expect(finding.resourceId).toEqual('resourcePath')
-  })
 })

tests/evaluators/js-evaluator.test.ts

@@ -596,25 +596,4 @@ describe('JsonEvaluator', () => {
 
     expect(finding.result).toBe(Result.FAIL)
   })
-
-  test('should return missing as result', async () => {
-    const finding = await evaluator.evaluateMissingResource(
-      { id: cuid() } as never
-    )
-    expect(finding.result).toEqual(Result.MISSING)
-  })
-
-  test('should contain "missing" at the id', async () => {
-    const finding = await evaluator.evaluateMissingResource(
-      { id: cuid() } as any
-    )
-    expect(finding.id.includes('missing')).toEqual(true)
-  })
-
-  test('should return the resource path at the resourceId', async () => {
-    const finding = await evaluator.evaluateMissingResource(
-      { id: cuid(), resource: 'resourcePath[*]'} as any
-    )
-    expect(finding.resourceId).toEqual('resourcePath')
-  })
 })

tests/evaluators/json-evaluator.test.ts

@@ -1,9 +1,8 @@
 import RulesProvider from '../src/rules-engine'
-import { Engine, Result, Rule } from '../src/rules-engine/types'
+import { Engine, Rule } from '../src/rules-engine/types'
 import ManualEvaluatorMock from './evaluators/manual-evaluator.test'
 import JSONEvaluatordMock from './evaluators/json-evaluator.test'
 import DgraphDataProcessor from '../src/rules-engine/data-processors/dgraph-data-processor'
-import { RuleFinding } from '../src'
 
 const typenameToFieldMap = {
   resourceA: 'querySchemaA',
@@ -51,17 +50,17 @@ describe('RulesEngine', () => {
     )
   })
 
-  it('Should return a missing finding type processing a rule with no data', async () => {
+  it('Should return an empty array processing a rule with no data', async () => {
     const data = {}
 
     const processedRule = await rulesEngine.processRule(
       JSONEvaluatordMock.jsonRule,
       data
-    ) as RuleFinding[]
+    )
 
     expect(processedRule).toBeDefined()
-    expect(processedRule.length).toBe(1)
-    expect(processedRule[0].result).toBe(Result.MISSING)
+    expect(processedRule instanceof Array).toBeTruthy()
+    expect(processedRule.length).toBe(0)
   })
 
   it('Should return empty mutations array given an empty findings array', () => {