codify-plugin-lib 1.0.75 → 1.0.77

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

@@ -0,0 +1,164 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings(): ParameterSetting;
+    /**
+     * Refresh the status of the stateful parameter on the system. This method works similarly to {@link Resource.refresh}.
+     * Return the value of the stateful parameter or null if not found.
+     *
+     * @param desired The desired value of the user.
+     *
+     * @return The value of the stateful parameter currently on the system or null if not found
+     */
+    abstract refresh(desired: V | null): Promise<V | null>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.create} except that its only
+     * applicable to the stateful parameter. For resource `CREATE` operations, this method will be called after the
+     * resource is successfully created. The add method is called when a ParameterChange is ADD in a plan. The add
+     * method is only called when the stateful parameter does not currently exist.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Add is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Add handles the request by calling `brew install --formulae jq jenv`
+     *
+     * @param valueToAdd The desired value of the stateful parameter.
+     * @param plan The overall plan that contains the ADD
+     */
+    abstract add(valueToAdd: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Modify the state of a stateful parameter on the system. This method is similar to {@link Resource.modify} except that its only
+     * applicable to the stateful parameter.
+     *
+     * **Example (Git email parameter):**
+     * 1. Add is called with a value of:
+     * ```
+     * newValue: 'email+new@gmail.com', previousValue: 'email+old@gmail.com'
+     * ```
+     * 2. Modify handles the request by calling `git config --global user.email email+new@gmail.com`
+     *
+     * @param newValue The desired value of the stateful parameter
+     * @param previousValue The current value of the stateful parameter
+     * @param plan The overall plan
+     */
+    abstract modify(newValue: V, previousValue: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.destroy} except that its only
+     * applicable to the stateful parameter. The remove method is only called when the stateful parameter already currently exist.
+     * This method corresponds to REMOVE parameter operations in a plan.
+     * For resource `DESTORY`, this method is only called if the {@link ResourceSettings.removeStatefulParametersBeforeDestroy}
+     * is set to true. This method will be called before the resource is destroyed.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Remove is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Remove handles the request by calling `brew uninstall --formulae jq jenv`
+     *
+     * @param valueToRemove The value to remove from the stateful parameter.
+     * @param plan The overall plan that contains the REMOVE
+     */
+    abstract remove(valueToRemove: V, plan: Plan<T>): Promise<void>;
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings(): ArrayParameterSetting;
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    add(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    modify(newValues: V[], previousValues: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    remove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * See {@link StatefulParameter.refresh} for more info.
+     *
+     * @param desired The desired value to refresh
+     * @return The current value on the system or null if not found.
+     */
+    abstract refresh(desired: V[] | null): Promise<V[] | null>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be added. See {@link StatefulParameter.add}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `addItem` for each element
+     * 3. Override addItem and install each formula using `brew install --formula jq`
+     *
+     * @param item The item to add (install)
+     * @param plan The overall plan
+     */
+    abstract addItem(item: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be removed. See {@link StatefulParameter.remove}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `removeItem` for each element
+     * 3. Override removeItem and uninstall each formula using `brew uninstall --formula jq`
+     *
+     * @param item The item to remove (uninstall)
+     * @param plan The overall plan
+     */
+    abstract removeItem(item: V, plan: Plan<T>): Promise<void>;
+}

package/dist/resource/stateful-parameter.js

@@ -0,0 +1,94 @@
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export class StatefulParameter {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings() {
+        return {};
+    }
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export class ArrayStatefulParameter extends StatefulParameter {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings() {
+        return { type: 'array' };
+    }
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async add(valuesToAdd, plan) {
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    async modify(newValues, previousValues, plan) {
+        // TODO: I don't think this works with duplicate elements. Solve at another time
+        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+            if (this.getSettings()?.isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+            if (this.getSettings().isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async remove(valuesToRemove, plan) {
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+}

package/dist/utils/utils.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
-import { SpawnOptions } from 'child_process';
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { SpawnOptions } from 'node:child_process';
+import { ArrayParameterSetting } from '../resource/resource-settings.js';
 export declare enum SpawnStatus {
     SUCCESS = "success",
     ERROR = "error"
@@ -13,13 +14,28 @@ type CodifySpawnOptions = {
     cwd?: string;
     stdioString?: boolean;
 } & SpawnOptions;
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param args Optional additional arguments to append
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ * @param extras From PromiseSpawn
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
 export declare function codifySpawn(cmd: string, args?: string[], opts?: Omit<CodifySpawnOptions, 'stdio' | 'stdioString'> & {
     throws?: boolean;
 }, extras?: Record<any, any>): Promise<SpawnResult>;
 export declare function isDebug(): boolean;
-export declare function splitUserConfig<T extends StringIndexedObject>(config: T & ResourceConfig): {
+export declare function splitUserConfig<T extends StringIndexedObject>(config: ResourceConfig & T): {
     parameters: T;
-    resourceMetadata: ResourceConfig;
+    coreParameters: ResourceConfig;
 };
 export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
+export declare function untildify(pathWithTilde: string): string;
+export declare function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown): boolean;
 export {};

package/dist/utils/utils.js

@@ -1,11 +1,27 @@
 import promiseSpawn from '@npmcli/promise-spawn';
+import os from 'node:os';
 export var SpawnStatus;
 (function (SpawnStatus) {
     SpawnStatus["SUCCESS"] = "success";
     SpawnStatus["ERROR"] = "error";
 })(SpawnStatus || (SpawnStatus = {}));
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param args Optional additional arguments to append
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ * @param extras From PromiseSpawn
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
 export async function codifySpawn(cmd, args, opts, extras) {
     try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
         const result = await promiseSpawn(cmd, args ?? [], { ...opts, stdio: 'pipe', stdioString: true, shell: opts?.shell ?? process.env.SHELL }, extras);
         if (isDebug()) {
             console.log(`codifySpawn result for: ${cmd}`);
@@ -34,20 +50,53 @@ export async function codifySpawn(cmd, args, opts, extras) {
     }
 }
 export function isDebug() {
-    return process.env.DEBUG != null && process.env.DEBUG.includes('codify');
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
 }
 export function splitUserConfig(config) {
-    const resourceMetadata = {
+    const coreParameters = {
         type: config.type,
         ...(config.name ? { name: config.name } : {}),
         ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
     };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { type, name, dependsOn, ...parameters } = config;
     return {
         parameters: parameters,
-        resourceMetadata,
+        coreParameters,
     };
 }
 export function setsEqual(set1, set2) {
     return set1.size === set2.size && [...set1].every((v) => set2.has(v));
 }
+const homeDirectory = os.homedir();
+export function untildify(pathWithTilde) {
+    return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+export function areArraysEqual(parameter, desired, current) {
+    if (!Array.isArray(desired) || !Array.isArray(current)) {
+        throw new Error(`A non-array value:
+          
+Desired: ${JSON.stringify(desired, null, 2)}
+
+Current: ${JSON.stringify(desired, null, 2)}
+
+Was provided even though type array was specified.
+`);
+    }
+    if (desired.length !== current.length) {
+        return false;
+    }
+    const desiredCopy = [...desired];
+    const currentCopy = [...current];
+    // Algorithm for to check equality between two un-ordered; un-hashable arrays using
+    // an isElementEqual method. Time: O(n^2)
+    for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+        const idx = currentCopy.findIndex((e2) => (parameter.isElementEqual ?? ((a, b) => a === b))(desiredCopy[counter], e2));
+        if (idx === -1) {
+            return false;
+        }
+        desiredCopy.splice(counter, 1);
+        currentCopy.splice(idx, 1);
+    }
+    return currentCopy.length === 0;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.75",
-  "description": "",
+  "version": "1.0.77",
+  "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "type": "module",
@@ -14,8 +14,9 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.44",
-    "@npmcli/promise-spawn": "^7.0.1"
+    "codify-schemas": "1.0.45",
+    "@npmcli/promise-spawn": "^7.0.1",
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@oclif/prettier-config": "^0.2.1",
@@ -24,6 +25,7 @@
     "@types/node": "^18",
     "@types/semver": "^7.5.4",
     "@types/sinon": "^17.0.3",
+    "@types/uuid": "^10.0.0",
     "chai-as-promised": "^7.1.1",
     "vitest": "^1.4.0",
     "vitest-mock-extended": "^1.3.1",

package/src/index.ts

@@ -1,16 +1,15 @@
-import { Plugin } from './entities/plugin.js';
 import { MessageHandler } from './messages/handlers.js';
+import { Plugin } from './plugin/plugin.js';
 
-export * from './entities/resource.js'
-export * from './entities/resource-types.js'
-export * from './entities/resource-options.js'
-export * from './entities/plugin.js'
-export * from './entities/change-set.js'
-export * from './entities/plan.js'
-export * from './entities/plan-types.js'
-export * from './entities/stateful-parameter.js'
-export * from './entities/errors.js'
-
+export * from './errors.js'
+export * from './plan/change-set.js'
+export * from './plan/plan.js'
+export * from './plan/plan-types.js'
+export * from './plugin/plugin.js'
+export * from './resource/parsed-resource-settings.js';
+export * from './resource/resource.js'
+export * from './resource/resource-settings.js'
+export * from './resource/stateful-parameter.js'
 export * from './utils/utils.js'
 
 export async function runPlugin(plugin: Plugin) {

package/src/messages/handlers.test.ts

@@ -1,10 +1,10 @@
 import { MessageHandler } from './handlers.js';
-import { Plugin } from '../entities/plugin.js';
+import { Plugin } from '../plugin/plugin.js';
 import { describe, expect, it } from 'vitest';
 import { mock } from 'vitest-mock-extended'
-import { Resource } from '../entities/resource.js';
-import { Plan } from '../entities/plan.js';
+import { Resource } from '../resource/resource.js';
 import { MessageStatus, ResourceOperation } from 'codify-schemas';
+import { TestResource } from '../utils/test-utils.test.js';
 
 describe('Message handler tests', () => {
   it('handles plan requests', async () => {
@@ -25,10 +25,13 @@ describe('Message handler tests', () => {
       await handler.onMessage({
         cmd: 'plan',
         data: {
-          type: 'resourceType',
-          name: 'name',
-          prop1: 'A',
-          prop2: 'B',
+          desired: {
+            type: 'resourceType',
+            name: 'name',
+            prop1: 'A',
+            prop2: 'B',
+          },
+          isStateful: false,
         }
       })
     } catch (e) {}
@@ -148,7 +151,7 @@ describe('Message handler tests', () => {
   })
 
   it('handles errors for plan', async () => {
-    const resource= testResource();
+    const resource = new TestResource()
     const plugin = testPlugin(resource);
 
     const handler = new MessageHandler(plugin);
@@ -165,7 +168,10 @@ describe('Message handler tests', () => {
     expect(async () => await handler.onMessage({
       cmd: 'plan',
       data: {
-        type: 'resourceA'
+        desired: {
+          type: 'resourceA'
+        },
+        isStateful: false,
       }
     })).rejects.to.not.throw;
 
@@ -173,7 +179,7 @@ describe('Message handler tests', () => {
   })
 
   it('handles errors for apply (create)', async () => {
-    const resource= testResource();
+    const resource = new TestResource()
     const plugin = testPlugin(resource);
 
     const handler = new MessageHandler(plugin);
@@ -182,7 +188,6 @@ describe('Message handler tests', () => {
       expect(message).toMatchObject({
         cmd: 'apply_Response',
         status: MessageStatus.ERROR,
-        data: 'Create error',
       })
       return true;
     }
@@ -200,7 +205,7 @@ describe('Message handler tests', () => {
   })
 
   it('handles errors for apply (destroy)', async () => {
-    const resource= testResource();
+    const resource = new TestResource()
     const plugin = testPlugin(resource);
 
     const handler = new MessageHandler(plugin);
@@ -209,7 +214,6 @@ describe('Message handler tests', () => {
       expect(message).toMatchObject({
         cmd: 'apply_Response',
         status: MessageStatus.ERROR,
-        data: 'Destroy error',
       })
       return true;
     }
@@ -225,33 +229,8 @@ describe('Message handler tests', () => {
       }
     })).rejects.to.not.throw;
   })
-
-
-  const testResource = () => new class extends Resource<any> {
-    constructor() {
-      super({ type: 'resourceA' });
-    }
-
-    async refresh(keys: Map<keyof any, any>): Promise<Partial<any> | null> {
-      throw new Error('Refresh error');
-    }
-
-    applyCreate(plan: Plan<any>): Promise<void> {
-      throw new Error('Create error');
-    }
-
-    applyDestroy(plan: Plan<any>): Promise<void> {
-      throw new Error('Destroy error');
-    }
-  }
-
-  const testPlugin = (resource: Resource<any>) => new class extends Plugin {
-    constructor() {
-      const map = new Map();
-      map.set('resourceA', resource);
-
-      super('name', map);
-    }
-  }
-
 });
+
+function testPlugin(resource: Resource<any>) {
+  return Plugin.create('plugin', [resource])
+}

package/src/messages/handlers.ts

@@ -1,4 +1,4 @@
-import { Plugin } from '../entities/plugin.js';
+import { Ajv, SchemaObject, ValidateFunction } from 'ajv';
 import addFormats from 'ajv-formats';
 import {
   ApplyRequestDataSchema,
@@ -14,44 +14,45 @@ import {
   ValidateRequestDataSchema,
   ValidateResponseDataSchema
 } from 'codify-schemas';
-import Ajv2020, { SchemaObject, ValidateFunction } from 'ajv/dist/2020.js';
-import { SudoError } from '../entities/errors.js';
 
-const SupportedRequests: Record<string, { requestValidator: SchemaObject; responseValidator: SchemaObject; handler: (plugin: Plugin, data: any) => Promise<unknown> }> = {
+import { SudoError } from '../errors.js';
+import { Plugin } from '../plugin/plugin.js';
+
+const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) => Promise<unknown>; requestValidator: SchemaObject; responseValidator: SchemaObject }> = {
+  'apply': {
+    async handler(plugin: Plugin, data: any) {
+      await plugin.apply(data);
+      return null;
+    },
+    requestValidator: ApplyRequestDataSchema,
+    responseValidator: ApplyResponseDataSchema
+  },
   'initialize': {
+    handler: async (plugin: Plugin) => plugin.initialize(),
     requestValidator: InitializeRequestDataSchema,
-    responseValidator: InitializeResponseDataSchema,
-    handler: async (plugin: Plugin) => plugin.initialize()
-  },
-  'validate': {
-    requestValidator: ValidateRequestDataSchema,
-    responseValidator: ValidateResponseDataSchema,
-    handler: async (plugin: Plugin, data: any) => plugin.validate(data)
+    responseValidator: InitializeResponseDataSchema
   },
   'plan': {
+    handler: async (plugin: Plugin, data: any) => plugin.plan(data),
     requestValidator: PlanRequestDataSchema,
-    responseValidator: PlanResponseDataSchema,
-    handler: async (plugin: Plugin, data: any) => plugin.plan(data)
+    responseValidator: PlanResponseDataSchema
   },
-  'apply': {
-    requestValidator: ApplyRequestDataSchema,
-    responseValidator: ApplyResponseDataSchema,
-    handler: async (plugin: Plugin, data: any) => {
-      await plugin.apply(data);
-      return null;
-    }
+  'validate': {
+    handler: async (plugin: Plugin, data: any) => plugin.validate(data),
+    requestValidator: ValidateRequestDataSchema,
+    responseValidator: ValidateResponseDataSchema
   }
 }
 
 export class MessageHandler {
-  private ajv: Ajv2020.default;
+  private ajv: Ajv;
   private readonly plugin: Plugin;
   private messageSchemaValidator: ValidateFunction;
   private requestValidators: Map<string, ValidateFunction>;
   private responseValidators: Map<string, ValidateFunction>;
 
   constructor(plugin: Plugin) {
-    this.ajv = new Ajv2020.default({ strict: true, strictRequired: false });
+    this.ajv = new Ajv({ strict: true, strictRequired: false });
     addFormats.default(this.ajv);
     this.ajv.addSchema(ResourceSchema);
     this.plugin = plugin;
@@ -91,12 +92,12 @@ export class MessageHandler {
 
       process.send!({
         cmd: message.cmd + '_Response',
-        status: MessageStatus.SUCCESS,
         data: result,
+        status: MessageStatus.SUCCESS,
       })
 
-    } catch (e: unknown) {
-      this.handleErrors(message, e as Error);
+    } catch (error: unknown) {
+      this.handleErrors(message, error as Error);
     }
   }
 
@@ -119,8 +120,8 @@ export class MessageHandler {
     if (e instanceof SudoError) {
       return process.send?.({
         cmd,
-        status: MessageStatus.ERROR,
         data: `Plugin: '${this.plugin.name}'. Forbidden usage of sudo for command '${e.command}'. Please contact the plugin developer to fix this.`,
+        status: MessageStatus.ERROR,
       })
     }
 
@@ -128,8 +129,8 @@ export class MessageHandler {
 
     process.send?.({
       cmd,
-      status: MessageStatus.ERROR,
       data: isDebug ? e.stack : e.message,
+      status: MessageStatus.ERROR,
     })
   }
 }