codify-plugin-lib 1.0.128 → 1.0.130

package/dist/plan/plan.d.ts

@@ -16,8 +16,8 @@ export declare class Plan<T extends StringIndexedObject> {
      * Ex: name, type, dependsOn etc. Metadata parameters
      */
     coreParameters: ResourceConfig;
-    statefulMode: boolean;
-    constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig, statefulMode: boolean);
+    isStateful: boolean;
+    constructor(id: string, changeSet: ChangeSet<T>, coreParameters: ResourceConfig, isStateful: boolean);
     /**
      * The desired config that a plan will achieve after executing all the actions.
      */
@@ -28,13 +28,20 @@ export declare class Plan<T extends StringIndexedObject> {
     get currentConfig(): T | null;
     get resourceId(): string;
     static calculate<T extends StringIndexedObject>(params: {
-        desiredParameters: Partial<T> | null;
-        currentParametersArray: Partial<T>[] | null;
-        stateParameters: Partial<T> | null;
-        coreParameters: ResourceConfig;
+        desired: Partial<T> | null;
+        currentArray: Partial<T>[] | null;
+        state: Partial<T> | null;
+        core: ResourceConfig;
         settings: ParsedResourceSettings<T>;
-        statefulMode: boolean;
+        isStateful: boolean;
     }): Plan<T>;
+    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
+    /**
+     * The type (id) of the resource
+     *
+     * @return string
+     */
+    getResourceType(): string;
     /**
      * When multiples of the same resource are allowed, this matching function will match a given config with one of the
      * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
@@ -44,13 +51,6 @@ export declare class Plan<T extends StringIndexedObject> {
      * @private
      */
     private static matchCurrentParameters;
-    /**
-     * The type (id) of the resource
-     *
-     * @return string
-     */
-    getResourceType(): string;
-    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
      *  defined.

package/dist/plan/plan.js

@@ -16,12 +16,12 @@ export class Plan {
      * Ex: name, type, dependsOn etc. Metadata parameters
      */
     coreParameters;
-    statefulMode;
-    constructor(id, changeSet, resourceMetadata, statefulMode) {
+    isStateful;
+    constructor(id, changeSet, coreParameters, isStateful) {
         this.id = id;
         this.changeSet = changeSet;
-        this.coreParameters = resourceMetadata;
-        this.statefulMode = statefulMode;
+        this.coreParameters = coreParameters;
+        this.isStateful = isStateful;
     }
     /**
      * The desired config that a plan will achieve after executing all the actions.
@@ -30,10 +30,7 @@ export class Plan {
         if (this.changeSet.operation === ResourceOperation.DESTROY) {
             return null;
         }
-        return {
-            ...this.coreParameters,
-            ...this.changeSet.desiredParameters,
-        };
+        return this.changeSet.desiredParameters;
     }
     /**
      * The current config that the plan is changing.
@@ -42,10 +39,7 @@ export class Plan {
         if (this.changeSet.operation === ResourceOperation.CREATE) {
             return null;
         }
-        return {
-            ...this.coreParameters,
-            ...this.changeSet.currentParameters,
-        };
+        return this.changeSet.currentParameters;
     }
     get resourceId() {
         return this.coreParameters.name
@@ -53,67 +47,36 @@ export class Plan {
             : this.coreParameters.type;
     }
     static calculate(params) {
-        const { desiredParameters, currentParametersArray, stateParameters, coreParameters, settings, statefulMode } = params;
-        const currentParameters = Plan.matchCurrentParameters({
-            desiredParameters,
-            currentParametersArray,
-            stateParameters,
+        const { desired, currentArray, state, core, settings, isStateful } = params;
+        const current = Plan.matchCurrentParameters({
+            desired,
+            currentArray,
+            state,
             settings,
-            statefulMode
+            isStateful
         });
         const filteredCurrentParameters = Plan.filterCurrentParams({
-            desiredParameters,
-            currentParameters,
-            stateParameters,
+            desired,
+            current,
+            state,
             settings,
-            statefulMode
+            isStateful
         });
         // Empty
-        if (!filteredCurrentParameters && !desiredParameters) {
-            return new Plan(uuidV4(), ChangeSet.empty(), coreParameters, statefulMode);
+        if (!filteredCurrentParameters && !desired) {
+            return new Plan(uuidV4(), ChangeSet.empty(), core, isStateful);
         }
         // CREATE
-        if (!filteredCurrentParameters && desiredParameters) {
-            return new Plan(uuidV4(), ChangeSet.create(desiredParameters), coreParameters, statefulMode);
+        if (!filteredCurrentParameters && desired) {
+            return new Plan(uuidV4(), ChangeSet.create(desired), core, isStateful);
         }
         // DESTROY
-        if (filteredCurrentParameters && !desiredParameters) {
-            return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters), coreParameters, statefulMode);
+        if (filteredCurrentParameters && !desired) {
+            return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters), core, isStateful);
         }
         // NO-OP, MODIFY or RE-CREATE
-        const changeSet = ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
-        return new Plan(uuidV4(), changeSet, coreParameters, statefulMode);
-    }
-    /**
-     * When multiples of the same resource are allowed, this matching function will match a given config with one of the
-     * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
-     * the application name and location to match it to our desired configs name and location.
-     *
-     * @param params
-     * @private
-     */
-    static matchCurrentParameters(params) {
-        const { desiredParameters, currentParametersArray, stateParameters, settings, statefulMode } = params;
-        if (!settings.allowMultiple) {
-            return currentParametersArray?.[0] ?? null;
-        }
-        if (!currentParametersArray) {
-            return null;
-        }
-        if (statefulMode) {
-            return stateParameters
-                ? settings.allowMultiple.matcher(stateParameters, currentParametersArray)
-                : null;
-        }
-        return settings.allowMultiple.matcher(desiredParameters, currentParametersArray);
-    }
-    /**
-     * The type (id) of the resource
-     *
-     * @return string
-     */
-    getResourceType() {
-        return this.coreParameters.type;
+        const changeSet = ChangeSet.calculateModification(desired, filteredCurrentParameters, settings.parameterSettings);
+        return new Plan(uuidV4(), changeSet, core, isStateful);
     }
     //   2. Even if there was (maybe for testing reasons), the plan values should not be adjusted
     static fromResponse(data, defaultValues) {
@@ -124,7 +87,7 @@ export class Plan {
         return new Plan(uuidV4(), new ChangeSet(data.operation, data.parameters), {
             type: data.resourceType,
             name: data.resourceName,
-        }, data.statefulMode);
+        }, data.isStateful);
         function addDefaultValues() {
             Object.entries(defaultValues ?? {})
                 .forEach(([key, defaultValue]) => {
@@ -169,6 +132,37 @@ export class Plan {
             });
         }
     }
+    /**
+     * The type (id) of the resource
+     *
+     * @return string
+     */
+    getResourceType() {
+        return this.coreParameters.type;
+    }
+    /**
+     * When multiples of the same resource are allowed, this matching function will match a given config with one of the
+     * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
+     * the application name and location to match it to our desired configs name and location.
+     *
+     * @param params
+     * @private
+     */
+    static matchCurrentParameters(params) {
+        const { desired, currentArray, state, settings, isStateful } = params;
+        if (!settings.allowMultiple) {
+            return currentArray?.[0] ?? null;
+        }
+        if (!currentArray) {
+            return null;
+        }
+        if (isStateful) {
+            return state
+                ? settings.allowMultiple.matcher(state, currentArray)
+                : null;
+        }
+        return settings.allowMultiple.matcher(desired, currentArray);
+    }
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
      *  defined.
@@ -178,7 +172,7 @@ export class Plan {
      *  or wants to set. If a parameter is not specified then it's not managed by Codify.
      */
     static filterCurrentParams(params) {
-        const { desiredParameters: desired, currentParameters: current, stateParameters: state, settings, statefulMode } = params;
+        const { desired, current, state, settings, isStateful } = params;
         if (!current) {
             return null;
         }
@@ -188,7 +182,7 @@ export class Plan {
         }
         // For stateful mode, we're done after filtering by the keys of desired + state. Stateless mode
         // requires additional filtering for stateful parameter arrays and objects.
-        if (statefulMode) {
+        if (isStateful) {
             return filteredCurrent;
         }
         // TODO: Add object handling here in addition to arrays in the future
@@ -200,7 +194,7 @@ export class Plan {
             if (!current) {
                 return null;
             }
-            if (statefulMode) {
+            if (isStateful) {
                 const keys = new Set([...Object.keys(state ?? {}), ...Object.keys(desired ?? {})]);
                 return Object.fromEntries(Object.entries(current)
                     .filter(([k]) => keys.has(k)));
@@ -276,7 +270,7 @@ export class Plan {
         return {
             planId: this.id,
             operation: this.changeSet.operation,
-            statefulMode: this.statefulMode,
+            isStateful: this.isStateful,
             resourceName: this.coreParameters.name,
             resourceType: this.coreParameters.type,
             parameters: this.changeSet.parameterChanges,

package/dist/plugin/plugin.d.ts

@@ -1,4 +1,4 @@
-import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
+import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ResourceJson, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
 import { BackgroundPty } from '../pty/background-pty.js';
 import { Resource } from '../resource/resource.js';
@@ -18,5 +18,5 @@ export declare class Plugin {
     apply(data: ApplyRequestData): Promise<void>;
     kill(): Promise<void>;
     private resolvePlan;
-    protected crossValidateResources(configs: ResourceConfig[]): Promise<void>;
+    protected crossValidateResources(resources: ResourceJson[]): Promise<void>;
 }

package/dist/plugin/plugin.js

@@ -52,26 +52,28 @@ export class Plugin {
         };
     }
     async import(data) {
-        if (!this.resourceControllers.has(data.config.type)) {
-            throw new Error(`Cannot get info for resource ${data.config.type}, resource doesn't exist`);
+        const { core, parameters } = data;
+        if (!this.resourceControllers.has(core.type)) {
+            throw new Error(`Cannot get info for resource ${core.type}, resource doesn't exist`);
         }
         const result = await ptyLocalStorage.run(this.planPty, () => this.resourceControllers
-            .get(data.config.type)
-            ?.import(data.config));
+            .get(core.type)
+            ?.import(core, parameters));
         return {
-            request: data.config,
+            request: data,
             result: result ?? [],
         };
     }
     async validate(data) {
         const validationResults = [];
         for (const config of data.configs) {
-            if (!this.resourceControllers.has(config.type)) {
-                throw new Error(`Resource type not found: ${config.type}`);
+            const { core, parameters } = config;
+            if (!this.resourceControllers.has(core.type)) {
+                throw new Error(`Resource type not found: ${core.type}`);
             }
             const validation = await this.resourceControllers
-                .get(config.type)
-                .validate(config);
+                .get(core.type)
+                .validate(core, parameters);
             validationResults.push(validation);
         }
         await this.crossValidateResources(data.configs);
@@ -80,11 +82,11 @@ export class Plugin {
         };
     }
     async plan(data) {
-        const type = data.desired?.type ?? data.state?.type;
-        if (!type || !this.resourceControllers.has(type)) {
+        const { type } = data.core;
+        if (!this.resourceControllers.has(type)) {
             throw new Error(`Resource type not found: ${type}`);
         }
-        const plan = await ptyLocalStorage.run(this.planPty, async () => this.resourceControllers.get(type).plan(data.desired ?? null, data.state ?? null, data.isStateful));
+        const plan = await ptyLocalStorage.run(this.planPty, async () => this.resourceControllers.get(type).plan(data.core, data.desired ?? null, data.state ?? null, data.isStateful));
         this.planStorage.set(plan.id, plan);
         return plan.toResponse();
     }
@@ -101,7 +103,7 @@ export class Plugin {
         // Validate using desired/desired. If the apply was successful, no changes should be reported back.
         // Default back desired back to current if it is not defined (for destroys only)
         const validationPlan = await ptyLocalStorage.run(new BackgroundPty(), async () => {
-            const result = await resource.plan(plan.desiredConfig, plan.desiredConfig ?? plan.currentConfig, plan.statefulMode);
+            const result = await resource.plan(plan.coreParameters, plan.desiredConfig, plan.desiredConfig ?? plan.currentConfig, plan.isStateful);
             await getPty().kill();
             return result;
         });
@@ -126,5 +128,6 @@ export class Plugin {
         const resource = this.resourceControllers.get(planRequest.resourceType);
         return Plan.fromResponse(planRequest, resource.parsedSettings.defaultValues);
     }
-    async crossValidateResources(configs) { }
+    async crossValidateResources(resources) {
+    }
 }

package/dist/resource/config-parser.d.ts

@@ -1,13 +1,10 @@
-import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { StringIndexedObject } from 'codify-schemas';
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 export declare class ConfigParser<T extends StringIndexedObject> {
     private readonly desiredConfig;
     private readonly stateConfig;
     private statefulParametersMap;
-    constructor(desiredConfig: Partial<T> & ResourceConfig | null, stateConfig: Partial<T> & ResourceConfig | null, statefulParameters: Map<keyof T, StatefulParameterController<T, T[keyof T]>>);
-    get coreParameters(): ResourceConfig;
-    get desiredParameters(): Partial<T> | null;
-    get stateParameters(): Partial<T> | null;
+    constructor(desiredConfig: Partial<T> | null, stateConfig: Partial<T> | null, statefulParameters: Map<keyof T, StatefulParameterController<T, T[keyof T]>>);
     get allParameters(): Partial<T>;
     get allNonStatefulParameters(): Partial<T>;
     get allStatefulParameters(): Partial<T>;

package/dist/resource/config-parser.js

@@ -1,4 +1,3 @@
-import { splitUserConfig } from '../utils/utils.js';
 export class ConfigParser {
     desiredConfig;
     stateConfig;
@@ -8,34 +7,8 @@ export class ConfigParser {
         this.stateConfig = stateConfig;
         this.statefulParametersMap = statefulParameters;
     }
-    get coreParameters() {
-        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() {
-        if (!this.desiredConfig) {
-            return null;
-        }
-        const { parameters } = splitUserConfig(this.desiredConfig);
-        return parameters;
-    }
-    get stateParameters() {
-        if (!this.stateConfig) {
-            return null;
-        }
-        const { parameters } = splitUserConfig(this.stateConfig);
-        return parameters;
-    }
     get allParameters() {
-        return { ...this.desiredParameters, ...this.stateParameters };
+        return { ...this.desiredConfig, ...this.stateConfig };
     }
     get allNonStatefulParameters() {
         const { allParameters, statefulParametersMap, } = this;

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

@@ -1,5 +1,5 @@
 import { Ajv, ValidateFunction } from 'ajv';
-import { ResourceConfig, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
+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';
@@ -14,10 +14,10 @@ export declare class ResourceController<T extends StringIndexedObject> {
     protected schemaValidator?: ValidateFunction;
     constructor(resource: Resource<T>);
     initialize(): Promise<void>;
-    validate(desiredConfig: Partial<T> & ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
-    plan(desiredConfig: Partial<T> & ResourceConfig | null, stateConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
+    validate(core: ResourceConfig, parameters: Partial<T>): Promise<ValidateResponseData['resourceValidations'][0]>;
+    plan(core: ResourceConfig, desired: Partial<T> | null, state: Partial<T> | null, isStateful?: boolean): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
-    import(config: Partial<T> & ResourceConfig): Promise<(Partial<T> & ResourceConfig)[] | null>;
+    import(core: ResourceConfig, parameters: Partial<T>): Promise<Array<ResourceJson> | null>;
     private applyCreate;
     private applyModify;
     private applyDestroy;

package/dist/resource/resource-controller.js

@@ -1,7 +1,6 @@
 import { Ajv } from 'ajv';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
-import { splitUserConfig } from '../utils/utils.js';
 import { ConfigParser } from './config-parser.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
 export class ResourceController {
@@ -31,19 +30,17 @@ export class ResourceController {
     async initialize() {
         return this.resource.initialize();
     }
-    async validate(desiredConfig) {
-        const configToValidate = { ...desiredConfig };
-        await this.applyTransformParameters(configToValidate);
-        const { parameters, coreParameters } = splitUserConfig(configToValidate);
+    async validate(core, parameters) {
+        await this.applyTransformParameters(parameters);
         this.addDefaultValues(parameters);
         if (this.schemaValidator) {
             // Schema validator uses pre transformation parameters
-            const isValid = this.schemaValidator(splitUserConfig(desiredConfig).parameters);
+            const isValid = this.schemaValidator(parameters);
             if (!isValid) {
                 return {
                     isValid: false,
-                    resourceName: coreParameters.name,
-                    resourceType: coreParameters.type,
+                    resourceName: core.name,
+                    resourceType: core.type,
                     schemaValidationErrors: this.schemaValidator?.errors ?? [],
                 };
             }
@@ -61,54 +58,54 @@ export class ResourceController {
             return {
                 customValidationErrorMessage,
                 isValid: false,
-                resourceName: coreParameters.name,
-                resourceType: coreParameters.type,
+                resourceName: core.name,
+                resourceType: core.type,
                 schemaValidationErrors: this.schemaValidator?.errors ?? [],
             };
         }
         return {
             isValid: true,
-            resourceName: coreParameters.name,
-            resourceType: coreParameters.type,
+            resourceName: core.name,
+            resourceType: core.type,
             schemaValidationErrors: [],
         };
     }
-    async plan(desiredConfig, stateConfig = null, statefulMode = false) {
-        this.validatePlanInputs(desiredConfig, stateConfig, statefulMode);
-        this.addDefaultValues(desiredConfig);
-        await this.applyTransformParameters(desiredConfig);
-        this.addDefaultValues(stateConfig);
-        await this.applyTransformParameters(stateConfig);
+    async plan(core, desired, state, isStateful = false) {
+        this.validatePlanInputs(core, desired, state, isStateful);
+        this.addDefaultValues(desired);
+        await this.applyTransformParameters(desired);
+        this.addDefaultValues(state);
+        await this.applyTransformParameters(state);
         // Parse data from the user supplied config
-        const parsedConfig = new ConfigParser(desiredConfig, stateConfig, this.parsedSettings.statefulParameters);
-        const { coreParameters, desiredParameters, stateParameters, allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        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 currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
+        const currentArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
         // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
-        if (currentParametersArray === null
-            || currentParametersArray === undefined
+        if (currentArray === null
+            || currentArray === undefined
             || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
-            || currentParametersArray.length === 0
-            || currentParametersArray.filter(Boolean).length === 0) {
+            || currentArray.length === 0
+            || currentArray.filter(Boolean).length === 0) {
             return Plan.calculate({
-                desiredParameters,
-                currentParametersArray,
-                stateParameters,
-                coreParameters,
+                desired,
+                currentArray,
+                state,
+                core,
                 settings: this.parsedSettings,
-                statefulMode,
+                isStateful,
             });
         }
         // Refresh stateful parameters. These parameters have state external to the resource. allowMultiple
         // does not work together with stateful parameters
         const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, allParameters);
         return Plan.calculate({
-            desiredParameters,
-            currentParametersArray: [{ ...currentParametersArray[0], ...statefulCurrentParameters }],
-            stateParameters,
-            coreParameters,
+            desired,
+            currentArray: [{ ...currentArray[0], ...statefulCurrentParameters }],
+            state,
+            core,
             settings: this.parsedSettings,
-            statefulMode
+            isStateful
         });
     }
     async apply(plan) {
@@ -131,36 +128,35 @@ export class ResourceController {
             }
         }
     }
-    async import(config) {
-        this.addDefaultValues(config);
-        await this.applyTransformParameters(config);
+    async import(core, parameters) {
+        this.addDefaultValues(parameters);
+        await this.applyTransformParameters(parameters);
         // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
         const parametersToRefresh = this.settings.import?.refreshKeys
             ? {
                 ...Object.fromEntries(this.settings.import?.refreshKeys.map((k) => [k, null])),
                 ...this.settings.import?.defaultRefreshValues,
-                ...config,
+                ...parameters,
             }
             : {
                 ...Object.fromEntries(this.getAllParameterKeys().map((k) => [k, null])),
                 ...this.settings.import?.defaultRefreshValues,
-                ...config,
+                ...parameters,
             };
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(parametersToRefresh, null, this.parsedSettings.statefulParameters);
-        const { allNonStatefulParameters, allStatefulParameters, coreParameters, } = parsedConfig;
+        const { allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
         const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
         if (currentParametersArray === null
             || currentParametersArray === undefined
             || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
-            || currentParametersArray.length === 0
             || currentParametersArray.filter(Boolean).length === 0) {
             return currentParametersArray
-                ?.map((r) => ({ ...coreParameters, ...r }))
+                ?.map((r) => ({ core, parameters: r }))
                 ?? null;
         }
         const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, parametersToRefresh);
-        return [{ ...coreParameters, ...currentParametersArray[0], ...statefulCurrentParameters }];
+        return [{ core, parameters: { ...currentParametersArray[0], ...statefulCurrentParameters } }];
     }
     async applyCreate(plan) {
         await this.resource.create(plan);
@@ -233,10 +229,9 @@ ${JSON.stringify(refresh, null, 2)}
             config[key] = await inputTransformation(config[key], this.settings.parameterSettings[key]);
         }
         if (this.settings.inputTransformation) {
-            const { parameters, coreParameters } = splitUserConfig(config);
-            const transformed = await this.settings.inputTransformation(parameters);
+            const transformed = await this.settings.inputTransformation({ ...config });
             Object.keys(config).forEach((k) => delete config[k]);
-            Object.assign(config, transformed, coreParameters);
+            Object.assign(config, transformed);
         }
     }
     addDefaultValues(config) {
@@ -272,11 +267,14 @@ ${JSON.stringify(refresh, null, 2)}
         }));
         return result;
     }
-    validatePlanInputs(desired, current, statefulMode) {
+    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 (!statefulMode && !desired) {
+        if (!isStateful && !desired) {
             throw new Error('Desired config must be provided in non-stateful mode');
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.128",
+  "version": "1.0.130",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.58",
+    "codify-schemas": "1.0.61",
     "@npmcli/promise-spawn": "^7.0.1",
     "@homebridge/node-pty-prebuilt-multiarch": "^0.12.0-beta.5",
     "uuid": "^10.0.0",

package/src/common/errors.test.ts

@@ -12,7 +12,7 @@ describe('Test file for errors file', () => {
         type: 'homebrew',
         name: 'first'
       },
-      statefulMode: true,
+      isStateful: true,
     })
 
     try {