ArraySchema: fixes OPERATION.DELETE_BY_REFID and OPERATION.ADD_BY_REFID

Author: endel

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "3.0.28",
+  "version": "3.0.29",
   "description": "Binary state serializer with delta encoding for games",
   "bin": {
     "schema-codegen": "./bin/schema-codegen",

src/decoder/DecodeOperation.ts

@@ -326,10 +326,15 @@ export const decodeArray: DecodeOperation = function (
         const refId = decode.number(bytes, it);
         const itemByRefId = decoder.root.refs.get(refId);
 
-        // use existing index, or push new value
-        index = (itemByRefId)
-            ? ref.findIndex((value) => value === itemByRefId)
-            : ref.length;
+        // if item already exists, use existing index
+        if (itemByRefId) {
+            index = ref.findIndex((value) => value === itemByRefId);
+        }
+
+        // fallback to use last index
+        if (index === -1 || index === undefined) {
+            index = ref.length;
+        }
 
     } else {
         index = decode.number(bytes, it);

src/encoder/EncodeOperation.ts

@@ -210,7 +210,7 @@ export const encodeArray: EncodeOperation = function (
     encode.number(bytes, refOrIndex, it);
 
     // Do not encode value for DELETE operations
-    if (operation === OPERATION.DELETE) {
+    if (operation === OPERATION.DELETE || operation === OPERATION.DELETE_BY_REFID) {
         return;
     }
 

test/StateView.test.ts

@@ -1,7 +1,6 @@
 import * as assert from "assert";
 import { Schema, type, view, ArraySchema, MapSchema, StateView, Encoder, ChangeTree, $changes, OPERATION, SetSchema, CollectionSchema } from "../src";
 import { createClientWithView, encodeMultiple, assertEncodeAllMultiple, getDecoder, getEncoder, createInstanceFromReflection, encodeAllForView, encodeAllMultiple } from "./Schema";
-import { getDecoderStateCallbacks } from "../src/decoder/strategy/StateCallbacks";
 import { nanoid } from "nanoid";
 
 describe("StateView", () => {
@@ -1489,6 +1488,103 @@ describe("StateView", () => {
 
             assertEncodeAllMultiple(encoder, state, [client])
         });
+
+        it("nested arrays of a filtered entity", () => {
+            class Component extends Schema {
+                @type("string") name: string;
+                @type("number") value: number;
+            }
+            class QuestCondition extends Schema {
+                @type('number') level: number = null;
+                @type('string') quest: string = null;
+            }
+            class QuestReward extends Schema {
+                @type('number') amount: number;
+            }
+            class QuestRequirement extends Schema {
+                @type('number') progress: number = 0;
+            }
+            class Quest extends Schema {
+                @type('string') name: string;
+                @type([QuestRequirement]) requirements = new ArraySchema<QuestRequirement>();
+                @type([QuestReward]) rewards = new ArraySchema<QuestReward>();
+                @type([QuestCondition]) conditions = new ArraySchema<QuestCondition>();
+            }
+            class QuestBook extends Component {
+                @type([Quest]) finished: Quest[] = new ArraySchema<Quest>();
+                @type([Quest]) ongoing: Quest[] = new ArraySchema<Quest>();
+            }
+            class Entity extends Schema {
+                @type("string") id: string = nanoid(9);
+                @type([Component]) components = new ArraySchema<Component>();
+            }
+
+            class MyRoomState extends Schema {
+                @view() @type({ map: Entity }) entities = new MapSchema<Entity>();
+            }
+
+            const state = new MyRoomState();
+            const encoder = getEncoder(state);
+
+            const questBook = new QuestBook().assign({
+                finished: [],
+                ongoing: [
+                    new Quest().assign({
+                        name: "Quest1",
+                        requirements: [new QuestRequirement().assign({ progress: 0 })],
+                        rewards: [new QuestReward().assign({ amount: 300 })],
+                        conditions: [new QuestCondition().assign({ level: 3, quest: "Quest1" })]
+                    }),
+                    new Quest().assign({
+                        name: "Quest2",
+                        requirements: [new QuestRequirement().assign({ progress: 0 })],
+                        rewards: [new QuestReward().assign({ amount: 400 })],
+                        conditions: [new QuestCondition().assign({ level: 4, quest: "Quest2" })]
+                    }),
+                    new Quest().assign({
+                        name: "Quest3",
+                        requirements: [new QuestRequirement().assign({ progress: 0 })],
+                        rewards: [new QuestReward().assign({ amount: 400 })],
+                        conditions: [new QuestCondition().assign({ level: 4, quest: "Quest3" })]
+                    })
+                ]
+            });
+
+            state.entities.set("one", new Entity().assign({
+                id: "one",
+                components: [questBook]
+            }));
+
+            state.entities.set("two", new Entity().assign({
+                id: "two",
+                components: []
+            }));
+
+            const client = createClientWithView(state);
+            encodeMultiple(encoder, state, [client]);
+
+            // add entities for the first time
+            client.view.add(state.entities.get("one"));
+
+            encodeMultiple(encoder, state, [client]);
+            assert.strictEqual(1, client.state.entities.size);
+
+            assert.deepStrictEqual(state.entities.get("one").toJSON(), client.state.entities.get("one").toJSON());
+
+            // 1st remove ongoing + add to finished
+            const ongoing1 = questBook.ongoing.shift();
+            questBook.finished.push(ongoing1);
+            encodeMultiple(encoder, state, [client]);
+            assert.deepStrictEqual(state.entities.get("one").toJSON(), client.state.entities.get("one").toJSON());
+
+            // 2st remove ongoing + add to finished
+            const ongoing2 = questBook.ongoing.shift();
+            questBook.finished.push(ongoing2);
+            encodeMultiple(encoder, state, [client]);
+            assert.deepStrictEqual(state.entities.get("one").toJSON(), client.state.entities.get("one").toJSON());
+
+            assertEncodeAllMultiple(encoder, state, [client]);
+        });
     });
 
     describe("Deep and nested structures", () => {