codify-plugin-lib 1.0.128 → 1.0.130

package/src/messages/handlers.test.ts

@@ -25,9 +25,11 @@ describe('Message handler tests', () => {
       await handler.onMessage({
         cmd: 'plan',
         data: {
-          desired: {
+          core: {
             type: 'resourceType',
             name: 'name',
+          },
+          desired: {
             prop1: 'A',
             prop2: 'B',
           },
@@ -45,7 +47,6 @@ describe('Message handler tests', () => {
     const handler = new MessageHandler(plugin);
 
     process.send = (message) => {
-      console.log(message);
       expect(message).toMatchObject({
         cmd: 'plan_Response',
         status: MessageStatus.ERROR,
@@ -168,6 +169,9 @@ describe('Message handler tests', () => {
     expect(async () => await handler.onMessage({
       cmd: 'plan',
       data: {
+        core: {
+          type: 'resourceA',
+        },
         desired: {
           type: 'resourceA'
         },
@@ -250,9 +254,11 @@ describe('Message handler tests', () => {
       cmd: 'plan',
       requestId: 'abcdef',
       data: {
-        desired: {
+        core: {
           type: 'type',
           name: 'name',
+        },
+        desired: {
           prop1: 'A',
           prop2: 'B',
         },

package/src/plan/plan.test.ts

@@ -20,13 +20,12 @@ describe('Plan entity tests', () => {
         previousValue: null,
         newValue: 'propBValue'
       }],
-      statefulMode: false,
+      isStateful: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).to.be.null;
 
     expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
@@ -49,11 +48,10 @@ describe('Plan entity tests', () => {
         previousValue: 'propBValue',
         newValue: null,
       }],
-      statefulMode: false,
+      isStateful: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
@@ -78,17 +76,15 @@ describe('Plan entity tests', () => {
         previousValue: 'propBValue',
         newValue: 'propBValue',
       }],
-      statefulMode: false,
+      isStateful: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
 
     expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
@@ -116,13 +112,12 @@ describe('Plan entity tests', () => {
         previousValue: null,
         newValue: 'propAValue',
       }],
-      statefulMode: false,
+      isStateful: false,
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).to.be.null
 
     expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
       propA: 'propAValue',
       propB: 'propBValue',
     })
@@ -134,15 +129,15 @@ describe('Plan entity tests', () => {
 
   it('Returns the original resource names', () => {
     const plan = Plan.calculate<TestConfig>({
-      desiredParameters: { propA: 'propA' },
-      currentParametersArray: [{ propA: 'propA2' }],
-      stateParameters: null,
-      coreParameters: {
+      desired: { propA: 'propA' },
+      currentArray: [{ propA: 'propA2' }],
+      state: null,
+      core: {
         type: 'type',
         name: 'name1'
       },
       settings: new ParsedResourceSettings<TestConfig>({ id: 'type' }),
-      statefulMode: false,
+      isStateful: false,
     });
 
     expect(plan.toResponse()).toMatchObject({
@@ -174,9 +169,12 @@ describe('Plan entity tests', () => {
     }
 
     const controller = new ResourceController(resource);
-    const plan = await controller.plan({
-      propZ: ['20.15'],
-    } as any)
+    const plan = await controller.plan(
+      { type: 'type' },
+      { propZ: ['20.15'], } as any,
+      null,
+      false
+    )
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
@@ -208,9 +206,12 @@ describe('Plan entity tests', () => {
     }
 
     const controller = new ResourceController(resource);
-    const plan = await controller.plan({
-      propZ: ['20.15'],
-    } as any)
+    const plan = await controller.plan(
+      { type: 'type' },
+      { propZ: ['20.15'], } as any,
+      null,
+      false
+    )
 
     expect(plan.changeSet).toMatchObject({
       operation: ResourceOperation.MODIFY,

package/src/plan/plan.ts

@@ -34,13 +34,13 @@ export class Plan<T extends StringIndexedObject> {
    */
   coreParameters: ResourceConfig;
 
-  statefulMode: boolean;
+  isStateful: boolean;
 
-  constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig, statefulMode: boolean) {
+  constructor(id: string, changeSet: ChangeSet<T>, coreParameters: ResourceConfig, isStateful: boolean) {
     this.id = id;
     this.changeSet = changeSet;
-    this.coreParameters = resourceMetadata;
-    this.statefulMode = statefulMode;
+    this.coreParameters = coreParameters;
+    this.isStateful = isStateful;
   }
 
   /**
@@ -51,10 +51,7 @@ export class Plan<T extends StringIndexedObject> {
       return null;
     }
 
-    return {
-      ...this.coreParameters,
-      ...this.changeSet.desiredParameters,
-    }
+    return this.changeSet.desiredParameters;
   }
 
   /**
@@ -65,10 +62,7 @@ export class Plan<T extends StringIndexedObject> {
       return null;
     }
 
-    return {
-      ...this.coreParameters,
-      ...this.changeSet.currentParameters,
-    }
+    return this.changeSet.currentParameters;
   }
 
   get resourceId(): string {
@@ -78,71 +72,71 @@ export class Plan<T extends StringIndexedObject> {
   }
 
   static calculate<T extends StringIndexedObject>(params: {
-    desiredParameters: Partial<T> | null,
-    currentParametersArray: Partial<T>[] | null,
-    stateParameters: Partial<T> | null,
-    coreParameters: ResourceConfig,
+    desired: Partial<T> | null,
+    currentArray: Partial<T>[] | null,
+    state: Partial<T> | null,
+    core: ResourceConfig,
     settings: ParsedResourceSettings<T>,
-    statefulMode: boolean,
+    isStateful: boolean,
   }): Plan<T> {
     const {
-      desiredParameters,
-      currentParametersArray,
-      stateParameters,
-      coreParameters,
+      desired,
+      currentArray,
+      state,
+      core,
       settings,
-      statefulMode
+      isStateful
     } = params
 
-    const currentParameters = Plan.matchCurrentParameters<T>({
-      desiredParameters,
-      currentParametersArray,
-      stateParameters,
+    const current = Plan.matchCurrentParameters<T>({
+      desired,
+      currentArray,
+      state,
       settings,
-      statefulMode
+      isStateful
     });
 
     const filteredCurrentParameters = Plan.filterCurrentParams<T>({
-      desiredParameters,
-      currentParameters,
-      stateParameters,
+      desired,
+      current,
+      state,
       settings,
-      statefulMode
+      isStateful
     });
 
     // Empty
-    if (!filteredCurrentParameters && !desiredParameters) {
+    if (!filteredCurrentParameters && !desired) {
       return new Plan(
         uuidV4(),
         ChangeSet.empty<T>(),
-        coreParameters,
-        statefulMode,
+        core,
+        isStateful,
       )
     }
 
     // CREATE
-    if (!filteredCurrentParameters && desiredParameters) {
+    if (!filteredCurrentParameters && desired) {
       return new Plan(
         uuidV4(),
-        ChangeSet.create(desiredParameters),
-        coreParameters,
-        statefulMode,
+        ChangeSet.create(desired),
+        core,
+        isStateful,
       )
     }
 
     // DESTROY
-    if (filteredCurrentParameters && !desiredParameters) {
+    if (filteredCurrentParameters && !desired) {
       return new Plan(
         uuidV4(),
         ChangeSet.destroy(filteredCurrentParameters),
-        coreParameters,
-        statefulMode,
+        core,
+        isStateful,
       )
     }
 
     // NO-OP, MODIFY or RE-CREATE
     const changeSet = ChangeSet.calculateModification(
-      desiredParameters!,
+      desired!,
       filteredCurrentParameters!,
       settings.parameterSettings,
     );
@@ -150,60 +144,11 @@ export class Plan<T extends StringIndexedObject> {
     return new Plan(
       uuidV4(),
       changeSet,
-      coreParameters,
-      statefulMode,
+      core,
+      isStateful,
     );
   }
 
-  /**
-   * When multiples of the same resource are allowed, this matching function will match a given config with one of the
-   * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
-   * the application name and location to match it to our desired configs name and location.
-   *
-   * @param params
-   * @private
-   */
-  private static matchCurrentParameters<T extends StringIndexedObject>(params: {
-    desiredParameters: Partial<T> | null,
-    currentParametersArray: Partial<T>[] | null,
-    stateParameters: Partial<T> | null,
-    settings: ResourceSettings<T>,
-    statefulMode: boolean,
-  }): Partial<T> | null {
-    const {
-      desiredParameters,
-      currentParametersArray,
-      stateParameters,
-      settings,
-      statefulMode
-    } = params;
-
-    if (!settings.allowMultiple) {
-      return currentParametersArray?.[0] ?? null;
-    }
-
-    if (!currentParametersArray) {
-      return null;
-    }
-
-    if (statefulMode) {
-      return stateParameters
-        ? settings.allowMultiple.matcher(stateParameters, currentParametersArray)
-        : null
-    }
-
-    return settings.allowMultiple.matcher(desiredParameters!, currentParametersArray);
-  }
-
-  /**
-   * The type (id) of the resource
-   *
-   * @return string
-   */
-  getResourceType(): string {
-    return this.coreParameters.type
-  }
-
   //   2. Even if there was (maybe for testing reasons), the plan values should not be adjusted
   static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T> {
     if (!data) {
@@ -222,7 +167,7 @@ export class Plan<T extends StringIndexedObject> {
         type: data.resourceType,
         name: data.resourceName,
       },
-      data.statefulMode
+      data.isStateful
     );
 
    function addDefaultValues(): void {
@@ -275,6 +220,55 @@ export class Plan<T extends StringIndexedObject> {
 
   }
 
+  /**
+   * The type (id) of the resource
+   *
+   * @return string
+   */
+  getResourceType(): string {
+    return this.coreParameters.type
+  }
+
+  /**
+   * When multiples of the same resource are allowed, this matching function will match a given config with one of the
+   * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
+   * the application name and location to match it to our desired configs name and location.
+   *
+   * @param params
+   * @private
+   */
+  private static matchCurrentParameters<T extends StringIndexedObject>(params: {
+    desired: Partial<T> | null,
+    currentArray: Partial<T>[] | null,
+    state: Partial<T> | null,
+    settings: ResourceSettings<T>,
+    isStateful: boolean,
+  }): Partial<T> | null {
+    const {
+      desired,
+      currentArray,
+      state,
+      settings,
+      isStateful
+    } = params;
+
+    if (!settings.allowMultiple) {
+      return currentArray?.[0] ?? null;
+    }
+
+    if (!currentArray) {
+      return null;
+    }
+
+    if (isStateful) {
+      return state
+        ? settings.allowMultiple.matcher(state, currentArray)
+        : null
+    }
+
+    return settings.allowMultiple.matcher(desired!, currentArray);
+  }
+
   /**
    *  Only keep relevant params for the plan. We don't want to change settings that were not already
    *  defined.
@@ -284,18 +278,18 @@ export class Plan<T extends StringIndexedObject> {
    *  or wants to set. If a parameter is not specified then it's not managed by Codify.
    */
   private static filterCurrentParams<T extends StringIndexedObject>(params: {
-    desiredParameters: Partial<T> | null,
-    currentParameters: Partial<T> | null,
-    stateParameters: Partial<T> | null,
+    desired: Partial<T> | null,
+    current: Partial<T> | null,
+    state: Partial<T> | null,
     settings: ResourceSettings<T>,
-    statefulMode: boolean,
+    isStateful: boolean,
   }): Partial<T> | null {
     const {
-      desiredParameters: desired,
-      currentParameters: current,
-      stateParameters: state,
+      desired,
+      current,
+      state,
       settings,
-      statefulMode
+      isStateful
     } = params;
 
     if (!current) {
@@ -309,7 +303,7 @@ export class Plan<T extends StringIndexedObject> {
 
     // For stateful mode, we're done after filtering by the keys of desired + state. Stateless mode
     // requires additional filtering for stateful parameter arrays and objects.
-    if (statefulMode) {
+    if (isStateful) {
       return filteredCurrent;
     }
 
@@ -327,7 +321,7 @@ export class Plan<T extends StringIndexedObject> {
         return null;
       }
 
-      if (statefulMode) {
+      if (isStateful) {
         const keys = new Set([...Object.keys(state ?? {}), ...Object.keys(desired ?? {})]);
         return Object.fromEntries(
           Object.entries(current)
@@ -426,7 +420,7 @@ export class Plan<T extends StringIndexedObject> {
     return {
       planId: this.id,
       operation: this.changeSet.operation,
-      statefulMode: this.statefulMode,
+      isStateful: this.isStateful,
       resourceName: this.coreParameters.name,
       resourceType: this.coreParameters.type,
       parameters: this.changeSet.parameterChanges,

package/src/plugin/plugin.test.ts

@@ -56,7 +56,7 @@ describe('Plugin tests', () => {
       parameters: [
         { name: 'propA', operation: ParameterOperation.ADD, newValue: 'abc', previousValue: null },
       ],
-      statefulMode: false,
+      isStateful: false,
     };
 
     await plugin.apply({ plan });
@@ -77,7 +77,7 @@ describe('Plugin tests', () => {
       parameters: [
         { name: 'propA', operation: ParameterOperation.REMOVE, newValue: null, previousValue: 'abc' },
       ],
-      statefulMode: true,
+      isStateful: true,
     };
 
     await testPlugin.apply({ plan })
@@ -100,7 +100,7 @@ describe('Plugin tests', () => {
       parameters: [
         { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
       ],
-      statefulMode: false,
+      isStateful: false,
     };
 
     await testPlugin.apply({ plan })
@@ -124,7 +124,7 @@ describe('Plugin tests', () => {
       parameters: [
         { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
       ],
-      statefulMode: false,
+      isStateful: false,
     };
 
     await testPlugin.apply({ plan })
@@ -224,7 +224,7 @@ describe('Plugin tests', () => {
       parameters: [
         { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
       ],
-      statefulMode: false,
+      isStateful: false,
     };
 
     await expect(() => testPlugin.apply({ plan }))
@@ -245,9 +245,8 @@ describe('Plugin tests', () => {
 
     const testPlugin = Plugin.create('testPlugin', [resource as any]);
     await testPlugin.plan({
-      desired: {
-        type: 'testResource'
-      },
+      core: { type: 'testResource' },
+      desired: {},
       state: undefined,
       isStateful: false,
     })
@@ -275,7 +274,7 @@ describe('Plugin tests', () => {
       parameters: [
         { name: 'propA', operation: ParameterOperation.ADD, newValue: 'abc', previousValue: null },
       ],
-      statefulMode: false,
+      isStateful: false,
     };
 
     await testPlugin.apply({ plan })

package/src/plugin/plugin.ts

@@ -9,6 +9,7 @@ import {
   PlanRequestData,
   PlanResponseData,
   ResourceConfig,
+  ResourceJson,
   ValidateRequestData,
   ValidateResponseData
 } from 'codify-schemas';
@@ -83,18 +84,20 @@ export class Plugin {
   }
 
   async import(data: ImportRequestData): Promise<ImportResponseData> {
-    if (!this.resourceControllers.has(data.config.type)) {
-      throw new Error(`Cannot get info for resource ${data.config.type}, resource doesn't exist`);
+    const { core, parameters } = data;
+
+    if (!this.resourceControllers.has(core.type)) {
+      throw new Error(`Cannot get info for resource ${core.type}, resource doesn't exist`);
     }
 
     const result = await ptyLocalStorage.run(this.planPty, () =>
       this.resourceControllers
-        .get(data.config.type!)
-        ?.import(data.config)
+        .get(core.type!)
+        ?.import(core, parameters)
     )
 
     return {
-      request: data.config,
+      request: data,
       result: result ?? [],
     }
   }
@@ -102,13 +105,15 @@ export class Plugin {
   async validate(data: ValidateRequestData): Promise<ValidateResponseData> {
     const validationResults = [];
     for (const config of data.configs) {
-      if (!this.resourceControllers.has(config.type)) {
-        throw new Error(`Resource type not found: ${config.type}`);
+      const { core, parameters } = config;
+
+      if (!this.resourceControllers.has(core.type)) {
+        throw new Error(`Resource type not found: ${core.type}`);
       }
 
       const validation = await this.resourceControllers
-        .get(config.type)!
-        .validate(config);
+        .get(core.type)!
+        .validate(core, parameters);
 
       validationResults.push(validation);
     }
@@ -120,16 +125,17 @@ export class Plugin {
   }
 
   async plan(data: PlanRequestData): Promise<PlanResponseData> {
-    const type = data.desired?.type ?? data.state?.type
+    const { type } = data.core
 
-    if (!type || !this.resourceControllers.has(type)) {
+    if (!this.resourceControllers.has(type)) {
       throw new Error(`Resource type not found: ${type}`);
     }
 
     const plan = await ptyLocalStorage.run(this.planPty, async () => this.resourceControllers.get(type)!.plan(
-        data.desired ?? null,
-        data.state ?? null,
-        data.isStateful
+      data.core,
+      data.desired ?? null,
+      data.state ?? null,
+      data.isStateful
     ))
 
     this.planStorage.set(plan.id, plan);
@@ -155,9 +161,10 @@ export class Plugin {
     // Default back desired back to current if it is not defined (for destroys only)
     const validationPlan = await ptyLocalStorage.run(new BackgroundPty(), async () => {
       const result = await resource.plan(
+        plan.coreParameters,
         plan.desiredConfig,
         plan.desiredConfig ?? plan.currentConfig,
-        plan.statefulMode
+        plan.isStateful
       );
 
       await getPty().kill();
@@ -192,5 +199,6 @@ export class Plugin {
     return Plan.fromResponse(planRequest, resource.parsedSettings.defaultValues);
   }
 
-  protected async crossValidateResources(configs: ResourceConfig[]): Promise<void> {}
+  protected async crossValidateResources(resources: ResourceJson[]): Promise<void> {
+  }
 }