codify-plugin-lib 1.0.12 → 1.0.14

package/dist/entities/plan.d.ts

@@ -1,11 +1,11 @@
 import { ChangeSet } from './change-set';
 import { PlanResponseData, ResourceConfig } from 'codify-schemas';
-export declare class Plan {
+export declare class Plan<T extends ResourceConfig> {
     id: string;
     changeSet: ChangeSet;
-    resourceConfig: ResourceConfig;
-    constructor(id: string, changeSet: ChangeSet, resourceConfig: ResourceConfig);
-    static create(changeSet: ChangeSet, resourceConfig: ResourceConfig): Plan;
+    resourceConfig: T;
+    constructor(id: string, changeSet: ChangeSet, resourceConfig: T);
+    static create<T extends ResourceConfig>(changeSet: ChangeSet, resourceConfig: T): Plan<T>;
     getResourceType(): string;
     toResponse(): PlanResponseData;
 }

package/dist/entities/plugin.d.ts

@@ -3,7 +3,7 @@ import { ApplyRequestData, PlanRequestData, PlanResponseData, ResourceConfig, Va
 import { Plan } from './plan';
 export declare class Plugin {
     resources: Map<string, Resource<ResourceConfig>>;
-    planStorage: Map<string, Plan>;
+    planStorage: Map<string, Plan<ResourceConfig>>;
     constructor(resources: Map<string, Resource<ResourceConfig>>);
     onInitialize(): Promise<void>;
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;

package/dist/entities/resource.d.ts

@@ -1,18 +1,18 @@
 import { ResourceConfig, ResourceOperation } from 'codify-schemas';
-import { ChangeSet, ParameterChange } from './change-set';
+import { ParameterChange } from './change-set';
 import { Plan } from './plan';
 export declare abstract class Resource<T extends ResourceConfig> {
     private dependencies;
     constructor(dependencies?: Resource<any>[]);
     abstract getTypeId(): string;
     onInitialize(): Promise<void>;
-    plan(desiredConfig: T): Promise<Plan>;
-    apply(plan: Plan): Promise<void>;
+    plan(desiredConfig: T): Promise<Plan<T>>;
+    apply(plan: Plan<T>): Promise<void>;
     abstract validate(config: ResourceConfig): Promise<boolean>;
     abstract getCurrentConfig(): Promise<T | null>;
     abstract calculateOperation(change: ParameterChange): ResourceOperation.MODIFY | ResourceOperation.RECREATE;
-    abstract applyCreate(changeSet: ChangeSet): Promise<void>;
-    abstract applyModify(changeSet: ChangeSet): Promise<void>;
-    abstract applyRecreate(changeSet: ChangeSet): Promise<void>;
-    abstract applyDestroy(changeSet: ChangeSet): Promise<void>;
+    abstract applyCreate(plan: Plan<T>): Promise<void>;
+    abstract applyModify(plan: Plan<T>): Promise<void>;
+    abstract applyRecreate(plan: Plan<T>): Promise<void>;
+    abstract applyDestroy(plan: Plan<T>): Promise<void>;
 }

package/dist/entities/resource.js

@@ -29,12 +29,11 @@ class Resource {
         if (plan.getResourceType() !== this.getTypeId()) {
             throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.getTypeId()} but got: ${plan.getResourceType()}`);
         }
-        const changeSet = plan.changeSet;
         switch (plan.changeSet.operation) {
-            case codify_schemas_1.ResourceOperation.CREATE: return this.applyCreate(changeSet);
-            case codify_schemas_1.ResourceOperation.MODIFY: return this.applyModify(changeSet);
-            case codify_schemas_1.ResourceOperation.RECREATE: return this.applyRecreate(changeSet);
-            case codify_schemas_1.ResourceOperation.DESTROY: return this.applyDestroy(changeSet);
+            case codify_schemas_1.ResourceOperation.CREATE: return this.applyCreate(plan);
+            case codify_schemas_1.ResourceOperation.MODIFY: return this.applyModify(plan);
+            case codify_schemas_1.ResourceOperation.RECREATE: return this.applyRecreate(plan);
+            case codify_schemas_1.ResourceOperation.DESTROY: return this.applyDestroy(plan);
         }
     }
 }

package/package.json

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

package/src/entities/plan.ts

@@ -5,18 +5,18 @@ import {
 } from 'codify-schemas';
 import { randomUUID } from 'crypto';
 
-export class Plan {
+export class Plan<T extends ResourceConfig> {
   id: string;
   changeSet: ChangeSet;
-  resourceConfig: ResourceConfig
+  resourceConfig: T
 
-  constructor(id: string, changeSet: ChangeSet, resourceConfig: ResourceConfig) {
+  constructor(id: string, changeSet: ChangeSet, resourceConfig: T) {
     this.id = id;
     this.changeSet = changeSet;
     this.resourceConfig = resourceConfig;
   }
 
-  static create(changeSet: ChangeSet, resourceConfig: ResourceConfig) {
+  static create<T extends ResourceConfig>(changeSet: ChangeSet, resourceConfig: T): Plan<T> {
     return new Plan(
       randomUUID(),
       changeSet,

package/src/entities/plugin.ts

@@ -10,7 +10,7 @@ import {
 import { Plan } from './plan';
 
 export class Plugin {
-  planStorage: Map<string, Plan>;
+  planStorage: Map<string, Plan<ResourceConfig>>;
 
   constructor(
     public resources: Map<string, Resource<ResourceConfig>>

package/src/entities/resource.test.ts

@@ -7,19 +7,19 @@ import { expect } from 'chai';
 import { Plan } from './plan';
 
 class TestResource extends Resource<TestConfig> {
-  applyCreate(changeSet: ChangeSet): Promise<void> {
+  applyCreate(plan: Plan): Promise<void> {
     return Promise.resolve(undefined);
   }
 
-  applyDestroy(changeSet: ChangeSet): Promise<void> {
+  applyDestroy(plan: Plan): Promise<void> {
     return Promise.resolve(undefined);
   }
 
-  applyModify(changeSet: ChangeSet): Promise<void> {
+  applyModify(plan: Plan): Promise<void> {
     return Promise.resolve(undefined);
   }
 
-  applyRecreate(changeSet: ChangeSet): Promise<void> {
+  applyRecreate(plan: Plan): Promise<void> {
     return Promise.resolve(undefined);
   }
 

package/src/entities/resource.ts

@@ -14,7 +14,7 @@ export abstract class Resource<T extends ResourceConfig> {
 
   // TODO: Add state in later.
   //  Calculate change set from current config -> state -> desired in the future
-  async plan(desiredConfig: T): Promise<Plan> {
+  async plan(desiredConfig: T): Promise<Plan<T>> {
     await this.validate(desiredConfig);
 
     const currentConfig = await this.getCurrentConfig();
@@ -42,17 +42,16 @@ export abstract class Resource<T extends ResourceConfig> {
     );
   }
 
-  async apply(plan: Plan): Promise<void> {
+  async apply(plan: Plan<T>): Promise<void> {
     if (plan.getResourceType() !== this.getTypeId()) {
       throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.getTypeId()} but got: ${plan.getResourceType()}`);
     }
 
-    const changeSet = plan.changeSet;
     switch (plan.changeSet.operation) {
-      case ResourceOperation.CREATE: return this.applyCreate(changeSet);
-      case ResourceOperation.MODIFY: return this.applyModify(changeSet);
-      case ResourceOperation.RECREATE: return this.applyRecreate(changeSet);
-      case ResourceOperation.DESTROY: return this.applyDestroy(changeSet);
+      case ResourceOperation.CREATE: return this.applyCreate(plan);
+      case ResourceOperation.MODIFY: return this.applyModify(plan);
+      case ResourceOperation.RECREATE: return this.applyRecreate(plan);
+      case ResourceOperation.DESTROY: return this.applyDestroy(plan);
     }
   }
 
@@ -62,11 +61,11 @@ export abstract class Resource<T extends ResourceConfig> {
 
   abstract calculateOperation(change: ParameterChange): ResourceOperation.MODIFY | ResourceOperation.RECREATE;
 
-  abstract applyCreate(changeSet: ChangeSet): Promise<void>;
+  abstract applyCreate(plan: Plan<T>): Promise<void>;
 
-  abstract applyModify(changeSet: ChangeSet): Promise<void>;
+  abstract applyModify(plan: Plan<T>): Promise<void>;
 
-  abstract applyRecreate(changeSet: ChangeSet): Promise<void>;
+  abstract applyRecreate(plan: Plan<T>): Promise<void>;
 
-  abstract applyDestroy(changeSet: ChangeSet): Promise<void>;
+  abstract applyDestroy(plan:Plan<T>): Promise<void>;
 }