@codifycli/plugin-core 1.0.0-beta1

package/dist/resource/parsed-resource-settings.d.ts

@@ -0,0 +1,47 @@
+import { JSONSchemaType } from 'ajv';
+import { LinuxDistro, OS, StringIndexedObject } from 'codify-schemas';
+import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
+import { ArrayParameterSetting, DefaultParameterSetting, InputTransformation, ResourceSettings } from './resource-settings.js';
+export interface ParsedStatefulParameterSetting extends DefaultParameterSetting {
+    type: 'stateful';
+    controller: StatefulParameterController<any, unknown>;
+    order?: number;
+    nestedSettings: ParsedParameterSetting;
+}
+export type ParsedArrayParameterSetting = {
+    isElementEqual: (a: unknown, b: unknown) => boolean;
+    isEqual: (a: unknown, b: unknown) => boolean;
+} & ArrayParameterSetting;
+export type ParsedParameterSetting = {
+    isEqual: (desired: unknown, current: unknown) => boolean;
+} & (DefaultParameterSetting | ParsedArrayParameterSetting | ParsedStatefulParameterSetting);
+export declare class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
+    private cache;
+    id: string;
+    description?: string;
+    schema?: Partial<JSONSchemaType<T | any>>;
+    allowMultiple?: {
+        identifyingParameters?: string[];
+        matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
+        findAllParameters?: () => Promise<Array<Partial<T>>>;
+    } | boolean;
+    removeStatefulParametersBeforeDestroy?: boolean | undefined;
+    dependencies?: string[] | undefined;
+    transformation?: InputTransformation;
+    operatingSystems: Array<OS>;
+    linuxDistros?: Array<LinuxDistro>;
+    isSensitive?: boolean;
+    private settings;
+    constructor(settings: ResourceSettings<T>);
+    get typeId(): string;
+    get canDestroy(): boolean;
+    get statefulParameters(): Map<keyof T, StatefulParameterController<T, T[keyof T]>>;
+    get parameterSettings(): Record<keyof T, ParsedParameterSetting>;
+    get defaultValues(): Partial<Record<keyof T, unknown>>;
+    get inputTransformations(): Partial<Record<keyof T, InputTransformation>>;
+    get statefulParameterOrder(): Map<keyof T, number>;
+    get matcher(): (desired: Partial<T>, current: Partial<T>) => boolean;
+    private validateSettings;
+    private validateParameterEqualsFn;
+    private getFromCacheOrCreate;
+}

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

