codify-plugin-lib 1.0.65 → 1.0.67

package/src/entities/resource-stateful-mode.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, it } from 'vitest';
+import { TestConfig, TestResource } from './resource.test.js';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { TestParameter } from './resource-parameters.test.js';
+import { StatefulParameter } from './stateful-parameter.js';
+
+
+describe('Resource tests for stateful plans', () => {
+  it('Supports delete operations ', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({ type: 'resource' });
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propADifferent',
+          propB: undefined,
+          propC: 'propCDifferent',
+        }
+      }
+    }
+
+    const plan = await resource.plan(
+      null,
+      {
+        type: 'resource',
+        propA: 'propA',
+        propB: 10,
+        propC: 'propC',
+      }, true
+    );
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.DESTROY,
+        parameterChanges: [
+          {
+            name: "propA",
+            previousValue: "propADifferent",
+            newValue: null,
+            operation: ParameterOperation.REMOVE
+          },
+          {
+            name: "propC",
+            previousValue: "propCDifferent",
+            newValue: null,
+            operation: ParameterOperation.REMOVE
+          },
+        ]
+      },
+      resourceMetadata: {
+        type: 'resource'
+      }
+    })
+  })
+
+  it('Supports create operations', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({ type: 'resource' });
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const plan = await resource.plan(
+      {
+        type: 'resource',
+        propA: 'propA',
+        propB: 10,
+        propC: 'propC',
+      },
+      null,
+      true
+    );
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.CREATE,
+        parameterChanges: [
+          {
+            name: "propA",
+            newValue: "propA",
+            previousValue: null,
+            operation: ParameterOperation.ADD
+          },
+          {
+            name: "propB",
+            newValue: 10,
+            previousValue: null,
+            operation: ParameterOperation.ADD
+          },
+          {
+            name: "propC",
+            newValue: 'propC',
+            previousValue: null,
+            operation: ParameterOperation.ADD
+          },
+        ]
+      },
+      resourceMetadata: {
+        type: 'resource'
+      }
+    })
+  })
+
+  it('Supports re-create operations', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({ type: 'resource' });
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propA',
+          propC: 'propC',
+          propB: undefined
+        };
+      }
+    }
+
+    const plan = await resource.plan(
+      {
+        type: 'resource',
+        propA: 'propA',
+        propB: 10,
+        propC: 'propC',
+      },
+      {
+        type: 'resource',
+        propA: 'propA',
+        propC: 'propC'
+      },
+      true
+    );
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.RECREATE,
+        parameterChanges: expect.arrayContaining([
+          {
+            name: "propA",
+            newValue: "propA",
+            previousValue: "propA",
+            operation: ParameterOperation.NOOP
+          },
+          {
+            name: "propB",
+            newValue: 10,
+            previousValue: null,
+            operation: ParameterOperation.ADD
+          },
+          {
+            name: "propC",
+            newValue: 'propC',
+            previousValue: 'propC',
+            operation: ParameterOperation.NOOP
+          },
+        ])
+      },
+      resourceMetadata: {
+        type: 'resource'
+      }
+    })
+  })
+
+  it('Supports stateful parameters', async () => {
+    const statefulParameter = new class extends TestParameter {
+      async refresh(): Promise<string | null> {
+        return null;
+      }
+    }
+
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resource',
+          parameterOptions: {
+            propD: { statefulParameter: statefulParameter as StatefulParameter<TestConfig, string> },
+          }
+        });
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propA',
+          propC: 'propC',
+          propB: undefined
+        };
+      }
+    }
+
+    const plan = await resource.plan(
+      {
+        type: 'resource',
+        propA: 'propA',
+        propB: 10,
+        propC: 'propC',
+        propD: 'propD'
+      },
+      {
+        type: 'resource',
+        propA: 'propA',
+        propC: 'propC'
+      },
+      true
+    );
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.RECREATE,
+        parameterChanges: expect.arrayContaining([
+          {
+            name: "propA",
+            newValue: "propA",
+            previousValue: "propA",
+            operation: ParameterOperation.NOOP
+          },
+          {
+            name: "propB",
+            newValue: 10,
+            previousValue: null,
+            operation: ParameterOperation.ADD
+          },
+          {
+            name: "propC",
+            newValue: 'propC',
+            previousValue: 'propC',
+            operation: ParameterOperation.NOOP
+          },
+          {
+            name: "propD",
+            newValue: 'propD',
+            previousValue: null,
+            operation: ParameterOperation.ADD
+          },
+        ])
+      },
+      resourceMetadata: {
+        type: 'resource'
+      }
+    })
+  })
+})

