Skip to content

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

DEV: Convert `Group` to TypeScript (#45190)

Sérgio Saquetim7624d2c1d12c
diff --git a/frontend/discourse/app/models/group.js b/frontend/discourse/app/models/group.js
deleted file mode 100644
index bedca7521da..00000000000
--- a/frontend/discourse/app/models/group.js
+++ /dev/null
@@ -1,527 +0,0 @@
-/* eslint-disable ember/no-observers */
-import EmberObject, { computed } from "@ember/object";
-import { dependentKeyCompat } from "@ember/object/compat";
-import { trackedArray } from "@ember/reactive/collections";
-import { isEmpty } from "@ember/utils";
-import { observes } from "@ember-decorators/object";
-import { ajax } from "discourse/lib/ajax";
-import {
- applyModelCallbacks,
- extraSavePropertiesFor,
-} from "discourse/lib/model-extensions";
-import { autoTrackedArray } from "discourse/lib/tracked-tools";
-import { applyValueTransformer } from "discourse/lib/transformer";
-import Category from "discourse/models/category";
-import GroupHistory from "discourse/models/group-history";
-import RestModel from "discourse/models/rest";
-import Site from "discourse/models/site";
-import Topic from "discourse/models/topic";
-import User from "discourse/models/user";
-
-export default class Group extends RestModel {
- static findAll(opts) {
- return ajax("/groups/search.json", { data: opts }).then((groups) =>
- groups.map((g) => Group.create(g))
- );
- }
-
- static loadMembers(name, opts) {
- const data = applyValueTransformer("group-members-request", opts, { name });
- return ajax(`/groups/${name}/members.json`, { data });
- }
-
- static mentionable(name) {
- return ajax(`/groups/${name}/mentionable`);
- }
-
- static messageable(name) {
- return ajax(`/groups/${name}/messageable`);
- }
-
- static checkName(name) {
- return ajax("/groups/check-name", { data: { group_name: name } });
- }
-
- @autoTrackedArray members = [];
- @autoTrackedArray requesters = [];
-
- user_count = 0;
-
- /** @type {number | null} */
- limit = null;
-
- /** @type {number | null} */
- offset = null;
- request_count = 0;
-
- /** @type {number | null} */
- requestersLimit = null;
-
- /** @type {number | null} */
- requestersOffset = null;
-
- @dependentKeyCompat
- get watchingCategories() {
- if (
- this.site.lazy_load_categories &&
- this.watching_category_ids &&
- !Category.hasAsyncFoundAll(this.watching_category_ids)
- ) {
- Category.asyncFindByIds(this.watching_category_ids).then(() =>
- this.notifyPropertyChange("watching_category_ids")
- );
- }
-
- return Category.findByIds(this.get("watching_category_ids"));
- }
-
- set watchingCategories(categories) {
- this.set(
- "watching_category_ids",
- categories.map((c) => c.id)
- );
- }
-
- @dependentKeyCompat
- get trackingCategories() {
- if (
- this.site.lazy_load_categories &&
- this.tracking_category_ids &&
- !Category.hasAsyncFoundAll(this.tracking_category_ids)
- ) {
- Category.asyncFindByIds(this.tracking_category_ids).then(() =>
- this.notifyPropertyChange("tracking_category_ids")
- );
- }
-
- return Category.findByIds(this.get("tracking_category_ids"));
- }
-
- set trackingCategories(categories) {
- this.set(
- "tracking_category_ids",
- categories.map((c) => c.id)
- );
- }
-
- @dependentKeyCompat
- get watchingFirstPostCategories() {
- if (
- this.site.lazy_load_categories &&
- this.watching_first_post_category_ids &&
- !Category.hasAsyncFoundAll(this.watching_first_post_category_ids)
- ) {
- Category.asyncFindByIds(this.watching_first_post_category_ids).then(() =>
- this.notifyPropertyChange("watching_first_post_category_ids")
- );
- }
-
- return Category.findByIds(this.get("watching_first_post_category_ids"));
- }
-
- set watchingFirstPostCategories(categories) {
- this.set(
- "watching_first_post_category_ids",
- categories.map((c) => c.id)
- );
- }
-
- @dependentKeyCompat
- get regularCategories() {
- if (
- this.site.lazy_load_categories &&
- this.regular_category_ids &&
- !Category.hasAsyncFoundAll(this.regular_category_ids)
- ) {
- Category.asyncFindByIds(this.regular_category_ids).then(() =>
- this.notifyPropertyChange("regular_category_ids")
- );
- }
-
- return Category.findByIds(this.get("regular_category_ids"));
- }
-
- set regularCategories(categories) {
- this.set(
- "regular_category_ids",
- categories.map((c) => c.id)
- );
- }
-
- @dependentKeyCompat
- get mutedCategories() {
- if (
- this.site.lazy_load_categories &&
- this.muted_category_ids &&
- !Category.hasAsyncFoundAll(this.muted_category_ids)
- ) {
- Category.asyncFindByIds(this.muted_category_ids).then(() =>
- this.notifyPropertyChange("muted_category_ids")
- );
- }
-
- return Category.findByIds(this.get("muted_category_ids"));
- }
-
- set mutedCategories(categories) {
- this.set(
- "muted_category_ids",
- categories.map((c) => c.id)
- );
- }
-
- @computed("mentionable_level")
- get canEveryoneMention() {
- return this.mentionable_level === 99;
- }
-
- @computed("automatic_membership_email_domains")
- get emailDomains() {
- return isEmpty(this.automatic_membership_email_domains)
- ? ""
- : this.automatic_membership_email_domains;
- }
-
- @computed("associated_group_ids")
- get associatedGroupIds() {
- return isEmpty(this.associated_group_ids) ? [] : this.associated_group_ids;
- }
-
- @computed("automatic")
- get type() {
- return this.automatic ? "automatic" : "custom";
- }
-
- @computed("display_name", "name")
- get displayName() {
- return this.display_name || this.name;
- }
-
- @computed("flair_bg_color")
- get flairBackgroundHexColor() {
- return this.flair_bg_color
- ? this.flair_bg_color.replace(new RegExp("[^0-9a-fA-F]", "g"), "")
- : null;
- }
-
- @computed("flair_color")
- get flairHexColor() {
- return this.flair_color
- ? this.flair_color.replace(new RegExp("[^0-9a-fA-F]", "g"), "")
- : null;
- }
-
- @computed("visibility_level")
- get isPrivate() {
- return this.visibility_level > 1;
- }
-
- async reloadMembers(params, refresh) {
- if (isEmpty(this.name) || !this.can_see_members) {
- return;
- }
-
- if (refresh) {
- this.setProperties({ limit: null, offset: null, members: [] });
- }
-
- params = { offset: (this.offset || 0) + (this.limit || 0), ...params };
-
- const response = await Group.loadMembers(this.name, params);
- const ownerIds = new Set();
- response.owners.forEach((owner) => ownerIds.add(owner.id));
-
- this.members.push(
- ...response.members.map((member) => {
- member.owner = ownerIds.has(member.id);
- member.primary = member.primary_group_name === this.name;
- return User.create(member);
- })
- );
-
- this.setProperties({
- user_count: response.meta.total,
- limit: response.meta.limit,
- offset: response.meta.offset,
- });
- }
-
- async findRequesters(params, refresh) {
- if (isEmpty(this.name) || !this.can_see_members) {
- throw new Error();
- }
-
- if (refresh) {
- this.setProperties({
- requesters: [],
- requestersOffset: null,
- requestersLimit: null,
- });
- }
-
- params = {
- offset: (this.requestersOffset || 0) + (this.requestersLimit || 0),
- requesters: true,
- ...params,
- };
-
- const result = await Group.loadMembers(this.name, params);
- this.requesters.push(...result.members.map((m) => User.create(m)));
-
- this.setProperties({
- request_count: result.meta.total,
- requestersLimit: result.meta.limit,
- requestersOffset: result.meta.offset,
- });
- }
-
- async removeOwner(member) {
- await ajax(`/admin/groups/${this.id}/owners.json`, {
- type: "DELETE",
- data: { user_id: member.id },
- });
- await this.reloadMembers({}, true);
- }
-
- async removeMember(member, params) {
- await ajax(`/groups/${this.id}/members.json`, {
- type: "DELETE",
- data: { user_id: member.id },
- });
- await this.reloadMembers(params, true);
- }
-
- async leave() {
- await ajax(`/groups/${this.id}/leave.json`, {
- type: "DELETE",
- });
- this.set("can_see_members", this.members_visibility_level < 2);
- await this.reloadMembers({}, true);
- }
-
- async addMembers(usernames, filter, notifyUsers, emails = []) {
- const response = await ajax(`/groups/${this.id}/members.json`, {
- type: "PUT",
- data: { usernames, emails, notify_users: notifyUsers },
- });
- if (filter) {
- await this._filterMembers(response.usernames);
- } else {
- await this.reloadMembers();
- }
- }
-
- async join() {
- await ajax(`/groups/${this.id}/join.json`, {
- type: "PUT",
- });
- await this.reloadMembers({}, true);
- }
-
- async addOwners(usernames, filter, notifyUsers) {
- const response = await ajax(`/groups/${this.id}/owners.json`, {
- type: "PUT",
- data: { usernames, notify_users: notifyUsers },
- });
-
- if (filter) {
- await this._filterMembers(response.usernames);
- } else {
- await this.reloadMembers({}, true);
- }
- }
-
- asJSON() {
- const attrs = {
- name: this.name,
- mentionable_level: this.mentionable_level,
- messageable_level: this.messageable_level,
- visibility_level: this.visibility_level,
- members_visibility_level: this.members_visibility_level,
- automatic_membership_email_domains: this.emailDomains,
- title: this.title,
- primary_group: !!this.primary_group,
- grant_trust_level: this.grant_trust_level,
- incoming_email: this.incoming_email,
- smtp_server: this.smtp_server,
- smtp_port: this.smtp_port,
- smtp_ssl_mode: this.smtp_ssl_mode,
- smtp_enabled: this.smtp_enabled,
- email_username: this.email_username,
- email_from_alias: this.email_from_alias,
- email_password: this.email_password,
- flair_icon: /** @type {string | null} */ (null),
- flair_upload_id: /** @type {number | null} */ (null),
- flair_bg_color: this.flairBackgroundHexColor,
- flair_color: this.flairHexColor,
- bio_raw: this.bio_raw,
- public_admission: this.public_admission,
- public_exit: this.public_exit,
- allow_membership_requests: this.allow_membership_requests,
- full_name: this.full_name,
- default_notification_level: this.default_notification_level,
- membership_request_template: this.membership_request_template,
- publish_read_state: this.publish_read_state,
- allow_unknown_sender_topic_replies:
- this.allow_unknown_sender_topic_replies,
- };
-
- ["muted", "regular", "watching", "tracking", "watching_first_post"].forEach(
- (s) => {
- let prop =
- s === "watching_first_post"
- ? "watchingFirstPostCategories"
- : s + "Categories";
-
- let categories = this.get(prop);
-
- if (categories) {
- attrs[s + "_category_ids"] =
- categories.length > 0 ? categories.map((c) => c.get("id")) : [-1];
- }
-
- let tags = this.get(s + "_tags");
-
- if (tags) {
- attrs[s + "_tags"] =
- tags.length > 0
- ? tags.map((t) => (typeof t === "object" ? t.name : t))
- : [""];
- }
- }
- );
-
- let agIds = this.associated_group_ids;
- if (agIds) {
- attrs["associated_group_ids"] = agIds.length ? agIds : [null];
- }
-
- if (this.flair_type === "icon") {
- attrs["flair_icon"] = this.flair_icon;
- } else if (this.flair_type === "image") {
- attrs["flair_upload_id"] = this.flair_upload_id;
- }
-
- if (!this.id) {
- attrs["usernames"] = this.usernames;
- attrs["owner_usernames"] = this.ownerUsernames;
- }
-
- return { ...attrs, ...extraSavePropertiesFor("group", this) };
- }
-
- /**
- * Creates the group on the server.
- *
- * @returns {Promise<object>} The created group, as the server serializes it.
- */
- async create() {
- await applyModelCallbacks("group", "beforeCreate", this);
-
- const response = await ajax("/admin/groups", {
- type: "POST",
- data: { group: this.asJSON() },
- });
-
- this.setProperties({
- id: response.basic_group.id,
- usernames: null,
- ownerUsernames: null,
- });
-
- await this.reloadMembers();
- await applyModelCallbacks("group", "afterCreate", this, response);
- return response.basic_group;
- }
-
- async save(opts = {}) {
- await applyModelCallbacks("group", "beforeUpdate", this, opts);
-
- const result = await ajax(`/groups/${this.id}`, {
- type: "PUT",
- data: { group: this.asJSON(), ...opts },
- });
-
- await applyModelCallbacks("group", "afterUpdate", this, result);
- return result;
- }
-
- async destroy() {
- if (!this.id) {
- return;
- }
-
- await applyModelCallbacks("group", "beforeDestroy", this);
- const result = await ajax(`/admin/groups/${this.id}`, { type: "DELETE" });
- await applyModelCallbacks("group", "afterDestroy", this, result);
- return result;
- }
-
- findLogs(offset, filters) {
- return ajax(`/groups/${this.name}/logs.json`, {
- data: { offset, filters },
- }).then((results) => {
- return EmberObject.create({
- logs: trackedArray(
- results["logs"].map((log) => GroupHistory.create(log))
- ),
- all_loaded: results["all_loaded"],
- });
- });
- }
-
- async findPosts(opts) {
- opts = opts || {};
- const type = opts.type || "posts";
- const data = {};
-
- if (opts.before) {
- data.before = opts.before;
- }
-
- if (opts.categoryId) {
- data.category_id = parseInt(opts.categoryId, 10);
- }
-
- const result = await ajax(`/groups/${this.name}/${type}.json`, { data });
-
- result.categories?.forEach((category) => {
- Site.current().updateCategory(category);
- });
-
- return trackedArray(
- result.posts.map((p) => {
- p.user = User.create(p.user);
- p.topic = Topic.create(p.topic);
- p.category = Category.findById(p.category_id);
- return EmberObject.create(p);
- })
- );
- }
-
- setNotification(notification_level, userId) {
- this.set("group_user.notification_level", notification_level);
- return ajax(`/groups/${this.name}/notifications`, {
- data: { notification_level, user_id: userId },
- type: "POST",
- });
- }
-
- requestMembership(reason) {
- return ajax(`/groups/${this.name}/request_membership.json`, {
- type: "POST",
- data: { reason },
- });
- }
-
- _filterMembers(usernames) {
- return this.reloadMembers({ filter: usernames.join(",") });
- }
-
- @observes("isPrivate", "canEveryoneMention")
- _updateAllowMembershipRequests() {
- if (this.isPrivate || !this.canEveryoneMention) {
- this.set("allow_membership_requests", false);
- }
- }
-}
diff --git a/frontend/discourse/app/models/group.ts b/frontend/discourse/app/models/group.ts
new file mode 100644
index 00000000000..037d5e5d1e6
--- /dev/null
+++ b/frontend/discourse/app/models/group.ts
@@ -0,0 +1,784 @@
+/* eslint-disable ember/no-observers */
+/* eslint-disable prefer-const -- Preserve bindings in this types-only port. */
+import EmberObject, { computed } from "@ember/object";
+import { dependentKeyCompat } from "@ember/object/compat";
+import { trackedArray } from "@ember/reactive/collections";
+import { isEmpty } from "@ember/utils";
+import { observes } from "@ember-decorators/object";
+import { ajax } from "discourse/lib/ajax";
+import {
+ applyModelCallbacks,
+ extraSavePropertiesFor,
+} from "discourse/lib/model-extensions";
+import { autoTrackedArray } from "discourse/lib/tracked-tools";
+import { applyValueTransformer } from "discourse/lib/transformer";
+import Category, { type CategoryFields } from "discourse/models/category";
+import GroupHistory from "discourse/models/group-history";
+import RestModel, { type RestModelAttrs } from "discourse/models/rest";
+import Site from "discourse/models/site";
+import Topic, { type TopicBasicUser } from "discourse/models/topic";
+import User, { type UserCreateAttrs } from "discourse/models/user";
+
+/** Data shared by list, search and show payloads; new groups can omit server fields. */
+export interface GroupFields {
+ id?: number;
+ name?: string;
+ automatic?: boolean;
+ display_name?: string | null;
+ mentionable_level?: number | null;
+ messageable_level?: number | null;
+ visibility_level?: number;
+ members_visibility_level?: number;
+ primary_group?: boolean;
+ title?: string | null;
+ full_name?: string | null;
+ grant_trust_level?: number | null;
+ incoming_email?: string | null;
+ has_messages?: boolean;
+ flair_url?: string | null;
+ flair_bg_color?: string | null;
+ flair_color?: string | null;
+ bio_raw?: string | null;
+ bio_cooked?: string | null;
+ bio_excerpt?: string | null;
+ public_admission?: boolean;
+ public_exit?: boolean;
+ allow_membership_requests?: boolean;
+ default_notification_level?: number;
+ membership_request_template?: string | null;
+ is_group_user?: boolean;
+ is_group_owner?: boolean;
+ is_group_owner_display?: boolean;
+ can_see_members?: boolean;
+ can_admin_group?: boolean;
+ can_edit_group?: boolean;
+ publish_read_state?: boolean;
+ mentionable?: boolean;
+ messageable?: boolean;
+ automatic_membership_email_domains?: string | null;
+ smtp_server?: string | null;
+ smtp_port?: number | null;
+ smtp_ssl_mode?: number;
+ smtp_enabled?: boolean | null;
+ smtp_updated_at?: string | null;
+ smtp_updated_by?: TopicBasicUser | null;
+ email_username?: string | null;
+ email_password?: string | null;
+ email_from_alias?: string | null;
+ message_count?: number;
+ allow_unknown_sender_topic_replies?: boolean;
+ associated_group_ids?: number[];
+ watching_category_ids?: number[];
+ tracking_category_ids?: number[];
+ watching_first_post_category_ids?: number[];
+ regular_category_ids?: number[];
+ muted_category_ids?: number[];
+ watching_tags?: GroupTag[];
+ tracking_tags?: GroupTag[];
+ watching_first_post_tags?: GroupTag[];
+ regular_tags?: GroupTag[];
+ muted_tags?: GroupTag[];
+ /** Attached during profile hydration, absent on ordinary group responses. */
+ group_user?: {
+ user_id: number;
+ group_id: number;
+ notification_level: number;
+ owner?: boolean;
+ };
+ /** Editable client state, cleared after creation. */
+ usernames?: string | string[] | null;
+ ownerUsernames?: string | null;
+ flair_type?: "icon" | "image";
+ flair_icon?: string | null;
+ flair_upload_id?: number | null;
+}
+
+/** Show payloads supply tag objects; the tag chooser also writes names. */
+export type GroupTag = { id: number; name: string; slug: string } | string;
+
+type NotificationLevel =
+ | "muted"
+ | "regular"
+ | "watching"
+ | "tracking"
+ | "watching_first_post";
+
+/** Empty selections use the API's category, tag and association sentinels. */
+export type GroupSaveAttrs = Omit<
+ GroupFields,
+ | `${NotificationLevel}_tags`
+ | `${NotificationLevel}_category_ids`
+ | "associated_group_ids"
+> & {
+ name: string | undefined;
+ primary_group: boolean;
+ associated_group_ids?: (number | null)[];
+ owner_usernames?: string | null;
+} & Partial<Record<`${NotificationLevel}_tags`, string[]>> &
+ Partial<Record<`${NotificationLevel}_category_ids`, (number | undefined)[]>>;
+
+export interface GroupSaveOptions {
+ update_existing_users?: boolean;
+ [key: string]: unknown;
+}
+
+export interface GroupMemberParams {
+ order?: string | null;
+ asc?: boolean;
+ filter?: string | null;
+ limit?: number;
+ offset?: number;
+ requesters?: boolean;
+}
+
+export interface GroupMembersResponse {
+ members: UserCreateAttrs[];
+ owners: UserCreateAttrs[];
+ meta: { total: number; limit: number; offset: number };
+}
+
+export interface GroupRequestersResponse {
+ members: (UserCreateAttrs & {
+ reason: string | null;
+ requested_at: string;
+ })[];
+ meta: GroupMembersResponse["meta"];
+}
+
+/** Activity entries are EmberObjects, not Post instances. */
+export interface GroupPostFields {
+ id: number;
+ created_at: string;
+ topic_id: number;
+ topic_title: string;
+ topic_slug: string;
+ topic_html_title: string;
+ url: string;
+ category_id: number | null;
+ post_number: number;
+ posts_count: number;
+ post_type: number;
+ user_id: number | null;
+ username: string | null;
+ name?: string | null;
+ avatar_template: string | null;
+ user_title: string | null;
+ primary_group_name: string | null;
+ excerpt: string | null;
+ truncated?: true;
+ user: User;
+ topic: Topic;
+ category?: Category;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/no-unsafe-declaration-merging
+export default interface Group extends GroupFields {}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+export default class Group extends RestModel {
+ static findAll(opts?: {
+ term?: string;
+ ignore_automatic?: boolean;
+ include_everyone?: boolean;
+ }): Promise<Group[]> {
+ return ajax("/groups/search.json", { data: opts }).then(
+ (groups: RestModelAttrs<Group>[]) => groups.map((g) => Group.create(g))
+ );
+ }
+
+ static loadMembers(
+ name: string | undefined,
+ opts: GroupMemberParams & { requesters: true }
+ ): Promise<GroupRequestersResponse>;
+
+ static loadMembers(
+ name: string | undefined,
+ opts?: GroupMemberParams & { requesters?: false }
+ ): Promise<GroupMembersResponse>;
+
+ static loadMembers(
+ name: string | undefined,
+ opts?: GroupMemberParams
+ ): Promise<GroupMembersResponse | GroupRequestersResponse>;
+
+ static loadMembers(
+ name: string | undefined,
+ opts?: GroupMemberParams
+ ): Promise<GroupMembersResponse | GroupRequestersResponse> {
+ const data = applyValueTransformer("group-members-request", opts, { name });
+ return ajax(`/groups/${name}/members.json`, { data });
+ }
+
+ static mentionable(name: string): Promise<{ mentionable: boolean }> {
+ return ajax(`/groups/${name}/mentionable`);
+ }
+
+ static messageable(name: string): Promise<{ messageable: boolean }> {
+ return ajax(`/groups/${name}/messageable`);
+ }
+
+ static checkName(name: string): Promise<{
+ available?: boolean;
+ suggestion?: string;
+ is_developer?: boolean;
+ errors?: string[];
+ }> {
+ return ajax("/groups/check-name", { data: { group_name: name } });
+ }
+
+ @autoTrackedArray members: User[] = [];
+ @autoTrackedArray requesters: User[] = [];
+
+ user_count = 0;
+
+ limit: number | null = null;
+
+ offset: number | null = null;
+ request_count = 0;
+
+ requestersLimit: number | null = null;
+
+ requestersOffset: number | null = null;
+
+ @dependentKeyCompat
+ get watchingCategories() {
+ if (
+ this.site.lazy_load_categories &&
+ this.watching_category_ids &&
+ !Category.hasAsyncFoundAll(this.watching_category_ids)
+ ) {
+ Category.asyncFindByIds(this.watching_category_ids).then(() =>
+ this.notifyPropertyChange("watching_category_ids")
+ );
+ }
+
+ return Category.findByIds(this.get("watching_category_ids"));
+ }
+
+ set watchingCategories(categories: Category[]) {
+ this.set(
+ "watching_category_ids",
+ categories.map((c) => c.id)
+ );
+ }
+
+ @dependentKeyCompat
+ get trackingCategories() {
+ if (
+ this.site.lazy_load_categories &&
+ this.tracking_category_ids &&
+ !Category.hasAsyncFoundAll(this.tracking_category_ids)
+ ) {
+ Category.asyncFindByIds(this.tracking_category_ids).then(() =>
+ this.notifyPropertyChange("tracking_category_ids")
+ );
+ }
+
+ return Category.findByIds(this.get("tracking_category_ids"));
+ }
+
+ set trackingCategories(categories: Category[]) {
+ this.set(
+ "tracking_category_ids",
+ categories.map((c) => c.id)
+ );
+ }
+
+ @dependentKeyCompat
+ get watchingFirstPostCategories() {
+ if (
+ this.site.lazy_load_categories &&
+ this.watching_first_post_category_ids &&
+ !Category.hasAsyncFoundAll(this.watching_first_post_category_ids)
+ ) {
+ Category.asyncFindByIds(this.watching_first_post_category_ids).then(() =>
+ this.notifyPropertyChange("watching_first_post_category_ids")
+ );
+ }
+
+ return Category.findByIds(this.get("watching_first_post_category_ids"));
+ }
+
+ set watchingFirstPostCategories(categories: Category[]) {
+ this.set(
+ "watching_first_post_category_ids",
+ categories.map((c) => c.id)
+ );
+ }
+
+ @dependentKeyCompat
+ get regularCategories() {
+ if (
+ this.site.lazy_load_categories &&
+ this.regular_category_ids &&
+ !Category.hasAsyncFoundAll(this.regular_category_ids)
+ ) {
+ Category.asyncFindByIds(this.regular_category_ids).then(() =>
+ this.notifyPropertyChange("regular_category_ids")
+ );
+ }
+
+ return Category.findByIds(this.get("regular_category_ids"));
+ }
+
+ set regularCategories(categories: Category[]) {
+ this.set(
+ "regular_category_ids",
+ categories.map((c) => c.id)
+ );
+ }
+
+ @dependentKeyCompat
+ get mutedCategories() {
+ if (
+ this.site.lazy_load_categories &&
+ this.muted_category_ids &&
+ !Category.hasAsyncFoundAll(this.muted_category_ids)
+ ) {
+ Category.asyncFindByIds(this.muted_category_ids).then(() =>
+ this.notifyPropertyChange("muted_category_ids")
+ );
+ }
+
+ return Category.findByIds(this.get("muted_category_ids"));
+ }
+
+ set mutedCategories(categories: Category[]) {
+ this.set(
+ "muted_category_ids",
+ categories.map((c) => c.id)
+ );
+ }
+
+ @computed("mentionable_level")
+ get canEveryoneMention() {
+ return this.mentionable_level === 99;
+ }
+
+ @computed("automatic_membership_email_domains")
+ get emailDomains(): string {
+ return isEmpty(this.automatic_membership_email_domains)
+ ? ""
+ : this.automatic_membership_email_domains!;
+ }
+
+ @computed("associated_group_ids")
+ get associatedGroupIds(): number[] {
+ return isEmpty(this.associated_group_ids) ? [] : this.associated_group_ids!;
+ }
+
+ @computed("automatic")
+ get type(): "automatic" | "custom" {
+ return this.automatic ? "automatic" : "custom";
+ }
+
+ @computed("display_name", "name")
+ get displayName() {
+ return this.display_name || this.name;
+ }
+
+ @computed("flair_bg_color")
+ get flairBackgroundHexColor() {
+ return this.flair_bg_color
+ ? this.flair_bg_color.replace(new RegExp("[^0-9a-fA-F]", "g"), "")
+ : null;
+ }
+
+ @computed("flair_color")
+ get flairHexColor() {
+ return this.flair_color
+ ? this.flair_color.replace(new RegExp("[^0-9a-fA-F]", "g"), "")
+ : null;
+ }
+
+ @computed("visibility_level")
+ get isPrivate() {
+ return this.visibility_level! > 1;
+ }
+
+ async reloadMembers(
+ params?: GroupMemberParams,
+ refresh?: boolean
+ ): Promise<void> {
+ if (isEmpty(this.name) || !this.can_see_members) {
+ return;
+ }
+
+ if (refresh) {
+ this.setProperties({ limit: null, offset: null, members: [] });
+ }
+
+ params = { offset: (this.offset || 0) + (this.limit || 0), ...params };
+
+ // This path assumes owners are present even if params overrides requesters.
+ const response = (await Group.loadMembers(
+ this.name,
+ params
+ )) as GroupMembersResponse;
+ const ownerIds = new Set();
+ response.owners.forEach((owner) => ownerIds.add(owner.id));
+
+ this.members.push(
+ ...response.members.map((member) => {
+ member.owner = ownerIds.has(member.id);
+ member.primary = member.primary_group_name === this.name;
+ return User.create(member);
+ })
+ );
+
+ this.setProperties({
+ user_count: response.meta.total,
+ limit: response.meta.limit,
+ offset: response.meta.offset,
+ });
+ }
+
+ async findRequesters(
+ params?: GroupMemberParams,
+ refresh?: boolean
+ ): Promise<void> {
+ if (isEmpty(this.name) || !this.can_see_members) {
+ throw new Error();
+ }
+
+ if (refresh) {
+ this.setProperties({
+ requesters: [],
+ requestersOffset: null,
+ requestersLimit: null,
+ });
+ }
+
+ params = {
+ offset: (this.requestersOffset || 0) + (this.requestersLimit || 0),
+ requesters: true,
+ ...params,
+ };
+
+ const result = await Group.loadMembers(this.name, params);
+ this.requesters.push(...result.members.map((m) => User.create(m)));
+
+ this.setProperties({
+ request_count: result.meta.total,
+ requestersLimit: result.meta.limit,
+ requestersOffset: result.meta.offset,
+ });
+ }
+
+ async removeOwner(member: Pick<User, "id">): Promise<void> {
+ await ajax(`/admin/groups/${this.id}/owners.json`, {
+ type: "DELETE",
+ data: { user_id: member.id },
+ });
+ await this.reloadMembers({}, true);
+ }
+
+ async removeMember(
+ member: Pick<User, "id">,
+ params?: GroupMemberParams
+ ): Promise<void> {
+ await ajax(`/groups/${this.id}/members.json`, {
+ type: "DELETE",
+ data: { user_id: member.id },
+ });
+ await this.reloadMembers(params, true);
+ }
+
+ async leave() {
+ await ajax(`/groups/${this.id}/leave.json`, {
+ type: "DELETE",
+ });
+ this.set("can_see_members", this.members_visibility_level! < 2);
+ await this.reloadMembers({}, true);
+ }
+
+ async addMembers(
+ usernames: string | string[],
+ filter?: boolean,
+ notifyUsers?: boolean,
+ emails: string | string[] = []
+ ): Promise<void> {
+ const response: { usernames: string[] } = await ajax(
+ `/groups/${this.id}/members.json`,
+ {
+ type: "PUT",
+ data: { usernames, emails, notify_users: notifyUsers },
+ }
+ );
+ if (filter) {
+ await this._filterMembers(response.usernames);
+ } else {
+ await this.reloadMembers();
+ }
+ }
+
+ async join() {
+ await ajax(`/groups/${this.id}/join.json`, {
+ type: "PUT",
+ });
+ await this.reloadMembers({}, true);
+ }
+
+ async addOwners(
+ usernames: string | string[],
+ filter?: boolean,
+ notifyUsers?: boolean
+ ): Promise<void> {
+ const response: { usernames: string[] } = await ajax(
+ `/groups/${this.id}/owners.json`,
+ {
+ type: "PUT",
+ data: { usernames, notify_users: notifyUsers },
+ }
+ );
+
+ if (filter) {
+ await this._filterMembers(response.usernames);
+ } else {
+ await this.reloadMembers({}, true);
+ }
+ }
+
+ asJSON(): GroupSaveAttrs {
+ const attrs: GroupSaveAttrs = {
+ name: this.name,
+ mentionable_level: this.mentionable_level,
+ messageable_level: this.messageable_level,
+ visibility_level: this.visibility_level,
+ members_visibility_level: this.members_visibility_level,
+ automatic_membership_email_domains: this.emailDomains,
+ title: this.title,
+ primary_group: !!this.primary_group,
+ grant_trust_level: this.grant_trust_level,
+ incoming_email: this.incoming_email,
+ smtp_server: this.smtp_server,
+ smtp_port: this.smtp_port,
+ smtp_ssl_mode: this.smtp_ssl_mode,
+ smtp_enabled: this.smtp_enabled,
+ email_username: this.email_username,
+ email_from_alias: this.email_from_alias,
+ email_password: this.email_password,
+ flair_icon: null as string | null,
+ flair_upload_id: null as number | null,
+ flair_bg_color: this.flairBackgroundHexColor,
+ flair_color: this.flairHexColor,
+ bio_raw: this.bio_raw,
+ public_admission: this.public_admission,
+ public_exit: this.public_exit,
+ allow_membership_requests: this.allow_membership_requests,
+ full_name: this.full_name,
+ default_notification_level: this.default_notification_level,
+ membership_request_template: this.membership_request_template,
+ publish_read_state: this.publish_read_state,
+ allow_unknown_sender_topic_replies:
+ this.allow_unknown_sender_topic_replies,
+ };
+
+ ["muted", "regular", "watching", "tracking", "watching_first_post"].forEach(
+ (s) => {
+ let prop = (
+ s === "watching_first_post"
+ ? "watchingFirstPostCategories"
+ : s + "Categories"
+ ) as
+ | "watchingFirstPostCategories"
+ | `${Exclude<NotificationLevel, "watching_first_post">}Categories`;
+
+ let categories = this.get(prop);
+
+ if (categories) {
+ attrs[(s + "_category_ids") as `${NotificationLevel}_category_ids`] =
+ categories.length > 0 ? categories.map((c) => c.get("id")) : [-1];
+ }
+
+ let tags = this.get((s + "_tags") as `${NotificationLevel}_tags`);
+
+ if (tags) {
+ attrs[(s + "_tags") as `${NotificationLevel}_tags`] =
+ tags.length > 0
+ ? tags.map((t) => (typeof t === "object" ? t.name : t))
+ : [""];
+ }
+ }
+ );
+
+ let agIds = this.associated_group_ids;
+ if (agIds) {
+ attrs["associated_group_ids"] = agIds.length ? agIds : [null];
+ }
+
+ if (this.flair_type === "icon") {
+ attrs["flair_icon"] = this.flair_icon;
+ } else if (this.flair_type === "image") {
+ attrs["flair_upload_id"] = this.flair_upload_id;
+ }
+
+ if (!this.id) {
+ attrs["usernames"] = this.usernames;
+ attrs["owner_usernames"] = this.ownerUsernames;
+ }
+
+ return { ...attrs, ...extraSavePropertiesFor("group", this) };
+ }
+
+ /**
+ * Creates the group on the server.
+ *
+ * @returns The created group, as the server serializes it.
+ */
+ async create(): Promise<GroupFields & { id: number; name: string }> {
+ await applyModelCallbacks("group", "beforeCreate", this);
+
+ const response: {
+ basic_group: GroupFields & { id: number; name: string };
+ } = await ajax("/admin/groups", {
+ type: "POST",
+ data: { group: this.asJSON() },
+ });
+
+ this.setProperties({
+ id: response.basic_group.id,
+ usernames: null,
+ ownerUsernames: null,
+ });
+
+ await this.reloadMembers();
+ await applyModelCallbacks("group", "afterCreate", this, response);
+ return response.basic_group;
+ }
+
+ /** Preserves RestModel compatibility; redirects can resolve without a response body. */
+ save(this: never, ...args: never[]): never;
+ save(opts?: GroupSaveOptions): Promise<{ success: string } | undefined>;
+ async save(
+ opts: GroupSaveOptions = {}
+ ): Promise<{ success: string } | undefined> {
+ await applyModelCallbacks("group", "beforeUpdate", this, opts);
+
+ const result = await ajax(`/groups/${this.id}`, {
+ type: "PUT",
+ data: { group: this.asJSON(), ...opts },
+ });
+
+ await applyModelCallbacks("group", "afterUpdate", this, result);
+ return result;
+ }
+
+ /** Preserves EmberObject compatibility without offering synchronous destruction. */
+ destroy(this: never, ...args: never[]): never;
+ destroy(): Promise<{ success: string } | undefined>;
+ async destroy(): Promise<{ success: string } | undefined> {
+ if (!this.id) {
+ return;
+ }
+
+ await applyModelCallbacks("group", "beforeDestroy", this);
+ const result = await ajax(`/admin/groups/${this.id}`, { type: "DELETE" });
+ await applyModelCallbacks("group", "afterDestroy", this, result);
+ return result;
+ }
+
+ findLogs(
+ offset?: number,
+ filters?: {
+ action?: string | null;
+ acting_user?: string | null;
+ target_user?: string | null;
+ subject?: string | null;
+ }
+ ): Promise<EmberObject & { logs: GroupHistory[]; all_loaded: boolean }> {
+ return ajax(`/groups/${this.name}/logs.json`, {
+ data: { offset, filters },
+ }).then(
+ (results: {
+ logs: RestModelAttrs<GroupHistory>[];
+ all_loaded: boolean;
+ }) => {
+ // EmberObject.create's inferred keys exclude these payload-only properties.
+ return EmberObject.create({
+ logs: trackedArray(
+ results["logs"].map((log) => GroupHistory.create(log))
+ ),
+ all_loaded: results["all_loaded"],
+ } as object) as EmberObject & {
+ logs: GroupHistory[];
+ all_loaded: boolean;
+ };
+ }
+ );
+ }
+
+ async findPosts(opts?: {
+ type?: "posts" | "mentions";
+ categoryId?: number | string | null;
+ before?: string;
+ }): Promise<(EmberObject & GroupPostFields)[]> {
+ opts = opts || {};
+ const type = opts.type || "posts";
+ const data: { before?: string; category_id?: number } = {};
+
+ if (opts.before) {
+ data.before = opts.before;
+ }
+
+ if (opts.categoryId) {
+ // parseInt also coerces numeric category IDs at runtime.
+ data.category_id = parseInt(opts.categoryId as string, 10);
+ }
+
+ const result: {
+ categories?: CategoryFields[];
+ posts: (Omit<GroupPostFields, "user" | "topic"> & {
+ user?: UserCreateAttrs | null;
+ topic: RestModelAttrs<Topic> | Topic;
+ })[];
+ } = await ajax(`/groups/${this.name}/${type}.json`, { data });
+
+ result.categories?.forEach((category) => {
+ Site.current().updateCategory(category);
+ });
+
+ return trackedArray(
+ result.posts.map((p) => {
+ // TODO(typescript-pending): User.create inherits RestModel's null normalization;
+ // remove when User's factory input includes null.
+ p.user = User.create(p.user as UserCreateAttrs);
+ p.topic = Topic.create(p.topic as RestModelAttrs<Topic>);
+ p.category = Category.findById(p.category_id);
+ // Both relationships are hydrated above; the factory only infers base keys.
+ return EmberObject.create(p as object) as EmberObject & GroupPostFields;
+ })
+ );
+ }
+
+ setNotification(
+ notification_level: number,
+ userId: number
+ ): Promise<{ success: string }> {
+ this.set("group_user.notification_level", notification_level);
+ return ajax(`/groups/${this.name}/notifications`, {
+ data: { notification_level, user_id: userId },
+ type: "POST",
+ });
+ }
+
+ requestMembership(
+ reason: string
+ ): Promise<{ success: string; relative_url: string }> {
+ return ajax(`/groups/${this.name}/request_membership.json`, {
+ type: "POST",
+ data: { reason },
+ });
+ }
+
+ _filterMembers(usernames: string[]): Promise<void> {
+ return this.reloadMembers({ filter: usernames.join(",") });
+ }
+
+ @observes("isPrivate", "canEveryoneMention")
+ _updateAllowMembershipRequests() {
+ if (this.isPrivate || !this.canEveryoneMention) {
+ this.set("allow_membership_requests", false);
+ }
+ }
+}
diff --git a/frontend/discourse/app/models/user.ts b/frontend/discourse/app/models/user.ts
index ed6d7736ea8..e5e754fe531 100644
--- a/frontend/discourse/app/models/user.ts
+++ b/frontend/discourse/app/models/user.ts
@@ -45,7 +45,7 @@ import { defaultHomepage, escapeExpression } from "discourse/lib/utilities";
import Badge from "discourse/models/badge";
import Bookmark from "discourse/models/bookmark";
import Category from "discourse/models/category";
-import Group from "discourse/models/group";
+import Group, { type GroupFields } from "discourse/models/group";
import RestModel, {
type RestModelAttrs,
type RestModelClass,
@@ -140,27 +140,23 @@ export interface UserOption {
watched_precedence_over_muted?: boolean;
}
-/** Visible memberships can be plain current-user entries or hydrated profile groups.
- * TODO(typescript-pending): Group omits its serializer fields; use its canonical fields when Group is typed.
- */
-export interface UserGroup {
- id: number;
- name: string;
- automatic?: boolean;
- has_messages?: boolean;
+/** Visible memberships can be plain current-user entries or hydrated profile groups. */
+export interface UserGroup
+ extends
+ Required<Pick<GroupFields, "id" | "name">>,
+ Pick<
+ GroupFields,
+ | "automatic"
+ | "has_messages"
+ | "title"
+ | "flair_url"
+ | "flair_bg_color"
+ | "flair_color"
+ | "can_admin_group"
+ | "is_group_owner"
+ | "group_user"
+ > {
owner?: true;
- title?: string | null;
- flair_url?: string | null;
- flair_bg_color?: string | null;
- flair_color?: string | null;
- can_admin_group?: boolean;
- is_group_owner?: boolean;
- group_user?: {
- user_id: number;
- group_id: number;
- notification_level: number;
- owner?: boolean;
- };
}
/** TODO(typescript-pending): Badge's field forwarders and factories lack declared fields; remove when Badge is typed. */
@@ -442,7 +438,7 @@ export interface UserDetailsResponse {
stats?:
| (Omit<Partial<UserActionStat>, "count"> & { count?: number | string })[]
| UserActionStat[];
- groups?: RestModelAttrs<Group>[];
+ groups?: (RestModelAttrs<Group> & Pick<UserGroup, "id" | "name">)[];
group_users?: UserGroup["group_user"][];
invited_by?: UserCreateAttrs | User | null;
card_badge?: RestPayload | UserBadgeModel | null;
@@ -1811,8 +1807,10 @@ export default class User extends RestModel.extend(Evented) {
if (Object.hasOwn(json.user, "groups")) {
json.user.visibleGroups = json.user.groups!.map((groupJson, index) => {
- // TODO(typescript-pending): Group omits group_user and serializer fields; remove when Group is typed.
- const group = Group.create(groupJson) as Group & UserGroup;
+ // TODO(typescript-pending): RestModel.create drops required input fields;
+ // remove when its factory retains profile group identity.
+ const group = Group.create(groupJson) as Group &
+ Pick<UserGroup, "id" | "name">;
group.group_user = json.user.group_users?.[index];
return group;
});
@@ -2046,7 +2044,7 @@ export default class User extends RestModel.extend(Evented) {
);
}
- canManageGroup(group: Group & UserGroup) {
+ canManageGroup(group: Group) {
return group.get("can_admin_group") || group.get("is_group_owner");
}
diff --git a/frontend/discourse/app/services/store.ts b/frontend/discourse/app/services/store.ts
index 65749f8cd66..cee5db2130d 100644
--- a/frontend/discourse/app/services/store.ts
+++ b/frontend/discourse/app/services/store.ts
@@ -9,6 +9,7 @@ import { getRegister } from "discourse/lib/get-owner";
import { cleanNullQueryParams } from "discourse/lib/utilities";
import WeakValueMap from "discourse/lib/weak-value-map";
import type Category from "discourse/models/category";
+import type Group from "discourse/models/group";
import type PendingPost from "discourse/models/pending-post";
import type { default as Post, PostCreateAttrs } from "discourse/models/post";
import type PostStream from "discourse/models/post-stream";
@@ -32,6 +33,7 @@ import type UserDraft from "discourse/models/user-draft";
/** Model instances by store type name. Plugins add theirs through module augmentation. */
export interface ModelRegistry {
category: Category;
+ group: Group;
"pending-post": PendingPost;
post: Post;
"post-stream": PostStream;
diff --git a/frontend/discourse/type-tests/models/group-test.ts b/frontend/discourse/type-tests/models/group-test.ts
new file mode 100644
index 00000000000..4eabf4bf482
--- /dev/null
+++ b/frontend/discourse/type-tests/models/group-test.ts
@@ -0,0 +1,212 @@
+import type EmberObject from "@ember/object";
+import { expectTypeOf } from "expect-type";
+import type Category from "discourse/models/category";
+import Group, {
+ type GroupFields,
+ type GroupMembersResponse,
+ type GroupRequestersResponse,
+} from "discourse/models/group";
+import type GroupHistory from "discourse/models/group-history";
+import type RestModel from "discourse/models/rest";
+import type Topic from "discourse/models/topic";
+import User, { UserGroup } from "discourse/models/user";
+import type {
+ default as StoreService,
+ ModelCreateAttrsFor,
+ ModelFor,
+} from "discourse/services/store";
+
+declare const store: StoreService;
+declare const group: Group;
+declare const user: User;
+
+expectTypeOf(group).toExtend<RestModel>();
+expectTypeOf(group).not.toBeAny();
+expectTypeOf<ModelFor<"group">>().toEqualTypeOf<Group>();
+expectTypeOf(store.find("group", "staff")).resolves.toEqualTypeOf<Group>();
+expectTypeOf(
+ store.createRecord("group", { name: "staff" })
+).toEqualTypeOf<Group>();
+
+/* Construction. */
+
+// The new-group route starts with no id or name; `create` assigns the id.
+expectTypeOf(
+ Group.create({ automatic: false, visibility_level: 0, can_admin_group: true })
+).toEqualTypeOf<Group>();
+// @ts-expect-error names are strings
+Group.create({ name: 1 });
+expectTypeOf(group.id).toEqualTypeOf<number | undefined>();
+expectTypeOf(group.name).toEqualTypeOf<string | undefined>();
+
+/* Serializer fields. */
+
+expectTypeOf(group.automatic).toEqualTypeOf<boolean | undefined>();
+expectTypeOf(group.visibility_level).toEqualTypeOf<number | undefined>();
+// The alias-level columns are nullable.
+expectTypeOf(group.mentionable_level).toEqualTypeOf<
+ number | null | undefined
+>();
+expectTypeOf(group.messageable_level).toEqualTypeOf<
+ number | null | undefined
+>();
+expectTypeOf(group.title).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(group.full_name).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(group.flair_url).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(group.flair_bg_color).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(group.bio_cooked).toEqualTypeOf<string | null | undefined>();
+expectTypeOf(group.grant_trust_level).toEqualTypeOf<
+ number | null | undefined
+>();
+expectTypeOf(group.can_see_members).toEqualTypeOf<boolean | undefined>();
+expectTypeOf(group.is_group_user).toEqualTypeOf<boolean | undefined>();
+// Admin-only SMTP settings.
+expectTypeOf(group.smtp_port).toEqualTypeOf<number | null | undefined>();
+expectTypeOf(group.watching_category_ids).toEqualTypeOf<number[] | undefined>();
+// Profiles attach the viewer's membership by index.
+expectTypeOf<
+ NonNullable<Group["group_user"]>["notification_level"]
+>().toEqualTypeOf<number>();
+
+/* Client state. */
+
+expectTypeOf(group.user_count).toEqualTypeOf<number>();
+expectTypeOf(group.request_count).toEqualTypeOf<number>();
+expectTypeOf(group.limit).toEqualTypeOf<number | null>();
+expectTypeOf(group.requestersOffset).toEqualTypeOf<number | null>();
+expectTypeOf(group.members).toEqualTypeOf<User[]>();
+expectTypeOf(group.requesters).toEqualTypeOf<User[]>();
+
+/* Derived state. */
+
+expectTypeOf(group.canEveryoneMention).toEqualTypeOf<boolean>();
+expectTypeOf(group.emailDomains).toEqualTypeOf<string>();
+expectTypeOf(group.associatedGroupIds).toEqualTypeOf<number[]>();
+expectTypeOf(group.type).toEqualTypeOf<"automatic" | "custom">();
+expectTypeOf(group.displayName).toEqualTypeOf<string | undefined>();
+expectTypeOf(group.flairBackgroundHexColor).toEqualTypeOf<string | null>();
+expectTypeOf(group.isPrivate).toEqualTypeOf<boolean>();
+expectTypeOf(group.watchingCategories).toEqualTypeOf<Category[]>();
+group.mutedCategories = [];
+
+/* Members. */
+
+expectTypeOf(
+ group.reloadMembers({ order: "name", asc: true, filter: "sam" }, true)
+).resolves.toEqualTypeOf<void>();
+group.reloadMembers();
+group.reloadMembers({ limit: 10 }, true);
+expectTypeOf(
+ group.findRequesters({ order: "", asc: false, filter: null }, true)
+).resolves.toEqualTypeOf<void>();
+group.addMembers("sam,jane", true, false, "[email protected]");
+group.addMembers("sam");
+group.addOwners("sam", true, true);
+group.removeMember(user, { order: "name" });
+group.removeOwner(user);
+expectTypeOf(group.join()).resolves.toEqualTypeOf<void>();
+expectTypeOf(group.leave()).resolves.toEqualTypeOf<void>();
+
+/* Persistence: these replace the inherited RestModel operations. */
+
+expectTypeOf(group.asJSON()).toExtend<{
+ name: string | undefined;
+ primary_group: boolean;
+}>();
+group.create();
+group.save();
+group.save({ update_existing_users: true });
+group.destroy();
+
+/* Activity. */
+
+expectTypeOf(group.findLogs()).resolves.toExtend<{
+ logs: GroupHistory[];
+ all_loaded: boolean;
+}>();
+group.findLogs(2, { action: "change_group_setting", acting_user: "sam" });
+expectTypeOf(
+ group.findPosts({ type: "mentions", categoryId: 3, before: undefined })
+).resolves.toExtend<{ user: User; topic: Topic; category?: Category }[]>();
+group.findPosts();
+group.setNotification(3, 1);
+group.requestMembership("Please add me");
+
+/* Statics. */
+
+expectTypeOf(
+ Group.findAll({ term: "sta", ignore_automatic: true })
+).resolves.toEqualTypeOf<Group[]>();
+Group.findAll();
+Group.loadMembers("staff", { offset: 0, requesters: true });
+Group.mentionable("staff");
+Group.messageable("staff");
+Group.checkName("staff");
+
+/* Consumers: users manage hydrated groups without casts. */
+
+expectTypeOf(user.canManageGroup(group)).toEqualTypeOf<boolean | undefined>();
+
+/* Base compatibility: the async overrides stay assignable to RestModel. */
+
+expectTypeOf(group).toExtend<EmberObject>();
+expectTypeOf<typeof Group>().toExtend<typeof RestModel>();
+expectTypeOf<ModelFor<"Group">>().toEqualTypeOf<Group>();
+expectTypeOf<ModelCreateAttrsFor<"group">["name"]>().toEqualTypeOf<
+ string | undefined
+>();
+expectTypeOf(group.save()).resolves.toEqualTypeOf<
+ { success: string } | undefined
+>();
+expectTypeOf(group.destroy()).resolves.toEqualTypeOf<
+ { success: string } | undefined
+>();
+expectTypeOf(group.create()).resolves.toExtend<{ id: number; name: string }>();
+
+/* Member responses: requester lists have no owners. */
+
+expectTypeOf(
+ Group.loadMembers("staff")
+).resolves.toEqualTypeOf<GroupMembersResponse>();
+expectTypeOf(
+ Group.loadMembers("staff", { requesters: true })
+).resolves.toEqualTypeOf<GroupRequestersResponse>();
+expectTypeOf<keyof GroupRequestersResponse>().toEqualTypeOf<
+ "members" | "meta"
+>();
+expectTypeOf<
+ GroupRequestersResponse["members"][number]["reason"]
+>().toEqualTypeOf<string | null>();
+
+/* Nullable show fields and boundaries. */
+
+expectTypeOf<GroupFields["smtp_enabled"]>().toEqualTypeOf<
+ boolean | null | undefined
+>();
+expectTypeOf<GroupFields["display_name"]>().toEqualTypeOf<
+ string | null | undefined
+>();
+expectTypeOf<GroupFields["smtp_updated_at"]>().toEqualTypeOf<
+ string | null | undefined
+>();
+expectTypeOf<GroupFields["smtp_updated_by"]>().toBeNullable();
+expectTypeOf<GroupFields>().not.toHaveProperty("displayName");
+// Plugin serializer fields are added by augmentation, not by core.
+expectTypeOf<GroupFields>().not.toHaveProperty("assignment_count");
+
+/* Current-user memberships are plain entries with identity. */
+
+expectTypeOf<UserGroup["id"]>().toEqualTypeOf<number>();
+expectTypeOf<UserGroup["name"]>().toEqualTypeOf<string>();
+expectTypeOf<UserGroup>().not.toExtend<Group>();
+
+/* Saving: editors send tag records or names, and asJSON keeps its sentinels. */
+
+Group.create({ watching_tags: ["a", { id: 1, name: "b", slug: "b" }] });
+group.addMembers(["sam", "jane"], false, true, ["[email protected]"]);
+expectTypeOf(group.asJSON().associated_group_ids).toEqualTypeOf<
+ (number | null)[] | undefined
+>();
+expectTypeOf(group.asJSON().watching_tags).toEqualTypeOf<
+ string[] | undefined
+>();