codify-plugin-lib 1.0.38 → 1.0.39

package/dist/entities/plan-types.d.ts

@@ -5,7 +5,7 @@ export interface ParameterConfiguration {
     isArrayElementEqual?: (a: any, b: any) => boolean;
     isStatefulParameter?: boolean;
 }
-export interface PlanConfiguration {
+export interface PlanConfiguration<T> {
     statefulMode: boolean;
-    parameterConfigurations?: Record<string, ParameterConfiguration>;
+    parameterConfigurations?: Record<keyof T, ParameterConfiguration>;
 }

package/dist/entities/plan.d.ts

@@ -6,7 +6,7 @@ export declare class Plan<T extends StringIndexedObject> {
     changeSet: ChangeSet<T>;
     resourceMetadata: ResourceConfig;
     constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
-    static create<T extends StringIndexedObject>(desiredConfig: Partial<T> & ResourceConfig, currentConfig: Partial<T> & ResourceConfig | null, configuration: PlanConfiguration): Plan<T>;
+    static create<T extends StringIndexedObject>(desiredConfig: Partial<T> & ResourceConfig, currentConfig: Partial<T> & ResourceConfig | null, configuration: PlanConfiguration<T>): Plan<T>;
     getResourceType(): string;
     static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan']): Plan<T>;
     get desiredConfig(): T;

package/dist/entities/plan.js

@@ -17,7 +17,7 @@ export class Plan {
             .filter(([k, v]) => v.isStatefulParameter)
             .map(([k, v]) => k));
         const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
-        const { parameters: currentParameters } = currentConfig ? splitUserConfig(currentConfig) : { parameters: {} };
+        const { parameters: currentParameters } = currentConfig != null ? splitUserConfig(currentConfig) : { parameters: null };
         const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: configuration.statefulMode, parameterConfigurations });
         let resourceOperation;
         if (!currentConfig && desiredConfig) {

package/dist/entities/resource.d.ts

@@ -7,7 +7,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     readonly typeId: string;
     readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
     readonly dependencies: Resource<any>[];
-    readonly parameterConfigurations: Record<string, ParameterConfiguration>;
+    readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>;
     private readonly options;
     protected constructor(configuration: ResourceConfiguration<T>);
     getDependencyTypeIds(): string[];

package/dist/entities/resource.js

@@ -28,18 +28,24 @@ export class Resource {
         const resourceParameters = Object.fromEntries([
             ...Object.entries(desiredParameters).filter(([key]) => !this.statefulParameters.has(key)),
         ]);
+        const statefulParameters = [...this.statefulParameters.values()]
+            .filter((sp) => desiredParameters[sp.name] !== undefined);
         const keysToRefresh = new Set(Object.keys(resourceParameters));
         const currentParameters = await this.refresh(keysToRefresh);
-        if (!currentParameters) {
+        if (currentParameters == null && statefulParameters.length === 0) {
             return Plan.create(desiredConfig, null, planConfiguration);
         }
         this.validateRefreshResults(currentParameters, keysToRefresh);
-        const statefulParameters = [...this.statefulParameters.values()]
-            .filter((sp) => desiredParameters[sp.name] !== undefined);
+        const currentStatefulParameters = {};
         for (const statefulParameter of statefulParameters) {
-            currentParameters[statefulParameter.name] = await statefulParameter.refresh(desiredParameters[statefulParameter.name] ?? null) ?? undefined;
+            const desiredValue = desiredParameters[statefulParameter.name];
+            let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
+            if (Array.isArray(currentValue) && Array.isArray(desiredValue) && !planConfiguration.statefulMode) {
+                currentValue = currentValue.filter((p) => desiredValue?.includes(p));
+            }
+            currentStatefulParameters[statefulParameter.name] = currentValue;
         }
-        return Plan.create(desiredConfig, { ...currentParameters, ...resourceMetadata }, planConfiguration);
+        return Plan.create(desiredConfig, { ...currentParameters, ...currentStatefulParameters, ...resourceMetadata }, planConfiguration);
     }
     async apply(plan) {
         if (plan.getResourceType() !== this.typeId) {
@@ -140,6 +146,9 @@ export class Resource {
         }
     }
     validateRefreshResults(refresh, desiredKeys) {
+        if (!refresh) {
+            return;
+        }
         const refreshKeys = new Set(Object.keys(refresh));
         if (!setsEqual(desiredKeys, refreshKeys)) {
             throw new Error(`Resource ${this.options.type}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.38",
+  "version": "1.0.39",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/entities/plan-types.ts

@@ -20,7 +20,7 @@ export interface ParameterConfiguration {
   isStatefulParameter?: boolean;
 }
 
-export interface PlanConfiguration {
+export interface PlanConfiguration<T> {
   statefulMode: boolean;
-  parameterConfigurations?: Record<string, ParameterConfiguration>;
+  parameterConfigurations?: Record<keyof T, ParameterConfiguration>;
 }

package/src/entities/plan.ts

@@ -8,7 +8,7 @@ import {
   StringIndexedObject,
 } from 'codify-schemas';
 import { randomUUID } from 'crypto';
-import { PlanConfiguration } from './plan-types.js';
+import { ParameterConfiguration, PlanConfiguration } from './plan-types.js';
 import { splitUserConfig } from '../utils/utils.js';
 
 export class Plan<T extends StringIndexedObject> {
@@ -25,9 +25,9 @@ export class Plan<T extends StringIndexedObject> {
   static create<T extends StringIndexedObject>(
     desiredConfig: Partial<T> & ResourceConfig,
     currentConfig: Partial<T> & ResourceConfig | null,
-    configuration: PlanConfiguration
+    configuration: PlanConfiguration<T>
   ): Plan<T> {
-    const parameterConfigurations = configuration.parameterConfigurations ?? {};
+    const parameterConfigurations = configuration.parameterConfigurations ?? {} as Record<keyof T, ParameterConfiguration>;
     const statefulParameterNames = new Set(
       [...Object.entries(parameterConfigurations)]
         .filter(([k, v]) => v.isStatefulParameter)
@@ -35,7 +35,7 @@ export class Plan<T extends StringIndexedObject> {
     );
 
     const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
-    const { parameters: currentParameters } = currentConfig ? splitUserConfig(currentConfig) : { parameters: {} };
+    const { parameters: currentParameters } = currentConfig != null ? splitUserConfig(currentConfig) : { parameters: null };
 
 
     // TODO: After adding in state files, need to calculate deletes here

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

@@ -0,0 +1,159 @@
+import { describe, expect, it } from 'vitest';
+import { StatefulParameter, StatefulParameterConfiguration } from './stateful-parameter.js';
+import { Plan } from './plan.js';
+import { spy } from 'sinon';
+import { ResourceOperation } from 'codify-schemas';
+import { TestConfig, TestResource } from './resource.test.js';
+
+class TestParameter extends StatefulParameter<TestConfig, string> {
+  constructor(configuration?: StatefulParameterConfiguration<TestConfig>) {
+    super(configuration ?? {
+      name: 'propA'
+    })
+  }
+
+  applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
+    return Promise.resolve();
+  }
+  applyModify(newValue: string, previousValue: string, allowDeletes: boolean, plan: Plan<TestConfig>): Promise<void> {
+    return Promise.resolve();
+  }
+  applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
+    return Promise.resolve();
+  }
+  async refresh(): Promise<string | null> {
+    return '';
+  }
+}
+
+describe('Resource parameters tests', () => {
+  it('supports the creation of stateful parameters', async () => {
+
+    const statefulParameter = new class extends TestParameter {
+      async refresh(): Promise<string | null> {
+        return null;
+      }
+    }
+
+    const statefulParameterSpy = spy(statefulParameter);
+
+    const resource = new class extends TestResource {
+
+      constructor() {
+        super({
+          type: 'resource',
+          statefulParameters: [statefulParameterSpy],
+        });
+      }
+    }
+
+    const resourceSpy = spy(resource);
+    const result = await resourceSpy.apply(
+      Plan.create<TestConfig>(
+        { type: 'resource', propA: 'a', propB: 0, propC: 'b' },
+        null,
+        { statefulMode: false },
+      )
+    );
+
+    expect(statefulParameterSpy.applyAdd.calledOnce).to.be.true;
+    expect(resourceSpy.applyCreate.calledOnce).to.be.true;
+  })
+
+  it('supports the modification of stateful parameters', async () => {
+    const statefulParameter = new class extends TestParameter {
+      async refresh(): Promise<string | null> {
+        return 'b';
+      }
+    }
+
+    const statefulParameterSpy = spy(statefulParameter);
+
+    const resource = new class extends TestResource {
+
+      constructor() {
+        super({
+          type: 'resource',
+          statefulParameters: [statefulParameterSpy],
+          parameterConfigurations: {
+            propB: { planOperation: ResourceOperation.MODIFY },
+          }
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return { propB: -1, propC: 'b' }
+      }
+    }
+
+    const plan = await resource.plan({ type: 'resource', propA: 'a', propB: 0, propC: 'b' })
+
+    const resourceSpy = spy(resource);
+    const result = await resourceSpy.apply(plan);
+
+    expect(statefulParameterSpy.applyModify.calledOnce).to.be.true;
+    expect(resourceSpy.applyModify.calledOnce).to.be.true;
+  })
+
+  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> {
+        return ['a', 'b', 'c', 'd']
+      }
+    }
+
+    const statefulParameterSpy = spy(statefulParameter);
+
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resource',
+          statefulParameters: [statefulParameterSpy],
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const plan = await resource.plan({ type: 'resource', propA: ['a', 'b'] } as any)
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.NOOP,
+      }
+    })
+  })
+
+  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> {
+        return ['a', 'b']
+      }
+    }
+
+    const statefulParameterSpy = spy(statefulParameter);
+
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resource',
+          statefulParameters: [statefulParameterSpy],
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const plan = await resource.plan({ type: 'resource', propA: ['a', 'b', 'c', 'd'] } as any)
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.MODIFY,
+      }
+    })
+  })
+})

package/src/entities/resource.test.ts

@@ -1,19 +1,17 @@
 import { Resource } from './resource.js';
 import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { ParameterChange } from './change-set.js';
 import { spy } from 'sinon';
 import { Plan } from './plan.js';
-import { StatefulParameter } from './stateful-parameter.js';
 import { describe, expect, it } from 'vitest'
-import { ResourceConfiguration } from './resource-types.js';
+import { ResourceConfiguration, ValidationResult } from './resource-types.js';
 
-interface TestConfig extends StringIndexedObject {
+export interface TestConfig extends StringIndexedObject {
   propA: string;
   propB: number;
   propC?: string;
 }
 
-class TestResource extends Resource<TestConfig> {
+export class TestResource extends Resource<TestConfig> {
   constructor(options: ResourceConfiguration<TestConfig>) {
     super(options);
   }
@@ -34,8 +32,10 @@ class TestResource extends Resource<TestConfig> {
     };
   }
 
-  async validate(config: unknown): Promise<string[] | undefined> {
-    return undefined;
+  async validate(config: unknown): Promise<ValidationResult> {
+    return {
+      isValid: true
+    }
   }
 }
 
@@ -89,10 +89,6 @@ describe('Resource tests', () => {
         super({ type: 'type' });
       }
 
-      calculateOperation(change: ParameterChange<TestConfig>): ResourceOperation.RECREATE | ResourceOperation.MODIFY {
-        return ResourceOperation.MODIFY;
-      }
-
       async refresh(): Promise<TestConfig | null> {
         return null;
       }
@@ -111,6 +107,24 @@ describe('Resource tests', () => {
     expect(result.changeSet.parameterChanges.length).to.eq(3);
   })
 
+  it('handles empty parameters', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({ type: 'type' });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const resourceSpy = spy(resource);
+    const result = await resourceSpy.plan({ type: 'type' })
+
+    expect(result.changeSet.operation).to.eq(ResourceOperation.CREATE);
+    expect(result.changeSet.parameterChanges.length).to.eq(0);
+  })
+
   it('chooses the create apply properly', async () => {
     const resource = new class extends TestResource {
       constructor() {
@@ -195,101 +209,4 @@ describe('Resource tests', () => {
 
     expect(resourceSpy.applyModify.calledTwice).to.be.true;
   })
-
-  it('supports the creation of stateful parameters', async () => {
-    const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
-      constructor() {
-        super({
-          name: 'propA',
-        })
-      }
-
-      applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve();
-      }
-      applyModify(newValue: string, previousValue: string, allowDeletes: boolean, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve();
-      }
-      applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve();
-      }
-      async refresh(): Promise<string | null> {
-        return '';
-      }
-    }
-
-    const statefulParameterSpy = spy(statefulParameter);
-
-    const resource = new class extends TestResource {
-
-      constructor() {
-        super({
-          type: 'resource',
-          statefulParameters: [statefulParameterSpy],
-        });
-      }
-    }
-
-    const resourceSpy = spy(resource);
-    const result = await resourceSpy.apply(
-      Plan.create<TestConfig>(
-        { type: 'resource', propA: 'a', propB: 0, propC: 'b' },
-        null,
-        { statefulMode: false },
-      )
-    );
-
-    expect(statefulParameterSpy.applyAdd.calledOnce).to.be.true;
-    expect(resourceSpy.applyCreate.calledOnce).to.be.true;
-  })
-
-  it('supports the modification of stateful parameters', async () => {
-    const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
-      constructor() {
-        super({
-          name: 'propA',
-        })
-      }
-
-      applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve();
-      }
-      applyModify(newValue: string, previousValue: string, allowDeletes: false, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve();
-      }
-      applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
-        return Promise.resolve();
-      }
-      async refresh(): Promise<string | null> {
-        return 'b';
-      }
-    }
-
-    const statefulParameterSpy = spy(statefulParameter);
-
-    const resource = new class extends TestResource {
-
-      constructor() {
-        super({
-          type: 'resource',
-          statefulParameters: [statefulParameterSpy],
-          parameterConfigurations: {
-            propB: { planOperation: ResourceOperation.MODIFY },
-          }
-        });
-      }
-
-      async refresh(): Promise<Partial<TestConfig> | null> {
-        return { propB: -1, propC: 'b' }
-      }
-    }
-
-    const plan = await resource.plan({ type: 'resource', propA: 'a', propB: 0, propC: 'b' })
-
-    const resourceSpy = spy(resource);
-    const result = await resourceSpy.apply(plan);
-
-    expect(statefulParameterSpy.applyModify.calledOnce).to.be.true;
-    expect(resourceSpy.applyModify.calledOnce).to.be.true;
-  })
-})
+});

package/src/entities/resource.ts

@@ -18,7 +18,7 @@ export abstract class Resource<T extends StringIndexedObject> {
   readonly typeId: string;
   readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
   readonly dependencies: Resource<any>[]; // TODO: Change this to a string
-  readonly parameterConfigurations: Record<string, ParameterConfiguration>
+  readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>
 
   private readonly options: ResourceConfiguration<T>;
 
@@ -45,23 +45,26 @@ export abstract class Resource<T extends StringIndexedObject> {
   async plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>> {
 
     // Explanation: these are settings for how the plan will be generated
-    const planConfiguration: PlanConfiguration = {
+    const planConfiguration: PlanConfiguration<T> = {
       statefulMode: false,
       parameterConfigurations: this.parameterConfigurations,
     }
 
     const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
 
-    // Refresh resource parameters
-    // This refreshes the parameters that configure the resource itself
-
     const resourceParameters = Object.fromEntries([
       ...Object.entries(desiredParameters).filter(([key]) => !this.statefulParameters.has(key)),
     ]) as Partial<T>;
 
+    const statefulParameters = [...this.statefulParameters.values()]
+      .filter((sp) => desiredParameters[sp.name] !== undefined) // Checking for undefined is fine here because JSONs can only have null.
+
+    // Refresh resource parameters
+    // This refreshes the parameters that configure the resource itself
     const keysToRefresh = new Set(Object.keys(resourceParameters));
     const currentParameters = await this.refresh(keysToRefresh);
-    if (!currentParameters) {
+
+    if (currentParameters == null && statefulParameters.length === 0) {
       return Plan.create(desiredConfig, null, planConfiguration);
     }
 
@@ -69,19 +72,24 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     // Refresh stateful parameters
     // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
-
-    const statefulParameters = [...this.statefulParameters.values()]
-      .filter((sp) => desiredParameters[sp.name] !== undefined) // Checking for undefined is fine here because JSONs can only have null.
+    const currentStatefulParameters = {} as Partial<T>;
 
     for(const statefulParameter of statefulParameters) {
-      currentParameters[statefulParameter.name] = await statefulParameter.refresh(
-        desiredParameters[statefulParameter.name] ?? null
-      ) ?? undefined;
+      const desiredValue = desiredParameters[statefulParameter.name];
+
+      let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
+
+      // In stateless mode, filter the refreshed parameters by the desired to ensure that no deletes happen
+      if (Array.isArray(currentValue) && Array.isArray(desiredValue) && !planConfiguration.statefulMode) {
+        currentValue = currentValue.filter((p) => desiredValue?.includes(p)) as any;
+      }
+
+      currentStatefulParameters[statefulParameter.name] = currentValue;
     }
 
     return Plan.create(
       desiredConfig,
-      { ...currentParameters, ...resourceMetadata } as Partial<T> & ResourceConfig,
+      { ...currentParameters, ...currentStatefulParameters, ...resourceMetadata } as Partial<T> & ResourceConfig,
       planConfiguration,
     )
   }
@@ -172,13 +180,13 @@ export abstract class Resource<T extends StringIndexedObject> {
 
   private generateParameterConfigurations(
     resourceConfiguration: ResourceConfiguration<T>
-  ): Record<string, ParameterConfiguration>  {
-    const resourceParameters: Record<string, ParameterConfiguration> = Object.fromEntries(
+  ): Record<keyof T, ParameterConfiguration>  {
+    const resourceParameters = Object.fromEntries(
       Object.entries(resourceConfiguration.parameterConfigurations ?? {})
         ?.map(([name, value]) => ([name, { ...value, isStatefulParameter: false }]))
-    )
+    ) as Record<keyof T, ParameterConfiguration>
 
-    const statefulParameters: Record<string, ParameterConfiguration> = resourceConfiguration.statefulParameters
+    const statefulParameters = resourceConfiguration.statefulParameters
       ?.reduce((obj, sp) => {
         return {
           ...obj,
@@ -209,7 +217,11 @@ export abstract class Resource<T extends StringIndexedObject> {
     }
   }
 
-  private validateRefreshResults(refresh: Partial<T>, desiredKeys: Set<keyof T>) {
+  private validateRefreshResults(refresh: Partial<T> | null, desiredKeys: Set<keyof T>) {
+    if (!refresh) {
+      return;
+    }
+
     const refreshKeys = new Set(Object.keys(refresh)) as Set<keyof T>;
 
     if (!setsEqual(desiredKeys, refreshKeys)) {