package/src/entities/resource.test.ts

@@ -301,8 +301,8 @@ describe('Resource tests', () => {
     }
 
     const plan = await resource.plan({ type: 'resource'})
-    expect(plan.currentConfig.propA).to.eq('propAAfter');
-    expect(plan.desiredConfig.propA).to.eq('propADefault');
+    expect(plan.currentConfig?.propA).to.eq('propAAfter');
+    expect(plan.desiredConfig?.propA).to.eq('propADefault');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
   })
 
@@ -327,8 +327,8 @@ describe('Resource tests', () => {
     }
 
     const plan = await resource.plan({ type: 'resource'})
-    expect(plan.currentConfig.propE).to.eq('propEDefault');
-    expect(plan.desiredConfig.propE).to.eq('propEDefault');
+    expect(plan.currentConfig?.propE).to.eq('propEDefault');
+    expect(plan.desiredConfig?.propE).to.eq('propEDefault');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
 
@@ -349,8 +349,8 @@ describe('Resource tests', () => {
     }
 
     const plan = await resource.plan({ type: 'resource'})
-    expect(plan.currentConfig.propE).to.eq(null);
-    expect(plan.desiredConfig.propE).to.eq('propEDefault');
+    expect(plan.currentConfig).to.be.null
+    expect(plan.desiredConfig!.propE).to.eq('propEDefault');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
   })
 
@@ -377,8 +377,8 @@ describe('Resource tests', () => {
     }
 
     const plan = await resource.plan({ type: 'resource', propA: 'propA'})
-    expect(plan.currentConfig.propA).to.eq('propAAfter');
-    expect(plan.desiredConfig.propA).to.eq('propA');
+    expect(plan.currentConfig?.propA).to.eq('propAAfter');
+    expect(plan.desiredConfig?.propA).to.eq('propA');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
   });
 

package/src/entities/resource.ts

@@ -4,7 +4,7 @@ import { Plan } from './plan.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
 import { setsEqual, splitUserConfig } from '../utils/utils.js';
-import { ParameterOptions, PlanOptions } from './plan-types.js';
+import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions, PlanOptions } from './plan-types.js';
 import { TransformParameter } from './transform-parameter.js';
 import { ResourceOptions, ResourceOptionsParser } from './resource-options.js';
 import Ajv from 'ajv';
@@ -74,38 +74,39 @@ export abstract class Resource<T extends StringIndexedObject> {
     return this.validate(parameters);
   }
 
