fix(store): id in values & minor pending state bugfix

src/cache.js

@@ -3,16 +3,17 @@ import * as emitter from "./emitter.js";
 const entries = new WeakMap();
 const stack = new Set();
 
-function dispatch(entry) {
+function dispatch(entry, resolved = false) {
   const contexts = [];
   let index = 0;
 
-  while (entry) {
-    entry.resolved = false;
+  entry.resolved = resolved;
 
+  while (entry) {
     if (entry.contexts) {
       for (const context of entry.contexts) {
         if (!stack.has(context) && !contexts.includes(context)) {
+          context.resolved = false;
           contexts.push(context);
         }
       }
@@ -137,7 +138,7 @@ export function sync(target, key, fn, value) {
     entry.value = nextValue;
     entry.assertValue = undefined;
 
-    dispatch(entry);
+    dispatch(entry, true);
 
     // mark as resolved to avoid double fn call in get
     entry.resolved = true;

src/store.js

@@ -1120,8 +1120,10 @@ function get(Model, id) {
   const entry = cache.getEntry(config, stringId);
   const cachedModel = entry.value;
 
-  if (entry.resolved && cachedModel && !validate(cachedModel)) {
-    entry.resolved = false;
+  if (cachedModel) {
+    entry.resolved =
+      (entry.resolved && validate(cachedModel)) ||
+      getModelState(cachedModel).state === "pending";
   }
 
   return cache.get(config, stringId, () => {
@@ -1287,7 +1289,13 @@ function set(model, values = {}) {
   }
 
   if (!isDraft && values && hasOwnProperty.call(values, "id")) {
-    throw TypeError(`Values must not contain 'id' property: ${values.id}`);
+    if (!config.enumerable) {
+      throw TypeError(`Values must not contain 'id' property: ${values.id}`);
+    } else if (!isInstance || values.id !== model.id) {
+      throw TypeError(
+        `You cannot change the 'id' property of the model instance: ${values.id}`,
+      );
+    }
   }
 
   const localModel = config.create(values, isInstance ? model : undefined);

test/spec/store.js

@@ -382,9 +382,23 @@ describe("store:", () => {
       expect(() => store.set(model, false)).toThrow();
     });
 
-    it("throws an error when values contain 'id' property", async () => {
+    it("throws an error when values contain 'id' property for singleton model", async () => {
+      Model = {};
+      expect(() => store.set(Model, { id: "test" })).toThrow();
+    });
+
+    it("throws an error when values contain 'id' property for enumerable model", async () => {
+      expect(() => store.set(Model, { id: "test" })).toThrow();
+    });
+
+    it("throws an error when updating an instance and values contain different 'id' property", async () => {
+      const model = await promise;
+      expect(() => store.set(model, { ...model, id: "different" })).toThrow();
+    });
+
+    it("does not throw an error when updating an instance and values contain the same 'id' property", async () => {
       const model = await promise;
-      expect(() => store.set(model, model)).toThrow();
+      expect(() => store.set(model, model)).not.toThrow();
     });
 
     it("throws an error when array with primitives is set with wrong type", async () => {