@glade-chat/glade.js 0.1.0

package/src/managers/FriendManager.js

@@ -0,0 +1,89 @@
+'use strict';
+
+import { Collection } from '../util/Collection.js';
+import { Routes } from '../rest/Routes.js';
+import { resolveId } from '../util/Util.js';
+
+/**
+ * Manages the client's friends and friend requests. Friends are {@link User}s,
+ * cached both here (accepted friends) and in the global user cache.
+ */
+export class FriendManager {
+  constructor(client) {
+    Object.defineProperty(this, 'client', { value: client });
+    /**
+     * Accepted friends, keyed by user id.
+     * @type {Collection<string, import('../structures/User.js').User>}
+     */
+    this.cache = new Collection();
+  }
+
+  /**
+   * Fetches the client's accepted friends.
+   * @returns {Promise<Collection<string, import('../structures/User.js').User>>}
+   */
+  async fetch() {
+    const { friends } = await this.client.rest.get(Routes.friends());
+    this.cache.clear();
+    for (const friend of friends) {
+      const user = this.client.users._add(friend);
+      this.cache.set(user.id, user);
+    }
+    return this.cache;
+  }
+
+  /**
+   * Fetches incoming and outgoing pending friend requests.
+   * @returns {Promise<{ incoming: Array<{ id: string, user: import('../structures/User.js').User }>, outgoing: Array<{ id: string, user: import('../structures/User.js').User }> }>}
+   */
+  async fetchPending() {
+    const data = await this.client.rest.get(Routes.friendsPending());
+    const map = (list) =>
+      list.map((entry) => ({ id: entry.id, user: this.client.users._add(entry.user) }));
+    return { incoming: map(data.incoming ?? []), outgoing: map(data.outgoing ?? []) };
+  }
+
+  /**
+   * Sends a friend request by handle. If the target had already requested you, the
+   * friendship is accepted instead (`accepted: true`).
+   * @param {string} handle
+   * @returns {Promise<{ accepted: boolean, user: import('../structures/User.js').User }>}
+   */
+  async add(handle) {
+    const { accepted, target } = await this.client.rest.post(Routes.friends(), { handle });
+    const user = this.client.users._add(target);
+    if (accepted) this.cache.set(user.id, user);
+    return { accepted, user };
+  }
+
+  /**
+   * Accepts an incoming friend request.
+   * @param {string} requestId The friendship id from {@link FriendManager#fetchPending}.
+   * @returns {Promise<void>}
+   */
+  async accept(requestId) {
+    await this.client.rest.post(Routes.friendAccept(requestId));
+  }
+
+  /**
+   * Declines an incoming request, or cancels an outgoing one.
+   * @param {string} requestId
+   * @returns {Promise<void>}
+   */
+  async decline(requestId) {
+    await this.client.rest.post(Routes.friendDecline(requestId));
+  }
+
+  /**
+   * Removes an existing friend.
+   * @param {string | import('../structures/User.js').User} user
+   * @returns {Promise<void>}
+   */
+  async remove(user) {
+    const id = resolveId(user);
+    await this.client.rest.delete(Routes.friendRemove(id));
+    this.cache.delete(id);
+  }
+}
+
+export default FriendManager;

package/src/managers/HouseManager.js

@@ -0,0 +1,44 @@
+'use strict';
+
+import { CachedManager } from './CachedManager.js';
+import { House } from '../structures/House.js';
+import { Routes } from '../rest/Routes.js';
+
+/**
+ * Manages the Houses the client is a member of.
+ * @extends {CachedManager}
+ */
+export class HouseManager extends CachedManager {
+  constructor(client) {
+    super(client, House);
+  }
+
+  /**
+   * Fetches all of the client's Houses, or a single House by id.
+   * @param {string} [id] If provided, fetches just that House (with its rooms).
+   * @param {{ force?: boolean }} [options]
+   * @returns {Promise<import('../util/Collection.js').Collection<string, House> | House>}
+   */
+  async fetch(id, { force = false } = {}) {
+    if (id) {
+      if (!force && this.cache.has(id)) return this.cache.get(id);
+      const { house } = await this.client.rest.get(Routes.house(id));
+      return this._add(house);
+    }
+    const { houses } = await this.client.rest.get(Routes.houses());
+    for (const house of houses) this._add(house);
+    return this.cache;
+  }
+
+  /**
+   * Creates a new House owned by the client.
+   * @param {string} name
+   * @returns {Promise<House>}
+   */
+  async create(name) {
+    const { house } = await this.client.rest.post(Routes.houses(), { name });
+    return this._add(house);
+  }
+}
+
+export default HouseManager;

