@media-quest/builder 0.0.22 → 0.0.23

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

@@ -1,118 +1,118 @@
-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,
-};
-
-export type ConditionGroupType = keyof typeof ConditionGroupType;
-export interface BuilderConditionGroupDto {
-  readonly kind: "condition-group";
-  readonly name: string;
-  readonly count?: number;
-  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") {
-      return false;
-    }
-    const validValues = Object.keys(ConditionGroupType);
-    return validValues.includes(value);
-  };
-
-  readonly objectType: "builder-condition-group" = "builder-condition-group";
-  private _type: ConditionGroupType;
-  name = "";
-  private readonly _conditions: Array<BuilderCondition>;
-  private readonly _variableList: ReadonlyArray<BuilderVariable>;
-
-  public static readonly fromDto = (dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) => {
-    return new BuilderConditionGroup(dto, variableList);
-  };
-  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._variableList = variableList;
-  }
-  get conditions(): ReadonlyArray<BuilderCondition> {
-    return this._conditions;
-  }
-
-  get conditionCount() {
-    return this._conditions.length;
-  }
-
-  addCondition(): BuilderCondition {
-    const newConditions = BuilderCondition.create(this._variableList);
-    this._conditions.push(newConditions);
-    return newConditions;
-  }
-
-  removeCondition(condition: BuilderCondition): boolean {
-    // this._conditions.
-    const index = this._conditions.indexOf(condition);
-    if (index < 0) {
-      return false;
-    }
-    this._conditions.splice(index, 1);
-    return true;
-  }
-
-  clone(): BuilderConditionGroupDto {
-    return this.toJson();
-  }
-
-  toJson(): BuilderConditionGroupDto {
-    const conditions: ReadonlyArray<BuilderConditionDto> = [...this._conditions.map((c) => c.toJson())];
-    return {
-      name: this.name,
-      conditions,
-      type: this._type,
-      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;
-  }
-  set type(conditionGroupType: ConditionGroupType) {
-    if (BuilderConditionGroup.isConditionGroupType(conditionGroupType)) {
-      this._type = conditionGroupType;
-    }
-  }
-}
+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,
+};
+
+export type ConditionGroupType = keyof typeof ConditionGroupType;
+export interface BuilderConditionGroupDto {
+  readonly kind: "condition-group";
+  readonly name: string;
+  readonly count?: number;
+  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") {
+      return false;
+    }
+    const validValues = Object.keys(ConditionGroupType);
+    return validValues.includes(value);
+  };
+
+  readonly objectType: "builder-condition-group" = "builder-condition-group";
+  private _type: ConditionGroupType;
+  name = "";
+  private readonly _conditions: Array<BuilderCondition>;
+  private readonly _variableList: ReadonlyArray<BuilderVariable>;
+
+  public static readonly fromDto = (dto: BuilderConditionGroupDto, variableList: ReadonlyArray<BuilderVariable>) => {
+    return new BuilderConditionGroup(dto, variableList);
+  };
+  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._variableList = variableList;
+  }
+  get conditions(): ReadonlyArray<BuilderCondition> {
+    return this._conditions;
+  }
+
+  get conditionCount() {
+    return this._conditions.length;
+  }
+
+  addCondition(): BuilderCondition {
+    const newConditions = BuilderCondition.create(this._variableList);
+    this._conditions.push(newConditions);
+    return newConditions;
+  }
+
+  removeCondition(condition: BuilderCondition): boolean {
+    // this._conditions.
+    const index = this._conditions.indexOf(condition);
+    if (index < 0) {
+      return false;
+    }
+    this._conditions.splice(index, 1);
+    return true;
+  }
+
+  clone(): BuilderConditionGroupDto {
+    return this.toJson();
+  }
+
+  toJson(): BuilderConditionGroupDto {
+    const conditions: ReadonlyArray<BuilderConditionDto> = [...this._conditions.map((c) => c.toJson())];
+    return {
+      name: this.name,
+      conditions,
+      type: this._type,
+      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;
+  }
+  set type(conditionGroupType: ConditionGroupType) {
+    if (BuilderConditionGroup.isConditionGroupType(conditionGroupType)) {
+      this._type = conditionGroupType;
+    }
+  }
+}

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

