@media-quest/builder 0.0.25 → 0.0.27

package/src/page/Builder-page.spec.ts

@@ -0,0 +1,163 @@
+import { BuilderPage } from "./Builder-page";
+import type { BuilderPageDto } from "./Builder-page";
+import type { BuilderQuestionDto } from "../Builder-question";
+import { DUtil } from "@media-quest/engine";
+import { PagePrefix } from "../primitives/page-prefix";
+import { SchemaPrefix } from "../primitives/schema-prefix";
+import { OptionID, PageID, QuestionID } from "../primitives/ID";
+
+const U = DUtil;
+const deleteIdsFromPage = (page: BuilderPageDto) => {
+  const deleteIdsFromQuestion = (q: BuilderQuestionDto) => {
+    U.deleteProp(q, "id");
+    q.options.forEach((o) => {
+      U.deleteProp(o, "id");
+    });
+  };
+  U.deleteProp(page, "id");
+  deleteIdsFromQuestion(page.defaultQuestion);
+  return page;
+};
+
+const pxx = PagePrefix.fromStringOrThrow("pxx");
+const questionPageDto: BuilderPageDto = {
+  _type: "question",
+  autoplaySequence: [],
+  includedInSumScores: [],
+  mainText: {
+    text: "Velkommen til denne undersøkelsen.",
+    audioFile: false,
+    autoplayDelay: 0,
+    autoplay: false,
+  },
+  tags: [],
+
+  nextButton: {
+    id: OptionID.dummy.a,
+    label: "Neste",
+    value: -1,
+  },
+  defaultQuestion: {
+    id: QuestionID.validateOrThrow("default-question-id"),
+    prefix: "q1",
+    text: "sadf",
+    options: [
+      {
+        id: "q1-opt1" as OptionID,
+        value: 0,
+        label: "Nei",
+      },
+      {
+        id: "q1-opt2" as OptionID,
+        value: 1,
+        label: "Ja",
+      },
+      {
+        id: "q1-opt3" as OptionID,
+        value: 9,
+        label: "Vet ikke",
+      },
+    ],
+    _type: "select-one",
+  },
+  // id: "p1" as BuilderObjectId.PageID,
+  id: PageID.create(),
+  prefix: PagePrefix.fromStringOrThrow("pxx"),
+};
+
+const multiQuestionPageDto: BuilderPageDto = {
+  _type: "question",
+  includedInSumScores: [],
+  mainText: {
+    text: "Velkommen til denne undersøkelsen.",
+    audioFile: false,
+    autoplay: false,
+    autoplayDelay: 0,
+  },
+  autoplaySequence: [],
+  defaultQuestion: {
+    id: QuestionID.create(),
+    prefix: "",
+    text: "",
+    options: [],
+    _type: "select-one",
+  },
+  tags: [],
+  nextButton: {
+    id: "next-button-id-3" as OptionID,
+    label: "Neste",
+    value: -1,
+  },
+
+  id: PageID.create(),
+  prefix: PagePrefix.fromStringOrThrow("pxx"),
+};
+
+let page = BuilderPage.create("info-page", PagePrefix.fromStringOrThrow("a"));
+
+beforeEach(() => {
+  page = BuilderPage.create("info-page", PagePrefix.fromStringOrThrow("a"));
+});
+
+describe("Builder Page", () => {
+  test("Can create page, and convert to json, and back", () => {
+    const page1 = BuilderPage.fromJson(questionPageDto);
+    const asJson = page1.toJson();
+    expect(questionPageDto).toStrictEqual(asJson);
+    const page2 = BuilderPage.fromJson(multiQuestionPageDto);
+    const asJson2 = page2.toJson();
+    expect(multiQuestionPageDto).toStrictEqual(asJson2);
+    // expect(page1.prefix).toBe(pageDto.prefix);
+  });
+  test("Can clone a page and everything except id is equal ", () => {
+    const page1 = BuilderPage.create("info-page", PagePrefix.fromStringOrThrow("as"));
+    const clone1 = BuilderPage.fromJson(page1.clone());
+    const page1Json = deleteIdsFromPage(page1.clone());
+    const clone1Json = deleteIdsFromPage(page1.clone());
+    expect(page1Json).toStrictEqual(clone1Json);
+
+    const page2 = BuilderPage.fromJson(questionPageDto);
+    const clone2 = BuilderPage.fromJson(page2.clone());
+    const page2Json = deleteIdsFromPage(page2.toJson());
+    const clone2Json = deleteIdsFromPage(clone2.toJson());
+    expect(page2Json).toStrictEqual(clone2Json);
+
+    const page3 = BuilderPage.fromJson(multiQuestionPageDto);
+    const clone3 = BuilderPage.fromJson(page3.clone());
+    const page3Json = deleteIdsFromPage(page3.toJson());
+    const clone3Json = deleteIdsFromPage(clone3.toJson());
+    expect(page3Json).toStrictEqual(clone3Json);
+  });
+  test("Can clone a page and no id is equal", () => {
+    const page1 = BuilderPage.create("info-page", pxx);
+    const clone1 = BuilderPage.fromJson(page1.clone());
+    expect(page1.id).not.toBe(clone1.id);
+
+    const testDtoIds = (dto: BuilderPageDto) => {
+      const instance = BuilderPage.fromJson(dto);
+      const clone = BuilderPage.fromJson(instance.clone());
+
+      testDtoIds(questionPageDto);
+      testDtoIds(multiQuestionPageDto);
+    };
+  });
+
+  test("Can get all rule-variables.", () => {
+    const prefix = PagePrefix.fromStringOrThrow("as1");
+    const page = BuilderPage.create("question", prefix);
+    page.mainText.text = "Hva heter du?";
+    page.defaultQuestion.addOption("Ja", 1);
+    page.defaultQuestion.addOption("Nei", 0);
+    const shemaPrefix = SchemaPrefix.fromValueOrThrow("ax");
+    const variables = page.getQuestionVariables(shemaPrefix, 1);
+    const first = variables[0];
+    expect(variables.length).toBe(1);
+    expect(first.options.length).toBe(2);
+    expect(first.options[0].value).toBe(1);
+    expect(first.kind === "question-variable").toBe(true);
+    // const newQuestion = BuilderQuestion.create('select-one');
+    // const m1 = page1.moveQuestion(newQuestion, 0);
+    // expect(page1.questions.length).toBe(3);
+    // expect(m1).toBe(false);
+  });
+});

