codify-plugin-lib 1.0.64 → 1.0.66

package/dist/entities/change-set.js

@@ -59,8 +59,8 @@ export class ChangeSet {
     }
     static calculateStatefulModeChangeSet(desired, current, parameterOptions) {
         const parameterChangeSet = new Array();
-        const _desired = { ...desired };
-        const _current = { ...current };
+        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
+        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
         this.addDefaultValues(_desired, parameterOptions);
         for (const [k, v] of Object.entries(_current)) {
             if (_desired[k] == null) {
@@ -108,8 +108,8 @@ export class ChangeSet {
     }
     static calculateStatelessModeChangeSet(desired, current, parameterOptions) {
         const parameterChangeSet = new Array();
-        const _desired = { ...desired };
-        const _current = { ...current };
+        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
+        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
         this.addDefaultValues(_desired, parameterOptions);
         for (const [k, v] of Object.entries(_desired)) {
             if (_current[k] == null) {

package/dist/entities/errors.d.ts

@@ -1,4 +1,11 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
 export declare class SudoError extends Error {
     command: string;
     constructor(command: string);
 }
+export declare class ApplyValidationError<T extends StringIndexedObject> extends Error {
+    desiredPlan: Plan<T>;
+    validatedPlan: Plan<T>;
+    constructor(desiredPlan: Plan<T>, validatedPlan: Plan<T>);
+}

package/dist/entities/errors.js

@@ -5,3 +5,12 @@ export class SudoError extends Error {
         this.command = command;
     }
 }
+export class ApplyValidationError extends Error {
+    desiredPlan;
+    validatedPlan;
+    constructor(desiredPlan, validatedPlan) {
+        super();
+        this.desiredPlan = desiredPlan;
+        this.validatedPlan = validatedPlan;
+    }
+}

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

@@ -1,5 +1,5 @@
 export interface ParameterOptions {
-    canModify?: boolean;
+    modifyOnChange?: boolean;
     isEqual?: (desired: any, current: any) => boolean;
     isElementEqual?: (desired: any, current: any) => boolean;
     default?: unknown;

package/dist/entities/plan.d.ts

@@ -8,8 +8,8 @@ export declare class Plan<T extends StringIndexedObject> {
     constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
     static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, options: PlanOptions<T>): Plan<T>;
     getResourceType(): string;
-    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues: Partial<Record<keyof T, unknown>>): Plan<T>;
-    get desiredConfig(): T;
-    get currentConfig(): T;
+    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
+    get desiredConfig(): T | null;
+    get currentConfig(): T | null;
     toResponse(): PlanResponseData;
 }

package/dist/entities/plan.js

@@ -31,8 +31,8 @@ export class Plan {
                 if (statefulParameterNames.has(curr.name)) {
                     newOperation = ResourceOperation.MODIFY;
                 }
-                else if (parameterOptions[curr.name]?.canModify) {
-                    newOperation = parameterOptions[curr.name].canModify ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
+                else if (parameterOptions[curr.name]?.modifyOnChange) {
+                    newOperation = parameterOptions[curr.name].modifyOnChange ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
                 }
                 else {
                     newOperation = ResourceOperation.RECREATE;
@@ -55,7 +55,7 @@ export class Plan {
             name: data.resourceName,
         });
         function addDefaultValues() {
-            Object.entries(defaultValues)
+            Object.entries(defaultValues ?? {})
                 .forEach(([key, defaultValue]) => {
                 const configValueExists = data
                     .parameters
@@ -98,12 +98,18 @@ export class Plan {
         }
     }
     get desiredConfig() {
+        if (this.changeSet.operation === ResourceOperation.DESTROY) {
+            return null;
+        }
         return {
             ...this.resourceMetadata,
             ...this.changeSet.desiredParameters,
         };
     }
     get currentConfig() {
+        if (this.changeSet.operation === ResourceOperation.CREATE) {
+            return null;
+        }
         return {
             ...this.resourceMetadata,
             ...this.changeSet.currentParameters,

package/dist/entities/plugin.d.ts

@@ -4,7 +4,8 @@ import { Plan } from './plan.js';
 export declare class Plugin {
     name: string;
     resources: Map<string, Resource<ResourceConfig>>;
-    planStorage: Map<string, Plan<ResourceConfig>>;
+    planStorage: Map<string, Plan<any>>;
+    static create(name: string, resources: Resource<any>[]): Plugin;
     constructor(name: string, resources: Map<string, Resource<ResourceConfig>>);
     initialize(): Promise<InitializeResponseData>;
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;

package/dist/entities/plugin.js

@@ -1,9 +1,15 @@
+import { ResourceOperation } from 'codify-schemas';
 import { Plan } from './plan.js';
 import { splitUserConfig } from '../utils/utils.js';
+import { ApplyValidationError } from './errors.js';
 export class Plugin {
     name;
     resources;
     planStorage;
+    static create(name, resources) {
+        const resourceMap = new Map(resources.map((r) => [r.typeId, r]));
+        return new Plugin(name, resourceMap);
+    }
     constructor(name, resources) {
         this.name = name;
         this.resources = resources;
@@ -58,6 +64,10 @@ export class Plugin {
             throw new Error('Malformed plan with resource that cannot be found');
         }
         await resource.apply(plan);
+        const validationPlan = await resource.plan(plan.desiredConfig, plan.currentConfig, true);
+        if (validationPlan.changeSet.operation !== ResourceOperation.NOOP) {
+            throw new ApplyValidationError(plan, validationPlan);
+        }
     }
     resolvePlan(data) {
         const { planId, plan: planRequest } = data;

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

@@ -1,6 +1,6 @@
 export type ErrorMessage = string;
 export interface ResourceParameterOptions {
-    canModify?: boolean;
+    modifyOnChange?: boolean;
     isEqual?: (desired: any, current: any) => boolean;
     default?: unknown;
 }

package/dist/entities/resource.d.ts

@@ -24,7 +24,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     protected constructor(options: ResourceOptions<T>);
     onInitialize(): Promise<void>;
     validateResource(parameters: unknown): Promise<ValidationResult>;
-    plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>>;
+    plan(desiredConfig: Partial<T> & ResourceConfig | null, currentConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
     private _applyCreate;
     private _applyModify;
@@ -32,8 +32,9 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private validateRefreshResults;
     private applyTransformParameters;
     private addDefaultValues;
-    private refreshResourceParameters;
+    private refreshNonStatefulParameters;
     private refreshStatefulParameters;
+    private validatePlanInputs;
     validate(parameters: unknown): Promise<ValidationResult>;
     abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
     abstract applyCreate(plan: Plan<T>): Promise<void>;

package/dist/entities/resource.js

@@ -49,21 +49,22 @@ export class Resource {
         }
         return this.validate(parameters);
     }
-    async plan(desiredConfig) {
+    async plan(desiredConfig, currentConfig = null, statefulMode = false) {
+        this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
         const planOptions = {
-            statefulMode: false,
+            statefulMode,
             parameterOptions: this.parameterOptions,
         };
         this.addDefaultValues(desiredConfig);
-        const parsedConfig = new ConfigParser(desiredConfig, this.statefulParameters, this.transformParameters);
-        const { parameters: desiredParameters, resourceMetadata, resourceParameters, statefulParameters, transformParameters, } = parsedConfig;
-        await this.applyTransformParameters(transformParameters, resourceParameters);
-        const currentParameters = await this.refreshResourceParameters(resourceParameters);
+        await this.applyTransformParameters(desiredConfig);
+        const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters);
+        const { desiredParameters, resourceMetadata, nonStatefulParameters, statefulParameters, } = parsedConfig;
+        const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
         if (currentParameters == null) {
-            return Plan.create({ ...resourceParameters, ...statefulParameters }, null, resourceMetadata, planOptions);
+            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
         }
         const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
-        return Plan.create({ ...resourceParameters, ...statefulParameters }, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
+        return Plan.create(desiredParameters, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
     }
     async apply(plan) {
         if (plan.getResourceType() !== this.typeId) {
@@ -151,20 +152,30 @@ Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
-    async applyTransformParameters(transformParameters, desired) {
-        const orderedEntries = [...Object.entries(transformParameters)]
+    async applyTransformParameters(desired) {
+        if (!desired) {
+            return;
+        }
+        const transformParameters = [...this.transformParameters.entries()]
             .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
-        for (const [key, value] of orderedEntries) {
-            const transformedValue = await this.transformParameters.get(key).transform(value);
+        for (const [key, transformParameter] of transformParameters) {
+            if (desired[key] === undefined) {
+                continue;
+            }
+            const transformedValue = await transformParameter.transform(desired[key]);
             if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
                 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]) => {
                 desired[tvKey] = tvValue;
             });
         }
     }
     addDefaultValues(desired) {
+        if (!desired) {
+            return;
+        }
         Object.entries(this.defaultValues)
             .forEach(([key, defaultValue]) => {
             if (defaultValue !== undefined && desired[key] === undefined) {
@@ -172,7 +183,7 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
             }
         });
     }
-    async refreshResourceParameters(resourceParameters) {
+    async refreshNonStatefulParameters(resourceParameters) {
         const entriesToRefresh = new Map(Object.entries(resourceParameters));
         const currentParameters = await this.refresh(entriesToRefresh);
         this.validateRefreshResults(currentParameters, entriesToRefresh);
@@ -204,6 +215,14 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
         return currentParameters;
     }
+    validatePlanInputs(desired, current, statefulMode) {
+        if (!desired && !current) {
+            throw new Error('Desired config and current config cannot both be missing');
+        }
+        if (!statefulMode && !desired) {
+            throw new Error('Desired config must be provided in non-stateful mode');
+        }
+    }
     async validate(parameters) {
         return {
             isValid: true,
@@ -214,23 +233,46 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
     ;
 }
 class ConfigParser {
-    config;
+    desiredConfig;
+    currentConfig;
     statefulParametersMap;
     transformParametersMap;
-    constructor(config, statefulParameters, transformParameters) {
-        this.config = config;
+    constructor(desiredConfig, currentConfig, statefulParameters, transformParameters) {
+        this.desiredConfig = desiredConfig;
+        this.currentConfig = currentConfig;
         this.statefulParametersMap = statefulParameters;
         this.transformParametersMap = transformParameters;
     }
     get resourceMetadata() {
-        const { resourceMetadata } = splitUserConfig(this.config);
-        return resourceMetadata;
+        const desiredMetadata = this.desiredConfig ? splitUserConfig(this.desiredConfig).resourceMetadata : undefined;
+        const currentMetadata = this.currentConfig ? splitUserConfig(this.currentConfig).resourceMetadata : undefined;
+        if (!desiredMetadata && !currentMetadata) {
+            throw new Error(`Unable to parse resource metadata from ${this.desiredConfig}, ${this.currentConfig}`);
+        }
+        if (currentMetadata && desiredMetadata && (Object.keys(desiredMetadata).length !== Object.keys(currentMetadata).length
+            || Object.entries(desiredMetadata).some(([key, value]) => currentMetadata[key] !== value))) {
+            throw new Error(`The metadata for the current config does not match the desired config. 
+Desired metadata:
+${JSON.stringify(desiredMetadata, null, 2)}
+
+Current metadata:
+${JSON.stringify(currentMetadata, null, 2)}`);
+        }
+        return desiredMetadata ?? currentMetadata;
     }
-    get parameters() {
-        const { parameters } = splitUserConfig(this.config);
+    get desiredParameters() {
+        if (!this.desiredConfig) {
+            return null;
+        }
+        const { parameters } = splitUserConfig(this.desiredConfig);
         return parameters;
     }
-    get resourceParameters() {
+    get parameters() {
+        const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
+        const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
+        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))),
@@ -242,10 +284,4 @@ class ConfigParser {
             ...Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)),
         ]);
     }
-    get transformParameters() {
-        const parameters = this.parameters;
-        return Object.fromEntries([
-            ...Object.entries(parameters).filter(([key]) => this.transformParametersMap.has(key)),
-        ]);
-    }
 }

package/dist/index.d.ts

@@ -8,6 +8,5 @@ export * from './entities/plan.js';
 export * from './entities/plan-types.js';
 export * from './entities/stateful-parameter.js';
 export * from './entities/errors.js';
-export * from './utils/test-utils.js';
 export * from './utils/utils.js';
 export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -8,7 +8,6 @@ export * from './entities/plan.js';
 export * from './entities/plan-types.js';
 export * from './entities/stateful-parameter.js';
 export * from './entities/errors.js';
-export * from './utils/test-utils.js';
 export * from './utils/utils.js';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);

package/dist/messages/handlers.js

@@ -1,7 +1,7 @@
 import addFormats from 'ajv-formats';
 import { ApplyRequestDataSchema, ApplyResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
 import Ajv2020 from 'ajv/dist/2020.js';
-import { SudoError } from '../entities/errors.js';
+import { ApplyValidationError, SudoError } from '../entities/errors.js';
 const SupportedRequests = {
     'initialize': {
         requestValidator: InitializeRequestDataSchema,
@@ -83,12 +83,26 @@ export class MessageHandler {
         }
         const cmd = message.cmd + '_Response';
         if (e instanceof SudoError) {
-            process.send?.({
+            return process.send?.({
                 cmd,
                 status: MessageStatus.ERROR,
                 data: `Plugin: '${this.plugin.name}'. Forbidden usage of sudo for command '${e.command}'. Please contact the plugin developer to fix this.`,
             });
         }
+        if (e instanceof ApplyValidationError) {
+            return process.send?.({
+                cmd,
+                status: MessageStatus.ERROR,
+                data: `Plugin: '${this.plugin.name}'. Apply validation was not successful (additional changes are needed to match the desired plan).
+
+Validation plan:
+${JSON.stringify(e.validatedPlan, null, 2)},
+        
+User desired plan:
+${JSON.stringify(e.desiredPlan, null, 2)}
+`
+            });
+        }
         const isDebug = process.env.DEBUG?.includes('*') ?? false;
         process.send?.({
             cmd,

package/package.json

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

package/src/entities/change-set.ts

@@ -123,8 +123,8 @@ export class ChangeSet<T extends StringIndexedObject> {
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
     
-    const _desired = { ...desired };
-    const _current = { ...current };
+    const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
+    const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
 
     this.addDefaultValues(_desired, parameterOptions);
 
@@ -190,8 +190,9 @@ export class ChangeSet<T extends StringIndexedObject> {
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
-    const _desired = { ...desired };
-    const _current = { ...current };
+    const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
+    const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
+
 
     this.addDefaultValues(_desired, parameterOptions);
 

package/src/entities/errors.ts

@@ -1,3 +1,6 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
+
 export class SudoError extends Error {
   command: string;
 
@@ -6,3 +9,17 @@ export class SudoError extends Error {
     this.command = command;
   }
 }
+
+export class ApplyValidationError<T extends StringIndexedObject> extends Error {
+  desiredPlan: Plan<T>;
+  validatedPlan: Plan<T>;
+
+  constructor(
+    desiredPlan: Plan<T>,
+    validatedPlan: Plan<T>
+  ) {
+    super();
+    this.desiredPlan = desiredPlan;
+    this.validatedPlan = validatedPlan;
+  }
+}

package/src/entities/plan-types.ts

@@ -5,7 +5,7 @@ export interface ParameterOptions {
   /**
    * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to false (re-creates resource on change).
    */
-  canModify?: boolean;
+  modifyOnChange?: boolean;
   /**
    * Customize the equality comparison for a parameter.
    * @param a

package/src/entities/plan.test.ts

@@ -19,11 +19,7 @@ describe('Plan entity tests', () => {
       }]
     }, resource.defaultValues);
 
-    expect(plan.currentConfig).toMatchObject({
-      type: 'type',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.currentConfig).to.be.null;
 
     expect(plan.desiredConfig).toMatchObject({
       type: 'type',
@@ -56,11 +52,7 @@ describe('Plan entity tests', () => {
       propB: 'propBValue',
     })
 
-    expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.desiredConfig).to.be.null;
 
     expect(plan.changeSet.parameterChanges
       .every((pc) => pc.operation === ParameterOperation.REMOVE)
@@ -117,11 +109,7 @@ describe('Plan entity tests', () => {
       }]
     }, resource.defaultValues);
 
-    expect(plan.currentConfig).toMatchObject({
-      type: 'type',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.currentConfig).to.be.null
 
     expect(plan.desiredConfig).toMatchObject({
       type: 'type',

package/src/entities/plan.ts

@@ -55,8 +55,8 @@ export class Plan<T extends StringIndexedObject> {
           let newOperation: ResourceOperation;
           if (statefulParameterNames.has(curr.name)) {
             newOperation = ResourceOperation.MODIFY // All stateful parameters are modify only
-          } else if (parameterOptions[curr.name]?.canModify) {
-            newOperation = parameterOptions[curr.name].canModify ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
+          } else if (parameterOptions[curr.name]?.modifyOnChange) {
+            newOperation = parameterOptions[curr.name].modifyOnChange ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
           } else {
             newOperation = ResourceOperation.RECREATE; // Default to Re-create. Should handle the majority of use cases
           }
@@ -75,7 +75,7 @@ export class Plan<T extends StringIndexedObject> {
     return this.resourceMetadata.type
   }
 
-  static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues: Partial<Record<keyof T, unknown>>): Plan<T> {
+  static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T> {
     if (!data) {
       throw new Error('Data is empty');
     }
@@ -95,7 +95,7 @@ export class Plan<T extends StringIndexedObject> {
     );
 
    function addDefaultValues(): void {
-      Object.entries(defaultValues)
+      Object.entries(defaultValues ?? {})
         .forEach(([key, defaultValue]) => {
           const configValueExists = data!
             .parameters
@@ -144,14 +144,22 @@ export class Plan<T extends StringIndexedObject> {
 
   }
 
-  get desiredConfig(): T {
+  get desiredConfig(): T | null {
+    if (this.changeSet.operation === ResourceOperation.DESTROY) {
+      return null;
+    }
+
     return {
       ...this.resourceMetadata,
       ...this.changeSet.desiredParameters,
     }
   }
 
-  get currentConfig(): T {
+  get currentConfig(): T | null {
+    if (this.changeSet.operation === ResourceOperation.CREATE) {
+      return null;
+    }
+
     return {
       ...this.resourceMetadata,
       ...this.changeSet.currentParameters,