codify-plugin-lib 1.0.148 → 1.0.150

package/dist/plugin/plugin.js

@@ -121,12 +121,10 @@ export class Plugin {
             return !controller.parsedSettings.allowMultiple && v > 1;
         });
         if (invalidMultipleConfigs.length > 0) {
-            validationResults.push(...invalidMultipleConfigs.map(([k, v]) => ({
-                resourceType: k,
-                schemaValidationErrors: [],
-                customValidationErrorMessage: `Multiple of resource type: ${k} found in configs. Only allowed 1.`,
-                isValid: false,
-            })));
+            throw new Error(`Multiples of the following configs were found but only 1 is allowed.
+
+[${invalidMultipleConfigs.map(([k]) => k).join(', ')}]
+`);
         }
         await this.crossValidateResources(data.configs);
         return {

package/dist/resource/resource-controller.js

@@ -79,7 +79,7 @@ export class ResourceController {
         await this.applyTransformParameters(state);
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(desired, state, this.parsedSettings.statefulParameters);
-        const { allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
         // Refresh resource parameters. This refreshes the parameters that configure the resource itself
         const currentArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
         // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
@@ -98,7 +98,7 @@ export class ResourceController {
         }
         // Refresh stateful parameters. These parameters have state external to the resource. Each variation of the
         // current parameters (each array element) is passed into the stateful parameter refresh.
-        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentArray);
+        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentArray, allParameters);
         return Plan.calculate({
             desired,
             currentArray: currentArray.map((c, idx) => ({ ...c, ...statefulCurrentParameters[idx] })),
@@ -165,14 +165,14 @@ export class ResourceController {
             };
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(parametersToRefresh, null, this.parsedSettings.statefulParameters);
-        const { allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
         const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
         if (currentParametersArray === null
             || currentParametersArray === undefined
             || currentParametersArray.filter(Boolean).length === 0) {
             return [];
         }
-        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentParametersArray);
+        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentParametersArray, allParameters);
         const resultParametersArray = currentParametersArray
             ?.map((r, idx) => ({ ...r, ...statefulCurrentParameters[idx] }));
         for (const result of resultParametersArray) {
@@ -291,17 +291,17 @@ ${JSON.stringify(refresh, null, 2)}
     }
     // Refresh stateful parameters
     // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
-    async refreshStatefulParameters(statefulParametersConfig, allParameters) {
-        const result = Array.from({ length: allParameters.length }, () => ({}));
+    async refreshStatefulParameters(statefulParametersConfig, currentArray, allParameters) {
+        const result = Array.from({ length: currentArray.length }, () => ({}));
         const sortedEntries = Object.entries(statefulParametersConfig)
             .sort(([key1], [key2]) => this.parsedSettings.statefulParameterOrder.get(key1) - this.parsedSettings.statefulParameterOrder.get(key2));
-        for (const [idx, refreshedParams] of allParameters.entries()) {
+        for (const [idx, refreshedParams] of currentArray.entries()) {
             await Promise.all(sortedEntries.map(async ([key, desiredValue]) => {
                 const statefulParameter = this.parsedSettings.statefulParameters.get(key);
                 if (!statefulParameter) {
                     throw new Error(`Stateful parameter ${key} was not found`);
                 }
-                result[idx][key] = await statefulParameter.refresh(desiredValue ?? null, refreshedParams);
+                result[idx][key] = await statefulParameter.refresh(desiredValue ?? null, { ...allParameters, ...refreshedParams });
             }));
         }
         return result;

package/package.json

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

package/src/plugin/plugin.test.ts

@@ -482,13 +482,12 @@ describe('Plugin tests', () => {
 
     const testPlugin = Plugin.create('testPlugin', [resource as any]);
 
-    const validate1 = await testPlugin.validate({
-      configs: [{ core: { type: 'ssh-config' }, parameters: { propA: 'a' } }, {
-        core: { type: 'ssh-config' },
-        parameters: { propB: 'b' }
-      }]
-    })
-
-    expect(validate1.resourceValidations.every((r) => r.isValid)).to.be.false;
+    await expect(() => testPlugin.validate({
+        configs: [{ core: { type: 'ssh-config' }, parameters: { propA: 'a' } }, {
+          core: { type: 'ssh-config' },
+          parameters: { propB: 'b' }
+        }]
+      })
+    ).rejects.toThrowError();
   })
 });

package/src/plugin/plugin.ts

@@ -178,12 +178,11 @@ export class Plugin {
     });
 
     if (invalidMultipleConfigs.length > 0) {
-      validationResults.push(...invalidMultipleConfigs.map(([k, v]) => ({
-        resourceType: k,
-        schemaValidationErrors: [],
-        customValidationErrorMessage: `Multiple of resource type: ${k} found in configs. Only allowed 1.`,
-        isValid: false,
-      })));
+      throw new Error(
+        `Multiples of the following configs were found but only 1 is allowed.
+
+[${invalidMultipleConfigs.map(([k]) => k).join(', ')}]
+`)
     }
 
     await this.crossValidateResources(data.configs);

package/src/resource/resource-controller.ts

@@ -119,6 +119,7 @@ export class ResourceController<T extends StringIndexedObject> {
     // Parse data from the user supplied config
     const parsedConfig = new ConfigParser(desired, state, this.parsedSettings.statefulParameters)
     const {
+      allParameters,
       allNonStatefulParameters,
       allStatefulParameters,
     } = parsedConfig;
@@ -144,7 +145,7 @@ export class ResourceController<T extends StringIndexedObject> {
 
     // Refresh stateful parameters. These parameters have state external to the resource. Each variation of the
     // current parameters (each array element) is passed into the stateful parameter refresh.
-    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentArray);
+    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentArray, allParameters);
 
     return Plan.calculate({
       desired,
@@ -239,6 +240,7 @@ export class ResourceController<T extends StringIndexedObject> {
     // Parse data from the user supplied config
     const parsedConfig = new ConfigParser(parametersToRefresh, null, this.parsedSettings.statefulParameters)
     const {
+      allParameters,
       allNonStatefulParameters,
       allStatefulParameters,
     } = parsedConfig;
@@ -252,7 +254,7 @@ export class ResourceController<T extends StringIndexedObject> {
       return [];
     }
 
-    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentParametersArray);
+    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentParametersArray, allParameters);
     const resultParametersArray = currentParametersArray
       ?.map((r, idx) => ({ ...r, ...statefulCurrentParameters[idx] }))
 
@@ -403,21 +405,25 @@ ${JSON.stringify(refresh, null, 2)}
 
   // Refresh stateful parameters
   // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
-  private async refreshStatefulParameters(statefulParametersConfig: Partial<T>, allParameters: Array<Partial<T>>): Promise<Array<Partial<T>>> {
-    const result: Array<Partial<T>> = Array.from({ length: allParameters.length }, () => ({}))
+  private async refreshStatefulParameters(
+    statefulParametersConfig: Partial<T>,
+    currentArray: Array<Partial<T>>,
+    allParameters: Partial<T>
+  ): Promise<Array<Partial<T>>> {
+    const result: Array<Partial<T>> = Array.from({ length: currentArray.length }, () => ({}))
     const sortedEntries = Object.entries(statefulParametersConfig)
       .sort(
         ([key1], [key2]) => this.parsedSettings.statefulParameterOrder.get(key1)! - this.parsedSettings.statefulParameterOrder.get(key2)!
       )
 
-    for (const [idx, refreshedParams] of allParameters.entries()) {
+    for (const [idx, refreshedParams] of currentArray.entries()) {
       await Promise.all(sortedEntries.map(async ([key, desiredValue]) => {
         const statefulParameter = this.parsedSettings.statefulParameters.get(key);
         if (!statefulParameter) {
           throw new Error(`Stateful parameter ${key} was not found`);
         }
 
-        (result[idx][key] as T[keyof T] | null) = await statefulParameter.refresh(desiredValue ?? null, refreshedParams)
+        (result[idx][key] as T[keyof T] | null) = await statefulParameter.refresh(desiredValue ?? null, { ...allParameters, ...refreshedParams })
       }))
     }