codify-plugin-lib 1.0.49 → 1.0.51

package/dist/entities/stateful-parameter.d.ts

@@ -1,26 +1,26 @@
 import { Plan } from './plan.js';
 import { StringIndexedObject } from 'codify-schemas';
-export interface StatefulParameterConfiguration<T> {
+export interface StatefulParameterOptions<T> {
     name: keyof T;
     isEqual?: (desired: any, current: any) => boolean;
     disableStatelessModeArrayFiltering?: boolean;
 }
-export interface ArrayStatefulParameterConfiguration<T> extends StatefulParameterConfiguration<T> {
+export interface ArrayStatefulParameterOptions<T> extends StatefulParameterOptions<T> {
     isEqual?: (desired: any[], current: any[]) => boolean;
     isElementEqual?: (desired: any, current: any) => boolean;
 }
 export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
     readonly name: keyof T;
-    readonly configuration: StatefulParameterConfiguration<T>;
-    protected constructor(configuration: StatefulParameterConfiguration<T>);
+    readonly options: StatefulParameterOptions<T>;
+    protected constructor(options: StatefulParameterOptions<T>);
     abstract refresh(desired: V | null): Promise<V | null>;
     abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
     abstract applyModify(newValue: V, previousValue: V, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     abstract applyRemove(valueToRemove: V, plan: Plan<T>): Promise<void>;
 }
 export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
-    configuration: ArrayStatefulParameterConfiguration<T>;
-    constructor(configuration: ArrayStatefulParameterConfiguration<T>);
+    options: ArrayStatefulParameterOptions<T>;
+    constructor(options: ArrayStatefulParameterOptions<T>);
     applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
     applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     applyRemove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;

package/dist/entities/stateful-parameter.js

@@ -1,16 +1,16 @@
 export class StatefulParameter {
     name;
-    configuration;
-    constructor(configuration) {
-        this.name = configuration.name;
-        this.configuration = configuration;
+    options;
+    constructor(options) {
+        this.name = options.name;
+        this.options = options;
     }
 }
 export class ArrayStatefulParameter extends StatefulParameter {
-    configuration;
-    constructor(configuration) {
-        super(configuration);
-        this.configuration = configuration;
+    options;
+    constructor(options) {
+        super(options);
+        this.options = options;
     }
     async applyAdd(valuesToAdd, plan) {
         for (const value of valuesToAdd) {
@@ -18,16 +18,16 @@ export class ArrayStatefulParameter extends StatefulParameter {
         }
     }
     async applyModify(newValues, previousValues, allowDeletes, plan) {
-        const configuration = this.configuration;
+        const options = this.options;
         const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
-            if ((configuration).isElementEqual) {
-                return configuration.isElementEqual(n, p);
+            if (options.isElementEqual) {
+                return options.isElementEqual(n, p);
             }
             return n === p;
         }));
         const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
-            if ((configuration).isElementEqual) {
-                return configuration.isElementEqual(n, p);
+            if (options.isElementEqual) {
+                return options.isElementEqual(n, p);
             }
             return n === p;
         }));

package/dist/entities/transform-parameter.d.ts

@@ -0,0 +1,4 @@
+import { StringIndexedObject } from 'codify-schemas';
+export declare abstract class TransformParameter<T extends StringIndexedObject> {
+    abstract transform(value: any): Promise<Partial<T>>;
+}

package/dist/entities/transform-parameter.js

@@ -0,0 +1,2 @@
+export class TransformParameter {
+}

package/package.json

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

package/src/entities/change-set.ts

@@ -1,5 +1,5 @@
 import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { ParameterConfiguration } from './plan-types.js';
+import { ParameterOptions } from './plan-types.js';
 
 export interface ParameterChange<T extends StringIndexedObject> {
   name: keyof T & string;
@@ -61,12 +61,12 @@ export class ChangeSet<T extends StringIndexedObject> {
   static calculateParameterChangeSet<T extends StringIndexedObject>(
     desired: T | null,
     current: T | null,
-    options: { statefulMode: boolean, parameterConfigurations?: Record<keyof T, ParameterConfiguration> },
+    options: { statefulMode: boolean, parameterOptions?: Record<keyof T, ParameterOptions> },
   ): ParameterChange<T>[] {
     if (options.statefulMode) {
-      return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterConfigurations);
+      return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterOptions);
     } else {
-      return ChangeSet.calculateStatelessModeChangeSet(desired, current, options.parameterConfigurations);
+      return ChangeSet.calculateStatelessModeChangeSet(desired, current, options.parameterOptions);
     }
   }
 
@@ -88,10 +88,10 @@ export class ChangeSet<T extends StringIndexedObject> {
   static isSame(
     desired: unknown,
     current: unknown,
-    configuration?: ParameterConfiguration,
+    options?: ParameterOptions,
   ): boolean {
-    if (configuration?.isEqual) {
-      return configuration.isEqual(desired, current);
+    if (options?.isEqual) {
+      return options.isEqual(desired, current);
     }
 
     if (Array.isArray(desired) && Array.isArray(current)) {
@@ -102,9 +102,9 @@ export class ChangeSet<T extends StringIndexedObject> {
         return false;
       }
 
-      if (configuration?.isElementEqual) {
+      if (options?.isElementEqual) {
         return sortedDesired.every((value, index) =>
-          configuration.isElementEqual!(value, sortedCurrent[index])
+          options.isElementEqual!(value, sortedCurrent[index])
         );
       }
 
@@ -119,7 +119,7 @@ export class ChangeSet<T extends StringIndexedObject> {
   private static calculateStatefulModeChangeSet<T extends StringIndexedObject>(
     desired: T | null,
     current: T | null,
-    parameterConfigurations?: Record<keyof T, ParameterConfiguration>,
+    parameterOptions?: Record<keyof T, ParameterOptions>,
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
     
@@ -139,7 +139,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         continue;
       }
 
-      if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k])) {
+      if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
         parameterChangeSet.push({
           name: k,
           previousValue: v,
@@ -184,7 +184,7 @@ export class ChangeSet<T extends StringIndexedObject> {
   private static calculateStatelessModeChangeSet<T extends StringIndexedObject>(
     desired: T | null,
     current: T | null,
-    parameterConfigurations?: Record<keyof T, ParameterConfiguration>,
+    parameterOptions?: Record<keyof T, ParameterOptions>,
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
@@ -203,7 +203,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         continue;
       }
 
-      if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k])) {
+      if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
         parameterChangeSet.push({
           name: k,
           previousValue: _current[k],

package/src/entities/plan-types.ts

@@ -3,7 +3,7 @@ import { ResourceOperation } from 'codify-schemas';
 /**
  * Customize properties for specific parameters. This will alter the way the library process changes to the parameter.
  */
-export interface ParameterConfiguration {
+export interface ParameterOptions {
   /**
    * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to re-create.
    */
@@ -20,7 +20,7 @@ export interface ParameterConfiguration {
   isStatefulParameter?: boolean;
 }
 
-export interface PlanConfiguration<T> {
+export interface PlanOptions<T> {
   statefulMode: boolean;
-  parameterConfigurations?: Record<keyof T, ParameterConfiguration>;
+  parameterOptions?: Record<keyof T, ParameterOptions>;
 }

package/src/entities/plan.test.ts

@@ -140,7 +140,7 @@ function createResource(): Resource<any> {
     constructor() {
       super({
         type: 'type',
-        parameterConfigurations: {
+        parameterOptions: {
           propA: {
             defaultValue: 'defaultA'
           }

package/src/entities/plan.ts

@@ -8,7 +8,7 @@ import {
   StringIndexedObject,
 } from 'codify-schemas';
 import { randomUUID } from 'crypto';
-import { ParameterConfiguration, PlanConfiguration } from './plan-types.js';
+import { ParameterOptions, PlanOptions } from './plan-types.js';
 
 export class Plan<T extends StringIndexedObject> {
   id: string;
@@ -25,11 +25,11 @@ export class Plan<T extends StringIndexedObject> {
     desiredParameters: Partial<T> | null,
     currentParameters: Partial<T> | null,
     resourceMetadata: ResourceConfig,
-    configuration: PlanConfiguration<T>
+    options: PlanOptions<T>
   ): Plan<T> {
-    const parameterConfigurations = configuration.parameterConfigurations ?? {} as Record<keyof T, ParameterConfiguration>;
+    const parameterOptions = options.parameterOptions ?? {} as Record<keyof T, ParameterOptions>;
     const statefulParameterNames = new Set(
-      [...Object.entries(parameterConfigurations)]
+      [...Object.entries(parameterOptions)]
         .filter(([k, v]) => v.isStatefulParameter)
         .map(([k, v]) => k)
     );
@@ -40,7 +40,7 @@ export class Plan<T extends StringIndexedObject> {
     const parameterChangeSet = ChangeSet.calculateParameterChangeSet(
       desiredParameters,
       currentParameters,
-      { statefulMode: configuration.statefulMode, parameterConfigurations }
+      { statefulMode: options.statefulMode, parameterOptions }
     );
 
     let resourceOperation: ResourceOperation;
@@ -55,8 +55,8 @@ export class Plan<T extends StringIndexedObject> {
           let newOperation: ResourceOperation;
           if (statefulParameterNames.has(curr.name)) {
             newOperation = ResourceOperation.MODIFY // All stateful parameters are modify only
-          } else if (parameterConfigurations[curr.name]?.planOperation) {
-            newOperation = parameterConfigurations[curr.name].planOperation!;
+          } else if (parameterOptions[curr.name]?.planOperation) {
+            newOperation = parameterOptions[curr.name].planOperation!;
           } else {
             newOperation = ResourceOperation.RECREATE; // Default to Re-create. Should handle the majority of use cases
           }

package/src/entities/plugin.ts

@@ -42,7 +42,7 @@ export class Plugin {
       }
 
       const { parameters } = splitUserConfig(config);
-      const validateResult = await this.resources.get(config.type)!.validate(parameters);
+      const validateResult = await this.resources.get(config.type)!.validateResource(parameters);
 
       validationResults.push({
         ...validateResult,

package/src/entities/resource-options.ts

@@ -0,0 +1,156 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
+import { ResourceParameterOptions } from './resource-types.js';
+import { ParameterOptions } from './plan-types.js';
+
+export interface ResourceOptions<T extends StringIndexedObject> {
+
+  /**
+   * The id of the resource.
+   */
+  type: string;
+
+  /**
+   * Schema to validate user configs with. Must be in the format JSON Schema 2020-12
+   */
+  schema?: unknown
+
+  /**
+   * If true, statefulParameter.applyRemove() will be called before resource destruction.
+   * Defaults to false.
+   */
+  callStatefulParameterRemoveOnDestroy?: boolean,
+
+  /**
+   * An array of type ids of resources that this resource depends on. This affects the order in which the resources are
+   * planned and applied.
+   */
+  dependencies?: string[];
+
+  /**
+   * Additional options for configuring parameters.
+   */
+  parameterOptions?: Partial<Record<keyof T,
+    ResourceParameterOptions
+    | ResourceStatefulParameterOptions<T>
+    | ResourceTransformParameterOptions<T>
+  >>
+}
+
+export interface ResourceStatefulParameterOptions<T extends StringIndexedObject> {
+  statefulParameter: StatefulParameter<T, T[keyof T]>;
+  order?: number;
+}
+
+export interface ResourceTransformParameterOptions<T extends StringIndexedObject> {
+  transformParameter: TransformParameter<T>;
+  order?: number;
+}
+
+export class ResourceOptionsParser<T extends StringIndexedObject> {
+  private options: ResourceOptions<T>;
+
+  constructor(options: ResourceOptions<T>) {
+    this.options = options;
+  }
+
+  get statefulParameters(): Map<keyof T, StatefulParameter<T, T[keyof T]>> {
+    const statefulParameters = Object.entries(this.options.parameterOptions ?? {})
+        .filter(([, p]) => p?.hasOwnProperty('statefulParameter'))
+        .map(([k, v]) => [k, v as ResourceStatefulParameterOptions<T>] as const)
+        .map(([k, v]) => [k, v.statefulParameter] as const)
+
+    return new Map(statefulParameters);
+  }
+
+  get transformParameters(): Map<keyof T, TransformParameter<T>> {
+    const transformParameters =
+      Object.entries(this.options.parameterOptions ?? {})
+        .filter(([, p]) => p?.hasOwnProperty('transformParameter'))
+        .map(([k, v]) => [k, v as ResourceTransformParameterOptions<T>] as const)
+        .map(([k, v]) => [k, v.transformParameter] as const)
+
+    return new Map(transformParameters);
+  }
+
+  get resourceParameters(): Map<keyof T, ResourceParameterOptions> {
+    const resourceParameters =
+      Object.entries(this.options.parameterOptions ?? {})
+        .filter(([, p]) => !(p?.hasOwnProperty('statefulParameter') || p?.hasOwnProperty('transformParameter')))
+        .map(([k, v]) => [k, v as ResourceParameterOptions] as const)
+
+    return new Map(resourceParameters);
+  }
+
+  get changeSetParameterOptions(): Record<keyof T, ParameterOptions>  {
+    const resourceParameters = Object.fromEntries(
+      [...this.resourceParameters.entries()]
+        .map(([name, value]) => ([name, { ...value, isStatefulParameter: false }]))
+    );
+
+    const statefulParameters = [...this.statefulParameters.entries()]
+      ?.reduce((obj, sp) => {
+        return {
+          ...obj,
+          [sp[0]]: {
+            ...sp[1].options,
+            isStatefulParameter: true,
+          }
+        }
+      }, {} as Record<keyof T, ParameterOptions>)
+
+    return {
+      ...resourceParameters,
+      ...statefulParameters,
+    }
+  }
+
+  get defaultValues(): Partial<Record<keyof T, unknown>>  {
+    if (!this.options.parameterOptions) {
+      return {};
+    }
+
+    return Object.fromEntries(
+      [...this.resourceParameters.entries()]
+        .filter(([, rp]) => rp.defaultValue !== undefined)
+        .map(([name, rp]) => [name, rp.defaultValue])
+    ) as Partial<Record<keyof T, unknown>>;
+  }
+
+  get statefulParameterOrder(): Map<keyof T, number> {
+    const entries = Object.entries(this.options.parameterOptions ?? {})
+      .filter(([, v]) => v?.hasOwnProperty('statefulParameter'))
+      .map(([k, v]) => [k, v as ResourceStatefulParameterOptions<T>] 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]));
+  }
+
+  get transformParameterOrder(): Map<keyof T, number> {
+    const entries = Object.entries(this.options.parameterOptions ?? {})
+      .filter(([, v]) => v?.hasOwnProperty('transformParameter'))
+      .map(([k, v]) => [k, v as ResourceTransformParameterOptions<T>] 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]));
+  }
+}