@thinkwise/testwise 0.1.12 → 0.1.63

package/page-extensions/GoToDeepLink.ts

@@ -14,8 +14,24 @@ export class GoToDeepLink {
       page: async ({ page }, use) => {
         page.goToDeepLink = async (deepLink: string): Promise<null | import('@playwright/test').Response> => {
           const url = new URL(await page.url());
+          const applicationIndex = url.hash.indexOf('#application=');
 
-          return await page.goto(`${url}/${deepLink}`);
+          if (applicationIndex !== -1) {
+            const applicationValue = url.hash.substring(applicationIndex + '#application='.length).split('/')[0];
+            url.hash = `#application=${applicationValue}`;
+          }
+
+          if (deepLink.startsWith('/')) {
+            deepLink = deepLink.substring(1);
+          }
+
+          if (url.hash.endsWith('/')) {
+            url.hash += deepLink;
+          } else {
+            url.hash += `/${deepLink}`;
+          }
+
+          return await page.goto(url.toString());
         };
 
         await use(page);

package/page-extensions/LoginFeatures.ts

@@ -1,12 +1,13 @@
 import { LoginHelper } from '../helpers/LoginHelper.js';
 import type { Test } from '../types/CoreTypes.js';
-import type { UniversalLoginOptions } from '../types/universal.js';
+import type { UniversalLoginOptions } from '../types/index.js';
 
 declare module '@playwright/test' {
   interface Page {
     logIn(): Promise<void>;
     logInWithCredentials(username: string, password: string): Promise<void>;
     logInWithOptions(options: UniversalLoginOptions): Promise<void>;
+    logOut(): Promise<void>;
   }
 }
 
@@ -31,6 +32,10 @@ export class LoginFeatures {
           await this.loginHelper.logInWithOptions(options);
         };
 
+        page.logOut = async () => {
+          await this.loginHelper.logOut();
+        };
+
         await use(page);
       }
     });

package/page-extensions/WaitEventHandler.ts

@@ -0,0 +1,26 @@
+import { GlobalWaitEventHandler } from '../helpers/GlobalWaitEventHandler.js';
+import type { Test } from '../types/CoreTypes.js';
+
+declare module '@playwright/test' {
+  interface Page {
+    waitEventHandler: GlobalWaitEventHandler;
+  }
+}
+
+export class WaitEventHandler {
+  private _test: Test;
+
+  constructor(test: Test) {
+    this._test = test.extend({
+      page: async ({ page }, use) => {
+        page.waitEventHandler = new GlobalWaitEventHandler(page);
+
+        await use(page);
+      }
+    });
+  }
+
+  get test() {
+    return this._test;
+  }
+}

package/page-extensions/index.ts

@@ -0,0 +1,3 @@
+export * from './GoToDeepLink.js';
+export * from './LoginFeatures.js';
+export * from './UserSimulation.js';

package/page-overrides/ClickOverride.ts

@@ -1,48 +1,82 @@
-import { type Locator, expect } from '@playwright/test';
-import { InflightRequestsTracker } from '../helpers/InflightRequestTracker.js';
+import type { Locator } from '@playwright/test';
+import { FlightTracker } from '../helpers/FlightTracker.js';
 import { testwiseConfig } from '../services/ConfigBuilder.js';
 import type { Test } from '../types/CoreTypes.js';
 
