codify-plugin-lib 1.0.64 → 1.0.66

package/src/entities/plugin.test.ts

@@ -0,0 +1,193 @@
+import { describe, expect, it } from 'vitest';
+import { Plugin } from './plugin.js';
+import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { Resource } from './resource.js';
+import { Plan } from './plan.js';
+import { ValidationResult } from './resource-types.js';
+import { ApplyValidationError } from './errors.js';
+
+interface TestConfig extends StringIndexedObject {
+  propA: string;
+  propB: number;
+  propC?: string;
+}
+
+class TestResource extends Resource<TestConfig> {
+  constructor() {
+    super({
+      type: 'testResource'
+    });
+  }
+
+  applyCreate(plan: Plan<TestConfig>): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+  applyDestroy(plan: Plan<TestConfig>): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+  async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+    return {
+      propA: 'a',
+      propB: 10,
+      propC: 'c',
+    };
+  }
+
+  async validateResource(config: unknown): Promise<ValidationResult> {
+    return {
+      isValid: true
+    }
+  }
+}
+
+describe('Plugin tests', () => {
+  it('Validates that applies were successfully applied', async () => {
+    const resource= new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      // Refresh has to line up with desired for the apply to go through
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'abc'
+        }
+      }
+    }
+
+    const plugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.CREATE,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.ADD, newValue: 'abc', previousValue: null },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    await plugin.apply({ plan });
+  });
+
+  it('Validates that applies were successfully applied (error)', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      // Return null to indicate that the resource was not created
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+    const plugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.CREATE,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.ADD, newValue: 'abc', previousValue: null },
+      ]
+    };
+
+    await expect(async () => plugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
+  });
+
+  it('Validates that deletes were successfully applied', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      // Return null to indicate that the resource was deleted
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.DESTROY,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: null, previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    await testPlugin.apply({ plan })
+  });
+
+  it('Validates that deletes were successfully applied (error)', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      // Return a value to indicate that the resource still exists
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return { propA: 'abc' };
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.DESTROY,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: null, previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    expect(async () => await testPlugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
+  });
+
+  it('Validates that re-create was successfully applied', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return { propA: 'def'};
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.RECREATE,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    await testPlugin.apply({ plan })
+  });
+
+  it('Validates that modify was successfully applied (error)', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return { propA: 'abc' };
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.DESTROY,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: 'def', previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    expect(async () => await testPlugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
+  });
+});

package/src/entities/plugin.ts

@@ -5,14 +5,24 @@ import {
   PlanRequestData,
   PlanResponseData,
   ResourceConfig,
+  ResourceOperation,
   ValidateRequestData,
   ValidateResponseData
 } from 'codify-schemas';
 import { Plan } from './plan.js';
 import { splitUserConfig } from '../utils/utils.js';
