@media-quest/builder 0.0.7 → 0.0.9

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/public-api.ts

@@ -8,6 +8,6 @@ export { BuilderMainText, type BuilderMainTextDto } from "./BuilderMainText";
 export { type BuilderMainVideoDto } from "./BuilderMainVideoDto";
 export { type BuilderTagDto, BuilderTag, TagCollection } from "./BuilderTag";
 export { type AudioFile, type ImageFile, type VideoFile } from "./media-files";
-
+export * from "./prefix";
 // Public Api of rule-builder
 export * from "./rulebuilder";

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;