codify-plugin-lib 1.0.76 → 1.0.77

package/src/resource/resource.ts

@@ -0,0 +1,149 @@
+import { StringIndexedObject, } from 'codify-schemas';
+
+import { ParameterChange } from '../plan/change-set.js';
+import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
+import { ResourceSettings } from './resource-settings.js';
+
+/**
+ * A resource represents an object on the system (application, CLI tool, or setting)
+ * that has state and can be created and destroyed. Examples of resources include CLI tools
+ * like homebrew, docker, and xcode-tools; applications like Google Chrome, Zoom, and OpenVPN;
+ * and settings like AWS profiles, git configs and system preference settings.
+ */
+export abstract class Resource<T extends StringIndexedObject> {
+
+  /**
+   * Return the settings for the resource. Consult the typing for {@link ResourceSettings} for
+   * a description of the options.
+   *
+   * **Parameters**:
+   * - id: The id of the resource. This translates to the `type` id parameter in codify.json configs
+   * - schema: A JSON schema used to validate user input
+   * - allowMultiple: Allow multiple copies of the resource to exist at the same time. If true then,
+   * a matcher must be defined that matches a user defined config and a single resource on the system.
+   * - removeStatefulParametersBeforeDestory: Call the delete methods of stateful parameters before destorying
+   * the base resource. Defaults to false.
+   * - dependencies: Specify the ids of any resources that this resource depends on
+   * - parameterSettings: Parameter specific settings. Use this to define custom equals functions, default values
+   * and input transformations
+   * - inputTransformation: Transform the input value.
+   *
+   * @return ResourceSettings The resource settings
+   */
+  abstract getSettings(): ResourceSettings<T>;
+
+  async initialize(): Promise<void> {
+  };
+
+  /**
+   * Add custom validation logic in-addition to the default schema validation.
+   * In this method throw an error if the object did not validate. The message of the
+   * error will be shown to the user.
+   * @param parameters
+   */
+  async validate(parameters: Partial<T>): Promise<void> {
+  };
+
+  /**
+   * Return the status of the resource on the system. If multiple resources exist, then return all instances of
+   * the resource back. Query for the individual parameters specified in the parameter param.
+   * Return null if the resource does not exist.
+   *
+   * Example (Android Studios Resource):
+   * 1. Receive Input:
+   * ```
+   * {
+   *   name: 'Android Studios.app'
+   *   directory: '/Application',
+   *   version: '2023.2'
+   * }
+   * ```
+   * 2. Query the system for any installed Android studio versions.
+   * 3. In this example we find that there is an 2023.2 version installed and an
+   * additional 2024.3-beta version installed as well.
+   * 4. We would return:
+   * ```
+   * [
+   *   { name: 'Android Studios.app', directory: '/Application', version: '2023.2' },
+   *   { name: 'Android Studios Preview.app', directory: '/Application', version: '2024.3' },
+   * ]
+   * ```
+   *
+   * @param parameters The parameters to refresh. In stateless mode this will be the parameters
+   * of the desired config. In stateful mode, this will be parameters of the state config + the desired
+   * config of any new parameters.
+   *
+   * @return A config or an array of configs representing the status of the resource on the
+   * system currently
+   */
+  abstract refresh(parameters: Partial<T>): Promise<Array<Partial<T>> | Partial<T> | null>;
+
+  /**
+   * Create the resource (install) based on the parameters passed in. Only the desired parameters will
+   * be non-null because in a CREATE plan, the current value is null.
+   *
+   * Example (Android Studios Resource):
+   * 1. We receive a plan of:
+   * ```
+   * Plan {
+   *   desiredConfig: {
+   *     name: 'Android Studios.app',
+   *     directory: '/Application',
+   *     version: '2023.2'
+   *   }
+   *   currentConfig: null,
+   * }
+   * ```
+   * 2. Install version Android Studios 2023.2 and then return.
+   *
+   * @param plan The plan of what to install. Use only the desiredConfig because currentConfig is null.
+   */
+  abstract create(plan: CreatePlan<T>): Promise<void>;
+
+  /**
+   * Modify a single parameter of a resource. Modify is optional to override and is only called
+   * when a resourceSetting was set to `canModify = true`. This method should only modify
+   * a single parameter at a time as specified by the first parameter: ParameterChange.
+   *
+   * Example (AWS Profile Resource):
+   * 1. We receive a parameter change of:
+   * ```
+   * {
+   *   name: 'awsAccessKeyId',
+   *   operation: ParameterOperation.MODIFY,
+   *   newValue: '123456',
+   *   previousValue: 'abcdef'
+   * }
+   * ```
+   * 2. Use an if statement to only apply this operation for the parameter `awsAccessKeyId`
+   * 3. Update the value of the `aws_access_key_id` to the `newValue` specified in the parameter change
+   *
+   * @param pc ParameterChange, the parameter name and values to modify on the resource
+   * @param plan The overall plan that triggered the modify operation
+   */
+  async modify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void> {
+  };
+
+  /**
+   * Destroy the resource (uninstall) based on the parameters passed in. Only the current parameters will
+   * be non-null because in a DESTROY plan, the desired value is null. This method will only be called in
+   * stateful mode.
+   *
+   * Example (Android Studios Resource):
+   * 1. We receive a plan of:
+   * ```
+   * Plan {
+   *   currentConfig: {
+   *     name: 'Android Studios.app',
+   *     directory: '/Application',
+   *     version: '2022.4'
+   *   },
+   *   desiredConfig: null
+   * }
+   * ```
+   * 2. Uninstall version Android Studios 2022.4 and then return.
+   *
+   * @param plan The plan of what to uninstall. Use only the currentConfig because desiredConfig is null.
+   */
+  abstract destroy(plan: DestroyPlan<T>): Promise<void>;
+}

