@flowerforce/flowerbase 1.0.1-beta.3

package/src/utils/context/interface.ts

@@ -0,0 +1,19 @@
+import { FastifyInstance } from 'fastify'
+import { Arguments, User } from '../../auth/dtos'
+import { Function, Functions } from '../../features/functions/interface'
+import { Rules } from '../../features/rules/interface'
+import { Services } from '../../services/interface'
+
+export interface GenerateContextParams {
+  app: FastifyInstance
+  currentFunction: Function
+  functionsList: Functions
+  rules: Rules
+  user: User
+  services: Services
+  args: Arguments
+}
+
+export interface GenerateContextDataParams extends Omit<GenerateContextParams, 'args'> {
+  GenerateContext: (params: GenerateContextParams) => Promise<void>
+}

package/src/utils/crypto/index.ts

@@ -0,0 +1,36 @@
+import crypto from 'node:crypto'
+import { promisify } from 'node:util'
+
+const scrypt = promisify(crypto.scrypt)
+
+/**
+ * > Creates the hash for a string
+ * @param plaintext -> the string that should be encrypted
+ * @tested
+ */
+export const hashPassword = async (plaintext: string) => {
+  const salt = crypto.randomBytes(128).toString('hex')
+  const buffer = (await scrypt(plaintext, salt, 64)) as Buffer
+  return `${buffer.toString('hex')}.${salt}`
+}
+
+/**
+ * > Compares two strings
+ * @param plaintext -> the first string
+ * @param storedPassword -> the second string
+ * @tested
+ */
+export const comparePassword = async (plaintext: string, storedPassword: string) => {
+  const [storedHash, storedSalt] = storedPassword.split('.')
+  const storedBuffer = Buffer.from(storedHash, 'hex')
+  const buffer = (await scrypt(plaintext, storedSalt, 64)) as Buffer
+  return crypto.timingSafeEqual(buffer, storedBuffer)
+}
+
+/**
+ * > Generate a random token
+ * @param length -> the token length
+ */
+export const generateToken = (length = 32) => {
+  return crypto.randomBytes(length).toString('hex');
+}

package/src/utils/helpers/someAsync.ts

