WIP big refactor

Author: philippfromme

lib/ExecutionLog.js

@@ -1,114 +1,48 @@
 /**
  * @typedef {import('./types').ExecutionLogEntry} ExecutionLogEntry
- * @typedef {import('./types').TaskExecutionStatus} TaskExecutionStatus
+ * @typedef {import('./types').ExecutionLogEntryStatus} TaskExecutionStatus
+ * @typedef {import('./types').ExecutionLogElementInstanceEntry} ElementInstanceEntry
  * @typedef {import('./types').TaskExecutionPollData} TaskExecutionPollData
- * @typedef {import('./types').ElementInstanceEntry} ElementInstanceEntry
+ * @typedef {import('./types').TaskExecutionState} TaskExecutionState
+ *
+ * @typedef {import('@camunda8/sdk/dist/c8/lib/C8Dto').DeployResourceResponse} DeployResourceResponse
+ * @typedef {import('./types').ApiResponse<DeployResourceResponse>} DeployResponse
+ *
+ * @typedef {import('@camunda8/sdk/dist/c8/lib/C8Dto').CreateProcessInstanceResponse} CreateProcessInstanceResponse
+ * @typedef {import('./types').ApiResponse<CreateProcessInstanceResponse>} StartInstanceResponse
  */
 
-const ENTRY_TYPE = /** @type {const} */ ({
+export const EXECUTION_LOG_ENTRY_TYPE = {
   STATUS: 'status',
   JOB: 'job',
   USER_TASK: 'user-task',
   MESSAGE_SUBSCRIPTION: 'message-subscription',
   ELEMENT_INSTANCE: 'element-instance'
-});
-
-const TASK_STATUS = /** @type {const} */ ({
-  EXECUTING: 'executing',
-  COMPLETED: 'completed',
-  INCIDENT: 'incident',
-  TERMINATED: 'terminated',
-  CANCELED: 'canceled'
-});
+};
 
 const TIMESTAMP_FIELDS = {
-  [ENTRY_TYPE.JOB]: [ 'endTime' ],
-  [ENTRY_TYPE.USER_TASK]: [ 'completionDate', 'creationDate' ],
-  [ENTRY_TYPE.ELEMENT_INSTANCE]: [ 'endDate', 'startDate' ]
+  [EXECUTION_LOG_ENTRY_TYPE.JOB]: [ 'endTime' ],
+  [EXECUTION_LOG_ENTRY_TYPE.USER_TASK]: [ 'completionDate', 'creationDate' ],
+  [EXECUTION_LOG_ENTRY_TYPE.ELEMENT_INSTANCE]: [ 'endDate', 'startDate' ]
 };
 
