@media-quest/engine 0.0.1 → 0.0.3

package/src/state/state-service.spec.ts

@@ -0,0 +1,307 @@
+import { DState } from "./Dstate";
+import { Condition } from "../rules/condition";
+import { Fact } from "../rules/fact";
+import { Ok } from "../common/result";
+import { StateService } from "./state-service";
+import { _P, _Q } from "./state-testing-helpers";
+import { EventBus } from "../events/event-bus";
+import { DCommandBus } from "../commands/DCommandBus";
+import { StateCommand } from "../commands/DCommand";
+
+let eventBus = new EventBus();
+let commandBus = new DCommandBus();
+let stateContainer = new StateService(eventBus, commandBus, [], []);
+const allVariables = Object.values(_P).map((p) => p.propDefinition);
+const allDerived = Object.values(_Q);
+
+const createCommand = (mutation: DState.StateMutation): StateCommand => {
+    return { kind: "STATE_MUTATE_COMMAND", target: "STATE", targetId: "STATE", payload: { mutation } };
+};
+
+describe("State-container", () => {
+    beforeEach(() => {
+        eventBus = new EventBus();
+        stateContainer = new StateService(eventBus, commandBus, allVariables, allDerived);
+    });
+
+    it("can add variables, and update", () => {
+        stateContainer = new StateService(eventBus, commandBus, [_P.propA.propDefinition]);
+
+        commandBus.emit(_P.propA.getSetFalseCommand());
+        const result = stateContainer.getPropAsFact(_P.propA.propName);
+        expect(result.isOk()).toBe(true);
+
+        // expect(result.errors.length).toBe(1);
+    });
+
+    it("can not update non-excisting variable", () => {
+        const p = _P.propB;
+        stateContainer = new StateService(eventBus, commandBus, [p.propDefinition]);
+        const invalidName = "invalid-variable-name";
+        commandBus.emit({
+            kind: "STATE_MUTATE_COMMAND",
+            target: "STATE",
+            targetId: "STATE",
+            payload: { mutation: { kind: "set-number", value: 1, propName: invalidName } },
+        });
+        const result0 = stateContainer.getPropAsFact(invalidName);
+        expect(result0.isOk()).toBe(false);
+    });
+    it("can solve condition, and initial value is false.: ", () => {
+        const p = _P.propD;
+        expect(stateContainer.isMatched(p.getIsTrueCondition())).toBe(false);
+        expect(stateContainer.isMatched(p.getIsFalseCondition())).toBe(true);
+    });
+
+    it("Solve will change after update: ", () => {
+        expect(stateContainer.isMatched(_P.propA.getIsFalseCondition())).toBe(true);
+        commandBus.emit(_P.propA.getSetTrueCommand());
+        expect(stateContainer.isMatched(_P.propA.getIsFalseCondition())).toBe(false);
+    });
+
+    it("Can also add audio-played count facts, and get results. ", () => {
+        const variable: DState.NumericProp = {
+            _type: "number",
+            propName: "audio-play-count-audio-1",
+            propDescription: "Number of times audio 1 has played through.",
+        };
+        stateContainer = new StateService(eventBus, commandBus, [variable]);
+        const condition: Condition = {
+            kind: "numeric-condition",
+            referenceId: variable.propName,
+            referenceLabel: variable.propDescription ?? "",
+            valueLabel: "Audio played at least 1 time.",
+            value: 0,
+            operator: "greater-then",
+        };
+
+        expect(stateContainer.isMatched(condition)).toBe(false);
+
+        const command = createCommand({
+            propName: variable.propName,
+            kind: "increment-number",
+            stepSize: 1,
+            ifNotExistThenSetTo: 1,
+        });
+        commandBus.emit(command);
+        // expect(res.success).toBe(true);
+        // expect(stateContainer.isMatched(condition)).toBe(true);
+        expect(stateContainer.isMatched(condition)).toBe(true);
+    });
+
+    it("Can create and update properties in state", () => {
+        const numProp1: DState.NumericProp = { _type: "number", propName: "numProp1", propDescription: "" };
+        const stringProp1: DState.StringProp = {
+            _type: "string",
+            propName: "stringProp1",
+            initialValue: "initial",
+            propDescription: "",
+        };
+        const stringProp2: DState.StringProp = { _type: "string", propName: "stringProp2", propDescription: "" };
+        const numericProp2: DState.NumericProp = {
+            _type: "number",
+            propName: "numProp2",
+            initialValue: 100,
+            propDescription: "",
+        };
+        stateContainer = new StateService(eventBus, commandBus, [numProp1, stringProp1, numericProp2, stringProp2]);
+
+        commandBus.emit(
+            createCommand({
+                propName: numProp1.propName,
+                kind: "increment-number",
+                stepSize: 1,
+                ifNotExistThenSetTo: 1,
+            })
+        );
+        const resultIntialString = stateContainer.getPropAsFact(stringProp1.propName) as Ok<Fact.String>;
+        const resultIntialStringEmpty = stateContainer.getPropAsFact(stringProp2.propName);
+
+        expect(resultIntialStringEmpty.isFailure()).toBe(true);
+        expect(resultIntialString.value.value).toBe(stringProp1.initialValue);
+        const result1 = stateContainer.getPropAsFact(numProp1.propName) as Ok<Fact.Numeric>;
+        expect(result1.value.value).toBe(1);
+        commandBus.emit(createCommand({ propName: numProp1.propName, kind: "set-number", value: 10 }));
+        const result10 = stateContainer.getPropAsFact(numProp1.propName) as Ok<Fact.Numeric>;
+        expect(result10.value.value).toBe(10);
+
+        // NUMPROP2
+        const numProp2InitialResult = stateContainer.getPropAsFact(numericProp2.propName) as Ok<Fact.Numeric>;
+        expect(numProp2InitialResult.value.value).toBe(100);
+        commandBus.emit(
+            createCommand({
+                propName: numericProp2.propName,
+                kind: "decrement-number",
+                stepSize: 10,
+                ifNotExistThenSetTo: 1,
+            })
+        );
+        const numProp2Res90 = stateContainer.getPropAsFact(numericProp2.propName) as Ok<Fact.Numeric>;
+        expect(numProp2Res90.value.value).toBe(90);
+
+        commandBus.emit(createCommand({ propName: stringProp1.propName, kind: "set-string", value: "updated-value" }));
+        const stringResUpdated = stateContainer.getPropAsFact(stringProp1.propName) as Ok<Fact.String>;
+        expect(stringResUpdated.value.value).toBe("updated-value");
+    });
+
+    it("Can have a counter variable in state. ", () => {
+        stateContainer = new StateService(eventBus, commandBus, [
+            { _type: "number", propDescription: "", propName: "page-count", initialValue: 0 },
+        ]);
+        const condition: Condition = {
+            kind: "numeric-condition",
+            referenceId: "page-count",
+            referenceLabel: "Number of pages seen today",
+            valueLabel: "Audio played at least 1 time.",
+            value: 10,
+            operator: "eq",
+        };
+
+        expect(stateContainer.isMatched(condition)).toBe(false);
+        commandBus.emit(
+            createCommand({
+                propName: condition.referenceId,
+                kind: "increment-number",
+                stepSize: 1,
+                ifNotExistThenSetTo: 1,
+            })
+        );
+        commandBus.emit(
+            createCommand({
+                propName: condition.referenceId,
+                kind: "increment-number",
+                stepSize: 5,
+                ifNotExistThenSetTo: 5,
+            })
+        );
+        commandBus.emit(
+            createCommand({
+                propName: condition.referenceId,
+                kind: "increment-number",
+                stepSize: 4,
+                ifNotExistThenSetTo: 4,
+            })
+        );
+        expect(stateContainer.isMatched(condition)).toBe(true);
+    });
+
+    it("Can get state-schema:", () => {
+        const s = stateContainer.getState();
+
+        expect(s.propCount).toBe(7);
+        expect(s.state[_P.propA.propName]).toBe(0);
+        expect(s.propArray.find((p) => p.propName === "not-defined")).toBe(undefined);
+        expect(s.propArray.find((p) => p.propName === _P.propB.propName)).toBeDefined();
+    });
+
+    it("Check that condition can be matched:", () => {
+        const simpleFn = (refId: string): Condition.Simple => {
+            if (Math.random() < 0.5) {
+                return {
+                    kind: "string-condition",
+                    referenceId: refId,
+                    referenceLabel: "label for " + refId,
+                    value: "dummy value",
+                    operator: "not-eq",
+                    valueLabel: "Is False",
+                };
+            } else {
+                return {
+                    kind: "numeric-condition",
+                    referenceId: refId,
+                    referenceLabel: "Label for " + refId,
+                    value: 0,
+                    operator: "not-eq",
+                    valueLabel: "Is False",
+                };
+            }
+        };
+
+        const complex = (all: Condition.Simple[], some: Condition.Simple[]): Condition.Complex => {
+            return { kind: "complex-condition", name: "", all, some };
+        };
+        const a = _P.propA;
+        const b = _P.propB;
+        const c = _P.propC;
+
+        expect(stateContainer.canBeMatched(simpleFn(a.propName))).toBe(true);
+        expect(stateContainer.canBeMatched(simpleFn("invalid"))).toBe(false);
+        expect(
+            stateContainer.canBeMatched(complex([simpleFn(a.propName), simpleFn(b.propName)], [simpleFn(c.propName)]))
+        ).toBe(true);
+    });
+
+    it("Can mutate state TODO!! Query", () => {
+        const { propA, propB, propC } = _P;
+        const s0 = stateContainer.getState();
+
+        expect(s0.propNames.length).toBe(7);
+        expect(s0.propCount).toBe(7);
+        expect(s0.propArray.length).toBe(6);
+
+        expect(s0.state[propA.propName]).toBe(0);
+        commandBus.emit(propA.getSetTrueCommand());
+        commandBus.emit(propB.getSetTrueCommand());
+        const s1 = stateContainer.getState();
+        expect(s1.state[propA.propName]).toBe(1);
+        commandBus.emit(propA.getSetFalseCommand());
+
+        commandBus.emit(propB.getSetFalseCommand());
+        const s2 = stateContainer.getState();
+        expect(s2.state[propA.propName]).toBe(0);
+    });
+
+    it("Will only emit query when changed changed event.", (done) => {
+        const { A_or_B_or_C_Query } = _Q;
+        let count = 0;
+        eventBus.subscribe((event) => {
+            if (event.kind === "STATE_QUERY_RESULT_CHANGED_EVENT") {
+                if (event.data.queryName === A_or_B_or_C_Query.name) {
+                    count += 1;
+                    if (count === 1) {
+                        expect(event.data.curr).toBe(true);
+                    }
+                    if (count === 2) {
+                        expect(event.data.curr).toBe(false);
+                        done();
+                    }
+                }
+            }
+        }, "Will only emit query when changed event.");
+        // 1 CHANGES QUERY
+        commandBus.emit(_P.propA.getSetTrueCommand());
+        // 2 NO CHANGE
+        commandBus.emit(_P.propA.getSetTrueCommand());
+        // 3 NO CHANGE
+        commandBus.emit(_P.propA.getSetTrueCommand());
+        // 4 CHANGES QUERY
+        commandBus.emit(_P.propA.getSetFalseCommand());
+    });
+
+    it("Can upsert props", (done) => {
+        const { A_or_B_or_C_Query } = _Q;
+        let count = 0;
+        eventBus.subscribe((event) => {
+            if (event.kind === "STATE_QUERY_RESULT_CHANGED_EVENT") {
+                if (event.data.queryName === A_or_B_or_C_Query.name) {
+                    count += 1;
+                    if (count === 1) {
+                        expect(event.data.curr).toBe(true);
+                    }
+                    if (count === 2) {
+                        expect(event.data.curr).toBe(false);
+                        done();
+                    }
+                }
+            }
+        }, "Can upsert props");
+        // 1 CHANGES QUERY
+        commandBus.emit(_P.propA.getSetTrueCommand());
+        // 2 NO CHANGE
+        commandBus.emit(_P.propA.getSetTrueCommand());
+        // 3 NO CHANGE
+        commandBus.emit(_P.propA.getSetTrueCommand());
+        // 4 CHANGES QUERY
+        commandBus.emit(_P.propA.getSetFalseCommand());
+    });
+});