@@ -0,0 +1,24 @@
+/**
+ * Asynchronously checks if at least one element in the array satisfies the given asynchronous callback function.
+ * 
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to iterate over.
+ * @param {(element: T, index: number, arr: T[]) => Promise<boolean>} callback - An asynchronous function that takes an element, its index, and the original array,
+ * and returns a Promise resolving to `true` if the condition is met, otherwise `false`.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if at least one element satisfies the callback condition, otherwise `false`.
+ * @tested
+ */
+export async function someAsync<T>(
+    array: T[],
+    callback: (element: T, index: number, arr: T[]) => Promise<boolean>
+): Promise<boolean> {
+    let i = 0;
+    for await (const el of array) {
+        const isValid = await callback(el, i, array);
+        if (isValid) {
+            return true;
+        }
+        i++;
+    }
+    return false;
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+import fs from 'fs'
+
+export const readFileContent = (filePath: string) => fs.readFileSync(filePath, 'utf-8')
+export const readJsonContent = (filePath: string) =>
+  JSON.parse(readFileContent(filePath)) as unknown

package/src/utils/initializer/exposeRoutes.ts

@@ -0,0 +1,26 @@
+import { uptime } from 'node:process'
+import { FastifyInstance } from 'fastify'
+import { API_VERSION } from '../../constants'
+
+/**
+ * > Used to expose all app routes
+ * @param fastify -> the fastify instance
+ * @tested
+ */
+export const exposeRoutes = async (fastify: FastifyInstance) => {
+  try {
+    fastify.get(`${API_VERSION}/app/:appId/location`, async (req) => ({
+      deployment_model: 'LOCAL',
+      location: 'IE',
+      hostname: `http://${req.headers.host}`,
+      ws_hostname: `wss://${req.headers.host}`
+    }))
+
+    fastify.get('/health', async () => ({
+      status: 'ok',
+      uptime: uptime()
+    }))
+  } catch (e) {
+    console.error('Error while exposing routes', (e as Error).message)
+  }
+}

package/src/utils/initializer/registerPlugins.ts

@@ -0,0 +1,97 @@
+import cors from '@fastify/cors'
+import fastifyMongodb from '@fastify/mongodb'
+import { FastifyInstance } from 'fastify'
+import { authController } from '../../auth/controller'
+import jwtAuthPlugin from '../../auth/plugins/jwt'
+import { localUserPassController } from '../../auth/providers/local-userpass/controller'
+import { API_VERSION } from '../../constants'
+import { Functions } from '../../features/functions/interface'
+
+type RegisterFunction = FastifyInstance['register']
+type RegisterParameters = Parameters<RegisterFunction>
+
+type RegisterPluginsParams = {
+  register: RegisterFunction
+  mongodbUrl: string
+  jwtSecret: string
+  functionsList: Functions
+}
+
+type RegisterConfig = {
+  plugin: RegisterParameters[0]
+  options: RegisterParameters[1]
+}
+
+/**
+ * > Used to register all plugins
+ * @param register -> the fastify register method
+ * @param mongodbUrl -> the database connection string
+ * @param jwtSecret -> connection jwt
+ * @tested
+ */
+export const registerPlugins = async ({
+  register,
+  mongodbUrl,
+  jwtSecret,
+  functionsList
+}: RegisterPluginsParams) => {
+  try {
+    const registersConfig = await getRegisterConfig({
+      mongodbUrl,
+      jwtSecret,
+      functionsList
+    })
+
+    registersConfig.forEach(({ plugin, options }) => {
+      register(plugin, options)
+    })
+  } catch (e) {
+    console.error('Error while registering plugins', (e as Error).message)
+  }
+}
+
+/**
+ * > Used to generate the register congig
+ * @param mongodbUrl -> the database connection string
+ * @param jwtSecret -> connection jwt
+ * @testable  
+ */
+const getRegisterConfig = async ({
+  mongodbUrl,
+  jwtSecret
+}: Pick<RegisterPluginsParams, 'jwtSecret' | 'mongodbUrl' | 'functionsList'>): Promise<
+  RegisterConfig[]
+> => {
+  return [
+    {
+      plugin: cors,
+      options: {
+        origin: '*',
+        methods: ['POST', 'GET']
+      }
+    },
+    {
+      plugin: fastifyMongodb,
+      options: {
+        forceClose: true,
+        url: mongodbUrl
+      }
+    },
+    {
+      plugin: jwtAuthPlugin,
+      options: {
+        secret: jwtSecret
+      }
+    },
+    {
+      plugin: authController,
+      options: { prefix: `${API_VERSION}/auth` }
+    },
+    {
+      plugin: localUserPassController,
+      options: {
+        prefix: `${API_VERSION}/app/:appId/auth/providers/local-userpass`
+      }
+    }
+  ] as RegisterConfig[]
+}

package/src/utils/roles/helpers.ts

@@ -0,0 +1,47 @@
+import { services } from '../../services'
+import { StateManager } from '../../state'
+import { GenerateContext } from '../context'
+import { expandQuery } from '../rules'
+import rulesMatcherUtils from '../rules-matcher/utils'
+import { PermissionExpression } from './interface'
+import { MachineContext } from './machines/interface'
+
+const functionsConditions = ["%%true", "%%false"]
+
+export const evaluateExpression = async (params: MachineContext["params"], expression?: PermissionExpression, user?: MachineContext["user"]): Promise<boolean> => {
+  if (!expression || typeof expression === 'boolean') return !!expression
+
+  const value = {
+    ...params.expansions,
+    ...params.cursor,
+    "%%user": user,
+    '%%true': true
+  }
+  const conditions = expandQuery(expression, value)
+  const complexCondition = Object.entries<Record<string, any>>(conditions).find(([key]) => functionsConditions.includes(key))
+  return complexCondition ? await evaluateComplexExpression(complexCondition, params, user) : rulesMatcherUtils.checkRule(conditions, value, {})
+
+}
+
+const evaluateComplexExpression = async (condition: [string, Record<string, any>], params: MachineContext["params"], user: MachineContext["user"]) => {
+  const [key, config] = condition
+
+  const { name } = config["%function"]
+  const functionsList = StateManager.select("functions")
+  const app = StateManager.select("app")
+  const currentFunction = functionsList[name]
+  const response = await GenerateContext({
+    args: [params.cursor],
+    app,
+    rules: {},
+    user,
+    currentFunction,
+    functionsList,
+    services
+  })
+  return key === "%%true" ? response : !response
+
+}
+
+
+

package/src/utils/roles/interface.ts

@@ -0,0 +1,42 @@
+export type PermissionExpression = boolean // TODO: add complex condition (%%true: %function)
+
+export type FieldPermissionExpression = {
+  read?: boolean,
+  write?: boolean
+}
+
+export interface DocumentFiltersPermissions {
+  read?: PermissionExpression
+  write?: PermissionExpression
+}
+
+export interface Role {
+  name: string
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  apply_when: Record<string, any> // TODO -> define this type
+  search?: PermissionExpression
+  document_filters?: DocumentFiltersPermissions
+  read?: PermissionExpression
+  write?: PermissionExpression
+  insert?: PermissionExpression
+  delete?: PermissionExpression
+  fields?: {
+    [K: string]: FieldPermissionExpression
+  }
+  additional_fields?: {
+    [K: string]: FieldPermissionExpression
+  }
+}
+
+export interface Params {
+  roles: Role[]
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  cursor: any // TODO -> define this type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  expansions: Record<string, any> // TODO -> define this type
+  type: 'insert' | 'read' | 'delete' | 'search' | 'write'
+}
+
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Condition = Record<string, any>

package/src/utils/roles/machines/commonValidators.ts

@@ -0,0 +1,24 @@
+import { someAsync } from "../../helpers/someAsync"
+import { evaluateExpression } from "../helpers"
+import { DocumentFiltersPermissions } from "../interface"
+import { MachineContext } from "./interface"
+
+const readOnlyPermissions = ['read']
+const readWritePermissions = ['write', 'delete', 'insert', ...readOnlyPermissions]
+
+export const evaluateDocumentFiltersFn = async ({ params, role, user }: MachineContext, currentType: keyof DocumentFiltersPermissions) => {
+    const permissions = currentType === "read" ? readOnlyPermissions : readWritePermissions
+    return await someAsync([
+        permissions.includes(params.type) && role.document_filters?.[currentType]
+    ]
+        .filter(Boolean), async (expr) => evaluateExpression(params, expr, user))
+}
+
+
+export const evaluateTopLevelPermissionsFn = async ({ params, role, user }: MachineContext, currentType: MachineContext["params"]["type"]) => {
+    return role[currentType] ? await evaluateExpression(params, role[currentType], user) : undefined
+}
+
+export const checkFieldsPropertyExists = ({ role }: MachineContext) => {
+    return !!Object.keys(role.fields ?? {}).length
+}

package/src/utils/roles/machines/index.ts

@@ -0,0 +1,20 @@
+import { User } from '../../../auth/dtos'
+import { Params, Role } from '../interface'
+import { StepResult } from './interface'
+import { StateMachine } from './machine'
+
+/**
+ * Executes the validation process using the `StateMachine` for the given role, parameters, and user.
+ *
+ * @param {Role} role - The role configuration for validation.
+ * @param {Params} params - The parameters relevant to the validation process.
+ * @param {User} user - The user for whom the validation is being performed.
+ * 
+ * @returns {Promise<StepResult>} - The result of the state machine's validation process.
+ */
+export const checkValidation = async (role: Role, params: Params, user: User, enableLog?: boolean): Promise<StepResult> => {
+  const stateMachine = new StateMachine(role, params, user, enableLog)
+  return await stateMachine.runValidation()
+}
+
+

package/src/utils/roles/machines/interface.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Document } from 'mongodb'
+import { User } from '../../../auth/dtos'
+import { Params, Role } from '../interface'
+
+export type PrevParams = Record<string, any>
+export interface MachineContext {
+  user: User
+  role: Role
+  params: Params
+  prevParams?: PrevParams
+  enableLog?: boolean
+}
+
+type StateFunction = (
+  params: RunParams & {
+    context: MachineContext
+  } & {
+    next: (step: string, params?: Record<string, any>) => void
+    endValidation: ({ success, document }: { success: boolean, document?: Document }) => void
+    goToNextValidationStage: (initialStep?: string | null) => void
+  }
+) => Promise<void>
+
+export type States = Record<string, StateFunction>
+
+export interface RunParams {
+  initialStep: string | null
+}
+
+export interface ValidationStatus {
+  status: boolean | null
+  document?: Document
+}
+
+
+export interface StepResult { status: boolean | null; nextInitialStep: string | null; document?: Document }
+
+export interface EndValidationParams { success: boolean, document?: Document }
+
+export type LogMachineInfoParams = {
+  enabled?: boolean
+  machine: string
+  step: number
+  stepName: string
+}