@@ -0,0 +1,196 @@
+import { ZodObject, z } from 'zod';
+import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
+import { resolveElementEqualsFn, resolveEqualsFn, resolveMatcher, resolveParameterTransformFn } from './resource-settings.js';
+export class ParsedResourceSettings {
+    cache = new Map();
+    id;
+    description;
+    schema;
+    allowMultiple;
+    removeStatefulParametersBeforeDestroy;
+    dependencies;
+    transformation;
+    operatingSystems;
+    linuxDistros;
+    isSensitive;
+    settings;
+    constructor(settings) {
+        this.settings = settings;
+        const { parameterSettings, schema, ...rest } = settings;
+        Object.assign(this, rest);
+        if (schema) {
+            this.schema = schema instanceof ZodObject
+                ? z.toJSONSchema(schema.strict(), {
+                    target: 'draft-7',
+                    override(ctx) {
+                        ctx.jsonSchema.title = settings.id;
+                        ctx.jsonSchema.description = settings.description ?? `${settings.id} resource. Can be used to manage ${settings.id}`;
+                    }
+                })
+                : schema;
+        }
+        this.validateSettings();
+    }
+    get typeId() {
+        return this.id;
+    }
+    get canDestroy() {
+        return !this.settings.importAndDestroy?.preventDestroy;
+    }
+    get statefulParameters() {
+        return this.getFromCacheOrCreate('statefulParameters', () => {
+            const statefulParameters = Object.entries(this.settings.parameterSettings ?? {})
+                .filter(([, p]) => p?.type === 'stateful')
+                .map(([k, v]) => [
+                k,
+                new StatefulParameterController(v.definition)
+            ]);
+            return new Map(statefulParameters);
+        });
+    }
+    get parameterSettings() {
+        return this.getFromCacheOrCreate('parameterSetting', () => {
+            const settings = Object.entries(this.settings.parameterSettings ?? {})
+                .map(([k, v]) => [k, v])
+                .map(([k, v]) => {
+                v.isEqual = resolveEqualsFn(v);
+                if (v.type === 'stateful') {
+                    const spController = this.statefulParameters.get(k);
+                    const parsed = {
+                        ...v,
+                        controller: spController,
+                        nestedSettings: spController?.parsedSettings,
+                    };
+                    return [k, parsed];
+                }
+                if (v.type === 'array') {
+                    const parsed = {
+                        ...v,
+                        isElementEqual: resolveElementEqualsFn(v)
+                    };
+                    return [k, parsed];
+                }
+                return [k, v];
+            });
+            return Object.fromEntries(settings);
+        });
+    }
+    get defaultValues() {
+        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]));
+            const statefulParameterDefaultValues = Object.fromEntries(Object.entries(this.settings.parameterSettings)
+                .filter(([, v]) => v?.type === 'stateful')
+                .filter(([, v]) => v.definition.getSettings().default !== undefined)
+                .map(([k, v]) => [k, v.definition.getSettings().default]));
+            return { ...defaultValues, ...statefulParameterDefaultValues };
+        });
+    }
+    get inputTransformations() {
+        return this.getFromCacheOrCreate('inputTransformations', () => {
+            if (!this.settings.parameterSettings) {
+                return {};
+            }
+            return Object.fromEntries(Object.entries(this.settings.parameterSettings)
+                .filter(([_, v]) => resolveParameterTransformFn(v) !== undefined)
+                .map(([k, v]) => [k, resolveParameterTransformFn(v)]));
+        });
+    }
+    get statefulParameterOrder() {
+        return this.getFromCacheOrCreate('stateParameterOrder', () => {
+            const entries = Object.entries(this.settings.parameterSettings ?? {})
+                .filter(([, v]) => v?.type === 'stateful')
+                .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 matcher() {
+        return resolveMatcher(this);
+    }
+    validateSettings() {
+        // 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 (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.schema;
+        if (!this.settings.importAndDestroy && (schema?.oneOf
+            && Array.isArray(schema.oneOf)
+            && schema.oneOf.some((s) => s.required))
+            || (schema?.anyOf
+                && Array.isArray(schema.anyOf)
+                && schema.anyOf.some((s) => s.required))
+            || (schema?.allOf
+                && Array.isArray(schema.allOf)
+                && schema.allOf.some((s) => s.required))
+            || (schema?.then
+                && Array.isArray(schema.then)
+                && schema.then.some((s) => s.required))
+            || (schema?.else
+                && Array.isArray(schema.else)
+                && schema.else.some((s) => s.required))) {
+            throw new Error(`In the schema of ${this.settings.id}, a conditional required was declared (within anyOf, allOf, oneOf, else, or then) but an` +
+                'import.requiredParameters was not found in the resource settings. This is required because Codify uses the required parameter to' +
+                'determine the prompt to ask users during imports. It can\'t parse which parameters are needed when ' +
+                'required is declared conditionally.');
+        }
+        if (this.settings.importAndDestroy) {
+            const { requiredParameters, refreshKeys, defaultRefreshValues } = this.settings.importAndDestroy;
+            const requiredParametersNotInSchema = requiredParameters
+                ?.filter((p) => schema && !(schema.properties[p]));
+            if (schema && requiredParametersNotInSchema && requiredParametersNotInSchema.length > 0) {
+                throw new Error(`The following properties were declared in settings.import.requiredParameters but were not found in the schema:
+${JSON.stringify(requiredParametersNotInSchema, null, 2)}`);
+            }
+            const refreshKeyNotInSchema = refreshKeys
+                ?.filter((k) => schema && !(schema.properties[k]));
+            if (schema && refreshKeyNotInSchema && refreshKeyNotInSchema.length > 0) {
+                throw new Error(`The following properties were declared in settings.import.refreshKeys but were not found in the schema:
+${JSON.stringify(requiredParametersNotInSchema, null, 2)}`);
+            }
+            const refreshValueNotInRefreshKey = Object.entries(defaultRefreshValues ?? {})
+                .filter(([k]) => schema && !(schema.properties[k])).map(([k]) => k);
+            if (schema && refreshValueNotInRefreshKey.length > 0) {
+                throw new Error(`Properties declared in defaultRefreshValues must already be declared in refreshKeys:
+${JSON.stringify(refreshValueNotInRefreshKey, null, 2)}`);
+            }
+        }
+    }
+    validateParameterEqualsFn(parameter, key) {
+        if (parameter.type === 'stateful') {
+            const nestedSettings = parameter.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
+    }
+    getFromCacheOrCreate(key, create) {
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const result = create();
+        this.cache.set(key, result);
+        return result;
+    }
+}

package/dist/resource/resource-controller.d.ts

@@ -0,0 +1,36 @@
+import { Ajv, ValidateFunction } from 'ajv';
+import { ResourceConfig, ResourceJson, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
+import { Resource } from './resource.js';
+import { ResourceSettings } from './resource-settings.js';
+export declare class ResourceController<T extends StringIndexedObject> {
+    readonly resource: Resource<T>;
+    readonly settings: ResourceSettings<T>;
+    readonly parsedSettings: ParsedResourceSettings<T>;
+    readonly typeId: string;
+    readonly dependencies: string[];
+    protected ajv?: Ajv;
+    protected schemaValidator?: ValidateFunction;
+    constructor(resource: Resource<T>);
+    initialize(): Promise<void>;
+    validate(core: ResourceConfig, parameters: Partial<T>): Promise<ValidateResponseData['resourceValidations'][0]>;
+    match(resource: ResourceJson, array: Array<ResourceJson>): Promise<ResourceJson | undefined>;
+    plan(core: ResourceConfig, desired: Partial<T> | null, state: Partial<T> | null, isStateful?: boolean, commandType?: string): Promise<Plan<T>>;
+    planDestroy(core: ResourceConfig, parameters: Partial<T>): Promise<Plan<T>>;
+    apply(plan: Plan<T>): Promise<void>;
+    import(core: ResourceConfig, parameters: Partial<T>, autoSearchAll?: boolean): Promise<Array<ResourceJson> | null>;
+    private applyCreate;
+    private applyModify;
+    private applyDestroy;
+    private validateRefreshResults;
+    private applyTransformations;
+    private addDefaultValues;
+    private removeDefaultValues;
+    private refreshNonStatefulParameters;
+    private refreshStatefulParameters;
+    private validatePlanInputs;
+    private getSortedStatefulParameterChanges;
+    private getAllParameterKeys;
+    private getParametersToRefreshForImport;
+}

package/dist/resource/resource-controller.js

@@ -0,0 +1,402 @@
+import { Ajv } from 'ajv';
+import cleanDeep from 'clean-deep';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ConfigParser } from './config-parser.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
+export class ResourceController {
+    resource;
+    settings;
+    parsedSettings;
+    typeId;
+    dependencies;
+    ajv;
+    schemaValidator;
+    constructor(resource) {
+        this.resource = resource;
+        this.settings = resource.getSettings();
+        this.typeId = this.settings.id;
+        this.dependencies = this.settings.dependencies ?? [];
+        this.parsedSettings = new ParsedResourceSettings(this.settings);
+        if (this.parsedSettings.schema) {
+            this.ajv = new Ajv({
+                allErrors: true,
+                strict: true,
+                strictRequired: false,
+                allowUnionTypes: true
+            });
+            this.schemaValidator = this.ajv.compile(this.parsedSettings.schema);
+        }
+    }
+    async initialize() {
+        return this.resource.initialize();
+    }
+    async validate(core, parameters) {
+        const originalParameters = structuredClone(parameters);
+        await this.applyTransformations(parameters, undefined, true);
+        this.addDefaultValues(parameters);
+        if (this.schemaValidator) {
+            // Schema validator uses pre transformation parameters
+            const isValid = this.schemaValidator(
+            // @ts-expect-error Non esm package
+            cleanDeep(originalParameters, {
+                nullValues: true,
+                undefinedValues: true,
+                emptyArrays: false,
+                emptyStrings: false,
+                emptyObjects: false,
+                NaNValues: false
+            }));
+            if (!isValid) {
+                return {
+                    isValid: false,
+                    resourceName: core.name,
+                    resourceType: core.type,
+                    schemaValidationErrors: this.schemaValidator?.errors ?? [],
+                };
+            }
+        }
+        let isValid = true;
+        let customValidationErrorMessage;
+        try {
+            await this.resource.validate(parameters);
+        }
+        catch (error) {
+            isValid = false;
+            customValidationErrorMessage = error.message;
+        }
+        if (!isValid) {
+            return {
+                customValidationErrorMessage,
+                isValid: false,
+                resourceName: core.name,
+                resourceType: core.type,
+                schemaValidationErrors: this.schemaValidator?.errors ?? [],
+            };
+        }
+        return {
+            isValid: true,
+            resourceName: core.name,
+            resourceType: core.type,
+            schemaValidationErrors: [],
+        };
+    }
+    async match(resource, array) {
+        if (resource.core.type !== this.typeId) {
+            throw new Error(`Unknown type passed into match method: ${resource.core.type} for ${this.typeId}`);
+        }
+        if (!this.parsedSettings.allowMultiple) {
+            return array.find((r) => r.core.type === resource.core.type);
+        }
+        const { name, type } = resource.core;
+        const parameterMatcher = this.parsedSettings.matcher;
+        for (const resourceToMatch of array) {
+            if (type !== resourceToMatch.core.type) {
+                return undefined;
+            }
+            // If the user specifies the same name for the resource and it's not auto-generated (a number) then it's the same resource
+            if (name === resourceToMatch.core.name
+                && name
+                && Number.isInteger(Number.parseInt(name, 10))) {
+                return resourceToMatch;
+            }
+            const originalParams = structuredClone(resource.parameters);
+            const paramsToMatch = structuredClone(resourceToMatch.parameters);
+            this.addDefaultValues(originalParams);
+            await this.applyTransformations(originalParams);
+            this.addDefaultValues(paramsToMatch);
+            await this.applyTransformations(paramsToMatch);
+            const match = parameterMatcher(originalParams, paramsToMatch);
+            if (match) {
+                return resourceToMatch;
+            }
+        }
+    }
+    async plan(core, desired, state, isStateful = false, commandType = 'plan') {
+        this.validatePlanInputs(core, desired, state, isStateful);
+        const context = {
+            commandType: commandType,
+            isStateful,
+            originalDesiredConfig: structuredClone(desired),
+        };
+        this.addDefaultValues(desired);
+        await this.applyTransformations(desired);
+        this.addDefaultValues(state);
+        await this.applyTransformations(state);
+        // Parse data from the user supplied config
+        const parsedConfig = new ConfigParser(desired, state, this.parsedSettings.statefulParameters);
+        const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        // Refresh resource parameters. This refreshes the parameters that configure the resource itself
+        const currentArray = await this.refreshNonStatefulParameters(allNonStatefulParameters, context);
+        // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
+        if (currentArray === null
+            || currentArray === undefined
+            || currentArray.length === 0
+            || currentArray.filter(Boolean).length === 0) {
+            return Plan.calculate({
+                desired,
+                currentArray,
+                state,
+                core,
+                settings: this.parsedSettings,
+                isStateful,
+            });
+        }
+        // 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, allParameters);
+        return Plan.calculate({
+            desired,
+            currentArray: currentArray.map((c, idx) => ({ ...c, ...statefulCurrentParameters[idx] })),
+            state,
+            core,
+            settings: this.parsedSettings,
+            isStateful
+        });
+    }
+    async planDestroy(core, parameters) {
+        this.addDefaultValues(parameters);
+        await this.applyTransformations(parameters);
+        // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
+        const parametersToRefresh = this.settings.importAndDestroy?.refreshKeys
+            ? {
+                ...Object.fromEntries(this.settings.importAndDestroy?.refreshKeys.map((k) => [k, null])),
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
+                ...parameters,
+            }
+            : {
+                ...Object.fromEntries(this.getAllParameterKeys().map((k) => [k, null])),
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
+                ...parameters,
+            };
+        return this.plan(core, null, parametersToRefresh, true);
+    }
+    async apply(plan) {
+        if (plan.getResourceType() !== this.typeId) {
+            throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.typeId} but got: ${plan.getResourceType()}`);
+        }
+        switch (plan.changeSet.operation) {
+            case ResourceOperation.CREATE: {
+                return this.applyCreate(plan);
+            }
+            case ResourceOperation.MODIFY: {
+                return this.applyModify(plan);
+            }
+            case ResourceOperation.RECREATE: {
+                await this.applyDestroy(plan);
+                return this.applyCreate(plan);
+            }
+            case ResourceOperation.DESTROY: {
+                return this.applyDestroy(plan);
+            }
+        }
+    }
+    async import(core, parameters, autoSearchAll = false) {
+        if (this.settings.importAndDestroy?.preventImport) {
+            throw new Error(`Type: ${this.typeId} cannot be imported`);
+        }
+        const context = {
+            commandType: 'import',
+            isStateful: true,
+            originalDesiredConfig: structuredClone(parameters),
+        };
+        // Auto search means that no required parameters will be provided. We will try to generate it ourselves or return an
+        // empty array if they can't be.
+        if (autoSearchAll && this.settings.allowMultiple) {
+            if (this.settings.allowMultiple === true || !this.settings.allowMultiple.findAllParameters?.()) {
+                return [];
+            }
+            const parametersToImport = await this.settings.allowMultiple.findAllParameters?.();
+            const results = await Promise.all(parametersToImport.map((p) => this.import(core, p).catch(() => null)));
+            return results.filter(Boolean).flat();
+        }
+        this.addDefaultValues(parameters);
+        await this.applyTransformations(parameters);
+        // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
+        const parametersToRefresh = this.getParametersToRefreshForImport(parameters, context);
+        // Parse data from the user supplied config
+        const parsedConfig = new ConfigParser(parametersToRefresh, null, this.parsedSettings.statefulParameters);
+        const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters, context);
+        if (currentParametersArray === null
+            || currentParametersArray === undefined
+            || currentParametersArray.filter(Boolean).length === 0) {
+            return [];
+        }
+        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, currentParametersArray, allParameters);
+        const resultParametersArray = currentParametersArray
+            ?.map((r, idx) => ({ ...r, ...statefulCurrentParameters[idx] }));
+        for (const result of resultParametersArray) {
+            await this.applyTransformations(result, { original: context.originalDesiredConfig });
+            this.removeDefaultValues(result, parameters);
+        }
+        return resultParametersArray?.map((r) => ({ core, parameters: r }));
+    }
+    async applyCreate(plan) {
+        await this.resource.create(plan);
+        const statefulParameterChanges = this.getSortedStatefulParameterChanges(plan.changeSet.parameterChanges);
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.parsedSettings.statefulParameters.get(parameterChange.name);
+            await statefulParameter.add(parameterChange.newValue, plan);
+        }
+    }
+    async applyModify(plan) {
+        const parameterChanges = plan
+            .changeSet
+            .parameterChanges
+            .filter((c) => c.operation !== ParameterOperation.NOOP);
+        const statelessParameterChanges = parameterChanges
+            .filter((pc) => !this.parsedSettings.statefulParameters.has(pc.name));
+        for (const pc of statelessParameterChanges) {
+            await this.resource.modify(pc, plan);
+        }
+        const statefulParameterChanges = this.getSortedStatefulParameterChanges(plan.changeSet.parameterChanges);
+        for (const parameterChange of statefulParameterChanges) {
+            const statefulParameter = this.parsedSettings.statefulParameters.get(parameterChange.name);
+            switch (parameterChange.operation) {
+                case ParameterOperation.ADD: {
+                    await statefulParameter.add(parameterChange.newValue, plan);
+                    break;
+                }
+                case ParameterOperation.MODIFY: {
+                    await statefulParameter.modify(parameterChange.newValue, parameterChange.previousValue, plan);
+                    break;
+                }
+                case ParameterOperation.REMOVE: {
+                    await statefulParameter.remove(parameterChange.previousValue, plan);
+                    break;
+                }
+            }
+        }
+    }
+    async applyDestroy(plan) {
+        // If this option is set (defaults to false), then stateful parameters need to be destroyed
+        // as well. This means that the stateful parameter wouldn't have been normally destroyed with applyDestroy()
+        if (this.settings.removeStatefulParametersBeforeDestroy) {
+            const statefulParameterChanges = this.getSortedStatefulParameterChanges(plan.changeSet.parameterChanges);
+            for (const parameterChange of statefulParameterChanges) {
+                const statefulParameter = this.parsedSettings.statefulParameters.get(parameterChange.name);
+                await statefulParameter.remove(parameterChange.previousValue, plan);
+            }
+        }
+        await this.resource.destroy(plan);
+    }
+    validateRefreshResults(refresh) {
+        if (!refresh) {
+            return;
+        }
+        if (!this.settings.allowMultiple && refresh.length > 1) {
+            throw new Error(`Resource: ${this.settings.id}. Allow multiple was set to false but multiple refresh results were returned.
+
+${JSON.stringify(refresh, null, 2)}     
+`);
+        }
+    }
+    async applyTransformations(config, reverse, skipConfigTransformation = false) {
+        if (!config) {
+            return;
+        }
+        for (const [key, inputTransformation] of Object.entries(this.parsedSettings.inputTransformations)) {
+            if (config[key] === undefined || !inputTransformation) {
+                continue;
+            }
+            config[key] = reverse
+                ? await inputTransformation.from(config[key], reverse.original?.[key])
+                : await inputTransformation.to(config[key]);
+        }
+        if (this.settings.transformation && !skipConfigTransformation) {
+            const transformed = reverse
+                ? await this.settings.transformation.from({ ...config }, reverse.original)
+                : await this.settings.transformation.to({ ...config });
+            Object.keys(config).forEach((k) => delete config[k]);
+            Object.assign(config, transformed);
+        }
+    }
+    addDefaultValues(config) {
+        if (!config) {
+            return;
+        }
+        for (const [key, defaultValue] of Object.entries(this.parsedSettings.defaultValues)) {
+            if (defaultValue !== undefined && (config[key] === undefined || config[key] === null)) {
+                config[key] = defaultValue;
+            }
+        }
+    }
+    removeDefaultValues(newConfig, originalConfig) {
+        if (!newConfig) {
+            return;
+        }
+        for (const [key, defaultValue] of Object.entries(this.parsedSettings.defaultValues)) {
+            if (defaultValue !== undefined && (newConfig[key] === defaultValue || originalConfig[key] === undefined || originalConfig[key] === null)) {
+                delete newConfig[key];
+            }
+        }
+    }
+    async refreshNonStatefulParameters(resourceParameters, context) {
+        const result = await this.resource.refresh(resourceParameters, context);
+        const currentParametersArray = Array.isArray(result) || result === null
+            ? result
+            : [result];
+        this.validateRefreshResults(currentParametersArray);
+        return currentParametersArray;
+    }
+    // Refresh stateful parameters
+    // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
+    async refreshStatefulParameters(statefulParametersConfig, currentArray, allParameters) {
+        const result = Array.from({ length: currentArray.length }, () => ({}));
+        const sortedEntries = Object.entries(statefulParametersConfig)
+            .sort(([key1], [key2]) => this.parsedSettings.statefulParameterOrder.get(key1) - this.parsedSettings.statefulParameterOrder.get(key2));
+        for (const [idx, refreshedParams] of currentArray.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, { ...allParameters, ...refreshedParams });
+            }));
+        }
+        return result;
+    }
+    validatePlanInputs(core, desired, current, isStateful) {
+        if (!core || !core.type) {
+            throw new Error('Core parameters type must be defined');
+        }
+        if (!desired && !current) {
+            throw new Error('Desired config and current config cannot both be missing');
+        }
+        if (!isStateful && !desired) {
+            throw new Error('Desired config must be provided in non-stateful mode');
+        }
+    }
+    getSortedStatefulParameterChanges(parameterChanges) {
+        return parameterChanges
+            .filter((pc) => this.parsedSettings.statefulParameters.has(pc.name))
+            .sort((a, b) => this.parsedSettings.statefulParameterOrder.get(a.name) - this.parsedSettings.statefulParameterOrder.get(b.name));
+    }
+    getAllParameterKeys() {
+        return this.parsedSettings.schema
+            ? Object.keys(this.parsedSettings.schema?.properties)
+            : Object.keys(this.parsedSettings.parameterSettings);
+    }
+    getParametersToRefreshForImport(parameters, context) {
+        if (this.settings.importAndDestroy?.refreshMapper) {
+            return this.settings.importAndDestroy?.refreshMapper(parameters, context);
+        }
+        return this.settings.importAndDestroy?.refreshKeys
+            ? {
+                ...Object.fromEntries(this.settings.importAndDestroy?.refreshKeys.map((k) => [k, null])),
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
+                ...parameters,
+                ...(Object.fromEntries(// If a default value was used, but it was also declared in the defaultRefreshValues, prefer the defaultRefreshValue instead
+                Object.entries(parameters).filter(([k, v]) => this.parsedSettings.defaultValues[k] !== undefined
+                    && v === this.parsedSettings.defaultValues[k]
+                    && context.originalDesiredConfig?.[k] === undefined
+                    && this.settings.importAndDestroy?.defaultRefreshValues?.[k] !== undefined).map(([k]) => [k, this.settings.importAndDestroy.defaultRefreshValues[k]])))
+            }
+            : {
+                ...Object.fromEntries(this.getAllParameterKeys().map((k) => [k, null])),
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
+                ...parameters,
+            };
+    }
+}