package/src/{Builder-page.ts → page/Builder-page.ts}

@@ -1,21 +1,22 @@
-import type { BuilderQuestionDto, BuilderQuestionType } from "./Builder-question";
-import { BuilderQuestion } from "./Builder-question";
-import { BuilderObject } from "./BuilderObject";
-import type { BuilderOptionDto } from "./Builder-option";
-import { BuilderOption } from "./Builder-option";
-import type { BuilderMainVideoDto } from "./BuilderMainVideoDto";
-import type { BuilderMainImageDto } from "./BuilderMainImageDto";
-import type { BuilderMainTextDto } from "./BuilderMainText";
-import { BuilderMainText } from "./BuilderMainText";
-import { BuilderVariableOption, QuestionVariable } from "./rulebuilder/RuleVariable";
+import type { BuilderQuestionDto, BuilderQuestionType } from "../Builder-question";
+import { BuilderQuestion } from "../Builder-question";
+import { BuilderObject } from "../BuilderObject";
+import type { BuilderOptionDto } from "../Builder-option";
+import { BuilderOption } from "../Builder-option";
+import type { BuilderMainVideoDto } from "../BuilderMainVideoDto";
+import type { BuilderMainImageDto } from "../BuilderMainImageDto";
+import type { BuilderMainTextDto } from "../BuilderMainText";
+import { BuilderMainText } from "../BuilderMainText";
+import { RuleVariableOption, RuleQuestionVariable } from "../rulebuilder";
 import { DUtil } from "@media-quest/engine";