package/src/resource/stateful-parameter.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { spy } from 'sinon';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { TestArrayStatefulParameter, TestConfig, testPlan } from '../utils/test-utils.test.js';
+import { ArrayParameterSetting } from './resource-settings.js';
+
+describe('Stateful parameter tests', () => {
+  it('addItem is called the correct number of times', async () => {
+    const plan = testPlan<TestConfig>({
+      desired: { propZ: ['a', 'b', 'c'] },
+    });
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
+    expect(plan.changeSet.parameterChanges.length).to.eq(1);
+
+    const testParameter = spy(new TestArrayStatefulParameter());
+    await testParameter.add((plan.desiredConfig! as any).propZ, plan);
+
+    expect(testParameter.addItem.callCount).to.eq(3);
+    expect(testParameter.removeItem.called).to.be.false;
+  })
+
+  it('applyRemoveItem is called the correct number of times', async () => {
+    const plan = testPlan<TestConfig>({
+      desired: null,
+      current: [{ propZ: ['a', 'b', 'c'] }],
+      state: { propZ: ['a', 'b', 'c'] },
+      statefulMode: true,
+    });
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.DESTROY);
+    expect(plan.changeSet.parameterChanges.length).to.eq(1);
+
+    const testParameter = spy(new TestArrayStatefulParameter());
+    await testParameter.remove((plan.currentConfig as any).propZ, plan);
+
+    expect(testParameter.addItem.called).to.be.false;
+    expect(testParameter.removeItem.callCount).to.eq(3);
+  })
+
+  it('In stateless mode only applyAddItem is called only for modifies', async () => {
+    const parameter = new TestArrayStatefulParameter()
+    const plan = testPlan<TestConfig>({
+      desired: { propZ: ['a', 'c', 'd', 'e', 'f'] }, // b to remove, d, e, f to add
+      current: [{ propZ: ['a', 'b', 'c'] }],
+      settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: parameter } } },
+    });
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.MODIFY);
+    expect(plan.changeSet.parameterChanges[0]).toMatchObject({
+      name: 'propZ',
+      previousValue: ['a', 'c'], // In stateless mode the previous value gets filtered to prevent deletes
+      newValue: ['a', 'c', 'd', 'e', 'f'],
+      operation: ParameterOperation.MODIFY,
+    })
+
+    const testParameter = spy(parameter);
+    await testParameter.modify((plan.desiredConfig as any).propZ, (plan.currentConfig as any).propZ, plan);
+
+    expect(testParameter.addItem.calledThrice).to.be.true;
+    expect(testParameter.removeItem.called).to.be.false;
+  })
+
+  it('isElementEqual is called for modifies', async () => {
+    const testParameter = spy(new class extends TestArrayStatefulParameter {
+      getSettings(): ArrayParameterSetting {
+        return {
+          type: 'array',
+          isElementEqual: (desired, current) => current.includes(desired),
+        }
+      }
+    });
+
+    const plan = testPlan<TestConfig>({
+      desired: { propZ: ['9.12', '9.13'] }, // b to remove, d, e, f to add
+      current: [{ propZ: ['9.12.9'] }],
+      settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: testParameter } } }
+    });
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.MODIFY);
+    expect(plan.changeSet.parameterChanges[0]).toMatchObject({
+      name: 'propZ',
+      previousValue: ['9.12.9'],
+      newValue: ['9.12', '9.13'],
+      operation: ParameterOperation.MODIFY,
+    })
+
+    await testParameter.modify((plan.desiredConfig as any).propZ, (plan.currentConfig as any).propZ, plan);
+
+    expect(testParameter.addItem.calledOnce).to.be.true;
+    expect(testParameter.removeItem.called).to.be.false;
+  })
+})

package/src/resource/stateful-parameter.ts