package/src/managers/InviteManager.js

@@ -0,0 +1,46 @@
+'use strict';
+
+import { CachedManager } from './CachedManager.js';
+import { Invite } from '../structures/Invite.js';
+import { Routes } from '../rest/Routes.js';
+
+/**
+ * Manages the invites of a single House.
+ * @extends {CachedManager}
+ */
+export class InviteManager extends CachedManager {
+  /**
+   * @param {import('../client/Client.js').Client} client
+   * @param {import('../structures/House.js').House} house
+   */
+  constructor(client, house) {
+    super(client, Invite);
+    /** @type {import('../structures/House.js').House} */
+    Object.defineProperty(this, 'house', { value: house });
+  }
+
+  /**
+   * Fetches all active invites for this House.
+   * @returns {Promise<import('../util/Collection.js').Collection<string, Invite>>}
+   */
+  async fetch() {
+    const { invites } = await this.client.rest.get(Routes.houseInvites(this.house.id));
+    for (const invite of invites) this._add(invite);
+    return this.cache;
+  }
+
+  /**
+   * Creates an invite to this House.
+   * @param {{ expiresInMinutes?: number | null, maxUses?: number | null }} [options]
+   * @returns {Promise<Invite>}
+   */
+  async create({ expiresInMinutes, maxUses } = {}) {
+    const { invite } = await this.client.rest.post(Routes.houseInvites(this.house.id), {
+      expiresInMinutes,
+      maxUses,
+    });
+    return this._add({ ...invite, house: { id: this.house.id, name: this.house.name } });
+  }
+}
+
+export default InviteManager;

package/src/managers/MemberManager.js

@@ -0,0 +1,41 @@
+'use strict';
+
+import { CachedManager } from './CachedManager.js';
+import { Member } from '../structures/Member.js';
+import { Routes } from '../rest/Routes.js';
+
+/**
+ * Manages the members of a single House.
+ * @extends {CachedManager}
+ */
+export class MemberManager extends CachedManager {
+  /**
+   * @param {import('../client/Client.js').Client} client
+   * @param {import('../structures/House.js').House} house
+   */
+  constructor(client, house) {
+    super(client, Member);
+    /** @type {import('../structures/House.js').House} */
+    Object.defineProperty(this, 'house', { value: house });
+  }
+
+  _create(data) {
+    return new Member(this.client, this.house, data);
+  }
+
+  /**
+   * Fetches all members, or returns a single member by id (fetching all first if
+   * necessary, since there is no single-member endpoint).
+   * @param {string} [id]
+   * @param {{ force?: boolean }} [options]
+   * @returns {Promise<import('../util/Collection.js').Collection<string, Member> | Member | null>}
+   */
+  async fetch(id, { force = false } = {}) {
+    if (id && !force && this.cache.has(id)) return this.cache.get(id);
+    const { members } = await this.client.rest.get(Routes.houseMembers(this.house.id));
+    for (const member of members) this._add(member);
+    return id ? (this.cache.get(id) ?? null) : this.cache;
+  }
+}
+
+export default MemberManager;

package/src/managers/MessageManager.js

