codify-plugin-lib 1.0.43 → 1.0.45

package/dist/entities/plugin.js

@@ -14,7 +14,7 @@ export class Plugin {
             resourceDefinitions: [...this.resources.values()]
                 .map((r) => ({
                 type: r.typeId,
-                dependencies: r.getDependencyTypeIds(),
+                dependencies: r.dependencies,
             }))
         };
     }

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

@@ -1,6 +1,5 @@
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { Resource } from './resource.js';
 export type ErrorMessage = string;
 export interface ResourceParameterConfiguration {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
@@ -9,7 +8,7 @@ export interface ResourceParameterConfiguration {
 export interface ResourceConfiguration<T extends StringIndexedObject> {
     type: string;
     callStatefulParameterRemoveOnDestroy?: boolean;
-    dependencies?: Resource<any>[];
+    dependencies?: string[];
     statefulParameters?: Array<StatefulParameter<T, T[keyof T]>>;
     parameterConfigurations?: Partial<Record<keyof T, ResourceParameterConfiguration>>;
 }

package/dist/entities/resource.d.ts

@@ -6,11 +6,10 @@ import { ParameterConfiguration } from './plan-types.js';
 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 dependencies: string[];
     readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>;
-    private readonly options;
+    readonly configuration: ResourceConfiguration<T>;
     protected constructor(configuration: ResourceConfiguration<T>);
-    getDependencyTypeIds(): string[];
     onInitialize(): Promise<void>;
     plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;

package/dist/entities/resource.js

@@ -6,17 +6,14 @@ export class Resource {
     statefulParameters;
     dependencies;
     parameterConfigurations;
-    options;
+    configuration;
     constructor(configuration) {
         this.validateResourceConfiguration(configuration);
         this.typeId = configuration.type;
         this.statefulParameters = new Map(configuration.statefulParameters?.map((sp) => [sp.name, sp]));
         this.parameterConfigurations = this.generateParameterConfigurations(configuration);
         this.dependencies = configuration.dependencies ?? [];
-        this.options = configuration;
-    }
-    getDependencyTypeIds() {
-        return this.dependencies.map((d) => d.typeId);
+        this.configuration = configuration;
     }
     async onInitialize() { }
     async plan(desiredConfig) {
@@ -39,8 +36,17 @@ export class Resource {
         for (const statefulParameter of statefulParameters) {
             const desiredValue = desiredParameters[statefulParameter.name];
             let currentValue = await statefulParameter.refresh() ?? undefined;
-            if (Array.isArray(currentValue) && Array.isArray(desiredValue) && !planConfiguration.statefulMode) {
-                currentValue = currentValue.filter((p) => desiredValue?.includes(p));
+            if (Array.isArray(currentValue)
+                && Array.isArray(desiredValue)
+                && !planConfiguration.statefulMode
+                && !statefulParameter.configuration.disableStatelessModeArrayFiltering) {
+                currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
+                    const pc = planConfiguration?.parameterConfigurations?.[statefulParameter.name];
+                    if (pc && pc.isElementEqual) {
+                        return pc.isElementEqual(d, c);
+                    }
+                    return d === c;
+                }));
             }
             currentParameters[statefulParameter.name] = currentValue;
         }
@@ -106,7 +112,7 @@ export class Resource {
         }
     }
     async _applyDestroy(plan) {
-        if (this.options.callStatefulParameterRemoveOnDestroy) {
+        if (this.configuration.callStatefulParameterRemoveOnDestroy) {
             const statefulParameterChanges = plan.changeSet.parameterChanges
                 .filter((pc) => this.statefulParameters.has(pc.name));
             for (const parameterChange of statefulParameterChanges) {
@@ -137,7 +143,7 @@ export class Resource {
     validateResourceConfiguration(data) {
         if (data.parameterConfigurations && data.statefulParameters) {
             const parameters = [...Object.keys(data.parameterConfigurations)];
-            const statefulParameterSet = new Set(Object.keys(data.statefulParameters));
+            const statefulParameterSet = new Set(data.statefulParameters.map((sp) => sp.name));
             const intersection = parameters.some((p) => statefulParameterSet.has(p));
             if (intersection) {
                 throw new Error(`Resource ${this.typeId} cannot declare a parameter as both stateful and non-stateful`);
@@ -150,7 +156,7 @@ export class Resource {
         }
         const refreshKeys = new Set(Object.keys(refresh));
         if (!setsEqual(desiredKeys, refreshKeys)) {
-            throw new Error(`Resource ${this.options.type}
+            throw new Error(`Resource ${this.configuration.type}
 refresh() must return back exactly the keys that were provided
 Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);

package/dist/entities/stateful-parameter.d.ts

@@ -3,6 +3,7 @@ import { StringIndexedObject } from 'codify-schemas';
 export interface StatefulParameterConfiguration<T> {
     name: keyof T;
     isEqual?: (desired: any, current: any) => boolean;
+    disableStatelessModeArrayFiltering?: boolean;
 }
 export interface ArrayStatefulParameterConfiguration<T> extends StatefulParameterConfiguration<T> {
     isEqual?: (desired: any[], current: any[]) => boolean;

package/package.json

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

package/src/entities/change-set.ts

@@ -126,7 +126,6 @@ export class ChangeSet<T extends StringIndexedObject> {
     const _desired = { ...desired };
     const _current = { ...current };
 
-
     for (const [k, v] of Object.entries(_current)) {
       if (_desired[k] == null) {
         parameterChangeSet.push({

package/src/entities/plan.ts

@@ -34,10 +34,6 @@ export class Plan<T extends StringIndexedObject> {
         .map(([k, v]) => k)
     );
 
-
-    // TODO: After adding in state files, need to calculate deletes here
-    //  Where current config exists and state config exists but desired config doesn't
-
     // Explanation: This calculates the change set of the parameters between the
     // two configs and then passes it to ChangeSet to calculate the overall
     // operation for the resource

package/src/entities/plugin.ts

@@ -28,7 +28,7 @@ export class Plugin {
       resourceDefinitions: [...this.resources.values()]
         .map((r) => ({
           type: r.typeId,
-          dependencies: r.getDependencyTypeIds(),
+          dependencies: r.dependencies,
         }))
     }
   }

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { StatefulParameter, StatefulParameterConfiguration } from './stateful-parameter.js';
+import { ArrayStatefulParameter, StatefulParameter, StatefulParameterConfiguration } from './stateful-parameter.js';
 import { Plan } from './plan.js';
 import { spy } from 'sinon';
 import { ResourceOperation } from 'codify-schemas';
@@ -157,4 +157,45 @@ describe('Resource parameters tests', () => {
       }
     })
   })
+
+  it('Uses isElementEqual for stateless mode filtering if available', async () => {
+    const statefulParameter = new class extends ArrayStatefulParameter<TestConfig, string> {
+      constructor() {
+        super({
+          name: 'propA',
+          isElementEqual: (desired, current) => current.includes(desired),
+        });
+      }
+
+      async refresh(): Promise<any | null> {
+        return ['3.11.9']
+      }
+
+      async applyAddItem(item: string, plan: Plan<TestConfig>): Promise<void> {}
+      async applyRemoveItem(item: string, plan: Plan<TestConfig>): Promise<void> {}
+    }
+
+    const statefulParameterSpy = spy(statefulParameter);
+
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resource',
+          statefulParameters: [statefulParameterSpy],
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {};
+      }
+    }
+
+    const plan = await resource.plan({ type: 'resource', propA: ['3.11'] } as any)
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.NOOP,
+      }
+    })
+  })
 })

package/src/entities/resource-types.ts

@@ -1,6 +1,5 @@
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { Resource } from './resource.js';
 
 export type ErrorMessage = string;
 
@@ -30,7 +29,7 @@ export interface ResourceConfiguration<T extends StringIndexedObject> {
    * Defaults to false.
    */
   callStatefulParameterRemoveOnDestroy?: boolean,
-  dependencies?: Resource<any>[];
+  dependencies?: string[];
   statefulParameters?: Array<StatefulParameter<T, T[keyof T]>>;
   parameterConfigurations?: Partial<Record<keyof T, ResourceParameterConfiguration>>
 }

package/src/entities/resource.test.ts

@@ -4,6 +4,7 @@ import { spy } from 'sinon';
 import { Plan } from './plan.js';
 import { describe, expect, it } from 'vitest'
 import { ResourceConfiguration, ValidationResult } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
 
 export interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -40,7 +41,8 @@ export class TestResource extends Resource<TestConfig> {
 }
 
 describe('Resource tests', () => {
-  it('plans correctly', async () => {
+
+  it('Plans successfully', async () => {
     const resource = new class extends TestResource {
       constructor() {
         super({ type: 'type' });
@@ -212,4 +214,83 @@ describe('Resource tests', () => {
 
     expect(resourceSpy.applyModify.calledTwice).to.be.true;
   })
+
+  it('Validates the resource configuration correct (pass)', () => {
+    const parameter = new class extends StatefulParameter<TestConfig, string> {
+      constructor() {
+        super({
+          name: 'propC',
+        });
+      }
+
+      async refresh(): Promise<string | null> {
+        return null;
+      }
+      applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
+        throw new Error('Method not implemented.');
+      }
+      applyModify(newValue: string, previousValue: string, allowDeletes: boolean, plan: Plan<TestConfig>): Promise<void> {
+        throw new Error('Method not implemented.');
+      }
+      applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
+        throw new Error('Method not implemented.');
+      }
+    }
+
+    expect(() => new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          dependencies: ['homebrew', 'python'],
+          statefulParameters: [
+            parameter
+          ],
+          parameterConfigurations: {
+            propA: { planOperation: ResourceOperation.MODIFY },
+            propC: { isEqual: (a, b) => true },
+          }
+        });
+      }
+    }).to.not.throw;
+  })
+
+  it('Validates the resource configuration correct (fail)', () => {
+    const parameter = new class extends StatefulParameter<TestConfig, string> {
+      constructor() {
+        super({
+          name: 'propC',
+        });
+      }
+
+      async refresh(): Promise<string | null> {
+        return null;
+      }
+      applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
+        throw new Error('Method not implemented.');
+      }
+      applyModify(newValue: string, previousValue: string, allowDeletes: boolean, plan: Plan<TestConfig>): Promise<void> {
+        throw new Error('Method not implemented.');
+      }
+      applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
+        throw new Error('Method not implemented.');
+      }
+    }
+
+    expect(() => new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          dependencies: ['homebrew', 'python'],
+          statefulParameters: [
+            parameter
+          ],
+          parameterConfigurations: {
+            propA: { planOperation: ResourceOperation.MODIFY },
+            propC: { isEqual: (a, b) => true },
+          }
+        });
+      }
+    }).to.not.throw;
+  })
+
 });

