@media-quest/builder 0.0.24 → 0.0.26

package/src/schema-config.ts

@@ -1,4 +1,4 @@
-import { PredefinedVariable } from "./variable/mq-variable";
+import { CodebookPredefinedVariable } from "./code-book/codebook-variable";
 import { BuilderSchemaDto } from "./Builder-schema";
 
 /**
@@ -9,7 +9,7 @@ export interface SchemaConfig {
   readonly schemaName: string;
   readonly schemaId: string;
   readonly schemaPrefix: string;
-  readonly variables: ReadonlyArray<Readonly<PredefinedVariable>>;
+  readonly variables: ReadonlyArray<CodebookPredefinedVariable>;
 }
 
 export const SchemaConfig = {

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]);
+  });
+});

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

@@ -0,0 +1,154 @@
+import { SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreMemberShipID, SumScoreVariableID } from "../primitives/ID";
+import { SumScoreMembershipDto } from "./sum-score-membership";
+import { DUtil } from "@media-quest/engine";
+
+const cloneItem = <const T extends object>(item: T): T => ({ ...item });
+
+export class SumScoreManager implements Iterable<SumScoreVariableDto> {
+  public static readonly create = (
+    variables: Array<SumScoreVariableDto>,
+    memberships: Array<SumScoreMembershipDto>,
+  ): SumScoreManager => {
+    return new SumScoreManager(variables, memberships);
+  };
+
+  private _variables: SumScoreVariableDto[];
+  private _memberShips: SumScoreMembershipDto[];
+
+  private constructor(variables: SumScoreVariableDto[], memberships: SumScoreMembershipDto[]) {
+    this._variables = [...variables];
+    this._memberShips = [...memberships];
+  }
+
+  get variables(): ReadonlyArray<SumScoreVariableDto> {
+    return [...this._variables];
+  }
+  get memberShips(): ReadonlyArray<SumScoreMembershipDto> {
+    return [...this._memberShips];
+  }
+
+  toJson(): { variables: SumScoreVariableDto[]; memberShips: SumScoreMembershipDto[] } {
+    const variables = this._variables.map(cloneItem);
+    const memberShips = this._memberShips.map(cloneItem);
+    return { variables, memberShips };
+  }
+
+  /**
+   * Deletes a variable by its ID.
+   * @param {SumScoreVariableID} id - The ID of the variable to delete.
+   * @return An object containing the deleted variable and the deleted memberships.
+   */
+  variableDeleteById(id: SumScoreVariableID) {
+    const toDelete = this.variableGetById(id);
+    if (!toDelete) return false;
+
+    const keepMemberships: SumScoreMembershipDto[] = [];
+    const toDeleteMemberships: SumScoreMembershipDto[] = [];
+
+    this._memberShips.forEach((memberShip) => {
+      if (memberShip.sumScoreId === id) {
+        toDeleteMemberships.push(memberShip);
+      } else {
+        keepMemberships.push(memberShip);
+      }
+    });
+    this._variables = this._variables.filter((v) => v.id !== id);
+    this._memberShips = keepMemberships;
+    return { variableDeleted: toDelete, membershipsDeleted: toDeleteMemberships };
+    // this._memberShips = this._memberShips.filter((m) => m !== id);
+  }
+
+  variableAddNew(data: {
+    name?: string;
+    description?: string;
+    useAvg?: boolean;
+  }): SumScoreVariableDto {
+    const ssv: SumScoreVariableDto = {
+      id: SumScoreVariableID.create(),
+      basedOn: [],
+      description: "",
+      name: "",
+      useAvg: true,
+    };
+    this._variables.push(ssv);
+    return ssv;
+  }
+
+  variableGetById(id: SumScoreVariableID) {
+    return this._variables.find((variable) => variable.id === id) ?? false;
+  }
+
+  variableUpdate(
+    sumScoreVariableId: SumScoreVariableID,
+    changes: { name?: string; description?: string; useAvg?: boolean },
+  ) {
+    const maybeVariable = this.variableGetById(sumScoreVariableId);
+    if (!maybeVariable) {
+      return false;
+    }
+    if (typeof changes.name === "string") {
+      maybeVariable.name = changes.name;
+    }
+    if (typeof changes.description === "string") {
+      maybeVariable.description = changes.description;
+    }
+    if (typeof changes.useAvg === "boolean") {
+      maybeVariable.useAvg = changes.useAvg;
+    }
+    return true;
+  }
+
+  [Symbol.iterator](): Iterator<SumScoreVariableDto> {
+    return this._variables[Symbol.iterator]();
+  }
+
+  membershipAdd(
+    sumScoreVariableID: SumScoreVariableID,
+    varId: string,
+    weight?: number,
+  ): SumScoreMembershipDto | false {
+    let variableExist = false;
+    let memberShipIsMissing = false;
+
+    // const variableExists = this._variables.some((v) => {
+    //
+    // });
+    this._memberShips.forEach((m) => {
+      if (m.sumScoreId === sumScoreVariableID && m.varId === varId) {
+        variableExist = true;
+      }
+    });
+
+    if (variableExist) {
+      return false;
+    }
+    if (memberShipIsMissing) {
+      return false;
+    }
+
+    const membership: SumScoreMembershipDto = {
+      id: SumScoreMemberShipID.create(),
+      sumScoreId: sumScoreVariableID,
+      varId: varId,
+      weight: DUtil.isNumber(weight) ? weight : 1,
+    };
+
+    this._memberShips.push(membership);
+    return membership;
+  }
+
+  membershipGetById(id: SumScoreMemberShipID): SumScoreMembershipDto | false {
+    // return false;
+    return this._memberShips.find((m) => m.id === id) ?? false;
+  }
+
+  membershipDelete(id: SumScoreMemberShipID) {
+    this._memberShips = this._memberShips.filter((m) => m.id === id);
+  }
+
+  membershipGetByVarId(varId: string): SumScoreMembershipDto[] {
+    const filtered = this._memberShips.filter((m) => m.varId === varId);
+    return filtered.map(cloneItem);
+  }
+}

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