-  // TODO: Add state in later.
-  //  Currently only calculating how to add things to reach desired state. Can't delete resources.
-  //  Add previousConfig as a parameter for plan(desired, previous);
-  async plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>> {
+  // TODO: Currently stateful mode expects that the currentConfig does not need any additional transformations (default and transform parameters)
+  //   This may change in the future?
+  async plan(
+    desiredConfig: Partial<T> & ResourceConfig | null,
+    currentConfig: Partial<T> & ResourceConfig | null = null,
+    statefulMode = false,
+  ): Promise<Plan<T>> {
+    this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
+
     const planOptions: PlanOptions<T> = {
-      statefulMode: false,
+      statefulMode,
       parameterOptions: this.parameterOptions,
     }
 
     this.addDefaultValues(desiredConfig);
+    await this.applyTransformParameters(desiredConfig);
 
     // Parse data from the user supplied config
-    const parsedConfig = new ConfigParser(desiredConfig, this.statefulParameters, this.transformParameters)
+    const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters)
     const {
-      parameters: desiredParameters,
+      desiredParameters,
       resourceMetadata,
-      resourceParameters,
+      nonStatefulParameters,
       statefulParameters,
-      transformParameters,
     } = parsedConfig;
 
-    // Apply transform parameters. Transform parameters turn into other parameters.
-    // Ex: csvFile: './location' => { password: 'pass', 'username': 'user' }
-    await this.applyTransformParameters(transformParameters, resourceParameters);
-
     // Refresh resource parameters. This refreshes the parameters that configure the resource itself
-    const currentParameters = await this.refreshResourceParameters(resourceParameters);
+    const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
 
     // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
     if (currentParameters == null) {
       return Plan.create(
-        { ...resourceParameters, ...statefulParameters },
+        desiredParameters,
         null,
         resourceMetadata,
         planOptions,
@@ -116,7 +117,7 @@ export abstract class Resource<T extends StringIndexedObject> {
     const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
 
     return Plan.create(
-      { ...resourceParameters, ...statefulParameters },
+      desiredParameters,
       { ...currentParameters, ...statefulCurrentParameters } as Partial<T>,
       resourceMetadata,
       planOptions,
@@ -232,17 +233,29 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
-  private async applyTransformParameters(transformParameters: Partial<T>, desired: Partial<T>): Promise<void> {
-    const orderedEntries = [...Object.entries(transformParameters)]
+  private async applyTransformParameters(desired: Partial<T> | null): Promise<void> {
+    if (!desired) {
+      return;
+    }
+
+    const transformParameters = [...this.transformParameters.entries()]
       .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA)! - this.transformParameterOrder.get(keyB)!)
 
-    for (const [key, value] of orderedEntries) {
-      const transformedValue = await this.transformParameters.get(key)!.transform(value);
+    for (const [key, transformParameter] of transformParameters) {
+      if (desired[key] === undefined) {
+        continue;
+      }
+
+      const transformedValue = await transformParameter.transform(desired[key]);
 
       if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
         throw new Error(`Transform parameter ${key as string} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
       }
 
+      // Remove original transform parameter from the config
+      delete desired[key];
+
+      // Add the new transformed values
       Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
         // @ts-ignore
         desired[tvKey] = tvValue;
@@ -250,7 +263,11 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
-  private addDefaultValues(desired: Partial<T>): void {
+  private addDefaultValues(desired: Partial<T> | null): void {
+    if (!desired) {
+      return;
+    }
+
     Object.entries(this.defaultValues)
       .forEach(([key, defaultValue]) => {
         if (defaultValue !== undefined && desired[key as any] === undefined) {
@@ -260,10 +277,11 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
       });
   }
 
-  private async refreshResourceParameters(resourceParameters: Partial<T>): Promise<Partial<T> | null> {
-    const entriesToRefresh = new Map(Object.entries(resourceParameters));
+  private async refreshNonStatefulParameters(resourceParameters: Partial<T>): Promise<Partial<T> | null> {
+    const entriesToRefresh = new Map<keyof T, T[keyof T]>(
+      Object.entries(resourceParameters)
+    )
     const currentParameters = await this.refresh(entriesToRefresh);
-
     this.validateRefreshResults(currentParameters, entriesToRefresh);
     return currentParameters;
   }
@@ -308,67 +326,106 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     return currentParameters;
   }
 
+  private validatePlanInputs(
+    desired: Partial<T> & ResourceConfig | null,
+    current: Partial<T> & ResourceConfig | null,
+    statefulMode: boolean,
+  ) {
+    if (!desired && !current) {
+      throw new Error('Desired config and current config cannot both be missing')
+    }
+
+    if (!statefulMode && !desired) {
+      throw new Error('Desired config must be provided in non-stateful mode')
+    }
+  }
+
   async validate(parameters: unknown): Promise<ValidationResult> {
     return {
       isValid: true,
     }
   };
 
-  abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
+  abstract refresh(values: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
 
-  abstract applyCreate(plan: Plan<T>): Promise<void>;
+  abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
 
-  async applyModify(pc: ParameterChange<T>, plan: Plan<T>): Promise<void> {};
+  async applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void> {};
 
-  abstract applyDestroy(plan: Plan<T>): Promise<void>;
+  abstract applyDestroy(plan: DestroyPlan<T>): Promise<void>;
 }
 
 class ConfigParser<T extends StringIndexedObject> {
-  private config: Partial<T> & ResourceConfig;
+  private desiredConfig: Partial<T> & ResourceConfig | null;
+  private currentConfig: Partial<T> & ResourceConfig | null;
   private statefulParametersMap: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
   private transformParametersMap: Map<keyof T, TransformParameter<T>>;
 
   constructor(
-    config: Partial<T> & ResourceConfig,
+    desiredConfig: Partial<T> & ResourceConfig | null,
+    currentConfig: Partial<T> & ResourceConfig | null,
     statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>,
-  transformParameters: Map<keyof T, TransformParameter<T>>,
+    transformParameters: Map<keyof T, TransformParameter<T>>,
   ) {
-    this.config = config;
+    this.desiredConfig = desiredConfig;
+    this.currentConfig = currentConfig
     this.statefulParametersMap = statefulParameters;
     this.transformParametersMap = transformParameters;
   }
 
   get resourceMetadata(): ResourceConfig {
-    const { resourceMetadata } = splitUserConfig(this.config);
-    return resourceMetadata;
+    const desiredMetadata = this.desiredConfig ? splitUserConfig(this.desiredConfig).resourceMetadata : undefined;
+    const currentMetadata = this.currentConfig ? splitUserConfig(this.currentConfig).resourceMetadata : undefined;
+
+    if (!desiredMetadata && !currentMetadata) {
+      throw new Error(`Unable to parse resource metadata from ${this.desiredConfig}, ${this.currentConfig}`)
+    }
+
+    if (currentMetadata && desiredMetadata && (
+        Object.keys(desiredMetadata).length !== Object.keys(currentMetadata).length
+        || Object.entries(desiredMetadata).some(([key, value]) => currentMetadata[key] !== value)
+    )) {
+      throw new Error(`The metadata for the current config does not match the desired config. 
+Desired metadata:
+${JSON.stringify(desiredMetadata, null, 2)}
+
+Current metadata:
+${JSON.stringify(currentMetadata, null, 2)}`);
+    }
+
+    return desiredMetadata ?? currentMetadata!;
   }
 
-  get parameters(): Partial<T> {
-    const { parameters } = splitUserConfig(this.config);
+  get desiredParameters(): Partial<T> | null {
+    if (!this.desiredConfig) {
+      return null;
+    }
+
+    const { parameters } = splitUserConfig(this.desiredConfig);
     return parameters;
   }
 
-  get resourceParameters(): Partial<T> {
-    const parameters = this.parameters;
 
-    return Object.fromEntries([
-      ...Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))),
-    ]) as Partial<T>;
+  get parameters(): Partial<T> {
+    const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
+    const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
+
+    return { ...(desiredParameters ?? {}), ...(currentParameters ?? {}) } as Partial<T>;
   }
 
-  get statefulParameters(): Partial<T> {
+  get nonStatefulParameters(): Partial<T> {
     const parameters = this.parameters;
 
     return Object.fromEntries([
-      ...Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)),
+      ...Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))),
     ]) as Partial<T>;
   }
 
-  get transformParameters(): Partial<T> {
+  get statefulParameters(): Partial<T> {
     const parameters = this.parameters;
 
     return Object.fromEntries([
-      ...Object.entries(parameters).filter(([key]) => this.transformParametersMap.has(key)),
+      ...Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)),
     ]) as Partial<T>;
   }
 }

package/src/entities/stateful-parameter.test.ts

@@ -10,10 +10,8 @@ interface TestConfig {
 }
 
 class TestArrayParameter extends ArrayStatefulParameter<TestConfig, string> {
-  constructor(options?: ArrayStatefulParameterOptions<TestConfig>) {
-    super(options ?? {
-      name: 'propA'
-    })
+  constructor(options?: ArrayStatefulParameterOptions<string>) {
+    super(options)
   }
 
   async applyAddItem(item: string, plan: Plan<TestConfig>): Promise<void> {}
@@ -104,7 +102,6 @@ describe('Stateful parameter tests', () => {
     const testParameter = spy(new class extends TestArrayParameter {
       constructor() {
         super({
-          name: 'propA',
           isElementEqual: (desired, current) => current.includes(desired),
         });
       }

package/src/index.ts

@@ -11,7 +11,6 @@ export * from './entities/plan-types.js'
 export * from './entities/stateful-parameter.js'
 export * from './entities/errors.js'
 
-export * from './utils/test-utils.js'
 export * from './utils/utils.js'
 
 export async function runPlugin(plugin: Plugin) {

package/src/utils/test-utils.test.ts

@@ -1,52 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { ChildProcess } from 'node:child_process';
-import { Readable } from 'stream';
-import { mock } from 'node:test';
-import { AssertionError } from 'chai';
-import { CodifyTestUtils } from './test-utils.js';
-import { describe, expect, it } from 'vitest';
-
-describe('Test Utils tests', async () => {
-
-  const mockChildProcess = () => {
-    const process = new ChildProcess();
-    process.stdout = new EventEmitter() as Readable;
-    process.stderr = new EventEmitter() as Readable
-    process.send = () => true;
-
-    return process;
-  }
-
-  it('send a message', async () => {
-    const process = mockChildProcess();
-    const sendMock = mock.method(process, 'send');
-
-    CodifyTestUtils.sendMessageToProcessAwaitResponse(process, { cmd: 'message', data: 'data' })
-
-    expect(sendMock.mock.calls.length).to.eq(1);
-    expect(sendMock.mock.calls[0].arguments[0]).to.deep.eq({ cmd: 'message', data: 'data' });
-  })
-
-  it('send a message and receives the response', async () => {
-    const process = mockChildProcess();
-
-    try {
-      const result = await Promise.all([
-        (async () => {
-          await sleep(30);
-          process.emit('message', { cmd: 'messageResult', data: 'data' })
-        })(),
-        CodifyTestUtils.sendMessageToProcessAwaitResponse(process, { cmd: 'message', data: 'data' }),
-      ]);
-
-      expect(result[1]).to.deep.eq({ cmd: 'messageResult', data: 'data' })
-    } catch (e) {
-      console.log(e);
-      throw new AssertionError('Failed to receive message');
-    }
-  });
-});
-
-async function sleep(ms: number) {
-  return new Promise((resolve, reject) => setTimeout(resolve, ms))
-}

package/src/utils/test-utils.ts

@@ -1,20 +0,0 @@
-import { ChildProcess } from 'child_process';
-
-export class CodifyTestUtils {
-  static sendMessageToProcessAwaitResponse(process: ChildProcess, message: any): Promise<any> {
-    return new Promise((resolve, reject) => {
-      process.on('message', (response) => {
-        resolve(response)
-      });
-      process.on('error', (err) => reject(err))
-      process.on('exit', (code) => {
-        if (code != 0) {
-          reject('Exit code is not 0');
-        }
-        resolve(code);
-      })
-      process.send(message);
-    });
-  }
-
-}