codify-plugin-lib 1.0.70 → 1.0.72

package/dist/entities/plugin.js

@@ -31,17 +31,15 @@ export class Plugin {
             if (!this.resources.has(config.type)) {
                 throw new Error(`Resource type not found: ${config.type}`);
             }
-            const { parameters } = splitUserConfig(config);
-            const validateResult = await this.resources.get(config.type).validateResource(parameters);
-            validationResults.push({
-                ...validateResult,
-                resourceType: config.type,
-                resourceName: config.name,
-            });
+            const { parameters, resourceMetadata } = splitUserConfig(config);
+            const validation = await this.resources
+                .get(config.type)
+                .validate(parameters, resourceMetadata);
+            validationResults.push(validation);
         }
         await this.crossValidateResources(data.configs);
         return {
-            validationResults
+            resourceValidations: validationResults
         };
     }
     async plan(data) {

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

@@ -9,7 +9,3 @@ export interface ResourceDefinition {
         type: string;
     };
 }
-export interface ValidationResult {
-    isValid: boolean;
-    errors?: unknown[];
-}

package/dist/entities/resource.d.ts

@@ -1,13 +1,13 @@
-import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import Ajv from 'ajv';
+import { ValidateFunction } from 'ajv/dist/2020.js';
+import { ResourceConfig, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
 import { ParameterChange } from './change-set.js';
 import { Plan } from './plan.js';
-import { StatefulParameter } from './stateful-parameter.js';
-import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
 import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions } from './plan-types.js';
-import { TransformParameter } from './transform-parameter.js';
 import { ResourceOptions } from './resource-options.js';
