@platformatic/watt-admin 0.6.0-alpha.1 → 0.6.0-alpha.3

package/web/backend/schemas/index.ts

@@ -0,0 +1,226 @@
+import { type FromSchema } from 'json-schema-to-ts'
+
+const dateSchema = { type: 'string', format: 'date-time' } as const
+
+export const modeSchema = { type: 'string', enum: ['start', 'stop'] } as const
+export type Mode = FromSchema<typeof modeSchema>
+
+const memoryDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: dateSchema,
+    rss: { type: 'number' },
+    totalHeap: { type: 'number' },
+    usedHeap: { type: 'number' },
+    newSpace: { type: 'number' },
+    oldSpace: { type: 'number' }
+  },
+  required: ['date', 'rss', 'totalHeap', 'usedHeap', 'newSpace', 'oldSpace']
+} as const
+export type MemoryDataPoint = FromSchema<typeof memoryDataPointSchema>
+
+const cpuDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: dateSchema,
+    cpu: { type: 'number' },
+    eventLoop: { type: 'number' }
+  },
+  required: ['date', 'cpu', 'eventLoop']
+} as const
+export type CpuDataPoint = FromSchema<typeof cpuDataPointSchema>
+
+const latencyDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: { type: 'string', format: 'date-time' },
+    p90: { type: 'number' },
+    p95: { type: 'number' },
+    p99: { type: 'number' }
+  },
+  required: ['date', 'p90', 'p95', 'p99']
+} as const
+export type LatencyDataPoint = FromSchema<typeof latencyDataPointSchema>
+
+const requestDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: { type: 'string', format: 'date-time' },
+    count: { type: 'number' },
+    rps: { type: 'number' }
+  },
+  required: ['date', 'count', 'rps']
+} as const
+export type RequestDataPoint = FromSchema<typeof requestDataPointSchema>
+
+const kafkaDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: { type: 'string', format: 'date-time' },
+    producers: { type: 'number' },
+    producedMessages: { type: 'number' },
+    consumers: { type: 'number' },
+    consumersStreams: { type: 'number' },
+    consumersTopics: { type: 'number' },
+    consumedMessages: { type: 'number' },
+    hooksMessagesInFlight: { type: 'number' },
+    hooksDlqMessagesTotal: { type: 'number' },
+  },
+  required: [
+    'date',
+    'producers',
+    'producedMessages',
+    'consumers',
+    'consumersStreams',
+    'consumersTopics',
+    'consumedMessages',
+    'hooksMessagesInFlight',
+    'hooksDlqMessagesTotal',
+  ]
+} as const
+export type KafkaDataPoint = FromSchema<typeof kafkaDataPointSchema>
+
+const undiciDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: { type: 'string', format: 'date-time' },
+    idleSockets: { type: 'number' },
+    openSockets: { type: 'number' },
+    pendingRequests: { type: 'number' },
+    queuedRequests: { type: 'number' },
+    activeRequests: { type: 'number' },
+    sizeRequests: { type: 'number' },
+  },
+  required: [
+    'date',
+    'idleSockets',
+    'openSockets',
+    'pendingRequests',
+    'queuedRequests',
+    'activeRequests',
+    'sizeRequests',
+  ]
+} as const
+export type UndiciDataPoint = FromSchema<typeof undiciDataPointSchema>
+
+const websocketDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: { type: 'string', format: 'date-time' },
+    connections: { type: 'number' }
+  },
+  required: [
+    'date',
+    'connections'
+  ]
+} as const
+export type WebsocketDataPoint = FromSchema<typeof websocketDataPointSchema>
+
+const nodejsDataPointSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    date: { type: 'string', format: 'date-time' },
+    resources: { type: 'number' }
+  },
+  required: [
+    'date',
+    'resources'
+  ]
+} as const
+export type NodejsDataPoint = FromSchema<typeof nodejsDataPointSchema>
+
+export const requiredMetricKeys = ['dataMem', 'dataCpu', 'dataKafka', 'dataReq', 'dataLatency', 'dataUndici', 'dataWebsocket', 'dataNodejs'] as const
+export const metricResponseSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    dataMem: { type: 'array', items: memoryDataPointSchema },
+    dataCpu: { type: 'array', items: cpuDataPointSchema },
+    dataLatency: { type: 'array', items: latencyDataPointSchema },
+    dataReq: { type: 'array', items: requestDataPointSchema },
+    dataKafka: { type: 'array', items: kafkaDataPointSchema },
+    dataUndici: { type: 'array', items: undiciDataPointSchema },
+    dataWebsocket: { type: 'array', items: websocketDataPointSchema },
+    dataNodejs: { type: 'array', items: nodejsDataPointSchema }
+  },
+  required: requiredMetricKeys
+} as const
+export type MetricsResponse = FromSchema<typeof metricResponseSchema>
+export type SingleMetricResponse = {
+  [K in keyof MetricsResponse]: MetricsResponse[K] extends (infer T)[] ? T : never
+}
+
+export const pidParamSchema = { type: 'object', additionalProperties: false, properties: { pid: { type: 'number' } }, required: ['pid'] } as const
+export type PidParam = FromSchema<typeof pidParamSchema>
+
+export const profileSchema = { type: 'string', enum: ['cpu', 'heap'] } as const
+export type Profile = FromSchema<typeof profileSchema>
+
+export const selectableRuntimeSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    pid: {
+      type: 'integer'
+    },
+    cwd: {
+      type: 'string'
+    },
+    argv: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    uptimeSeconds: {
+      type: 'number'
+    },
+    execPath: {
+      type: 'string'
+    },
+    nodeVersion: {
+      type: 'string'
+    },
+    projectDir: {
+      type: 'string'
+    },
+    packageName: {
+      type: 'string'
+    },
+    packageVersion: {
+      type: 'string'
+    },
+    url: {
+      type: 'string'
+    },
+    platformaticVersion: {
+      type: 'string'
+    },
+    selected: {
+      type: 'boolean'
+    }
+  },
+  required: [
+    'pid',
+    'cwd',
+    'argv',
+    'uptimeSeconds',
+    'execPath',
+    'nodeVersion',
+    'projectDir',
+    'packageName',
+    'packageVersion',
+    'url',
+    'platformaticVersion',
+    'selected'
+  ]
+} as const
+export type SelectableRuntime = FromSchema<typeof selectableRuntimeSchema>