package/src/utils/roles/machines/machine.ts

@@ -0,0 +1,85 @@
+import { Document } from "mongodb"
+import { User } from "../../../auth/dtos";
+import { Params, Role } from "../interface";
+import { MachineContext, PrevParams, States, StepResult, ValidationStatus } from "./interface";
+import { READ_MACHINE } from "./read";
+import { WRITE_MACHINE } from "./write";
+
+export class StateMachine {
+    private _context: MachineContext
+    private _validation: StepResult = {
+        status: null,
+        nextInitialStep: null
+    }
+    private _machines: States[]
+    private _currentStep: {
+        names: readonly string[]
+        states: States
+        validation: ValidationStatus,
+        completed?: boolean,
+        initialStep: string | null
+    }
+    constructor(role: Role, params: Params, user: User, enableLog?: boolean) {
+        this._context = { role, params, user, enableLog }
+        this._machines = params.type === "read" ? READ_MACHINE : WRITE_MACHINE
+        this._currentStep = {
+            names: [],
+            states: {},
+            validation: {
+                status: null
+            },
+            initialStep: null
+        }
+    }
+
+    async runValidation() {
+        for await (const machine of this._machines) {
+            this._currentStep = { names: Object.freeze(Object.keys(machine)) as readonly (keyof typeof machine)[], states: machine, validation: { status: null }, initialStep: null }
+            await this.runMachine(this._validation.nextInitialStep);
+
+            this._validation.nextInitialStep = this._currentStep.initialStep;
+            if (this._currentStep.validation.status !== null) {
+                this._validation.status = this._currentStep.validation.status;
+                this._validation.document = this._currentStep.validation.document;
+                break;
+            }
+        }
+        return this._validation;
+    }
+
+    private async runMachine(initialStep: string | null) {
+        const executeStep = async (step: keyof typeof this._currentStep.states, params?: PrevParams) => {
+            const currentStep = this._currentStep.states[step]
+            const next = (nextStep: keyof typeof this._currentStep.states, params?: PrevParams) =>
+                executeStep(nextStep, params)
+
+            await currentStep({
+                context: { ...this._context, prevParams: params },
+                next,
+                endValidation: this.endValidation.bind(this),
+                goToNextValidationStage: this.goToNextValidationStage.bind(this),
+                initialStep
+            })
+
+            if (this._currentStep.validation.status !== null || this._currentStep.completed !== undefined)
+                return { isValid: this._currentStep.validation.status, ...this._currentStep }
+        }
+        const nextStep = initialStep && this._currentStep.states[initialStep] ? initialStep : this._currentStep.names[0]
+        await executeStep(nextStep)
+    }
+
+    private endValidation({ success, document }: { success: boolean, document?: Document }) {
+        this._currentStep.validation.status = success
+        if (success) {
+            this._currentStep.validation.document = document || this._context.params.cursor
+        }
+    }
+
+
+    private goToNextValidationStage(initialStep: string | null = null) {
+        this._currentStep.completed = true
+        this._currentStep.initialStep = initialStep
+    }
+
+
+}