@@ -0,0 +1,45 @@
+import { SumScoreMemberShipID, SumScoreVariableID } from "../primitives/ID";
+import { BuilderObject } from "../BuilderObject";
+import { DUtil } from "@media-quest/engine";
+
+export interface SumScoreMembershipDto {
+  id: SumScoreMemberShipID;
+  sumScoreId: SumScoreVariableID;
+  varId: string;
+  weight: number;
+}
+
+export class SumScoreMemberShip extends BuilderObject<
+  "builder-sum-score-membership",
+  SumScoreMembershipDto
+> {
+  readonly objectType = "builder-sum-score-membership";
+  toJson(): SumScoreMembershipDto {
+    throw new Error("Method not implemented.");
+  }
+  clone(): SumScoreMembershipDto {
+    throw new Error("Method not implemented.");
+  }
+
+  static create = (
+    sumScoreVariableId: SumScoreVariableID,
+    varId: string,
+    weight?: number,
+  ): SumScoreMemberShip => {
+    const id = SumScoreMemberShipID.create();
+    const w = DUtil.isNumber(weight) ? weight : 1;
+    return new SumScoreMemberShip(id, sumScoreVariableId, varId, w);
+  };
+
+  get isValid() {
+    return true;
+  }
+  private constructor(
+    readonly id: SumScoreMemberShipID,
+    readonly sumScoreId: SumScoreVariableID,
+    readonly varId: string,
+    readonly weight: number,
+  ) {
+    super({ id, sumScoreId, varId, weight });
+  }
+}

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

