@media-quest/builder 0.0.2 → 0.0.4

package/src/rulebuilder/SingleSelectItem.ts

@@ -1,135 +1,135 @@
 import { BuilderVariable, BuilderVariableOption } from "./RuleVariable";
-import { BuilderOperator } from "./Builder-operator";
+import { BuilderOperator } from "./condition/Builder-operator";
 import { JumpToPageAction } from "./RuleAction";
 
 export abstract class SingleSelectItem<T> {
-    private readonly _selectLabel;
-    private readonly _toolTip;
-    private readonly _searchString;
-    get selectLabel(): string {
-        return this._selectLabel;
-    }
-    get tooltip() {
-        return this._toolTip;
-    }
-
-    get searchString() {
-        return this._searchString;
-    }
-
-    protected constructor(readonly data: T) {
-        this._selectLabel = this.getSelectLabel();
-        this._toolTip = this.getTooltip();
-        this._searchString = this.getSearchString();
-    }
-    protected abstract getSelectLabel(): string;
-    protected abstract getTooltip(): string;
-    protected abstract getSearchString(): string;
+  private readonly _selectLabel;
+  private readonly _toolTip;
+  private readonly _searchString;
+  get selectLabel(): string {
+    return this._selectLabel;
+  }
+  get tooltip() {
+    return this._toolTip;
+  }
+
+  get searchString() {
+    return this._searchString;
+  }
+
+  protected constructor(readonly data: T) {
+    this._selectLabel = this.getSelectLabel();
+    this._toolTip = this.getTooltip();
+    this._searchString = this.getSearchString();
+  }
+  protected abstract getSelectLabel(): string;
+  protected abstract getTooltip(): string;
+  protected abstract getSearchString(): string;
 }
 
 export class RuleVariableSelectItem extends SingleSelectItem<BuilderVariable> {
-    public static create = (data: BuilderVariable) => {
-        return new RuleVariableSelectItem(data);
-    };
-    readonly options: ReadonlyArray<RuleOptionSelectItem>;
-    constructor(readonly data: BuilderVariable) {
-        super(data);
-        this.options = data.options.map(RuleOptionSelectItem.create);
-    }
-
-    protected getSearchString(): string {
-        return this.data.varId + this.data.label;
-    }
-
-    getSelectLabel(): string {
-        return this.data.varId;
-    }
-
-    getTooltip(): string {
-        return this.data.label;
-    }
+  public static create = (data: BuilderVariable) => {
+    return new RuleVariableSelectItem(data);
+  };
+  readonly options: ReadonlyArray<RuleOptionSelectItem>;
+  constructor(readonly data: BuilderVariable) {
+    super(data);
+    this.options = data.options.map(RuleOptionSelectItem.create);
+  }
+
+  protected getSearchString(): string {
+    return this.data.varId + this.data.label;
+  }
+
+  getSelectLabel(): string {
+    return this.data.varId;
+  }
+
+  getTooltip(): string {
+    return this.data.label;
+  }
 }
 
 export class RuleOptionSelectItem extends SingleSelectItem<BuilderVariableOption> {
-    public static create = (option: BuilderVariableOption) => {
-        return new RuleOptionSelectItem(option);
-    };
-    private constructor(option: BuilderVariableOption) {
-        super(option);
-    }
-    protected getSearchString(): string {
-        return "";
-    }
-
-    protected getSelectLabel(): string {
-        return this.data.label + "(" + this.data.value + ")";
-    }
-
-    protected getTooltip(): string {
-        return "";
-    }
+  public static create = (option: BuilderVariableOption) => {
+    return new RuleOptionSelectItem(option);
+  };
+  private constructor(option: BuilderVariableOption) {
+    super(option);
+  }
+  protected getSearchString(): string {
+    return "";
+  }
+
+  protected getSelectLabel(): string {
+    return this.data.label + "(" + this.data.value + ")";
+  }
+
+  protected getTooltip(): string {
+    return "";
+  }
 }
 
 export class OperatorSelectItem extends SingleSelectItem<BuilderOperator | ""> {
-    public static readonly EQ = new OperatorSelectItem("equal");
-    public static readonly NOT_EQ = new OperatorSelectItem("notEqual");
-    public static readonly fromSymbol = (
-        symbol: BuilderOperator | Omit<string, BuilderOperator>
-    ): OperatorSelectItem | false => {
-        if (symbol === "equal") {
-            return OperatorSelectItem.EQ;
-        }
-        if (symbol === "notEqual") {
-            return OperatorSelectItem.NOT_EQ;
-        }
-        return false;
-    };
-    private constructor(operator: BuilderOperator) {
-        super(operator);
-    }
-
-    protected getSearchString(): string {
-        return "";
-    }
-
-    protected getSelectLabel(): string {
-        const operator = this.data;
-        if (operator === "equal") {
-            return "Equals";
-        }
-        if (operator === "notEqual") {
-            return "Not equals";
-        }
-        return "";
-    }
-
-    protected getTooltip(): string {
-        const operator = this.data;
-        if (operator === "equal") {
-            return "Equals";
-        }
-        if (operator === "notEqual") {
-            return "Not equals";
-        }
-        return "";
-    }
+  public static readonly EQ = new OperatorSelectItem("equal");
+  public static readonly NOT_EQ = new OperatorSelectItem("notEqual");
+  public static readonly fromSymbol = (
+    symbol: BuilderOperator | Omit<string, BuilderOperator>,
+  ): OperatorSelectItem | false => {
+    if (symbol === "equal") {
+      return OperatorSelectItem.EQ;
+    }
+    if (symbol === "notEqual") {
+      return OperatorSelectItem.NOT_EQ;
+    }
+    return false;
+  };
+  private constructor(operator: BuilderOperator) {
+    super(operator);
+  }
+
+  protected getSearchString(): string {
+    return "";
+  }
+
+  protected getSelectLabel(): string {
+    const operator = this.data;
+    if (operator === "equal") {
+      return "Equals";
+    }
+    if (operator === "notEqual") {
+      return "Not equals";
+    }
+    return "";
+  }
+
+  protected getTooltip(): string {
+    const operator = this.data;
+    if (operator === "equal") {
+      return "Equals";
+    }
+    if (operator === "notEqual") {
+      return "Not equals";
+    }
+    return "";
+  }
 }
 
 export class JumpToPageSelectItem extends SingleSelectItem<JumpToPageAction> {
-    public static readonly create = (pageData: JumpToPageAction) => new JumpToPageSelectItem(pageData);
-    protected constructor(pageData: JumpToPageAction) {
-        super(pageData);
-    }
-
-    protected getSearchString(): string {
-        return this.data.pageId + this.data.mainText;
-    }
-
-    protected getSelectLabel(): string {
-        return this.data.pageId + " (" + this.data.pageNumber + ")";
-    }
-
-    protected getTooltip(): string {
-        return this.data.mainText;
-    }
+  public static readonly create = (pageData: JumpToPageAction) => new JumpToPageSelectItem(pageData);
+  protected constructor(pageData: JumpToPageAction) {
+    super(pageData);
+  }
+
+  protected getSearchString(): string {
+    return this.data.pageId + this.data.mainText;
+  }
+
+  protected getSelectLabel(): string {
+    return this.data.pageId + " (" + this.data.pageNumber + ")";
+  }
+
+  protected getTooltip(): string {
+    return this.data.mainText;
+  }
 }