package/src/state/state-service.ts

@@ -0,0 +1,251 @@
+import { Fact } from "../rules/fact";
+import { Result } from "../common/result";
+import { Condition } from "../rules/condition";
+import { DState } from "./Dstate";
+import { DEventDispatcher } from "../events/event-bus";
+import { DTimestamp } from "../common/DTimestamp";
+import { QueryChangedEvent } from "../events/DEvents";
+import { DCommandBus } from "../commands/DCommandBus";
+
+export class StateService {
+  private readonly TAG = " [ STATE_SERVICE ] :";
+  private readonly factsString = new Map<string, Fact.String>();
+  private readonly factsNumeric = new Map<string, Fact.Numeric>();
+  private readonly propDefinitions = new Map<string, DState.Prop>();
+  private readonly queries = new Map<string, { query: DState.StateQuery; lastResult: boolean }>();
+  private readonly unsubscribeCommands: () => void;
+  constructor(
+    private readonly eventBus: DEventDispatcher,
+    private readonly commandBus: DCommandBus,
+    private readonly props: ReadonlyArray<DState.Prop>,
+    private readonly queryList: ReadonlyArray<DState.StateQuery> = [],
+  ) {
+    props.forEach((prop) => {
+      this.registerProperty(prop);
+    });
+    const facts = this.getAllFacts();
+    queryList.forEach((definition) => {
+      this.registerQuery(definition, facts);
+    });
+
+    this.evaluateQueries();
+    this.unsubscribeCommands = this.commandBus.subscribe((command) => {
+      if (command.kind === "STATE_MUTATE_COMMAND") {
+        this.mutation(command.payload.mutation);
+      }
+    }, this.TAG);
+  }
+
+  destroy() {
+    this.unsubscribeCommands();
+  }
+
+  private registerQuery(query: DState.StateQuery, currentFacts: ReadonlyArray<Fact>) {
+    const result = Condition.evaluate(query.condition, currentFacts);
+    this.queries.set(query.name, { query: query, lastResult: result });
+    this.emitQueryChangedEvent({ queryName: query.name, prev: result, curr: result });
+  }
+
+  private registerProperty(prop: DState.Prop) {
+    if (this.propDefinitions.has(prop.propName)) {
+      // LOGGING
+      console.warn("Prop excists already.", prop.propName);
+    }
+
+    this.propDefinitions.set(prop.propName, prop);
+
+    if (prop.initialValue === undefined) {
+      return;
+    }
+
+    if (prop._type === "string") {
+      const fact = DState.stringPropToFact(prop, prop.initialValue);
+      this.factsString.set(fact.referenceId, fact);
+    }
+    if (prop._type === "number") {
+      const fact = DState.numericPropToFact(prop, prop.initialValue);
+      this.factsNumeric.set(fact.referenceId, fact);
+    }
+  }
+
+  private mutateString(prop: DState.StringProp, value: string) {
+    const curr = this.factsString.get(prop.propName);
+    if (curr) {
+      const updated: Fact.String = { ...curr, value };
+      this.setFact(updated);
+    } else {
+      const created: Fact.String = {
+        kind: "string-fact",
+        referenceId: prop.propName,
+        referenceLabel: "label for: " + prop.propName,
+        value,
+        label: "Value: " + value,
+      };
+      this.setFact(created);
+    }
+  }
+
+  private mutateNumber(prop: DState.NumericProp, mutation: DState.NumberMutations) {
+    const curr = this.factsNumeric.get(prop.propName);
+    if (!curr) {
+      switch (mutation.kind) {
+        case "set-number":
+          this.setFact(DState.numericPropToFact(prop, mutation.value));
+          break;
+        case "decrement-number":
+          this.setFact(DState.numericPropToFact(prop, mutation.ifNotExistThenSetTo));
+          break;
+        case "increment-number":
+          this.setFact(DState.numericPropToFact(prop, mutation.ifNotExistThenSetTo));
+          break;
+        default:
+          const check: never = mutation;
+      }
+    }
+    if (curr) {
+      switch (mutation.kind) {
+        case "set-number":
+          this.setFact({ ...curr, value: mutation.value });
+          break;
+        case "decrement-number":
+          this.setFact({ ...curr, value: curr.value - mutation.stepSize });
+          break;
+        case "increment-number":
+          this.setFact({ ...curr, value: curr.value + mutation.stepSize });
+          break;
+        default:
+          const check: never = mutation;
+      }
+    }
+  }
+
+  private evaluateQueries(): ReadonlyArray<{ queryName: string; prev: boolean; curr: boolean; didChange: boolean }> {
+    const facts = this.getAllFacts();
+    const all: Array<{ queryName: string; prev: boolean; curr: boolean; didChange: boolean }> = [];
+    this.queries.forEach((q) => {
+      const prev = q.lastResult;
+
+      const curr = Condition.evaluate(q.query.condition, facts);
+      const didChange = prev !== curr;
+      q.lastResult = curr;
+      all.push({ queryName: q.query.name, prev, curr, didChange });
+      // def.value = value;
+    });
+    return all;
+  }
+
+  private mutation(mutation: DState.StateMutation): { success: boolean } {
+    const propDef = this.propDefinitions.get(mutation.propName);
+    if (!propDef) {
+      // TODO LOGGING
+      return { success: false };
+    }
+
+    if (propDef._type === "string" && DState.isStringMutation(mutation)) {
+      this.mutateString(propDef, mutation.value);
+    }
+
+    if (propDef._type === "number" && DState.isNumberMutation(mutation)) {
+      this.mutateNumber(propDef, mutation);
+    }
+    const queryResults = this.evaluateQueries();
+    const changedResult = queryResults.filter((r) => r.didChange);
+    changedResult.forEach((res) => {
+      this.emitQueryChangedEvent({ queryName: res.queryName, prev: res.prev, curr: res.curr });
+    });
+
+    return { success: true };
+  }
+
+  private emitQueryChangedEvent(data: { queryName: string; prev: boolean; curr: boolean }) {
+    const queryChangedEvent: QueryChangedEvent = {
+      kind: "STATE_QUERY_RESULT_CHANGED_EVENT",
+      producer: "STATE-SERVICE",
+      producerId: "STATE-SERVICE",
+      timestamp: DTimestamp.now(),
+      data,
+    };
+    const { queryName, curr, prev } = queryChangedEvent.data;
+    // console.log("[ QUERY_CHANGED " + queryName + "] : " + prev + " -> " + curr);
+    this.eventBus.emit(queryChangedEvent);
+  }
+
+  getPropAsFact(propName: string): Result<Fact> {
+    const propDef = this.propDefinitions.get(propName);
+    if (!propDef) {
+      return Result.failure(
+        "No definition form property ny name " + propName + " is registered. (Pass in constructor.)",
+      );
+    }
+    const value = this.factsString.get(propName) ?? this.factsNumeric.get(propName);
+
+    return value ? Result.ok(value) : Result.failure("Property " + propName + " has no value.");
+  }
+
+  private setFact(fact: Fact) {
+    switch (fact.kind) {
+      case "numeric-fact":
+        this.factsNumeric.set(fact.referenceId, fact);
+        break;
+      case "string-fact":
+        this.factsString.set(fact.referenceId, fact);
+        break;
+      default:
+        const check: never = fact;
+    }
+  }
+
+  getState() {
+    const props: Record<string, string | number | null | boolean> = {};
+    this.propDefinitions.forEach((def) => {
+      let value: string | number | null = null;
+      const maybeFact = this.getAnyFact(def.propName);
+      if (maybeFact) {
+        value = maybeFact.value;
+      }
+      props[def.propName] = value;
+    });
+    this.queries.forEach((query) => {
+      props[query.query.name] = query.lastResult;
+    });
+
+    const propNames = Object.keys(props);
+    const propCount = propNames.length;
+    const propArray = [...this.propDefinitions.values()];
+
+    return { propCount, propNames, propArray, state: props };
+  }
+
+  private getAnyFact(propName: string): Fact | false {
+    return this.factsString.get(propName) ?? this.factsNumeric.get(propName) ?? false;
+  }
+
+  private getAllFacts(): ReadonlyArray<Fact> {
+    return [...this.factsNumeric.values(), ...this.factsString.values()];
+  }
+
+  /**
+   * Will check that all referenceIds used in Condition is registered as a valid property in state.
+   * @param condition
+   */
+  canBeMatched(condition: Condition): boolean {
+    const simpleConditions = Condition.getAllSimpleConditions(condition);
+    let hasAll = true;
+
+    const allIds = simpleConditions.map((c) => c.referenceId);
+
+    const missingIds: string[] = [];
+    allIds.forEach((id) => {
+      if (!this.propDefinitions.has(id)) {
+        hasAll = false;
+        missingIds.push(id);
+      }
+    });
+    console.log(this.TAG, missingIds);
+
+    return hasAll;
+  }
+  isMatched(condition: Condition) {
+    return Condition.evaluate(condition, this.getAllFacts());
+  }
+}

