codify-plugin-lib 1.0.114 → 1.0.116

package/dist/common/errors.d.ts

@@ -0,0 +1,8 @@
+import { Plan } from '../plan/plan.js';
+export declare class ApplyValidationError extends Error {
+    resourceType: string;
+    resourceName?: string;
+    plan: Plan<any>;
+    constructor(plan: Plan<any>);
+    private static prettyPrintPlan;
+}

package/dist/common/errors.js

@@ -0,0 +1,24 @@
+export class ApplyValidationError extends Error {
+    resourceType;
+    resourceName;
+    plan;
+    constructor(plan) {
+        super(`Failed to apply changes to resource: "${plan.resourceId}". Additional changes are needed to complete apply.\nChanges remaining:\n${ApplyValidationError.prettyPrintPlan(plan)}`);
+        this.resourceType = plan.coreParameters.type;
+        this.resourceName = plan.coreParameters.name;
+        this.plan = plan;
+    }
+    static prettyPrintPlan(plan) {
+        const { operation, parameters } = plan.toResponse();
+        const prettyParameters = parameters.map(({ name, operation, previousValue, newValue }) => ({
+            name,
+            operation,
+            currentValue: previousValue,
+            desiredValue: newValue,
+        }));
+        return JSON.stringify({
+            operation,
+            parameters: prettyParameters,
+        }, null, 2);
+    }
+}

package/dist/index.js

@@ -13,4 +13,7 @@ export * from './utils/utils.js';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);
     process.on('message', (message) => messageHandler.onMessage(message));
+    process.on('beforeExit', () => {
+        plugin.kill();
+    });
 }

package/dist/plan/plan.d.ts

@@ -8,9 +8,16 @@ import { ChangeSet } from './change-set.js';
  */
 export declare class Plan<T extends StringIndexedObject> {
     id: string;
+    /**
+     * List of changes to make
+     */
     changeSet: ChangeSet<T>;
+    /**
+     * Ex: name, type, dependsOn etc. Metadata parameters
+     */
     coreParameters: ResourceConfig;
-    constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
+    statefulMode: boolean;
+    constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig, statefulMode: boolean);
     /**
      * The desired config that a plan will achieve after executing all the actions.
      */
