@media-quest/builder 0.0.6 → 0.0.8

package/src/Builder-schema.ts

@@ -10,12 +10,22 @@ import type { BuilderRuleDto } from "./rulebuilder";
 import { BuilderRule } from "./rulebuilder";
 import { DefaultThemeCompiler } from "./theme/default-theme-compiler";
 import { ImageFile } from "./media-files";
-import { SchemaDto, DUtil } from "@media-quest/engine";
+import { SchemaDto, DUtil, PageID, SchemaID } from "@media-quest/engine";
+import { PagePrefix, SchemaPrefix, SchemaPrefixValue } from "./prefix";
 const U = DUtil;
+
+class PrimitiveWrapper<T> {
+  constructor(private readonly _value: T) {}
+
+  get value(): T {
+    return this._value;
+  }
+}
+
 // type SchemaHash = string & { __MD5__HASH: true };
 export interface BuilderSchemaDto {
-  readonly id: string;
-  readonly prefix: string;
+  readonly id: SchemaID;
+  readonly prefix: SchemaPrefixValue;
   readonly mainImage: ImageFile | false;
   readonly backgroundColor: string;
   readonly name: string;
@@ -33,6 +43,7 @@ export interface SchemaBuildOutput {
 }
 
 export class BuilderSchema {
+  private readonly _prefix: SchemaPrefix;
   baseHeight = 1300;
   baseWidth = 1024;
   backgroundColor = "#000000";
@@ -43,16 +54,22 @@ export class BuilderSchema {
     return [...this._rules];
   }
 
+  get prefix(): SchemaPrefixValue {
+    return this._prefix.value;
+  }
+
   private readonly _tagCollection: TagCollection = TagCollection.create();
   get tags(): ReadonlyArray<BuilderTag> {
     return [...this._tagCollection];
   }
-  public static create(id: string, name: string, prefix: string) {
-    return new BuilderSchema(id, name, prefix);
+  public static create(id: SchemaID, name: string, prefix: SchemaPrefixValue) {
+    const schemaPrefix = SchemaPrefix.castOrCreateRandom(prefix);
+    return new BuilderSchema(id, name, schemaPrefix);
   }
 
   public static fromJson(dto: BuilderSchemaDto): BuilderSchema {
-    const schema = new BuilderSchema(dto.id, dto.name, dto.prefix);
+    const schemaPrefix = SchemaPrefix.castOrCreateRandom(dto.prefix);
+    const schema = new BuilderSchema(dto.id, dto.name, schemaPrefix);
     const pages = dto.pages.map(BuilderPage.fromJson);
     schema._tagCollection.init(dto.tags);
     schema.backgroundColor = dto.backgroundColor;
@@ -87,13 +104,16 @@ export class BuilderSchema {
     return dto;
   }
   private constructor(
-    public readonly id: string,
+    public readonly id: SchemaID,
     public name: string,
-    public prefix: string,
-  ) {}
+    _prefix: SchemaPrefix,
+  ) {
+    this._prefix = _prefix;
+  }
 
   addPage(type: BuilderPageType, atIndex = -1): BuilderPage {
-    const newPage = BuilderPage.create(type, "");
+    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 {
@@ -188,9 +208,9 @@ export class BuilderSchema {
       return excludeByTagDto;
     });
     const jumpActions: JumpToPageAction[] = [];
-    const prefix = "";
+    const prefix = this.prefix;
     this.pages.forEach((page, index) => {
-      const pageVariables = page.getQuestionVariables(prefix, index);
+      const pageVariables = page.getQuestionVariables(this._prefix, index);
       qVars.push(...pageVariables);
       const mainText = page.mainText.text;
       const jumpAction: JumpToPageAction = {
@@ -221,25 +241,6 @@ export class BuilderSchema {
     this._tagCollection.add(builderTag);
   }
 
-  // getHash(): SchemaHash {
-  //     const md5 = MD5(this.toJson());
-  //     return
-  // }
-
-  // hasChanged(hash: SchemaHash): boolean {
-  //     return hash !== this.getHash();
-  // }
-
-  private getQuestionVariables(withModulePrefix = false): ReadonlyArray<QuestionVariable> {
-    const prefix = withModulePrefix ? this.prefix : "";
-    const all = this.pages
-      .map((page, index) => {
-        return page.getQuestionVariables(prefix, index);
-      })
-      .flat(1);
-    return all;
-  }
-
   compile(): SchemaBuildOutput {
     const moduleDto = this.toJson();
     const imp = new DefaultThemeCompiler();

package/src/BuilderObject.ts

@@ -21,14 +21,9 @@ type BuilderObjectType =
 export namespace BuilderObjectId {
   export type QuestionOptionID = string & { __OPTION__ID__: true };
   export type QuestionID = string & { __QUESTION__ID__: true };
-  export type VideoFileID = string & { __VIDEO__ID__: true };
-  export type AudioFileID = string & { __AUDIO__ID__: true };
-  export type ImageID = string & { __IMAGE__ID__: true };
   export type TextID = string & { __TEXT__ID__: true };
   export type MainTextID = string & { __MAIN__TEXT__ID__: true };
-  export type PageID = string & { __PAGE__ID__: true };
   export type TagId = string & { __TAG__ID__: true };
-
   export const createTagId = (): TagId => {
     return createId("builder-tag") as TagId;
   };
@@ -46,9 +41,6 @@ export namespace BuilderObjectId {
   export const questionId = (): QuestionID => {
     return createId("builder-question") as QuestionID;
   };
-  export const pageId = (): PageID => {
-    return createId("builder-page") as PageID;
-  };
 
   const createId = (type: BuilderObjectType): string => {
     const id = U.randomString(24);

package/src/prefix.spec.ts

@@ -0,0 +1,5 @@
+describe("Prefix", () => {
+  it("should create an instance", () => {
+    expect(true).toBeTruthy();
+  });
+});

package/src/prefix.ts

@@ -0,0 +1,107 @@
+export type SchemaPrefixValue = string & { __SCHEMA_PREFIX__: true };
+export type PagePrefixValue = string & { __PAGE_PREFIX__: true };
+// export type QuestionPrefixValue = string & { __QUESTION_PREFIX__: true };
+export type VarID = `${SchemaPrefixValue}_${PagePrefixValue}`;
+export const VarID = {
+  create: (schemaPrefix: SchemaPrefixValue, pagePrefix: PagePrefixValue): VarID => {
+    const varId = schemaPrefix + "_" + pagePrefix;
+    return varId as VarID;
+  },
+};
+const createRandomPrefix = <const P extends string>(length: number): P => {
+  const letters = "abcdefghijklmnopqrstuvyz";
+  const all = letters + letters.toUpperCase();
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    const char = all.charAt(Math.floor(Math.random() * all.length));
+    result += char;
+  }
+  return result as P;
+};
+export class SchemaPrefix {
+  public static readonly MIN_LENGTH = 1;
+  private static randomLen = 5;
+  public static readonly MAX_LENGTH = 16;
+  public static fromValue = (value: SchemaPrefixValue): SchemaPrefix => {
+    return new SchemaPrefix(value);
+  };
+
+  public static fromValueOrThrow = (value: string): SchemaPrefix => {
+    if (!SchemaPrefix.isValid(value)) throw new Error("Invalid prefix");
+    return new SchemaPrefix(value);
+  };
+  public static fromString = (value: string): SchemaPrefix | false => {
+    if (!SchemaPrefix.isValid(value)) return false;
+    return new SchemaPrefix(value);
+  };
+  public static castOrCreateRandom = (value: string): SchemaPrefix => {
+    const v = SchemaPrefix.isValid(value) ? value : createRandomPrefix<SchemaPrefixValue>(SchemaPrefix.randomLen);
+    return new SchemaPrefix(v);
+  };
+
+  public static isValid = (prefix: string | 999): prefix is SchemaPrefixValue => {
+    if (typeof prefix !== "string") return false;
+    if (prefix.length < SchemaPrefix.MIN_LENGTH) return false;
+    if (prefix.length > SchemaPrefix.MAX_LENGTH) return false;
+    return true;
+  };
+
+  get value(): SchemaPrefixValue {
+    return this._value;
+  }
+
+  set value(value: string) {
+    if (!SchemaPrefix.isValid(value)) {
+      console.log("INVALID PREFIX", value);
+    } else {
+      this._value = value;
+    }
+  }
+  private constructor(private _value: SchemaPrefixValue) {}
+}
+export class PagePrefix {
+  public static readonly MIN_LENGTH = 1;
+  private static randomLen = 5;
+  public static readonly MAX_LENGTH = 16;
+  public static fromValue = (value: PagePrefixValue): PagePrefix => {
+    return new PagePrefix(value);
+  };
+
+  public static create = (): PagePrefix => {
+    const v = createRandomPrefix<PagePrefixValue>(PagePrefix.randomLen);
+    return new PagePrefix(v);
+  };
+  public static fromString = (value: string): PagePrefix | false => {
+    if (!PagePrefix.isValid(value)) return false;
+    return new PagePrefix(value);
+  };
+
+  public static fromStringOrThrow = (value: string): PagePrefixValue => {
+    if (!PagePrefix.isValid(value)) throw new Error("Invalid prefix");
+    return value;
+  };
+  public static castOrCreateRandom = (value: string): PagePrefix => {
+    const v = PagePrefix.isValid(value) ? value : createRandomPrefix<PagePrefixValue>(PagePrefix.randomLen);
+    return new PagePrefix(v);
+  };
+
+  public static isValid = (prefix: string | 999): prefix is PagePrefixValue => {
+    if (typeof prefix !== "string") return false;
+    if (prefix.length < SchemaPrefix.MIN_LENGTH) return false;
+    if (prefix.length > SchemaPrefix.MAX_LENGTH) return false;
+    return true;
+  };
+
+  get value(): PagePrefixValue {
+    return this._value;
+  }
+
+  set value(value: string) {
+    if (!PagePrefix.isValid(value)) {
+      console.log("INVALID PREFIX", value);
+    } else {
+      this._value = value;
+    }
+  }
+  private constructor(private _value: PagePrefixValue) {}
+}

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

@@ -3,38 +3,50 @@ import { RuleBuilderTestUtils as U } from "./RuleBuilder-test-utils";
 import { RuleInput } from "./RuleInput";
 import type { BuilderConditionGroupDto } from "./condition/Builder-condition-group";
 import { BuilderConditionDto } from "./condition/Builder-condition";
-import { Condition } from "@media-quest/engine";
+import { Condition, PageID } from "@media-quest/engine";
+import { PagePrefix, VarID, SchemaPrefix } from "../prefix";
 
-const { createBuilderVariables_A_H } = U;
-let questionVariables = createBuilderVariables_A_H();
-const createDto = (): {
+const { createPagesAndVars_A_H } = U;
+
+const sxx = SchemaPrefix.fromValueOrThrow("sxx");
+let varsAndPages_A_H = createPagesAndVars_A_H(sxx);
+
+const varId = (sxx: SchemaPrefix, pxx: string): VarID => {
+  const pagePrefix = PagePrefix.fromStringOrThrow(pxx);
+  return VarID.create(sxx.value, pagePrefix);
+};
+const createDto = (
+  modulePrefix: SchemaPrefix,
+): {
   ruleInput: RuleInput;
   builderRuleDto: BuilderRuleDto;
 } => {
-  const v1 = U.createRuleVariable("v1", 1);
-  const v2 = U.createRuleVariable("v2", 2);
-  const v3 = U.createRuleVariable("v3", 3);
-  const v4 = U.createRuleVariable("v4", 4);
-  const vg1 = U.createRuleVariable("vg1", 5);
-  const vg2 = U.createRuleVariable("vg2", 6);
-  const vg3 = U.createRuleVariable("vg3", 7);
-  const vg4 = U.createRuleVariable("vg4", 8);
+  const v1 = U.createRuleVariable(varId(modulePrefix, "v1"), 1);
+  const v2 = U.createRuleVariable(varId(modulePrefix, "v2"), 2);
+  const v3 = U.createRuleVariable(varId(modulePrefix, "v3"), 3);
+  const v4 = U.createRuleVariable(varId(modulePrefix, "v4"), 4);
+  const vg1 = U.createRuleVariable(varId(modulePrefix, "vg1"), 5);
+  const vg2 = U.createRuleVariable(varId(modulePrefix, "vg2"), 6);
+  const vg3 = U.createRuleVariable(varId(modulePrefix, "vg3"), 7);
+  const vg4 = U.createRuleVariable(varId(modulePrefix, "vg4"), 8);
   const variableList = [v1, v2, v3, v4, vg1, vg2, vg3, vg4];
   const tagAction1 = U.excludeByTagAction("tag1");
   const tagAction2 = U.excludeByTagAction("tag2");
   const tagAction3 = U.excludeByTagAction("tag3");
   const tagAction4 = U.excludeByTagAction("tag4");
-  const pageAction1 = U.excludeByPageIdAction(v1.varId, v1.pageNumber);
-  const pageAction2 = U.excludeByPageIdAction(v2.varId, v2.pageNumber);
-  const pageAction3 = U.excludeByPageIdAction(v3.varId, v3.pageNumber);
-  const pageAction4 = U.excludeByPageIdAction(v4.varId, v4.pageNumber);
-  const jumpToPageAction1 = U.jumpToPageAction(v1.varId, v1.pageNumber);
-  const jumpToPageAction2 = U.jumpToPageAction(v2.varId, v2.pageNumber);
-  const jumpToPageAction3 = U.jumpToPageAction(v3.varId, v3.pageNumber);
-  const jumpToPageAction4 = U.jumpToPageAction(v4.varId, v1.pageNumber);
-
-  // const pageAction =
-  // const excludeByTagList = [];
+  const pageId1 = PageID.create();
+  const pageId2 = PageID.create();
+  const pageId3 = PageID.create();
+  const pageId4 = PageID.create();
+  const pageAction1 = U.excludeByPageIdAction(pageId1, v1.pageNumber);
+  const pageAction2 = U.excludeByPageIdAction(pageId2, v2.pageNumber);
+  const pageAction3 = U.excludeByPageIdAction(pageId3, v3.pageNumber);
+  const pageAction4 = U.excludeByPageIdAction(pageId4, v4.pageNumber);
+  const jumpToPageAction1 = U.jumpToPageAction(pageId1, v1.pageNumber);
+  const jumpToPageAction2 = U.jumpToPageAction(pageId2, v2.pageNumber);
+  const jumpToPageAction3 = U.jumpToPageAction(pageId3, v3.pageNumber);
+  const jumpToPageAction4 = U.jumpToPageAction(pageId4, v1.pageNumber);
+
   const ruleInput = new RuleInput(
     variableList,
     [],
@@ -60,7 +72,7 @@ const createDto = (): {
   const builderRuleDto1: BuilderRuleDto = {
     type: "any",
     jumpToPage: false,
-    excludePages: [v1.varId, v3.varId],
+    excludePages: [pageId1, pageId3],
     excludeTags: [tagAction1.tag, tagAction2.tag],
     name: "kitchen-sink",
     conditions: [c1, c2, group3, c3, c4],
@@ -78,9 +90,17 @@ let dto: BuilderRuleDto = {
 };
 
 const excludeByTagActionList = U.excludeByTagActionList();
-const pageActions = questionVariables.map((q) => U.excludeByPageIdAction(q.varId, q.pageNumber));
-
-let ruleInput = new RuleInput(questionVariables, [], [...pageActions], excludeByTagActionList, []);
+// const pageActions = questionVariables.list.map((q) => U.excludeByPageIdAction(q.pageId, q.pageNumber));
+// const pageActions = questionVariables.map((q) => U.excludeByPageIdAction(, q.pageNumber));
+// const pageActions = varsAndPages_A_H.pageIds((p) => U.excludeByPageIdAction(p.pageId, p.pageNumber));
+let ruleInput = new RuleInput(
+  varsAndPages_A_H.list,
+  [],
+  [...varsAndPages_A_H.pageIdList.map((id, index) => U.excludeByPageIdAction(id, index))],
+  excludeByTagActionList,
+  [],
+);
+// let ruleInput = new RuleInput(questionVariables.list, [], [], excludeByTagActionList, []);
 
 let rule: BuilderRule = BuilderRule.fromDto(dto, ruleInput);
 
@@ -187,7 +207,8 @@ describe("Builder Rule", () => {
   });
 
   test("fromJSON -> toJSON -> are equal.", () => {
-    const data = createDto();
+    const schemaPrefix = SchemaPrefix.fromValueOrThrow("ax");
+    const data = createDto(schemaPrefix);
 
     const localRule = BuilderRule.fromDto(data.builderRuleDto, data.ruleInput);
 
@@ -212,8 +233,11 @@ describe("Builder Rule", () => {
     expect(ruleInput.excludeByTagActions.length).toStrictEqual(10);
   });
 
+  // TODO FIX THIS TEST.
   test("toEngineRuleWorks: ", () => {
-    const input = createDto().ruleInput;
+    const schemaPrefix = SchemaPrefix.fromValueOrThrow("ax");
+    const dto = createDto(schemaPrefix);
+    const input = dto.ruleInput;
     const v1 = input.questionVars[0];
     const v2 = input.questionVars[1];
     const tag1 = input.excludeByTagActions[0];
@@ -247,26 +271,30 @@ describe("Builder Rule", () => {
       type: "all",
     };
 
-    const dtoWithOneCondition: BuilderRuleDto = {
+    expect(c1.variableId).toBe(schemaPrefix.value + "_v1");
+
+    const dtoWithThreeCondition: BuilderRuleDto = {
       type: "all",
       name: "dto-with-one-condition",
       excludePages: [pageAction1.pageId],
       excludeTags: [tag1.tag],
-      jumpToPage: v1.varId,
+      jumpToPage: pageAction1.pageId,
       conditions: [c1, conditionGroupALL, conditionGroupANY],
     };
 
     const actionCount =
-      dtoWithOneCondition.excludeTags.length +
-      dtoWithOneCondition.excludePages.length +
-      (dtoWithOneCondition.jumpToPage ? 1 : 0);
+      dtoWithThreeCondition.excludeTags.length +
+      dtoWithThreeCondition.excludePages.length +
+      (dtoWithThreeCondition.jumpToPage ? 1 : 0);
+
+    const rule = BuilderRule.fromDto(dtoWithThreeCondition, input);
 
-    const rule = BuilderRule.fromDto(dtoWithOneCondition, input);
     const engineRule = rule.toEngineRule();
 
     // console.log(rule);
     expect(engineRule.all.length).toBe(3);
     expect(engineRule.some.length).toBe(0);
+    // expect(engineRule.all[0]).toBe(0);
 
     const simple1 = engineRule.all.find(
       (c) => c.kind === "numeric-condition" && c.referenceId === c1.variableId,
@@ -286,6 +314,7 @@ describe("Builder Rule", () => {
     expect(complexChild1.value).toBe(c2.value);
     expect(complexChild1.referenceLabel).toBe(v2.label);
     expect(complexChild1.operator === "eq").toBeTruthy();
+    // expect(engineRule.onSuccess).toBe(1);
     expect(engineRule.onSuccess.length).toBe(actionCount);
   });
 });

package/src/rulebuilder/Builder-rule.ts

@@ -132,18 +132,18 @@ export class BuilderRule extends BuilderObject<"builder-rule", BuilderRuleDto> {
     };
     return dto;
   }
-  toEngineRule(modulePrefix: string): PageQueRules {
+  toEngineRule(): PageQueRules {
     const conditions: Condition[] = [];
     this._conditions.forEach((c) => {
       if (c) {
         if (c instanceof BuilderCondition) {
-          const simpleCondition = c.toEngineCondition(modulePrefix);
+          const simpleCondition = c.toEngineCondition();
           if (simpleCondition) {
             conditions.push(simpleCondition);
           }
         }
         if (c instanceof BuilderConditionGroup) {
-          const complexCondition = c.toEngineConditionComplex(modulePrefix);
+          const complexCondition = c.toEngineConditionComplex();
           if (complexCondition) conditions.push(complexCondition);
         }
       }

package/src/rulebuilder/RuleAction.ts

@@ -1,19 +1,21 @@
+import { PageID } from "@media-quest/engine";
+
 export interface ExcludeByPageAction {
-  readonly kind: 'exclude-by-pageId';
-  readonly pageId: string;
+  readonly kind: "exclude-by-pageId";
+  readonly pageId: PageID;
   readonly mainText: string;
   readonly pageNumber: number;
 }
 
 export interface JumpToPageAction {
-  readonly kind: 'jump-to-page';
-  readonly pageId: string;
+  readonly kind: "jump-to-page";
+  readonly pageId: PageID;
   readonly mainText: string;
   readonly pageNumber: number;
 }
 
 export interface ExcludeByTagAction {
-  readonly kind: 'exclude-by-tag';
+  readonly kind: "exclude-by-tag";
   readonly tag: string;
   readonly description: string;
   readonly pageCount: number;

package/src/rulebuilder/RuleBuilder-test-utils.ts

@@ -6,7 +6,10 @@ import type { BuilderConditionDto } from "./condition/Builder-condition";
 import type { BuilderOperator } from "./condition/Builder-operator";
 import type { ExcludeByPageAction, ExcludeByTagAction, JumpToPageAction } from "./RuleAction";
 import { ExcludeByPageIdSelectItem, ExcludeByTagSelectItem } from "./multi-select-item";
+import { PageID } from "@media-quest/engine";
+import { PagePrefix, VarID, SchemaPrefix } from "../prefix";
 
+const id = () => PageID.create();
 export namespace RuleBuilderTestUtils {
   export const createOptions = () => [
     BuilderOption.create(0, "Nei"),
@@ -25,7 +28,7 @@ export namespace RuleBuilderTestUtils {
     return action;
   };
 
-  export const excludeByPageIdAction = (pageId: string, pageNumber: number) => {
+  export const excludeByPageIdAction = (pageId: PageID, pageNumber: number) => {
     const action: ExcludeByPageAction = {
       kind: "exclude-by-pageId",
       mainText: "",
@@ -34,7 +37,7 @@ export namespace RuleBuilderTestUtils {
     };
     return action;
   };
-  export const jumpToPageAction = (pageId: string, pageNumber: number) => {
+  export const jumpToPageAction = (pageId: PageID, pageNumber: number) => {
     const action: JumpToPageAction = {
       kind: "jump-to-page",
       mainText: "TEXT: " + pageId,
@@ -59,22 +62,50 @@ export namespace RuleBuilderTestUtils {
     ] as const;
     return list;
   };
-  export const createRuleVariable = (id: string, pageNumber: number): QuestionVariable =>
-    new QuestionVariable(id, "Har du " + id + "?", createOptions(), pageNumber);
+  export const createRuleVariable = (varId: VarID, pageNumber: number): QuestionVariable =>
+    new QuestionVariable(varId, "Har du " + varId + "?", createOptions(), pageNumber);
 
   /**
    *
    */
-  export const createBuilderVariables_A_H = (): ReadonlyArray<QuestionVariable> => [
-    createRuleVariable("a", 3),
-    createRuleVariable("b", 4),
-    createRuleVariable("c", 5),
-    createRuleVariable("d", 6),
-    createRuleVariable("e", 7),
-    createRuleVariable("f", 8),
-    createRuleVariable("g", 9),
-    createRuleVariable("h", 10),
-  ];
+  export const createPagesAndVars_A_H = (schemaPrefix: SchemaPrefix) => {
+    const varId = (pagePrefix: string) => {
+      const pxx = PagePrefix.fromStringOrThrow(pagePrefix);
+      const qxx = VarID.create(schemaPrefix.value, pxx);
+      return qxx;
+    };
+    const pageAID = PageID.create();
+    const pageBID = PageID.create();
+    const pageCID = PageID.create();
+    const pageDID = PageID.create();
+    const pageEID = PageID.create();
+    const pageFID = PageID.create();
+    const pageGID = PageID.create();
+    const pageHID = PageID.create();
+    const a = createRuleVariable(varId("a"), 3);
+    const b = createRuleVariable(varId("b"), 4);
+    const c = createRuleVariable(varId("c"), 5);
+    const d = createRuleVariable(varId("d"), 6);
+    const e = createRuleVariable(varId("e"), 7);
+    const f = createRuleVariable(varId("f"), 8);
+    const g = createRuleVariable(varId("g"), 9);
+    const h = createRuleVariable(varId("h"), 10);
+    const list = [a, b, c, d, e, f, g, h];
+    const items = { a, b, c, d, e, f, g, h };
+    const pageIds = {
+      a: pageAID,
+      b: pageBID,
+      c: pageCID,
+      d: pageDID,
+      e: pageEID,
+      f: pageFID,
+      g: pageGID,
+
+      h: pageHID,
+    };
+    const pageIdList = [pageAID, pageBID, pageCID, pageDID, pageEID, pageFID, pageGID, pageHID];
+    return { list, items, pageIds, pageIdList };
+  };
 
   export const createConditionDto = (variable: BuilderVariable): BuilderConditionDto => {
     const operator: BuilderOperator = Math.random() > 0 ? "equal" : "notEqual";
@@ -97,12 +128,12 @@ export namespace RuleBuilderTestUtils {
     };
   };
 
-  export const createBuilderRuleDto = (): ReadonlyArray<BuilderRuleDto> => {
-    const variables = createBuilderVariables_A_H();
-    const condition0 = createConditionDto(variables[0]);
-    const condition1 = createConditionDto(variables[1]);
-    const condition3 = createConditionDto(variables[3]);
-    const condition5 = createConditionDto(variables[5]);
+  export const createBuilderRuleDto = (schemaPrefix: SchemaPrefix): ReadonlyArray<BuilderRuleDto> => {
+    const v = createPagesAndVars_A_H(schemaPrefix);
+    const condition0 = createConditionDto(v.items.a);
+    const condition1 = createConditionDto(v.items.b);
+    const condition3 = createConditionDto(v.items.c);
+    const condition5 = createConditionDto(v.items.e);
     const group = createConditionGroupDto([condition0, condition3]);
     // const action1: Exc
     const rule: BuilderRuleDto = {
@@ -119,7 +150,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_a",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -129,7 +160,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_b",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -139,7 +170,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_c",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -149,7 +180,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_d",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -159,7 +190,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_e",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -168,7 +199,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_f",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -178,7 +209,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_g",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -188,7 +219,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_h",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -198,7 +229,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_i",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },
@@ -208,7 +239,7 @@ export namespace RuleBuilderTestUtils {
     ExcludeByPageIdSelectItem.create(
       {
         kind: "exclude-by-pageId",
-        pageId: "page_j",
+        pageId: id(),
         pageNumber: 5,
         mainText: "Har du noen gang vært deprimeri?? ",
       },