{"version":3,"file":"ploson-rule-engine.modern.mjs","sources":["../src/rule-dm.js","../src/utils.js","../src/processing.js","../src/rule.js","../src/trigger-dm.js","../src/manager-logic.js","../src/manager.js"],"sourcesContent":["import joi from 'joi';\n\n// .required()\n// actuator: joi\n//   .string()\n//   .default('backend')\n//   .description('ID of where the rule should be loaded and run.'),\n\nexport const Rule = joi\n  .object()\n  .unknown()\n  .keys({\n    id: joi.string().required().description('Identifier for this particular rule.'),\n    active: joi\n      .boolean()\n      .default(true)\n      .description('If the rule is active or not. An inactive rule is not run at all.'),\n    ttl: joi\n      .date()\n      .default(17407501722694)\n      .description('At this time (ISO timestamp) the rule will be set to inactive.'),\n    onLoad: joi.any().description('Ploson code to e.g. create reusable constants and functions.'),\n    // triggered: joi.object().keys({\n    cooldown: joi\n      .number()\n      .min(0)\n      .description(\"A rule can't be triggered again unless this number of seconds has passed.\"),\n    resetCondition: joi\n      .any()\n      .description('Ploson code to check if rule should reset, if it is in flipped state.'),\n    resetAction: joi.any().description('Ploson code block to execute when resetCondition is true.'),\n    // }),\n    condition: joi\n      .any()\n      .default(true)\n      .description(\n        'Ploson code to check if rule should execute (state to flipped, run actions etc).',\n      ),\n    action: joi\n      .any()\n      .description('Ploson code block to execute when condition is true (& not in flipped state).'),\n  });\n\nexport const validateRule = (item) => {\n  const { value, error, warning } = Rule.validate(item);\n  if (warning) console.warn(warning);\n  return error ? [Error(error)] : [undefined, value];\n};\n","import * as R from 'ramda';\nimport { createPatch } from 'rfc6902';\nimport { OBJ } from 'ploson';\nimport isFunction from 'lodash.isfunction';\n\nexport const idUniquesInFirst = R.differenceWith(\n  ({ id: id1 } = OBJ, { id: id2 } = OBJ) => id1 === id2,\n);\n\nexport const sleep = (ms) => new Promise((r) => setTimeout(r, ms));\n\nexport const createInterval = (func, ms, val) => {\n  if (!isFunction(func)) return undefined;\n  const id = setInterval(func, ms, val);\n  return () => clearInterval(id);\n};\n\nexport const createTimeout = (func, ms, val) => {\n  if (!isFunction(func)) return undefined;\n  const id = setTimeout(func, ms, val);\n  return () => clearTimeout(id);\n};\n\nexport const configuredCollectionDiff =\n  ({\n    idKey = 'id',\n    ignoreKeys,\n    skipIf,\n    autoRemoveCondition,\n    transformAutoRemoved,\n    transformAdded,\n    transformUpdated,\n  } = {}) =>\n  (prev) =>\n    R.converge(R.mergeLeft, [\n      R.reduce(\n        (acc, item) => {\n          if (skipIf && skipIf(item)) return acc;\n          if (autoRemoveCondition && autoRemoveCondition(item)) return acc;\n          const { [idKey]: id } = item;\n          const prevItem = R.find(R.propEq('id', id))(prev);\n          if (prevItem) {\n            const args = R.when(() => ignoreKeys, R.map(R.omit(ignoreKeys)))([prevItem, item]);\n            const patch = createPatch(...args);\n            return R.isEmpty(patch)\n              ? acc\n              : {\n                  ...acc,\n                  updated: [\n                    ...acc.updated,\n                    transformUpdated ? transformUpdated(item, prevItem, patch) : item,\n                  ],\n                };\n          }\n          return { ...acc, added: [...acc.added, transformAdded ? transformAdded(item) : item] };\n        },\n        { added: [], updated: [] },\n      ),\n      R.pipe(\n        R.converge(R.concat, [\n          idUniquesInFirst(prev),\n          R.pipe(\n            R.filter(autoRemoveCondition ?? R.F),\n            R.map((item) => {\n              const { [idKey]: id } = item;\n              const prevItem = R.find(R.propEq('id', id))(prev);\n              return transformAutoRemoved ? transformAutoRemoved(item, prevItem) : item;\n            }),\n          ),\n        ]),\n        R.objOf('removed'),\n      ),\n    ]);\n\nexport const collectionDiff = configuredCollectionDiff();\n","import * as R from 'ramda';\nimport isError from 'lodash.iserror';\n\nexport const runPlosonOrReject = async ({ ploson, code, createReturn = R.identity }) => {\n  const result = await ploson(code);\n  return isError(result) ? Promise.reject(result) : createReturn(result);\n};\n\nexport const groupByHasCallback = R.groupBy(({ callback }) =>\n  callback ? 'updatedSoft' : 'updatedHard',\n);\n\nexport const populateCallbacks = R.map(({ trigger, ploson, ...item }) =>\n  runPlosonOrReject({\n    ploson,\n    code: trigger,\n    createReturn: (callback) => ({ ...item, trigger, ploson, callback }),\n  }),\n);\n\nexport const getTriggerCallbackActor = (callback, targets) => (sendCb) =>\n  callback((payload, dynamicTargets) => {\n    // console.log('payload:', payload);\n    return sendCb({ type: 'FIRE_RULES', targets: dynamicTargets ?? targets, payload });\n  });\n","import { createMachine, assign } from 'xstate';\n// import * as R from 'ramda';\nimport { ARR, OBJ } from 'ploson';\nimport { isBefore } from 'date-fns/fp/index.js'; // eslint-disable-line\n\nimport { runPlosonOrReject } from './processing';\n\nconst machineConf = {\n  predictableActionArguments: true,\n  id: 'rule',\n  initial: 'idle',\n  on: {\n    INACTIVATE: { actions: 'log', target: 'inactive' },\n    UPDATE: { actions: 'updateRule' },\n  },\n  states: {\n    inactive: { on: { ACTIVATE: 'idle' } },\n    idle: { on: { FIRE: 'checkExpired' } },\n    checkExpired: {\n      // always: [{ cond: 'isExpired', target: 'expired' }, { target: 'checkCondition' }],\n      invoke: {\n        src: 'checkIfExpired',\n        onDone: 'checkCondition',\n        onError: 'expired',\n      },\n    },\n    checkCondition: {\n      invoke: {\n        src: 'condition',\n        onDone: [{ cond: 'conditionTruthy', target: 'executeAction' }, { target: 'idle' }],\n        onError: { actions: 'logError', target: 'idle' },\n      },\n    },\n    executeAction: {\n      invoke: {\n        src: 'action',\n        onDone: { target: 'fired' },\n        onError: { actions: 'logError', target: 'fired' },\n      },\n    },\n    fired: {\n      type: 'parallel',\n      on: { ABORT: 'idle' },\n      states: {\n        switcher: {\n          initial: 'decide',\n          states: {\n            decide: {\n              always: [{ cond: 'hasHysteresis', target: 'flipped' }, { target: 'done' }],\n            },\n            flipped: { on: { FIRE: 'checkCondition' } },\n            checkCondition: {\n              invoke: {\n                src: 'resetCondition',\n                onDone: [\n                  { cond: 'conditionTruthy', target: 'executeResetAction' },\n                  { target: 'flipped' },\n                ],\n                onError: { actions: 'logError', target: 'executeResetAction' },\n              },\n            },\n            executeResetAction: {\n              invoke: {\n                src: 'resetAction',\n                onDone: { target: 'done' },\n                onError: { actions: 'logError', target: 'done' },\n              },\n            },\n            done: { type: 'final' },\n          },\n        },\n        temperature: {\n          initial: 'decide',\n          states: {\n            decide: {\n              always: [{ cond: 'hasCooldown', target: 'hot' }, { target: 'cool' }],\n            },\n            hot: { after: { COOLDOWN: 'cool' } },\n            cool: { type: 'final' },\n          },\n        },\n      },\n      onDone: 'idle',\n    },\n    expired: { type: 'final' },\n  },\n};\n\nconst options = {\n  delays: {\n    COOLDOWN: ({ cooldown }) => cooldown,\n  },\n  guards: {\n    hasCooldown: ({ cooldown }) => Boolean(cooldown),\n    hasHysteresis: ({ resetCondition }) => Boolean(resetCondition),\n    conditionTruthy: (ctx, { data: [ok] = ARR }) => Boolean(ok),\n    isExpired: ({ ttl }) => isBefore(new Date())(ttl),\n  },\n  services: {\n    checkIfExpired: ({ ttl }, { payload }) => {\n      // console.log('Check if expired:', payload);\n      return isBefore(new Date())(ttl)\n        ? Promise.reject(Error('Take onError path'))\n        : Promise.resolve({ payload });\n    },\n    condition: ({ condition, ploson }, { data: { payload } }) => {\n      // console.log('condition:', condition, '| payload:', payload);\n      return runPlosonOrReject({\n        ploson,\n        payload,\n        code: [',', { payload: Promise.resolve(payload) }, condition],\n        createReturn: (res) => [res, payload],\n      });\n    },\n    resetCondition: ({ resetCondition, ploson }, { payload }) =>\n      runPlosonOrReject({\n        ploson,\n        payload,\n        code: [',', { payload: Promise.resolve(payload) }, resetCondition],\n        createReturn: (res) => [res, payload],\n      }),\n    action: async ({ action, ploson }, { data: [, payload] = ARR }) => {\n      // console.log('action, payload:', payload);\n      return runPlosonOrReject({\n        ploson,\n        payload,\n        code: [',', { payload: Promise.resolve(payload) }, action],\n      });\n    },\n    resetAction: ({ resetAction, ploson }, { data: [, payload] = ARR }) =>\n      runPlosonOrReject({\n        ploson,\n        payload,\n        code: [',', { payload: Promise.resolve(payload) }, resetAction],\n      }),\n  },\n  actions: {\n    log: () => console.log('Inactivation GOTTEN!'),\n    logError: (ctx, { data }) => console.error(data),\n    updateRule: assign({\n      ttl: (ctx, { rule: { ttl } = OBJ }) => ttl,\n      hysteresis: (ctx, { rule: { hysteresis } = OBJ }) => hysteresis,\n      condition: (ctx, { rule: { condition } = OBJ }) => {\n        // console.log('assign condition:', condition)\n        return condition;\n      },\n      action: (ctx, { rule: { action } = OBJ }) => {\n        // console.log('assign action:', action);\n        return action;\n      },\n      cooldown: (ctx, { rule: { cooldown } = OBJ }) => cooldown,\n      resetCondition: (ctx, { rule: { resetCondition } = OBJ }) => resetCondition,\n      resetAction: (ctx, { rule: { resetAction } = OBJ }) => resetAction,\n    }),\n  },\n};\n\nexport const ruleMachine = createMachine(machineConf, options);\n","import joi from 'joi';\n\n// .required()\n// actuator: joi\n//   .string()\n//   .default('backend')\n//   .description('ID of where the rule should be loaded and run.'),\n\nexport const Trigger = joi\n  .object()\n  .unknown()\n  .keys({\n    id: joi.string().required().description('Identifier for this particular trigger.'),\n    active: joi\n      .boolean()\n      .default(true)\n      .description('If the trigger is active or not. An inactive trigger is not run at all.'),\n    trigger: joi\n      .array()\n      .required()\n      .items(joi.any())\n      .description('Ploson function representing a callback actor.'),\n    // }),\n    targets: joi\n      .array()\n      .items(joi.string())\n      .unique()\n      .description('List of rule IDs that this trigger should trigger.'),\n  });\n\nexport const validateTrigger = (item) => {\n  const { value, error, warning } = Trigger.validate(item);\n  if (warning) console.warn(warning);\n  return error ? [Error(error)] : [undefined, value];\n};\n","import { spawn, send, assign, actions } from 'xstate';\nimport { createRunner } from 'ploson';\nimport * as R from 'ramda';\nimport isFunction from 'lodash.isfunction';\nimport { createPatch } from 'rfc6902';\n\nimport { ruleMachine } from './rule';\nimport { validateRule } from './rule-dm';\nimport { validateTrigger } from './trigger-dm';\nimport { runPlosonOrReject, getTriggerCallbackActor } from './processing';\n\nconst { stop } = actions;\n\n/** RULE */\n\nexport const createPrepareAddedRule =\n  (staticEnv) =>\n  async (ctx, { data: item }) => {\n    const [error, value] = validateRule(item);\n    if (error) return Promise.reject(error);\n\n    const ploson = createRunner({ staticEnv });\n    const { onLoad } = item;\n    if (onLoad) await runPlosonOrReject({ ploson, code: onLoad });\n    // console.log('RULE TO ADD:', value);\n    return { ...value, ploson };\n  };\n\nexport const prepareUpdatedRule = async ({ rules }, { data: item }) => {\n  const [error, value] = validateRule(item);\n  if (error) return Promise.reject(error);\n\n  const prevItem = R.find(R.propEq('id', value.id))(rules);\n  const { ref, ploson, ...pureItem } = prevItem;\n  // console.log('prepareUpdatedRule items:', pureItem, value);\n  const patch = createPatch(pureItem, value);\n  // console.log('prepareUpdatedRule patch:', patch);\n  return { ...value, ploson, ref, lastPatch: patch };\n};\n\nexport const getUpdateRuleActions = ({ rules }, { data: rule }) => {\n  const { id, lastPatch, ref, active } = rule;\n  const ix = R.findIndex(R.propEq('id', id), rules);\n  const conditionChange = R.any(R.pipe(R.prop('path'), R.startsWith('/condition')))(lastPatch);\n  const activated = R.pipe(R.find(R.propEq('path', '/active')), R.propEq('value', true))(lastPatch);\n  const actionObjects = [\n    assign({ rules: R.update(ix, rule)(rules) }),\n    send({ type: 'UPDATE', rule }, { to: ref }),\n    ...(!active ? [send('INACTIVATE', { to: ref })] : []),\n    ...(conditionChange ? [send('ABORT', { to: ref })] : []),\n    ...(activated ? [send('ACTIVATE', { to: ref })] : []),\n  ];\n  return actionObjects;\n};\n\nexport const getAddedRule = ({ id, active, ...rest }) => {\n  console.info('Spawning Rule with id:', id);\n  const spawnedIfActive = active ? { ref: spawn(ruleMachine.withContext(rest), id) } : {};\n  return { id, active, ...rest, ...spawnedIfActive };\n};\n\n/** TRIGGER */\n\nexport const createPrepareAddedTrigger =\n  (staticEnvTriggers) =>\n  async (ctx, { data }) => {\n    const [error, value] = validateTrigger(data);\n    if (error) return Promise.reject(error);\n\n    const { trigger, ...item } = value;\n    const ploson = createRunner({ staticEnv: staticEnvTriggers });\n    const callback = await runPlosonOrReject({ ploson, code: trigger });\n    if (!isFunction(callback)) return Promise.reject(Error('trigger is not a function'));\n    return { ...item, trigger, ploson, callback };\n  };\n\nexport const prepareUpdatedTrigger = async ({ triggers }, { data }) => {\n  const [error, value] = validateTrigger(data);\n  if (error) return Promise.reject(error);\n  const { id, trigger, active } = value;\n\n  const prevItem = R.find(R.propEq('id', id))(triggers);\n  const { callback, ploson, ref, doUpdateTrigger: _, ...pureItem } = prevItem;\n  const patch = createPatch(pureItem, value);\n\n  const activated = R.pipe(R.find(R.propEq('path', '/active')), R.propEq('value', true))(patch);\n  const doUpdateTrigger = activated || (active && R.any(R.propEq('path', '/trigger'))(patch));\n\n  const newCallback = doUpdateTrigger && (await runPlosonOrReject({ ploson, code: trigger }));\n  if (newCallback && !isFunction(newCallback))\n    return Promise.reject(Error('trigger is not a function'));\n  return {\n    ...value,\n    ploson,\n    callback,\n    ref,\n    ...(doUpdateTrigger ? { callback: newCallback } : {}),\n    doUpdateTrigger,\n  };\n};\n\nexport const getAddedTrigger = ({ active, callback, targets, id, ...rest }) => {\n  console.info('Spawning Trigger with id:', id);\n  const spawnedIfActive = active\n    ? { ref: spawn(getTriggerCallbackActor(callback, targets), id) }\n    : {};\n  return { id, active, targets, callback, ...rest, ...spawnedIfActive };\n};\n\nexport const updateTriggerAction = ({ triggers }, { data }) => {\n  const { id, doUpdateTrigger, callback, ref, targets, active } = data;\n  const ix = R.findIndex(R.propEq('id', id), triggers);\n\n  const actionObjects = [\n    ...(doUpdateTrigger || (!active && ref) ? [stop(ref)] : []),\n    ...(doUpdateTrigger ? [spawn(getTriggerCallbackActor(callback, targets), id)] : []),\n    assign({ triggers: R.update(ix, data)(triggers) }),\n  ];\n  // console.log('actionObjects:', actionObjects);\n  return actionObjects;\n};\n","import { createMachine, assign, spawn, actions, send, interpret } from 'xstate';\nimport { createRunner, OBJ, ARR, FUNC } from 'ploson';\nimport * as R from 'ramda';\n\nimport { Rule } from './rule-dm';\nimport { configuredCollectionDiff, idUniquesInFirst } from './utils';\nimport {\n  getAddedRule,\n  getAddedTrigger,\n  createPrepareAddedRule,\n  createPrepareAddedTrigger,\n  // spawnTriggerActors,\n  prepareUpdatedRule,\n  prepareUpdatedTrigger,\n  getUpdateRuleActions,\n  updateTriggerAction,\n} from './manager-logic';\nimport { runPlosonOrReject, groupByHasCallback, populateCallbacks } from './processing';\n\nconst { pure, stop } = actions;\n\nconst deferredActions = {\n  ADD_RULE: { actions: 'defer' },\n  ADD_TRIGGER: { actions: 'defer' },\n  UPDATE_RULE: { actions: 'defer' },\n  UPDATE_TRIGGER: { actions: 'defer' },\n  DELETE_RULE: { actions: 'defer' },\n  DELETE_TRIGGER: { actions: 'defer' },\n};\n\nconst context = {\n  $queue: [],\n  rules: [\n    // { ploson, ref, ...rule }\n  ],\n  triggers: [\n    // { id, trigger, targets, ploson, callback, ref }\n  ],\n};\n\nconst machineConf = {\n  predictableActionArguments: true,\n  id: 'rule-manager',\n  initial: 'initRules',\n  context,\n  states: {\n    retryRules: { after: { RETRY_DELAY: { target: 'initRules' } } },\n    initRules: {\n      invoke: {\n        src: 'ruleFetcher',\n        onDone: 'prepareRules',\n        onError: { actions: 'logError', target: 'retryRules' },\n      },\n    },\n    prepareRules: {\n      invoke: {\n        id: 'processInitRules',\n        src: 'processRules',\n        onDone: { actions: 'addRules', target: 'initTriggers' },\n        onError: { actions: 'logError', target: 'initTriggers' },\n      },\n    },\n    retryTriggers: { after: { RETRY_DELAY: { target: 'initTriggers' } } },\n    initTriggers: {\n      invoke: {\n        src: 'triggerFetcher',\n        onDone: { target: 'prepareTriggers' },\n        onError: { actions: 'logError', target: 'retryTriggers' },\n      },\n    },\n    prepareTriggers: {\n      invoke: {\n        id: 'processInitTriggers',\n        src: 'processTriggers',\n        onDone: { actions: ['addTriggers'], target: 'running' },\n        onError: { actions: 'logError', target: 'running' },\n      },\n    },\n    running: {\n      entry: 'spawnUpdater',\n      initial: 'idle',\n      on: {\n        FIRE_RULES: { actions: 'fireRules' },\n      },\n      states: {\n        idle: {\n          entry: 'recallFromQueue',\n          on: {\n            UPDATE_RULES: { target: 'updatingRules' },\n            UPDATE_TRIGGERS: { target: 'processingTriggers' },\n            ADD_RULE: { target: 'prepareAddingRule' },\n            ADD_TRIGGER: { target: 'prepareAddingTrigger' },\n            UPDATE_RULE: { target: 'prepareUpdatingRule' },\n            UPDATE_TRIGGER: { target: 'prepareUpdatingTrigger' },\n            DELETE_RULE: { actions: 'removeRule' },\n            DELETE_TRIGGER: { actions: 'removeTrigger' },\n          },\n        },\n        prepareAddingRule: {\n          invoke: {\n            src: 'prepareAddedRule',\n            onError: { actions: 'logError', target: 'idle' },\n            onDone: { actions: 'addRuleExternal', target: 'idle' },\n          },\n          on: deferredActions,\n        },\n        prepareAddingTrigger: {\n          invoke: {\n            src: 'prepareAddedTrigger',\n            onError: { actions: 'logError', target: 'idle' },\n            onDone: { actions: 'addTriggerExternal', target: 'idle' },\n          },\n          on: deferredActions,\n        },\n        prepareUpdatingRule: {\n          invoke: {\n            src: 'prepareUpdatedRule',\n            onError: { actions: 'logError', target: 'idle' },\n            onDone: { actions: 'updateRuleExternal', target: 'idle' },\n          },\n          on: deferredActions,\n        },\n        prepareUpdatingTrigger: {\n          invoke: {\n            src: 'prepareUpdatedTrigger',\n            onError: { actions: 'logError', target: 'idle' },\n            onDone: { actions: 'updateTriggerExternal', target: 'idle' },\n          },\n          on: deferredActions,\n        },\n        updatingRules: {\n          invoke: {\n            id: 'processRuleUpdates',\n            src: 'processRules',\n            onDone: {\n              actions: ['removeRules', 'addRules', 'updateRules'],\n              target: 'idle',\n            },\n            onError: { actions: 'logError', target: 'idle' },\n          },\n        },\n        processingTriggers: {\n          invoke: {\n            id: 'processTriggerUpdates',\n            src: 'processTriggers',\n            onDone: {\n              actions: ['killActors', 'sendUpdateTriggers'],\n              // target: 'updatingTriggers',\n            },\n            onError: { actions: 'logError', target: 'idle' },\n          },\n          on: {\n            PASS_ON_RESULT: 'updatingTriggers',\n          },\n        },\n        updatingTriggers: {\n          entry: ['removeTriggers', 'updateTriggers', 'addTriggers'],\n          always: { target: 'idle' },\n        },\n      },\n    },\n  },\n};\n\nconst getOptions = ({\n  ruleFetcher = () => Promise.resolve(ARR),\n  triggerFetcher = () => Promise.resolve(ARR),\n  staticEnv = OBJ,\n  staticEnvTriggers = staticEnv,\n  updater = FUNC,\n}) => {\n  const rulesDiff = configuredCollectionDiff({\n    ignoreKeys: ['ref', 'ploson', 'active'],\n    // skipIf: ({ active }) => !active,\n    autoRemoveCondition: ({ active }) => !active,\n    transformAdded: (item) => {\n      const { value, error, warning } = Rule.validate(item);\n      if (error || warning) console.warn(error || warning);\n      const ploson = createRunner({ staticEnv });\n      return { ...value, ploson };\n    },\n    transformUpdated: (item, { ploson, ref }) => ({ ...item, ploson, ref }),\n  });\n\n  const triggersDiff = configuredCollectionDiff({\n    ignoreKeys: ['ploson', 'callback', 'ref'],\n    autoRemoveCondition: ({ active }) => !active,\n    transformAutoRemoved: (item, { ref }) => ({ ...item, ref }),\n    transformAdded: ({ targets = ARR, ...item }) => {\n      const ploson = createRunner({ staticEnv: staticEnvTriggers });\n      return { ...item, targets, ploson };\n    },\n    transformUpdated: (item, { ploson, callback, ref }, patch) => ({\n      ...item,\n      ploson,\n      ref,\n      ...(R.any(R.propEq('path', '/trigger'))(patch) || !item.active ? OBJ : { callback }),\n    }),\n  });\n\n  const prepareAddedRule = createPrepareAddedRule(staticEnv);\n  const prepareAddedTrigger = createPrepareAddedTrigger(staticEnvTriggers);\n\n  return {\n    delays: { RETRY_DELAY: 30_000 },\n\n    services: {\n      ruleFetcher,\n      triggerFetcher,\n      processRules: async ({ rules }, { data = ARR }) => {\n        const { added, updated, removed } = rulesDiff(rules)(data);\n        await Promise.all(\n          R.map(({ onLoad, ploson }) => {\n            if (!onLoad) return Promise.resolve();\n            return runPlosonOrReject({ ploson, code: onLoad });\n          })(added),\n        );\n        // console.log('Rules processed (onLoad) and ready to be run:', added, removed, updated);\n        return { added, toRemove: removed, toUpdate: updated };\n      },\n      processTriggers: async ({ triggers }, { data = ARR }) => {\n        // console.log('processTriggers - prev, next:', triggers, data);\n        const { added, updated, removed } = triggersDiff(triggers)(data);\n        // console.log('processTriggers - added, updated, removed:', added, updated, removed);\n        // console.log('processTriggers - added.trigger:', added?.[0]?.trigger);\n        const { updatedHard = ARR, updatedSoft = ARR } = groupByHasCallback(updated);\n        // console.log('processTriggers - grouped hard, soft:', updatedHard, updatedSoft);\n        const toAdd = await Promise.all(populateCallbacks([...added, ...updatedHard]));\n        return { added: toAdd, toRemove: removed, toUpdate: updatedSoft, toRestart: updatedHard };\n      },\n      prepareAddedRule,\n      prepareAddedTrigger,\n      prepareUpdatedRule,\n      prepareUpdatedTrigger,\n    },\n\n    actions: {\n      defer: assign({\n        $queue: ({ $queue }, e) => R.append(e, $queue),\n      }),\n      recallFromQueue: pure(({ $queue: [first, ...rest] }) => [\n        ...(first ? [send(first)] : []),\n        assign({ $queue: rest }),\n      ]),\n      addRuleExternal: assign({\n        rules: ({ rules }, { data }) => R.append(getAddedRule(data))(rules),\n      }),\n      removeRule: pure(({ rules }, { data: { id } = OBJ }) => {\n        const rIx = R.findIndex(R.propEq('id', id), rules);\n        if (rIx === -1) return [];\n        const { ref } = rules[rIx];\n        return [stop(ref), assign({ rules: R.remove(rIx, 1)(rules) })];\n      }),\n      addTriggerExternal: assign({\n        triggers: ({ triggers }, { data }) => R.append(getAddedTrigger(data))(triggers),\n      }),\n      removeTrigger: pure(({ triggers }, { data: { id } = OBJ }) => {\n        const rIx = R.findIndex(R.propEq('id', id), triggers);\n        if (rIx === -1) return [];\n        const { ref } = triggers[rIx];\n        return [stop(ref), assign({ triggers: R.remove(rIx, 1)(triggers) })];\n      }),\n      updateRuleExternal: pure(getUpdateRuleActions),\n      updateTriggerExternal: pure(updateTriggerAction),\n      logError: (ctx, { data }) => console.error(data),\n\n      killActors: pure((ctx, { data: { toRemove = ARR, toRestart = ARR } = OBJ }) => {\n        // console.log('killActors toRemove, toRestart:', toRemove, toRestart);\n        const events = R.pipe(\n          R.filter(({ ref }) => Boolean(ref)),\n          R.map(({ ref }) => stop(ref)),\n        )([...toRemove, ...toRestart]);\n        // console.log('killActors events:', events);\n        return events;\n      }),\n      sendUpdateTriggers: send((ctx, { data }) => ({ type: 'PASS_ON_RESULT', data })),\n      removeTriggers: assign({\n        triggers: ({ triggers }, { data: { toRemove = ARR } = OBJ }) =>\n          idUniquesInFirst(triggers, toRemove),\n        // TODO: Destructors??\n      }),\n      addTriggers: assign({\n        triggers: ({ triggers }, { data: { added = ARR, toRestart = ARR } = OBJ }) => {\n          // console.info('Spawning triggers:', R.pluck('id', added));\n          const addedTriggers = R.map(getAddedTrigger)([...added, ...toRestart]);\n          return [...triggers, ...addedTriggers];\n        },\n      }),\n      updateTriggers: assign({\n        triggers: ({ triggers }, { data: { toUpdate = ARR } = OBJ }) => {\n          // R.over(R.lensIndex(R.findIndex(R.propEq('id', id))), R.assoc('targets'))(triggers);\n          return R.map((item) => {\n            const updated = R.find(R.propEq('id', item.id))(toUpdate);\n            return updated ? R.assoc('targets', updated.targets ?? [], item) : item;\n          })(triggers);\n        },\n      }),\n      removeRules: assign({\n        rules: ({ rules }, { data: { toRemove = ARR } = OBJ }) => idUniquesInFirst(rules, toRemove),\n      }),\n      addRules: assign({\n        rules: ({ rules }, { data: { added = ARR } = OBJ }) => {\n          const addedRules = R.map(getAddedRule)(added);\n          return [...rules, ...addedRules];\n        },\n      }),\n      updateRules: pure((ctx, { data: { toUpdate = ARR } = OBJ }) =>\n        R.map((rule) => send({ type: 'UPDATE_RULE', data: rule }))(toUpdate),\n      ),\n      fireRules: pure(({ rules }, { targets, payload }) => {\n        // console.log('fireRules...:', targets, payload);\n        const events = R.reduce(\n          (acc, { id, active, ref }) =>\n            active && ref && R.includes(id, targets)\n              ? [...acc, send({ type: 'FIRE', payload }, { to: ref })]\n              : acc,\n          [],\n        )(rules);\n        // console.log('fireRules:', events);\n        return events;\n      }),\n      spawnUpdater: assign({ updaterRef: () => spawn(updater, 'rule-trigger-updater') }),\n    },\n  };\n};\n\nexport const createRuleEngineMachine = (config) => {\n  return createMachine(machineConf, getOptions(config));\n};\n\nexport const createRuleEngine = (...args) => interpret(createRuleEngineMachine(...args));\n"],"names":["Rule","joi","object","unknown","keys","id","string","required","description","active","boolean","default","ttl","date","onLoad","any","cooldown","number","min","resetCondition","resetAction","condition","action","item","value","error","warning","validate","console","warn","Error","undefined","idUniquesInFirst","R","differenceWith","id1","OBJ","id2","configuredCollectionDiff","idKey","ignoreKeys","skipIf","autoRemoveCondition","transformAutoRemoved","transformAdded","transformUpdated","prev","converge","mergeLeft","reduce","acc","_idKey","find","propEq","prevItem","args","when","map","omit","patch","createPatch","isEmpty","updated","added","pipe","concat","filter","F","objOf","_excluded","runPlosonOrReject","async","ploson","code","createReturn","identity","result","Promise","reject","groupBy","callback","populateCallbacks","_ref","trigger","targets","sendCb","payload","dynamicTargets","type","options","delays","COOLDOWN","guards","hasCooldown","Boolean","hasHysteresis","conditionTruthy","ctx","data","ok","ARR","isExpired","isBefore","Date","services","checkIfExpired","resolve","res","actions","log","logError","updateRule","assign","rule","hysteresis","ruleMachine","createMachine","predictableActionArguments","initial","on","INACTIVATE","target","UPDATE","states","inactive","ACTIVATE","idle","FIRE","checkExpired","invoke","src","onDone","onError","checkCondition","cond","executeAction","fired","ABORT","switcher","decide","always","flipped","executeResetAction","done","temperature","hot","after","cool","expired","Trigger","array","items","unique","validateTrigger","stop","prepareUpdatedRule","rules","validateRule","ref","pureItem","_objectWithoutPropertiesLoose","lastPatch","getUpdateRuleActions","ix","findIndex","conditionChange","prop","startsWith","activated","update","send","to","actionObjects","getAddedRule","rest","_excluded2","info","_extends","spawn","withContext","prepareUpdatedTrigger","triggers","_excluded4","doUpdateTrigger","newCallback","isFunction","getAddedTrigger","_ref2","getTriggerCallbackActor","updateTriggerAction","pure","deferredActions","ADD_RULE","ADD_TRIGGER","UPDATE_RULE","UPDATE_TRIGGER","DELETE_RULE","DELETE_TRIGGER","machineConf","context","$queue","retryRules","RETRY_DELAY","initRules","prepareRules","retryTriggers","initTriggers","prepareTriggers","running","entry","FIRE_RULES","UPDATE_RULES","UPDATE_TRIGGERS","prepareAddingRule","prepareAddingTrigger","prepareUpdatingRule","prepareUpdatingTrigger","updatingRules","processingTriggers","PASS_ON_RESULT","updatingTriggers","createRuleEngineMachine","config","ruleFetcher","triggerFetcher","staticEnv","staticEnvTriggers","updater","FUNC","rulesDiff","createRunner","triggersDiff","processRules","removed","all","toRemove","toUpdate","processTriggers","updatedHard","updatedSoft","groupByHasCallback","toRestart","prepareAddedRule","prepareAddedTrigger","_excluded3","defer","e","append","recallFromQueue","first","addRuleExternal","removeRule","rIx","remove","addTriggerExternal","removeTrigger","updateRuleExternal","updateTriggerExternal","killActors","sendUpdateTriggers","removeTriggers","addTriggers","updateTriggers","_updated$targets","assoc","removeRules","addRules","updateRules","fireRules","includes","spawnUpdater","updaterRef","getOptions","createRuleEngine","interpret"],"mappings":"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"}