@@ -19,6 +26,15 @@ export declare class Plan<T extends StringIndexedObject> {
      * The current config that the plan is changing.
      */
     get currentConfig(): T | null;
+    get resourceId(): string;
+    static calculate<T extends StringIndexedObject>(params: {
+        desiredParameters: Partial<T> | null;
+        currentParametersArray: Partial<T>[] | null;
+        stateParameters: Partial<T> | null;
+        coreParameters: ResourceConfig;
+        settings: ParsedResourceSettings<T>;
+        statefulMode: boolean;
+    }): Plan<T>;
     /**
      * When multiples of the same resource are allowed, this matching function will match a given config with one of the
      * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
@@ -34,14 +50,7 @@ export declare class Plan<T extends StringIndexedObject> {
      * @return string
      */
     getResourceType(): string;
-    static calculate<T extends StringIndexedObject>(params: {
-        desiredParameters: Partial<T> | null;
-        currentParametersArray: Partial<T>[] | null;
-        stateParameters: Partial<T> | null;
-        coreParameters: ResourceConfig;
-        settings: ParsedResourceSettings<T>;
-        statefulMode: boolean;
-    }): Plan<T>;
+    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
      *  defined.
@@ -51,7 +60,7 @@ export declare class Plan<T extends StringIndexedObject> {
      *  or wants to set. If a parameter is not specified then it's not managed by Codify.
      */
     private static filterCurrentParams;
-    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
+    requiresChanges(): boolean;
     /**
      * Convert the plan to a JSON response object
      */

package/dist/plan/plan.js

@@ -8,12 +8,20 @@ import { ChangeSet } from './change-set.js';
  */
 export class Plan {
     id;
+    /**
+     * List of changes to make
+     */
     changeSet;
+    /**
+     * Ex: name, type, dependsOn etc. Metadata parameters
+     */
     coreParameters;
-    constructor(id, changeSet, resourceMetadata) {
+    statefulMode;
+    constructor(id, changeSet, resourceMetadata, statefulMode) {
         this.id = id;
         this.changeSet = changeSet;
         this.coreParameters = resourceMetadata;
+        this.statefulMode = statefulMode;
     }
     /**
      * The desired config that a plan will achieve after executing all the actions.
@@ -39,6 +47,43 @@ export class Plan {
             ...this.changeSet.currentParameters,
         };
     }
+    get resourceId() {
+        return this.coreParameters.name
+            ? `${this.coreParameters.type}.${this.coreParameters.name}`
+            : this.coreParameters.type;
+    }
+    static calculate(params) {
+        const { desiredParameters, currentParametersArray, stateParameters, coreParameters, settings, statefulMode } = params;
+        const currentParameters = Plan.matchCurrentParameters({
+            desiredParameters,
+            currentParametersArray,
+            stateParameters,
+            settings,
+            statefulMode
+        });
+        const filteredCurrentParameters = Plan.filterCurrentParams({
+            desiredParameters,
+            currentParameters,
+            stateParameters,
+            settings,
+            statefulMode
+        });
+        // Empty
+        if (!filteredCurrentParameters && !desiredParameters) {
+            return new Plan(uuidV4(), ChangeSet.empty(), coreParameters, statefulMode);
+        }
+        // CREATE
+        if (!filteredCurrentParameters && desiredParameters) {
+            return new Plan(uuidV4(), ChangeSet.create(desiredParameters), coreParameters, statefulMode);
+        }
+        // DESTROY
+        if (filteredCurrentParameters && !desiredParameters) {
+            return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters), coreParameters, statefulMode);
+        }
+        // NO-OP, MODIFY or RE-CREATE
+        const changeSet = ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
+        return new Plan(uuidV4(), changeSet, coreParameters, statefulMode);
+    }
     /**
      * When multiples of the same resource are allowed, this matching function will match a given config with one of the
      * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
@@ -70,37 +115,59 @@ export class Plan {
     getResourceType() {
         return this.coreParameters.type;
     }
-    static calculate(params) {
-        const { desiredParameters, currentParametersArray, stateParameters, coreParameters, settings, statefulMode } = params;
-        const currentParameters = Plan.matchCurrentParameters({
-            desiredParameters,
-            currentParametersArray,
-            stateParameters,
-            settings,
-            statefulMode
-        });
-        const filteredCurrentParameters = Plan.filterCurrentParams({
-            desiredParameters,
-            currentParameters,
-            stateParameters,
-            settings,
-            statefulMode
-        });
-        // Empty
-        if (!filteredCurrentParameters && !desiredParameters) {
-            return new Plan(uuidV4(), ChangeSet.empty(), coreParameters);
-        }
-        // CREATE
-        if (!filteredCurrentParameters && desiredParameters) {
-            return new Plan(uuidV4(), ChangeSet.create(desiredParameters), coreParameters);
+    //   2. Even if there was (maybe for testing reasons), the plan values should not be adjusted
+    static fromResponse(data, defaultValues) {
+        if (!data) {
+            throw new Error('Data is empty');
         }
-        // DESTROY
-        if (filteredCurrentParameters && !desiredParameters) {
-            return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters), coreParameters);
+        addDefaultValues();
+        return new Plan(uuidV4(), new ChangeSet(data.operation, data.parameters), {
+            type: data.resourceType,
+            name: data.resourceName,
+        }, data.statefulMode);
+        function addDefaultValues() {
+            Object.entries(defaultValues ?? {})
+                .forEach(([key, defaultValue]) => {
+                const configValueExists = data
+                    .parameters
+                    .some((p) => p.name === key);
+                // Only set default values if the value does not exist in the config
+                if (configValueExists) {
+                    return;
+                }
+                switch (data.operation) {
+                    case ResourceOperation.CREATE: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.ADD,
+                            previousValue: null,
+                            newValue: defaultValue,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.DESTROY: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.REMOVE,
+                            previousValue: defaultValue,
+                            newValue: null,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.MODIFY:
+                    case ResourceOperation.RECREATE:
+                    case ResourceOperation.NOOP: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.NOOP,
+                            previousValue: defaultValue,
+                            newValue: defaultValue,
+                        });
+                        break;
+                    }
+                }
+            });
         }
-        // NO-OP, MODIFY or RE-CREATE
-        const changeSet = ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
-        return new Plan(uuidV4(), changeSet, coreParameters);
     }
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
@@ -199,59 +266,8 @@ export class Plan {
     }
     // TODO: This needs to be revisited. I don't think this is valid anymore.
     //   1. For all scenarios, there shouldn't be an apply without a plan beforehand
-    //   2. Even if there was (maybe for testing reasons), the plan values should not be adjusted
-    static fromResponse(data, defaultValues) {
-        if (!data) {
-            throw new Error('Data is empty');
-        }
-        addDefaultValues();
-        return new Plan(uuidV4(), new ChangeSet(data.operation, data.parameters), {
-            type: data.resourceType,
-            name: data.resourceName,
-        });
-        function addDefaultValues() {
-            Object.entries(defaultValues ?? {})
-                .forEach(([key, defaultValue]) => {
-                const configValueExists = data
-                    .parameters
-                    .some((p) => p.name === key);
-                // Only set default values if the value does not exist in the config
-                if (configValueExists) {
-                    return;
-                }
-                switch (data.operation) {
-                    case ResourceOperation.CREATE: {
-                        data.parameters.push({
-                            name: key,
-                            operation: ParameterOperation.ADD,
-                            previousValue: null,
-                            newValue: defaultValue,
-                        });
-                        break;
-                    }
-                    case ResourceOperation.DESTROY: {
-                        data.parameters.push({
-                            name: key,
-                            operation: ParameterOperation.REMOVE,
-                            previousValue: defaultValue,
-                            newValue: null,
-                        });
-                        break;
-                    }
-                    case ResourceOperation.MODIFY:
-                    case ResourceOperation.RECREATE:
-                    case ResourceOperation.NOOP: {
-                        data.parameters.push({
-                            name: key,
-                            operation: ParameterOperation.NOOP,
-                            previousValue: defaultValue,
-                            newValue: defaultValue,
-                        });
-                        break;
-                    }
-                }
-            });
-        }
+    requiresChanges() {
+        return this.changeSet.operation !== ResourceOperation.NOOP;
     }
     /**
      * Convert the plan to a JSON response object

package/dist/plugin/plugin.d.ts

@@ -1,8 +1,8 @@
 import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
+import { BackgroundPty } from '../pty/background-pty.js';
 import { Resource } from '../resource/resource.js';
 import { ResourceController } from '../resource/resource-controller.js';
-import { BackgroundPty } from '../pty/background-pty.js';
 export declare class Plugin {
     name: string;
     resourceControllers: Map<string, ResourceController<ResourceConfig>>;
@@ -16,6 +16,7 @@ export declare class Plugin {
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;
     plan(data: PlanRequestData): Promise<PlanResponseData>;
     apply(data: ApplyRequestData): Promise<void>;
+    kill(): Promise<void>;
     private resolvePlan;
     protected crossValidateResources(configs: ResourceConfig[]): Promise<void>;
 }

package/dist/plugin/plugin.js

@@ -1,7 +1,9 @@
+import { ApplyValidationError } from '../common/errors.js';
 import { Plan } from '../plan/plan.js';
+import { BackgroundPty } from '../pty/background-pty.js';
+import { getPty } from '../pty/index.js';
 import { ResourceController } from '../resource/resource-controller.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
-import { BackgroundPty } from '../pty/background-pty.js';
 export class Plugin {
     name;
     resourceControllers;
@@ -82,9 +84,7 @@ export class Plugin {
         if (!type || !this.resourceControllers.has(type)) {
             throw new Error(`Resource type not found: ${type}`);
         }
-        const plan = await ptyLocalStorage.run(this.planPty, async () => {
-            return this.resourceControllers.get(type).plan(data.desired ?? null, data.state ?? null, data.isStateful);
-        });
+        const plan = await ptyLocalStorage.run(this.planPty, async () => this.resourceControllers.get(type).plan(data.desired ?? null, data.state ?? null, data.isStateful));
         this.planStorage.set(plan.id, plan);
         return plan.toResponse();
     }
@@ -98,6 +98,17 @@ export class Plugin {
             throw new Error('Malformed plan with resource that cannot be found');
         }
         await resource.apply(plan);
+        const validationPlan = await ptyLocalStorage.run(new BackgroundPty(), async () => {
+            const result = await resource.plan(plan.desiredConfig, plan.currentConfig, plan.statefulMode);
+            await getPty().kill();
+            return result;
+        });
+        if (validationPlan.requiresChanges()) {
+            throw new ApplyValidationError(plan);
+        }
+    }
+    async kill() {
+        await this.planPty.kill();
     }
     resolvePlan(data) {
         const { plan: planRequest, planId } = data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.114",
+  "version": "1.0.116",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.53",
+    "codify-schemas": "1.0.54",
     "@npmcli/promise-spawn": "^7.0.1",
     "uuid": "^10.0.0",
     "lodash.isequal": "^4.5.0",

package/src/common/errors.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { ApplyValidationError } from './errors.js';
+import { testPlan } from '../utils/test-utils.test.js';
+
+describe('Test file for errors file', () => {
+  it('Can properly format ApplyValidationError', () => {
+    const plan = testPlan({
+      desired: null,
+      current: [{ propZ: ['a', 'b', 'c'] }],
+      state: { propZ: ['a', 'b', 'c'] },
+      core: {
+        type: 'homebrew',
+        name: 'first'
+      },
+      statefulMode: true,
+    })
+
+    try {
+      throw new ApplyValidationError(plan);
+    } catch (e) {
+      console.error(e);
+      expect(e.message).toMatch(
+        `Failed to apply changes to resource: "homebrew.first". Additional changes are needed to complete apply.
+Changes remaining:
+{
+  "operation": "destroy",
+  "parameters": [
+    {
+      "name": "propZ",
+      "operation": "remove",
+      "currentValue": [
+        "a",
+        "b",
+        "c"
+      ],
+      "desiredValue": null
+    }
+  ]
+}`
+      )
+    }
+  })
+})

package/src/common/errors.ts

@@ -0,0 +1,31 @@
+import { Plan } from '../plan/plan.js';
+
+export class ApplyValidationError extends Error {
+  resourceType: string;
+  resourceName?: string;
+  plan: Plan<any>;
+
+  constructor(plan: Plan<any>) {
+    super(`Failed to apply changes to resource: "${plan.resourceId}". Additional changes are needed to complete apply.\nChanges remaining:\n${ApplyValidationError.prettyPrintPlan(plan)}`);
+
+    this.resourceType = plan.coreParameters.type;
+    this.resourceName = plan.coreParameters.name;
+    this.plan = plan;
+  }
+
+  private static prettyPrintPlan(plan: Plan<any>): string {
+    const { operation, parameters } = plan.toResponse();
+
+    const prettyParameters = parameters.map(({ name, operation, previousValue, newValue }) => ({
+      name,
+      operation,
+      currentValue: previousValue,
+      desiredValue: newValue,
+    }));
+
+    return JSON.stringify({
+      operation,
+      parameters: prettyParameters,
+    }, null, 2);
+  }
+}

package/src/index.ts

@@ -16,4 +16,8 @@ export * from './utils/utils.js'
 export async function runPlugin(plugin: Plugin) {
   const messageHandler = new MessageHandler(plugin);
   process.on('message', (message) => messageHandler.onMessage(message))
+
+  process.on('beforeExit', () => {
+    plugin.kill();
+  })
 }

package/src/plan/plan.test.ts

@@ -19,7 +19,8 @@ describe('Plan entity tests', () => {
         operation: ParameterOperation.ADD,
         previousValue: null,
         newValue: 'propBValue'
-      }]
+      }],
+      statefulMode: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).to.be.null;
@@ -47,7 +48,8 @@ describe('Plan entity tests', () => {
         operation: ParameterOperation.REMOVE,
         previousValue: 'propBValue',
         newValue: null,
-      }]
+      }],
+      statefulMode: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
@@ -75,7 +77,8 @@ describe('Plan entity tests', () => {
         operation: ParameterOperation.NOOP,
         previousValue: 'propBValue',
         newValue: 'propBValue',
-      }]
+      }],
+      statefulMode: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
@@ -112,7 +115,8 @@ describe('Plan entity tests', () => {
         operation: ParameterOperation.ADD,
         previousValue: null,
         newValue: 'propAValue',
-      }]
+      }],
+      statefulMode: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).to.be.null

package/src/plan/plan.ts

@@ -23,13 +23,24 @@ import { ChangeSet } from './change-set.js';
  */
 export class Plan<T extends StringIndexedObject> {
   id: string;
+
+  /**
+   * List of changes to make
+   */
   changeSet: ChangeSet<T>;
-  coreParameters: ResourceConfig
 
-  constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig) {
+  /**
+   * Ex: name, type, dependsOn etc. Metadata parameters
+   */
+  coreParameters: ResourceConfig;
+
+  statefulMode: boolean;
+
+  constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig, statefulMode: boolean) {
     this.id = id;
     this.changeSet = changeSet;
     this.coreParameters = resourceMetadata;
+    this.statefulMode = statefulMode;
   }
 
   /**
@@ -60,53 +71,10 @@ export class Plan<T extends StringIndexedObject> {
     }
   }
 
-  /**
-   * When multiples of the same resource are allowed, this matching function will match a given config with one of the
-   * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
-   * the application name and location to match it to our desired configs name and location.
-   *
-   * @param params
-   * @private
-   */
-  private static matchCurrentParameters<T extends StringIndexedObject>(params: {
-    desiredParameters: Partial<T> | null,
-    currentParametersArray: Partial<T>[] | null,
-    stateParameters: Partial<T> | null,
-    settings: ResourceSettings<T>,
-    statefulMode: boolean,
-  }): Partial<T> | null {
-    const {
-      desiredParameters,
-      currentParametersArray,
-      stateParameters,
-      settings,
-      statefulMode
-    } = params;
-
-    if (!settings.allowMultiple) {
-      return currentParametersArray?.[0] ?? null;
-    }
-
-    if (!currentParametersArray) {
-      return null;
-    }
-
-    if (statefulMode) {
-      return stateParameters
-        ? settings.allowMultiple.matcher(stateParameters, currentParametersArray)
-        : null
-    }
-
-    return settings.allowMultiple.matcher(desiredParameters!, currentParametersArray);
-  }
-
-  /**
-   * The type (id) of the resource
-   *
-   * @return string
-   */
-  getResourceType(): string {
-    return this.coreParameters.type
+  get resourceId(): string {
+    return this.coreParameters.name
+      ? `${this.coreParameters.type}.${this.coreParameters.name}`
+      : this.coreParameters.type;
   }
 
   static calculate<T extends StringIndexedObject>(params: {
@@ -148,6 +116,7 @@ export class Plan<T extends StringIndexedObject> {
         uuidV4(),
         ChangeSet.empty<T>(),
         coreParameters,
+        statefulMode,
       )
     }
 
@@ -156,7 +125,8 @@ export class Plan<T extends StringIndexedObject> {
       return new Plan(
         uuidV4(),
         ChangeSet.create(desiredParameters),
-        coreParameters
+        coreParameters,
+        statefulMode,
       )
     }
 
@@ -165,7 +135,8 @@ export class Plan<T extends StringIndexedObject> {
       return new Plan(
         uuidV4(),
         ChangeSet.destroy(filteredCurrentParameters),
-        coreParameters
+        coreParameters,
+        statefulMode,
       )
     }
 
@@ -180,7 +151,128 @@ export class Plan<T extends StringIndexedObject> {
       uuidV4(),
       changeSet,
       coreParameters,
+      statefulMode,
+    );
+  }
+
+  /**
+   * When multiples of the same resource are allowed, this matching function will match a given config with one of the
+   * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
+   * the application name and location to match it to our desired configs name and location.
+   *
+   * @param params
+   * @private
+   */
+  private static matchCurrentParameters<T extends StringIndexedObject>(params: {
+    desiredParameters: Partial<T> | null,
+    currentParametersArray: Partial<T>[] | null,
+    stateParameters: Partial<T> | null,
+    settings: ResourceSettings<T>,
+    statefulMode: boolean,
+  }): Partial<T> | null {
+    const {
+      desiredParameters,
+      currentParametersArray,
+      stateParameters,
+      settings,
+      statefulMode
+    } = params;
+
+    if (!settings.allowMultiple) {
+      return currentParametersArray?.[0] ?? null;
+    }
+
+    if (!currentParametersArray) {
+      return null;
+    }
+
+    if (statefulMode) {
+      return stateParameters
+        ? settings.allowMultiple.matcher(stateParameters, currentParametersArray)
+        : null
+    }
+
+    return settings.allowMultiple.matcher(desiredParameters!, currentParametersArray);
+  }
+
+  /**
+   * The type (id) of the resource
+   *
+   * @return string
+   */
+  getResourceType(): string {
+    return this.coreParameters.type
+  }
+
+  //   2. Even if there was (maybe for testing reasons), the plan values should not be adjusted
+  static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T> {
+    if (!data) {
+      throw new Error('Data is empty');
+    }
+
+    addDefaultValues();
+
+    return new Plan(
+      uuidV4(),
+      new ChangeSet<T>(
+        data.operation,
+        data.parameters
+      ),
+      {
+        type: data.resourceType,
+        name: data.resourceName,
+      },
+      data.statefulMode
     );
+
+   function addDefaultValues(): void {
+      Object.entries(defaultValues ?? {})
+        .forEach(([key, defaultValue]) => {
+          const configValueExists = data!
+            .parameters
+            .some((p) => p.name === key);
+
+          // Only set default values if the value does not exist in the config
+          if (configValueExists) {
+            return;
+          }
+
+          switch (data!.operation) {
+            case ResourceOperation.CREATE: {
+              data!.parameters.push({
+                name: key,
+                operation: ParameterOperation.ADD,
+                previousValue: null,
+                newValue: defaultValue,
+              });
+              break;
+            }
+
+            case ResourceOperation.DESTROY: {
+              data!.parameters.push({
+                name: key,
+                operation: ParameterOperation.REMOVE,
+                previousValue: defaultValue,
+                newValue: null,
+              });
+              break;
+            }
+
+            case ResourceOperation.MODIFY:
+            case ResourceOperation.RECREATE:
+            case ResourceOperation.NOOP: {
+              data!.parameters.push({
+                name: key,
+                operation: ParameterOperation.NOOP,
+                previousValue: defaultValue,
+                newValue: defaultValue,
+              });
+              break;
+            }
+          }
+        });
+    }
+
   }
 
   /**
@@ -322,74 +414,9 @@ export class Plan<T extends StringIndexedObject> {
 
   // TODO: This needs to be revisited. I don't think this is valid anymore.
   //   1. For all scenarios, there shouldn't be an apply without a plan beforehand
-  //   2. Even if there was (maybe for testing reasons), the plan values should not be adjusted
-  static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T> {
-    if (!data) {
-      throw new Error('Data is empty');
-    }
-
-    addDefaultValues();
-
-    return new Plan(
-      uuidV4(),
-      new ChangeSet<T>(
-        data.operation,
-        data.parameters
-      ),
-      {
-        type: data.resourceType,
-        name: data.resourceName,
-      },
-    );
-
-   function addDefaultValues(): void {
-      Object.entries(defaultValues ?? {})
-        .forEach(([key, defaultValue]) => {
-          const configValueExists = data!
-            .parameters
-            .some((p) => p.name === key);
-
-          // Only set default values if the value does not exist in the config
-          if (configValueExists) {
-            return;
-          }
-
-          switch (data!.operation) {
-            case ResourceOperation.CREATE: {
-              data!.parameters.push({
-                name: key,
-                operation: ParameterOperation.ADD,
-                previousValue: null,
-                newValue: defaultValue,
-              });
-              break;
-            }
-
-            case ResourceOperation.DESTROY: {
-              data!.parameters.push({
-                name: key,
-                operation: ParameterOperation.REMOVE,
-                previousValue: defaultValue,
-                newValue: null,
-              });
-              break;
-            }
-
-            case ResourceOperation.MODIFY:
-            case ResourceOperation.RECREATE:
-            case ResourceOperation.NOOP: {
-              data!.parameters.push({
-                name: key,
-                operation: ParameterOperation.NOOP,
-                previousValue: defaultValue,
-                newValue: defaultValue,
-              });
-              break;
-            }
-          }
-        });
-    }
 
+  requiresChanges(): boolean {
+    return this.changeSet.operation !== ResourceOperation.NOOP;
   }
 
   /**

package/src/plugin/plugin.test.ts

@@ -1,10 +1,13 @@
 import { describe, expect, it } from 'vitest';
 import { Plugin } from './plugin.js';
-import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { ApplyRequestData, ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
 import { Resource } from '../resource/resource.js';
 import { Plan } from '../plan/plan.js';
 import { spy } from 'sinon';
 import { ResourceSettings } from '../resource/resource-settings.js';
+import { TestConfig } from '../utils/test-utils.test.js';
+import { ApplyValidationError } from '../common/errors.js';
+import { getPty } from '../pty/index.js';
 
 interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -38,15 +41,22 @@ class TestResource extends Resource<TestConfig> {
 
 describe('Plugin tests', () => {
   it('Can apply resource', async () => {
-    const resource= spy(new TestResource())
+    const resource = spy(new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'abc',
+        }
+      }
+    })
     const plugin = Plugin.create('testPlugin', [resource as any])
 
-    const plan = {
+    const plan: ApplyRequestData['plan'] = {
       operation: ResourceOperation.CREATE,
       resourceType: 'testResource',
       parameters: [
         { name: 'propA', operation: ParameterOperation.ADD, newValue: 'abc', previousValue: null },
-      ]
+      ],
+      statefulMode: false,
     };
 
     await plugin.apply({ plan });
@@ -54,15 +64,20 @@ describe('Plugin tests', () => {
   });
 
   it('Can destroy resource', async () => {
-    const resource = spy(new TestResource());
+    const resource = spy(new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    });
     const testPlugin = Plugin.create('testPlugin', [resource as any])
 
-    const plan = {
+    const plan: ApplyRequestData['plan'] = {
       operation: ResourceOperation.DESTROY,
       resourceType: 'testResource',
       parameters: [
         { name: 'propA', operation: ParameterOperation.REMOVE, newValue: null, previousValue: 'abc' },
-      ]
+      ],
+      statefulMode: true,
     };
 
     await testPlugin.apply({ plan })
@@ -70,15 +85,22 @@ describe('Plugin tests', () => {
   });
 
   it('Can re-create resource', async () => {
-    const resource = spy(new TestResource())
+    const resource = spy(new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'def',
+        }
+      }
+    })
     const testPlugin = Plugin.create('testPlugin', [resource as any])
 
-    const plan = {
+    const plan: ApplyRequestData['plan'] = {
       operation: ResourceOperation.RECREATE,
       resourceType: 'testResource',
       parameters: [
         { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
-      ]
+      ],
+      statefulMode: false,
     };
 
     await testPlugin.apply({ plan })
@@ -87,15 +109,22 @@ describe('Plugin tests', () => {
   });
 
   it('Can modify resource', async () => {
-    const resource = spy(new TestResource())
+    const resource = spy(new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'def',
+        }
+      }
+    })
     const testPlugin = Plugin.create('testPlugin', [resource as any])
 
-    const plan = {
+    const plan: ApplyRequestData['plan'] = {
       operation: ResourceOperation.MODIFY,
       resourceType: 'testResource',
       parameters: [
         { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
-      ]
+      ],
+      statefulMode: false,
     };
 
     await testPlugin.apply({ plan })
@@ -178,4 +207,78 @@ describe('Plugin tests', () => {
       requiredParameters: []
     })
   })
+
+  it('Fails an apply if the validation fails', async () => {
+    const resource = spy(new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'abc',
+        }
+      }
+    })
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
+
+    const plan: ApplyRequestData['plan'] = {
+      operation: ResourceOperation.MODIFY,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
+      ],
+      statefulMode: false,
+    };
+
+    await expect(() => testPlugin.apply({ plan }))
+      .rejects
+      .toThrowError(new ApplyValidationError(Plan.fromResponse(plan)));
+    expect(resource.modify.calledOnce).to.be.true;
+  })
+
+  it('Allows the usage of pty in refresh (plan)', async () => {
+    const resource = spy(new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        expect(getPty()).to.not.be.undefined;
+        expect(getPty()).to.not.be.null;
+
+        return null;
+      }
+    })
+
+    const testPlugin = Plugin.create('testPlugin', [resource as any]);
+    await testPlugin.plan({
+      desired: {
+        type: 'testResource'
+      },
+      state: undefined,
+      isStateful: false,
+    })
+
+    expect(resource.refresh.calledOnce).to.be.true;
+  });
+
+  it('Allows the usage of pty in validation refresh (apply)', async () => {
+    const resource = spy(new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        expect(getPty()).to.not.be.undefined;
+        expect(getPty()).to.not.be.null;
+
+        return {
+          propA: 'abc'
+        };
+      }
+    })
+
+    const testPlugin = Plugin.create('testPlugin', [resource as any]);
+
+    const plan: ApplyRequestData['plan'] = {
+      operation: ResourceOperation.CREATE,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.ADD, newValue: 'abc', previousValue: null },
+      ],
+      statefulMode: false,
+    };
+
+    await testPlugin.apply({ plan })
+    expect(resource.refresh.calledOnce).to.be.true;
+  })
 });

package/src/plugin/plugin.ts

@@ -13,11 +13,13 @@ import {
   ValidateResponseData
 } from 'codify-schemas';
 
+import { ApplyValidationError } from '../common/errors.js';
 import { Plan } from '../plan/plan.js';
+import { BackgroundPty } from '../pty/background-pty.js';
+import { getPty } from '../pty/index.js';
 import { Resource } from '../resource/resource.js';
 import { ResourceController } from '../resource/resource-controller.js';
 import { ptyLocalStorage } from '../utils/pty-local-storage.js';
-import { BackgroundPty } from '../pty/background-pty.js';
 
 export class Plugin {
   planStorage: Map<string, Plan<any>>;
@@ -122,13 +124,11 @@ export class Plugin {
       throw new Error(`Resource type not found: ${type}`);
     }
 
-    const plan = await ptyLocalStorage.run(this.planPty, async () => {
-      return this.resourceControllers.get(type)!.plan(
+    const plan = await ptyLocalStorage.run(this.planPty, async () => this.resourceControllers.get(type)!.plan(
         data.desired ?? null,
         data.state ?? null,
         data.isStateful
-      );
-    })
+    ))
 
     this.planStorage.set(plan.id, plan);
 
@@ -148,6 +148,25 @@ export class Plugin {
     }
 
     await resource.apply(plan);
+
+    const validationPlan = await ptyLocalStorage.run(new BackgroundPty(), async () => {
+      const result = await resource.plan(
+        plan.desiredConfig,
+        plan.currentConfig,
+        plan.statefulMode
+      );
+
+      await getPty().kill();
+      return result;
+    })
+
+    if (validationPlan.requiresChanges()) {
+      throw new ApplyValidationError(plan);
+    }
+  }
+
+  async kill() {
+    await this.planPty.kill();
   }
 
   private resolvePlan(data: ApplyRequestData): Plan<ResourceConfig> {
@@ -170,5 +189,4 @@ export class Plugin {
   }
 
   protected async crossValidateResources(configs: ResourceConfig[]): Promise<void> {}
-
 }

package/src/resource/resource-settings.test.ts

@@ -499,7 +499,8 @@ describe('Resource parameter tests', () => {
           { name: 'propA', operation: ParameterOperation.ADD, previousValue: null, newValue: null },
           { name: 'propB', operation: ParameterOperation.ADD, previousValue: null, newValue: null },
           { name: 'propC', operation: ParameterOperation.ADD, previousValue: null, newValue: null },
-        ]
+        ],
+        statefulMode: false,
       }, {}) as any
     );
 
@@ -521,7 +522,8 @@ describe('Resource parameter tests', () => {
           { name: 'propA', operation: ParameterOperation.MODIFY, previousValue: null, newValue: null },
           { name: 'propB', operation: ParameterOperation.MODIFY, previousValue: null, newValue: null },
           { name: 'propC', operation: ParameterOperation.MODIFY, previousValue: null, newValue: null },
-        ]
+        ],
+        statefulMode: false,
       }, {}) as any
     );
 
@@ -539,7 +541,8 @@ describe('Resource parameter tests', () => {
           { name: 'propA', operation: ParameterOperation.REMOVE, previousValue: null, newValue: null },
           { name: 'propB', operation: ParameterOperation.REMOVE, previousValue: null, newValue: null },
           { name: 'propC', operation: ParameterOperation.REMOVE, previousValue: null, newValue: null },
-        ]
+        ],
+        statefulMode: false,
       }, {}) as any
     );
 

package/vitest.config.ts

@@ -2,6 +2,7 @@ import { defaultExclude, defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
+    pool: 'forks',
     exclude: [
       ...defaultExclude,
       './src/utils/test-utils.test.ts',