@@ -0,0 +1,69 @@
+'use strict';
+
+import { CachedManager } from './CachedManager.js';
+import { Message } from '../structures/Message.js';
+import { Routes } from '../rest/Routes.js';
+
+/**
+ * Manages the cached messages of a single room or DM channel.
+ * @extends {CachedManager}
+ *
+ * @typedef {object} MessagePayload
+ * @property {string} content The message content (may be E2E ciphertext).
+ * @property {string} [nonce] A client nonce echoed back for optimistic dedupe.
+ * @property {string[]} [mentions] Explicit mentioned user ids (needed when content is encrypted).
+ */
+export class MessageManager extends CachedManager {
+  /**
+   * @param {import('../client/Client.js').Client} client
+   * @param {import('../structures/Room.js').Room | import('../structures/DMChannel.js').DMChannel} channel
+   */
+  constructor(client, channel) {
+    super(client, Message);
+    /** @type {import('../structures/Room.js').Room | import('../structures/DMChannel.js').DMChannel} */
+    Object.defineProperty(this, 'channel', { value: channel });
+  }
+
+  /** Whether the owning channel is a DM. */
+  get isDM() {
+    return typeof this.channel.isDM === 'function' && this.channel.isDM();
+  }
+
+  /**
+   * Fetches a page of messages (ascending order), newest page first via `cursor`.
+   * @param {{ cursor?: string, limit?: number }} [options]
+   * @returns {Promise<{ messages: Message[], nextCursor: string | null }>}
+   */
+  async fetch({ cursor, limit } = {}) {
+    const path = this.isDM
+      ? Routes.dmMessages(this.channel.id)
+      : Routes.roomMessages(this.channel.id);
+    const data = await this.client.rest.get(path, { query: { cursor, limit } });
+    const messages = data.messages.map((m) => this._add(m));
+    return { messages, nextCursor: data.nextCursor ?? null };
+  }
+
+  /**
+   * Fetches the room's pinned messages (rooms only).
+   * @returns {Promise<Message[]>}
+   */
+  async fetchPins() {
+    if (this.isDM) throw new Error('DM channels do not support pinned messages');
+    const { messages } = await this.client.rest.get(Routes.roomPins(this.channel.id));
+    return messages.map((m) => this._add(m));
+  }
+
+  /**
+   * Sends a message to this channel.
+   * @param {string | MessagePayload} content
+   * @returns {Promise<Message>}
+   */
+  send(content) {
+    const target = this.isDM
+      ? { dmChannelId: this.channel.id }
+      : { roomId: this.channel.id };
+    return this.client._sendMessage(target, content);
+  }
+}
+
+export default MessageManager;

package/src/managers/RoleManager.js

@@ -0,0 +1,65 @@
+'use strict';
+
+import { CachedManager } from './CachedManager.js';
+import { Role } from '../structures/Role.js';
+import { Routes } from '../rest/Routes.js';
+import { PermissionsBitField } from '../util/Permissions.js';
+
+/**
+ * Manages the roles of a single House.
+ * @extends {CachedManager}
+ */
+export class RoleManager extends CachedManager {
+  /**
+   * @param {import('../client/Client.js').Client} client
+   * @param {import('../structures/House.js').House} house
+   */
+  constructor(client, house) {
+    super(client, Role);
+    /** @type {import('../structures/House.js').House} */
+    Object.defineProperty(this, 'house', { value: house });
+  }
+
+  /** The default `@everyone` role, if cached. */
+  get everyone() {
+    return this.cache.find((r) => r.isDefault) ?? null;
+  }
+
+  /**
+   * Fetches all roles in this House.
+   * @returns {Promise<import('../util/Collection.js').Collection<string, Role>>}
+   */
+  async fetch() {
+    const { roles } = await this.client.rest.get(Routes.houseRoles(this.house.id));
+    for (const role of roles) this._add(role);
+    return this.cache;
+  }
+
+  /**
+   * Creates a role. Requires `ManageRoles`.
+   * @param {{ name: string, color?: string | null, permissions?: import('../util/Permissions.js').PermissionResolvable }} data
+   * @returns {Promise<Role>}
+   */
+  async create({ name, color, permissions } = {}) {
+    const body = { name, color };
+    if (permissions !== undefined) body.permissions = PermissionsBitField.resolve(permissions);
+    const { role } = await this.client.rest.post(Routes.houseRoles(this.house.id), body);
+    return this._add(role);
+  }
+
+  /**
+   * Reorders the House's roles.
+   * @param {Array<string | Role>} orderedIds
+   * @returns {Promise<import('../util/Collection.js').Collection<string, Role>>}
+   */
+  async reorder(orderedIds) {
+    const ids = orderedIds.map((r) => this.resolveId(r));
+    const { roles } = await this.client.rest.post(Routes.houseRolesReorder(this.house.id), {
+      orderedIds: ids,
+    });
+    for (const role of roles) this._add(role);
+    return this.cache;
+  }
+}
+
+export default RoleManager;

