codify-plugin-lib 1.0.146 → 1.0.148

package/dist/plugin/plugin.js

@@ -107,6 +107,27 @@ export class Plugin {
                 .validate(core, parameters);
             validationResults.push(validation);
         }
+        // Validate that if allow multiple is false, then only 1 of each resource exists
+        const countMap = data.configs.reduce((map, resource) => {
+            if (!map.has(resource.core.type)) {
+                map.set(resource.core.type, 0);
+            }
+            const count = map.get(resource.core.type);
+            map.set(resource.core.type, count + 1);
+            return map;
+        }, new Map());
+        const invalidMultipleConfigs = [...countMap.entries()].filter(([k, v]) => {
+            const controller = this.resourceControllers.get(k);
+            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,
+            })));
+        }
         await this.crossValidateResources(data.configs);
         return {
             resourceValidations: validationResults

package/dist/resource/parsed-resource-settings.js

@@ -113,10 +113,10 @@ export class ParsedResourceSettings {
                 this.validateParameterEqualsFn(v, k);
             }
         }
-        // if (this.allowMultiple
-        //   && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
-        //   throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`)
-        // }
+        if (Object.entries(this.parameterSettings).some(([k, v]) => v.type === 'stateful'
+            && typeof this.settings.allowMultiple === 'object' && this.settings.allowMultiple?.identifyingParameters?.includes(k))) {
+            throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`);
+        }
         const schema = this.settings.schema;
         if (!this.settings.importAndDestroy && (schema?.oneOf
             && Array.isArray(schema.oneOf)

package/dist/resource/resource-controller.js

@@ -79,13 +79,12 @@ export class ResourceController {
         await this.applyTransformParameters(state);
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(desired, state, this.parsedSettings.statefulParameters);
-        const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        const { 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
         if (currentArray === null
             || currentArray === undefined
-            || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
             || currentArray.length === 0
             || currentArray.filter(Boolean).length === 0) {
             return Plan.calculate({
@@ -97,12 +96,12 @@ export class ResourceController {
                 isStateful,
             });
         }
-        // Refresh stateful parameters. These parameters have state external to the resource. allowMultiple
-        // does not work together with stateful parameters
-        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, allParameters);
+        // 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);
         return Plan.calculate({
             desired,
-            currentArray: [{ ...currentArray[0], ...statefulCurrentParameters }],
+            currentArray: currentArray.map((c, idx) => ({ ...c, ...statefulCurrentParameters[idx] })),
             state,
             core,
             settings: this.parsedSettings,
@@ -170,17 +169,17 @@ export class ResourceController {
         const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
         if (currentParametersArray === null
             || currentParametersArray === undefined
-            || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
             || currentParametersArray.filter(Boolean).length === 0) {
-            return currentParametersArray
-                ?.map((r) => ({ core, parameters: r }))
-                ?? null;
+            return [];
+        }
+        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentParametersArray);
+        const resultParametersArray = currentParametersArray
+            ?.map((r, idx) => ({ ...r, ...statefulCurrentParameters[idx] }));
+        for (const result of resultParametersArray) {
+            await this.applyTransformParameters(result, true);
+            this.removeDefaultValues(result, parameters);
         }
-        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, parametersToRefresh);
-        const resultParameters = { ...currentParametersArray[0], ...statefulCurrentParameters };
-        await this.applyTransformParameters(resultParameters, true);
-        this.removeDefaultValues(resultParameters, parameters);
-        return [{ core, parameters: resultParameters }];
+        return resultParametersArray?.map((r) => ({ core, parameters: r }));
     }
     async applyCreate(plan) {
         await this.resource.create(plan);
@@ -293,16 +292,18 @@ ${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 = {};
+        const result = Array.from({ length: allParameters.length }, () => ({}));
         const sortedEntries = Object.entries(statefulParametersConfig)
             .sort(([key1], [key2]) => this.parsedSettings.statefulParameterOrder.get(key1) - this.parsedSettings.statefulParameterOrder.get(key2));
-        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[key] = await statefulParameter.refresh(desiredValue ?? null, allParameters);
-        }));
+        for (const [idx, refreshedParams] of allParameters.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);
+            }));
+        }
         return result;
     }
     validatePlanInputs(core, desired, current, isStateful) {

package/package.json

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

package/src/plugin/plugin.test.ts

@@ -448,4 +448,47 @@ describe('Plugin tests', () => {
 
     console.log(match)
   })
+
+  it('Validates that a config correctly allows multiple of a config when allowMultiple is true', async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'ssh-config',
+          allowMultiple: true
+        }
+      }
+    })
+
+    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.true;
+  })
+
+  it('Validates that a config correctly dis-allows multiple of a config when allowMultiple is false', async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'ssh-config',
+        }
+      }
+    })
+
+    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;
+  })
 });

package/src/plugin/plugin.ts

@@ -145,7 +145,7 @@ export class Plugin {
   }
 
   async validate(data: ValidateRequestData): Promise<ValidateResponseData> {
-    const validationResults = [];
+    const validationResults: ValidateResponseData['resourceValidations'] = [];
     for (const config of data.configs) {
       const { core, parameters } = config;
 
@@ -160,6 +160,32 @@ export class Plugin {
       validationResults.push(validation);
     }
 
+    // Validate that if allow multiple is false, then only 1 of each resource exists
+    const countMap = data.configs.reduce((map, resource) => {
+      if (!map.has(resource.core.type)) {
+        map.set(resource.core.type, 0);
+      }
+
+      const count = map.get(resource.core.type)!;
+      map.set(resource.core.type, count + 1)
+
+      return map;
+    }, new Map<string, number>())
+
+    const invalidMultipleConfigs = [...countMap.entries()].filter(([k, v]) => {
+      const controller = this.resourceControllers.get(k)!;
+      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,
+      })));
+    }
+
     await this.crossValidateResources(data.configs);
     return {
       resourceValidations: validationResults

package/src/resource/parsed-resource-settings.ts

@@ -188,10 +188,11 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       }
     }
 
-    // if (this.allowMultiple
-    //   && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
-    //   throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`)
-    // }
+    if (Object.entries(this.parameterSettings).some(([k, v]) =>
+      v.type === 'stateful'
+      && typeof this.settings.allowMultiple === 'object' && this.settings.allowMultiple?.identifyingParameters?.includes(k))) {
+      throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`)
+    }
 
     const schema = this.settings.schema as JSONSchemaType<any>;
     if (!this.settings.importAndDestroy && (schema?.oneOf

package/src/resource/resource-controller.ts

@@ -119,7 +119,6 @@ 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;
@@ -130,7 +129,6 @@ export class ResourceController<T extends StringIndexedObject> {
     // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
     if (currentArray === null
       || currentArray === undefined
-      || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
       || currentArray.length === 0
       || currentArray.filter(Boolean).length === 0
     ) {
@@ -144,13 +142,13 @@ export class ResourceController<T extends StringIndexedObject> {
       });
     }
 
-    // Refresh stateful parameters. These parameters have state external to the resource. allowMultiple
-    // does not work together with stateful parameters
-    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, allParameters);
+    // 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);
 
     return Plan.calculate({
       desired,
-      currentArray: [{ ...currentArray[0], ...statefulCurrentParameters }] as Partial<T>[],
+      currentArray: currentArray.map((c, idx) => ({ ...c, ...statefulCurrentParameters[idx] })),
       state,
       core,
       settings: this.parsedSettings,
@@ -249,21 +247,21 @@ export class ResourceController<T extends StringIndexedObject> {
 
     if (currentParametersArray === null
       || currentParametersArray === undefined
-      || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
       || currentParametersArray.filter(Boolean).length === 0
     ) {
-      return currentParametersArray
-          ?.map((r) => ({ core, parameters: r }))
-        ?? null;
+      return [];
     }
 
-    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, parametersToRefresh);
-    const resultParameters = { ...currentParametersArray[0], ...statefulCurrentParameters };
+    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentParametersArray);
+    const resultParametersArray = currentParametersArray
+      ?.map((r, idx) => ({ ...r, ...statefulCurrentParameters[idx] }))
 
-    await this.applyTransformParameters(resultParameters, true);
-    this.removeDefaultValues(resultParameters, parameters)
+    for (const result of resultParametersArray) {
+      await this.applyTransformParameters(result, true);
+      this.removeDefaultValues(result, parameters);
+    }
 
-    return [{ core, parameters: resultParameters }];
+    return resultParametersArray?.map((r) => ({ core, parameters: r }))
   }
 
   private async applyCreate(plan: Plan<T>): Promise<void> {
@@ -405,21 +403,23 @@ ${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: Partial<T>): Promise<Partial<T>> {
-    const result: Partial<T> = {}
+  private async refreshStatefulParameters(statefulParametersConfig: Partial<T>, allParameters: Array<Partial<T>>): Promise<Array<Partial<T>>> {
+    const result: Array<Partial<T>> = Array.from({ length: allParameters.length }, () => ({}))
     const sortedEntries = Object.entries(statefulParametersConfig)
       .sort(
         ([key1], [key2]) => this.parsedSettings.statefulParameterOrder.get(key1)! - this.parsedSettings.statefulParameterOrder.get(key2)!
       )
 
-    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`);
-      }
+    for (const [idx, refreshedParams] of allParameters.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 as Record<string, unknown>)[key] = await statefulParameter.refresh(desiredValue ?? null, allParameters)
-    }))
+        (result[idx][key] as T[keyof T] | null) = await statefulParameter.refresh(desiredValue ?? null, refreshedParams)
+      }))
+    }
 
     return result;
   }