@media-quest/builder 0.0.25 → 0.0.26

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-manager.spec.ts

@@ -0,0 +1,189 @@
+import { SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreMemberShipID, SumScoreVariableID } from "../primitives/ID";
+import { SumScoreAnswer } from "./sum-score-answer";
+import { SumScoreManager } from "./sum-score-manager";
+import { SumScoreMembershipDto } from "./sum-score-membership";
+
+const createAnswer = (value: number): SumScoreAnswer => {
+  const varId = "v" + value;
+  const varLabel = "label for " + varId;
+  const valueLabel = "label for value " + value;
+  return {
+    varId,
+    varLabel,
+    value,
+    valueLabel,
+  };
+};
+
+const a0 = createAnswer(0);
+const a1 = createAnswer(1);
+const a2 = createAnswer(2);
+const a3 = createAnswer(3);
+const a4 = createAnswer(4);
+const a5 = createAnswer(5);
+const a6 = createAnswer(6);
+const a7 = createAnswer(7);
+const a8 = createAnswer(8);
+const a9 = createAnswer(9);
+
+const all = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9];
+
+const getData = () => {
+  const dep: SumScoreVariableDto = {
+    basedOn: [],
+    description: "Hvis depresjons index er høyere enn 20, så er det alvorlig.",
+    id: SumScoreVariableID.dummy.a,
+    name: "Depresjons index",
+    useAvg: false,
+  };
+
+  const angst: SumScoreVariableDto = {
+    basedOn: [],
+    description: "Index for angst. Grenseverdi 28.",
+    id: SumScoreVariableID.dummy.d,
+    name: "Angst",
+    useAvg: false,
+  };
+
+  const depA0: SumScoreMembershipDto = {
+    id: SumScoreMemberShipID.create(),
+    sumScoreId: dep.id,
+    varId: a0.varId,
+    weight: 1,
+  };
+
+  const depA1: SumScoreMembershipDto = {
+    id: SumScoreMemberShipID.create(),
+    sumScoreId: dep.id,
+    varId: a1.varId,
+    weight: 1,
+  };
+
+  const angstA0: SumScoreMembershipDto = {
+    id: SumScoreMemberShipID.create(),
+    sumScoreId: dep.id,
+    varId: a0.varId,
+    weight: 1,
+  };
+
+  const angstA1: SumScoreMembershipDto = {
+    id: SumScoreMemberShipID.create(),
+    sumScoreId: dep.id,
+    varId: a1.varId,
+    weight: 1,
+  };
+
+  const angstA5: SumScoreMembershipDto = {
+    id: SumScoreMemberShipID.create(),
+    sumScoreId: dep.id,
+    varId: a5.varId,
+    weight: 1,
+  };
+  return { dep, angst, depA1, depA0, angstA1, angstA0, angstA5 };
+};
+
+describe("Sum-score-manager", () => {
+  test("Crud for variables work", () => {
+    const d = getData();
+    const m = SumScoreManager.create([d.dep, d.angst], [d.depA0, d.depA1, d.angstA5]);
+    expect(m.memberShips.length).toBe(3);
+    expect(m.variables.length).toBe(2);
+    const newVar = m.variableAddNew({});
+    expect(m.variables.length).toBe(3);
+    const newVar2 = m.variableAddNew({
+      name: "var 2 name",
+      description: "var 2 description",
+      useAvg: true,
+    });
+    expect(m.variables.length).toBe(4);
+
+    // Will not delete a variable that is not there.
+    m.variableDeleteById(SumScoreVariableID.create());
+    expect(m.variables.length).toBe(4);
+    m.variableDeleteById(d.dep.id);
+    expect(m.variables.length).toBe(3);
+  });
+  test("Can not add same variable twice", () => {
+    const d = getData();
+    const m = SumScoreManager.create([d.dep, d.angst], [d.depA0, d.depA1, d.angstA5]);
+    expect(m.memberShips.length).toBe(3);
+    expect(m.variables.length).toBe(2);
+    const newVar = m.variableAddNew({});
+    expect(m.variables.length).toBe(3);
+    const newVar2 = m.variableAddNew({ name: "søvnløshet", description: "", useAvg: true });
+    expect(m.variables.length).toBe(4);
+
+    // Will not delete a variable that is not there.
+    m.variableDeleteById(SumScoreVariableID.create());
+    expect(m.variables.length).toBe(4);
+    m.variableDeleteById(d.dep.id);
+    expect(m.variables.length).toBe(3);
+  });
+
+  test("Can update variable", () => {
+    const m = SumScoreManager.create([], []);
+    const v = m.variableAddNew({});
+    expect(m.variables.length).toBe(1);
+    expect(v.useAvg).toBe(true);
+    // Will update dep
+    const updatedName = "Updated name";
+    const updatedDescription = "Updated description";
+    m.variableUpdate(v.id, {
+      name: updatedName,
+      description: updatedDescription,
+      useAvg: false,
+    });
+    const updatedVariable = m.variableGetById(v.id) as SumScoreVariableDto;
+
+    expect(updatedVariable.name).toBe(updatedName);
+    expect(updatedVariable.description).toBe(updatedDescription);
+    expect(updatedVariable.useAvg).toBe(false);
+  });
+
+  test("Crud membership works", () => {
+    const m = SumScoreManager.create([], []);
+    const v1 = m.variableAddNew({ name: "V1" });
+    const v2 = m.variableAddNew({ name: "V2" });
+    expect(m.variables.length).toBe(2);
+    const m1 = m.membershipAdd(v1.id, "a") as SumScoreMembershipDto;
+    expect(m1).toBeTruthy();
+    const m2 = m.membershipAdd(v1.id, "b") as SumScoreMembershipDto;
+    expect(m2).toBeTruthy();
+    expect(m.memberShips.length).toBe(2);
+    const m2_duplicate = m.membershipAdd(v1.id, "b");
+    expect(m.memberShips.length).toBe(2);
+    expect(m.membershipGetById(m1.id)).toEqual(m1);
+    expect(m.membershipGetById(m2.id)).toEqual(m2);
+    m.membershipDelete(m2.id);
+    expect(m.memberShips.length).toBe(1);
+  });
+
+  test("Get membership by varId works", () => {
+    const m = SumScoreManager.create([], []);
+    const v1 = m.variableAddNew({ name: "V1" });
+    const v2 = m.variableAddNew({ name: "V2" });
+    const membership1 = m.membershipAdd(v1.id, "a") as SumScoreMembershipDto;
+    const membership2 = m.membershipAdd(v2.id, "a") as SumScoreMembershipDto;
+    const membership3 = m.membershipAdd(v1.id, "c") as SumScoreMembershipDto;
+
+    expect(membership1).toBeTruthy();
+    expect(membership2).toBeTruthy();
+    expect(membership3).toBeTruthy();
+
+    expect(m.membershipGetByVarId("a")).toEqual([membership1, membership2]);
+    expect(m.membershipGetByVarId("c")).toEqual([membership3]);
+  });
+
+  test("When a variable is deleted, the memberships will be deleted too.", () => {
+    const m = SumScoreManager.create([], []);
+    const v1 = m.variableAddNew({ name: "V1" });
+    const v2 = m.variableAddNew({ name: "V2" });
+    const membership1 = m.membershipAdd(v1.id, "a") as SumScoreMembershipDto;
+    const membership2 = m.membershipAdd(v2.id, "a") as SumScoreMembershipDto;
+    const membership3 = m.membershipAdd(v1.id, "c") as SumScoreMembershipDto;
+    expect(m.memberShips.length).toBe(3);
+    m.variableDeleteById(v1.id);
+    expect(m.membershipGetByVarId("a")).toEqual([membership2]);
+  });
+});