definition walker.

Author: b4rtaz

.prettierrc

@@ -0,0 +1,8 @@
+{
+	"printWidth": 140,
+	"singleQuote": true,
+	"trailingComma": "none",
+	"semi": true,
+	"useTabs": true,
+	"arrowParens": "avoid"
+}

jest.config.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+	testMatch: ['**/?(*.)+(spec|test).ts?(x)'],
+	transform: {
+		'^.+\\.(ts|js)x?$': 'ts-jest',
+	}
+};

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "sequential-workflow-model",
 	"description": "Extendable data model of sequential workflow.",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"homepage": "https://nocode-js.com/",
 	"author": {
 		"name": "NoCode JS",
@@ -35,13 +35,21 @@
 	},
 	"scripts": {
 		"clean": "rm -rf lib",
-		"build": "yarn clean && rollup -c"
+		"build": "yarn clean && rollup -c",
+		"prettier": "prettier --check ./src",
+		"prettier:fix": "prettier --write ./src",
+		"test:single": "jest",
+		"test": "jest --clearCache && jest --watchAll"
 	},
 	"devDependencies": {
 		"typescript": "^4.9.5",
 		"rollup-plugin-dts": "^5.2.0",
 		"rollup-plugin-typescript2": "^0.34.1",
-		"rollup": "^3.18.0"
+		"rollup": "^3.18.0",
+		"prettier": "^2.8.8",
+		"@types/jest": "^29.5.1",
+		"jest": "^29.5.0",
+		"ts-jest": "^29.1.0"
 	},
 	"keywords": [
 		"workflow",

src/definition-walker/default-resolvers.ts

@@ -0,0 +1,20 @@
+import { BranchedStep, SequentialStep, Step } from '../model';
+import { StepChildren, StepChildrenResolver, StepChildrenType } from './definition-walker';
+
+export const defaultResolvers: StepChildrenResolver[] = [sequentialResolver, branchedResolver];
+
+function branchedResolver(step: Step): StepChildren | null {
+	const branches = (step as BranchedStep).branches;
+	if (branches) {
+		return { type: StepChildrenType.branches, items: branches };
+	}
+	return null;
+}
+
+function sequentialResolver(step: Step): StepChildren | null {
+	const sequence = (step as SequentialStep).sequence;
+	if (sequence) {
+		return { type: StepChildrenType.sequence, items: sequence };
+	}
+	return null;
+}

src/definition-walker/definition-walker.spec.ts

@@ -0,0 +1,124 @@
+import { DefinitionWalker, StepChildrenType } from './definition-walker';
+import { BranchedStep, SequentialStep, Step } from '../model';
+
+describe('DefinitionWalker', () => {
+	function createIf(name: string, falseStep: Step): BranchedStep {
+		return {
+			componentType: 'switch',
+			id: 'if' + name,
+			type: 'if' + name,
+			name,
+			branches: {
+				true: [],
+				false: [falseStep]
+			},
+			properties: {}
+		};
+	}
+
+	function createTask(name: string): Step {
+		return {
+			componentType: 'task',
+			id: 'task' + name,
+			type: 'task' + name,
+			name,
+			properties: {}
+		};
+	}
+
+	const taskFoo = createTask('foo');
+	const ifAlfa = createIf('beta', taskFoo);
+	const ifBeta = createIf('alfa', ifAlfa);
+	const loop = {
+		componentType: 'container',
+		id: 'loop',
+		name: 'loop',
+		type: 'loop',
+		properties: {},
+		sequence: [ifBeta]
+	} as SequentialStep;
+	const definition = {
+		sequence: [
+			createIf('q', createTask('p')),
+			loop // loop > ifBeta > 'false' > ifAlfa > 'false' > taskFoo
+		],
+		properties: {}
+	};
+
+	let walker: DefinitionWalker;
+
+	beforeAll(() => {
+		walker = new DefinitionWalker();
+	});
+
+	describe('getChildren', () => {
+		it('returns null for task', () => {
+			expect(walker.getChildren(taskFoo)).toBeNull();
+		});
+
+		it('returns single sequence for container', () => {
+			const result = walker.getChildren(loop);
+			expect(result?.type).toEqual(StepChildrenType.sequence);
+			expect(result?.items).toEqual(loop.sequence);
+		});
+
+		it('returns branches for branched step', () => {
+			const result = walker.getChildren(ifBeta);
+			expect(result?.type).toEqual(StepChildrenType.branches);
+			expect(result?.items).toEqual(ifBeta.branches);
+		});
+	});
+
+	describe('getParents', () => {
+		it('returns task parents', () => {
+			const parents = walker.getParents(definition, taskFoo);
+			expect(parents.length).toEqual(6);
+			expect(parents[0]).toEqual(loop);
+			expect(parents[1]).toEqual(ifBeta);
+			expect(parents[2]).toEqual('false');
+			expect(parents[3]).toEqual(ifAlfa);
+			expect(parents[4]).toEqual('false');
+			expect(parents[5]).toEqual(taskFoo);
+		});
+
+		it('returns alfa parents', () => {
+			const parents = walker.getParents(definition, ifBeta);
+			expect(parents.length).toEqual(2);
+			expect(parents[0]).toEqual(loop);
+			expect(parents[1]).toEqual(ifBeta);
+		});
+
+		it('returns loop parents', () => {
+			const parents = walker.getParents(definition, loop);
+			expect(parents.length).toEqual(1);
+			expect(parents[0]).toEqual(loop);
+		});
+
+		it('returns no parents for root sequence', () => {
+			const parents = walker.getParents(definition, definition.sequence);
+			expect(parents.length).toEqual(0);
+		});
+	});
+
+	describe('findById', () => {
+		it('returns null when stepId not exists', () => {
+			const found = walker.findById(definition, 'invalidId');
+			expect(found).toBeNull();
+		});
+
+		it('returns task step', () => {
+			const found = walker.findById(definition, taskFoo.id);
+			expect(found).toEqual(taskFoo);
+		});
+
+		it('returns container step', () => {
+			const found = walker.findById(definition, loop.id);
+			expect(found).toEqual(loop);
+		});
+
+		it('returns switch step', () => {
+			const found = walker.findById(definition, ifBeta.id);
+			expect(found).toEqual(ifBeta);
+		});
+	});
+});

src/definition-walker/definition-walker.ts

@@ -0,0 +1,139 @@
+import { Branches, Definition, Sequence, Step } from '../model';
+import { defaultResolvers } from './default-resolvers';
+
+export interface StepChildren {
+	type: StepChildrenType;
+	items: Sequence | Branches;
+}
+
+export enum StepChildrenType {
+	sequence = 1,
+	branches = 2
+}
+
+export type StepOrName = Step | string;
+
+export interface StepWithParentSequence {
+	step: Step;
+	/**
+	 * Index of the step in the parent sequence.
+	 */
+	index: number;
+	parentSequence: Sequence;
+}
+
+type StepWithParentSequenceOrName = StepWithParentSequence | string;
+
+export type StepChildrenResolver = (step: Step) => StepChildren | null;
+
+export class DefinitionWalker {
+	private readonly resolvers: StepChildrenResolver[];
+
+	public constructor(resolvers?: StepChildrenResolver[]) {
+		this.resolvers = resolvers ? resolvers.concat(defaultResolvers) : defaultResolvers;
+	}
+
+	public getChildren(step: Step): StepChildren | null {
+		const count = this.resolvers.length;
+		for (let i = 0; i < count; i++) {
+			const result = this.resolvers[i](step);
+			if (result) {
+				return result;
+			}
+		}
+		return null;
+	}
+
+	public getParents(definition: Definition, needle: Sequence | Step): StepOrName[] {
+		const result: StepWithParentSequenceOrName[] = [];
+		const searchSequence = Array.isArray(needle) ? needle : null;
+		const searchStepId = !searchSequence ? (needle as Step).id : null;
+
+		if (this.find(definition.sequence, searchSequence, searchStepId, result)) {
+			result.reverse();
+			return result.map(item => {
+				return typeof item === 'string' ? item : item.step;
+			});
+		}
+
+		throw new Error(searchStepId ? `Cannot get parents of step: ${searchStepId}` : 'Cannot get parents of sequence');
+	}
+
+	public findParentSequence(definition: Definition, stepId: string): StepWithParentSequence | null {
+		const result: StepWithParentSequenceOrName[] = [];
+		if (this.find(definition.sequence, null, stepId, result)) {
+			return result[0] as StepWithParentSequence;
+		}
+		return null;
+	}
+
+	public getParentSequence(definition: Definition, stepId: string): StepWithParentSequence {
+		const result = this.findParentSequence(definition, stepId);
+		if (!result) {
+			throw new Error(`Cannot find step by id: ${stepId}`);
+		}
+		return result;
+	}
+
+	public findById(definition: Definition, stepId: string): Step | null {
+		const result = this.findParentSequence(definition, stepId);
+		return result ? result.step : null;
+	}
+
+	public getById(definition: Definition, stepId: string): Step {
+		return this.getParentSequence(definition, stepId).step;
+	}
+
+	private find(
+		sequence: Sequence,
+		needSequence: Sequence | null,
+		needStepId: string | null,
+		result: StepWithParentSequenceOrName[]
+	): boolean {
+		if (needSequence && sequence === needSequence) {
+			return true;
+		}
+		const count = sequence.length;
+		for (let index = 0; index < count; index++) {
+			const step = sequence[index];
+			if (needStepId && step.id === needStepId) {
+				result.push({ step, index, parentSequence: sequence });
+				return true;
+			}
+
+			const children = this.getChildren(step);
+			if (children) {
+				switch (children.type) {
+					case StepChildrenType.sequence:
+						{
+							const parentSequence = children.items as Sequence;
+							if (this.find(parentSequence, needSequence, needStepId, result)) {
+								result.push({ step, index, parentSequence });
+								return true;
+							}
+						}
+						break;
+
+					case StepChildrenType.branches:
+						{
+							const branches = children.items as Branches;
+							const branchNames = Object.keys(branches);
+							for (const branchName of branchNames) {
+								const parentSequence = branches[branchName];
+								if (this.find(parentSequence, needSequence, needStepId, result)) {
+									result.push(branchName);
+									result.push({ step, index, parentSequence });
+									return true;
+								}
+							}
+						}
+						break;
+
+					default:
+						throw new Error(`Step children type ${children.type} is not supported`);
+				}
+			}
+		}
+		return false;
+	}
+}

src/definition-walker/index.ts

@@ -0,0 +1 @@
+export * from './definition-walker';