chore(types): several typing improvements

.eslintrc.js

@@ -13,9 +13,10 @@ module.exports = {
     'prettier',
   ],
   rules: {
-    '@typescript-eslint/no-var-requires': 0,
-    '@typescript-eslint/interface-name-prefix': 0,
-    '@typescript-eslint/no-empty-function': 0,
+    '@typescript-eslint/no-var-requires': 'off',
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/no-empty-function': 'off',
+    '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_'}],
     eqeqeq: 1,
     quotes: ['error', 'single', { avoidEscape: true }],
   },

README.md

@@ -23,7 +23,7 @@ npm i flowed
 <script src="https://cdn.jsdelivr.net/npm/flowed@latest/dist/lib/flowed.js" charset="utf-8"></script>
 ```
 
-Or change `latest` in the URL for any available version.
+Or replace `latest` in the URL for your desired version.
 
 **From package**
 

package.json

@@ -82,9 +82,10 @@
     "all": true,
     "exclude": [
       "test",
-      "coverage",
+      "ops",
       "dist",
-      "*.js",
+      ".eslintrc.js",
+      "webpack.config.js",
       "web/flowed.js"
     ],
     "check-coverage": true,

src/engine/flow-manager.ts

@@ -2,7 +2,7 @@ import { readFile } from 'fs';
 import * as http from 'http';
 import * as https from 'https';
 import { IncomingMessage } from 'http';
-import { TaskResolverMap, ValueMap, FlowedPlugin, FlowedLogger, FlowedLogEntry } from '../types';
+import { TaskResolverMap, ValueMap, FlowedPlugin, FlowedLogger, FlowedLogEntry, OptPromise } from '../types';
 import { Flow } from './flow';
 import { FlowSpec } from './specs';
 
@@ -22,7 +22,7 @@ export class FlowManager {
     resolvers: TaskResolverMap = {},
     context: ValueMap = {},
     options: ValueMap = {},
-  ): Promise<ValueMap> {
+  ): OptPromise<ValueMap> {
     const flow = new Flow(flowSpec);
     return flow.start(params, expectedResults, resolvers, context, options);
   }
@@ -91,10 +91,10 @@ export class FlowManager {
     }
 
     return new Promise<ValueMap>((resolveFlow, reject) => {
-      (client || https)
+      client! // eslint-disable-line @typescript-eslint/no-non-null-assertion
         .get(flowSpecUrl, (res: IncomingMessage) => {
           const { statusCode } = res;
-          const contentType = res.headers['content-type'] || 'application/json';
+          const contentType = res.headers['content-type'] ?? 'application/json';
 
           let error;
           if (statusCode !== 200) {

src/engine/flow-state/flow-pausing.ts

@@ -20,8 +20,7 @@ export class FlowPausing extends FlowState {
     }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected postProcessFinished(error: Error | boolean, stopFlowExecutionOnError: boolean): void {
+  protected postProcessFinished(error: Error | boolean, _stopFlowExecutionOnError: boolean): void {
     this.runStatus.state.paused(error);
   }
 }

src/engine/flow-state/flow-ready.ts

@@ -7,13 +7,7 @@ export class FlowReady extends FlowState {
     return FlowStateEnum.Ready;
   }
 
-  public start(
-    params: ValueMap,
-    expectedResults: string[],
-    resolvers: TaskResolverMap,
-    context: ValueMap,
-    options: ValueMap = {},
-  ): Promise<ValueMap> {
+  public start(params: ValueMap, expectedResults: string[], resolvers: TaskResolverMap, context: ValueMap, options: ValueMap = {}) {
     this.setRunOptions(options);
     this.log({ n: this.runStatus.id, m: 'Flow started with params: %O', mp: params, e: 'FS' });
 

src/engine/flow-state/flow-state.ts

@@ -13,7 +13,16 @@ import {
   ThrowErrorResolver,
   WaitResolver,
 } from '../../resolver-library';
-import { AnyValue, FlowedLogEntry, FlowStateEnum, FlowTransitionEnum, TaskResolverExecutor, TaskResolverMap, ValueMap } from '../../types';
+import {
+  AnyValue,
+  FlowedLogEntry,
+  FlowStateEnum,
+  FlowTransitionEnum,
+  OptPromise,
+  TaskResolverExecutor,
+  TaskResolverMap,
+  ValueMap,
+} from '../../types';
 import { FlowRunStatus, SerializedFlowRunStatus } from '../flow-run-status';
 import { Task } from '../task';
 import { TaskProcess } from '../task-process';
@@ -50,22 +59,20 @@ export abstract class FlowState implements IFlow {
     expectedResults: string[],
     resolvers: TaskResolverMap,
     context: ValueMap,
-    options: ValueMap = {}, // eslint-disable-line @typescript-eslint/no-unused-vars
-  ): Promise<ValueMap> {
+    _options: ValueMap = {},
+  ): OptPromise<ValueMap> {
     throw this.createTransitionError(FlowTransitionEnum.Start);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public finished(error: Error | boolean = false): void {
+  public finished(_error: Error | boolean = false): void {
     throw this.createTransitionError(FlowTransitionEnum.Finished);
   }
 
   public pause(): Promise<ValueMap> {
     throw this.createTransitionError(FlowTransitionEnum.Pause);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public paused(error: Error | boolean = false): void {
+  public paused(_error: Error | boolean = false): void {
     throw this.createTransitionError(FlowTransitionEnum.Paused);
   }
 
@@ -77,8 +84,7 @@ export abstract class FlowState implements IFlow {
     throw this.createTransitionError(FlowTransitionEnum.Stop);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public stopped(error: Error | boolean = false): void {
+  public stopped(_error: Error | boolean = false): void {
     throw this.createTransitionError(FlowTransitionEnum.Stopped);
   }
 
@@ -341,8 +347,7 @@ export abstract class FlowState implements IFlow {
     this.runStatus.state.postProcessFinished(error, stopFlowExecutionOnError);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected postProcessFinished(error: Error | boolean, stopFlowExecutionOnError: boolean): void {}
+  protected postProcessFinished(_error: Error | boolean, _stopFlowExecutionOnError: boolean): void {}
 
   protected createTransitionError(transition: string): Error {
     return new Error(`Cannot execute transition ${transition} in current state ${this.getStateCode()}.`);
@@ -353,7 +358,7 @@ export abstract class FlowState implements IFlow {
   }
 
   public debug(formatter: string, ...args: AnyValue[]): void {
-    const scope = this && this.runStatus && typeof this.runStatus.runOptions.debugKey === 'string' ? this.runStatus.runOptions.debugKey : 'init';
+    const scope = this?.runStatus && typeof this.runStatus.runOptions.debugKey === 'string' ? this.runStatus.runOptions.debugKey : 'init';
     rawDebug(scope)(formatter, ...args);
   }
 

src/engine/flow-state/flow-stopping.ts

@@ -18,8 +18,7 @@ export class FlowStopping extends FlowState {
     }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected postProcessFinished(error: Error | boolean, stopFlowExecutionOnError: boolean): void {
+  protected postProcessFinished(error: Error | boolean, _stopFlowExecutionOnError: boolean): void {
     this.runStatus.state.stopped(error);
   }
 }

src/engine/flow-state/iflow.ts

@@ -1,13 +1,13 @@
-import { AnyValue, FlowStateEnum, TaskResolverMap, ValueMap } from '../../types';
+import { AnyValue, FlowStateEnum, OptPromise, TaskResolverMap, ValueMap } from '../../types';
 
 export interface IFlow {
-  start(params: ValueMap, expectedResults: string[], resolvers: TaskResolverMap, context: ValueMap): Promise<ValueMap>;
+  start(params: ValueMap, expectedResults: string[], resolvers: TaskResolverMap, context: ValueMap): OptPromise<ValueMap>;
 
-  pause(): Promise<ValueMap>;
+  pause(): OptPromise<ValueMap>;
 
-  resume(): Promise<ValueMap>;
+  resume(): OptPromise<ValueMap>;
 
-  stop(): Promise<ValueMap>;
+  stop(): OptPromise<ValueMap>;
 
   reset(): void;
 

src/engine/flow.ts

@@ -23,23 +23,23 @@ export class Flow implements IFlow {
     resolvers: TaskResolverMap = {},
     context: ValueMap = {},
     options: ValueMap = {},
-  ): Promise<ValueMap> {
+  ) {
     return this.runStatus.state.start(params, expectedResults, resolvers, context, options);
   }
 
-  public pause(): Promise<ValueMap> {
+  public pause() {
     return this.runStatus.state.pause();
   }
 
-  public resume(): Promise<ValueMap> {
+  public resume() {
     return this.runStatus.state.resume();
   }
 
-  public stop(): Promise<ValueMap> {
+  public stop() {
     return this.runStatus.state.stop();
   }
 
-  public reset(): void {
+  public reset() {
     this.runStatus.state.reset();
   }
 
@@ -48,7 +48,7 @@ export class Flow implements IFlow {
   }
 
   public debug(formatter: string, ...args: AnyValue[]): void {
-    this && this.runStatus ? this.runStatus.state.debug(formatter, ...args) : rawDebug('init')(formatter, ...args);
+    this?.runStatus ? this.runStatus.state.debug(formatter, ...args) : rawDebug('init')(formatter, ...args);
   }
 
   public log({ n, m, mp, l, e }: { n?: number; m: string; mp?: ValueMap; l?: string; e?: string }): void {

src/engine/task-process.ts

@@ -40,9 +40,9 @@ export class TaskProcess {
     let resolverThis: TaskResolverClass | undefined = undefined;
     const isClassResolver = this.taskResolverExecutor.prototype && this.taskResolverExecutor.prototype.exec;
     if (isClassResolver) {
-      // @todo try to remove type assertions in this code section
+      // @todo try to remove type casts in this code section
       const resolverInstance = new (this.taskResolverExecutor as TaskResolverClass)();
-      resolverFn = resolverInstance.exec as TaskResolverFn;
+      resolverFn = resolverInstance.exec;
       resolverThis = resolverInstance as unknown as TaskResolverClass;
     }
 

src/engine/task.ts

@@ -60,26 +60,23 @@ export class Task {
     }
   }
 
-  // @todo convert to protected
   public mapParamsForResolver(solvedReqs: ValueMap, automap: boolean, flowId: number, log: LoggerFn): ValueMap {
     const params: ValueMap = {};
 
-    let resolverParams = (this.spec.resolver ?? {}).params ?? {};
+    let resolverParams = this.spec.resolver?.params ?? {};
 
     if (automap) {
       const requires = this.spec.requires ?? [];
       // When `Object.fromEntries()` is available in ES, use it instead of the following solution
       // @todo Add test with requires = []
-      const autoMappedParams = requires.map(req => ({ [req]: req })).reduce((accum, peer) => Object.assign(accum, peer), {}); // @todo improve this expression
+      const autoMappedParams = requires.map(req => ({ [req]: req })).reduce((accum, peer) => Object.assign(accum, peer), {});
       log({ n: flowId, m: `  ⓘ Auto-mapped resolver params in task '${this.code}': %O`, mp: autoMappedParams, l: 'd' });
       resolverParams = Object.assign(autoMappedParams, resolverParams);
     }
 
     let paramValue;
     for (const [resolverParamName, paramSolvingInfo] of Object.entries(resolverParams)) {
-      // @todo Add test to check the case when a loop round does not set anything and make sure next value is undefined by default
-      // Added to make sure default value is undefined
-      paramValue = undefined;
+      // @todo Add test to check the case when a loop round does not set anything and make sure next value (`paramValue`) is undefined by default
 
       // If it is string, it is a task param name
       if (typeof paramSolvingInfo === 'string') {
@@ -109,7 +106,6 @@ export class Task {
     return params;
   }
 
-  // @todo convert to protected
   public mapResultsFromResolver(solvedResults: ValueMap, automap: boolean, flowId: number, log: LoggerFn): ValueMap {
     if (typeof solvedResults !== 'object') {
       throw new Error(
@@ -125,9 +121,8 @@ export class Task {
 
     if (automap) {
       const provides = this.spec.provides ?? [];
-      // When `Object.fromEntries()` is available in ES, use it instead of the following solution
       // @todo Add test with provides = []
-      const autoMappedResults = provides.map(prov => ({ [prov]: prov })).reduce((accum, peer) => Object.assign(accum, peer), {}); // @todo improve this expression
+      const autoMappedResults = provides.reduce((acc: ValueMap, prov) => Object.assign(acc, { [prov]: prov }), {});
       log({ n: flowId, m: `  ⓘ Auto-mapped resolver results in task '${this.code}': %O`, mp: autoMappedResults, l: 'd' });
 
       resolverResults = Object.assign(autoMappedResults, resolverResults);

src/engine/value-queue-manager.ts

@@ -1,4 +1,3 @@
-// @todo Check if this could be the same as ValueMap
 import { AnyValue, ValueMap } from '../types';
 
 export type ValueQueue = AnyValue[];

src/resolver-library.ts

@@ -5,32 +5,32 @@ import { LoggerFn, ValueMap } from './types';
 
 // Do nothing and finish
 export class NoopResolver {
-  public async exec(): Promise<ValueMap> {
+  public exec(): ValueMap {
     return {};
   }
 }
 
 export class EchoResolver {
-  public async exec(params: ValueMap): Promise<ValueMap> {
+  public exec(params: ValueMap): ValueMap {
     return { out: params.in };
   }
 }
 
 export class ThrowErrorResolver {
-  public async exec(params: ValueMap): Promise<ValueMap> {
+  public exec(params: ValueMap): ValueMap {
     throw new Error(typeof params.message !== 'undefined' ? params.message : 'ThrowErrorResolver resolver has thrown an error');
   }
 }
 
 export class ConditionalResolver {
-  public async exec(params: ValueMap): Promise<ValueMap> {
+  public exec(params: ValueMap): ValueMap {
     return params.condition ? { onTrue: params.trueResult } : { onFalse: params.falseResult };
   }
 }
 
 // Wait for 'ms' milliseconds and finish
 export class WaitResolver {
-  public async exec(params: ValueMap): Promise<ValueMap> {
+  public exec(params: ValueMap): ValueMap {
     return new Promise<ValueMap>(resolve => {
       setTimeout(() => {
         resolve({ result: params.result });
@@ -219,13 +219,13 @@ export class LoopResolver {
 }
 
 export class StopResolver {
-  public async exec(params: ValueMap, context: ValueMap): Promise<ValueMap> {
+  public exec(params: ValueMap, context: ValueMap): ValueMap {
     return { promise: context.$flowed.flow.stop() };
   }
 }
 
 export class PauseResolver {
-  public async exec(params: ValueMap, context: ValueMap): Promise<ValueMap> {
+  public exec(params: ValueMap, context: ValueMap): ValueMap {
     return { promise: context.$flowed.flow.pause() };
   }
 }

src/types.ts

@@ -23,11 +23,11 @@ export enum FlowTransitionEnum {
   Stopped = 'Stopped',
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyValue = any;
+export type AnyValue = any; // eslint-disable-line @typescript-eslint/no-explicit-any
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type TransformTemplate = any;
+export type TransformTemplate = AnyValue;
+
+export type OptPromise<T> = T | Promise<T>;
 
 export interface ValueMap {
   [key: string]: AnyValue;
@@ -37,18 +37,16 @@ export interface ValueMap {
 export type GenericValueMap = ValueMap;
 
 export interface ITaskResolver {
-  exec(params: ValueMap, context: ValueMap, task: Task, debug: Debugger, log: LoggerFn): Promise<ValueMap>;
+  exec(params: ValueMap, context?: ValueMap, task?: Task, debug?: Debugger, log?: LoggerFn): OptPromise<ValueMap>;
 }
 
 export class TaskResolver implements ITaskResolver {
-  // @todo this method should return type ValueMap | Promise<ValueMap>
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public exec(params: ValueMap, context: ValueMap, task: Task, debug: Debugger, log: LoggerFn): Promise<ValueMap> {
-    return Promise.resolve({});
+  public exec(_params: ValueMap, _context?: ValueMap, _task?: Task, _debug?: Debugger, _log?: LoggerFn): OptPromise<ValueMap> {
+    return {};
   }
 }
 
-export type TaskResolverFn = (params: ValueMap, context?: ValueMap, task?: Task, debug?: Debugger, log?: LoggerFn) => ValueMap | Promise<ValueMap>;
+export type TaskResolverFn = (params: ValueMap, context?: ValueMap, task?: Task, debug?: Debugger, log?: LoggerFn) => OptPromise<ValueMap>;
 
 export type TaskResolverClass = typeof TaskResolver;