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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.+ @dependentKeyCompatget 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).+ @dependentKeyCompatget 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.jsindex 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.jsindex 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.gjsnew file mode 100644index 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.jsnew file mode 100644index 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.jsindex 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");