@@ -0,0 +1,151 @@
+import { SumScore } from "./sum-score";
+import { SumScoreVariableDto } from "./sum-score-variable";
+import { SumScoreVariableID } from "../primitives/ID";
+import { SumScoreAnswer } from "./sum-score-answer";
+
+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 createSumScore = (basedOn: SumScoreVariableDto["basedOn"]) => {
+  const id = SumScoreVariableID.create();
+  const sumVar1: SumScoreVariableDto = {
+    id,
+    name: "",
+    description: "",
+    useAvg: true,
+    basedOn,
+  };
+  return sumVar1;
+};
+
+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];
+
+describe("Sum score sum-score.", () => {
+  test("Is allowed SumScoreValue", () => {
+    expect(SumScore.isAllowedValue(-1)).toBeFalsy();
+    expect(SumScore.isAllowedValue(0)).toBeTruthy();
+    expect(SumScore.isAllowedValue(1)).toBeTruthy();
+    expect(SumScore.isAllowedValue(2)).toBeTruthy();
+    expect(SumScore.isAllowedValue(3)).toBeTruthy();
+    expect(SumScore.isAllowedValue(4)).toBeTruthy();
+    expect(SumScore.isAllowedValue(5)).toBeTruthy();
+    expect(SumScore.isAllowedValue(6)).toBeTruthy();
+    expect(SumScore.isAllowedValue(7)).toBeTruthy();
+    expect(SumScore.isAllowedValue(8)).toBeTruthy();
+    expect(SumScore.isAllowedValue(9)).toBeFalsy();
+    expect(SumScore.isAllowedValue(999)).toBeFalsy();
+  });
+
+  test("Will calculate 2", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(3);
+    expect(score.basedOn.length).toBe(3);
+    expect(score.avg).toBe(1.5);
+    expect(score.skippedBy9Count).toBe(1);
+  });
+  test("Will calculate 5 values", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 1 },
+      { varId: a4.varId, varLabel: a4.varLabel, weight: 1 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1 },
+      { varId: a6.varId, varLabel: a6.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 0.5 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(18);
+    expect(score.avg).toBe(3.6);
+    const basedOn1 = score.basedOn[0];
+    expect(basedOn1.value).toBe(a1.value);
+    expect(basedOn1.weight).toBe(1);
+    expect(basedOn1.varId).toBe(a1.varId);
+    expect(basedOn1.varLabel).toBe(a1.varLabel);
+  });
+  test("Will not include 9 in includedAnswersCount", () => {
+    const ss1 = createSumScore([
+      { varId: a0.varId, varLabel: a0.varLabel, weight: 1 },
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1 },
+      { varId: a9.varId, varLabel: a9.varLabel, weight: 1 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(6);
+    expect(score.avg).toBe(2);
+    expect(score.includedAnswerCount).toBe(3);
+  });
+  test("Will calculate weight", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a8.varId, varLabel: a8.varLabel, weight: 0.5 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(5);
+  });
+  test("Will calculate many weighted variables.", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel, weight: 1 },
+      { varId: a2.varId, varLabel: a2.varLabel, weight: 0.5 },
+      { varId: a5.varId, varLabel: a5.varLabel, weight: 1.2 },
+      { varId: a8.varId, varLabel: a8.varLabel, weight: 2 },
+    ]);
+    const score = SumScore.calculate(ss1, all);
+    expect(score.sumScore).toBe(24);
+  });
+  test("Will count missing answers (missingAnswersCount)", () => {
+    const ss1 = createSumScore([
+      { varId: a1.varId, varLabel: a1.varLabel },
+      { varId: a2.varId, varLabel: a2.varLabel },
+      { varId: a3.varId, varLabel: a3.varLabel },
+      { varId: a5.varId, varLabel: a5.varLabel },
+      { varId: a9.varId, varLabel: a9.varLabel },
+    ]);
+    const missing5InDataSet = [a1, a2, a8];
+    const score = SumScore.calculate(ss1, missing5InDataSet);
+    expect(score.sumScore).toBe(3);
+    expect(score.includedAnswerCount).toBe(2);
+    expect(score.missingAnswerCount).toBe(3);
+    expect(score.avg).toBe(1.5);
+    expect(score.basedOn.length).toBe(2);
+    expect(score.avg).toBe(1.5);
+    expect(score.errorMessages.length).toBe(0);
+  });
+  test("includedAnswerCount + missingAnswerCount + skippedBy9Count = SumScoreVariable.basedOn.length", () => {
+    const ss1 = createSumScore([
+      { varId: a0.varId, varLabel: a0.varLabel },
+      { varId: a1.varId, varLabel: a1.varLabel },
+      { varId: a2.varId, varLabel: a2.varLabel },
+      { varId: a9.varId, varLabel: a9.varLabel },
+    ]);
+    const answers = [a1, a7, a8, a9];
+    const score = SumScore.calculate(ss1, answers);
+
+    expect(score.includedAnswerCount + score.missingAnswerCount + score.skippedBy9Count).toBe(
+      ss1.basedOn.length,
+    );
+  });
+});

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

@@ -0,0 +1,36 @@
+import { SumScoreVariableID } from "../primitives/ID";
+import { BuilderObject } from "../BuilderObject";
+
+export interface SumScoreVariableDto {
+  id: SumScoreVariableID;
+  name: string;
+  description: string;
+  useAvg: boolean;
+  /**
+   * All variables that the sum-score should be based on.
+   */
+  basedOn: Array<{ varId: string; varLabel: string; weight?: number }>;
+}
+
+export class SumScoreVariable extends BuilderObject<
+  "builder-sum-score-variable",
+  SumScoreVariableDto
+> {
+  readonly objectType = "builder-sum-score-variable";
+  useAvg = true;
+  name = "";
+  description = "";
+  private _basedOn: Array<{ varId: string }> = [];
+  public static readonly create = () => {
+    const id = SumScoreVariableID.create();
+  };
+  private constructor(dto: SumScoreVariableDto) {
+    super(dto);
+  }
+  toJson(): SumScoreVariableDto {
+    throw new Error("Method not implemented.");
+  }
+  clone(): SumScoreVariableDto {
+    throw new Error("Method not implemented.");
+  }
+}