package/src/managers/RoomManager.js

@@ -0,0 +1,80 @@
+'use strict';
+
+import { CachedManager } from './CachedManager.js';
+import { Room, createRoom } from '../structures/Room.js';
+import { Routes } from '../rest/Routes.js';
+
+/**
+ * Manages the rooms (channels) of a single House. Entries are also mirrored into
+ * the client-wide {@link ChannelManager} cache.
+ * @extends {CachedManager}
+ */
+export class RoomManager extends CachedManager {
+  /**
+   * @param {import('../client/Client.js').Client} client
+   * @param {import('../structures/House.js').House} house
+   */
+  constructor(client, house) {
+    super(client, Room);
+    /** @type {import('../structures/House.js').House} */
+    Object.defineProperty(this, 'house', { value: house });
+  }
+
+  _create(data) {
+    return createRoom(this.client, { ...data, houseId: data.houseId ?? this.house.id });
+  }
+
+  _add(data, cache = true) {
+    const isNew = data.id != null && !this.cache.has(data.id);
+    const room = super._add(data, cache);
+    // Mirror into the global channel cache so rooms resolve by id anywhere.
+    if (cache && this.client.options.cache) this.client.channels.cache.set(room.id, room);
+    // Subscribe to realtime events for rooms discovered while already connected
+    // (rooms cached before connect are handled by Client on the `ready` event).
+    if (
+      isNew &&
+      this.client.options.autoSubscribeRooms !== false &&
+      this.client.gateway?.connected
+    ) {
+      this.client.gateway.send('room:join', room.id);
+    }
+    return room;
+  }
+
+  /**
+   * Fetches all rooms in this House (filtered to those the client can view).
+   * @returns {Promise<import('../util/Collection.js').Collection<string, Room>>}
+   */
+  async fetch() {
+    const { rooms } = await this.client.rest.get(Routes.houseRooms(this.house.id));
+    for (const room of rooms) this._add(room);
+    return this.cache;
+  }
+
+  /**
+   * Creates a room in this House. Requires `ManageChannels`.
+   * @param {string} name
+   * @param {{ type?: 'text' | 'voice' | 'portal' }} [options]
+   * @returns {Promise<Room>}
+   */
+  async create(name, { type } = {}) {
+    const { room } = await this.client.rest.post(Routes.houseRooms(this.house.id), { name, type });
+    return this._add(room);
+  }
+
+  /**
+   * Reorders the House's rooms.
+   * @param {Array<string | Room>} orderedIds
+   * @returns {Promise<import('../util/Collection.js').Collection<string, Room>>}
+   */
+  async reorder(orderedIds) {
+    const ids = orderedIds.map((r) => this.resolveId(r));
+    const { rooms } = await this.client.rest.post(Routes.houseRoomsReorder(this.house.id), {
+      orderedIds: ids,
+    });
+    for (const room of rooms) this._add(room);
+    return this.cache;
+  }
+}
+
+export default RoomManager;

package/src/managers/UserManager.js

@@ -0,0 +1,41 @@
+'use strict';
+
+import { CachedManager } from './CachedManager.js';
+import { User } from '../structures/User.js';
+import { Routes } from '../rest/Routes.js';
+
+/**
+ * The client-wide cache of known users.
+ * @extends {CachedManager}
+ */
+export class UserManager extends CachedManager {
+  constructor(client) {
+    super(client, User);
+  }
+
+  /**
+   * Fetches a user's full profile by id.
+   * @param {string} id
+   * @param {{ force?: boolean }} [options]
+   * @returns {Promise<User>}
+   */
+  async fetch(id, { force = false } = {}) {
+    if (!force && this.cache.has(id)) return this.cache.get(id);
+    const { profile } = await this.client.rest.get(Routes.user(id));
+    return this._add(profile);
+  }
+
+  /**
+   * Searches the client's contacts (accepted friends + existing DM partners).
+   * @param {string} [query]
+   * @returns {Promise<User[]>}
+   */
+  async search(query = '') {
+    const { users } = await this.client.rest.get(Routes.userSearch(), {
+      query: { q: query },
+    });
+    return users.map((u) => this._add(u));
+  }
+}
+
+export default UserManager;