Skip to content

A platform for community discussion. Free, open, simple.

FIX: Restore reactivity and sideloaded records on WarpDrive models (#43342)

Samd344a135fd22
diff --git a/frontend/discourse/app/data/normalize.js b/frontend/discourse/app/data/normalize.js
index 4235190a0b2..d723cdc94a9 100644
--- a/frontend/discourse/app/data/normalize.js
+++ b/frontend/discourse/app/data/normalize.js
@@ -47,15 +47,16 @@ function userBadgeResource(raw, lookup, includedIds) {
const resource = resourceFrom("user-badge", UserBadgeSchema, raw);
const { attributes } = resource;
// Inline sideloads as plain objects so templates can read arbitrary fields
- // without hitting LegacyMode's strict schema check on cached records.
- if (raw.user_id != null) {
- attributes.user = lookup.user(raw.user_id);
- }
- if (raw.granted_by_id != null) {
- attributes.granted_by = lookup.user(raw.granted_by_id);
- }
- if (raw.topic_id != null) {
- attributes.topic = lookup.topic(raw.topic_id);
+ // without hitting LegacyMode's strict schema check on cached records. Assign
+ // only what this payload sideloads, or a thinner endpoint clears the rest.
+ for (const [name, entry] of [
+ ["user", lookup.user(raw.user_id)],
+ ["granted_by", lookup.user(raw.granted_by_id)],
+ ["topic", lookup.topic(raw.topic_id)],
+ ]) {
+ if (entry) {
+ attributes[name] = entry;
+ }
}
const relationships = {};
diff --git a/frontend/discourse/app/data/warp-rest-model.js b/frontend/discourse/app/data/warp-rest-model.js
index a910539657a..bf788d785dd 100644
--- a/frontend/discourse/app/data/warp-rest-model.js
+++ b/frontend/discourse/app/data/warp-rest-model.js
@@ -1,3 +1,4 @@
+import { dependentKeyCompat } from "@ember/object/compat";
import {
exposeExtraAttributes,
extraAttributesFor,
@@ -193,6 +194,11 @@ export function defineFieldForwarders(Klass, schema) {
}
};
}
- Object.defineProperty(proto, name, descriptor);
+ // Classic computed consumers observe the wrapper, not the cached record.
+ Object.defineProperty(
+ proto,
+ name,
+ dependentKeyCompat(proto, name, descriptor)
+ );
}
}
diff --git a/frontend/discourse/app/models/topic-details.js b/frontend/discourse/app/models/topic-details.js
index 772c5c9dd6a..1737d3d7e2f 100644
--- a/frontend/discourse/app/models/topic-details.js
+++ b/frontend/discourse/app/models/topic-details.js
@@ -1,5 +1,6 @@
import { tracked } from "@glimmer/tracking";
import EmberObject from "@ember/object";
+import { trackedArray } from "@ember/reactive/collections";
import {
removeAllowedTopicGroup,
removeAllowedTopicUser,
@@ -94,8 +95,12 @@ export default class TopicDetails extends RestCompatModel {
return;
}
const wrapped = { ...details };
+ // Inviting a user appends here in place; inviting a group reloads the
+ // topic instead, so `allowed_groups` needs no equivalent.
if (details.allowed_users) {
- wrapped.allowed_users = details.allowed_users.map((u) => User.create(u));
+ wrapped.allowed_users = trackedArray(
+ details.allowed_users.map((u) => User.create(u))
+ );
}
if (details.participants) {
const topic = this.topic;
@@ -134,8 +139,8 @@ export default class TopicDetails extends RestCompatModel {
await store.request(
removeAllowedTopicUser(this.#effectiveTopicId(), username)
);
- this.allowed_users = this.allowed_users.filter(
- (u) => u.username !== username
+ this.allowed_users = trackedArray(
+ this.allowed_users.filter((u) => u.username !== username)
);
}
}
diff --git a/frontend/discourse/app/models/user-badge.js b/frontend/discourse/app/models/user-badge.js
index d494c777aa4..78ecaf0cccd 100644
--- a/frontend/discourse/app/models/user-badge.js
+++ b/frontend/discourse/app/models/user-badge.js
@@ -1,3 +1,4 @@
+import { dependentKeyCompat } from "@ember/object/compat";
import {
findUserBadgesByBadgeId,
findUserBadgesByUsername,
@@ -16,6 +17,19 @@ import {
import { ajax } from "discourse/lib/ajax";
import { popupAjaxError } from "discourse/lib/ajax-error";
import Badge from "discourse/models/badge";
+import Topic from "discourse/models/topic";
+import User from "discourse/models/user";
+
+// Restores the setter these getters displace, shadowing the getter from then
+// on so admin's read-then-write `groupedBadges` doesn't trip Glimmer.
+function shadow(instance, name, value) {
+ Object.defineProperty(instance, name, {
+ value,
+ writable: true,
+ configurable: true,
+ enumerable: true,
+ });
+}
export default class UserBadge extends RestCompatModel {
static type = "user-badge";
@@ -38,36 +52,56 @@ export default class UserBadge extends RestCompatModel {
return requestOne(this, grantUserBadge(badgeId, username, reason));
}
- #badge;
- #badgeResource;
+ #wrappers = new Map();
- // Wraps the cached resource in a `Badge` so callers can read its computed
- // getters (`.url`, `.badgeTypeClassName`, ...). Memoized against that
- // resource — a fresh instance per read would fire `init` callbacks and break
- // identity — while the unconditional read keeps its tracked tag consumed.
+ // Consumers read class getters off these (`badge.url`, `topic.fancyTitle`,
+ // `user.statusManager`), which the cached plain objects lack. Copy before
+ // wrapping — `RestModel.create` stamps `__munge` onto its argument — and
+ // apply `@dependentKeyCompat` by hand, since `defineFieldForwarders` skips
+ // names already on the prototype.
+ @dependentKeyCompat
get badge() {
- const resource = this.__resource?.badge;
- if (resource !== this.#badgeResource) {
- this.#badgeResource = resource;
- this.#badge = resource ? new Badge(resource) : undefined;
- }
- return this.#badge;
+ return this.#wrap("badge", (raw) => new Badge(raw));
+ }
+
+ @dependentKeyCompat
+ get topic() {
+ return this.#wrap("topic", (raw) => Topic.create({ ...raw }));
+ }
+
+ set topic(value) {
+ shadow(this, "topic", value);
+ }
+
+ @dependentKeyCompat
+ get user() {
+ return this.#wrap("user", (raw) => User.create({ ...raw }));
+ }
+
+ set user(value) {
+ shadow(this, "user", value);
}
// Getter: null → undefined (test contract).
+ @dependentKeyCompat
get granted_by() {
return this.__resource?.granted_by ?? undefined;
}
- // Setter: shadows on the wrapper so admin's read-then-write `groupedBadges`
- // doesn't trip Glimmer.
set granted_by(value) {
- Object.defineProperty(this, "granted_by", {
- value,
- writable: true,
- configurable: true,
- enumerable: true,
- });
+ shadow(this, "granted_by", value);
+ }
+
+ // Memoized against the raw value: rebuilding per read would refire the
+ // model's `init` callbacks and hand out a new identity each render.
+ #wrap(name, build) {
+ const raw = this.__resource?.[name];
+ let cached = this.#wrappers.get(name);
+ if (!cached || cached.raw !== raw) {
+ cached = { raw, value: raw ? build(raw) : undefined };
+ this.#wrappers.set(name, cached);
+ }
+ return cached.value;
}
get grantedAt() {
diff --git a/frontend/discourse/tests/acceptance/badges-test.js b/frontend/discourse/tests/acceptance/badges-test.js
index 24e38afca22..136ca47de7a 100644
--- a/frontend/discourse/tests/acceptance/badges-test.js
+++ b/frontend/discourse/tests/acceptance/badges-test.js
@@ -1,7 +1,11 @@
import { click, visit } from "@ember/test-helpers";
import { test } from "qunit";
+import { cloneJSON } from "discourse/lib/object";
+import badgesFixtures from "discourse/tests/fixtures/badges-fixture";
+import userBadgesFixtures from "discourse/tests/fixtures/user-badges";
import { acceptance } from "discourse/tests/helpers/qunit-helpers";
import selectKit from "discourse/tests/helpers/select-kit-helper";
+import { i18n } from "discourse-i18n";
acceptance("Badges", function (needs) {
needs.user();
@@ -35,3 +39,118 @@ acceptance("Badges", function (needs) {
);
});
});
+
+acceptance("Badges - favorites", function (needs) {
+ needs.user();
+ needs.settings({ max_favorite_badges: 1 });
+
+ let isFavorite;
+ const firstButton = '[data-badge-slug="badge-8"] .favorite-btn';
+ const secondButton = '[data-badge-slug="custombadge"] .favorite-btn';
+
+ needs.hooks.beforeEach(() => {
+ isFavorite = false;
+ });
+
+ needs.pretender((server, helper) => {
+ server.get("/user-badges/eviltrout.json", () => {
+ const payload = cloneJSON(userBadgesFixtures["/user-badges/:username"]);
+ payload.badges.find((badge) => badge.id === 880).slug = "badge-8";
+ payload.badges.find((badge) => badge.id === 50).slug = "custombadge";
+ payload.user_badges.forEach((userBadge) => {
+ userBadge.can_favorite = true;
+ userBadge.is_favorite = userBadge.badge_id === 880 && isFavorite;
+ });
+ return helper.response(payload);
+ });
+ server.put("/user_badges/668/toggle_favorite", () => {
+ isFavorite = !isFavorite;
+ return helper.response({ user_badge: { is_favorite: isFavorite } });
+ });
+ });
+
+ test("favoriting a badge updates the count and enforces the limit", async function (assert) {
+ await visit("/u/eviltrout/badges");
+
+ assert
+ .dom(".favorite-count")
+ .hasText(
+ i18n("badges.favorite_count", { count: 0, max: 1 }),
+ "no badges are initially favorited"
+ );
+ assert.dom(secondButton).isEnabled("another badge can be favorited");
+
+ await click(firstButton);
+
+ assert.true(isFavorite, "the server receives the favorite request");
+ assert.dom(`${firstButton} .d-icon-star`).exists("the badge is favorited");
+ assert
+ .dom(".favorite-count")
+ .hasText(
+ i18n("badges.favorite_count", { count: 1, max: 1 }),
+ "the favorite count updates without reloading"
+ );
+ assert.dom(secondButton).isDisabled("the favorite limit is enforced");
+
+ await click(firstButton);
+
+ assert.false(isFavorite, "the server receives the unfavorite request");
+ assert
+ .dom(`${firstButton} .d-icon-far-star`)
+ .exists("the favorite is removed");
+ assert
+ .dom(".favorite-count")
+ .hasText(
+ i18n("badges.favorite_count", { count: 0, max: 1 }),
+ "the count stays reactive across consecutive toggles"
+ );
+ assert.dom(secondButton).isEnabled("the favorite slot is available again");
+ });
+});
+
+acceptance("Badges - granting post link", function (needs) {
+ needs.user();
+
+ needs.pretender((server, helper) => {
+ server.get("/user_badges.json", () => {
+ const payload = cloneJSON(badgesFixtures["/user_badges.json"]);
+ payload.topics = [
+ {
+ id: 280,
+ title: "A granting topic",
+ fancy_title: "A granting topic",
+ slug: "a-granting-topic",
+ posts_count: 3,
+ },
+ ];
+ payload.user_badges = [
+ {
+ ...payload.user_badges[0],
+ post_number: 2,
+ topic_id: 280,
+ },
+ // Topic the viewer can't see, so the sideload omits it: reading an
+ // absent sideload used to throw.
+ {
+ ...payload.user_badges[1],
+ post_number: 5,
+ topic_id: 999,
+ },
+ ];
+ return helper.response(payload);
+ });
+ });
+
+ test("links to the post that granted the badge", async function (assert) {
+ await visit("/badges/9/autobiographer");
+
+ assert
+ .dom(".badges-granted a.post-link")
+ .hasAttribute(
+ "href",
+ "/t/a-granting-topic/280/2",
+ "links to the granting post"
+ )
+ .hasText("A granting topic", "shows the topic title");
+ });
+});
diff --git a/frontend/discourse/tests/acceptance/personal-message-test.js b/frontend/discourse/tests/acceptance/personal-message-test.js
index e1e077de839..ddf5523d721 100644
--- a/frontend/discourse/tests/acceptance/personal-message-test.js
+++ b/frontend/discourse/tests/acceptance/personal-message-test.js
@@ -142,3 +142,81 @@ acceptance("Personal Message - email invite", function (needs) {
.doesNotExist("the invite modal closes instead of showing an empty body");
});
});
+
+acceptance("Personal Message - recipient updates", function (needs) {
+ needs.user();
+ needs.pretender((server, helper) => {
+ const user = {
+ id: 123,
+ username: "example",
+ name: "Example",
+ avatar_template: "/letter_avatar_proxy/v4/letter/e/999999/{size}.png",
+ };
+ server.get("/u/search/users", () => helper.response({ users: [user] }));
+ server.post("/t/12/invite", () => helper.response({ user }));
+ server.put("/t/12/remove-allowed-user", () =>
+ helper.response({ success: "OK" })
+ );
+ });
+
+ async function inviteExample() {
+ await click(".topic-map__private-message-map .add-participant-btn");
+ const input = selectKit(".invite-user-input");
+ await input.expand();
+ await input.fillInFilter("example");
+ await input.selectRowByValue("example");
+ await click(".send-invite");
+ }
+
+ const recipient =
+ '.topic-map__private-message-map [data-user-card="example"]';
+ const existingRecipient =
+ '.topic-map__private-message-map [data-user-card="someguy"]';
+ const retainedRecipient =
+ '.topic-map__private-message-map [data-user-card="test"]';
+
+ test("inviting a user updates the recipient list without reloading", async function (assert) {
+ await visit("/t/pm-for-testing/12");
+
+ assert.dom(recipient).doesNotExist("the invitee is not yet a recipient");
+ assert.dom(existingRecipient).exists("the existing recipient is present");
+ assert.dom(retainedRecipient).exists("the other recipient is present");
+
+ await inviteExample();
+
+ assert
+ .dom(".d-modal.add-pm-participants")
+ .doesNotExist("the invitation succeeds");
+ assert
+ .dom(recipient)
+ .exists("the invited user appears immediately in the recipient list");
+ assert.dom(existingRecipient).exists("the existing recipient is retained");
+ assert.dom(retainedRecipient).exists("the other recipient is retained");
+ });
+
+ test("inviting a user updates the recipient list after removing a recipient", async function (assert) {
+ await visit("/t/pm-for-testing/12");
+
+ assert.dom(existingRecipient).exists("the recipient is initially present");
+ await click(
+ '.topic-map__private-message-map [data-id="2"] .remove-invited'
+ );
+ assert
+ .dom(existingRecipient)
+ .doesNotExist("the previous recipient is removed");
+ assert.dom(recipient).doesNotExist("the invitee is not yet a recipient");
+
+ await inviteExample();
+
+ assert
+ .dom(".d-modal.add-pm-participants")
+ .doesNotExist("the invitation succeeds");
+ assert
+ .dom(recipient)
+ .exists("the invited user appears immediately in the recipient list");
+ assert
+ .dom(existingRecipient)
+ .doesNotExist("the removed recipient stays removed");
+ assert.dom(retainedRecipient).exists("the remaining recipient is retained");
+ });
+});
diff --git a/frontend/discourse/tests/integration/components/topic-map/private-message-map-test.gjs b/frontend/discourse/tests/integration/components/topic-map/private-message-map-test.gjs
new file mode 100644
index 00000000000..a78d88bfaab
--- /dev/null
+++ b/frontend/discourse/tests/integration/components/topic-map/private-message-map-test.gjs
@@ -0,0 +1,49 @@
+import { click, render } from "@ember/test-helpers";
+import { module, test } from "qunit";
+import PrivateMessageMap from "discourse/components/topic-map/private-message-map";
+import { setupRenderingTest } from "discourse/tests/helpers/component-test";
+import pretender, { response } from "discourse/tests/helpers/create-pretender";
+
+module(
+ "Integration | Component | TopicMap | PrivateMessageMap",
+ function (hooks) {
+ setupRenderingTest(hooks);
+
+ test("removing a group recipient updates the map without reloading", async function (assert) {
+ const topic = this.owner
+ .lookup("service:store")
+ .createRecord("topic", { id: 123 });
+ const details = topic.details;
+ details.updateFromJson({
+ allowed_groups: [
+ { id: 41, name: "first-group" },
+ { id: 42, name: "second-group" },
+ ],
+ allowed_users: [],
+ can_remove_allowed_users: true,
+ });
+ const removeAllowedGroup = (group) => details.removeAllowedGroup(group);
+ pretender.put("/t/123/remove-allowed-group", () =>
+ response({ success: "OK" })
+ );
+
+ await render(
+ <template>
+ <PrivateMessageMap
+ @removeAllowedGroup={{removeAllowedGroup}}
+ @topicDetails={{details}}
+ />
+ </template>
+ );
+
+ assert.dom(".group").exists({ count: 2 }, "both groups are rendered");
+
+ await click('.group[data-id="41"] .remove-invited');
+
+ assert
+ .dom('.group[data-id="41"]')
+ .doesNotExist("the removed group disappears immediately");
+ assert.dom('.group[data-id="42"]').exists("other groups are retained");
+ });
+ }
+);
diff --git a/frontend/discourse/tests/unit/data/warp-rest-model-test.js b/frontend/discourse/tests/unit/data/warp-rest-model-test.js
new file mode 100644
index 00000000000..98ffd32a2c8
--- /dev/null
+++ b/frontend/discourse/tests/unit/data/warp-rest-model-test.js
@@ -0,0 +1,58 @@
+import EmberObject, { computed, get } from "@ember/object";
+import { settled } from "@ember/test-helpers";
+import { setupTest } from "ember-qunit";
+import { module, test } from "qunit";
+import Badge from "discourse/models/badge";
+
+module("Unit | Data | warp-rest-model", function (hooks) {
+ setupTest(hooks);
+
+ test("schema forwarders invalidate classic computed consumers on cache updates and assignment", async function (assert) {
+ const store = this.owner.lookup("service:warp-store");
+ const badge = Badge.createFromJson({ badge: { id: 123, name: "Before" } });
+ class Consumer extends EmberObject {
+ @computed("badge.name")
+ get label() {
+ return this.badge.name;
+ }
+ }
+ const consumer = Consumer.create({ badge });
+
+ assert.strictEqual(
+ get(consumer, "label"),
+ "Before",
+ "the computed value is initially cached"
+ );
+
+ store.push({
+ data: { type: "badge", id: "123", attributes: { name: "From server" } },
+ });
+ await settled();
+
+ assert.strictEqual(
+ get(consumer, "label"),
+ "From server",
+ "a cache update invalidates the wrapper's dependent key"
+ );
+
+ badge.name = "From assignment";
+ await settled();
+
+ assert.strictEqual(
+ get(consumer, "label"),
+ "From assignment",
+ "assignment also invalidates the classic computed value"
+ );
+ assert.strictEqual(
+ get(badge, "name"),
+ "From assignment",
+ "the forwarder remains writable"
+ );
+ assert.strictEqual(
+ store.peekRecord({ type: "badge", id: "123" }).name,
+ "From assignment",
+ "assignment updates the cached record"
+ );
+ consumer.destroy();
+ });
+});
diff --git a/frontend/discourse/tests/unit/models/user-badge-test.js b/frontend/discourse/tests/unit/models/user-badge-test.js
index 723b06ee828..1d531362911 100644
--- a/frontend/discourse/tests/unit/models/user-badge-test.js
+++ b/frontend/discourse/tests/unit/models/user-badge-test.js
@@ -42,6 +42,51 @@ module("Unit | Model | user-badge", function (hooks) {
);
});
+ test("wraps sideloaded topic and user in their model classes", function (assert) {
+ const payload = cloneJSON(badgeFixtures["/user_badges"]);
+ payload.user_badge.user_id = 13470;
+ payload.user_badge.topic_id = 280;
+ payload.topics = [
+ { id: 280, title: "A granting topic", slug: "a-granting-topic" },
+ ];
+
+ const userBadge = UserBadge.createFromJson(payload);
+
+ assert.strictEqual(
+ userBadge.topic.url,
+ "/t/a-granting-topic/280",
+ "topic exposes `Topic` getters"
+ );
+ assert.strictEqual(
+ userBadge.user.path,
+ "/u/anne3",
+ "user exposes `User` getters"
+ );
+
+ const topic = userBadge.topic;
+ assert.strictEqual(userBadge.topic, topic, "reuses the same wrapper");
+ });
+
+ test("keeps sideloads that a later payload doesn't carry", function (assert) {
+ const withTopic = cloneJSON(badgeFixtures["/user_badges"]);
+ withTopic.user_badge.topic_id = 280;
+ withTopic.topics = [
+ { id: 280, title: "A granting topic", slug: "a-granting-topic" },
+ ];
+ UserBadge.createFromJson(withTopic);
+
+ // `/user-badges/:username` sends `topic_id` but no `topics` sideload.
+ const withoutTopic = cloneJSON(badgeFixtures["/user_badges"]);
+ withoutTopic.user_badge.topic_id = 280;
+ const userBadge = UserBadge.createFromJson(withoutTopic);
+
+ assert.strictEqual(
+ userBadge.topic.url,
+ "/t/a-granting-topic/280",
+ "the topic from the earlier payload survives"
+ );
+ });
+
test("findByUsername", async function (assert) {
const badges = await UserBadge.findByUsername("anne3");
assert.true(Array.isArray(badges), "returns an array");