codify-plugin-lib 1.0.75 → 1.0.77

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

@@ -0,0 +1,179 @@
+import { StringIndexedObject } from 'codify-schemas';
+
+import { areArraysEqual } from '../utils/utils.js';
+import {
+  ArrayParameterSetting,
+  ParameterEqualsDefaults,
+  ParameterSetting,
+  ParameterSettingType,
+  ResourceSettings,
+  StatefulParameterSetting
+} from './resource-settings.js';
+import { StatefulParameter as StatefulParameterImpl } from './stateful-parameter.js'
+
+export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
+  private cache = new Map<string, unknown>();
+  id!: string;
+  schema?: unknown;
+  allowMultiple?: { matcher: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>; } | undefined;
+  removeStatefulParametersBeforeDestroy?: boolean | undefined;
+  dependencies?: string[] | undefined;
+  inputTransformation?: ((desired: Partial<T>) => unknown) | undefined;
+  private settings: ResourceSettings<T>;
+
+  constructor(settings: ResourceSettings<T>) {
+    this.settings = settings;
+    this.id = settings.id;
+    this.schema = settings.schema;
+    this.allowMultiple = settings.allowMultiple;
+    this.removeStatefulParametersBeforeDestroy = settings.removeStatefulParametersBeforeDestroy;
+    this.dependencies = settings.dependencies;
+    this.inputTransformation = settings.inputTransformation;
+
+    this.validateSettings();
+  }
+
+  get typeId(): string {
+    return this.id;
+  }
+
+  get statefulParameters(): Map<keyof T, StatefulParameterImpl<T, T[keyof T]>> {
+    return this.getFromCacheOrCreate('statefulParameters', () => {
+
+      const statefulParameters = Object.entries(this.settings.parameterSettings ?? {})
+        .filter(([, p]) => p?.type === 'stateful')
+        .map(([k, v]) => [k, (v as StatefulParameterSetting).definition] as const)
+
+      return new Map(statefulParameters) as Map<keyof T, StatefulParameterImpl<T, T[keyof T]>>;
+    })
+  }
+
+  get parameterSettings(): Record<keyof T, ParameterSetting> {
+    return this.getFromCacheOrCreate('parameterSetting', () => {
+
+      const settings = Object.entries(this.settings.parameterSettings ?? {})
+        .map(([k, v]) => [k, v!] as const)
+        .map(([k, v]) => {
+          v.isEqual = this.resolveEqualsFn(v, k);
+
+          return [k, v];
+        })
+
+      return Object.fromEntries(settings);
+    });
+  }
+
+  get defaultValues(): Partial<Record<keyof T, unknown>> {
+    return this.getFromCacheOrCreate('defaultValues', () => {
+
+      if (!this.settings.parameterSettings) {
+        return {};
+      }
+
+      const defaultValues = Object.fromEntries(
+        Object.entries(this.settings.parameterSettings)
+          .filter(([, v]) => v!.default !== undefined)
+          .map(([k, v]) => [k, v!.default] as const)
+      )
+
+      const statefulParameterDefaultValues = Object.fromEntries(
+        Object.entries(this.settings.parameterSettings)
+          .filter(([, v]) => v?.type === 'stateful')
+          .filter(([, v]) => (v as StatefulParameterSetting).definition.getSettings().default !== undefined)
+          .map(([k, v]) => [k, (v as StatefulParameterSetting).definition.getSettings().default] as const)
+      )
+
+      return { ...defaultValues, ...statefulParameterDefaultValues } as Partial<Record<keyof T, unknown>>;
+    });
+  }
+
+  get inputTransformations(): Partial<Record<keyof T, (a: unknown) => unknown>> {
+    return this.getFromCacheOrCreate('inputTransformations', () => {
+      if (!this.settings.parameterSettings) {
+        return {};
+      }
+
+      return Object.fromEntries(
+        Object.entries(this.settings.parameterSettings)
+          .filter(([, v]) => v!.inputTransformation !== undefined)
+          .map(([k, v]) => [k, v!.inputTransformation!] as const)
+      ) as Record<keyof T, (a: unknown) => unknown>;
+    });
+  }
+
+  get statefulParameterOrder(): Map<keyof T, number> {
+    return this.getFromCacheOrCreate('stateParameterOrder', () => {
+
+      const entries = Object.entries(this.settings.parameterSettings ?? {})
+        .filter(([, v]) => v?.type === 'stateful')
+        .map(([k, v]) => [k, v as StatefulParameterSetting] as const)
+
+      const orderedEntries = entries.filter(([, v]) => v.order !== undefined)
+      const unorderedEntries = entries.filter(([, v]) => v.order === undefined)
+
+      orderedEntries.sort((a, b) => a[1].order! - b[1].order!);
+
+      const resultArray = [
+        ...orderedEntries.map(([k]) => k),
+        ...unorderedEntries.map(([k]) => k)
+      ]
+
+      return new Map(resultArray.map((key, idx) => [key, idx]));
+    });
+  }
+
+  private validateSettings(): void {
+    // validate parameter settings
+    if (this.settings.parameterSettings) {
+      for (const [k, v] of Object.entries(this.settings.parameterSettings)) {
+        if (!v) {
+          throw new Error(`Resource: ${this.id}. Parameter setting ${k} was left undefined`);
+        }
+
+        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`)
+    }
+  }
+
+  private validateParameterEqualsFn(parameter: ParameterSetting, key: string): void {
+    if (parameter.type === 'stateful') {
+      const nestedSettings = (parameter as StatefulParameterSetting).definition.getSettings();
+
+      if (nestedSettings.type === 'stateful') {
+        throw new Error(`Nested stateful parameters are not allowed for ${key}`);
+      }
+
+      this.validateParameterEqualsFn(nestedSettings, key);
+    }
+
+    // The rest of the types have defaults set already
+  }
+
+  private resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
+    if (parameter.type === 'array') {
+      return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
+    }
+
+    if (parameter.type === 'stateful') {
+      return this.resolveEqualsFn((parameter as StatefulParameterSetting).definition.getSettings(), key)
+    }
+
+    return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
+  }
+
+  private getFromCacheOrCreate<T2>(key: string, create: () => T2): T2 {
+    if (this.cache.has(key)) {
+      return this.cache.get(key) as T2
+    }
+
+    const result = create();
+
+    this.cache.set(key, result)
+    return result;
+  }
+}

package/src/{entities/resource-stateful-mode.test.ts → resource/resource-controller-stateful-mode.test.ts}

@@ -1,17 +1,13 @@
 import { describe, expect, it } from 'vitest';
-import { TestConfig, TestResource } from './resource.test.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { TestParameter } from './resource-parameters.test.js';
-import { StatefulParameter } from './stateful-parameter.js';
+import { TestConfig, TestResource, TestStatefulParameter } from '../utils/test-utils.test.js';
+import { ResourceSettings } from './resource-settings.js';
+import { ResourceController } from './resource-controller.js';
 
 
 describe('Resource tests for stateful plans', () => {
   it('Supports delete operations ', async () => {
     const resource = new class extends TestResource {
-      constructor() {
-        super({ type: 'resource' });
-      }
-
       async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propADifferent',
@@ -21,10 +17,11 @@ describe('Resource tests for stateful plans', () => {
       }
     }
 
-    const plan = await resource.plan(
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan(
       null,
       {
-        type: 'resource',
+        type: 'type',
         propA: 'propA',
         propB: 10,
         propC: 'propC',
@@ -41,6 +38,12 @@ describe('Resource tests for stateful plans', () => {
             newValue: null,
             operation: ParameterOperation.REMOVE
           },
+          {
+            name: 'propB',
+            previousValue: null,
+            newValue: null,
+            operation: ParameterOperation.REMOVE
+          },
           {
             name: "propC",
             previousValue: "propCDifferent",
@@ -49,24 +52,21 @@ describe('Resource tests for stateful plans', () => {
           },
         ]
       },
-      resourceMetadata: {
-        type: 'resource'
+      coreParameters: {
+        type: 'type'
       }
     })
   })
 
   it('Supports create operations', async () => {
     const resource = new class extends TestResource {
-      constructor() {
-        super({ type: 'resource' });
-      }
-
       async refresh(): Promise<Partial<TestConfig> | null> {
         return null;
       }
     }
 
-    const plan = await resource.plan(
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan(
       {
         type: 'resource',
         propA: 'propA',
@@ -101,7 +101,7 @@ describe('Resource tests for stateful plans', () => {
           },
         ]
       },
-      resourceMetadata: {
+      coreParameters: {
         type: 'resource'
       }
     })
@@ -109,28 +109,24 @@ describe('Resource tests for stateful plans', () => {
 
   it('Supports re-create operations', async () => {
     const resource = new class extends TestResource {
-      constructor() {
-        super({ type: 'resource' });
-      }
-
       async refresh(): Promise<Partial<TestConfig> | null> {
         return {
           propA: 'propA',
           propC: 'propC',
-          propB: undefined
         };
       }
     }
 
-    const plan = await resource.plan(
+    const controller = new ResourceController(resource)
+    const plan = await controller.plan(
       {
-        type: 'resource',
+        type: 'type',
         propA: 'propA',
         propB: 10,
         propC: 'propC',
       },
       {
-        type: 'resource',
+        type: 'type',
         propA: 'propA',
         propC: 'propC'
       },
@@ -161,27 +157,27 @@ describe('Resource tests for stateful plans', () => {
           },
         ])
       },
-      resourceMetadata: {
-        type: 'resource'
+      coreParameters: {
+        type: 'type'
       }
     })
   })
 
   it('Supports stateful parameters', async () => {
-    const statefulParameter = new class extends TestParameter {
+    const statefulParameter = new class extends TestStatefulParameter {
       async refresh(): Promise<string | null> {
         return null;
       }
     }
 
     const resource = new class extends TestResource {
-      constructor() {
-        super({
-          type: 'resource',
-          parameterOptions: {
-            propD: { statefulParameter: statefulParameter as StatefulParameter<TestConfig, string> },
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propD: { type: 'stateful', definition: statefulParameter },
           }
-        });
+        };
       }
 
       async refresh(): Promise<Partial<TestConfig> | null> {
@@ -193,16 +189,17 @@ describe('Resource tests for stateful plans', () => {
       }
     }
 
-    const plan = await resource.plan(
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan(
       {
-        type: 'resource',
+        type: 'type',
         propA: 'propA',
         propB: 10,
         propC: 'propC',
         propD: 'propD'
       },
       {
-        type: 'resource',
+        type: 'type',
         propA: 'propA',
         propC: 'propC'
       },
@@ -239,8 +236,8 @@ describe('Resource tests for stateful plans', () => {
           },
         ])
       },
-      resourceMetadata: {
-        type: 'resource'
+      coreParameters: {
+        type: 'type'
       }
     })
   })