package/src/entities/resource.ts

@@ -17,10 +17,9 @@ 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 dependencies: string[]; // TODO: Change this to a string
   readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>
-
-  private readonly options: ResourceConfiguration<T>;
+  readonly configuration: ResourceConfiguration<T>;
 
   protected constructor(configuration: ResourceConfiguration<T>) {
     this.validateResourceConfiguration(configuration);
@@ -30,11 +29,7 @@ export abstract class Resource<T extends StringIndexedObject> {
     this.parameterConfigurations = this.generateParameterConfigurations(configuration);
 
     this.dependencies = configuration.dependencies ?? [];
-    this.options = configuration;
-  }
-
-  getDependencyTypeIds(): string[] {
-    return this.dependencies.map((d) => d.typeId)
+    this.configuration = configuration;
   }
 
   async onInitialize(): Promise<void> {}
@@ -79,8 +74,18 @@ export abstract class Resource<T extends StringIndexedObject> {
       let currentValue = await statefulParameter.refresh() ?? 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;
+      if (Array.isArray(currentValue)
+        && Array.isArray(desiredValue)
+        && !planConfiguration.statefulMode
+        && !statefulParameter.configuration.disableStatelessModeArrayFiltering
+      ) {
+        currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
+          const pc = planConfiguration?.parameterConfigurations?.[statefulParameter.name];
+          if (pc && pc.isElementEqual) {
+            return pc.isElementEqual(d, c);
+          }
+          return d === c;
+        })) as any;
       }
 
       currentParameters[statefulParameter.name] = currentValue;
