@media-quest/builder 0.0.25 → 0.0.27

package/src/rulebuilder/rule2/Rule2.ts

@@ -1,215 +1,211 @@
-import { BuilderOperator } from "../condition/Builder-operator";
-import { BuilderConditionDto } from "../condition/Builder-condition";
-import { BuilderConditionGroupDto } from "../condition/Builder-condition-group";
-import { BuilderRuleDto } from "../Builder-rule";
-
-type SolveErrorReason =
-  | "INVALID_FACT_TYPE"
-  | "INVALID_OPERATOR"
-  | "INVALID_VALUE"
-  | "INVALID_VARIABLE"
-  | "UNIMPLEMENTED_VARIABLE_TYPE"
-  | "UNIMPLEMENTED_OPERATOR";
-
-type TrueResult = { readonly type: "IS_TRUE" };
-type FalseResult = { readonly type: "IS_FALSE" };
-type MissingFactsResult = {
-  readonly type: "MISSING_FACTS";
-  readonly missingVariables: ReadonlyArray<string>;
-};
-type ErrorResult = {
-  readonly type: "HAS_ERROR";
-  readonly reason: SolveErrorReason;
-  readonly data: Record<string, string>;
-};
-
-export type EvalResult = FalseResult | TrueResult | MissingFactsResult | ErrorResult;
-
-export interface Fact2 {
-  readonly variableType: "numeric";
-  readonly value: number;
-  readonly valueLabel: string;
-  readonly variableId: string;
-  readonly variableLabel: string;
-}
-
-export class FactCollection {
-  public static isFact = (value: unknown): value is Fact2 => {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      return false;
-    }
-    const fact = value as Partial<Fact2>;
-    if (typeof fact.variableId !== "string" || fact.variableId.length === 0) {
-      return false;
-    }
-    if (typeof fact.variableLabel !== "string") {
-      return false;
-    }
-    if (typeof fact.value !== "number") {
-      return false;
-    }
-    if (typeof fact.valueLabel !== "string") {
-      return false;
-    }
-    // NB: This is a temporary check until we have more variable types.
-    if (typeof fact.variableType !== "string" || fact.variableType !== "numeric") {
-      return false;
-    }
-
-    return true;
-  };
-  public static create = (facts: ReadonlyArray<Fact2>): FactCollection => {
-    return new FactCollection(facts);
-  };
-
-  private readonly _facts: ReadonlyArray<Fact2>;
-
-  private constructor(facts: ReadonlyArray<Fact2>) {
-    if (!Array.isArray(facts)) {
-      console.log("Invalid facts", facts);
-      this._facts = [];
-    } else {
-      this._facts = [...facts];
-    }
-  }
-  byId(variableId: string): Fact2 | false {
-    const result = this._facts.find((fact) => fact.variableId === variableId);
-    if (!result) {
-      return false;
-    }
-    return { ...result };
-  }
-}
-interface FactEvaluator {
-  isTrue(facts: FactCollection): boolean;
-  evaluate(facts: FactCollection): EvalResult;
-}
-interface IsValid {
-  isValid(): boolean;
-}
-export class Condition implements FactEvaluator, IsValid {
-  public static create = (dto: BuilderConditionDto): Condition => {
-    return new Condition(dto);
-  };
-  private constructor(private readonly dto: BuilderConditionDto) {}
-  isTrue(facts: FactCollection): boolean {
-    const dto = this.dto;
-    const op = dto.operator;
-    const value = dto.value;
-    const varId = dto.variableId;
-    if (!BuilderOperator.is(op)) {
-      return false;
-    }
-
-    if (typeof value !== "number") {
-      return false;
-    }
-
-    const fact = facts.byId(this.dto.variableId);
-
-    if (!FactCollection.isFact(fact)) {
-      return false;
-    }
-
-    if (fact.variableType !== "numeric" && typeof fact.value !== "number") {
-      return false;
-    }
-
-    if (op === "equal") {
-      return fact.value === value;
-    }
-
-    if (op === "notEqual") {
-      return fact.value !== value;
-    }
-
-    return false;
-  }
-  isValid(): boolean {
-    return false;
-  }
-
-  evaluate(facts: FactCollection): EvalResult {
-    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
-  }
-}
-export class ConditionGroup implements FactEvaluator, IsValid {
-  public static readonly create = (dto: BuilderConditionGroupDto): ConditionGroup => {
-    return new ConditionGroup(dto);
-  };
-
-  private readonly _conditions: ReadonlyArray<Condition>;
-  private constructor(private readonly dto: BuilderConditionGroupDto) {
-    this._conditions = dto.conditions.map(Condition.create);
-  }
-
-  isTrue(facts: FactCollection): boolean {
-    const results = this._conditions.map((condition) => condition.isTrue(facts));
-    let trueCount = 0;
-    let falseCount = 0;
-    results.forEach((results) => {
-      if (results) {
-        trueCount++;
-      } else {
-        falseCount++;
-      }
-    });
-    if (trueCount === 0 || falseCount === 0) {
-      return false;
-    }
-    const type = this.dto.type;
-
-    if (type === "all" && trueCount === this._conditions.length) {
-      return true;
-    }
-
-    if (type === "any" && trueCount > 0) {
-      return true;
-    }
-
-    const minLimit = this.dto.count;
-    if (type === "count" && typeof minLimit === "number" && trueCount >= minLimit) {
-      return true;
-    }
-
-    return false;
-  }
-
-  isValid(): boolean {
-    return true;
-  }
-
-  evaluate(facts: FactCollection): EvalResult {
-    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
-  }
-}
-export class Rule2 implements FactEvaluator {
-  readonly name: string;
-  private readonly _conditions: ReadonlyArray<Condition | ConditionGroup>;
-  public static readonly create = (dto: BuilderRuleDto): Rule2 => {
-    return new Rule2(dto);
-  };
-  private _count = -1;
-  constructor(private readonly dto: BuilderRuleDto) {
-    this.name = dto.name;
-    const conditions: Array<Condition | ConditionGroup> = [];
-    dto.conditions.forEach((condition) => {
-      if (condition.kind === "condition-group") {
-        conditions.push(ConditionGroup.create(condition));
-      } else if (condition.kind === "condition") {
-        conditions.push(Condition.create(condition));
-      } else {
-        console.log("Unknown condition", condition);
-      }
-    });
-    this._conditions = conditions;
-  }
-
-  isTrue(facts: FactCollection): boolean {
-    return false;
-  }
-
-  evaluate(facts: FactCollection): EvalResult {
-    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
-  }
-}
+import { BuilderOperator } from "../condition/Builder-operator";
+import { BuilderConditionDto } from "../condition/Builder-condition";
+import { BuilderConditionGroupDto } from "../condition/Builder-condition-group";
+import { BuilderRuleDto } from "../Builder-rule";
+
+type SolveErrorReason =
+  | "INVALID_FACT_TYPE"
+  | "INVALID_OPERATOR"
+  | "INVALID_VALUE"
+  | "INVALID_VARIABLE"
+  | "UNIMPLEMENTED_VARIABLE_TYPE"
+  | "UNIMPLEMENTED_OPERATOR";
+
+type TrueResult = { readonly type: "IS_TRUE" };
+type FalseResult = { readonly type: "IS_FALSE" };
+type MissingFactsResult = {
+  readonly type: "MISSING_FACTS";
+  readonly missingVariables: ReadonlyArray<string>;
+};
+type ErrorResult = {
+  readonly type: "HAS_ERROR";
+  readonly reason: SolveErrorReason;
+  readonly data: Record<string, string>;
+};
+
+export type EvalResult = FalseResult | TrueResult | MissingFactsResult | ErrorResult;
+
+export interface Fact2 {
+  readonly variableType: "numeric";
+  readonly value: number;
+  readonly valueLabel: string;
+  readonly variableId: string;
+  readonly variableLabel: string;
+}
+
+export class FactCollection {
+  public static isFact = (value: unknown): value is Fact2 => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const fact = value as Partial<Fact2>;
+    if (typeof fact.variableId !== "string" || fact.variableId.length === 0) {
+      return false;
+    }
+    if (typeof fact.variableLabel !== "string") {
+      return false;
+    }
+    if (typeof fact.value !== "number") {
+      return false;
+    }
+    if (typeof fact.valueLabel !== "string") {
+      return false;
+    }
+    // NB: This is a temporary check until we have more sum-score types.
+    if (typeof fact.variableType !== "string" || fact.variableType !== "numeric") {
+      return false;
+    }
+
+    return true;
+  };
+  public static create = (facts: ReadonlyArray<Fact2>): FactCollection => {
+    return new FactCollection(facts);
+  };
+
+  private readonly _facts: ReadonlyArray<Fact2>;
+
+  private constructor(facts: ReadonlyArray<Fact2>) {
+    if (!Array.isArray(facts)) {
+      console.log("Invalid facts", facts);
+      this._facts = [];
+    } else {
+      this._facts = [...facts];
+    }
+  }
+  byId(variableId: string): Fact2 | false {
+    const result = this._facts.find((fact) => fact.variableId === variableId);
+    if (!result) {
+      return false;
+    }
+    return { ...result };
+  }
+}
+interface FactEvaluator {
+  isTrue(facts: FactCollection): boolean;
+  evaluate(facts: FactCollection): EvalResult;
+}
+interface IsValid {
+  isValid(): boolean;
+}
+export class Condition implements FactEvaluator, IsValid {
+  public static create = (dto: BuilderConditionDto): Condition => {
+    return new Condition(dto);
+  };
+  private constructor(private readonly dto: BuilderConditionDto) {}
+  isTrue(facts: FactCollection): boolean {
+    const dto = this.dto;
+    const op = dto.operator;
+    const value = dto.value;
+    const varId = dto.variableId;
+    if (!BuilderOperator.is(op)) {
+      return false;
+    }
+
+    if (typeof value !== "number") {
+      return false;
+    }
+
+    const fact = facts.byId(this.dto.variableId);
+
+    if (!FactCollection.isFact(fact)) {
+      return false;
+    }
+
+    if (fact.variableType !== "numeric" && typeof fact.value !== "number") {
+      return false;
+    }
+
+    if (op === "equal") {
+      return fact.value === value;
+    }
+
+    if (op === "notEqual") {
+      return fact.value !== value;
+    }
+
+    return false;
+  }
+  isValid(): boolean {
+    return false;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}
+export class ConditionGroup implements FactEvaluator, IsValid {
+  public static readonly create = (dto: BuilderConditionGroupDto): ConditionGroup => {
+    return new ConditionGroup(dto);
+  };
+
+  private readonly _conditions: ReadonlyArray<Condition>;
+  private constructor(private readonly dto: BuilderConditionGroupDto) {
+    this._conditions = dto.conditions.map(Condition.create);
+  }
+
+  isTrue(facts: FactCollection): boolean {
+    const results = this._conditions.map((condition) => condition.isTrue(facts));
+    let trueCount = 0;
+    let falseCount = 0;
+    results.forEach((results) => {
+      if (results) {
+        trueCount++;
+      } else {
+        falseCount++;
+      }
+    });
+    if (trueCount === 0 || falseCount === 0) {
+      return false;
+    }
+    const type = this.dto.type;
+
+    if (type === "all" && trueCount === this._conditions.length) {
+      return true;
+    }
+
+    if (type === "any" && trueCount > 0) {
+      return true;
+    }
+
+    const minLimit = this.dto.count;
+    return type === "count" && typeof minLimit === "number" && trueCount >= minLimit;
+  }
+
+  isValid(): boolean {
+    return true;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}
+export class Rule2 implements FactEvaluator {
+  readonly name: string;
+  private readonly _conditions: ReadonlyArray<Condition | ConditionGroup>;
+  public static readonly create = (dto: BuilderRuleDto): Rule2 => {
+    return new Rule2(dto);
+  };
+  private _count = -1;
+  constructor(private readonly dto: BuilderRuleDto) {
+    this.name = dto.name;
+    const conditions: Array<Condition | ConditionGroup> = [];
+    dto.conditions.forEach((condition) => {
+      if (condition.kind === "condition-group") {
+        conditions.push(ConditionGroup.create(condition));
+      } else if (condition.kind === "condition") {
+        conditions.push(Condition.create(condition));
+      } else {
+        console.log("Unknown condition", condition);
+      }
+    });
+    this._conditions = conditions;
+  }
+
+  isTrue(facts: FactCollection): boolean {
+    return false;
+  }
+
+  evaluate(facts: FactCollection): EvalResult {
+    return { type: "HAS_ERROR", reason: "UNIMPLEMENTED_VARIABLE_TYPE", data: {} }; // TODO
+  }
+}

package/src/schema-config.ts

@@ -1,25 +1,25 @@
-import { PredefinedVariable } from "./variable/b-variable";
-import { BuilderSchemaDto } from "./Builder-schema";
-
-/**
- * This interface is ment to define all information that a schema-admin app
- * needs to generate a dynamic form for setting values for predefined variables.
- */
-export interface SchemaConfig {
-  readonly schemaName: string;
-  readonly schemaId: string;
-  readonly schemaPrefix: string;
-  readonly variables: ReadonlyArray<Readonly<PredefinedVariable>>;
-}
-
-export const SchemaConfig = {
-  fromSchema: (schema: BuilderSchemaDto): SchemaConfig => {
-    const variables = schema.predefinedVariables ?? [];
-    return {
-      schemaId: schema.id,
-      schemaName: schema.name,
-      schemaPrefix: schema.prefix,
-      variables,
-    };
-  },
-} as const;
+import { CodebookPredefinedVariable } from "./code-book/codebook-variable";
+import { BuilderSchemaDto } from "./Builder-schema";
+
+/**
+ * This interface is ment to define all information that a schema-admin app
+ * needs to generate a dynamic form for setting values for predefined variables.
+ */
+export interface SchemaConfig {
+  readonly schemaName: string;
+  readonly schemaId: string;
+  readonly schemaPrefix: string;
+  readonly variables: ReadonlyArray<CodebookPredefinedVariable>;
+}
+
+export const SchemaConfig = {
+  fromSchema: (schema: BuilderSchemaDto): SchemaConfig => {
+    const variables = schema.predefinedVariables ?? [];
+    return {
+      schemaId: schema.id,
+      schemaName: schema.name,
+      schemaPrefix: schema.prefix,
+      variables,
+    };
+  },
+} as const;

package/src/sum-score/sum-score-answer.ts

@@ -0,0 +1,6 @@
+export interface SumScoreAnswer {
+  readonly varId: string;
+  readonly varLabel: string;
+  readonly value: number;
+  readonly valueLabel: string;
+}

package/src/sum-score/sum-score-variable-collection.spec.ts

@@ -0,0 +1,68 @@
+import { SumScoreVariableCollection } from "./sum-score-variable-collection";
+import { SumScoreVariable } from "./sum-score-variable";
+
+const v = (name: string) => {
+  return SumScoreVariable.create({ name, description: "description for " + name, useAvg: true });
+};
+
+let empty = SumScoreVariableCollection.create([]);
+beforeEach(() => {
+  empty = SumScoreVariableCollection.create([]);
+});
+describe("Sum-score-variable-collection", () => {
+  test("Add, update, delete works", () => {
+    const v1 = empty.addNew({ name: "v1", description: "v1 desc", useAvg: true });
+    const v2 = empty.addNew({ name: "v2", description: "v2 desc", useAvg: true });
+
+    const v2_updated = empty._updateOne(v2.id, { name: "n2", description: "d2", useAvg: false });
+    expect(v2_updated).toBeTruthy();
+    expect(empty.size).toBe(2);
+    const variable = empty._getVariableById(v2.id);
+    expect(variable).toBeDefined();
+    expect(variable!.name).toBe("n2");
+    expect(variable!.description).toBe("d2");
+    expect(variable!.useAvg).toBe(false);
+    empty._deleteVariable(v1.id);
+    expect(empty.size).toBe(1);
+  });
+  test("Duplicate names are detected", () => {
+    const v1 = empty.addNew({ name: "v1", description: "desc", useAvg: true });
+    const v2 = empty.addNew({ name: "v1", description: "desc", useAvg: true });
+    expect(v1.hasErrors).toBe(true);
+    expect(v2.hasErrors).toBe(true);
+  });
+  test("Error are removed on update", () => {
+    const v1 = empty.addNew({ name: "v1", description: "desc", useAvg: true });
+    const v2 = empty.addNew({ name: "v1", description: "desc", useAvg: true });
+    expect(v1.hasErrors).toBe(true);
+    expect(v2.hasErrors).toBe(true);
+    empty._updateOne(v1.id, { name: "updated-name-updated" });
+    expect(v1.hasErrors).toBe(false);
+    expect(v2.hasErrors).toBe(false);
+  });
+  test("Error are removed on delete", () => {
+    const v1 = empty.addNew({ name: "v1", description: "desc", useAvg: true });
+    const v2 = empty.addNew({ name: "v1", description: "desc", useAvg: true });
+    expect(v1.hasErrors).toBe(true);
+    expect(v2.hasErrors).toBe(true);
+    empty._deleteVariable(v1.id);
+
+    expect(empty.size).toBe(1);
+    expect(v2.hasErrors).toBe(false);
+  });
+  test("Error are detected on construction", () => {
+    const col = SumScoreVariableCollection.create([v("v1"), v("v1")]);
+    expect(col.errorsCount).toBe(2);
+  });
+
+  test("Error are detected after init", () => {
+    const col = SumScoreVariableCollection.create([]);
+    const v1 = v("v1");
+    const v1_duplicate = v("v1");
+    const v3 = v("v3");
+    const v4 = v("v4");
+    col.init([v1, v1_duplicate, v3, v4]);
+    expect(col.errorsCount).toBe(2);
+    expect(col.size).toBe(4);
+  });
+});

package/src/sum-score/sum-score-variable-collection.ts

@@ -0,0 +1,101 @@
+import { SumScoreVariable, SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreVariableID } from "../primitives/ID";
+
+export class SumScoreVariableCollection implements Iterable<SumScoreVariable> {
+  private _all: Array<SumScoreVariable> = [];
+
+  [Symbol.iterator]() {
+    const list = [...this._all];
+    return list[Symbol.iterator]();
+  }
+
+  asArray(): ReadonlyArray<SumScoreVariable> {
+    return [...this._all];
+  }
+
+  public static readonly create = (
+    variables?: SumScoreVariableDto[],
+  ): SumScoreVariableCollection => {
+    return new SumScoreVariableCollection(variables);
+  };
+
+  private constructor(sumScoreVariables?: SumScoreVariableDto[]) {
+    const all = Array.isArray(sumScoreVariables) ? sumScoreVariables : [];
+    this._all = all.map((dto) => SumScoreVariable.fromDto(dto));
+    this.checkForErrors();
+  }
+
+  init(variables: SumScoreVariableDto[]) {
+    this._all = variables.map((variable) => SumScoreVariable.fromDto(variable));
+    this.checkForErrors();
+  }
+  addNew(options: { name: string; description: string; useAvg: boolean }) {
+    // console.log(options);
+    const newVariable = SumScoreVariable.create({ ...options });
+    this._all.push(newVariable);
+    this.checkForErrors();
+    return newVariable;
+  }
+
+  get size() {
+    return this._all.length;
+  }
+
+  get errorsCount() {
+    return this._all.filter((variable) => variable.hasErrors).length;
+  }
+
+  toJson() {
+    return this._all.map((item) => item.toJson());
+  }
+
+  /**
+   *
+   */
+  _deleteVariable(id: SumScoreVariableID) {
+    const initialSize = this._all.length;
+    this._all = this._all.filter((variable) => variable.id !== id);
+    this.checkForErrors();
+    return initialSize === this.size + 1;
+  }
+
+  /**
+   * @internal
+   */
+  _updateOne(
+    id: SumScoreVariableID,
+    updates: { name?: string; description?: string; useAvg?: boolean },
+  ): boolean {
+    const variable = this._all.find((variable) => variable.id === id);
+    if (variable) {
+      variable._update(updates);
+      this.checkForErrors();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /** @internal */
+  _getVariableById(id: SumScoreVariableID): SumScoreVariable | undefined {
+    return this._all.find((variable) => variable.id === id);
+  }
+
+  private checkForErrors() {
+    const nameMap = new Map<string, SumScoreVariable[]>();
+    this._all.forEach((v) => {
+      const array = nameMap.get(v.name) ?? [];
+      array.push(v);
+      nameMap.set(v.name, array);
+    });
+    nameMap.forEach((sameNameArray) => {
+      sameNameArray.forEach((sameNameItem) => {
+        if (sameNameArray.length > 1) {
+          sameNameItem._setError("Duplicate name");
+        } else {
+          sameNameItem._setError("");
+        }
+      });
+    });
+  }
+}