package/src/utils/roles/machines/read/A/index.ts

@@ -0,0 +1,19 @@
+import { States } from '../../interface'
+import { logMachineInfo } from '../../utils'
+
+export const STEP_A_STATES: States = {
+  checkSearchRequest: async ({ context, next, goToNextValidationStage }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "A", step: 1, stepName: "checkSearchRequest" })
+    if (context.params.type === 'search') {
+      return next('evaluateSearch')
+    }
+    return goToNextValidationStage()
+  },
+  evaluateSearch: async ({ context, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "A", step: 2, stepName: "evaluateSearch" })
+    // NOTE -> we don't support search operations
+    return endValidation({ success: false })
+  }
+}
+
+

package/src/utils/roles/machines/read/B/index.ts

@@ -0,0 +1,31 @@
+import { evaluateDocumentFiltersFn } from '../../commonValidators'
+import { States } from '../../interface'
+import { logMachineInfo } from '../../utils'
+
+export const STEP_B_STATES: States = {
+  checkDocumentsFilters: async ({ context, next, goToNextValidationStage }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 1, stepName: "checkDocumentsFilters" })
+    const { role } = context
+    if (role.document_filters) {
+      return next('evaluateDocumentsFiltersRead')
+    }
+    return goToNextValidationStage()
+  },
+  evaluateDocumentsFiltersRead: async ({ context, next, goToNextValidationStage }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 2, stepName: "evaluateDocumentsFiltersRead" })
+    const hasDocumentFiltersRead = await evaluateDocumentFiltersFn(context, "read")
+    if (!hasDocumentFiltersRead) return next('evaluateDocumentsFiltersWrite')
+    return goToNextValidationStage()
+  },
+  evaluateDocumentsFiltersWrite: async ({
+    context,
+    endValidation,
+    goToNextValidationStage
+  }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 3, stepName: "evaluateDocumentsFiltersWrite" })
+    const check = await evaluateDocumentFiltersFn(context, "write")
+    return check ? goToNextValidationStage() : endValidation({ success: false })
+  }
+}
+
+

