codify-plugin-lib 1.0.9 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "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;
+    }
   }
 }