@@ -0,0 +1,217 @@
+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 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 {
+    return {}
+  }
+
+  /**
+   * 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 abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any>{
+
+  /**
+   * Parameter level settings. Type must be 'array'.
+   */
+  getSettings(): ArrayParameterSetting {
+    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: V[], plan: Plan<T>): Promise<void> {
+    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: V[], previousValues: V[], plan: Plan<T>): Promise<void> {
+
+    // 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: V[], plan: Plan<T>): Promise<void> {
+    for (const value of valuesToRemove) {
+      await this.removeItem(value as V, plan);
+    }
+  }
+
+  /**
+   * 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/src/utils/test-utils.test.ts

@@ -0,0 +1,87 @@
+import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { ResourceSettings } from '../resource/resource-settings.js';
+import { Plan } from '../plan/plan.js';
+import { Resource } from '../resource/resource.js';
+import { CreatePlan, DestroyPlan } from '../plan/plan-types.js';
+import { ArrayStatefulParameter, StatefulParameter } from '../resource/stateful-parameter.js';
+import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
+
+export function testPlan<T extends StringIndexedObject>(params: {
+  desired?: Partial<T> | null;
+  current?: Partial<T>[] | null;
+  state?: Partial<T> | null;
+  core?: ResourceConfig;
+  settings?: ResourceSettings<T>;
+  statefulMode?: boolean;
+}) {
+  return Plan.calculate({
+    desiredParameters: params.desired ?? null,
+    currentParametersArray: params.current ?? null,
+    stateParameters: params.state ?? null,
+    coreParameters: params.core ?? { type: 'type' },
+    settings: params.settings ?
+      new ParsedResourceSettings<T>(params.settings)
+      : new ParsedResourceSettings<T>({ id: 'type' }),
+    statefulMode: params.statefulMode ?? false,
+  })
+}
+
+export interface TestConfig extends StringIndexedObject {
+  propA: string;
+  propB: number;
+  propC?: string;
+}
+
+export class TestResource extends Resource<TestConfig> {
+  getSettings(): ResourceSettings<TestConfig> {
+    return { id: 'type' }
+  }
+
+  create(plan: CreatePlan<TestConfig>): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+  destroy(plan: DestroyPlan<TestConfig>): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+  async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+    return {
+      propA: 'a',
+      propB: 10,
+      propC: 'c',
+    };
+  }
+}
+
+export class TestStatefulParameter extends StatefulParameter<TestConfig, string> {
+  async refresh(desired: string | null): Promise<string | null> {
+    return 'd';
+  }
+
+  async add(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
+    return;
+  }
+
+  async modify(newValue: string, previousValue: string, plan: Plan<TestConfig>): Promise<void> {
+    return;
+  }
+
+  async remove(valueToRemove: string, plan: Plan<TestConfig>): Promise<void> {
+    return;
+  }
+}
+
+export class TestArrayStatefulParameter extends ArrayStatefulParameter<TestConfig, string> {
+  async refresh(): Promise<any | null> {
+    return ['3.11.9']
+  }
+
+  addItem(item: string, plan: Plan<TestConfig>): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+
+  removeItem(item: string, plan: Plan<TestConfig>): Promise<void> {
+    return Promise.resolve(undefined);
+  }
+}

package/src/utils/utils.test.ts

@@ -3,7 +3,7 @@ import { splitUserConfig } from './utils.js';
 
 describe('Utils tests', () => {
   it('Can split a config correctly', () => {
-    const { parameters, resourceMetadata } = splitUserConfig({
+    const { parameters, coreParameters } = splitUserConfig({
       type: 'type',
       name: 'name',
       dependsOn: ['a', 'b', 'c'],
@@ -13,7 +13,7 @@ describe('Utils tests', () => {
       propD: 'propD',
     })
 
-    expect(resourceMetadata).toMatchObject({
+    expect(coreParameters).toMatchObject({
       type: 'type',
       name: 'name',
       dependsOn: ['a', 'b', 'c'],

package/src/utils/utils.ts

@@ -1,6 +1,9 @@
 import promiseSpawn from '@npmcli/promise-spawn';
-import { SpawnOptions } from 'child_process';
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { SpawnOptions } from 'node:child_process';
+import os from 'node:os';
+
+import { ArrayParameterSetting } from '../resource/resource-settings.js';
 
 export enum SpawnStatus {
   SUCCESS = 'success',
@@ -81,21 +84,64 @@ export function isDebug(): boolean {
 }
 
 export function splitUserConfig<T extends StringIndexedObject>(
-  config: T & ResourceConfig
-): { parameters: T;  resourceMetadata: ResourceConfig} {
-  const resourceMetadata = {
+  config: ResourceConfig & T
+): { parameters: T; coreParameters: ResourceConfig } {
+  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 as T,
-    resourceMetadata,
+    coreParameters,
   };
 }
 
 export function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean {
   return set1.size === set2.size && [...set1].every((v) => set2.has(v));
 }
+
+const homeDirectory = os.homedir();
+
+export function untildify(pathWithTilde: string) {
+  return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+
+export function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown) {
+  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/tsconfig.json

@@ -7,7 +7,6 @@
     "noImplicitAny": true,
     "resolveJsonModule": true,
     "esModuleInterop": true,
-    "removeComments": true,
     "strictNullChecks": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defaultExclude, defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    exclude: [
+      ...defaultExclude,
+      './src/utils/test-utils.test.ts'
+    ]
+  },
+});