+import { ApplyValidationError } from './errors.js';
 
 export class Plugin {
-  planStorage: Map<string, Plan<ResourceConfig>>;
+  planStorage: Map<string, Plan<any>>;
+
+  static create(name: string, resources: Resource<any>[]) {
+    const resourceMap = new Map<string, Resource<any>>(
+      resources.map((r) => [r.typeId, r] as const)
+    );
+
+    return new Plugin(name, resourceMap);
+  }
 
   constructor(
     public name: string,
@@ -82,6 +92,17 @@ export class Plugin {
     }
 
     await resource.apply(plan);
+
+    // Perform a validation check after to ensure that the plan was properly applied.
+    // Sometimes no errors are returned (exit code 0) but the apply was not successful
+    const validationPlan = await resource.plan(
+      plan.desiredConfig,
+      plan.currentConfig,
+      true,
+    );
+    if (validationPlan.changeSet.operation !== ResourceOperation.NOOP) {
+      throw new ApplyValidationError(plan, validationPlan);
+    }
   }
 
   private resolvePlan(data: ApplyRequestData): Plan<ResourceConfig> {

package/src/entities/resource-parameters.test.ts

@@ -6,7 +6,7 @@ import { ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { TestConfig, TestResource } from './resource.test.js';
 import { TransformParameter } from './transform-parameter.js';
 
-class TestParameter extends StatefulParameter<TestConfig, string> {
+export class TestParameter extends StatefulParameter<TestConfig, string> {
   constructor(options?: StatefulParameterOptions<string>) {
     super(options ?? {})
   }
@@ -55,11 +55,7 @@ describe('Resource parameter tests', () => {
     })
 
     expect(statefulParameter.refresh.notCalled).to.be.true;
-    expect(plan.currentConfig).toMatchObject({
-      type: 'resource',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.currentConfig).to.be.null;
     expect(plan.desiredConfig).toMatchObject({
       type: 'resource',
       propA: 'a',
@@ -119,7 +115,7 @@ describe('Resource parameter tests', () => {
           type: 'resource',
           parameterOptions: {
             propA: { statefulParameter: statefulParameterSpy },
-            propB: { canModify: true },
+            propB: { modifyOnChange: true },
           }
         });
       }
@@ -171,10 +167,7 @@ describe('Resource parameter tests', () => {
     })
 
     expect(statefulParameter.refresh.notCalled).to.be.true;
-    expect(plan.currentConfig).toMatchObject({
-      type: 'resource',
-      propA: null,
-    })
+    expect(plan.currentConfig).to.be.null;
     expect(plan.desiredConfig).toMatchObject({
       type: 'resource',
       propA: 'abc',
@@ -182,7 +175,6 @@ describe('Resource parameter tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
   })
 
-
   it('Filters array results in stateless mode to prevent modify from being called', async () => {
     const statefulParameter = new class extends TestParameter {
       async refresh(): Promise<any | null> {
@@ -350,10 +342,10 @@ describe('Resource parameter tests', () => {
       propE: 'propE',
     });
 
-    expect(plan.currentConfig.propB).to.be.lessThan(plan.currentConfig.propC as any);
-    expect(plan.currentConfig.propC).to.be.lessThan(plan.currentConfig.propA as any);
-    expect(plan.currentConfig.propA).to.be.lessThan(plan.currentConfig.propD as any);
-    expect(plan.currentConfig.propD).to.be.lessThan(plan.currentConfig.propE as any);
+    expect(plan.currentConfig?.propB).to.be.lessThan(plan.currentConfig?.propC as any);
+    expect(plan.currentConfig?.propC).to.be.lessThan(plan.currentConfig?.propA as any);
+    expect(plan.currentConfig?.propA).to.be.lessThan(plan.currentConfig?.propD as any);
+    expect(plan.currentConfig?.propD).to.be.lessThan(plan.currentConfig?.propE as any);
   })
 
   it('Applies stateful parameters in the order specified', async () => {
@@ -483,9 +475,9 @@ describe('Resource parameter tests', () => {
     expect(resource.refresh.getCall(0).firstArg.has('propB')).to.be.true;
     expect(resource.refresh.getCall(0).firstArg.has('propC')).to.be.false;
 
-    expect(plan.desiredConfig.propA).to.eq('propA');
-    expect(plan.desiredConfig.propB).to.eq(10);
-    expect(plan.desiredConfig.propC).to.be.undefined;
+    expect(plan.desiredConfig?.propA).to.eq('propA');
+    expect(plan.desiredConfig?.propB).to.eq(10);
+    expect(plan.desiredConfig?.propC).to.be.undefined;
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
@@ -570,8 +562,8 @@ describe('Resource parameter tests', () => {
       propC: 'propC',
     });
 
-    expect(plan.desiredConfig.propE).to.be.lessThan(plan.desiredConfig.propF as any);
-    expect(plan.desiredConfig.propF).to.be.lessThan(plan.desiredConfig.propD as any);
+    expect(plan.desiredConfig?.propE).to.be.lessThan(plan.desiredConfig?.propF as any);
+    expect(plan.desiredConfig?.propF).to.be.lessThan(plan.desiredConfig?.propD as any);
   })
 
   it('Plans transform even for creating new resources', async () => {
@@ -602,11 +594,7 @@ describe('Resource parameter tests', () => {
       propB: 10,
       propC: 'propC',
     });
-    expect(plan.currentConfig).toMatchObject({
-      type: 'resourceType',
-      propD: null,
-      propE: null,
-    })
+    expect(plan.currentConfig).to.be.null;
     expect(plan.desiredConfig).toMatchObject({
       type: 'resourceType',
       propD: 'abc',

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-types.ts

@@ -7,7 +7,7 @@ export interface ResourceParameterOptions {
   /**
    * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to false (re-create).
    */
-  canModify?: boolean;
+  modifyOnChange?: boolean;
   /**
    * Customize the equality comparison for a parameter.
    * @param desired

package/src/entities/resource.test.ts

@@ -195,8 +195,8 @@ describe('Resource tests', () => {
         super({
           type: 'resource',
           parameterOptions: {
-            propA: { canModify: true },
-            propB: { canModify: true },
+            propA: { modifyOnChange: true },
+            propB: { modifyOnChange: true },
           }
         });
       }
@@ -218,12 +218,6 @@ describe('Resource tests', () => {
 
   it('Validates the resource options correct (pass)', () => {
     const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
-      constructor() {
-        super({
-          name: 'propC',
-        });
-      }
-
       async refresh(): Promise<string | null> {
         return null;
       }
@@ -244,7 +238,7 @@ describe('Resource tests', () => {
           type: 'type',
           dependencies: ['homebrew', 'python'],
           parameterOptions: {
-            propA: { canModify: true },
+            propA: { modifyOnChange: true },
             propB: { statefulParameter },
             propC: { isEqual: (a, b) => true },
           }
@@ -255,12 +249,6 @@ describe('Resource tests', () => {
 
   it('Validates the resource options correct (fail)', () => {
     const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
-      constructor() {
-        super({
-          name: 'propC',
-        });
-      }
-
       async refresh(): Promise<string | null> {
         return null;
       }
@@ -281,7 +269,7 @@ describe('Resource tests', () => {
           type: 'type',
           dependencies: ['homebrew', 'python'],
           parameterOptions: {
-            propA: { canModify: true },
+            propA: { modifyOnChange: true },
             propB: { statefulParameter },
             propC: { isEqual: (a, b) => true },
           }
@@ -313,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);
   })
 
@@ -339,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);
   })
 
@@ -361,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);
   })
 
@@ -389,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);
   });