@media-quest/builder 0.0.25 → 0.0.27

package/src/Builder-schema.spec.ts

@@ -1,13 +1,13 @@
 import type { BuilderSchemaDto } from "./Builder-schema";
 import { BuilderSchema } from "./Builder-schema";
-import { BuilderPage } from "./Builder-page";
-import type { BuilderTagDto } from "./BuilderTag";
-import { BuilderTag } from "./BuilderTag";
+import { BuilderPage } from "./page/Builder-page";
+import type { BuilderTagDto } from "./tag/BuilderTag";
+import { BuilderTag } from "./tag/BuilderTag";
 import { PagePrefix } from "./primitives/page-prefix";
 import { SchemaPrefix } from "./primitives/schema-prefix";
 
-import { SumScoreVariableDto } from "./variable/sum-score-variable";
-import { OptionID, PageID, QuestionID, SchemaID } from "./primitives/ID";
+import { SumScoreVariableDto } from "./sum-score/sum-score-variable";
+import { OptionID, PageID, QuestionID, SchemaID, SumScoreVariableID } from "./primitives/ID";
 
 const tag1: BuilderTagDto = BuilderTag.create("tag1", "This tag is defined in schemaDto1").toJson();
 
@@ -24,18 +24,18 @@ const schemaDto1: BuilderSchemaDto = {
   tags: [tag1, tag2, tag3],
   sumScoreVariables: [
     {
-      kind: "numeric-variable",
-      origin: "sum-score",
-      label: "label for dummy variable",
-      initialValue: 0,
-      varId: "testId",
-      basedOn: [],
+      id: SumScoreVariableID.dummy.a,
+      name: "label for dummy sum-score",
+      description: "testId",
+      useAvg: false,
+      // basedOn: [],
     },
   ],
   pages: [
     {
       id: PageID.validateOrCreate("a".repeat(24)),
       _type: "info-page",
+      includedInSumScores: [],
       prefix: PagePrefix.fromStringOrThrow("p1"),
       mainText: {
         text: "hello from test",
@@ -78,14 +78,14 @@ const schemaDto1: BuilderSchemaDto = {
         // { tag: 'can_read', description: 'The patient can read' },
         // { tag: 'is grown up', description: 'Is grownUp.' }
       ],
-      questions: [],
       autoplaySequence: [],
     },
     {
-      id: PageID.validateOrCreate("b".repeat(24)),
-      _type: "multi-select",
+      id: PageID.dummy.b,
+      _type: "question",
       prefix: PagePrefix.fromStringOrThrow("page2-prefix"),
       tags: [tag3.tag],
+      includedInSumScores: [],
       mainText: {
         text: "hello from test",
         autoplay: false,
@@ -104,31 +104,6 @@ const schemaDto1: BuilderSchemaDto = {
         text: "q1",
         options: [],
       },
-      questions: [
-        {
-          id: QuestionID.create(),
-          prefix: "one-prefix",
-          _type: "select-one",
-          text: "q1-text",
-          options: [
-            {
-              id: "opt-nei" as OptionID,
-              value: 0,
-              label: "Nei",
-            },
-            {
-              id: "opt-ja" as OptionID,
-              value: 1,
-              label: "Ja",
-            },
-            {
-              id: "opt-vet-ikke" as OptionID,
-              value: 9,
-              label: "Vet ikke",
-            },
-          ],
-        },
-      ],
       autoplaySequence: [],
     },
   ],
@@ -138,41 +113,41 @@ const schemaDto1: BuilderSchemaDto = {
 };
 
 const SCHEMA_ID = SchemaID.create();
-const schemaPrefixA = SchemaPrefix.castOrCreateRandom("a").value;
-let builderSchema = BuilderSchema.create(SCHEMA_ID, "test", schemaPrefixA);
+const SCHEMA_PREFIX_A = SchemaPrefix.castOrCreateRandom("a").value;
+let s1 = BuilderSchema.create(SCHEMA_ID, "test-name", SCHEMA_PREFIX_A);
 
 beforeEach(() => {
-  builderSchema = BuilderSchema.create(SCHEMA_ID, "test-name", schemaPrefixA);
+  s1 = BuilderSchema.create(SCHEMA_ID, "test-name", SCHEMA_PREFIX_A);
 });
 
 describe("Builder schema", () => {
   test("Can add pages.", () => {
-    builderSchema.addPage("question");
-    builderSchema.addPage("info-page");
-    expect(builderSchema.pages.length).toBe(2);
-    const dto = builderSchema.compile().schema;
+    s1.addPage("question");
+    s1.addPage("info-page");
+    expect(s1.pages.length).toBe(2);
+    const dto = s1.compile().schema;
     expect(dto.pages.length).toBe(2);
-    expect(dto.id).toBe(builderSchema.id);
-    expect(dto.baseHeight).toBe(builderSchema.baseHeight);
-    expect(dto.baseWidth).toBe(builderSchema.baseWidth);
-    expect(dto.backgroundColor).toBe(builderSchema.backgroundColor);
+    expect(dto.id).toBe(s1.id);
+    expect(dto.baseHeight).toBe(s1.baseHeight);
+    expect(dto.baseWidth).toBe(s1.baseWidth);
+    expect(dto.backgroundColor).toBe(s1.backgroundColor);
   });
 
   test("Can delete page by passing reference", () => {
-    const p1 = builderSchema.addPage("question");
-    const p2 = builderSchema.addPage("question");
-    const p3 = builderSchema.addPage("info-page");
-    expect(builderSchema.pages.length).toBe(3);
-    const result = builderSchema.deletePage(p1);
-    expect(builderSchema.pages.length).toBe(2);
+    const p1 = s1.addPage("question");
+    const p2 = s1.addPage("question");
+    const p3 = s1.addPage("info-page");
+    expect(s1.pages.length).toBe(3);
+    const result = s1.deletePage(p1);
+    expect(s1.pages.length).toBe(2);
     expect(result).toBe(true);
-    const result2 = builderSchema.deletePage(p2);
+    const result2 = s1.deletePage(p2);
     expect(result2).toBe(true);
-    expect(builderSchema.pages.length).toBe(1);
-    expect(builderSchema.pages[0]).toBe(p3);
-    const result3 = builderSchema.deletePage(p2);
+    expect(s1.pages.length).toBe(1);
+    expect(s1.pages[0]).toBe(p3);
+    const result3 = s1.deletePage(p2);
     expect(result3).toBe(false);
-    const result4 = builderSchema.deletePage(p3);
+    const result4 = s1.deletePage(p3);
     expect(result4).toBe(true);
   });
 
@@ -205,73 +180,76 @@ describe("Builder schema", () => {
     const json = s.toJson();
     expect(schemaDto1).toStrictEqual(json);
   });
+
   test("Can add page at concrete index", () => {
-    const p1 = builderSchema.addPage("form");
-    expect(p1.pageType).toBe("form");
-    const p2 = builderSchema.addPage("multi-select", 0);
-    expect(p2.pageType).toBe("multi-select");
-    const pages = builderSchema.pages;
-    expect(pages[0].id).toBe(p2.id);
-    builderSchema.addPage("form");
-    builderSchema.addPage("form");
-    const last = builderSchema.addPage("form");
-    expect(builderSchema.pages[builderSchema.pages.length - 1]).toBe(last);
-    const p3 = builderSchema.addPage("info-page", 4);
-    expect(pages[4].id).toBe(p3.id);
+    const p1 = s1.addPage("question");
+    expect(p1.pageType).toBe("question");
+    const p2 = s1.addPage("info-page", 0);
+    expect(p2.pageType).toBe("info-page");
+    // const pages = s1.pages;
+    expect(s1.pages[0].id).toBe(p2.id);
+    s1.addPage("question");
+    s1.addPage("question");
+    const last = s1.addPage("question");
+    expect(s1.pages[s1.pages.length - 1]).toBe(last);
+    const p3 = s1.addPage("info-page", 4);
+    expect(s1.pages[4].id).toBe(p3.id);
   });
+
   test("Can move page up and down", () => {
-    const p1 = builderSchema.addPage("form");
-    const p2 = builderSchema.addPage("form");
-    const p3 = builderSchema.addPage("form");
-    const p4 = builderSchema.addPage("multi-select");
-    const last = builderSchema.addPage("form");
-    const pages = builderSchema.pages;
-    builderSchema.movePage(p2, 0);
-    expect(pages[0]).toBe(p2);
-    expect(pages[1]).toBe(p1);
-    expect(builderSchema.movePage(p4, 4)).toBeTruthy();
-    expect(builderSchema.movePage(p4, 5)).toBeFalsy();
-    expect(builderSchema.movePage(p4, 10)).toBeFalsy();
+    const p1 = s1.addPage("question");
+    const p2 = s1.addPage("question");
+    const p3 = s1.addPage("question");
+    const p4 = s1.addPage("info-page");
+    const last = s1.addPage("question");
+    s1.movePage(p2, 0);
+    expect(s1.pages[0]).toBe(p2);
+    expect(s1.pages[1]).toBe(p1);
+    expect(s1.movePage(p4, 4)).toBeTruthy();
+    expect(s1.movePage(p4, 5)).toBeFalsy();
+    expect(s1.movePage(p4, 10)).toBeFalsy();
 
     // expect(pages[0].id).toBe(p4.id);
   });
+
   test("Can clone a page and insert at index", () => {
-    const p1 = builderSchema.addPage("form");
-    const p2 = builderSchema.addPage("form");
-    const p3 = builderSchema.addPage("form");
+    const p1 = s1.addPage("question");
+    const p2 = s1.addPage("question");
+    const p3 = s1.addPage("question");
     const mainTextContent = "Hello from test";
-    const p4 = builderSchema.addPage("multi-select");
+    const p4 = s1.addPage("info-page");
     p3.mainText.text = mainTextContent;
     const p1Clone = BuilderPage.fromJson(p1.clone());
-    const beforeLen = builderSchema.pages.length;
-    builderSchema.insertPage(p1Clone, 2);
-    const pages = builderSchema.pages;
+    const beforeLen = s1.pages.length;
+    s1.insertPage(p1Clone, 2);
+    const pages = s1.pages;
     expect(beforeLen + 1).toBe(pages.length);
     expect(pages[2]).toBe(p1Clone);
   });
+
   test("Will not insert a page that is already in array.", () => {
-    const p1 = builderSchema.addPage("form");
-    const p2 = builderSchema.addPage("form");
-    const p3 = builderSchema.addPage("form");
-    const beforeLen = builderSchema.pages.length;
-    const result = builderSchema.insertPage(p1, 0);
-    const pages = builderSchema.pages;
+    const p1 = s1.addPage("question");
+    const p2 = s1.addPage("question");
+    const p3 = s1.addPage("question");
+    const beforeLen = s1.pages.length;
+    const result = s1.insertPage(p1, 0);
+    const pages = s1.pages;
     expect(beforeLen).toBe(pages.length);
     expect(result).toBe(false);
   });
 
   test("Can generate a info-page", () => {
-    const p1 = builderSchema.addPage("info-page");
-    const p2 = builderSchema.addPage("question");
+    const p1 = s1.addPage("info-page");
+    const p2 = s1.addPage("question");
     p2.defaultQuestion.addOption("Ja", 1, 0);
     p2.defaultQuestion.addOption("Nei", 0);
     p1.nextButton.label = "Neste";
-    builderSchema.backgroundColor = "red";
-    builderSchema.baseHeight = 600;
-    builderSchema.baseWidth = 500;
+    s1.backgroundColor = "red";
+    s1.baseHeight = 600;
+    s1.baseWidth = 500;
     // builderSchema.prefix = "as";
-    builderSchema.name = "depressed";
-    const schema = builderSchema.compile().schema;
+    s1.name = "depressed";
+    const schema = s1.compile().schema;
     expect(schema.backgroundColor).toBe("red");
     expect(schema.baseHeight).toBe(600);
     expect(schema.baseWidth).toBe(500);
@@ -287,17 +265,17 @@ describe("Builder schema", () => {
     // expect(schemaP2.elements.length).toBe(options.length + 1);
   });
   test("Can get ruleInput!", () => {
-    const p0 = builderSchema.addPage("info-page");
+    const p0 = s1.addPage("info-page");
     // p0.prefix = "info_page_prefix_";
-    const p1 = builderSchema.addPage("question");
+    const p1 = s1.addPage("question");
     // p1.prefix = "p1_prefix_";
-    const p2 = builderSchema.addPage("question");
+    const p2 = s1.addPage("question");
     // p2.prefix = "p2_prefix_";
     p1.defaultQuestion.addOption("Ja", 1, 0);
     p1.defaultQuestion.addOption("Nei", 0, 0);
     p2.defaultQuestion.addOption("Ja", 1, 0);
     p2.defaultQuestion.addOption("Nei", 0);
-    const ruleInput = builderSchema.getRuleInput();
+    const ruleInput = s1.getRuleInput();
     expect(ruleInput.questionVars.length).toBe(2);
     expect(ruleInput.jumpToPageActions.length).toBe(3);
     // TODO add TAGS!!
@@ -314,44 +292,57 @@ describe("Builder schema", () => {
       expect(allPageIds.has(v.pageId)).toBe(true);
     });
   });
-  test.skip("Can add sum-variables - and save as json", () => {
-    // p0.prefix = "info_page_prefix_";
-    const p1 = builderSchema.addPage("question");
-    const p2 = builderSchema.addPage("question");
-    p1.prefix = PagePrefix.fromStringOrThrow("p1_prefix");
-    p2.prefix = PagePrefix.fromStringOrThrow("p2_prefix");
-    p1.defaultQuestion.addOption("Ja", 1, 0);
-    p1.defaultQuestion.addOption("Nei", 0, 0);
-    p2.defaultQuestion.addOption("Ja", 1, 0);
-    p2.defaultQuestion.addOption("Nei", 0);
 
-    const ruleInput = builderSchema.getRuleInput();
-    const ss1: SumScoreVariableDto = {
-      label: "ss1",
-      varId: "ss1_var_id",
-      initialValue: 0,
-      kind: "numeric-variable",
-      origin: "sum-score",
-      basedOn: [],
-    };
+  test("Can add, update and delete sum-variable", () => {
+    const ssv = (name: string) =>
+      s1.sumScoreVariableCreate({ name, useAvg: true, description: "description for " + name });
 
-    builderSchema.addSumScoreVariable(ss1);
+    const v1 = ssv("v1");
+    const v2 = ssv("v2");
+    const v3 = ssv("v3");
+    expect(s1.sumScoreVariables.length).toBe(3);
+    s1.sumScoreVariableUpdate(v1.id, { name: "updatedName" });
+    expect(s1.sumScoreVariables[0].name).toBe("updatedName");
+    const success = s1.sumScoreVariableDelete(v2.id);
+    expect(success).toBeTruthy();
+    expect(s1.sumScoreVariables.length).toBe(2);
+    const failure = s1.sumScoreVariableDelete(SumScoreVariableID.create());
+    expect(failure).toBeFalsy();
+    // s1.sumScoreVariableDelete(v2.id);
+  });
 
-    expect(ruleInput.questionVars.length).toBe(2);
-    expect(ruleInput.jumpToPageActions.length).toBe(3);
+  test("When a sum-score updates, then the pages update as well", () => {
+    const p1 = s1.addPage("question");
+    const v1 = s1.sumScoreVariableCreate({
+      name: "v1",
+      useAvg: true,
+      description: "description for v1",
+    });
+    expect(s1.sumScoreVariables.length).toBe(1);
+    expect(s1.pages.length).toBe(1);
+    const success = s1.sumScoreVariableAddToPage(v1, p1, 1);
+    expect(success).toBe(true);
+    expect(p1.includedInSumScores.length).toBe(1);
+    const updateSuccess = s1.sumScoreVariableUpdate(v1.id, {
+      name: "updated_name",
+      description: "updated_description",
+      useAvg: !v1.useAvg,
+    });
+    expect(updateSuccess).toBe(true);
+    expect(p1.includedInSumScores[0].name).toBe("updated_name");
+    expect(p1.includedInSumScores[0].description).toBe("updated_description");
+  });
 
-    // TODO add TAGS!!
-    // expect(ruleInput.excludeByTagActions.length).toBe(0);
-    // expect(ruleInput.excludeByPageIdActions.length).toBe(3);
-    // const allPageIds = new Set(ruleInput.jumpToPageActions.map((a) => a.pageId));
-    // expect(allPageIds.has(p0.id)).toBe(true);
-    // expect(allPageIds.has(p1.id)).toBe(true);
-    // expect(allPageIds.has(p2.id)).toBe(true);
-    // ruleInput.questionVars.forEach((v) => {
-    //   expect(allPageIds.has(v.varId)).toBe(true);
-    // });
-    // ruleInput.jumpToPageActions.forEach((v) => {
-    //   expect(allPageIds.has(v.pageId)).toBe(true);
-    // });
+  test("When a sum-score is deleted, then pages will delete from included in sum-scores.", () => {
+    const p1 = s1.addPage("question");
+    const v1 = s1.sumScoreVariableCreate({
+      name: "v1",
+      useAvg: true,
+      description: "description for v1",
+    });
+    const success = s1.sumScoreVariableAddToPage(v1, p1, 1);
+    expect(success).toBe(true);
+    s1.sumScoreVariableDelete(v1.id);
+    expect(p1.includedInSumScores.length).toBe(0);
   });
 });

package/src/Builder-schema.ts

@@ -1,28 +1,31 @@
-import type { BuilderPageDto, BuilderPageType } from "./Builder-page";
-import { BuilderPage } from "./Builder-page";
+import type { BuilderPageDto, BuilderPageType } from "./page/Builder-page";
+import { BuilderPage } from "./page/Builder-page";
 import type {
   BuilderRuleDto,
-  CustomVariable,
   ExcludeByPageAction,
   ExcludeByTagAction,
   JumpToPageAction,
+  RuleCustomVariable,
 } from "./rulebuilder";
 import { BuilderRule, RuleInput } from "./rulebuilder";
-import type { QuestionVariable } from "./rulebuilder/RuleVariable";
-import type { BuilderTagDto } from "./BuilderTag";
-import { BuilderTag, TagCollection } from "./BuilderTag";
+import type { RuleQuestionVariable } from "./rulebuilder/RuleVariable";
+import type { BuilderTagDto } from "./tag/BuilderTag";
+import { BuilderTag } from "./tag/BuilderTag";
 import { DefaultThemeCompiler } from "./theme/default-theme-compiler";
 import { ImageFile } from "./media-files";
 import { DUtil } from "@media-quest/engine";
 import { PagePrefix } from "./primitives/page-prefix";
 import { SchemaPrefix, SchemaPrefixValue } from "./primitives/schema-prefix";
-import { CodeBook } from "./codebook";
-import { PredefinedVariable } from "./variable/b-variable";
+import { CodeBook } from "./code-book/codebook";
+import { CodebookPredefinedVariable } from "./code-book/codebook-variable";
 import { SchemaConfig } from "./schema-config";
 import { CompilerOption, CompilerOutput } from "./builder-compiler";
 
-import { SumScoreVariableDto } from "./variable/sum-score-variable";
-import { SchemaID } from "./primitives/ID";
+import { SumScoreVariable, SumScoreVariableDto } from "./sum-score/sum-score-variable";
+import { PageID, SchemaID, SumScoreVariableID } from "./primitives/ID";
+import { SumScoreVariableCollection } from "./sum-score/sum-score-variable-collection";
+import { TagCollection } from "./tag/Tag-Collection";
+import { BuilderPageCollection } from "./page/Builder-page-collection";
 
 const U = DUtil;
 
@@ -32,34 +35,34 @@ export interface BuilderSchemaDto {
   readonly mainImage: ImageFile | false;
   readonly backgroundColor: string;
   readonly name: string;
-  readonly pages: BuilderPageDto[];
+  readonly pages: ReadonlyArray<BuilderPageDto>;
   readonly baseHeight: number;
   readonly baseWidth: number;
-  readonly predefinedVariables?: Array<PredefinedVariable>;
+  readonly predefinedVariables?: Array<CodebookPredefinedVariable>;
   readonly sumScoreVariables?: ReadonlyArray<SumScoreVariableDto>;
   readonly rules: ReadonlyArray<BuilderRuleDto>;
   readonly tags: ReadonlyArray<BuilderTagDto>;
 }
 
-class SumScoreVariableCollection {
-  private _all: Array<SumScoreVariableDto> = [];
-}
-
 export class BuilderSchema {
   readonly prefix: SchemaPrefix;
   baseHeight = 1300;
   baseWidth = 1024;
   backgroundColor = "#000000";
-  pages: BuilderPage[] = [];
+  private readonly _pageCollection: BuilderPageCollection;
   mainImage: ImageFile | false = false;
-  predefinedVariables: PredefinedVariable[] = [];
+  predefinedVariables: CodebookPredefinedVariable[] = [];
   private _rules: BuilderRule[] = [];
-  private _sumVariables: SumScoreVariableDto[] = [];
+  private readonly _sumScoreCollection;
   get rules(): ReadonlyArray<BuilderRule> {
     return [...this._rules];
   }
-  get sumScoreVariables(): ReadonlyArray<SumScoreVariableDto> {
-    return [...this._sumVariables];
+  get pages(): ReadonlyArray<BuilderPage> {
+    return [...this._pageCollection];
+  }
+
+  get sumScoreVariables(): ReadonlyArray<SumScoreVariable> {
+    return [...this._sumScoreCollection];
   }
 
   // get prefix(): SchemaPrefixValue {
@@ -78,29 +81,31 @@ export class BuilderSchema {
   public static fromJson(dto: BuilderSchemaDto): BuilderSchema {
     const schemaPrefix = SchemaPrefix.castOrCreateRandom(dto.prefix);
     const schema = new BuilderSchema(dto.id, dto.name, schemaPrefix);
-    const pages = dto.pages.map(BuilderPage.fromJson);
+    const sumScoreVariables = dto.sumScoreVariables ? [...dto.sumScoreVariables] : [];
+    const pagesDto = Array.isArray(dto.pages) ? dto.pages : [];
 
+    // Init collections.
     schema._tagCollection.init(dto.tags);
+    schema._sumScoreCollection.init(sumScoreVariables);
+
     schema.backgroundColor = dto.backgroundColor;
     schema.baseHeight = dto.baseHeight;
     schema.baseWidth = dto.baseWidth;
-    schema.pages = pages;
+    schema._pageCollection._init(pagesDto);
     schema.predefinedVariables = dto.predefinedVariables ?? [];
     schema.backgroundColor = dto.backgroundColor;
     schema.mainImage = dto.mainImage ?? false;
     const rulesDto = dto.rules ?? [];
     const ruleInput = schema.getRuleInput();
-
-    schema._sumVariables = Array.isArray(dto.sumScoreVariables) ? [...dto.sumScoreVariables] : [];
     schema._rules = rulesDto.map((r) => BuilderRule.fromDto(r, ruleInput));
     return schema;
   }
 
   toJson(): BuilderSchemaDto {
-    const pages = this.pages.map((p) => p.toJson());
+    const pages = this._pageCollection.toJson();
     const tags = this._tagCollection.toJson();
     const rules = this._rules.map((rule) => rule.toJson());
-
+    const sumScoreVariables = this._sumScoreCollection.toJson();
     const dto: BuilderSchemaDto = {
       backgroundColor: this.backgroundColor,
       baseHeight: this.baseHeight,
@@ -111,7 +116,7 @@ export class BuilderSchema {
       rules,
       tags,
       predefinedVariables: this.predefinedVariables,
-      sumScoreVariables: [...this.sumScoreVariables],
+      sumScoreVariables,
       mainImage: this.mainImage,
       prefix: this.prefix.value,
     };
@@ -123,22 +128,31 @@ export class BuilderSchema {
     prefix: SchemaPrefix,
   ) {
     this.prefix = prefix;
+    this._sumScoreCollection = SumScoreVariableCollection.create([]);
+    this._pageCollection = BuilderPageCollection.create([]);
+    // this
   }
 
   addPage(type: BuilderPageType, atIndex = -1): BuilderPage {
-    const pagePrefix = PagePrefix.create();
-    const newPage = BuilderPage.create(type, pagePrefix.value);
-    if (atIndex >= 0 && atIndex < this.pages.length) {
-      this.pages.splice(atIndex, 0, newPage);
-    } else {
-      this.pages.push(newPage);
-    }
-    return newPage;
+    return this._pageCollection.add(type, atIndex);
   }
 
-  addSumScoreVariable(variable: SumScoreVariableDto) {
+  sumScoreVariableCreate(options: { name: string; description: string; useAvg: boolean }) {
     // TODO VALIDATE.
-    this._sumVariables.push({ ...variable });
+    // this._sumVariables.push({ ...variable });
+    const variable = this._sumScoreCollection.addNew(options);
+
+    return variable;
+  }
+  sumScoreVariableAddToPage(sumScoreVariable: SumScoreVariable, page: BuilderPage, weight: number) {
+    // this._pages.
+    return this._pageCollection.addSumScoreVariable(sumScoreVariable, page.id, weight);
+  }
+
+  sumScoreVariableUpdate(id: SumScoreVariableID, data: Partial<SumScoreVariableDto>) {
+    const didUpdate = this._sumScoreCollection._updateOne(id, data);
+    this._pageCollection.updateAllData({ sumScoreVariables: this._sumScoreCollection.asArray() });
+    return didUpdate;
   }
 
   insertPage(page: BuilderPage, atIndex: number): boolean {
@@ -146,16 +160,7 @@ export class BuilderSchema {
   }
 
   private insertPageAtIndex(page: BuilderPage, atIndex: number) {
-    const isValidIndex = U.isInRange(0, this.pages.length - 1);
-    if (!isValidIndex(atIndex)) {
-      return false;
-    }
-    const exists = !!this.pages.find((p) => p.id === page.id);
-    if (exists) {
-      return false;
-    }
-    this.pages.splice(atIndex, 0, page);
-    return true;
+    return this._pageCollection.insertPage(page, atIndex);
   }
 
   addRule() {
@@ -181,25 +186,11 @@ export class BuilderSchema {
   }
 
   movePage(page: BuilderPage, toIndex: number): boolean {
-    const index = this.pages.indexOf(page);
-    if (index < 0) {
-      return false;
-    }
-    const isValidIndex = U.isInRange(0, this.pages.length - 1);
-    if (!isValidIndex(toIndex)) {
-      return false;
-    }
-    // console.log('Moving from :' + index + ' to: ' + toIndex);
-    this.pages.splice(index, 1);
-    this.pages.splice(toIndex, 0, page);
-    return true;
+    return this._pageCollection.movePage(page, toIndex);
   }
 
   deletePage(page: BuilderPage): boolean {
-    const filtered = this.pages.filter((p) => p !== page);
-    const didDelete = filtered.length === this.pages.length - 1;
-    this.pages = filtered;
-    return didDelete;
+    return this._pageCollection.deleteById(page.id);
   }
 
   reevaluateRules() {
@@ -210,12 +201,12 @@ export class BuilderSchema {
   }
 
   getRuleInput(): RuleInput {
-    const qVars: QuestionVariable[] = [];
-    const cVars: CustomVariable[] = [];
+    const qVars: RuleQuestionVariable[] = [];
+    const cVars: RuleCustomVariable[] = [];
     const pageIdActions: ExcludeByPageAction[] = [];
     const tagActions: ExcludeByTagAction[] = this.tags.map((t) => {
       const tag = t.tagText;
-      const pageCount = this.pages.reduce((count, curr) => {
+      const pageCount = this._pageCollection.pages.reduce((count, curr) => {
         return curr.tags.includes(tag) ? count + 1 : count;
       }, 0);
       const excludeByTagDto: ExcludeByTagAction = {
@@ -226,8 +217,10 @@ export class BuilderSchema {
       };
       return excludeByTagDto;
     });
+
     const jumpActions: JumpToPageAction[] = [];
-    this.pages.forEach((page, index) => {
+
+    this._pageCollection.pages.forEach((page, index) => {
       const pageVariables = page.getQuestionVariables(this.prefix, index);
       qVars.push(...pageVariables);
       const mainText = page.mainText.text;
@@ -269,7 +262,7 @@ export class BuilderSchema {
     const builderSchema = BuilderSchema.fromJson(this.toJson());
 
     // Overriding the
-    builderSchema.pages.forEach((p) => {
+    builderSchema._pageCollection.pages.forEach((p) => {
       if (options.blockAutoplayQuestion) {
         p.mainText.autoplay = false;
       }
@@ -289,4 +282,12 @@ export class BuilderSchema {
     const output: CompilerOutput = { codebook, schema, schemaConfig };
     return output;
   }
+
+  sumScoreVariableDelete(id: SumScoreVariableID) {
+    const didDelete = this._sumScoreCollection._deleteVariable(id);
+    const sumScoreVariables = [...this._sumScoreCollection];
+    this._pageCollection.updateAllData({ sumScoreVariables });
+    this._pageCollection.sumScoreVariableDelete(id);
+    return didDelete;
+  }
 }