codify-plugin-lib 1.0.66 → 1.0.68

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

@@ -1,3 +1,5 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
 export interface ParameterOptions {
     modifyOnChange?: boolean;
     isEqual?: (desired: any, current: any) => boolean;
@@ -9,3 +11,15 @@ export interface PlanOptions<T> {
     statefulMode: boolean;
     parameterOptions?: Record<keyof T, ParameterOptions>;
 }
+export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: T;
+    currentConfig: null;
+}
+export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: null;
+    currentConfig: T;
+}
+export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: T;
+    currentConfig: T;
+}

package/dist/entities/resource.d.ts

@@ -3,7 +3,7 @@ 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 { ParameterOptions } from './plan-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';
@@ -36,8 +36,8 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     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>;
-    applyModify(pc: ParameterChange<T>, plan: Plan<T>): Promise<void>;
-    abstract applyDestroy(plan: Plan<T>): Promise<void>;
+    abstract refresh(values: Map<keyof T, T[keyof 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/package.json

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

package/src/entities/plan-types.ts

@@ -1,3 +1,6 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
+
 /**
  * Customize properties for specific parameters. This will alter the way the library process changes to the parameter.
  */
@@ -24,3 +27,18 @@ export interface PlanOptions<T> {
   statefulMode: boolean;
   parameterOptions?: Record<keyof T, ParameterOptions>;
 }
+
+export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
+  desiredConfig: T;
+  currentConfig: null;
+}
+
+export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
+  desiredConfig: null;
+  currentConfig: T;
+}
+
+export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
+  desiredConfig: T;
+  currentConfig: T;
+}

package/src/entities/resource.test.ts

@@ -6,6 +6,8 @@ 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';
+import { ParameterChange } from './change-set.js';
 
 export interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -221,12 +223,15 @@ describe('Resource tests', () => {
       async refresh(): Promise<string | null> {
         return null;
       }
+
       applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
         throw new Error('Method not implemented.');
       }
+
       applyModify(newValue: string, previousValue: string, allowDeletes: boolean, plan: Plan<TestConfig>): Promise<void> {
         throw new Error('Method not implemented.');
       }
+
       applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
         throw new Error('Method not implemented.');
       }
@@ -252,12 +257,15 @@ describe('Resource tests', () => {
       async refresh(): Promise<string | null> {
         return null;
       }
+
       applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
         throw new Error('Method not implemented.');
       }
+
       applyModify(newValue: string, previousValue: string, allowDeletes: boolean, plan: Plan<TestConfig>): Promise<void> {
         throw new Error('Method not implemented.');
       }
+
       applyRemove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
         throw new Error('Method not implemented.');
       }
@@ -300,7 +308,7 @@ describe('Resource tests', () => {
       }
     }
 
-    const plan = await resource.plan({ type: 'resource'})
+    const plan = await resource.plan({ type: 'resource' })
     expect(plan.currentConfig?.propA).to.eq('propAAfter');
     expect(plan.desiredConfig?.propA).to.eq('propADefault');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
@@ -326,7 +334,7 @@ describe('Resource tests', () => {
       }
     }
 
-    const plan = await resource.plan({ type: 'resource'})
+    const plan = await resource.plan({ type: 'resource' })
     expect(plan.currentConfig?.propE).to.eq('propEDefault');
     expect(plan.desiredConfig?.propE).to.eq('propEDefault');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
@@ -348,7 +356,7 @@ describe('Resource tests', () => {
       }
     }
 
-    const plan = await resource.plan({ type: 'resource'})
+    const plan = await resource.plan({ type: 'resource' })
     expect(plan.currentConfig).to.be.null
     expect(plan.desiredConfig!.propE).to.eq('propEDefault');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
@@ -376,7 +384,7 @@ describe('Resource tests', () => {
       }
     }
 
-    const plan = await resource.plan({ type: 'resource', propA: 'propA'})
+    const plan = await resource.plan({ type: 'resource', propA: 'propA' })
     expect(plan.currentConfig?.propA).to.eq('propAAfter');
     expect(plan.desiredConfig?.propA).to.eq('propA');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
@@ -398,4 +406,29 @@ describe('Resource tests', () => {
       propA: 'propADefault',
     })
   })
+
+  it('Has the correct typing for applys', () => {
+    const resource = new class extends Resource<TestConfig> {
+      constructor() {
+        super({ type: 'type' });
+      }
+
+      async refresh(values: Map<keyof TestConfig, unknown>): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+
+      async applyCreate(plan: CreatePlan<TestConfig>): Promise<void> {
+        plan.desiredConfig.propA
+      }
+
+      async applyDestroy(plan: DestroyPlan<TestConfig>): Promise<void> {
+        plan.currentConfig.propB
+      }
+
+      async applyModify(pc: ParameterChange<TestConfig>, plan: ModifyPlan<TestConfig>): Promise<void> {
+        plan.desiredConfig.propA
+        plan.currentConfig.propB
+      }
+    }
+  })
 });

package/src/entities/resource.ts

@@ -4,7 +4,7 @@ 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 { ParameterOptions, PlanOptions } from './plan-types.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';
@@ -147,7 +147,7 @@ export abstract class Resource<T extends StringIndexedObject> {
   }
 
   private async _applyCreate(plan: Plan<T>): Promise<void> {
-    await this.applyCreate(plan);
+    await this.applyCreate(plan as CreatePlan<T>);
 
     const statefulParameterChanges = plan.changeSet.parameterChanges
       .filter((pc: ParameterChange<T>) => this.statefulParameters.has(pc.name))
@@ -170,7 +170,7 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     for (const pc of statelessParameterChanges) {
       // TODO: When stateful mode is added in the future. Dynamically choose if deletes are allowed
-      await this.applyModify(pc, plan);
+      await this.applyModify(pc, plan as ModifyPlan<T>);
     }
 
     const statefulParameterChanges = parameterChanges
@@ -212,7 +212,7 @@ export abstract class Resource<T extends StringIndexedObject> {
       }
     }
 
-    await this.applyDestroy(plan);
+    await this.applyDestroy(plan as DestroyPlan<T>);
   }
 
   private validateRefreshResults(refresh: Partial<T> | null, desiredMap: Map<keyof T, T[keyof T]>) {
@@ -346,13 +346,13 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   };
 
-  abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
+  abstract refresh(values: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
 
-  abstract applyCreate(plan: Plan<T>): Promise<void>;
+  abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
 
-  async applyModify(pc: ParameterChange<T>, plan: Plan<T>): Promise<void> {};
+  async applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void> {};
 
-  abstract applyDestroy(plan: Plan<T>): Promise<void>;
+  abstract applyDestroy(plan: DestroyPlan<T>): Promise<void>;
 }
 
 class ConfigParser<T extends StringIndexedObject> {