-import Ajv from 'ajv';
-import { ValidateFunction } from 'ajv/dist/2020.js';
+import { ResourceParameterOptions } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
 export declare abstract class Resource<T extends StringIndexedObject> {
     readonly typeId: string;
     readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
@@ -23,7 +23,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     protected schemaValidator?: ValidateFunction;
     protected constructor(options: ResourceOptions<T>);
     onInitialize(): Promise<void>;
-    validateResource(parameters: Partial<T>): Promise<ValidationResult>;
+    validate(parameters: Partial<T>, resourceMetaData: ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
     plan(desiredConfig: Partial<T> & ResourceConfig | null, currentConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
     private _applyCreate;
@@ -35,8 +35,8 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private refreshNonStatefulParameters;
     private refreshStatefulParameters;
     private validatePlanInputs;
-    validate(parameters: Partial<T>): Promise<ValidationResult>;
-    abstract refresh(values: Partial<T>): Promise<Partial<T> | null>;
+    customValidation(parameters: Partial<T>): Promise<void>;
+    abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
     abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
     applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void>;
     abstract applyDestroy(plan: DestroyPlan<T>): Promise<void>;

package/dist/entities/resource.js

@@ -1,8 +1,8 @@
+import Ajv2020 from 'ajv/dist/2020.js';
 import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
-import { Plan } from './plan.js';
 import { setsEqual, splitUserConfig } from '../utils/utils.js';
+import { Plan } from './plan.js';
 import { ResourceOptionsParser } from './resource-options.js';
-import Ajv2020 from 'ajv/dist/2020.js';
 export class Resource {
     typeId;
     statefulParameters;
@@ -37,28 +37,53 @@ export class Resource {
         this.transformParameterOrder = parser.transformParameterOrder;
     }
     async onInitialize() { }
-    async validateResource(parameters) {
+    async validate(parameters, resourceMetaData) {
         if (this.schemaValidator) {
             const isValid = this.schemaValidator(parameters);
             if (!isValid) {
                 return {
+                    resourceType: resourceMetaData.type,
+                    resourceName: resourceMetaData.name,
+                    schemaValidationErrors: this.schemaValidator?.errors ?? [],
                     isValid: false,
-                    errors: this.schemaValidator?.errors ?? [],
                 };
             }
         }
-        return this.validate(parameters);
+        let isValid = true;
+        let customValidationErrorMessage = undefined;
+        try {
+            await this.customValidation(parameters);
+        }
+        catch (err) {
+            isValid = false;
+            customValidationErrorMessage = err.message;
+        }
+        if (!isValid) {
+            return {
+                resourceType: resourceMetaData.type,
+                resourceName: resourceMetaData.name,
+                schemaValidationErrors: this.schemaValidator?.errors ?? [],
+                customValidationErrorMessage,
+                isValid: false,
+            };
+        }
+        return {
+            resourceType: resourceMetaData.type,
+            resourceName: resourceMetaData.name,
+            schemaValidationErrors: [],
+            isValid: true,
+        };
     }
     async plan(desiredConfig, currentConfig = null, statefulMode = false) {
         this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
         const planOptions = {
-            statefulMode,
             parameterOptions: this.parameterOptions,
+            statefulMode,
         };
         this.addDefaultValues(desiredConfig);
         await this.applyTransformParameters(desiredConfig);
         const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters);
-        const { desiredParameters, resourceMetadata, nonStatefulParameters, statefulParameters, } = parsedConfig;
+        const { desiredParameters, nonStatefulParameters, resourceMetadata, statefulParameters, } = parsedConfig;
         const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
         if (currentParameters == null) {
             return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
@@ -167,21 +192,20 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
                 throw new Error(`Transform parameter ${key} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
             }
             delete desired[key];
-            Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
+            for (const [tvKey, tvValue] of Object.entries(transformedValue)) {
                 desired[tvKey] = tvValue;
-            });
+            }
         }
     }
     addDefaultValues(desired) {
         if (!desired) {
             return;
         }
-        Object.entries(this.defaultValues)
-            .forEach(([key, defaultValue]) => {
+        for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
             if (defaultValue !== undefined && desired[key] === undefined) {
                 desired[key] = defaultValue;
             }
-        });
+        }
     }
     async refreshNonStatefulParameters(resourceParameters) {
         const currentParameters = await this.refresh(resourceParameters);
@@ -222,11 +246,7 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
             throw new Error('Desired config must be provided in non-stateful mode');
         }
     }
-    async validate(parameters) {
-        return {
-            isValid: true,
-        };
-    }
+    async customValidation(parameters) { }
     ;
     async applyModify(pc, plan) { }
     ;
@@ -269,18 +289,14 @@ ${JSON.stringify(currentMetadata, null, 2)}`);
     get parameters() {
         const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
         const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
-        return { ...(desiredParameters ?? {}), ...(currentParameters ?? {}) };
+        return { ...desiredParameters, ...currentParameters };
     }
     get nonStatefulParameters() {
-        const parameters = this.parameters;
-        return Object.fromEntries([
-            ...Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))),
-        ]);
+        const { parameters } = this;
+        return Object.fromEntries(Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))));
     }
     get statefulParameters() {
-        const parameters = this.parameters;
-        return Object.fromEntries([
-            ...Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)),
-        ]);
+        const { parameters } = this;
+        return Object.fromEntries(Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)));
     }
 }

package/dist/utils/utils.js