@@ -166,7 +171,7 @@ export abstract class Resource<T extends StringIndexedObject> {
   private async _applyDestroy(plan: Plan<T>): Promise<void> {
     // If this option is set (defaults to false), then stateful parameters need to be destroyed
     // as well. This means that the stateful parameter wouldn't have been normally destroyed with applyDestroy()
-    if (this.options.callStatefulParameterRemoveOnDestroy) {
+    if (this.configuration.callStatefulParameterRemoveOnDestroy) {
       const statefulParameterChanges = plan.changeSet.parameterChanges
         .filter((pc: ParameterChange<T>) => this.statefulParameters.has(pc.name))
       for (const parameterChange of statefulParameterChanges) {
@@ -205,16 +210,18 @@ export abstract class Resource<T extends StringIndexedObject> {
   }
 
   private validateResourceConfiguration(data: ResourceConfiguration<T>) {
-    // A parameter cannot be both stateful and stateless
+    // Stateful parameters are configured within the object not in the resource.
     if (data.parameterConfigurations && data.statefulParameters) {
       const parameters = [...Object.keys(data.parameterConfigurations)];
-      const statefulParameterSet = new Set(Object.keys(data.statefulParameters));
+      const statefulParameterSet = new Set(data.statefulParameters.map((sp) => sp.name));
 
       const intersection = parameters.some((p) => statefulParameterSet.has(p));
       if (intersection) {
         throw new Error(`Resource ${this.typeId} cannot declare a parameter as both stateful and non-stateful`);
       }
     }
+
+
   }
 
   private validateRefreshResults(refresh: Partial<T> | null, desiredKeys: Set<keyof T>) {
@@ -226,7 +233,7 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     if (!setsEqual(desiredKeys, refreshKeys)) {
       throw new Error(
-        `Resource ${this.options.type}
+        `Resource ${this.configuration.type}
 refresh() must return back exactly the keys that were provided
 Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`

package/src/entities/stateful-parameter.ts

@@ -4,6 +4,17 @@ import { StringIndexedObject } from 'codify-schemas';
 export interface StatefulParameterConfiguration<T> {
   name: keyof T;
   isEqual?: (desired: any, current: any) => boolean;
+
+  /**
+   * In stateless mode, array refresh results (current) will be automatically filtered by the user config (desired).
+   * This is done to ensure that for modify operations, stateless mode will not try to delete existing resources.
+   *
+   * Ex: System has python 3.11.9 and 3.12.7 installed (current). Desired is 3.11. Without filtering 3.12.7 will be deleted
+   * in the next modify
+   *
+   * Set this flag to true to disable this behaviour
+   */
+  disableStatelessModeArrayFiltering?: boolean;
 }
 
 export interface ArrayStatefulParameterConfiguration<T> extends StatefulParameterConfiguration<T> {