-import { PagePrefix, PagePrefixValue } from "./primitives/page-prefix";
-import { VarID } from "./primitives/varID";
-import { SchemaPrefix } from "./primitives/schema-prefix";
-import { PageID } from "./primitives/ID";
+import { PagePrefix, PagePrefixValue } from "../primitives/page-prefix";
+import { VarID } from "../primitives/varID";
+import { SchemaPrefix } from "../primitives/schema-prefix";
+import { PageID, SumScoreVariableID } from "../primitives/ID";
+import { SumScoreVariable } from "../sum-score/sum-score-variable";
 
 const U = DUtil;
-export type BuilderPageType = "info-page" | "question" | "multi-select" | "form";
+export type BuilderPageType = "info-page" | "question";
 
 export interface BuilderPageDto {
   readonly id: PageID;
@@ -24,11 +25,10 @@ export interface BuilderPageDto {
   mainText: BuilderMainTextDto;
   nextButton: BuilderOptionDto;
   defaultQuestion: BuilderQuestionDto;
-  questions: Array<BuilderQuestionDto>;
   mainMedia?: BuilderMainImageDto | BuilderMainVideoDto;
+  includedInSumScores: Array<{ sumScoreVariableId: SumScoreVariableID; weight: number }>;
   autoplaySequence: Array<string>;
   tags: ReadonlyArray<string>;
-  // sumScoreVariables: Array<BuilderObjectId.SumScoreVariableId>
 }
 
 export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
@@ -36,9 +36,18 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
   readonly id: PageID;
   private _pageType: BuilderPageType;
   private _prefix: PagePrefix;
-  private _questions: Array<BuilderQuestion> = [];
   private readonly _tags: Set<string>;
   private _backgroundColor = "#FFFFFF";
+  private _includedInSumScores: Map<
+    SumScoreVariableID,
+    {
+      sumScoreVariableId: SumScoreVariableID;
+      weight: number;
+      name: string;
+      description: string;
+    }
+  > = new Map();
+
   mainMedia: BuilderMainVideoDto | BuilderMainImageDto | false = false;
   defaultQuestion: BuilderQuestion;
   mainText: BuilderMainText;
@@ -63,7 +72,7 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
       nextButton: nextButtonDto,
       mainText: mainTextDto,
       prefix: _prefix,
-      questions: [],
+      includedInSumScores: [],
       tags: [],
     };
 
@@ -84,74 +93,20 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
     this.mainText = BuilderMainText.fromJson(dto.mainText);
     this.nextButton = BuilderOption.fromJson(dto.nextButton);
     this.defaultQuestion = BuilderQuestion.fromJson(dto.defaultQuestion);
-    this._questions = dto.questions.map((q) => BuilderQuestion.fromJson(q));
     const tagList: string[] = Array.isArray(dto.tags) ? dto.tags : [];
+    const sumScores = Array.isArray(dto.includedInSumScores) ? dto.includedInSumScores : [];
+    sumScores.forEach((item) => {
+      this._includedInSumScores.set(item.sumScoreVariableId, {
+        sumScoreVariableId: item.sumScoreVariableId,
+        weight: item.weight,
+        name: "",
+        description: "",
+      });
+    });
     this._tags = new Set(tagList);
     if (dto.mainMedia) {
       this.mainMedia = dto.mainMedia;
     }