+const waitForRequestsToComplete =
+  testwiseConfig().get<boolean>('featureSettings.InflightRequests.waitForRequestsToComplete') ?? true;
+const continueOnError = testwiseConfig().get<boolean>('featureSettings.InflightRequests.continueOnError') ?? true;
+
 export class ClickOverride {
   private _test: Test;
+  private flightTracker: FlightTracker = new FlightTracker();
 
   constructor(test: Test) {
     this._test = test.extend({
       page: async ({ page }, use) => {
-        const overrideClickMethod = (locator: Locator) => {
+        const overrideClickMethod = (locator: Locator): Locator => {
           const originalClickMethod = locator.click.bind(locator);
 
-          locator.click = async (options) => {
-            if (testwiseConfig().get<boolean>('InflightRequests.waitForRequestsToComplete') === true) {
-              const tracker = new InflightRequestsTracker(page);
+          page.on('request', (request) => {
+            if (request.resourceType() === 'xhr') {
+              this.flightTracker.requestsInFlight++;
+            }
+          });
 
-              await Promise.all([
-                originalClickMethod(options),
+          page.on('response', (response) => {
+            if (response.request().resourceType() === 'xhr') {
+              if (this.flightTracker.requestsInFlight > 0) {
+                this.flightTracker.requestsInFlight--;
+              }
 
-                // Ensure at least one XHR request is issued
-                Promise.race([
-                  page.waitForRequest((request) => request.resourceType() === 'xhr'),
-                  new Promise((resolve) => setTimeout(resolve, 50)) // Wait briefly to ensure the XHR request is in flight
-                ])
-              ]);
+              if (this.flightTracker.requestsInFlight === 0) {
+                this.flightTracker.eventEmitter.emit('idle');
+              }
+            }
+          });
 
-              // Wait for all XHR requests to finish
+          locator.click = async (options) => {
+            await originalClickMethod(options);
+            if (waitForRequestsToComplete) {
               try {
-                await expect
-                  .poll(() => tracker.inflightRequests().filter((request) => request.resourceType() === 'xhr').length, {
-                    timeout: 3000
-                  })
-                  .toBe(0);
-              } catch (e) {
-                console.warn('Exception while waiting for inflight requests to finish:', e);
-
-                if (testwiseConfig().get<boolean>('InflightRequests.swallowPollingExceptions') === false) throw e;
+                await this.flightTracker.waitToContinue();
+              } catch (error) {
+                console.warn('Exception while waiting for inflight requests to finish:', error);
+
+                if (!continueOnError) throw error;
               }
-            } else {
-              await originalClickMethod(options);
             }
           };
 
+          // Ensure chaining works by overriding methods that return new Locators
+          const originalLocatorMethod = locator.locator.bind(locator);
+          locator.locator = (...args) => overrideClickMethod(originalLocatorMethod(...args));
+
+          // Override the filter method so returned locators also have custom click logic
+          const originalFilterMethod = locator.filter?.bind(locator);
+          locator.filter = (...args) => overrideClickMethod(originalFilterMethod(...args));
+
+          const originalGetByTextMethod = locator.getByText.bind(locator);
+          locator.getByText = (...args) => overrideClickMethod(originalGetByTextMethod(...args));
+
+          const originalGetByTestIdMethod = locator.getByTestId.bind(locator);
+          locator.getByTestId = (...args) => overrideClickMethod(originalGetByTestIdMethod(...args));
+
+          const originalGetByAltTextMethod = locator.getByAltText.bind(locator);
+          locator.getByAltText = (...args) => overrideClickMethod(originalGetByAltTextMethod(...args));
+
+          const originalGetByLabelMethod = locator.getByLabel.bind(locator);
+          locator.getByLabel = (...args) => overrideClickMethod(originalGetByLabelMethod(...args));
+
+          const originalGetByRoleMethod = locator.getByRole.bind(locator);
+          locator.getByRole = (...args) => overrideClickMethod(originalGetByRoleMethod(...args));
+
+          const originalGetByPlaceholderMethod = locator.getByPlaceholder.bind(locator);
+          locator.getByPlaceholder = (...args) => overrideClickMethod(originalGetByPlaceholderMethod(...args));
+
+          const originalGetByTitleMethod = locator.getByTitle.bind(locator);
+          locator.getByTitle = (...args) => overrideClickMethod(originalGetByTitleMethod(...args));
+
           return locator;
         };
 

package/page-overrides/FillOverride.ts

@@ -0,0 +1,133 @@
+import type { Locator } from '@playwright/test';
+import { FlightTracker } from '../helpers/FlightTracker.js';
+import { testwiseConfig } from '../services/ConfigBuilder.js';
+import type { Test } from '../types/CoreTypes.js';
+
+const requestWatchlist: string[] = testwiseConfig().get<string[]>('featureSettings.InflightRequests.paths') ?? [];
+const waitForRequestsToComplete =
+  testwiseConfig().get<boolean>('featureSettings.InflightRequests.waitForRequestsToComplete') ?? true;
+
+export class FillOverride {
+  private _test: Test;
+  private flightTracker: FlightTracker = new FlightTracker();
+
+  constructor(test: Test) {
+    this._test = test.extend({
+      page: async ({ page }, use) => {
+        if (waitForRequestsToComplete) {
+          requestWatchlist.forEach((stringToMatch) => {
+            page.on('request', (request) => {
+              if (request.url().includes(stringToMatch)) {
+                this.flightTracker.requestsInFlight++;
+              }
+            });
+
+            page.on('response', (response) => {
+              if (response.url().includes(stringToMatch)) {
+                if (this.flightTracker.requestsInFlight > 0) this.flightTracker.requestsInFlight--;
+
+                if (this.flightTracker.requestsInFlight === 0) {
+                  this.flightTracker.eventEmitter.emit('idle');
+                }
+              }
+            });
+          });
+        }
+
+        const overrideFillMethod = (locator: Locator) => {
+          const originalFillMethod = locator.fill.bind(locator);
+
+          locator.fill = async (value, options) => {
+            try {
+              if (waitForRequestsToComplete) await this.flightTracker.waitToContinue();
+            } catch (e) {
+              console.warn('Exception:', e);
+              this.flightTracker.requestsInFlight = 0;
+            }
+
+            const currentValue = await locator.inputValue();
+            const valueIsDifferent = currentValue !== value;
+
+            const testIdWhitelist: string[] = ['form-field__'];
+
+            const isWhitelisted = await locator.evaluate((el, testIdWhitelist) => {
+              const elementTestId = el.getAttribute('data-testid');
+              if (elementTestId) {
+                return testIdWhitelist.some((whitelistedId) => elementTestId.includes(whitelistedId));
+              }
+              return false;
+            }, testIdWhitelist);
+
+            if (valueIsDifferent && isWhitelisted) {
+              await page.waitEventHandler.waitForCanContinue();
+              page.waitEventHandler.waitForResponse('/staged');
+            }
+
+            await originalFillMethod(value, options);
+
+            if (isWhitelisted) {
+              await locator.evaluate((el) => {
+                const ariaExpanded = el.getAttribute('aria-expanded');
+
+                if (!ariaExpanded) el.blur();
+              });
+            }
+          };
+
+          const originalLocatorMethod = locator.locator.bind(locator);
+          locator.locator = (...args) => overrideFillMethod(originalLocatorMethod(...args));
+
+          const originalGetByTextMethod = locator.getByText.bind(locator);
+          locator.getByText = (...args) => overrideFillMethod(originalGetByTextMethod(...args));
+
+          const originalGetByTestIdMethod = locator.getByTestId.bind(locator);
+          locator.getByTestId = (...args) => overrideFillMethod(originalGetByTestIdMethod(...args));
+
+          const originalGetByAltTextMethod = locator.getByAltText.bind(locator);
+          locator.getByAltText = (...args) => overrideFillMethod(originalGetByAltTextMethod(...args));
+
+          const originalGetByLabelMethod = locator.getByLabel.bind(locator);
+          locator.getByLabel = (...args) => overrideFillMethod(originalGetByLabelMethod(...args));
+
+          const originalGetByRoleMethod = locator.getByRole.bind(locator);
+          locator.getByRole = (...args) => overrideFillMethod(originalGetByRoleMethod(...args));
+
+          const originalGetByPlaceholderMethod = locator.getByPlaceholder.bind(locator);
+          locator.getByPlaceholder = (...args) => overrideFillMethod(originalGetByPlaceholderMethod(...args));
+
+          const originalGetByTitleMethod = locator.getByTitle.bind(locator);
+          locator.getByTitle = (...args) => overrideFillMethod(originalGetByTitleMethod(...args));
+
+          return locator;
+        };
+
+        // Override the locator method on the page object
+        const originalLocator = page.locator.bind(page);
+        page.locator = (...args) => overrideFillMethod(originalLocator(...args));
+
+        const originalGetByTestId = page.getByTestId.bind(page);
+        const originalGetByAltText = page.getByAltText.bind(page);
+        const originalGetByLabel = page.getByLabel.bind(page);
+        const originalGetByRole = page.getByRole.bind(page);
+        const originalGetByPlaceholder = page.getByPlaceholder.bind(page);
+        const originalGetByText = page.getByText.bind(page);
+        const originalGetByTitle = page.getByTitle.bind(page);
+
+        // Override other top-level methods as before
+        page.getByTestId = (...args) => overrideFillMethod(originalGetByTestId(...args));
+        page.getByAltText = (...args) => overrideFillMethod(originalGetByAltText(...args));
+        page.getByLabel = (...args) => overrideFillMethod(originalGetByLabel(...args));
+        page.getByRole = (...args) => overrideFillMethod(originalGetByRole(...args));
+        page.getByPlaceholder = (...args) => overrideFillMethod(originalGetByPlaceholder(...args));
+        page.getByText = (...args) => overrideFillMethod(originalGetByText(...args));
+        page.getByTitle = (...args) => overrideFillMethod(originalGetByTitle(...args));
+
+        await use(page);
+      }
+    });
+  }
+
+  get test() {
+    return this._test;
+  }
+}

package/page-overrides/index.ts

@@ -0,0 +1 @@
+export * from './ClickOverride.js';

package/promptCredentials.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import chalk from 'chalk';
-import process from 'node:process';
 import { spawnSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
+import process from 'node:process';
+import chalk from 'chalk';
 import prompts from 'prompts';
 
 const packageScripts = JSON.parse(readFileSync('./package.json')).scripts;
@@ -14,7 +14,10 @@ function exitWithError(error) {
 
 function startTestSolution() {
   console.log('Now starting test solution...');
-  spawnSync(`yarn --cwd ../ ${args.join(' ')}`, { shell: true, stdio: 'inherit' });
+  spawnSync(`yarn --cwd ../ ${args.join(' ')}`, {
+    shell: true,
+    stdio: 'inherit'
+  });
   process.exit();
 }
 
@@ -53,27 +56,30 @@ if (process.env.SF_TEST_USERNAME && process.env.SF_TEST_PASSWORD) {
   startTestSolution();
 }
 
-const questions = [{
-  type: 'text',
-  name: 'username',
-  message: 'Username:',
-  validate: (value) => {
-    if (!value?.length) {
-      return 'Username is required';
+const questions = [
+  {
+    type: 'text',
+    name: 'username',
+    message: 'Username:',
+    validate: (value) => {
+      if (!value?.length) {
+        return 'Username is required';
+      }
+
+      if (value.toLowerCase() === 'demo') {
+        return 'Running tests locally with demo is forbidden as it results in dataset concurrency problems';
+      }
+
+      return true;
     }
-
-    if (value.toLowerCase() === 'demo') {
-      return 'Running tests locally with demo is forbidden as it results in dataset concurrency problems'
-    }
-
-    return true;
+  },
+  {
+    type: 'invisible',
+    name: 'password',
+    message: 'Password:',
+    validate: (value) => (!value?.length ? 'Password is required' : true)
   }
-}, {
-  type: 'invisible',
-  name: 'password',
-  message: 'Password:',
-  validate: (value) => !value?.length ? 'Password is required' : true
-}];
+];
 
 (async () => {
   const credentialsResponse = await prompts(questions);
@@ -89,17 +95,22 @@ const questions = [{
   params.append('Password', password);
 
   const fetch = (await import('node-fetch')).default;
-  const authResponse = await fetch(`${indiciumURL}/account/api/login`, { method: 'POST', body: params });
+  const authResponse = await fetch(`${indiciumURL}/account/api/login`, {
+    method: 'POST',
+    body: params
+  });
 
   if (authResponse.status === 204) {
     console.log('Confirmed credentials work @', indiciumURL);
   } else {
-    const confirmResponse = await prompts([{
-      type: 'confirm',
-      name: 'value',
-      message: `Can't login to ${indiciumURL} with the given credentials. Continue anyways?`,
-      initial: true
-    }]);
+    const confirmResponse = await prompts([
+      {
+        type: 'confirm',
+        name: 'value',
+        message: `Can't login to ${indiciumURL} with the given credentials. Continue anyways?`,
+        initial: true
+      }
+    ]);
 
     if (!confirmResponse.value) {
       return;
@@ -110,4 +121,4 @@ const questions = [{
   process.env.SF_TEST_PASSWORD = password;
 
   startTestSolution();
-})();
+})();

package/scripts/Testwise.template.json

@@ -8,12 +8,15 @@
     "logger" : {
       "logDir" : "logs",
       "logLevel" : "info",
+      "applyLogLevelToConsoleOutput" : false,
       "logByDay" : true,
       "bufferSizeLimit" : -1
     },
     "InflightRequests" : {
       "waitForRequestsToComplete" : true,
-      "swallowPollingExceptions" : true
+      "waitTimeout" : 5000,
+      "continueOnError" : true,
+      "paths" : ["/stage", "/layout()", "/context()"]
     },
     "other" : {
       "loginTimeout" : 30000

package/scripts/add-config.js

@@ -11,7 +11,7 @@ if (process.argv[2] === 'install') {
   const __dirname = path.dirname(__filename);
   const configFile = path.resolve(process.cwd(), 'Testwise.json');
   const templateFile = path.join(__dirname, 'Testwise.template.json');
-  
+
   if (!fs.existsSync(configFile)) {
     fs.copyFileSync(templateFile, configFile);
     console.log('Testwise.json config file created.');
@@ -20,4 +20,4 @@ if (process.argv[2] === 'install') {
   }
 } else {
   console.log('Unknown or missing command. Usage: npx testwise install');
-}
+}

package/services/ConfigBuilder.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import dotenv from 'dotenv';
 
 class ConfigBuilder {
   private config: Record<string, unknown>;
@@ -7,6 +8,14 @@ class ConfigBuilder {
   constructor() {
     const configFilePath = path.resolve(process.cwd(), 'Testwise.json');
 
+    // Find all env files in the consuming project and apply them to process.env
+    const envFiles = fs.readdirSync(process.cwd()).filter((file) => file.endsWith('.env'));
+
+    for (const envFile of envFiles) {
+      const envConfig = dotenv.parse(fs.readFileSync(path.resolve(process.cwd(), envFile)));
+      Object.assign(process.env, envConfig);
+    }
+
     if (!fs.existsSync(configFilePath)) {
       throw new Error(`Config file not found at path: ${configFilePath}`);
     }
@@ -21,12 +30,29 @@ class ConfigBuilder {
    * @returns The value associated with the key, or undefined if not found.
    */
   public get<T>(key: string): T | undefined {
-    return key
+    const result = key
       .split('.')
       .reduce(
         (obj: Record<string, unknown> | undefined, segment) => obj?.[segment] as Record<string, unknown>,
         this.config
       ) as T;
+
+    // Convert the key to uppercase, replace dots with underscores, and insert underscores before uppercase letters
+    let envKey = key.replace(/\./g, '_');
+    envKey = envKey.replace(/([a-z0-9])([A-Z])/g, '$1_$2');
+    envKey = envKey.toUpperCase();
+
+    if (process.env[envKey] !== undefined) {
+      const envValue = process.env[envKey] as unknown;
+      // Attempt to parse JSON values, fallback to string if parsing fails
+      try {
+        return JSON.parse(envValue as string) as T;
+      } catch {
+        return envValue as T;
+      }
+    }
+
+    return result;
   }
 }
 

package/services/Logger.ts

@@ -5,6 +5,46 @@ import { originalDebug, originalError, originalInfo, originalLog, originalWarn }
 import { testwiseConfig } from './ConfigBuilder.js';
 
 const logDir = path.resolve(process.cwd(), testwiseConfig().get<string>('featureSettings.logger.logDir') ?? 'logs');
+const logLevel =
+  (testwiseConfig().get<string>('featureSettings.logger.logLevel')?.toUpperCase() as LogLevel) ?? LogLevel.ALL;
+const applyLogLevelToConsoleOutput =
+  testwiseConfig().get<boolean>('featureSettings.logger.applyLogLevelToConsoleOutput') ?? false;
+
+let logErrors = false;
+let logWarnings = false;
+let logInfo = false;
+let logDebug = false;
+let logLog = false;
+
+switch (logLevel) {
+  case LogLevel.ERROR:
+    logErrors = true;
+    break;
+  case LogLevel.WARN:
+    logErrors = true;
+    logWarnings = true;
+    break;
+  case LogLevel.INFO:
+    logErrors = true;
+    logWarnings = true;
+    logInfo = true;
+    break;
+  case LogLevel.DEBUG:
+    logErrors = true;
+    logWarnings = true;
+    logInfo = true;
+    logDebug = true;
+    break;
+  case LogLevel.ALL:
+    logErrors = true;
+    logWarnings = true;
+    logInfo = true;
+    logDebug = true;
+    logLog = true;
+    break;
+  default:
+    throw new Error(`Unknown log level: ${logLevel}`);
+}
 
 fs.mkdirSync(logDir, { recursive: true });
 
@@ -19,12 +59,12 @@ const logFilePath = path.join(
 let logBuffer: string[] = [];
 const bufferSizeLimit = testwiseConfig().get<number>('featureSettings.logger.bufferSizeLimit') ?? 1000;
 
-let linesAlreadyWritten = 0;
+let _linesAlreadyWritten = 0;
 
 if (fs.existsSync(logFilePath)) {
   const existingLogs = fs.readFileSync(logFilePath, 'utf-8').split('\n').filter(Boolean);
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  linesAlreadyWritten = existingLogs.length;
+  _linesAlreadyWritten = existingLogs.length;
 }
 
 /**
@@ -57,32 +97,51 @@ function flushLogs() {
  * @param level
  * @param optionalParams
  */
-function log(message?: string, level: LogLevel = LogLevel.INFO, ...optionalParams: unknown[]): void {
+function log(message?: string, level: LogLevel = LogLevel.ALL, ...optionalParams: unknown[]): void {
   const timestamp = new Date().toISOString();
   const origin = getCallerInfo();
   const formatted = `[${timestamp}] [${level}] [${origin}] ${message}`;
 
   switch (level) {
-    case LogLevel.FATAL:
     case LogLevel.ERROR:
-      originalError(formatted, ...optionalParams);
+      if (logErrors) {
+        logBuffer.push(`${formatted} ${optionalParams}`);
+      }
+
+      if (logErrors || !applyLogLevelToConsoleOutput) originalError(formatted, ...optionalParams);
       break;
     case LogLevel.WARN:
-      originalWarn(formatted, ...optionalParams);
+      if (logWarnings) {
+        logBuffer.push(`${formatted} ${optionalParams}`);
+      }
+
+      if (logWarnings || !applyLogLevelToConsoleOutput) originalWarn(formatted, ...optionalParams);
       break;
     case LogLevel.DEBUG:
-      originalDebug(formatted, ...optionalParams);
+      if (logDebug) {
+        logBuffer.push(`${formatted} ${optionalParams}`);
+      }
+
+      if (logDebug || !applyLogLevelToConsoleOutput) originalDebug(formatted, ...optionalParams);
       break;
     case LogLevel.INFO:
-      originalInfo(formatted, ...optionalParams);
+      if (logInfo) {
+        logBuffer.push(`${formatted} ${optionalParams}`);
+      }
+
+      if (logInfo || !applyLogLevelToConsoleOutput) originalInfo(formatted, ...optionalParams);
       break;
     default:
-      originalLog(formatted, ...optionalParams);
-      break;
+      if (logLog) {
+        logBuffer.push(`${formatted} ${optionalParams}`);
+      }
+
+      if (logLog || !applyLogLevelToConsoleOutput) originalLog(formatted, ...optionalParams);
   }
 
-  logBuffer.push(`${formatted} ${optionalParams}`);
-  flushLogs();
+  if (logBuffer.length >= bufferSizeLimit) {
+    flushLogs();
+  }
 }
 
 /**
@@ -116,10 +175,9 @@ function getCallerInfo(): string {
 
 export const logger = {
   // Order by severity level
-  fatal: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.FATAL, ...optionalParams),
   error: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.ERROR, ...optionalParams),
   warn: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.WARN, ...optionalParams),
-  step: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.STEP, ...optionalParams),
   info: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.INFO, ...optionalParams),
-  debug: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.DEBUG, ...optionalParams)
+  debug: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.DEBUG, ...optionalParams),
+  log: (msg?: string, ...optionalParams: unknown[]): void => log(msg, LogLevel.ALL, ...optionalParams)
 };

package/services/index.ts

@@ -0,0 +1 @@
+export * from './ConfigBuilder.js';