package/web/backend/utils/bytes.ts

@@ -0,0 +1 @@
+export const bytesToMB = (bytes: number): number => Number((bytes / (1024 * 1024)).toFixed(2))

package/web/backend/utils/client.openapi.ts

@@ -0,0 +1,29 @@
+import fs from 'fs/promises'
+import { create } from '@platformatic/service'
+import { join, resolve } from 'node:path'
+
+const __dirname = import.meta.dirname
+
+async function clientOpenapi () {
+  const basePath = resolve(__dirname, join('..', 'platformatic.json'))
+  const server = await create(basePath, {
+    service: { openapi: true },
+    watch: false,
+    plugins: {
+      paths: [
+        {
+          path: resolve(__dirname, join('..', 'plugins')),
+          encapsulate: false
+        },
+        resolve(__dirname, join('..', 'routes'))
+      ]
+    }
+  })
+
+  await server.start({})
+  const { body } = await server.getApplication().inject('/documentation/json')
+  await fs.writeFile('openapi.json', body)
+  await server.close()
+}
+
+clientOpenapi()

package/web/backend/utils/constants.ts

@@ -0,0 +1,4 @@
+export const MS_WAITING = 1000
+
+// This is to avoid the mapped metrics array from growing indefinitely (and therefore a memory leak): store the last 10 minutes of metrics (1# * 10m * 60s).
+export const MAX_STORED_METRICS = 600

package/web/backend/utils/metrics-helpers.ts

