Implement pipeMode Parameter to EvalCommand

ts/packages/ts/src/commands/EvalCommand.ts

@@ -14,9 +14,11 @@ export enum EvaluatedConfigOrigin {
   EmptyValue = 'EMPTY_VALUE',
 }
 
+export type EvalCommandPipeMode = 'include' | 'forward';
+
 export type EvalCommandReturn = {
   [key: string]: {
-    context: { store: string; set: string; schema: string; key: string; cfgu: Cfgu };
+    context: { store: string; set: string; schema: string; key: string; cfgu: Cfgu; pipeMode: EvalCommandPipeMode };
     result: { origin: EvaluatedConfigOrigin; source: string; value: string };
   };
 };
@@ -28,6 +30,7 @@ export type EvalCommandParameters = {
   configs?: { [key: string]: string };
   pipe?: EvalCommandReturn;
   validate?: boolean;
+  pipeMode?: EvalCommandPipeMode;
 };
 
 export class EvalCommand extends Command<EvalCommandReturn> {
@@ -224,6 +227,15 @@ export class EvalCommand extends Command<EvalCommandReturn> {
     return resultWithTemplates;
   }
 
+  private removeForwards(result: EvalCommandReturn): EvalCommandReturn {
+    const { pipe } = this.parameters;
+    if (!pipe) {
+      return result;
+    }
+    console.log(result);
+    return _.omitBy(result, (current) => pipe[current.context.key] && current.context.pipeMode === 'forward');
+  }
+
   private validateResult(result: EvalCommandReturn): void {
     const { validate = true } = this.parameters;
 
@@ -265,7 +277,7 @@ export class EvalCommand extends Command<EvalCommandReturn> {
   }
 
   async run() {
-    const { store, set, schema } = this.parameters;
+    const { store, set, schema, pipeMode = 'include' } = this.parameters;
 
     await store.init();
 
@@ -277,6 +289,7 @@ export class EvalCommand extends Command<EvalCommandReturn> {
           schema: schema.name,
           key,
           cfgu,
+          pipeMode,
         },
         result: {
           origin: EvaluatedConfigOrigin.EmptyValue,
@@ -308,6 +321,8 @@ export class EvalCommand extends Command<EvalCommandReturn> {
       ...this.evalTemplates(result),
     };
 
+    result = this.removeForwards(result);
+
     this.validateResult(result);
 
     return result;

ts/packages/ts/src/commands/commands.test.ts

@@ -9,6 +9,7 @@ import {
   type EvalCommandParameters,
   DeleteCommand,
   type EvalCommandReturn,
+  ExportCommand,
 } from '..';
 
 describe(`commands`, () => {
@@ -221,5 +222,149 @@ describe(`commands`, () => {
         await Promise.all(deletePromises);
       }
     });
+    describe('PipeMode', () => {
+      test('run EvalCommand and pipe to another, all keys should exist in export', async () => {
+        const evalMyName = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('myName', {
+            MY_NAME: {
+              type: 'String',
+            },
+          }),
+          configs: {
+            MY_NAME: 'What?',
+          },
+        }).run();
+        const evalQuote = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('quote', {
+            QUOTE: {
+              type: 'String',
+              template: 'Hi! My name is {{MY_NAME}}, my name is Who?',
+            },
+          }),
+          pipe: evalMyName,
+        }).run();
+        const evaluatedConfigs = await new ExportCommand({ pipe: evalQuote }).run();
+        expect(evaluatedConfigs).toStrictEqual({ MY_NAME: 'What?', QUOTE: 'Hi! My name is What?, my name is Who?' });
+      });
+      test("run EvalCommand(pipeMode='forward') and pipe to another, only keys from the second should exist in export", async () => {
+        const evalMyName = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('myName', {
+            MY_NAME: {
+              type: 'String',
+            },
+          }),
+          configs: {
+            MY_NAME: 'What?',
+          },
+          pipeMode: 'forward',
+        }).run();
+        const evalQuote = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('quote', {
+            QUOTE: {
+              type: 'String',
+              template: 'Hi! My name is {{MY_NAME}}, my name is Who?',
+            },
+          }),
+          pipe: evalMyName,
+        }).run();
+        const evaluatedConfigs = await new ExportCommand({ pipe: evalQuote }).run();
+        expect(evaluatedConfigs).toStrictEqual({ QUOTE: 'Hi! My name is What?, my name is Who?' });
+      });
+      test("run EvalCommand(pipeMode='forward') and pipe to two other evals, only keys from the second should exist in export", async () => {
+        const evalMyName = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('myName', {
+            MY_NAME: {
+              type: 'String',
+            },
+          }),
+          configs: {
+            MY_NAME: 'What?',
+          },
+          pipeMode: 'forward',
+        }).run();
+        const evalQuote = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('quote', {
+            QUOTE: {
+              type: 'String',
+              template: 'Hi! My name is {{MY_NAME}}, my name is Who?',
+            },
+          }),
+          pipeMode: 'forward',
+          pipe: evalMyName,
+        }).run();
+        const lastEval = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('last', {
+            MY_QUOTE: {
+              type: 'String',
+              template: '{{QUOTE}} My Name is Chiky Chicky Slim Shady',
+            },
+          }),
+          pipeMode: 'forward',
+          pipe: evalQuote,
+        }).run();
+        const evaluatedConfigs = await new ExportCommand({ pipe: lastEval }).run();
+        expect(evaluatedConfigs).toStrictEqual({
+          MY_QUOTE: 'Hi! My name is , my name is Who? My Name is Chiky Chicky Slim Shady',
+        });
+      });
+      test('check for the scenario where a 2nd eval overrides the same key from a forwarded eval and ensure that the key is still there', async () => {
+        const evalMyName = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('myName', {
+            MY_NAME: {
+              type: 'String',
+            },
+          }),
+          configs: {
+            MY_NAME: 'Who?',
+          },
+          pipeMode: 'forward',
+        }).run();
+        const evalMyNameAgain = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('myName', {
+            MY_NAME: {
+              type: 'String',
+            },
+          }),
+          configs: {
+            MY_NAME: 'What?',
+          },
+          pipeMode: 'forward',
+          pipe: evalMyName,
+        }).run();
+        const lastEval = await new EvalCommand({
+          store: store1,
+          set: set1,
+          schema: new ConfigSchema('last', {
+            MY_QUOTE: {
+              type: 'String',
+              template: 'Hi! My name is {{MY_NAME}}, my name is Who?',
+            },
+          }),
+          pipe: evalMyNameAgain,
+        }).run();
+        const evaluatedConfigs = await new ExportCommand({ pipe: lastEval }).run();
+        expect(evaluatedConfigs).toStrictEqual({
+          MY_QUOTE: 'Hi! My name is What?, my name is Who?',
+        });
+      });
+    });
   });
 });