@@ -39,8 +39,8 @@ export function isDebug() {
 export function splitUserConfig(config) {
     const resourceMetadata = {
         type: config.type,
-        ...(config.name && { name: config.name }),
-        ...(config.dependsOn && { dependsOn: config.dependsOn }),
+        ...(config.name ? { name: config.name } : {}),
+        ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
     };
     const { type, name, dependsOn, ...parameters } = config;
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.70",
+  "version": "1.0.72",
   "description": "",
   "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.38",
+    "codify-schemas": "1.0.42",
     "@npmcli/promise-spawn": "^7.0.1"
   },
   "devDependencies": {

package/src/entities/plan.test.ts

@@ -121,6 +121,28 @@ describe('Plan entity tests', () => {
       .every((pc) => pc.operation === ParameterOperation.ADD)
     ).to.be.true;
   })
+
+  it('Returns the original resource names', () => {
+    const resource = createResource();
+
+    const plan = Plan.create(
+      {
+        propA: 'propA',
+      },
+      {
+        propA: 'propA2',
+      },
+      {
+        type: 'type',
+        name: 'name1'
+      }, { statefulMode: false });
+
+    expect(plan.toResponse()).toMatchObject({
+      resourceType: 'type',
+      resourceName: 'name1',
+      operation: ResourceOperation.RECREATE
+    })
+  })
 })
 
 function createResource(): Resource<any> {

package/src/entities/plugin.test.ts

@@ -3,8 +3,7 @@ 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';
+import { spy } from 'sinon';
 
 interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -27,36 +26,19 @@ class TestResource extends Resource<TestConfig> {
     return Promise.resolve(undefined);
   }
 
-  async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+  async refresh(): 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])
+  it('Can apply resource', async () => {
+    const resource= spy(new TestResource())
+    const plugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
       operation: ResourceOperation.CREATE,
@@ -66,45 +48,13 @@ describe('Plugin tests', () => {
       ]
     };
 
-    // If this doesn't throw then it passes the test
     await plugin.apply({ plan });
+    expect(resource.applyCreate.calledOnce).to.be.true;
   });
 
-  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])
+  it('Can destroy resource', async () => {
+    const resource = spy(new TestResource());
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
       operation: ResourceOperation.DESTROY,
@@ -114,46 +64,13 @@ describe('Plugin tests', () => {
       ]
     };
 
-    // If this doesn't throw then it passes the test
     await testPlugin.apply({ plan })
+    expect(resource.applyDestroy.calledOnce).to.be.true;
   });
 
-  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])
+  it('Can re-create resource', async () => {
+    const resource = spy(new TestResource())
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
       operation: ResourceOperation.RECREATE,
@@ -163,31 +80,24 @@ describe('Plugin tests', () => {
       ]
     };
 
-    // If this doesn't throw then it passes the test
     await testPlugin.apply({ plan })
+    expect(resource.applyDestroy.calledOnce).to.be.true;
+    expect(resource.applyCreate.calledOnce).to.be.true;
   });
 
-  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])
+  it('Can modify resource', async () => {
+    const resource = spy(new TestResource())
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
 
     const plan = {
-      operation: ResourceOperation.DESTROY,
+      operation: ResourceOperation.MODIFY,
       resourceType: 'testResource',
       parameters: [
-        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: 'def', previousValue: 'abc' },
+        { name: 'propA', operation: ParameterOperation.MODIFY, 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));
+    await testPlugin.apply({ plan })
+    expect(resource.applyModify.calledOnce).to.be.true;
   });
 });

package/src/entities/plugin.ts

@@ -50,19 +50,17 @@ export class Plugin {
         throw new Error(`Resource type not found: ${config.type}`);
       }
 
-      const { parameters } = splitUserConfig(config);
-      const validateResult = await this.resources.get(config.type)!.validateResource(parameters);
-
-      validationResults.push({
-        ...validateResult,
-        resourceType: config.type,
-        resourceName: config.name,
-      });
+      const { parameters, resourceMetadata } = splitUserConfig(config);
+      const validation = await this.resources
+        .get(config.type)!
+        .validate(parameters, resourceMetadata);
+
+      validationResults.push(validation);
     }
 
     await this.crossValidateResources(data.configs);
     return {
-      validationResults
+      resourceValidations: validationResults
     };
   }
 

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

@@ -471,9 +471,9 @@ describe('Resource parameter tests', () => {
     const plan = await resource.plan({ type: 'resourceType', propC: 'abc' } as any);
 
     expect(resource.refresh.called).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propA')).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propB')).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propC')).to.be.false;
+    expect(resource.refresh.getCall(0).firstArg['propA']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propB']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propC']).to.not.exist;
 
     expect(plan.desiredConfig?.propA).to.eq('propA');
     expect(plan.desiredConfig?.propB).to.eq(10);