package/src/utils/roles/machines/read/C/index.ts

@@ -0,0 +1,30 @@
+import { checkFieldsPropertyExists, evaluateTopLevelPermissionsFn } from '../../commonValidators'
+import { States } from '../../interface'
+import { logMachineInfo } from '../../utils'
+
+
+export const STEP_C_STATES: States = {
+  evaluateTopLevelRead: async ({ context, next, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "C", step: 1, stepName: "evaluateTopLevelRead" })
+    const check = await evaluateTopLevelPermissionsFn(context, "read")
+    return check
+      ? endValidation({ success: true })
+      : next('evaluateTopLevelWrite', { check })
+  },
+  evaluateTopLevelWrite: async ({ context, next, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "C", step: 2, stepName: "evaluateTopLevelWrite" })
+    const check = await evaluateTopLevelPermissionsFn(context, "write")
+    if (check) return endValidation({ success: true })
+    return context?.prevParams?.check === false
+      ? endValidation({ success: false })
+      : next('checkFieldsProperty')
+  },
+  checkFieldsProperty: async ({ context, goToNextValidationStage }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "C", step: 3, stepName: "checkFieldsProperty" })
+    const check = checkFieldsPropertyExists(context)
+    return goToNextValidationStage(
+      check ? 'checkIsValidFieldName' : 'checkAdditionalFields'
+    )
+  }
+}
+

package/src/utils/roles/machines/read/D/index.ts

@@ -0,0 +1,20 @@
+import { States } from '../../interface'
+import { logMachineInfo } from '../../utils'
+import {
+  checkAdditionalFieldsFn,
+  checkIsValidFieldNameFn,
+} from './validators'
+
+export const STEP_D_STATES: States = {
+  checkAdditionalFields: async ({ context, next, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "D", step: 1, stepName: "checkAdditionalFields" })
+    const check = checkAdditionalFieldsFn(context)
+    return check ? next('checkIsValidFieldName') : endValidation({ success: false })
+  },
+  checkIsValidFieldName: async ({ context, endValidation }) => {
+    logMachineInfo({ enabled: context.enableLog, machine: "D", step: 2, stepName: "checkIsValidFieldName" })
+    const document = checkIsValidFieldNameFn(context)
+    return endValidation({ success: !!Object.keys(document).length, document })
+  },
+}
+