-const SIMPLE_POLL_SLICES = [
+const POLL_RESPONSE_FIELDS = [
   {
     resultField: 'jobsResult',
-    entryType: ENTRY_TYPE.JOB
+    entryType: EXECUTION_LOG_ENTRY_TYPE.JOB
   },
   {
     resultField: 'userTasksResult',
-    entryType: ENTRY_TYPE.USER_TASK
+    entryType: EXECUTION_LOG_ENTRY_TYPE.USER_TASK
   },
   {
     resultField: 'messageSubscriptionsResult',
-    entryType: ENTRY_TYPE.MESSAGE_SUBSCRIPTION
+    entryType: EXECUTION_LOG_ENTRY_TYPE.MESSAGE_SUBSCRIPTION
   }
 ];
 
-const SNAPSHOT_ENTRY_TYPES = [
-  ENTRY_TYPE.JOB,
-  ENTRY_TYPE.USER_TASK,
-  ENTRY_TYPE.MESSAGE_SUBSCRIPTION,
-  ENTRY_TYPE.ELEMENT_INSTANCE
-];
-
-function createEmptyPollEntriesByType() {
-  return {
-    [ENTRY_TYPE.JOB]: [],
-    [ENTRY_TYPE.USER_TASK]: [],
-    [ENTRY_TYPE.MESSAGE_SUBSCRIPTION]: [],
-    [ENTRY_TYPE.ELEMENT_INSTANCE]: []
-  };
-}
-
 /**
- * Check whether a set of log entries represents a finished execution.
- *
- * @param {ExecutionLogEntry[]} entries
- *
- * @returns {boolean}
- */
-export function isFinished(entries) {
-  return entries.some(
-    e => e.type === ENTRY_TYPE.STATUS && (
-      e.status === TASK_STATUS.COMPLETED
-      || e.status === TASK_STATUS.INCIDENT
-      || e.status === TASK_STATUS.TERMINATED
-      || e.status === TASK_STATUS.CANCELED
-    )
-  );
-}
-
-/**
- * Derive the display-ready list of entries from raw entries.
- * - When finished, the transient `executing` status is dropped entirely.
- * - While running, `executing` is moved to the end so it always appears last.
- *
- * @param {ExecutionLogEntry[]} entries
- *
- * @returns {ExecutionLogEntry[]}
- */
-export function getDisplayEntries(entries) {
-  const finished = isFinished(entries);
-  const withoutExecuting = [];
-  const executing = [];
-
-  for (const entry of entries) {
-    if (entry.type === ENTRY_TYPE.STATUS && entry.status === TASK_STATUS.EXECUTING) {
-      executing.push(entry);
-    } else {
-      withoutExecuting.push(entry);
-    }
-  }
-
-  withoutExecuting.sort((a, b) => a.timestamp - b.timestamp);
-
-  if (finished) {
-    return withoutExecuting;
-  }
-
-  return [ ...withoutExecuting, ...executing ];
-}
-
-/**
- * Get the most meaningful timestamp from an API result item.
+ * Get the most meaningful timestamp from 
  *
  * job → endTime  (when the job last changed state)
  * user-task → completionDate, then creationDate
@@ -117,11 +51,10 @@ export function getDisplayEntries(entries) {
  *
  * @param {string} type
  * @param {any} data
- * @param {number} pollTimestamp
  *
  * @returns {number}
  */
-function getTimestamp(type, data, pollTimestamp) {
+function getTimestamp(type, data) {
   const candidateFields = TIMESTAMP_FIELDS[type] || [];
 
   for (const field of candidateFields) {
@@ -137,7 +70,8 @@ function getTimestamp(type, data, pollTimestamp) {
     }
   }
 
-  return pollTimestamp;
+  // TODO: for message-subscription, we currently have no reliable timestamp field. We could consider using the poll timestamp, but that would require passing it through multiple layers. For now, we just use the current time as a fallback.
+  return Date.now();
 }
 
 /**
@@ -171,12 +105,13 @@ export default class ExecutionLog {
    * @param {Object} [injector]
    */
   constructor(injector) {
+    this._state = null;
 
-    /** @type {ExecutionLogEntry[]} */
-    this._statusEntries = [];
+    this._deployResponse = null;
+
+    this._startInstanceResponse = null;
 
-    /** @type {Record<string, ExecutionLogEntry[]>} */
-    this._pollEntriesByType = createEmptyPollEntriesByType();
+    this._pollResponse = null;
 
     /** @type {ExecutionLogEntry[]} */
     this._entries = [];
@@ -186,135 +121,103 @@ export default class ExecutionLog {
   }
 
   /**
-   * Record a status entry.
+   * Add state.
    *
-   * @param {TaskExecutionStatus} status
+   * @param {TaskExecutionState} state
    * @param {number} [timestamp]
-   * @param {Object} [data]
    *
    * @returns {ExecutionLogEntry[]}
    */
-  recordStatus(status, timestamp = Date.now(), data = {}) {
-    this._statusEntries = [ ...this._statusEntries, {
-      type: ENTRY_TYPE.STATUS,
-      status,
-      timestamp,
-      data
-    } ];
+  addState(state, timestamp = Date.now()) {
+    this._state = { type: state, timestamp };
 
     this._updateEntries();
 
     return this._entries;
   }
 
   /**
-   * Record a poll entry and refresh poll snapshots.
+   * Set deploy response.
    *
-   * @param {TaskExecutionPollData} pollEntry
+   * @param {DeployResponse} deployResponse
    *
    * @returns {ExecutionLogEntry[]}
    */
-  recordPoll(pollEntry) {
-    const {
-      jobsResult,
-      userTasksResult,
-      messageSubscriptionsResult,
-      elementInstancesResult,
-      elementId,
-      timestamp
-    } = /** @type {any} */ (pollEntry);
-
-    const pollData = {
-      jobsResult,
-      userTasksResult,
-      messageSubscriptionsResult
-    };
-
-    const nextPollEntriesByType = { ...this._pollEntriesByType };
-
-    // Simple slices (jobs, user tasks, message subscriptions)
-    for (const { resultField, entryType } of SIMPLE_POLL_SLICES) {
-      const result = pollData[resultField];
-
-      if (result.success) {
-        nextPollEntriesByType[entryType] = this._buildSimpleSliceEntries(
-          result.response.items,
-          entryType,
-          timestamp
-        );
-      }
-    }
-
-    // Element instances
-    if (elementInstancesResult.success) {
-      nextPollEntriesByType[ENTRY_TYPE.ELEMENT_INSTANCE] = this._buildElementInstanceEntries({
-        allInstances: elementInstancesResult.response.items || [],
-        elementId,
-        timestamp
-      });
-    }
-
-    this._pollEntriesByType = nextPollEntriesByType;
+  setDeployResponse(deployResponse) {
+    this._deployResponse = deployResponse;
 
     this._updateEntries();
 
     return this._entries;
   }
 
   /**
+   * Set start instance response.
+   *
+   * @param {StartInstanceResponse} startInstanceResponse
+   *
    * @returns {ExecutionLogEntry[]}
    */
-  getEntries() {
+  setStartInstanceResponse(startInstanceResponse) {
+    this._instanceStartedData = startInstanceResponse;
+
+    this._updateEntries();
+
     return this._entries;
   }
 
   /**
-   * Get entries projected for display.
+   * Set poll response.
+   *
+   * @param {TaskExecutionPollData} pollResponse
    *
    * @returns {ExecutionLogEntry[]}
    */
-  getDisplayEntries() {
-    return getDisplayEntries(this._entries);
+  setPollResponse(pollResponse) {
+    this._pollResponse = pollResponse;
+
+    this._updateEntries();
+
+    return this._entries;
   }
 
   /**
-   * Whether the log contains a terminal status (completed, incident, canceled).
-   *
-   * @returns {boolean}
+   * @returns {ExecutionLogEntry[]}
    */
-  isFinished() {
-    return isFinished(this._entries);
+  getEntries() {
+    return this._entries;
   }
 
   /**
-   * Clear all entries.
+   * Clear all data and entries.
    */
   reset() {
-    this._statusEntries = [];
-    this._pollEntriesByType = createEmptyPollEntriesByType();
+    this._state = null;
+    this._deployResponse = null;
+    this._startInstanceResponse = null;
+    this._pollResponse = null;
     this._entries = [];
   }
 
   /**
    * Update merged entries from status history + poll snapshots.
    */
   _updateEntries() {
-    const pollEntries = SNAPSHOT_ENTRY_TYPES.flatMap(type => this._pollEntriesByType[type]);
-    this._entries = [ ...this._statusEntries, ...pollEntries ];
+
+    // TODO: implement entire entries logic based on state and all available data (deploy, start instance, poll)
   }
 
   /**
    * @param {any[]} items
    * @param {'job'|'user-task'|'message-subscription'} type
-   * @param {number} pollTimestamp
    *
    * @returns {ExecutionLogEntry[]}
    */
-  _buildSimpleSliceEntries(items, type, pollTimestamp) {
+  _buildSimpleSliceEntries(items, type) {
     return (items || []).map(data => ({
       type,
       data,
-      timestamp: getTimestamp(type, data, pollTimestamp)
+      timestamp: getTimestamp(type, data)
     }));
   }
 
@@ -326,10 +229,10 @@ export default class ExecutionLog {
    * @returns {ElementInstanceEntry}
    */
   _createElementInstanceEntry({ instance, timestamp }) {
-    return /** @type {import('./types').ElementInstanceEntry} */ ({
-      type: ENTRY_TYPE.ELEMENT_INSTANCE,
+    return /** @type {import('./types').ExecutionLogElementInstanceEntry} */ ({
+      type: EXECUTION_LOG_ENTRY_TYPE.ELEMENT_INSTANCE,
       data: instance,
-      timestamp: getTimestamp(ENTRY_TYPE.ELEMENT_INSTANCE, instance, timestamp)
+      timestamp: getTimestamp(EXECUTION_LOG_ENTRY_TYPE.ELEMENT_INSTANCE, instance, timestamp)
     });
   }