@@ -0,0 +1,89 @@
+import type { CpuDataPoint, KafkaDataPoint, LatencyDataPoint, MemoryDataPoint, MetricsResponse, NodejsDataPoint, RequestDataPoint, SingleMetricResponse, UndiciDataPoint, WebsocketDataPoint } from '../schemas/index.ts'
+import { MAX_STORED_METRICS } from './constants.ts'
+
+export type MappedMetrics = Record<number, {
+  aggregated: MetricsResponse,
+  services: Record<string, Record<'all' | number, MetricsResponse>>
+}>
+
+export const websocketMetricMap = {
+  active_ws_composer_connections: 'connections',
+} as const
+export const isWebsocketMetricName = (metricName: string): metricName is keyof typeof websocketMetricMap => metricName in websocketMetricMap
+
+export const nodejsMetricMap = {
+  active_resources_event_loop: 'resources'
+} as const
+export const isNodejsMetricName = (metricName: string): metricName is keyof typeof nodejsMetricMap => metricName in nodejsMetricMap
+
+export const undiciMetricMap = {
+  http_client_stats_free: 'idleSockets',
+  http_client_stats_connected: 'openSockets',
+  http_client_stats_pending: 'pendingRequests',
+  http_client_stats_queued: 'queuedRequests',
+  http_client_stats_running: 'activeRequests',
+  http_client_stats_size: 'sizeRequests'
+} as const
+export const isUndiciMetricName = (metricName: string): metricName is keyof typeof undiciMetricMap => metricName in undiciMetricMap
+
+export const kafkaMetricMap = {
+  kafka_producers: 'producers',
+  kafka_produced_messages: 'producedMessages',
+  kafka_consumers: 'consumers',
+  kafka_consumers_streams: 'consumersStreams',
+  kafka_consumers_topics: 'consumersTopics',
+  kafka_consumed_messages: 'consumedMessages',
+  kafka_hooks_messages_in_flight: 'hooksMessagesInFlight',
+  kafka_hooks_dlq_messages_total: 'hooksDlqMessagesTotal'
+} as const
+export const isKafkaMetricName = (metricName: string): metricName is keyof typeof kafkaMetricMap => metricName in kafkaMetricMap
+
+export const addMetricDataPoint = <T extends MemoryDataPoint | CpuDataPoint | LatencyDataPoint | RequestDataPoint | KafkaDataPoint | UndiciDataPoint | WebsocketDataPoint | NodejsDataPoint>(metrics: T[], dataPoint: T) => {
+  if (metrics.length >= MAX_STORED_METRICS) {
+    metrics.shift()
+  }
+  metrics.push(dataPoint)
+}
+
+export const initMetricsObject = (date: string): SingleMetricResponse => ({ dataMem: initMemData(date), dataCpu: initCpuData(date), dataKafka: initKafkaData(date), dataReq: initReqData(date), dataLatency: initLatencyData(date), dataUndici: initUndiciData(date), dataWebsocket: initWebsocketData(date), dataNodejs: initNodejsData(date) })
+
+export const initMetricsResponse = (date?: string, length?: number): MetricsResponse => {
+  const isArray = date && length
+  return {
+    dataCpu: isArray ? Array.from({ length }, () => initCpuData(date)) : [],
+    dataLatency: isArray ? Array.from({ length }, () => initLatencyData(date)) : [],
+    dataMem: isArray ? Array.from({ length }, () => initMemData(date)) : [],
+    dataReq: isArray ? Array.from({ length }, () => initReqData(date)) : [],
+    dataKafka: isArray ? Array.from({ length }, () => initKafkaData(date)) : [],
+    dataUndici: isArray ? Array.from({ length }, () => initUndiciData(date)) : [],
+    dataWebsocket: isArray ? Array.from({ length }, () => initWebsocketData(date)) : [],
+    dataNodejs: isArray ? Array.from({ length }, () => initNodejsData(date)) : [],
+  }
+}
+
+const initMemData = (date: string): MemoryDataPoint => ({ date, rss: 0, totalHeap: 0, usedHeap: 0, newSpace: 0, oldSpace: 0 })
+const initCpuData = (date: string): CpuDataPoint => ({ date, cpu: 0, eventLoop: 0 })
+const initLatencyData = (date: string): LatencyDataPoint => ({ date, p90: 0, p95: 0, p99: 0 })
+const initReqData = (date: string): RequestDataPoint => ({ date, count: 0, rps: 0, })
+const initKafkaData = (date: string): KafkaDataPoint => ({ date, consumedMessages: 0, consumers: 0, consumersStreams: 0, consumersTopics: 0, hooksDlqMessagesTotal: 0, hooksMessagesInFlight: 0, producedMessages: 0, producers: 0 })
+const initUndiciData = (date: string): UndiciDataPoint => ({ date, activeRequests: 0, idleSockets: 0, openSockets: 0, pendingRequests: 0, queuedRequests: 0, sizeRequests: 0 })
+const initWebsocketData = (date: string): WebsocketDataPoint => ({ date, connections: 0 })
+const initNodejsData = (date: string): NodejsDataPoint => ({ date, resources: 0 })
+
+export const initServiceMetrics = ({ areMultipleWorkersEnabled, metrics, pid, serviceId, workers }: {
+  metrics: MappedMetrics,
+  pid: number,
+  serviceId: string,
+  workers: number,
+  areMultipleWorkersEnabled: boolean
+}): void => {
+  if (!metrics[pid].services[serviceId]) {
+    metrics[pid].services[serviceId] = { all: initMetricsResponse() }
+
+    if (areMultipleWorkersEnabled) {
+      for (let i = 0; i < workers; i++) {
+        metrics[pid].services[serviceId][i] = initMetricsResponse()
+      }
+    }
+  }
+}