package/src/utils/roles/machines/read/D/validators.ts

@@ -0,0 +1,24 @@
+import { MachineContext } from "../../interface"
+
+
+export const checkAdditionalFieldsFn = ({ role }: MachineContext) => {
+  return !!Object.keys(role.additional_fields || {}).length
+}
+
+export const checkIsValidFieldNameFn = ({ role, params }: MachineContext) => {
+  const { cursor } = params
+
+  const { fields = {}, additional_fields = {} } = role
+  const rulesOnId = !!(fields["_id"] || additional_fields["_id"])
+  const filteredDocument = Object.entries(cursor).reduce((filteredDocument, [key, value]) => {
+    if (fields![key]) {
+      return (role.fields![key].read || role.fields![key].write) ? { ...filteredDocument, [key]: value } : filteredDocument
+    }
+    if (additional_fields[key]) {
+      return (additional_fields[key]?.read || additional_fields[key]?.write) ? { ...filteredDocument, [key]: value } : filteredDocument
+    }
+    return { ...filteredDocument, [key]: value }
+  }, {})
+
+  return (rulesOnId || cursor._id === undefined) ? filteredDocument : { ...filteredDocument, "_id": cursor._id }
+}

package/src/utils/roles/machines/read/index.ts

@@ -0,0 +1,6 @@
+import { STEP_A_STATES } from "./A";
+import { STEP_B_STATES } from "./B";
+import { STEP_C_STATES } from "./C";
+import { STEP_D_STATES } from "./D";
+
+export const READ_MACHINE = [STEP_A_STATES, STEP_B_STATES, STEP_C_STATES, STEP_D_STATES]

package/src/utils/roles/machines/utils.ts

@@ -0,0 +1,54 @@
+import { Document, OptionalId } from "mongodb"
+import { User } from "../../../auth/dtos";
+import { Filter } from "../../../features/rules/interface";
+import { getValidRule } from "../../../services/mongodb-atlas/utils";
+import { Role } from "../interface"
+import { LogMachineInfoParams } from "./interface";
+
+/**
+ * Determines the first applicable role for a given user and document.
+ *
+ * @param {OptionalId<Document> | null} document - The document to check against role conditions.
+ * @param {User} user - The user for whom the role is being determined.
+ * @param {Role[]} [roles=[]] - The list of available roles to evaluate.
+ *
+ * @returns {Role | null} - Returns the first role that matches the `apply_when` condition, or `null` if none match.
+ */
+export const getWinningRole = (document: OptionalId<Document> | null, user: User, roles: Role[] = []): Role | null => {
+  if (!roles.length) return null
+  for (const role of roles) {
+    if (checkApplyWhen(role.apply_when, user, document)) {
+      return role;
+    }
+  }
+  return null
+}
+
+/**
+ * Checks if the `apply_when` condition is valid for the given user and document.
+ *
+ * @param {Role["apply_when"]} apply_when - The rule condition to evaluate.
+ * @param {User} user - The user for whom the condition is being checked.
+ * @param {WithId<Document> | null} document - The document to check against the condition.
+ * 
+ * @returns {boolean} - Returns `true` if at least one valid rule is found, otherwise `false`.
+ */
+export const checkApplyWhen = (apply_when: Role["apply_when"], user: User, document: OptionalId<Document> | null) => {
+  const validRule = getValidRule({ filters: [{ apply_when } as Filter], user, record: document })
+  return !!validRule.length
+}
+
+/**
+ * Logs machine step information if logging is enabled.
+ *
+ * @param {Object} params - The parameters for logging machine info.
+ * @param {boolean} params.enabled - Whether logging is enabled.
+ * @param {string} params.machine - The name of the machine.
+ * @param {number} params.step - The current step number.
+ * @param {string} params.stepName - The name of the current step.
+ *
+ * @returns {void}
+ */
+export const logMachineInfo = ({ enabled, machine, step, stepName }: LogMachineInfoParams) => {
+  if (enabled) console.log(`MACHINE ${machine} -> STEP ${step}: ${stepName}`)
+}