codify-plugin-lib 1.0.50 → 1.0.51

package/dist/entities/change-set.d.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;
     operation: ParameterOperation;
@@ -14,10 +14,10 @@ export declare class ChangeSet<T extends StringIndexedObject> {
     get currentParameters(): T;
     static calculateParameterChangeSet<T extends StringIndexedObject>(desired: T | null, current: T | null, options: {
         statefulMode: boolean;
-        parameterConfigurations?: Record<keyof T, ParameterConfiguration>;
+        parameterOptions?: Record<keyof T, ParameterOptions>;
     }): ParameterChange<T>[];
     static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation): ResourceOperation;
-    static isSame(desired: unknown, current: unknown, configuration?: ParameterConfiguration): boolean;
+    static isSame(desired: unknown, current: unknown, options?: ParameterOptions): boolean;
     private static calculateStatefulModeChangeSet;
     private static calculateStatelessModeChangeSet;
 }

package/dist/entities/change-set.js

@@ -22,10 +22,10 @@ export class ChangeSet {
     }
     static calculateParameterChangeSet(desired, current, options) {
         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);
         }
     }
     static combineResourceOperations(prev, next) {
@@ -40,9 +40,9 @@ export class ChangeSet {
         const indexNext = orderOfOperations.indexOf(next);
         return orderOfOperations[Math.max(indexPrev, indexNext)];
     }
-    static isSame(desired, current, configuration) {
-        if (configuration?.isEqual) {
-            return configuration.isEqual(desired, current);
+    static isSame(desired, current, options) {
+        if (options?.isEqual) {
+            return options.isEqual(desired, current);
         }
         if (Array.isArray(desired) && Array.isArray(current)) {
             const sortedDesired = desired.map((x) => x).sort();
@@ -50,14 +50,14 @@ export class ChangeSet {
             if (sortedDesired.length !== sortedCurrent.length) {
                 return false;
             }
-            if (configuration?.isElementEqual) {
-                return sortedDesired.every((value, index) => configuration.isElementEqual(value, sortedCurrent[index]));
+            if (options?.isElementEqual) {
+                return sortedDesired.every((value, index) => options.isElementEqual(value, sortedCurrent[index]));
             }
             return JSON.stringify(sortedDesired) === JSON.stringify(sortedCurrent);
         }
         return desired === current;
     }
-    static calculateStatefulModeChangeSet(desired, current, parameterConfigurations) {
+    static calculateStatefulModeChangeSet(desired, current, parameterOptions) {
         const parameterChangeSet = new Array();
         const _desired = { ...desired };
         const _current = { ...current };
@@ -72,7 +72,7 @@ export class ChangeSet {
                 delete _current[k];
                 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,
@@ -105,7 +105,7 @@ export class ChangeSet {
         }
         return parameterChangeSet;
     }
-    static calculateStatelessModeChangeSet(desired, current, parameterConfigurations) {
+    static calculateStatelessModeChangeSet(desired, current, parameterOptions) {
         const parameterChangeSet = new Array();
         const _desired = { ...desired };
         const _current = { ...current };
@@ -119,7 +119,7 @@ export class ChangeSet {
                 });
                 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/dist/entities/plan-types.d.ts

@@ -1,11 +1,11 @@
 import { ResourceOperation } from 'codify-schemas';
-export interface ParameterConfiguration {
+export interface ParameterOptions {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
     isEqual?: (desired: any, current: any) => boolean;
     isElementEqual?: (desired: any, current: any) => boolean;
     isStatefulParameter?: boolean;
 }
-export interface PlanConfiguration<T> {
+export interface PlanOptions<T> {
     statefulMode: boolean;
-    parameterConfigurations?: Record<keyof T, ParameterConfiguration>;
+    parameterOptions?: Record<keyof T, ParameterOptions>;
 }

package/dist/entities/plan.d.ts

@@ -1,12 +1,12 @@
 import { ChangeSet } from './change-set.js';
 import { ApplyRequestData, PlanResponseData, ResourceConfig, StringIndexedObject } from 'codify-schemas';
-import { PlanConfiguration } from './plan-types.js';
+import { PlanOptions } from './plan-types.js';
 export declare class Plan<T extends StringIndexedObject> {
     id: string;
     changeSet: ChangeSet<T>;
     resourceMetadata: ResourceConfig;
     constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
-    static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, configuration: PlanConfiguration<T>): Plan<T>;
+    static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, options: PlanOptions<T>): Plan<T>;
     getResourceType(): string;
     static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues: Partial<Record<keyof T, unknown>>): Plan<T>;
     get desiredConfig(): T;

package/dist/entities/plan.js

@@ -10,12 +10,12 @@ export class Plan {
         this.changeSet = changeSet;
         this.resourceMetadata = resourceMetadata;
     }
-    static create(desiredParameters, currentParameters, resourceMetadata, configuration) {
-        const parameterConfigurations = configuration.parameterConfigurations ?? {};
-        const statefulParameterNames = new Set([...Object.entries(parameterConfigurations)]
+    static create(desiredParameters, currentParameters, resourceMetadata, options) {
+        const parameterOptions = options.parameterOptions ?? {};
+        const statefulParameterNames = new Set([...Object.entries(parameterOptions)]
             .filter(([k, v]) => v.isStatefulParameter)
             .map(([k, v]) => k));
-        const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: configuration.statefulMode, parameterConfigurations });
+        const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: options.statefulMode, parameterOptions });
         let resourceOperation;
         if (!currentParameters && desiredParameters) {
             resourceOperation = ResourceOperation.CREATE;
@@ -31,8 +31,8 @@ export class Plan {
                 if (statefulParameterNames.has(curr.name)) {
                     newOperation = ResourceOperation.MODIFY;
                 }
-                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;

package/dist/entities/plugin.js

@@ -26,7 +26,7 @@ export class Plugin {
                 throw new Error(`Resource type not found: ${config.type}`);
             }
             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,
                 resourceType: config.type,

package/dist/entities/resource-options.d.ts

@@ -0,0 +1,31 @@
+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> {
+    type: string;
+    schema?: unknown;
+    callStatefulParameterRemoveOnDestroy?: boolean;
+    dependencies?: string[];
+    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 declare class ResourceOptionsParser<T extends StringIndexedObject> {
+    private options;
+    constructor(options: ResourceOptions<T>);
+    get statefulParameters(): Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+    get transformParameters(): Map<keyof T, TransformParameter<T>>;
+    get resourceParameters(): Map<keyof T, ResourceParameterOptions>;
+    get changeSetParameterOptions(): Record<keyof T, ParameterOptions>;
+    get defaultValues(): Partial<Record<keyof T, unknown>>;
+    get statefulParameterOrder(): Map<keyof T, number>;
+    get transformParameterOrder(): Map<keyof T, number>;
+}

package/dist/entities/resource-options.js

@@ -0,0 +1,78 @@
+export class ResourceOptionsParser {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get statefulParameters() {
+        const statefulParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => p?.hasOwnProperty('statefulParameter'))
+            .map(([k, v]) => [k, v])
+            .map(([k, v]) => [k, v.statefulParameter]);
+        return new Map(statefulParameters);
+    }
+    get transformParameters() {
+        const transformParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => p?.hasOwnProperty('transformParameter'))
+            .map(([k, v]) => [k, v])
+            .map(([k, v]) => [k, v.transformParameter]);
+        return new Map(transformParameters);
+    }
+    get resourceParameters() {
+        const resourceParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => !(p?.hasOwnProperty('statefulParameter') || p?.hasOwnProperty('transformParameter')))
+            .map(([k, v]) => [k, v]);
+        return new Map(resourceParameters);
+    }
+    get changeSetParameterOptions() {
+        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,
+                }
+            };
+        }, {});
+        return {
+            ...resourceParameters,
+            ...statefulParameters,
+        };
+    }
+    get defaultValues() {
+        if (!this.options.parameterOptions) {
+            return {};
+        }
+        return Object.fromEntries([...this.resourceParameters.entries()]
+            .filter(([, rp]) => rp.defaultValue !== undefined)
+            .map(([name, rp]) => [name, rp.defaultValue]));
+    }
+    get statefulParameterOrder() {
+        const entries = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, v]) => v?.hasOwnProperty('statefulParameter'))
+            .map(([k, v]) => [k, v]);
+        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() {
+        const entries = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, v]) => v?.hasOwnProperty('transformParameter'))
+            .map(([k, v]) => [k, v]);
+        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]));
+    }
+}