package/web/backend/utils/metrics.ts

@@ -0,0 +1,202 @@
+import { RuntimeApiClient } from '@platformatic/control'
+import type { FastifyInstance } from 'fastify'
+import { requiredMetricKeys } from '../schemas/index.ts'
+import type { MemoryDataPoint, CpuDataPoint } from '../schemas/index.ts'
+import { bytesToMB } from './bytes.ts'
+import { getReqRps } from './rps.ts'
+import { addMetricDataPoint, initMetricsObject, initMetricsResponse, initServiceMetrics, isKafkaMetricName, isNodejsMetricName, isUndiciMetricName, isWebsocketMetricName, kafkaMetricMap, nodejsMetricMap, undiciMetricMap, websocketMetricMap } from './metrics-helpers.ts'
+
+export const getMetrics = async ({ loaded: { metrics }, log }: FastifyInstance): Promise<void> => {
+  try {
+    const api = new RuntimeApiClient()
+    const runtimes = await api.getRuntimes()
+    for (const { pid } of runtimes) {
+      const date = new Date().toISOString()
+      const aggregatedMetrics = initMetricsObject(date)
+      let aggregatedRss = 0
+
+      const runtimeMetrics = await api.getRuntimeMetrics(pid, { format: 'json' })
+      if (!metrics[pid]) {
+        metrics[pid] = { services: {}, aggregated: initMetricsResponse() }
+      }
+
+      const { applications, entrypoint } = await api.getRuntimeApplications(pid)
+      for (const service of applications) {
+        const { id: serviceId } = service
+        const workers = 'workers' in service && service?.workers ? service.workers : 1
+        const areMultipleWorkersEnabled = workers > 1
+        const isEntrypointService = entrypoint === serviceId
+        initServiceMetrics({ metrics, pid, serviceId, workers, areMultipleWorkersEnabled })
+        const workerMetrics = initMetricsResponse(date, workers)
+        const serviceMetrics = initMetricsObject(date)
+
+        const incDataMetric = <T extends 'dataMem' | 'dataCpu'>({ key, workerId, data, prop }: { key: T, workerId: number, data: number, prop: Exclude<T extends 'dataMem' ? keyof MemoryDataPoint : keyof CpuDataPoint, 'date'> }) => {
+          if (areMultipleWorkersEnabled) {
+            workerMetrics[key as 'dataMem'][workerId][prop as 'rss'] = data
+          }
+          serviceMetrics[key as 'dataMem'][prop as 'rss'] += data
+          aggregatedMetrics[key as 'dataMem'][prop as 'rss'] += serviceMetrics[key as 'dataMem'][prop as 'rss']
+        }
+
+        for (const metric of runtimeMetrics) {
+          if (metric.values.length > 0) {
+            const [{ value, labels }] = metric.values
+            const workerId = labels.workerId ?? 0
+
+            if (isEntrypointService) {
+              if (metric.name === 'process_resident_memory_bytes') {
+                aggregatedRss = bytesToMB(value)
+              }
+            }
+
+            if (serviceId === labels.applicationId) {
+              if (metric.name === 'nodejs_heap_size_total_bytes') {
+                incDataMetric({ key: 'dataMem', workerId, data: bytesToMB(value), prop: 'totalHeap' })
+              }
+
+              if (metric.name === 'nodejs_heap_size_used_bytes') {
+                incDataMetric({ key: 'dataMem', workerId, data: bytesToMB(value), prop: 'usedHeap' })
+              }
+
+              if (metric.name === 'nodejs_heap_space_size_used_bytes') {
+                metric.values.forEach(({ value, labels }) => {
+                  if (labels?.space === 'new') {
+                    incDataMetric({ key: 'dataMem', workerId, data: bytesToMB(value), prop: 'newSpace' })
+                  } else if (labels?.space === 'old') {
+                    incDataMetric({ key: 'dataMem', workerId, data: bytesToMB(value), prop: 'oldSpace' })
+                  }
+                })
+              }
+
+              if (metric.name === 'thread_cpu_percent_usage') {
+                incDataMetric({ key: 'dataCpu', workerId, data: value / workers, prop: 'cpu' })
+              }
+
+              if (metric.name === 'nodejs_eventloop_utilization') {
+                incDataMetric({ key: 'dataCpu', workerId, data: (value * 100) / workers, prop: 'eventLoop' })
+              }
+
+              if (metric.name === 'http_request_all_summary_seconds') {
+                for (const metricValue of metric.values) {
+                  const data = metricValue.value * 1000
+                  if (data > 0) {
+                    if (metricValue.labels?.quantile === 0.9) {
+                      if (data > serviceMetrics.dataLatency.p90) {
+                        if (areMultipleWorkersEnabled) {
+                          workerMetrics.dataLatency[workerId].p90 = data
+                        }
+                        serviceMetrics.dataLatency.p90 = data
+                      }
+                      if (isEntrypointService) {
+                        aggregatedMetrics.dataLatency.p90 = serviceMetrics.dataLatency.p90
+                      }
+                    }
+                    if (metricValue.labels?.quantile === 0.95) {
+                      if (data > serviceMetrics.dataLatency.p95) {
+                        if (areMultipleWorkersEnabled) {
+                          workerMetrics.dataLatency[workerId].p95 = data
+                        }
+                        serviceMetrics.dataLatency.p95 = data
+                      }
+                      if (isEntrypointService) {
+                        aggregatedMetrics.dataLatency.p95 = serviceMetrics.dataLatency.p95
+                      }
+                    }
+                    if (metricValue.labels?.quantile === 0.99) {
+                      if (data > serviceMetrics.dataLatency.p99) {
+                        if (areMultipleWorkersEnabled) {
+                          workerMetrics.dataLatency[workerId].p99 = data
+                        }
+                        serviceMetrics.dataLatency.p99 = data
+                      }
+                      if (isEntrypointService) {
+                        aggregatedMetrics.dataLatency.p99 = serviceMetrics.dataLatency.p99
+                      }
+                    }
+                  }
+                }
+              }
+
+              if (metric.name === 'http_request_all_duration_seconds') {
+                const count = metric.values.reduce((acc, { metricName, value }) => {
+                  if (metricName === 'http_request_all_duration_seconds_count') {
+                    acc += value
+                  }
+                  return acc
+                }, 0)
+                if (!count) {
+                  log.debug(metric.values, 'Empty HTTP request count')
+                } else {
+                  if (areMultipleWorkersEnabled) {
+                    workerMetrics.dataReq[workerId].count = count
+                    const rps = getReqRps(count, metrics[pid].services[serviceId][workerId].dataReq)
+                    workerMetrics.dataReq[workerId].rps = rps
+                  }
+                  serviceMetrics.dataReq.count += count
+                  const rps = getReqRps(serviceMetrics.dataReq.count, metrics[pid].services[serviceId].all.dataReq)
+                  serviceMetrics.dataReq.rps = rps
+
+                  if (isEntrypointService) {
+                    aggregatedMetrics.dataReq.count = serviceMetrics.dataReq.count
+                    aggregatedMetrics.dataReq.rps = rps
+                  }
+                }
+              }
+
+              if (isUndiciMetricName(metric.name)) {
+                const key = undiciMetricMap[metric.name]
+                serviceMetrics.dataUndici[key] = value
+                aggregatedMetrics.dataUndici[key] = value
+                if (areMultipleWorkersEnabled) {
+                  workerMetrics.dataUndici[workerId][key] = value
+                }
+              }
+
+              if (isWebsocketMetricName(metric.name)) {
+                const key = websocketMetricMap[metric.name]
+                serviceMetrics.dataWebsocket[key] = value
+                aggregatedMetrics.dataWebsocket[key] = value
+                if (areMultipleWorkersEnabled) {
+                  workerMetrics.dataWebsocket[workerId][key] = value
+                }
+              }
+
+              if (isNodejsMetricName(metric.name)) {
+                const key = nodejsMetricMap[metric.name]
+                serviceMetrics.dataNodejs[key] = value
+                aggregatedMetrics.dataNodejs[key] = value
+                if (areMultipleWorkersEnabled) {
+                  workerMetrics.dataNodejs[workerId][key] = value
+                }
+              }
+
+              if (isKafkaMetricName(metric.name)) {
+                const key = kafkaMetricMap[metric.name]
+                serviceMetrics.dataKafka[key] = value
+                aggregatedMetrics.dataKafka[key] = value
+                if (areMultipleWorkersEnabled) {
+                  workerMetrics.dataKafka[workerId][key] = value
+                }
+              }
+            }
+          }
+        }
+
+        serviceMetrics.dataMem.rss = aggregatedRss
+        aggregatedMetrics.dataMem.rss = aggregatedRss
+
+        if (areMultipleWorkersEnabled) {
+          for (let i = 0; i < workers; i++) {
+            workerMetrics.dataMem[i].rss = aggregatedRss
+            requiredMetricKeys.forEach(key => addMetricDataPoint(metrics[pid].services[serviceId][i][key], workerMetrics[key][i]))
+          }
+        }
+
+        requiredMetricKeys.forEach(key => addMetricDataPoint(metrics[pid].services[serviceId].all[key], serviceMetrics[key]))
+      }
+      requiredMetricKeys.forEach(key => addMetricDataPoint(metrics[pid].aggregated[key], aggregatedMetrics[key]))
+    }
+  } catch (error) {
+    log.warn(error, 'Unable to get runtime metrics. Retry will start soon...')
+  }
+}

