@mat3ra/wode 2025.10.1-0

package/src/units/assertion.js

@@ -0,0 +1,29 @@
+import { UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export class AssertionUnit extends BaseUnit {
+    constructor(config) {
+        super({ ...AssertionUnit.getAssertionConfig(), ...config });
+    }
+
+    static getAssertionConfig() {
+        return {
+            name: UNIT_TYPES.assertion,
+            type: UNIT_TYPES.assertion,
+            statement: "true",
+            errorMessage: "assertion failed",
+        };
+    }
+
+    get statement() {
+        return this.prop("statement");
+    }
+
+    get errorMessage() {
+        return this.prop("errorMessage");
+    }
+
+    getHashObject() {
+        return { statement: this.statement, errorMessage: this.errorMessage };
+    }
+}

package/src/units/assignment.js

@@ -0,0 +1,34 @@
+import { UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export class AssignmentUnit extends BaseUnit {
+    constructor(config) {
+        super({ ...AssignmentUnit.getAssignmentConfig(), ...config });
+    }
+
+    static getAssignmentConfig() {
+        return {
+            name: UNIT_TYPES.assignment,
+            type: UNIT_TYPES.assignment,
+            operand: "X",
+            value: "1",
+            input: [],
+        };
+    }
+
+    get operand() {
+        return this.prop("operand");
+    }
+
+    get value() {
+        return this.prop("value");
+    }
+
+    get input() {
+        return this.prop("input");
+    }
+
+    getHashObject() {
+        return { input: this.input, operand: this.operand, value: this.value };
+    }
+}

package/src/units/base.js

@@ -0,0 +1,97 @@
+import { NamedDefaultableRepetitionRuntimeItemsImportantSettingsContextAndRenderHashedInMemoryEntity } from "@mat3ra/code/dist/js/entity";
+import { taggableMixin } from "@mat3ra/code/dist/js/entity/mixins/TaggableMixin";
+import { Utils } from "@mat3ra/utils";
+import lodash from "lodash";
+
+import { UNIT_STATUSES } from "../enums";
+
+// eslint-disable-next-line max-len
+export class BaseUnit extends NamedDefaultableRepetitionRuntimeItemsImportantSettingsContextAndRenderHashedInMemoryEntity {
+    static usePredefinedIds = false;
+
+    constructor(config) {
+        const flowchartId =
+            config.flowchartId || BaseUnit.generateFlowChartId.call(new.target, config.name);
+        super({
+            ...config,
+            status: config.status || UNIT_STATUSES.idle,
+            statusTrack: config.statusTrack || [],
+            flowchartId,
+            tags: config.tags || [],
+        });
+    }
+
+    static generateFlowChartId(...args) {
+        args[0] = `flowchart-${args[0]}`;
+        if (this.usePredefinedIds) return Utils.uuid.getUUIDFromNamespace(...args);
+        return Utils.uuid.getUUID();
+    }
+
+    get flowchartId() {
+        return this.prop("flowchartId");
+    }
+
+    get head() {
+        return this.prop("head", false);
+    }
+
+    set head(bool) {
+        this.setProp("head", bool);
+    }
+
+    get next() {
+        return this.prop("next");
+    }
+
+    set next(flowchartId) {
+        this.setProp("next", flowchartId);
+    }
+
+    get status() {
+        return lodash.get(this.lastStatusUpdate, "status") || UNIT_STATUSES.idle;
+    }
+
+    set status(s) {
+        this.setProp("status", s);
+    }
+
+    get lastStatusUpdate() {
+        const statusTrack = this.prop("statusTrack", []).filter(
+            (s) => (s.repetition || 0) === this.repetition,
+        );
+        const sortedStatusTrack = lodash.sortBy(statusTrack || [], (x) => x.trackedAt);
+        return sortedStatusTrack[sortedStatusTrack.length - 1];
+    }
+
+    get type() {
+        return this.prop("type");
+    }
+
+    get isDraft() {
+        return this.prop("isDraft", false);
+    }
+
+    getHashObject() {
+        return { ...this.hashObjectFromRuntimeItems, type: this.type };
+    }
+
+    /**
+     * Checks whether a unit is currently in a given status (e.g. idle, active, etc). The full list can be found
+     * in the UNIT_STATUSES variable in enums.js.
+     * @param status (String) name of the status to check
+     * @returns Boolean
+     */
+    isInStatus(status) {
+        return this.status === status;
+    }
+
+    clone(extraContext) {
+        const flowchartIDOverrideConfigAsExtraContext = {
+            flowchartId: this.constructor.generateFlowChartId(),
+            ...extraContext,
+        };
+        return super.clone(flowchartIDOverrideConfigAsExtraContext);
+    }
+}
+
+taggableMixin(BaseUnit.prototype);

package/src/units/builders/AssertionUnitConfigBuilder.js

@@ -0,0 +1,28 @@
+import { UNIT_TYPES } from "../../enums";
+import { UnitConfigBuilder } from "./UnitConfigBuilder";
+
+export class AssertionUnitConfigBuilder extends UnitConfigBuilder {
+    constructor(name, statement, errorMessage) {
+        super({ name, type: UNIT_TYPES.assertion });
+        this._statement = statement;
+        this._errorMessage = errorMessage;
+    }
+
+    statement(str) {
+        this._statement = str;
+        return this;
+    }
+
+    errorMessage(str) {
+        this._errorMessage = str;
+        return this;
+    }
+
+    build() {
+        return {
+            ...super.build(),
+            statement: this._statement,
+            errorMessage: this._errorMessage,
+        };
+    }
+}

package/src/units/builders/AssignmentUnitConfigBuilder.js

@@ -0,0 +1,36 @@
+import { UNIT_TYPES } from "../../enums";
+import { UnitConfigBuilder } from "./UnitConfigBuilder";
+
+export class AssignmentUnitConfigBuilder extends UnitConfigBuilder {
+    constructor(name, variableName, variableValue, input = [], results = []) {
+        super({ name, type: UNIT_TYPES.assignment });
+        this._variableName = variableName;
+        this._variableValue = variableValue;
+        this._input = input;
+        this._results = results;
+    }
+
+    input(arr) {
+        this._input = arr;
+        return this;
+    }
+
+    variableName(str) {
+        this._variableName = str;
+        return this;
+    }
+
+    variableValue(str) {
+        this._variableValue = str;
+        return this;
+    }
+
+    build() {
+        return {
+            ...super.build(),
+            input: this._input,
+            operand: this._variableName,
+            value: this._variableValue,
+        };
+    }
+}

package/src/units/builders/ExecutionUnitConfigBuilder.js

@@ -0,0 +1,59 @@
+/* eslint-disable class-methods-use-this */
+import ApplicationRegistry from "@exabyte-io/ade.js/dist/js/ApplicationRegistry";
+
+import { UNIT_TYPES } from "../../enums";
+import { UnitConfigBuilder } from "./UnitConfigBuilder";
+
+export class ExecutionUnitConfigBuilder extends UnitConfigBuilder {
+    constructor(name, application, execName, flavorName, flowchartId) {
+        super({ name, type: UNIT_TYPES.execution, flowchartId });
+
+        try {
+            this.initialize(application, execName, flavorName);
+        } catch (e) {
+            console.error(`Can't initialize executable/flavor: ${execName}/${flavorName}`);
+            throw e;
+        }
+
+        // initialize runtimeItems
+        this._results = this.flavor.results;
+        this._monitors = this.flavor.monitors;
+        this._preProcessors = this.flavor.preProcessors;
+        this._postProcessors = this.flavor.postProcessors;
+    }
+
+    initialize(application, execName, flavorName) {
+        this.application = application;
+        this.executable = this._createExecutable(this.application, execName);
+        this.flavor = this._createFlavor(this.executable, flavorName);
+    }
+
+    build() {
+        return {
+            ...super.build(),
+            application: this.application.toJSON(),
+            executable: this.executable.toJSON(),
+            flavor: this.flavor.toJSON(),
+        };
+    }
+
+    /**
+     * Creates an executable instance. This method is intended to be overridden in subclasses.
+     * @param {Application} application - The application object
+     * @param {string} execName - The name of the executable
+     * @returns {Executable} The created executable instance
+     */
+    _createExecutable(application, execName) {
+        return ApplicationRegistry.getExecutableByName(application.name, execName);
+    }
+
+    /**
+     * Creates a flavor instance. This method is intended to be overridden in subclasses.
+     * @param {Executable} executable - The executable object
+     * @param {string} flavorName - The name of the flavor
+     * @returns {Flavor} The created flavor instance
+     */
+    _createFlavor(executable, flavorName) {
+        return ApplicationRegistry.getFlavorByName(executable, flavorName);
+    }
+}

package/src/units/builders/IOUnitConfigBuilder.js

@@ -0,0 +1,53 @@
+import { UNIT_TYPES } from "../../enums";
+import { UnitConfigBuilder } from "./UnitConfigBuilder";
+
+export class IOUnitConfigBuilder extends UnitConfigBuilder {
+    constructor(name, endpointName, endpointOptions) {
+        super({ name, type: UNIT_TYPES.io });
+        this._endpointName = endpointName;
+        this._endpointOptions = endpointOptions;
+        this._variableName = "DATA";
+        this._subtype = "input";
+        this._source = "api";
+    }
+
+    endpointName(str) {
+        this._endpointName = str;
+        return this;
+    }
+
+    endpointOptions(options) {
+        this._endpointOptions = options;
+        return this;
+    }
+
+    variableName(str) {
+        this._variableName = str;
+        return this;
+    }
+
+    subtype(str) {
+        this._subtype = str;
+        return this;
+    }
+
+    source(str) {
+        this._source = str;
+        return this;
+    }
+
+    build() {
+        return {
+            ...super.build(),
+            subtype: this._subtype,
+            source: this._source,
+            input: [
+                {
+                    endpoint: this._endpointName,
+                    endpoint_options: this._endpointOptions,
+                    name: this._variableName,
+                },
+            ],
+        };
+    }
+}

package/src/units/builders/UnitConfigBuilder.js

@@ -0,0 +1,86 @@
+import { Utils } from "@mat3ra/utils";
+import _ from "underscore";
+
+export class UnitConfigBuilder {
+    static usePredefinedIds = false;
+
+    constructor({ name, type, flowchartId }) {
+        this.type = type;
+        this._name = name;
+        this._head = false;
+        this._results = [];
+        this._monitors = [];
+        this._preProcessors = [];
+        this._postProcessors = [];
+        this._flowchartId = flowchartId || this.constructor.generateFlowChartId(name);
+    }
+
+    name(str) {
+        this._name = str;
+        return this;
+    }
+
+    head(bool) {
+        this._head = bool;
+        return this;
+    }
+
+    static generateFlowChartId(...args) {
+        if (this.usePredefinedIds) return Utils.uuid.getUUIDFromNamespace(...args);
+        return Utils.uuid.getUUID();
+    }
+
+    flowchartId(flowchartId) {
+        this._flowchartId = flowchartId;
+        return this;
+    }
+
+    static _stringArrayToNamedObject(array) {
+        return array.map((name) => (_.isString(name) ? { name } : name));
+    }
+
+    addPreProcessors(preProcessorNames) {
+        this._preProcessors = _.union(
+            this.constructor._stringArrayToNamedObject(preProcessorNames),
+            this._preProcessors,
+        );
+        return this;
+    }
+
+    addPostProcessors(postProcessorNames) {
+        this._postProcessors = _.union(
+            this.constructor._stringArrayToNamedObject(postProcessorNames),
+            this._postProcessors,
+        );
+        return this;
+    }
+
+    addResults(resultNames) {
+        this._results = _.union(
+            this.constructor._stringArrayToNamedObject(resultNames),
+            this._results,
+        );
+        return this;
+    }
+
+    addMonitors(monitorNames) {
+        this._monitors = _.union(
+            this.constructor._stringArrayToNamedObject(monitorNames),
+            this._monitors,
+        );
+        return this;
+    }
+
+    build() {
+        return {
+            type: this.type,
+            name: this._name,
+            head: this._head,
+            results: this._results,
+            monitors: this._monitors,
+            flowchartId: this._flowchartId,
+            preProcessors: this._preProcessors,
+            postProcessors: this._postProcessors,
+        };
+    }
+}

package/src/units/builders/index.js

@@ -0,0 +1,15 @@
+import { AssertionUnitConfigBuilder } from "./AssertionUnitConfigBuilder";
+import { AssignmentUnitConfigBuilder } from "./AssignmentUnitConfigBuilder";
+import { ExecutionUnitConfigBuilder } from "./ExecutionUnitConfigBuilder";
+import { IOUnitConfigBuilder } from "./IOUnitConfigBuilder";
+import { UnitConfigBuilder } from "./UnitConfigBuilder";
+
+const builders = {
+    UnitConfigBuilder,
+    AssignmentUnitConfigBuilder,
+    AssertionUnitConfigBuilder,
+    ExecutionUnitConfigBuilder,
+    IOUnitConfigBuilder,
+};
+
+export { builders };

package/src/units/condition.js

@@ -0,0 +1,47 @@
+import { UNIT_TYPES } from "../enums";
+import { BaseUnit } from "./base";
+
+export class ConditionUnit extends BaseUnit {
+    constructor(config) {
+        super({ ...ConditionUnit.getConditionConfig(), ...config });
+    }
+
+    static getConditionConfig() {
+        return {
+            name: UNIT_TYPES.condition,
+            type: UNIT_TYPES.condition,
+            input: [],
+            results: [],
+            preProcessors: [],
+            postProcessors: [],
+            then: undefined,
+            else: undefined,
+            statement: "true",
+            maxOccurrences: 100,
+        };
+    }
+
+    get input() {
+        return this.prop("input");
+    }
+
+    get then() {
+        return this.prop("then");
+    }
+
+    get else() {
+        return this.prop("else");
+    }
+
+    get statement() {
+        return this.prop("statement");
+    }
+
+    get maxOccurrences() {
+        return this.prop("maxOccurrences");
+    }
+
+    getHashObject() {
+        return { statement: this.statement, maxOccurrences: this.maxOccurrences };
+    }
+}