package/dist/entities/resource-types.d.ts

@@ -1,20 +1,10 @@
-import { StatefulParameter } from './stateful-parameter.js';
-import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { TransformParameter } from './transform-parameter.js';
+import { ResourceOperation } from 'codify-schemas';
 export type ErrorMessage = string;
-export interface ResourceParameterConfiguration {
+export interface ResourceParameterOptions {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
     isEqual?: (desired: any, current: any) => boolean;
     defaultValue?: unknown;
 }
-export interface ResourceConfiguration<T extends StringIndexedObject> {
-    type: string;
-    callStatefulParameterRemoveOnDestroy?: boolean;
-    dependencies?: string[];
-    statefulParameters?: Array<StatefulParameter<T, T[keyof T]>>;
-    transformParameters?: Partial<Record<keyof T, TransformParameter<T>>>;
-    parameterConfigurations?: Partial<Record<keyof T, ResourceParameterConfiguration>>;
-}
 export interface ResourceDefinition {
     [x: string]: {
         type: string;

package/dist/entities/resource.d.ts

@@ -1,31 +1,39 @@
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 import { Plan } from './plan.js';
 import { StatefulParameter } from './stateful-parameter.js';
-import { ResourceConfiguration, ValidationResult } from './resource-types.js';
-import { ParameterConfiguration } from './plan-types.js';
+import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
+import { ParameterOptions } from './plan-types.js';
 import { TransformParameter } from './transform-parameter.js';
+import { ResourceOptions } from './resource-options.js';
+import Ajv from 'ajv';
+import { ValidateFunction } from 'ajv/dist/2020.js';
 export declare abstract class Resource<T extends StringIndexedObject> {
     readonly typeId: string;
     readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
     readonly transformParameters: Map<keyof T, TransformParameter<T>>;
+    readonly resourceParameters: Map<keyof T, ResourceParameterOptions>;
+    readonly statefulParameterOrder: Map<keyof T, number>;
+    readonly transformParameterOrder: Map<keyof T, number>;
     readonly dependencies: string[];
-    readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>;
-    readonly configuration: ResourceConfiguration<T>;
+    readonly parameterOptions: Record<keyof T, ParameterOptions>;
+    readonly options: ResourceOptions<T>;
     readonly defaultValues: Partial<Record<keyof T, unknown>>;
-    protected constructor(configuration: ResourceConfiguration<T>);
+    protected ajv?: Ajv.default;
+    protected schemaValidator?: ValidateFunction;
+    protected constructor(options: ResourceOptions<T>);
     onInitialize(): Promise<void>;
+    validateResource(parameters: unknown): Promise<ValidationResult>;
     plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
     private _applyCreate;
     private _applyModify;
     private _applyDestroy;
-    private initializeParameterConfigurations;
-    private initializeDefaultValues;
-    private validateResourceConfiguration;
     private validateRefreshResults;
     private applyTransformParameters;
     private addDefaultValues;
-    abstract validate(parameters: unknown): Promise<ValidationResult>;
+    private refreshResourceParameters;
+    private refreshStatefulParameters;
+    validate(parameters: unknown): Promise<ValidationResult>;
     abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
     abstract applyCreate(plan: Plan<T>): Promise<void>;
     applyModify(parameterName: keyof T, newValue: unknown, previousValue: unknown, allowDeletes: boolean, plan: Plan<T>): Promise<void>;

package/dist/entities/resource.js

@@ -1,62 +1,69 @@
 import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
 import { Plan } from './plan.js';
 import { setsEqual, splitUserConfig } from '../utils/utils.js';
+import { ResourceOptionsParser } from './resource-options.js';
+import Ajv2020 from 'ajv/dist/2020.js';
 export class Resource {
     typeId;
     statefulParameters;
     transformParameters;
+    resourceParameters;
+    statefulParameterOrder;
+    transformParameterOrder;
     dependencies;
-    parameterConfigurations;
-    configuration;
+    parameterOptions;
+    options;
     defaultValues;
-    constructor(configuration) {
-        this.validateResourceConfiguration(configuration);
-        this.typeId = configuration.type;
-        this.statefulParameters = new Map(configuration.statefulParameters?.map((sp) => [sp.name, sp]));
-        this.transformParameters = new Map(Object.entries(configuration.transformParameters ?? {}));
-        this.parameterConfigurations = this.initializeParameterConfigurations(configuration);
-        this.defaultValues = this.initializeDefaultValues(configuration);
-        this.dependencies = configuration.dependencies ?? [];
-        this.configuration = configuration;
+    ajv;
+    schemaValidator;
+    constructor(options) {
+        this.typeId = options.type;
+        this.dependencies = options.dependencies ?? [];
+        this.options = options;
+        if (this.options.schema) {
+            this.ajv = new Ajv2020.default({
+                strict: true,
+                strictRequired: false,
+            });
+            this.schemaValidator = this.ajv.compile(this.options.schema);
+        }
+        const parser = new ResourceOptionsParser(options);
+        this.statefulParameters = parser.statefulParameters;
+        this.transformParameters = parser.transformParameters;
+        this.resourceParameters = parser.resourceParameters;
+        this.parameterOptions = parser.changeSetParameterOptions;
+        this.defaultValues = parser.defaultValues;
+        this.statefulParameterOrder = parser.statefulParameterOrder;
+        this.transformParameterOrder = parser.transformParameterOrder;
     }
     async onInitialize() { }
+    async validateResource(parameters) {
+        if (this.schemaValidator) {
+            const isValid = this.schemaValidator(parameters);
+            if (!isValid) {
+                return {
+                    isValid: false,
+                    errors: this.schemaValidator?.errors ?? [],
+                };
+            }
+        }
+        return this.validate(parameters);
+    }
     async plan(desiredConfig) {
-        const planConfiguration = {
+        const planOptions = {
             statefulMode: false,
-            parameterConfigurations: this.parameterConfigurations,
+            parameterOptions: this.parameterOptions,
         };
-        const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
-        this.addDefaultValues(desiredParameters);
-        await this.applyTransformParameters(desiredParameters);
-        const resourceParameters = Object.fromEntries([
-            ...Object.entries(desiredParameters).filter(([key]) => !this.statefulParameters.has(key)),
-        ]);
-        const statefulParameters = [...this.statefulParameters.values()]
-            .filter((sp) => desiredParameters[sp.name] !== undefined);
-        const entriesToRefresh = new Map(Object.entries(resourceParameters));
-        const currentParameters = await this.refresh(entriesToRefresh);
+        const parsedConfig = new ConfigParser(desiredConfig, this.statefulParameters, this.transformParameters);
+        const { parameters: desiredParameters, resourceMetadata, resourceParameters, statefulParameters } = parsedConfig;
+        this.addDefaultValues(resourceParameters);
+        await this.applyTransformParameters(resourceParameters);
+        const currentParameters = await this.refreshResourceParameters(resourceParameters);
         if (currentParameters == null) {
-            return Plan.create(desiredParameters, null, resourceMetadata, planConfiguration);
-        }
-        this.validateRefreshResults(currentParameters, entriesToRefresh);
-        for (const statefulParameter of statefulParameters) {
-            const desiredValue = desiredParameters[statefulParameter.name];
-            let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
-            if (Array.isArray(currentValue)
-                && Array.isArray(desiredValue)
-                && !planConfiguration.statefulMode
-                && !statefulParameter.configuration.disableStatelessModeArrayFiltering) {
-                currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
-                    const pc = planConfiguration?.parameterConfigurations?.[statefulParameter.name];
-                    if (pc && pc.isElementEqual) {
-                        return pc.isElementEqual(d, c);
-                    }
-                    return d === c;
-                }));
-            }
-            currentParameters[statefulParameter.name] = currentValue;
+            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
         }
-        return Plan.create(desiredParameters, currentParameters, resourceMetadata, planConfiguration);
+        const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
+        return Plan.create({ ...resourceParameters, ...statefulParameters }, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
     }
     async apply(plan) {
         if (plan.getResourceType() !== this.typeId) {
@@ -81,7 +88,8 @@ export class Resource {
     async _applyCreate(plan) {
         await this.applyCreate(plan);
         const statefulParameterChanges = plan.changeSet.parameterChanges
-            .filter((pc) => this.statefulParameters.has(pc.name));
+            .filter((pc) => this.statefulParameters.has(pc.name))
+            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
         for (const parameterChange of statefulParameterChanges) {
             const statefulParameter = this.statefulParameters.get(parameterChange.name);
             await statefulParameter.applyAdd(parameterChange.newValue, plan);
@@ -98,7 +106,8 @@ export class Resource {
             await this.applyModify(pc.name, pc.newValue, pc.previousValue, false, plan);
         }
         const statefulParameterChanges = parameterChanges
-            .filter((pc) => this.statefulParameters.has(pc.name));
+            .filter((pc) => this.statefulParameters.has(pc.name))
+            .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
         for (const parameterChange of statefulParameterChanges) {
             const statefulParameter = this.statefulParameters.get(parameterChange.name);
             switch (parameterChange.operation) {
@@ -118,9 +127,10 @@ export class Resource {
         }
     }
     async _applyDestroy(plan) {
-        if (this.configuration.callStatefulParameterRemoveOnDestroy) {
+        if (this.options.callStatefulParameterRemoveOnDestroy) {
             const statefulParameterChanges = plan.changeSet.parameterChanges
-                .filter((pc) => this.statefulParameters.has(pc.name));
+                .filter((pc) => this.statefulParameters.has(pc.name))
+                .sort((a, b) => this.statefulParameterOrder.get(a.name) - this.statefulParameterOrder.get(b.name));
             for (const parameterChange of statefulParameterChanges) {
                 const statefulParameter = this.statefulParameters.get(parameterChange.name);
                 await statefulParameter.applyRemove(parameterChange.previousValue, plan);
@@ -128,42 +138,6 @@ export class Resource {
         }
         await this.applyDestroy(plan);
     }
-    initializeParameterConfigurations(resourceConfiguration) {
-        const resourceParameters = Object.fromEntries(Object.entries(resourceConfiguration.parameterConfigurations ?? {})
-            ?.map(([name, value]) => ([name, { ...value, isStatefulParameter: false }])));
-        const statefulParameters = resourceConfiguration.statefulParameters
-            ?.reduce((obj, sp) => {
-            return {
-                ...obj,
-                [sp.name]: {
-                    ...sp.configuration,
-                    isStatefulParameter: true,
-                }
-            };
-        }, {}) ?? {};
-        return {
-            ...resourceParameters,
-            ...statefulParameters,
-        };
-    }
-    initializeDefaultValues(resourceConfiguration) {
-        if (!resourceConfiguration.parameterConfigurations) {
-            return {};
-        }
-        return Object.fromEntries(Object.entries(resourceConfiguration.parameterConfigurations)
-            .filter((p) => p[1]?.defaultValue !== undefined)
-            .map((config) => [config[0], config[1].defaultValue]));
-    }
-    validateResourceConfiguration(data) {
-        if (data.parameterConfigurations && data.statefulParameters) {
-            const parameters = [...Object.keys(data.parameterConfigurations)];
-            const statefulParameterSet = new Set(data.statefulParameters.map((sp) => sp.name));
-            const intersection = parameters.some((p) => statefulParameterSet.has(p));
-            if (intersection) {
-                throw new Error(`Resource ${this.typeId} cannot declare a parameter as both stateful and non-stateful`);
-            }
-        }
-    }
     validateRefreshResults(refresh, desiredMap) {
         if (!refresh) {
             return;
@@ -171,14 +145,16 @@ export class Resource {
         const desiredKeys = new Set(desiredMap.keys());
         const refreshKeys = new Set(Object.keys(refresh));
         if (!setsEqual(desiredKeys, refreshKeys)) {
-            throw new Error(`Resource ${this.configuration.type}
+            throw new Error(`Resource ${this.typeId}
 refresh() must return back exactly the keys that were provided
 Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
     async applyTransformParameters(desired) {
-        for (const [key, tp] of this.transformParameters.entries()) {
+        const orderedEntries = [...this.transformParameters.entries()]
+            .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
+        for (const [key, tp] of orderedEntries) {
             if (desired[key] !== null) {
                 const transformedValue = await tp.transform(desired[key]);
                 if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
@@ -199,6 +175,80 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
             }
         });
     }
+    async refreshResourceParameters(resourceParameters) {
+        const entriesToRefresh = new Map(Object.entries(resourceParameters));
+        const currentParameters = await this.refresh(entriesToRefresh);
+        this.validateRefreshResults(currentParameters, entriesToRefresh);
+        return currentParameters;
+    }
+    async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {
+        const currentParameters = {};
+        const sortedEntries = Object.entries(statefulParametersConfig)
+            .sort(([key1], [key2]) => this.statefulParameterOrder.get(key1) - this.statefulParameterOrder.get(key2));
+        for (const [key, desiredValue] of sortedEntries) {
+            const statefulParameter = this.statefulParameters.get(key);
+            if (!statefulParameter) {
+                throw new Error(`Stateful parameter ${key} was not found`);
+            }
+            let currentValue = await statefulParameter.refresh(desiredValue ?? null);
+            if (Array.isArray(currentValue)
+                && Array.isArray(desiredValue)
+                && !isStatefulMode
+                && !statefulParameter.options.disableStatelessModeArrayFiltering) {
+                currentValue = currentValue.filter((c) => desiredValue?.some((d) => {
+                    const parameterOptions = statefulParameter.options;
+                    if (parameterOptions && parameterOptions.isElementEqual) {
+                        return parameterOptions.isElementEqual(d, c);
+                    }
+                    return d === c;
+                }));
+            }
+            currentParameters[key] = currentValue;
+        }
+        return currentParameters;
+    }
+    async validate(parameters) {
+        return {
+            isValid: true,
+        };
+    }
+    ;
     async applyModify(parameterName, newValue, previousValue, allowDeletes, plan) { }
     ;
 }
+class ConfigParser {
+    config;
+    statefulParametersMap;
+    transformParametersMap;
+    constructor(config, statefulParameters, transformParameters) {
+        this.config = config;
+        this.statefulParametersMap = statefulParameters;
+        this.transformParametersMap = transformParameters;
+    }
+    get resourceMetadata() {
+        const { resourceMetadata } = splitUserConfig(this.config);
+        return resourceMetadata;
+    }
+    get parameters() {
+        const { parameters } = splitUserConfig(this.config);
+        return parameters;
+    }
+    get resourceParameters() {
+        const parameters = this.parameters;
+        return Object.fromEntries([
+            ...Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))),
+        ]);
+    }
+    get statefulParameters() {
+        const parameters = this.parameters;
+        return Object.fromEntries([
+            ...Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)),
+        ]);
+    }
+    get transformParameters() {
+        const parameters = this.parameters;
+        return Object.fromEntries([
+            ...Object.entries(parameters).filter(([key]) => this.transformParametersMap.has(key)),
+        ]);
+    }
+}