-    this.updateRows();
-  }
-
-  insertQuestion(question: BuilderQuestion, atIndex: number): boolean {
-    const validIndexFn = U.isInRange(0, this._questions.length);
-    if (!validIndexFn(atIndex)) {
-      return false;
-    }
-    const hasQuestion = !!this._questions.find((q) => q.id === question.id);
-    if (hasQuestion) {
-      return false;
-    }
-    this._questions.splice(atIndex, 0, question);
-    return true;
-  }
-
-  addQuestion(type: BuilderQuestionType, atIndex = -1): BuilderQuestion {
-    const question = BuilderQuestion.create(type);
-    if (atIndex < this._questions.length && atIndex >= 0) {
-      this._questions.splice(atIndex, 0, question);
-    } else {
-      this._questions.push(question);
-    }
-    return question;
-  }
-
-  /**
-   * Move a question in questions-array
-   * @param question (reference)
-   * @param toIndex
-   */
-  moveQuestion(question: BuilderQuestion, toIndex: number): boolean {
-    const validToIndexFn = U.isInRange(0, this._questions.length);
-    if (!validToIndexFn(toIndex)) {
-      return false;
-    }
-    const currentIndex = this._questions.indexOf(question);
-    if (currentIndex < 0) {
-      return false;
-    }
-    this._questions.splice(currentIndex, 1);
-    this._questions.splice(toIndex, 0, question);
-    return true;
-  }
-
-  deleteQuestion(question: BuilderQuestion) {
-    this._questions = this._questions.filter((q) => q !== question);
-    // TODO EMIT DELETED QUESTION.
-    this.updateRows();
-  }
-  private updateRows() {
-    if (this._pageType === "question" || this._pageType === "info-page") {
-      this._questions = [];
-    }
-    if (this._pageType === "form" && this._questions.length === 0) {
-      this._questions = [];
-      this.addQuestion("text");
-    }
-    if (this._pageType === "multi-select" && this._questions.length === 0) {
-      this._questions = [];
-      this.addQuestion("text");
-    }
   }
 
   public addTag(tag: string) {
@@ -163,15 +118,17 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
 
   set pageType(value: BuilderPageType) {
     this._pageType = value;
-    // TODO Emit All questions that are deleted? Listen for removed variables??
-    this.updateRows();
+  }
+
+  get includedInSumScores() {
+    return [...this._includedInSumScores.values()];
   }
 
   getQuestionVariables(
     modulePrefix: SchemaPrefix,
     pageNumber: number,
-  ): ReadonlyArray<QuestionVariable> {
-    const variables: QuestionVariable[] = [];
+  ): ReadonlyArray<RuleQuestionVariable> {
+    const variables: RuleQuestionVariable[] = [];
 
     if (this._pageType === "question") {
       const pagePrefix = this.prefix;
@@ -180,9 +137,9 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
       const op = this.defaultQuestion.options.map((o) => {
         const label = o.label;
         const value = o.value;
-        return new BuilderVariableOption(label, value);
+        return new RuleVariableOption(label, value);
       });
-      const singleVar = new QuestionVariable(varId, label, op, pageNumber);
+      const singleVar = new RuleQuestionVariable(varId, label, op, pageNumber);
       variables.push(singleVar);
     }
     return variables;
@@ -203,11 +160,36 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
     this._prefix.value = value;
   }
 
+  sumScoreVariableSet(sumScoreVariable: SumScoreVariable, weight: number) {
+    const { id, name, description } = sumScoreVariable;
+
+    this._includedInSumScores.set(sumScoreVariable.id, {
+      sumScoreVariableId: id,
+      weight,
+      name,
+      description,
+    });
+
+    return true;
+  }
+
+  sumScoreVariableUpdateData(variables: ReadonlyArray<SumScoreVariable>) {
+    variables.forEach((v) => {
+      const sumScoreEntry = this._includedInSumScores.get(v.id);
+      if (sumScoreEntry) {
+        this.sumScoreVariableSet(v, sumScoreEntry.weight);
+      }
+    });
+  }
+
   toJson(): BuilderPageDto {
-    const questions = this._questions.map((q) => q.toJson());
     const mainText = this.mainText.toJson();
     const nextButton = this.nextButton.toJson();
     const mainMedia = this.mainMedia;
+    const includedInSumScores = this.includedInSumScores.map(({ sumScoreVariableId, weight }) => ({
+      sumScoreVariableId,
+      weight,
+    }));
     const dto: BuilderPageDto = {
       _type: this.pageType,
       mainText,
@@ -215,9 +197,9 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
       nextButton,
       id: this.id,
       tags: [...this.tags],
+      includedInSumScores,
       prefix: this._prefix.value,
       defaultQuestion: this.defaultQuestion.toJson(),
-      questions,
     };
     if (mainMedia) {
       dto.mainMedia = mainMedia;
@@ -229,15 +211,12 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
     const dto = this.toJson();
     const defaultQuestionClone = this.defaultQuestion.clone();
     const mainTextClone = JSON.parse(JSON.stringify(this.mainText));
-    // const pagesClone = this
-    const questionsClone = this.questions.map((q) => q.clone());
     const newId = PageID.create();
     const clone: BuilderPageDto = {
       ...dto,
       id: newId,
       defaultQuestion: defaultQuestionClone,
       mainText: mainTextClone,
-      questions: questionsClone,
     };
     // const cloneDto
     return clone;
@@ -253,7 +232,7 @@ export class BuilderPage extends BuilderObject<"builder-page", BuilderPageDto> {
     }
   }
 
-  get questions(): ReadonlyArray<BuilderQuestion> {
-    return this._questions;
+  sumScoreVariableDelete(sumScoreVariableID: SumScoreVariableID) {
+    this._includedInSumScores.delete(sumScoreVariableID);
   }
 }

package/src/primitives/ID.spec.ts

@@ -1,39 +1,39 @@
-import { PageID, SchemaID } from "./ID";
-
-describe("ID Functions work", () => {
-  //Generate test for schema prefix
-  test("SCHEMA_ID isFunction works", () => {
-    const id = SchemaID.create();
-    expect(SchemaID.is(id)).toBe(true);
-    expect(SchemaID.is("")).toBe(false);
-    expect(SchemaID.is("a")).toBe(false);
-    expect(SchemaID.is("a".repeat(10))).toBe(true);
-    expect(SchemaID.is("a".repeat(9))).toBe(false);
-  });
-  test("SCHEMA_ID ensure works", () => {
-    const id = SchemaID.create();
-    expect(SchemaID.validateOrCreate(id)).toBe(id);
-    expect(SchemaID.validateOrCreate("")).not.toBe("");
-    expect(SchemaID.validateOrCreate("")).not.toBe("a");
-    expect(SchemaID.validateOrCreate("a".repeat(10))).toBe("a".repeat(10));
-    expect(SchemaID.validateOrCreate("a".repeat(9))).not.toBe("a".repeat(9));
-    expect(SchemaID.validateOrCreate("ABcdefghigKLML")).toBe("ABcdefghigKLML");
-  });
-  test("PageID isFunction works", () => {
-    const id = PageID.create();
-    expect(PageID.is(id)).toBe(true);
-    expect(PageID.is("")).toBe(false);
-    expect(PageID.is("a")).toBe(false);
-    expect(PageID.is("a".repeat(10))).toBe(true);
-    expect(PageID.is("a".repeat(9))).toBe(false);
-  });
-  test("PageID ensure works", () => {
-    const id = PageID.create();
-    expect(PageID.validateOrCreate(id)).toBe(id);
-    expect(PageID.validateOrCreate("")).not.toBe("");
-    expect(PageID.validateOrCreate("")).not.toBe("a");
-    expect(PageID.validateOrCreate("a".repeat(10))).toBe("a".repeat(10));
-    expect(PageID.validateOrCreate("a".repeat(9))).not.toBe("a".repeat(9));
-    expect(PageID.validateOrCreate("ABcdefghigKLML")).toBe("ABcdefghigKLML");
-  });
-});
+import { PageID, SchemaID } from "./ID";
+
+describe("ID Functions work", () => {
+  //Generate test for schema prefix
+  test("SCHEMA_ID isFunction works", () => {
+    const id = SchemaID.create();
+    expect(SchemaID.is(id)).toBe(true);
+    expect(SchemaID.is("")).toBe(false);
+    expect(SchemaID.is("a")).toBe(false);
+    expect(SchemaID.is("a".repeat(10))).toBe(true);
+    expect(SchemaID.is("a".repeat(9))).toBe(false);
+  });
+  test("SCHEMA_ID ensure works", () => {
+    const id = SchemaID.create();
+    expect(SchemaID.validateOrCreate(id)).toBe(id);
+    expect(SchemaID.validateOrCreate("")).not.toBe("");
+    expect(SchemaID.validateOrCreate("")).not.toBe("a");
+    expect(SchemaID.validateOrCreate("a".repeat(10))).toBe("a".repeat(10));
+    expect(SchemaID.validateOrCreate("a".repeat(9))).not.toBe("a".repeat(9));
+    expect(SchemaID.validateOrCreate("ABcdefghigKLML")).toBe("ABcdefghigKLML");
+  });
+  test("PageID isFunction works", () => {
+    const id = PageID.create();
+    expect(PageID.is(id)).toBe(true);
+    expect(PageID.is("")).toBe(false);
+    expect(PageID.is("a")).toBe(false);
+    expect(PageID.is("a".repeat(10))).toBe(true);
+    expect(PageID.is("a".repeat(9))).toBe(false);
+  });
+  test("PageID ensure works", () => {
+    const id = PageID.create();
+    expect(PageID.validateOrCreate(id)).toBe(id);
+    expect(PageID.validateOrCreate("")).not.toBe("");
+    expect(PageID.validateOrCreate("")).not.toBe("a");
+    expect(PageID.validateOrCreate("a".repeat(10))).toBe("a".repeat(10));
+    expect(PageID.validateOrCreate("a".repeat(9))).not.toBe("a".repeat(9));
+    expect(PageID.validateOrCreate("ABcdefghigKLML")).toBe("ABcdefghigKLML");
+  });
+});

package/src/primitives/ID.ts

@@ -86,17 +86,30 @@ export const createTypedIdSingleton = <const B extends string>(idName: B): Id<B>
     return is(id) ? id : create();
   };
 
+  const a = createDummyID(idName, "a");
+  const b = createDummyID(idName, "b");
+  const c = createDummyID(idName, "c");
+  const d = createDummyID(idName, "d");
+  const e = createDummyID(idName, "e");
+  const f = createDummyID(idName, "f");
+  const g = createDummyID(idName, "g");
+  const h = createDummyID(idName, "h");
+  const i = createDummyID(idName, "i");
+  const j = createDummyID(idName, "j");
+  const list = [a, b, c, d, e, f, g, h, i, j];
+
   const dummy = {
-    a: createDummyID(idName, "a"),
-    b: createDummyID(idName, "b"),
-    c: createDummyID(idName, "c"),
-    d: createDummyID(idName, "d"),
-    e: createDummyID(idName, "e"),
-    f: createDummyID(idName, "f"),
-    g: createDummyID(idName, "g"),
-    h: createDummyID(idName, "h"),
-    i: createDummyID(idName, "i"),
-    j: createDummyID(idName, "j"),
+    a,
+    b,
+    c,
+    d,
+    e,
+    f,
+    g,
+    h,
+    i,
+    j,
+    list,
   };
 
   return Object.freeze({ create, is, validateOrCreate, validateOrThrow, name, dummy });
@@ -117,3 +130,6 @@ export type TextID = ID<"TEXT">;
 export const TextID = createTypedIdSingleton("TEXT");
 export type QuestionID = ID<"QUESTION">;
 export const QuestionID = createTypedIdSingleton("QUESTION");
+
+export type SumScoreVariableID = ID<"SUM_SCORE_VARIABLE">;
+export const SumScoreVariableID = createTypedIdSingleton("SUM_SCORE_VARIABLE");

package/src/primitives/page-prefix.ts

@@ -1,59 +1,59 @@
-import { SchemaPrefix } from "./schema-prefix";
-
-export type PagePrefixValue = string & { __PAGE_PREFIX__: true };
-export 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 PagePrefix {
-  public static readonly MIN_LENGTH = 1;
-  private static randomLen = 5;
-  public static readonly MAX_LENGTH = 16;
-
-  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;
-    return prefix.length <= SchemaPrefix.MAX_LENGTH;
-  };
-
-  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) {}
-}
+import { SchemaPrefix } from "./schema-prefix";
+
+export type PagePrefixValue = string & { __PAGE_PREFIX__: true };
+export 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 PagePrefix {
+  public static readonly MIN_LENGTH = 1;
+  private static randomLen = 5;
+  public static readonly MAX_LENGTH = 16;
+
+  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;
+    return prefix.length <= SchemaPrefix.MAX_LENGTH;
+  };
+
+  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) {}
+}