codify-plugin-lib 1.0.76 → 1.0.77

package/src/resource/config-parser.ts

@@ -0,0 +1,77 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+
+import { splitUserConfig } from '../utils/utils.js';
+import { StatefulParameter } from './stateful-parameter.js';
+
+export class ConfigParser<T extends StringIndexedObject> {
+  private readonly desiredConfig: Partial<T> & ResourceConfig | null;
+  private readonly stateConfig: Partial<T> & ResourceConfig | null;
+  private statefulParametersMap: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+
+  constructor(
+    desiredConfig: Partial<T> & ResourceConfig | null,
+    stateConfig: Partial<T> & ResourceConfig | null,
+    statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>,
+  ) {
+    this.desiredConfig = desiredConfig;
+    this.stateConfig = stateConfig
+    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>;
+  }
+
+  get allNonStatefulParameters(): Partial<T> {
+    const {
+      allParameters,
+      statefulParametersMap,
+    } = this;
+
+    return Object.fromEntries(
+      Object.entries(allParameters).filter(([key]) => !statefulParametersMap.has(key))
+    ) as Partial<T>;
+  }
+
+  get allStatefulParameters(): Partial<T> {
+    const { allParameters, statefulParametersMap } = this;
+
+    return Object.fromEntries(
+      Object.entries(allParameters).filter(([key]) => statefulParametersMap.has(key))
+    ) as Partial<T>;
+  }
+}

package/src/{entities/resource-options.test.ts → resource/parsed-resource-settings.test.ts}

@@ -1,20 +1,21 @@
 import { describe, expect, it } from 'vitest';
-import { ResourceOptions, ResourceOptionsParser } from './resource-options.js';
-import { TestConfig } from './resource.test.js';
+import { ResourceSettings } from './resource-settings.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
+import { TestConfig } from '../utils/test-utils.test.js';
 
 describe('Resource options parser tests', () => {
   it('Parses default values from options', () => {
-    const option: ResourceOptions<TestConfig> = {
-      type: 'typeId',
-      parameterOptions: {
+    const option: ResourceSettings<TestConfig> = {
+      id: 'typeId',
+      parameterSettings: {
         propA: { default: 'propA' },
         propB: { default: 'propB' },
         propC: { isEqual: () => true },
-        propD: { },
+        propD: {},
       }
     }
 
-    const result = new ResourceOptionsParser(option);
+    const result = new ParsedResourceSettings(option);
     expect(result.defaultValues).to.deep.eq({
       propA: 'propA',
       propB: 'propB'

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'
       }
     })
   })