@xyo-network/sentinel-memory 2.85.5

package/src/SentinelIntervalAutomationWrapper.ts

@@ -0,0 +1,76 @@
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+import { SentinelIntervalAutomationPayload } from '@xyo-network/sentinel-model'
+
+export class SentinelIntervalAutomationWrapper<
+  T extends SentinelIntervalAutomationPayload = SentinelIntervalAutomationPayload,
+> extends PayloadWrapper<T> {
+  constructor(payload: T) {
+    super(payload)
+  }
+
+  protected get frequencyMillis() {
+    const frequency = this.jsonPayload().frequency
+    if (frequency === undefined) return Number.POSITIVE_INFINITY
+    const frequencyUnits = this.jsonPayload().frequencyUnits
+    switch (frequencyUnits ?? 'hour') {
+      case 'second': {
+        return frequency * 1000
+      }
+      case 'minute': {
+        return frequency * 60 * 1000
+      }
+      case 'hour': {
+        return frequency * 60 * 60 * 1000
+      }
+      case 'day': {
+        return frequency * 24 * 60 * 60 * 1000
+      }
+      default: {
+        return Number.POSITIVE_INFINITY
+      }
+    }
+  }
+
+  protected get remaining() {
+    return this.jsonPayload().remaining ?? Number.POSITIVE_INFINITY
+  }
+
+  next() {
+    const now = Date.now()
+    const previousStart = this.jsonPayload()?.start ?? now
+    const start = Math.max(previousStart, now)
+    const nextStart = start + this.frequencyMillis
+    this.setStart(nextStart)
+    this.consumeRemaining()
+    this.checkEnd()
+    return this
+  }
+
+  protected checkEnd() {
+    if (this.jsonPayload().start > (this.jsonPayload().end ?? Number.POSITIVE_INFINITY)) {
+      this.setStart(Number.POSITIVE_INFINITY)
+    }
+  }
+
+  protected consumeRemaining(count = 1) {
+    const remaining = Math.max(this.remaining - count, 0)
+    this.setRemaining(remaining)
+    if (remaining <= 0) this.setStart(Number.POSITIVE_INFINITY)
+  }
+
+  /**
+   * Sets the remaining of the wrapped automation
+   * @param remaining The remaining time in milliseconds
+   */
+  protected setRemaining(remaining: number) {
+    this.obj.remaining = remaining
+  }
+
+  /**
+   * Sets the start of the wrapped automation
+   * @param start The start time in milliseconds
+   */
+  protected setStart(start: number) {
+    this.obj.start = start
+  }
+}

package/src/SentinelRunner.ts

@@ -0,0 +1,114 @@
+import { assertEx } from '@xylabs/assert'
+import { Payload } from '@xyo-network/payload-model'
+import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+import {
+  isSentinelIntervalAutomation,
+  SentinelAutomationPayload,
+  SentinelInstance,
+  SentinelIntervalAutomationPayload,
+} from '@xyo-network/sentinel-model'
+
+import { SentinelIntervalAutomationWrapper } from './SentinelIntervalAutomationWrapper'
+
+export type OnSentinelRunnerTriggerResult = (result: Payload[]) => void
+
+export class SentinelRunner {
+  protected _automations: Record<string, SentinelAutomationPayload> = {}
+  protected onTriggerResult: OnSentinelRunnerTriggerResult | undefined
+  protected sentinel: SentinelInstance
+  protected timeoutId?: NodeJS.Timeout | string | number
+
+  constructor(sentinel: SentinelInstance, automations?: SentinelAutomationPayload[], onTriggerResult?: OnSentinelRunnerTriggerResult) {
+    this.sentinel = sentinel
+    this.onTriggerResult = onTriggerResult
+    if (automations) for (const automation of automations) this.add(automation)
+  }
+
+  get automations() {
+    return this._automations
+  }
+
+  private get next() {
+    // eslint-disable-next-line unicorn/no-array-reduce
+    return Object.values(this._automations).reduce<SentinelAutomationPayload | undefined>((previous, current) => {
+      if (isSentinelIntervalAutomation(current) && isSentinelIntervalAutomation(previous)) {
+        return current.start < (previous?.start ?? Number.POSITIVE_INFINITY) ? current : previous
+      }
+      return current
+      // eslint-disable-next-line unicorn/no-useless-undefined
+    }, undefined)
+  }
+
+  async add(automation: SentinelAutomationPayload, restart = true) {
+    const hash = await PayloadWrapper.hashAsync(automation)
+    this._automations[hash] = automation
+    if (restart) await this.restart()
+    return hash
+  }
+
+  find(hash: string) {
+    Object.entries(this._automations).find(([key]) => key === hash)
+  }
+
+  async remove(hash: string, restart = true) {
+    delete this._automations[hash]
+    if (restart) await this.restart()
+  }
+
+  removeAll() {
+    this.stop()
+    this._automations = {}
+  }
+
+  async restart() {
+    this.stop()
+    await this.start()
+  }
+
+  async start() {
+    // NOTE: Keep async to match module start signature
+    await Promise.resolve()
+    assertEx(this.timeoutId === undefined, 'Already started')
+    const automation = this.next
+    if (isSentinelIntervalAutomation(automation)) {
+      const now = Date.now()
+      const start = Math.max(automation.start ?? now, now)
+      const delay = Math.max(start - now, 0)
+      if (delay < Number.POSITIVE_INFINITY) {
+        this.timeoutId = setTimeout(async () => {
+          try {
+            // Run the automation
+            await this.trigger(automation)
+            this.stop()
+          } finally {
+            // No matter what start the next automation
+            await this.start()
+          }
+        }, delay)
+      }
+    }
+  }
+
+  stop() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId)
+      this.timeoutId = undefined
+    }
+  }
+
+  async update(hash: string, automation: SentinelAutomationPayload, restart = true) {
+    await this.remove(hash, false)
+    await this.add(automation, false)
+    if (restart) await this.restart()
+  }
+
+  private async trigger(automation: SentinelIntervalAutomationPayload) {
+    const wrapper = new SentinelIntervalAutomationWrapper(automation)
+    await this.remove(await wrapper.hashAsync(), false)
+    wrapper.next()
+    await this.add(wrapper.jsonPayload(), false)
+    const triggerResult = await this.sentinel.report()
+    this.onTriggerResult?.(triggerResult)
+    // await this.start()
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './MemorySentinel'

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}