Merge pull request #349 from rsodre/dojo-store-add

fix: Dojo store add entity

Author: MartianGreed

packages/sdk/package.json

@@ -38,8 +38,6 @@
         "starknet": "6.11.0"
     },
     "dependencies": {
-        "@dojoengine/core": "workspace:*",
-        "@dojoengine/create-burner": "workspace:*",
         "@dojoengine/torii-client": "workspace:*",
         "immer": "^10.1.1",
         "zustand": "^4.5.5"

packages/sdk/src/__tests__/state.test.ts

@@ -104,6 +104,7 @@ describe("createDojoStore", () => {
                 initialGalaxy,
             ]);
         const state = useStore.getState();
+        expect(state.getEntities()).toHaveLength(4);
         expect(state.entities["player1"]).toEqual(initialPlayer);
         expect(state.entities["game1"]).toEqual(initialGame);
         expect(state.entities["item1"]).toEqual(initialItem);
@@ -124,12 +125,14 @@ describe("createDojoStore", () => {
             },
         });
         const state = useStore.getState();
+        expect(state.getEntities()).toHaveLength(1);
         expect(state.entities["player1"].models.world?.player?.name).toEqual(
             "Bob"
         );
     });
 
-    test("updateEntity should not add a new entity if entityId does not exist", () => {
+    test("updateEntity should add a new entity if entityId does not exist", () => {
+        useStore.getState().setEntities([initialPlayer]);
         useStore.getState().updateEntity({
             entityId: "nonexistent",
             models: {
@@ -142,7 +145,10 @@ describe("createDojoStore", () => {
             },
         });
         const state = useStore.getState();
-        expect(state.entities["nonexistent"]).toBeUndefined();
+        expect(state.getEntities()).toHaveLength(2);
+        expect(
+            state.entities["nonexistent"].models.world?.player?.name
+        ).toEqual("Charlie");
     });
 
     test("applyOptimisticUpdate should apply updates and add to pendingTransactions", () => {

packages/sdk/src/convertQueryToEntityKeyClauses.ts

@@ -182,8 +182,6 @@ function createClauseFromWhere(
         }
     });
 
-    console.log("fieldOrder", keys);
-
     return {
         Keys: {
             keys: keys,

packages/sdk/src/state/zustand.ts

@@ -72,46 +72,48 @@ export function createDojoStore<T extends SchemaType>() {
                 },
                 updateEntity: (entity: Partial<ParsedEntity<T>>) => {
                     set((state: Draft<GameState<T>>) => {
-                        if (
-                            entity.entityId &&
-                            state.entities[entity.entityId] &&
-                            entity.models
-                        ) {
+                        if (entity.entityId && entity.models) {
                             const existingEntity =
                                 state.entities[entity.entityId];
 
-                            // Create new models object without spread
-                            const mergedModels: typeof existingEntity.models =
-                                Object.assign({}, existingEntity.models);
+                            if (existingEntity) {
+                                // Create new models object without spread
+                                const mergedModels: typeof existingEntity.models =
+                                    Object.assign({}, existingEntity.models);
 
-                            // Iterate through each namespace in the new models
-                            Object.entries(entity.models).forEach(
-                                ([namespace, namespaceModels]) => {
-                                    const typedNamespace =
-                                        namespace as keyof ParsedEntity<T>["models"];
-                                    if (!(typedNamespace in mergedModels)) {
-                                        mergedModels[
-                                            typedNamespace as keyof typeof mergedModels
-                                        ] = {} as any;
-                                    }
+                                // Iterate through each namespace in the new models
+                                Object.entries(entity.models).forEach(
+                                    ([namespace, namespaceModels]) => {
+                                        const typedNamespace =
+                                            namespace as keyof ParsedEntity<T>["models"];
+                                        if (!(typedNamespace in mergedModels)) {
+                                            mergedModels[
+                                                typedNamespace as keyof typeof mergedModels
+                                            ] = {} as any;
+                                        }
 
-                                    mergedModels[
-                                        typedNamespace as keyof typeof mergedModels
-                                    ] = Object.assign(
-                                        {},
                                         mergedModels[
                                             typedNamespace as keyof typeof mergedModels
-                                        ],
-                                        namespaceModels
-                                    );
-                                }
-                            );
-                            // Update the entity
-                            state.entities[entity.entityId] = {
-                                ...existingEntity,
-                                ...entity,
-                                models: mergedModels,
-                            };
+                                        ] = Object.assign(
+                                            {},
+                                            mergedModels[
+                                                typedNamespace as keyof typeof mergedModels
+                                            ],
+                                            namespaceModels
+                                        );
+                                    }
+                                );
+                                // Update the entity
+                                state.entities[entity.entityId] = {
+                                    ...existingEntity,
+                                    ...entity,
+                                    models: mergedModels,
+                                };
+                            } else {
+                                // Set new entity
+                                state.entities[entity.entityId] =
+                                    entity as WritableDraft<ParsedEntity<T>>;
+                            }
                         }
                     });
                 },