@@ -513,8 +513,8 @@ describe('Resource parameter tests', () => {
     const plan = await resource.plan({ type: 'resourceType', propA: 'propA', propB: 10 } as any);
 
     expect(transformParameter.transform.called).to.be.false;
-    expect(resource.refresh.getCall(0).firstArg.has('propA')).to.be.true;
-    expect(resource.refresh.getCall(0).firstArg.has('propB')).to.be.true;
+    expect(resource.refresh.getCall(0).firstArg['propA']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propB']).to.exist;
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })

package/src/entities/resource-stateful-mode.test.ts

@@ -12,7 +12,7 @@ describe('Resource tests for stateful plans', () => {
         super({ type: 'resource' });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propADifferent',
           propB: undefined,
@@ -61,7 +61,7 @@ describe('Resource tests for stateful plans', () => {
         super({ type: 'resource' });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return null;
       }
     }
@@ -113,7 +113,7 @@ describe('Resource tests for stateful plans', () => {
         super({ type: 'resource' });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propA',
           propC: 'propC',
@@ -184,7 +184,7 @@ describe('Resource tests for stateful plans', () => {
         });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propA',
           propC: 'propC',

package/src/entities/resource-types.ts

@@ -29,8 +29,3 @@ export interface ResourceDefinition {
     type: string;
   }
 }
-
-export interface ValidationResult {
-  isValid: boolean;
-  errors?: unknown[],
-}

package/src/entities/resource.test.ts

@@ -3,7 +3,6 @@ import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
 import { spy } from 'sinon';
 import { Plan } from './plan.js';
 import { describe, expect, it } from 'vitest'
-import { ValidationResult } from './resource-types.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceOptions } from './resource-options.js';
 import { CreatePlan, DestroyPlan, ModifyPlan } from './plan-types.js';
@@ -28,19 +27,13 @@ export class TestResource extends Resource<TestConfig> {
     return Promise.resolve(undefined);
   }
 
-  async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+  async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
     return {
       propA: 'a',
       propB: 10,
       propC: 'c',
     };
   }
-
-  async validateResource(config: unknown): Promise<ValidationResult> {
-    return {
-      isValid: true
-    }
-  }
 }
 
 describe('Resource tests', () => {
@@ -298,9 +291,8 @@ describe('Resource tests', () => {
       }
 
       // @ts-ignore
-      async refresh(desired: Map<string, unknown>): Promise<Partial<TestConfig>> {
-        expect(desired.has('propA')).to.be.true;
-        expect(desired.get('propA')).to.be.eq('propADefault');
+      async refresh(desired: Partial<TestConfig>): Promise<Partial<TestConfig>> {
+        expect(desired['propA']).to.be.eq('propADefault');
 
         return {
           propA: 'propAAfter'
@@ -325,11 +317,11 @@ describe('Resource tests', () => {
         });
       }
 
-      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
-        expect(keys.has('propE')).to.be.true;
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        expect(parameters['propE']).to.exist;
 
         return {
-          propE: keys.get('propE'),
+          propE: parameters['propE'],
         };
       }
     }
@@ -374,9 +366,8 @@ describe('Resource tests', () => {
       }
 
       // @ts-ignore
-      async refresh(desired: Map<string, unknown>): Promise<Partial<TestConfig>> {
-        expect(desired.has('propA')).to.be.true;
-        expect(desired.get('propA')).to.be.eq('propA');
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig>> {
+        expect(parameters['propA']).to.be.eq('propA');
 
         return {
           propA: 'propAAfter'
@@ -413,7 +404,7 @@ describe('Resource tests', () => {
         super({ type: 'type' });
       }
 
-      async refresh(values: Map<keyof TestConfig, unknown>): Promise<Partial<TestConfig> | null> {
+      async refresh(): Promise<Partial<TestConfig> | null> {
         return null;
       }
 

package/src/entities/resource.ts

@@ -1,14 +1,21 @@
-import { ParameterOperation, ResourceConfig, ResourceOperation, StringIndexedObject, } from 'codify-schemas';
+import Ajv from 'ajv';
+import Ajv2020, { ValidateFunction } from 'ajv/dist/2020.js';
+import {
+  ParameterOperation,
+  ResourceConfig,
+  ResourceOperation,
+  StringIndexedObject,
+  ValidateResponseData,
+} from 'codify-schemas';
+
+import { setsEqual, splitUserConfig } from '../utils/utils.js';
 import { ParameterChange } from './change-set.js';
 import { Plan } from './plan.js';
-import { StatefulParameter } from './stateful-parameter.js';
-import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
-import { setsEqual, splitUserConfig } from '../utils/utils.js';
 import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions, PlanOptions } from './plan-types.js';
-import { TransformParameter } from './transform-parameter.js';
 import { ResourceOptions, ResourceOptionsParser } from './resource-options.js';
-import Ajv from 'ajv';
-import Ajv2020, { ValidateFunction } from 'ajv/dist/2020.js';
+import { ResourceParameterOptions } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
 
 /**
  * Description of resource here
@@ -59,19 +66,48 @@ export abstract class Resource<T extends StringIndexedObject> {
 
   async onInitialize(): Promise<void> {}
 
-  async validateResource(parameters: Partial<T>): Promise<ValidationResult> {
+  async validate(
+    parameters: Partial<T>,
+    resourceMetaData: ResourceConfig
+  ): Promise<ValidateResponseData['resourceValidations'][0]> {
     if (this.schemaValidator) {
       const isValid = this.schemaValidator(parameters);
 
       if (!isValid) {
         return {
+          resourceType: resourceMetaData.type,
+          resourceName: resourceMetaData.name,
+          schemaValidationErrors: this.schemaValidator?.errors ?? [],
           isValid: false,
-          errors: this.schemaValidator?.errors ?? [],
         }
       }
     }
 
-    return this.validate(parameters);
+    let isValid = true;
+    let customValidationErrorMessage = undefined;
+    try {
+      await this.customValidation(parameters);
+    } catch (err) {
+      isValid = false;
+      customValidationErrorMessage = (err as Error).message;
+    }
+
+    if (!isValid) {
+      return {
+        resourceType: resourceMetaData.type,
+        resourceName: resourceMetaData.name,
+        schemaValidationErrors: this.schemaValidator?.errors ?? [],
+        customValidationErrorMessage,
+        isValid: false,
+      }
+    }
+
+    return {
+      resourceType: resourceMetaData.type,
+      resourceName: resourceMetaData.name,
+      schemaValidationErrors: [],
+      isValid: true,
+    }
   }
 
   // TODO: Currently stateful mode expects that the currentConfig does not need any additional transformations (default and transform parameters)
@@ -84,8 +120,8 @@ export abstract class Resource<T extends StringIndexedObject> {
     this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
 
     const planOptions: PlanOptions<T> = {
-      statefulMode,
       parameterOptions: this.parameterOptions,
+      statefulMode,
     }
 
     this.addDefaultValues(desiredConfig);
@@ -95,8 +131,8 @@ export abstract class Resource<T extends StringIndexedObject> {
     const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters)
     const {
       desiredParameters,
-      resourceMetadata,
       nonStatefulParameters,
+      resourceMetadata,
       statefulParameters,
     } = parsedConfig;
 
@@ -133,13 +169,16 @@ export abstract class Resource<T extends StringIndexedObject> {
       case ResourceOperation.CREATE: {
         return this._applyCreate(plan); // TODO: Add new parameters value so that apply
       }
+
       case ResourceOperation.MODIFY: {
         return this._applyModify(plan);
       }
+
       case ResourceOperation.RECREATE: {
         await this._applyDestroy(plan);
         return this._applyCreate(plan);
       }
+
       case ResourceOperation.DESTROY: {
         return this._applyDestroy(plan);
       }
@@ -185,11 +224,13 @@ export abstract class Resource<T extends StringIndexedObject> {
           await statefulParameter.applyAdd(parameterChange.newValue, plan);
           break;
         }
+
         case ParameterOperation.MODIFY: {
           // TODO: When stateful mode is added in the future. Dynamically choose if deletes are allowed
           await statefulParameter.applyModify(parameterChange.newValue, parameterChange.previousValue, false, plan);
           break;
         }
+
         case ParameterOperation.REMOVE: {
           await statefulParameter.applyRemove(parameterChange.previousValue, plan);
           break;
@@ -256,10 +297,10 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
       delete desired[key];
 
       // Add the new transformed values
-      Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
+      for (const [tvKey, tvValue] of Object.entries(transformedValue)) {
         // @ts-ignore
         desired[tvKey] = tvValue;
-      })
+      }
     }
   }
 
@@ -268,13 +309,12 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
       return;
     }
 
-    Object.entries(this.defaultValues)
-      .forEach(([key, defaultValue]) => {
+    for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
         if (defaultValue !== undefined && desired[key as any] === undefined) {
           // @ts-ignore
           desired[key] = defaultValue;
         }
-      });
+      }
   }
 
   private async refreshNonStatefulParameters(resourceParameters: Partial<T>): Promise<Partial<T> | null> {
@@ -337,13 +377,15 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
-  async validate(parameters: Partial<T>): Promise<ValidationResult> {
-    return {
-      isValid: true,
-    }
-  };
+  /**
+   * Add custom validation logic in-addition to the default schema validation.
+   * In this method throw an error if the object did not validate. The message of the
+   * error will be shown to the user.
+   * @param parameters
+   */
+  async customValidation(parameters: Partial<T>): Promise<void> {};
 
-  abstract refresh(values: Partial<T>): Promise<Partial<T> | null>;
+  abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
 
   abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
 
@@ -407,22 +449,22 @@ ${JSON.stringify(currentMetadata, null, 2)}`);
     const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
     const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
 
-    return { ...(desiredParameters ?? {}), ...(currentParameters ?? {}) } as Partial<T>;
+    return { ...desiredParameters, ...currentParameters } as Partial<T>;
   }
 
   get nonStatefulParameters(): Partial<T> {
-    const parameters = this.parameters;
+    const { parameters } = this;
 
-    return Object.fromEntries([
-      ...Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))),
-    ]) as Partial<T>;
+    return Object.fromEntries(
+      Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key)))
+    ) as Partial<T>;
   }
 
   get statefulParameters(): Partial<T> {
-    const parameters = this.parameters;
+    const { parameters } = this;
 
-    return Object.fromEntries([
-      ...Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)),
-    ]) as Partial<T>;
+    return Object.fromEntries(
+      Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key))
+    ) as Partial<T>;
   }
 }

package/src/entities/stateful-parameter.test.ts

@@ -22,7 +22,6 @@ class TestArrayParameter extends ArrayStatefulParameter<TestConfig, string> {
   }
 }
 
-
 describe('Stateful parameter tests', () => {
   it('applyAddItem is called the correct number of times', async () => {
     const plan = Plan.create<TestConfig>(
@@ -36,7 +35,7 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.parameterChanges.length).to.eq(1);
 
     const testParameter = spy(new TestArrayParameter());
-    await testParameter.applyAdd(plan.desiredConfig.propA, plan);
+    await testParameter.applyAdd(plan.desiredConfig!.propA, plan);
 
     expect(testParameter.applyAddItem.callCount).to.eq(3);
     expect(testParameter.applyRemoveItem.called).to.be.false;
@@ -54,7 +53,7 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.parameterChanges.length).to.eq(1);
 
     const testParameter = spy(new TestArrayParameter());
-    await testParameter.applyRemove(plan.currentConfig.propA, plan);
+    await testParameter.applyRemove(plan.currentConfig!.propA, plan);
 
     expect(testParameter.applyAddItem.called).to.be.false;
     expect(testParameter.applyRemoveItem.callCount).to.eq(3);
@@ -77,7 +76,7 @@ describe('Stateful parameter tests', () => {
     })
 
     const testParameter = spy(new TestArrayParameter());
-    await testParameter.applyModify(plan.desiredConfig.propA, plan.currentConfig.propA, false, plan);
+    await testParameter.applyModify(plan.desiredConfig!.propA, plan.currentConfig!.propA, false, plan);
 
     expect(testParameter.applyAddItem.calledThrice).to.be.true;
     expect(testParameter.applyRemoveItem.called).to.be.false;
@@ -107,7 +106,7 @@ describe('Stateful parameter tests', () => {
       }
     });
 
-    await testParameter.applyModify(plan.desiredConfig.propA, plan.currentConfig.propA, false, plan);
+    await testParameter.applyModify(plan.desiredConfig!.propA, plan.currentConfig!.propA, false, plan);
 
     expect(testParameter.applyAddItem.calledOnce).to.be.true;
     expect(testParameter.applyRemoveItem.called).to.be.false;

package/src/utils/utils.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { splitUserConfig } from './utils.js';
+
+describe('Utils tests', () => {
+  it('Can split a config correctly', () => {
+    const { parameters, resourceMetadata } = splitUserConfig({
+      type: 'type',
+      name: 'name',
+      dependsOn: ['a', 'b', 'c'],
+      propA: 'propA',
+      propB: 'propB',
+      propC: 'propC',
+      propD: 'propD',
+    })
+
+    expect(resourceMetadata).toMatchObject({
+      type: 'type',
+      name: 'name',
+      dependsOn: ['a', 'b', 'c'],
+    })
+
+    expect(parameters).toMatchObject({
+      propA: 'propA',
+      propB: 'propB',
+      propC: 'propC',
+      propD: 'propD',
+    })
+  })
+})

package/src/utils/utils.ts

@@ -85,8 +85,8 @@ export function splitUserConfig<T extends StringIndexedObject>(
 ): { parameters: T;  resourceMetadata: ResourceConfig} {
   const resourceMetadata = {
     type: config.type,
-    ...(config.name && { name: config.name }),
-    ...(config.dependsOn && { dependsOn: config.dependsOn }),
+    ...(config.name ? { name: config.name } : {}),
+    ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
   };
 
   const { type, name, dependsOn, ...parameters } = config;

package/dist/entities/test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/entities/test.js

@@ -1,22 +0,0 @@
-import { Resource } from './resource.js';
-class Test extends Resource {
-    validate(config) {
-        throw new Error('Method not implemented.');
-    }
-    async refresh(keys) {
-        const result = {};
-        if (keys.has('propA')) {
-            result['propA'] = 'abc';
-        }
-        return result;
-    }
-    applyCreate(plan) {
-        throw new Error('Method not implemented.');
-    }
-    applyModify(parameterName, newValue, previousValue, plan) {
-        throw new Error('Method not implemented.');
-    }
-    applyDestroy(plan) {
-        throw new Error('Method not implemented.');
-    }
-}

package/dist/utils/common-types.d.ts

@@ -1,3 +0,0 @@
-export interface StringIndexedObject {
-    [x: string]: unknown;
-}

package/dist/utils/common-types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/test-utils.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { ChildProcess } from 'child_process';
-export declare class CodifyTestUtils {
-    static sendMessageToProcessAwaitResponse(process: ChildProcess, message: any): Promise<any>;
-}

package/dist/utils/test-utils.js

@@ -1,17 +0,0 @@
-export class CodifyTestUtils {
-    static sendMessageToProcessAwaitResponse(process, message) {
-        return new Promise((resolve, reject) => {
-            process.on('message', (response) => {
-                resolve(response);
-            });
-            process.on('error', (err) => reject(err));
-            process.on('exit', (code) => {
-                if (code != 0) {
-                    reject('Exit code is not 0');
-                }
-                resolve(code);
-            });
-            process.send(message);
-        });
-    }
-}