package/src/rulebuilder/{Builder-condition-group.ts → condition/Builder-condition-group.ts}

@@ -1,62 +1,47 @@
-import {
-  BuilderCondition,
-  type BuilderConditionDto
-} from './Builder-condition';
-import { BuilderObject } from '../BuilderObject';
-import type { BuilderVariable } from './RuleVariable';
+import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
+import { BuilderObject } from "../../BuilderObject";
+import type { BuilderVariable } from "../RuleVariable";
+import { Condition } from "@media-quest/engine";
 
 const ConditionGroupType = {
   all: true,
   any: true,
   count: true,
-  range: true
+  range: true,
 };
 
 export type ConditionGroupType = keyof typeof ConditionGroupType;
 export interface BuilderConditionGroupDto {
-  readonly kind: 'condition-group';
+  readonly kind: "condition-group";
   readonly name: string;
   readonly type: ConditionGroupType;
   readonly conditions: ReadonlyArray<BuilderConditionDto>;
 }
 
-export class BuilderConditionGroup extends BuilderObject<
-  'builder-condition-group',
-  BuilderConditionGroupDto
-> {
-  static readonly isConditionGroupType = (
-    value: string | symbol
-  ): value is ConditionGroupType => {
-    if (typeof value !== 'string') {
+export class BuilderConditionGroup extends BuilderObject<"builder-condition-group", BuilderConditionGroupDto> {
+  static readonly isConditionGroupType = (value: string | symbol): value is ConditionGroupType => {
+    if (typeof value !== "string") {
       return false;
     }
     const validValues = Object.keys(ConditionGroupType);
     return validValues.includes(value);
   };
 
-  readonly objectType: 'builder-condition-group' = 'builder-condition-group';
+  readonly objectType: "builder-condition-group" = "builder-condition-group";
   private _type: ConditionGroupType;
-  name = '';
+  name = "";
   private readonly _conditions: Array<BuilderCondition>;
   private readonly _variableList: ReadonlyArray<BuilderVariable>;
 
-  public static readonly fromDto = (
-    dto: BuilderConditionGroupDto,
-    variableList: ReadonlyArray<BuilderVariable>
-  ) => {
+  public static readonly fromDto = (dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) => {
     return new BuilderConditionGroup(dto, variableList);
   };
-  protected constructor(
-    dto: BuilderConditionGroupDto,
-    variableList: ReadonlyArray<BuilderVariable>
-  ) {
+  protected constructor(dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) {
     super(dto);
     this.name = dto.name;
     this._type = dto.type;
     const conditionList = Array.isArray(dto.conditions) ? dto.conditions : [];
-    this._conditions = conditionList.map(dto =>
-      BuilderCondition.fromDto(dto, variableList)
-    );
+    this._conditions = conditionList.map((dto) => BuilderCondition.fromDto(dto, variableList));
     this._variableList = variableList;
   }
   get conditions(): ReadonlyArray<BuilderCondition> {
@@ -88,16 +73,40 @@ export class BuilderConditionGroup extends BuilderObject<
   }
 
   toJson(): BuilderConditionGroupDto {
-    const conditions: ReadonlyArray<BuilderConditionDto> = [
-      ...this._conditions.map(c => c.toJson())
-    ];
+    const conditions: ReadonlyArray<BuilderConditionDto> = [...this._conditions.map((c) => c.toJson())];
     return {
       name: this.name,
       conditions,
       type: this._type,
-      kind: 'condition-group'
+      kind: "condition-group",
     };
   }
+
+  toEngineConditionComplex(): Condition.Complex | false {
+    const comp: Condition.Complex = {
+      kind: "complex-condition",
+      all: [],
+      some: [],
+      name: "",
+    };
+    const conditions: Condition.Simple[] = [];
+    this.conditions.forEach((c) => {
+      const maybeSimple = c.toEngineCondition();
+      if (maybeSimple) {
+        conditions.push(maybeSimple);
+      }
+    });
+    if (this._type === "all") {
+      return { ...comp, all: conditions };
+    }
+    if (this._type === "any") {
+      return { ...comp, some: conditions };
+    }
+
+    console.log("INVALID COMPLEX CONDITION. TODO IMPLEMENT range, and count.");
+
+    return false;
+  }
   get type(): ConditionGroupType {
     return this._type;
   }

package/src/rulebuilder/condition/Builder-condition.spec.ts

@@ -0,0 +1,185 @@
+import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
+import { RuleBuilderTestUtils } from "../RuleBuilder-test-utils";
+import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
+import { QuestionVariable } from "../RuleVariable";
+
+let condition = BuilderCondition.create([]);
+
+beforeEach(() => {
+  condition = BuilderCondition.create([]);
+});
+
+describe("Builder Operator", () => {
+  test("Can create", () => {
+    expect(condition).toBeInstanceOf(BuilderCondition);
+  });
+  test("Can resolve dto from Variables in universe.", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 1,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    // c.setVariableList(vs);
+    expect(c.operatorsSelectItems.length).toBe(2);
+    expect(c.operator === "equal").toBe(true);
+    expect(c.value).toBeTruthy();
+  });
+  test("Can not resolve value if invalid value", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 8,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    expect(c.operatorsSelectItems.length).toBe(2);
+    expect(c.value).toBe(false);
+    // expect(match).toBe(false);
+  });
+  test("Will nullify dto if not matchedFrom is called", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, []);
+    expect(c.operatorsSelectItems.length).toBe(0);
+    expect(c.toJson().name).toBe(dto.name);
+    expect(c.toJson().value).toBe("");
+    expect(c.toJson().operator).toBe("");
+    expect(c.toJson().variableId).toBe("");
+    // expect(match).toBe(false);
+  });
+  test("Will not nullify if created with valid universe", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.operator === "equal").toBe(true);
+    const value = c.value as BuilderVariableOption;
+    expect(value.value).toBe(0);
+    expect(value.label).toBe("Nei");
+    expect(c.variable).toBe(a);
+  });
+  test("Condition is valid, when in sync with universe.", () => {
+    const vs = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const a = vs[0];
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+
+      name: "name of a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, vs);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.operator === "equal").toBe(true);
+    const value = c.value as BuilderVariableOption;
+    expect(value.value).toBe(0);
+    expect(value.label).toBe("Nei");
+    expect(c.validate().isValid).toBe(true);
+  });
+  test("Condition is invalid, when not matched against universe", () => {
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "name of a",
+      variableId: "a",
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, []);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("Condition is invalid, when variable dont exist in universe.", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "kkk",
+      operator: "equal",
+      value: 9,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("Condition is invalid if not all set, when variable dont exist in universe.", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "kkk",
+      operator: "equal",
+      value: 9,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("Condition is invalid if operator is not set", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "a",
+      operator: "",
+      value: 1,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.validate().isValid).toBe(false);
+    expect(c.value).toBe(false);
+  });
+  test("Condition is invalid if value (from dto) is not found in variable", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "a",
+      operator: "equal",
+      value: 7,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.operator).toBe("equal");
+    expect(c.operatorsSelectItems.length).toBe(BuilderCondition.NUMBER_OPERATORS.length);
+    expect(c.value).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("toEngineConditionWorks", () => {
+    const universe = RuleBuilderTestUtils.createBuilderVariables_A_H();
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "a",
+      operator: "equal",
+      value: 7,
+    };
+    const c = BuilderCondition.fromDto(dto, universe);
+    expect(c.variable).toBeInstanceOf(QuestionVariable);
+    expect(c.operator).toBe("equal");
+    expect(c.operatorsSelectItems.length).toBe(BuilderCondition.NUMBER_OPERATORS.length);
+    expect(c.value).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+});