codify-plugin-lib 1.0.43 → 1.0.44

package/dist/entities/resource.js

@@ -39,8 +39,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;
         }

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.44",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

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

@@ -79,8 +79,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;

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> {