package/web/backend/utils/rps.ts

@@ -0,0 +1,3 @@
+import type { RequestDataPoint } from '../schemas/index.ts'
+
+export const getReqRps = (count: number, req: RequestDataPoint[]) => Math.abs(count - (req[req.length - 1]?.count || 0))

package/web/backend/utils/runtimes.ts

@@ -0,0 +1,21 @@
+import type { Runtime } from '@platformatic/control'
+import type { SelectableRuntime } from '../schemas/index.ts'
+
+export const getSelectableRuntimes = (runtimes: Runtime[], includeAdmin: boolean): SelectableRuntime[] => {
+  const selectableRuntimes: SelectableRuntime[] = []
+  for (const runtime of runtimes) {
+    if (!includeAdmin && runtime.packageName === '@platformatic/watt-admin' && !process.env.INCLUDE_ADMIN) {
+      continue
+    }
+
+    let selected = true
+    if (process.env.SELECTED_RUNTIME) {
+      selected = process.env.SELECTED_RUNTIME === runtime.pid.toString()
+    }
+
+    selectableRuntimes.push({ ...runtime, packageName: runtime.packageName || '', packageVersion: runtime.packageVersion || '', url: runtime.url || '', selected })
+  }
+  return selectableRuntimes
+}
+
+export const getPidToLoad = (runtimes: SelectableRuntime[]): number => runtimes.find(({ selected }) => selected === true)?.pid || 0

package/web/backend/utils/states.ts

@@ -0,0 +1,3 @@
+import type { Mode } from '../schemas/index.ts'
+
+export const checkRecordState = ({ from, to }: { from: Mode | undefined, to: Mode }): boolean => (from === undefined && to === 'start') || (from === 'start' && to === 'stop') || (from === 'stop' && to === 'start')