codify-plugin-lib 1.0.129 → 1.0.130

package/src/plan/plan.test.ts

@@ -26,7 +26,6 @@ describe('Plan entity tests', () => {
     expect(plan.currentConfig).to.be.null;
 
     expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
@@ -53,7 +52,6 @@ describe('Plan entity tests', () => {
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
@@ -82,13 +80,11 @@ describe('Plan entity tests', () => {
     }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
 
     expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
       propA: 'defaultA',
       propB: 'propBValue',
     })
@@ -122,7 +118,6 @@ describe('Plan entity tests', () => {
     expect(plan.currentConfig).to.be.null
 
     expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
       propA: 'propAValue',
       propB: 'propBValue',
     })
@@ -134,10 +129,10 @@ 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'
       },
@@ -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

@@ -36,10 +36,10 @@ export class Plan<T extends StringIndexedObject> {
 
   isStateful: boolean;
 
-  constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig, isStateful: boolean) {
+  constructor(id: string, changeSet: ChangeSet<T>, coreParameters: ResourceConfig, isStateful: boolean) {
     this.id = id;
     this.changeSet = changeSet;
-    this.coreParameters = resourceMetadata;
+    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>,
     isStateful: boolean,
   }): Plan<T> {
     const {
-      desiredParameters,
-      currentParametersArray,
-      stateParameters,
-      coreParameters,
+      desired,
+      currentArray,
+      state,
+      core,
       settings,
       isStateful
     } = params
 
-    const currentParameters = Plan.matchCurrentParameters<T>({
-      desiredParameters,
-      currentParametersArray,
-      stateParameters,
+    const current = Plan.matchCurrentParameters<T>({
+      desired,
+      currentArray,
+      state,
       settings,
       isStateful
     });
 
     const filteredCurrentParameters = Plan.filterCurrentParams<T>({
-      desiredParameters,
-      currentParameters,
-      stateParameters,
+      desired,
+      current,
+      state,
       settings,
       isStateful
     });
 
     // Empty
-    if (!filteredCurrentParameters && !desiredParameters) {
+    if (!filteredCurrentParameters && !desired) {
       return new Plan(
         uuidV4(),
         ChangeSet.empty<T>(),
-        coreParameters,
+        core,
         isStateful,
       )
     }
 
     // CREATE
-    if (!filteredCurrentParameters && desiredParameters) {
+    if (!filteredCurrentParameters && desired) {
       return new Plan(
         uuidV4(),
-        ChangeSet.create(desiredParameters),
-        coreParameters,
+        ChangeSet.create(desired),
+        core,
         isStateful,
       )
     }
 
     // DESTROY
-    if (filteredCurrentParameters && !desiredParameters) {
+    if (filteredCurrentParameters && !desired) {
       return new Plan(
         uuidV4(),
         ChangeSet.destroy(filteredCurrentParameters),
-        coreParameters,
+        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,
+      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>,
-    isStateful: boolean,
-  }): Partial<T> | null {
-    const {
-      desiredParameters,
-      currentParametersArray,
-      stateParameters,
-      settings,
-      isStateful
-    } = params;
-
-    if (!settings.allowMultiple) {
-      return currentParametersArray?.[0] ?? null;
-    }
-
-    if (!currentParametersArray) {
-      return null;
-    }
-
-    if (isStateful) {
-      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) {
@@ -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,16 +278,16 @@ 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>,
     isStateful: boolean,
   }): Partial<T> | null {
     const {
-      desiredParameters: desired,
-      currentParameters: current,
-      stateParameters: state,
+      desired,
+      current,
+      state,
       settings,
       isStateful
     } = params;

package/src/plugin/plugin.test.ts

@@ -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,
     })

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,6 +161,7 @@ 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.isStateful
@@ -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> {
+  }
 }

package/src/resource/config-parser.ts

@@ -1,16 +1,15 @@
-import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { StringIndexedObject } from 'codify-schemas';
 
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
-import { splitUserConfig } from '../utils/utils.js';
 
 export class ConfigParser<T extends StringIndexedObject> {
-  private readonly desiredConfig: Partial<T> & ResourceConfig | null;
-  private readonly stateConfig: Partial<T> & ResourceConfig | null;
+  private readonly desiredConfig: Partial<T> | null;
+  private readonly stateConfig: Partial<T> | null;
   private statefulParametersMap: Map<keyof T, StatefulParameterController<T, T[keyof T]>>;
 
   constructor(
-    desiredConfig: Partial<T> & ResourceConfig | null,
-    stateConfig: Partial<T> & ResourceConfig | null,
+    desiredConfig: Partial<T> | null,
+    stateConfig: Partial<T> | null,
     statefulParameters: Map<keyof T, StatefulParameterController<T, T[keyof T]>>,
   ) {
     this.desiredConfig = desiredConfig;
@@ -18,42 +17,8 @@ export class ConfigParser<T extends StringIndexedObject> {
     this.statefulParametersMap = statefulParameters;
   }
 
-  get coreParameters(): ResourceConfig {
-    const desiredCoreParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).coreParameters : undefined;
-    const currentCoreParameters = this.stateConfig ? splitUserConfig(this.stateConfig).coreParameters : undefined;
-
-    if (!desiredCoreParameters && !currentCoreParameters) {
-      throw new Error(`Unable to parse resource core parameters from:
-       
- Desired: ${JSON.stringify(this.desiredConfig, null, 2)}
-  
- Current: ${JSON.stringify(this.stateConfig, null, 2)}`)
-    }
-
-    return desiredCoreParameters ?? currentCoreParameters!;
-  }
-
-  get desiredParameters(): Partial<T> | null {
-    if (!this.desiredConfig) {
-      return null;
-    }
-
-    const { parameters } = splitUserConfig(this.desiredConfig);
-    return parameters;
-  }
-
-  get stateParameters(): Partial<T> | null {
-    if (!this.stateConfig) {
-      return null;
-    }
-
-    const { parameters } = splitUserConfig(this.stateConfig);
-    return parameters;
-  }
-
-
   get allParameters(): Partial<T> {
-    return { ...this.desiredParameters, ...this.stateParameters } as Partial<T>;
+    return { ...this.desiredConfig, ...this.stateConfig } as Partial<T>;
   }
 
   get allNonStatefulParameters(): Partial<T> {

package/src/resource/resource-controller-stateful-mode.test.ts

@@ -19,9 +19,9 @@ describe('Resource tests for stateful plans', () => {
 
     const controller = new ResourceController(resource);
     const plan = await controller.plan(
+      { type: 'type' },
       null,
       {
-        type: 'type',
         propA: 'propA',
         propB: 10,
         propC: 'propC',
@@ -67,8 +67,8 @@ describe('Resource tests for stateful plans', () => {
 
     const controller = new ResourceController(resource);
     const plan = await controller.plan(
+      { type: 'resource' },
       {
-        type: 'resource',
         propA: 'propA',
         propB: 10,
         propC: 'propC',
@@ -119,6 +119,7 @@ describe('Resource tests for stateful plans', () => {
 
     const controller = new ResourceController(resource)
     const plan = await controller.plan(
+      { type: 'type' },
       {
         type: 'type',
         propA: 'propA',
@@ -191,15 +192,14 @@ describe('Resource tests for stateful plans', () => {
 
     const controller = new ResourceController(resource);
     const plan = await controller.plan(
+      { type: 'type' },
       {
-        type: 'type',
         propA: 'propA',
         propB: 10,
         propC: 'propC',
         propD: 'propD'
       },
       {
-        type: 'type',
         propA: 'propA',
         propC: 'propC'
       },