codify-plugin-lib 1.0.9 → 1.0.11

package/dist/entities/plugin.d.ts

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

package/dist/entities/plugin.js

@@ -29,6 +29,16 @@ class Plugin {
         return plan.toResponse();
     }
     async apply(data) {
+        const { planId } = data;
+        const plan = this.planStorage.get(planId);
+        if (!plan) {
+            throw new Error(`Plan with id: ${planId} was not found`);
+        }
+        const resource = this.resources.get(plan.getResourceType());
+        if (!resource) {
+            throw new Error('Malformed plan with resource that cannot be found');
+        }
+        await resource.apply(plan);
     }
     async crossValidateResources(configs) { }
 }

package/dist/entities/resource.d.ts

@@ -7,7 +7,7 @@ export declare abstract class Resource<T extends ResourceConfig> {
     abstract getTypeId(): string;
     onInitialize(): Promise<void>;
     plan(desiredConfig: T): Promise<Plan>;
-    apply(plan: Plan): Promise<any>;
+    apply(plan: Plan): Promise<void>;
     abstract validate(config: ResourceConfig): Promise<boolean>;
     abstract getCurrentConfig(): Promise<T | null>;
     abstract calculateOperation(change: ParameterChange): ResourceOperation.MODIFY | ResourceOperation.RECREATE;

package/dist/entities/resource.js

@@ -26,25 +26,16 @@ class Resource {
         return plan_1.Plan.create(new change_set_1.ChangeSet(resourceOperation, parameterChangeSet), desiredConfig);
     }
     async apply(plan) {
-        if (plan.getResourceType()) {
-            throw new Error('Internal error: Plan set to wrong resource during apply');
+        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:
-                await this.applyCreate(changeSet);
-                break;
-            case codify_schemas_1.ResourceOperation.MODIFY:
-                await this.applyModify(changeSet);
-                break;
-            case codify_schemas_1.ResourceOperation.RECREATE:
-                await this.applyRecreate(changeSet);
-                break;
-            case codify_schemas_1.ResourceOperation.DESTROY:
-                await this.applyDestroy(changeSet);
-                break;
+            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);
         }
-        return null;
     }
 }
 exports.Resource = Resource;

package/dist/messages/handlers.js

@@ -21,7 +21,10 @@ const SupportedRequests = {
     'apply': {
         requestValidator: codify_schemas_1.ApplyRequestDataSchema,
         responseValidator: codify_schemas_1.ApplyResponseDataSchema,
-        handler: async (plugin, data) => plugin.apply(data)
+        handler: async (plugin, data) => {
+            await plugin.apply(data);
+            return null;
+        }
     }
 };
 class MessageHandler {

package/package.json

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

package/src/entities/plugin.ts

@@ -7,9 +7,10 @@ import {
   ValidateRequestData,
   ValidateResponseData
 } from 'codify-schemas';
+import { Plan } from './plan';
 
 export class Plugin {
-  planStorage: Map<string, any>;
+  planStorage: Map<string, Plan>;
 
   constructor(
     public resources: Map<string, Resource<ResourceConfig>>
@@ -46,6 +47,18 @@ export class Plugin {
   }
 
   async apply(data: ApplyRequestData): Promise<void> {
+    const { planId } = data;
+    const plan = this.planStorage.get(planId);
+    if (!plan) {
+      throw new Error(`Plan with id: ${planId} was not found`);
+    }
+
+    const resource = this.resources.get(plan.getResourceType());
+    if (!resource) {
+      throw new Error('Malformed plan with resource that cannot be found');
+    }
+
+    await resource.apply(plan);
   }
 
   protected async crossValidateResources(configs: ResourceConfig[]): Promise<void> {}

package/src/entities/resource.test.ts

@@ -4,6 +4,7 @@ import { ResourceConfig, ResourceOperation } from 'codify-schemas';
 import { ChangeSet, ParameterChange } from './change-set';
 import { spy } from 'sinon';
 import { expect } from 'chai';
+import { Plan } from './plan';
 
 class TestResource extends Resource<TestConfig> {
   applyCreate(changeSet: ChangeSet): Promise<void> {
@@ -143,4 +144,40 @@ describe('Resource tests', () => {
     expect(result.changeSet.operation).to.eq(ResourceOperation.CREATE);
     expect(result.changeSet.parameterChanges.length).to.eq(3);
   })
+
+  it('chooses the create apply properly', async () => {
+    const resource = new class extends TestResource {
+      getTypeId(): string {
+        return 'resource'
+      }
+    }
+
+    const resourceSpy = spy(resource);
+    const result = await resourceSpy.apply(
+      Plan.create(
+        new ChangeSet(ResourceOperation.CREATE, []),
+        { type: 'resource' }
+      )
+    )
+
+    expect(resourceSpy.applyCreate.calledOnce).to.be.true;
+  })
+
+  it('chooses the destroy apply properly', async () => {
+    const resource = new class extends TestResource {
+      getTypeId(): string {
+        return 'resource'
+      }
+    }
+
+    const resourceSpy = spy(resource);
+    const result = await resourceSpy.apply(
+      Plan.create(
+        new ChangeSet(ResourceOperation.DESTROY, []),
+        { type: 'resource' }
+      )
+    )
+
+    expect(resourceSpy.applyDestroy.calledOnce).to.be.true;
+  })
 })

package/src/entities/resource.ts

@@ -42,20 +42,18 @@ export abstract class Resource<T extends ResourceConfig> {
     );
   }
 
-  async apply(plan: Plan): Promise<any> {
-    if (plan.getResourceType()) {
-      throw new Error('Internal error: Plan set to wrong resource during apply');
+  async apply(plan: Plan): 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: await this.applyCreate(changeSet); break;
-      case ResourceOperation.MODIFY: await this.applyModify(changeSet); break;
-      case ResourceOperation.RECREATE: await this.applyRecreate(changeSet); break;
-      case ResourceOperation.DESTROY: await this.applyDestroy(changeSet); break;
+      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);
     }
-
-    return null;
   }
 
   abstract validate(config: ResourceConfig): Promise<boolean>;

package/src/messages/handlers.ts

@@ -26,8 +26,11 @@ const SupportedRequests: Record<string, { requestValidator: SchemaObject; respon
   },
   'apply': {
     requestValidator: ApplyRequestDataSchema,
-    responseValidator: ApplyResponseDataSchema, // Replace with response validator
-    handler: async (plugin: Plugin, data: any) => plugin.apply(data)
+    responseValidator: ApplyResponseDataSchema,
+    handler: async (plugin: Plugin, data: any) => {
+      await plugin.apply(data);
+      return null;
+    }
   }
 }