codify-plugin-lib 1.0.69 → 1.0.71

package/dist/entities/resource.d.ts

@@ -1,13 +1,13 @@
+import Ajv from 'ajv';
+import { ValidateFunction } from 'ajv/dist/2020.js';
 import { ResourceConfig, StringIndexedObject } 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, ValidationResult } 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: unknown): Promise<ValidationResult>;
+    validateResource(parameters: Partial<T>): Promise<ValidationResult>;
     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: unknown): Promise<ValidationResult>;
-    abstract refresh(values: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
+    validate(parameters: Partial<T>): Promise<ValidationResult>;
+    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;
@@ -42,8 +42,8 @@ export class Resource {
             const isValid = this.schemaValidator(parameters);
             if (!isValid) {
                 return {
-                    isValid: false,
                     errors: this.schemaValidator?.errors ?? [],
+                    isValid: false,
                 };
             }
         }
@@ -52,13 +52,13 @@ export class Resource {
     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);
@@ -139,11 +139,11 @@ export class Resource {
         }
         await this.applyDestroy(plan);
     }
-    validateRefreshResults(refresh, desiredMap) {
+    validateRefreshResults(refresh, desired) {
         if (!refresh) {
             return;
         }
-        const desiredKeys = new Set(desiredMap.keys());
+        const desiredKeys = new Set(Object.keys(refresh));
         const refreshKeys = new Set(Object.keys(refresh));
         if (!setsEqual(desiredKeys, refreshKeys)) {
             throw new Error(`Resource ${this.typeId}
@@ -167,26 +167,24 @@ 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 entriesToRefresh = new Map(Object.entries(resourceParameters));
-        const currentParameters = await this.refresh(entriesToRefresh);
-        this.validateRefreshResults(currentParameters, entriesToRefresh);
+        const currentParameters = await this.refresh(resourceParameters);
+        this.validateRefreshResults(currentParameters, resourceParameters);
         return currentParameters;
     }
     async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {
@@ -270,18 +268,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.69",
+  "version": "1.0.71",
   "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.39",
     "@npmcli/promise-spawn": "^7.0.1"
   },
   "devDependencies": {

package/src/entities/errors.ts

@@ -1,6 +1,3 @@
-import { Plan } from './plan.js';
-import { StringIndexedObject } from 'codify-schemas';
-
 export class SudoError extends Error {
   command: string;
 

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

@@ -5,7 +5,6 @@ import {
   PlanRequestData,
   PlanResponseData,
   ResourceConfig,
-  ResourceOperation,
   ValidateRequestData,
   ValidateResponseData
 } from 'codify-schemas';

package/src/entities/resource.ts

@@ -1,14 +1,15 @@
+import Ajv from 'ajv';
+import Ajv2020, { ValidateFunction } from 'ajv/dist/2020.js';
 import { ParameterOperation, ResourceConfig, ResourceOperation, StringIndexedObject, } 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, ValidationResult } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
 
 /**
  * Description of resource here
@@ -59,14 +60,14 @@ export abstract class Resource<T extends StringIndexedObject> {
 
   async onInitialize(): Promise<void> {}
 
-  async validateResource(parameters: unknown): Promise<ValidationResult> {
+  async validateResource(parameters: Partial<T>): Promise<ValidationResult> {
     if (this.schemaValidator) {
       const isValid = this.schemaValidator(parameters);
 
       if (!isValid) {
         return {
-          isValid: false,
           errors: this.schemaValidator?.errors ?? [],
+          isValid: false,
         }
       }
     }
@@ -84,8 +85,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 +96,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 +134,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 +189,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;
@@ -215,12 +221,12 @@ export abstract class Resource<T extends StringIndexedObject> {
     await this.applyDestroy(plan as DestroyPlan<T>);
   }
 
-  private validateRefreshResults(refresh: Partial<T> | null, desiredMap: Map<keyof T, T[keyof T]>) {
+  private validateRefreshResults(refresh: Partial<T> | null, desired: Partial<T>) {
     if (!refresh) {
       return;
     }
 
-    const desiredKeys = new Set<keyof T>(desiredMap.keys());
+    const desiredKeys = new Set(Object.keys(refresh)) as Set<keyof T>;
     const refreshKeys = new Set(Object.keys(refresh)) as Set<keyof T>;
 
     if (!setsEqual(desiredKeys, refreshKeys)) {
@@ -256,10 +262,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,21 +274,17 @@ 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> {
-    const entriesToRefresh = new Map<keyof T, T[keyof T]>(
-      Object.entries(resourceParameters)
-    )
-    const currentParameters = await this.refresh(entriesToRefresh);
-    this.validateRefreshResults(currentParameters, entriesToRefresh);
+    const currentParameters = await this.refresh(resourceParameters);
+    this.validateRefreshResults(currentParameters, resourceParameters);
     return currentParameters;
   }
 
@@ -340,13 +342,13 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
-  async validate(parameters: unknown): Promise<ValidationResult> {
+  async validate(parameters: Partial<T>): Promise<ValidationResult> {
     return {
       isValid: true,
     }
   };
 
-  abstract refresh(values: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
+  abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
 
   abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
 
@@ -410,22 +412,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/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);
-        });
-    }
-}