package/src/state/state-testing-helpers.ts

@@ -0,0 +1,59 @@
+import { DState } from "./Dstate";
+import { BooleanStateProperty } from "./boolean-property";
+
+const propA = new BooleanStateProperty("a", false, "a-description");
+const propB = new BooleanStateProperty("b", false, "b-description");
+const propC = new BooleanStateProperty("c", false, "c-description");
+const propD = new BooleanStateProperty("d", false, "d-description");
+const propE = new BooleanStateProperty("e", false, "e-description");
+const propF = new BooleanStateProperty("f", false, "f-description");
+
+const A_or_B_or_C_Query: DState.StateQuery = {
+    name: "a_or_b_or_c",
+    condition: {
+        kind: "complex-condition",
+        name: "audio-controls-are-blocked",
+        some: [
+            {
+                kind: "numeric-condition",
+                referenceId: propA.propName,
+                operator: "eq",
+                value: 1,
+                valueLabel: "TRUE",
+                referenceLabel: propA.propName,
+            },
+            {
+                kind: "numeric-condition",
+                referenceId: propB.propName,
+                value: 1,
+                operator: "eq",
+                valueLabel: "TRUE",
+                referenceLabel: propB.propName,
+            },
+            {
+                kind: "numeric-condition",
+                referenceId: propC.propName,
+                value: 1,
+                operator: "eq",
+                valueLabel: "TRUE",
+                referenceLabel: propC.propName,
+            },
+        ],
+        all: [],
+    },
+};
+export const _Q = {
+    A_or_B_or_C_Query,
+};
+
+export const _P = {
+    propA,
+    propB,
+    propC,
+    propD,
+    propE,
+    propF,
+} as const;
+
+// export const DEFAULT_STATE_PROPS_LIST = Object.values(DEFAULT_STATE_PROPS);
+// export const DEFAULT_STATE_DERIVED_LIST = Object.values(DERIVED_STATE);