@@ -1,195 +1,195 @@
-import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
-import { RuleBuilderTestUtils } from "../RuleBuilder-test-utils";
-import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
-import { QuestionVariable } from "../RuleVariable";
-
-import { SchemaPrefix } from "../../primitives/schema-prefix";
-
-let condition = BuilderCondition.create([]);
-
-beforeEach(() => {
-  condition = BuilderCondition.create([]);
-});
-
-const as = SchemaPrefix.fromValueOrThrow("as");
-
-describe("Builder Operator", () => {
-  test("Can create", () => {
-    expect(condition).toBeInstanceOf(BuilderCondition);
-  });
-  test("Can resolve dto from Variables in universe.", () => {
-    const vs = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
-    const a = vs.items.a;
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "a",
-      variableId: a.varId,
-      operator: "equal",
-      value: 1,
-    };
-    const c = BuilderCondition.fromDto(dto, vs.list);
-    // 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.createPagesAndVars_A_H(as);
-    const a = vs.items.a;
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "a",
-      variableId: a.varId,
-      operator: "equal",
-      value: 8,
-    };
-    const c = BuilderCondition.fromDto(dto, vs.list);
-    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.createPagesAndVars_A_H(as);
-    const a = vs.items.a;
-    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.createPagesAndVars_A_H(as);
-    const a = vs.items.a;
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "a",
-      variableId: a.varId,
-      operator: "equal",
-      value: 0,
-    };
-    const c = BuilderCondition.fromDto(dto, vs.list);
-    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.createPagesAndVars_A_H(as);
-    const a = vs.items.a;
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-
-      name: "name of a",
-      variableId: a.varId,
-      operator: "equal",
-      value: 0,
-    };
-    const c = BuilderCondition.fromDto(dto, vs.list);
-    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 variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "invalid variable name in dto",
-      variableId: "kkk",
-      operator: "equal",
-      value: 9,
-    };
-    const c = BuilderCondition.fromDto(dto, variables.list);
-    expect(c.variable).toBe(false);
-    expect(c.validate().isValid).toBe(false);
-  });
-  test("Condition is invalid if not all set, when variable dont exist in variables.", () => {
-    const variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "invalid variable name in dto",
-      variableId: "kkk",
-      operator: "equal",
-      value: 9,
-    };
-    const c = BuilderCondition.fromDto(dto, variables.list);
-    expect(c.variable).toBe(false);
-    expect(c.validate().isValid).toBe(false);
-  });
-
-  test("Condition is invalid if operator is not set", () => {
-    const variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
-    const a = variables.items.a;
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "invalid variable name in dto",
-      variableId: a.varId,
-      operator: "",
-      value: 1,
-    };
-    expect(a.varId).toBe("as_a");
-    const c = BuilderCondition.fromDto(dto, variables.list);
-    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 { list, items } = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
-    expect(items.a.varId).toBe("as_a");
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "invalid variable name in dto",
-      variableId: items.a.varId,
-      operator: "equal",
-      value: 42,
-    };
-    const c = BuilderCondition.fromDto(dto, list);
-    expect(c).toBeInstanceOf(BuilderCondition);
-    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 variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
-
-    const dto: BuilderConditionDto = {
-      kind: "condition",
-      name: "invalid variable name in dto",
-      variableId: variables.items.a.varId,
-      operator: "equal",
-      value: 7,
-    };
-    const c = BuilderCondition.fromDto(dto, variables.list);
-    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);
-  });
-});
+import { BuilderCondition, type BuilderConditionDto } from "./Builder-condition";
+import { RuleBuilderTestUtils } from "../RuleBuilder-test-utils";
+import type { BuilderVariable, BuilderVariableOption } from "../RuleVariable";
+import { QuestionVariable } from "../RuleVariable";
+
+import { SchemaPrefix } from "../../primitives/schema-prefix";
+
+let condition = BuilderCondition.create([]);
+
+beforeEach(() => {
+  condition = BuilderCondition.create([]);
+});
+
+const as = SchemaPrefix.fromValueOrThrow("as");
+
+describe("Builder Operator", () => {
+  test("Can create", () => {
+    expect(condition).toBeInstanceOf(BuilderCondition);
+  });
+  test("Can resolve dto from Variables in universe.", () => {
+    const vs = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
+    const a = vs.items.a;
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 1,
+    };
+    const c = BuilderCondition.fromDto(dto, vs.list);
+    // 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.createPagesAndVars_A_H(as);
+    const a = vs.items.a;
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 8,
+    };
+    const c = BuilderCondition.fromDto(dto, vs.list);
+    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.createPagesAndVars_A_H(as);
+    const a = vs.items.a;
+    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.createPagesAndVars_A_H(as);
+    const a = vs.items.a;
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, vs.list);
+    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.createPagesAndVars_A_H(as);
+    const a = vs.items.a;
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+
+      name: "name of a",
+      variableId: a.varId,
+      operator: "equal",
+      value: 0,
+    };
+    const c = BuilderCondition.fromDto(dto, vs.list);
+    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 variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "kkk",
+      operator: "equal",
+      value: 9,
+    };
+    const c = BuilderCondition.fromDto(dto, variables.list);
+    expect(c.variable).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+  test("Condition is invalid if not all set, when variable dont exist in variables.", () => {
+    const variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: "kkk",
+      operator: "equal",
+      value: 9,
+    };
+    const c = BuilderCondition.fromDto(dto, variables.list);
+    expect(c.variable).toBe(false);
+    expect(c.validate().isValid).toBe(false);
+  });
+
+  test("Condition is invalid if operator is not set", () => {
+    const variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
+    const a = variables.items.a;
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: a.varId,
+      operator: "",
+      value: 1,
+    };
+    expect(a.varId).toBe("as_a");
+    const c = BuilderCondition.fromDto(dto, variables.list);
+    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 { list, items } = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
+    expect(items.a.varId).toBe("as_a");
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: items.a.varId,
+      operator: "equal",
+      value: 42,
+    };
+    const c = BuilderCondition.fromDto(dto, list);
+    expect(c).toBeInstanceOf(BuilderCondition);
+    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 variables = RuleBuilderTestUtils.createPagesAndVars_A_H(as);
+
+    const dto: BuilderConditionDto = {
+      kind: "condition",
+      name: "invalid variable name in dto",
+      variableId: variables.items.a.varId,
+      operator: "equal",
+      value: 7,
+    };
+    const c = BuilderCondition.fromDto(dto, variables.list);
+    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);
+  });
+});