@nerimity/nerimity.js 1.15.2 → 1.16.1

package/src/classes/Client.ts

@@ -0,0 +1,339 @@
+import EventEmitter from "eventemitter3";
+import { Socket, io } from "socket.io-client";
+import {
+  ClientEventMap,
+  ClientEvents,
+  SocketClientEvents,
+  SocketServerEvents,
+} from "../EventNames";
+import {
+  AuthenticatedPayload,
+  MessageButtonClickPayload,
+  RawBotCommand,
+  RawChannel,
+  RawMessage,
+  RawServer,
+  RawServerMember,
+  RawServerRole,
+} from "../RawData";
+
+import { path, updatePath } from "../services/serviceEndpoints";
+
+import { updateCommands as postUpdateCommands } from "../services/ApplicationService";
+import { MessageButton } from "./MessageButton";
+import { ClientUser } from "./ClientUser";
+import { Users } from "./User";
+
+import { Servers } from "./Server";
+import { Posts } from "./Post";
+import { ServerMember } from "./ServerMember";
+import { ServerChannel } from "./ServerChannel";
+import { Message } from "./Message";
+import { ServerRole } from "./ServerRole";
+import { Channels } from "./Channels";
+
+export const Events = ClientEvents;
+
+export class Client extends EventEmitter<ClientEventMap> {
+  socket: Socket;
+  token: string | undefined;
+  user: ClientUser | undefined;
+  users: Users;
+  channels: Channels;
+  servers: Servers;
+  posts: Posts;
+
+  constructor(opts?: { urlOverride?: string }) {
+    super();
+    if (opts?.urlOverride) {
+      updatePath(opts.urlOverride);
+    }
+    this.socket = io(path, {
+      transports: ["websocket"],
+      autoConnect: false,
+    });
+    this.channels = new Channels(this);
+    this.users = new Users(this);
+    this.servers = new Servers(this);
+    this.posts = new Posts(this);
+    new EventHandlers(this);
+  }
+
+  updateCommands(token: string, commands: Omit<RawBotCommand, "botUserId">[]) {
+    return postUpdateCommands(token, commands);
+  }
+  public login(token: string) {
+    this.token = token;
+    this.socket.connect();
+  }
+}
+
+class EventHandlers {
+  client: Client;
+  socket: Socket;
+  constructor(client: Client) {
+    this.client = client;
+    this.socket = client.socket;
+
+    client.socket.on(SocketServerEvents.CONNECT, this.onConnect.bind(this));
+    client.socket.on(
+      SocketServerEvents.USER_AUTHENTICATED,
+      this.onAuthenticated.bind(this)
+    );
+
+    client.socket.on(
+      SocketServerEvents.SERVER_MEMBER_JOINED,
+      this.onServerMemberJoined.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_MEMBER_UPDATED,
+      this.onServerMemberUpdated.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_MEMBER_LEFT,
+      this.onServerMemberLeft.bind(this)
+    );
+
+    client.socket.on(
+      SocketServerEvents.SERVER_JOINED,
+      this.onServerJoined.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_CHANNEL_CREATED,
+      this.onServerChannelCreated.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_CHANNEL_UPDATED,
+      this.onServerChannelUpdated.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_CHANNEL_DELETED,
+      this.onServerChannelDeleted.bind(this)
+    );
+
+    client.socket.on(
+      SocketServerEvents.SERVER_LEFT,
+      this.onServerLeft.bind(this)
+    );
+
+    client.socket.on(
+      SocketServerEvents.MESSAGE_CREATED,
+      this.onMessageCreated.bind(this)
+    );
+
+    client.socket.on(
+      SocketServerEvents.MESSAGE_BUTTON_CLICKED,
+      this.onMessageButtonClicked.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_ROLE_CREATED,
+      this.onServerRoleCreated.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_ROLE_DELETED,
+      this.onServerRoleDeleted.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_ROLE_UPDATED,
+      this.onServerRoleUpdated.bind(this)
+    );
+    client.socket.on(
+      SocketServerEvents.SERVER_ROLE_ORDER_UPDATED,
+      this.onServerRoleOrderUpdated.bind(this)
+    );
+  }
+  onConnect() {
+    this.socket.emit(SocketClientEvents.AUTHENTICATE, {
+      token: this.client.token,
+    });
+  }
+  onAuthenticated(payload: AuthenticatedPayload) {
+    this.client.user = new ClientUser(this.client, payload.user);
+
+    for (let i = 0; i < payload.servers.length; i++) {
+      const server = payload.servers[i];
+      this.client.servers.setCache(server);
+    }
+
+    for (let i = 0; i < payload.channels.length; i++) {
+      const rawChannel = payload.channels[i];
+      this.client.channels.setCache(rawChannel);
+    }
+    for (let i = 0; i < payload.serverMembers.length; i++) {
+      const member = payload.serverMembers[i];
+      this.client.users.setCache(member.user);
+      const server = this.client.servers.cache.get(member.serverId);
+      server?.members.setCache(member);
+    }
+
+    for (let i = 0; i < payload.serverRoles.length; i++) {
+      const role = payload.serverRoles[i];
+      const server = this.client.servers.cache.get(role.serverId);
+      server?.roles.setCache(role);
+    }
+
+    this.client.emit(ClientEvents.Ready);
+  }
+
+  onServerMemberJoined(payload: { serverId: string; member: RawServerMember }) {
+    const server = this.client.servers.cache.get(payload.serverId);
+    this.client.users.setCache(payload.member.user);
+    const member = server?.members.setCache(payload.member);
+    if (!member) return;
+    this.client.emit(ClientEvents.ServerMemberJoined, member);
+  }
+
+  onServerMemberUpdated(payload: {
+    serverId: string;
+    userId: string;
+    updated: {
+      roleIds: string[];
+    };
+  }) {
+    const server = this.client.servers.cache.get(payload.serverId);
+    const member = server?.members.cache.get(payload.userId);
+    if (!member) return;
+
+    updateClass<ServerMember>(member, payload.updated);
+
+    this.client.emit(ClientEvents.ServerMemberUpdated, member);
+  }
+
+  onServerJoined(payload: {
+    server: RawServer;
+    members: RawServerMember[];
+    channels: RawChannel[];
+    roles: RawServerRole[];
+    // memberPresences: any[]
+    // voiceChannelUsers: any[];
+  }) {
+    const server = this.client.servers.setCache(payload.server);
+
+    for (let i = 0; i < payload.members.length; i++) {
+      const member = payload.members[i];
+      this.client.users.setCache(member.user);
+      server?.members.setCache(member);
+    }
+    for (let i = 0; i < payload.roles.length; i++) {
+      const role = payload.roles[i];
+      server?.roles.setCache(role);
+    }
+
+    for (let i = 0; i < payload.channels.length; i++) {
+      const channel = payload.channels[i];
+      this.client.channels.setCache(channel);
+    }
+    this.client.emit(ClientEvents.ServerJoined, server);
+  }
+  onServerChannelCreated(payload: { serverId: string; channel: RawChannel }) {
+    const channel = this.client.channels.setCache(payload.channel);
+    this.client.emit(
+      ClientEvents.ServerChannelCreated,
+      channel as ServerChannel
+    );
+  }
+  onServerChannelUpdated(payload: {
+    serverId: string;
+    channelId: string;
+    updated: Partial<RawChannel>;
+  }) {
+    const channel = this.client.channels.cache.get(payload.channelId);
+    const updated = payload.updated;
+    if (channel) {
+      updateClass<ServerChannel>(channel as ServerChannel, updated);
+      this.client.emit(
+        ClientEvents.ServerChannelUpdated,
+        channel as ServerChannel
+      );
+    }
+  }
+  onServerChannelDeleted(payload: { serverId: string; channelId: string }) {
+    const channel = this.client.channels.cache.has(payload.channelId);
+    if (channel) {
+      this.client.channels.cache.delete(payload.channelId);
+      this.client.emit(ClientEvents.ServerChannelDeleted, {
+        channelId: payload.channelId,
+        serverId: payload.serverId,
+      });
+    }
+  }
+  onServerLeft(payload: { serverId: string }) {
+    const server = this.client.servers.cache.get(payload.serverId);
+    if (!server) return;
+    this.client.emit(ClientEvents.ServerLeft, server);
+    this.client.servers.cache.delete(payload.serverId);
+
+    this.client.channels.cache.forEach((channel) => {
+      if (
+        channel instanceof ServerChannel &&
+        channel.serverId === payload.serverId
+      ) {
+        this.client.channels.cache.delete(channel.id);
+      }
+    });
+    server.members.cache.clear();
+  }
+  onServerMemberLeft(payload: { userId: string; serverId: string }) {
+    const server = this.client.servers.cache.get(payload.serverId);
+    const member = server?.members.cache.get(payload.userId);
+    if (!member) return;
+    this.client.emit(ClientEvents.ServerMemberLeft, member);
+    server?.members.cache.delete(payload.userId);
+  }
+  onMessageCreated(payload: { message: RawMessage }) {
+    const message = new Message(this.client, payload.message);
+    this.client.emit(ClientEvents.MessageCreate, message);
+  }
+  onMessageButtonClicked(payload: MessageButtonClickPayload) {
+    const button = new MessageButton(this.client, payload);
+    this.client.emit(ClientEvents.MessageButtonClick, button);
+  }
+  onServerRoleCreated(payload: RawServerRole) {
+    const server = this.client.servers.cache.get(payload.serverId);
+    const role = server?.roles.setCache(payload);
+    if (!role) return;
+    this.client.emit(ClientEvents.ServerRoleCreated, role);
+  }
+  onServerRoleDeleted(payload: { serverId: string; roleId: string }) {
+    const server = this.client.servers.cache.get(payload.serverId);
+    const role = server?.roles.cache.get(payload.roleId);
+    if (!role) return;
+    server?.roles.cache.delete(payload.roleId);
+
+    this.client.emit(ClientEvents.ServerRoleDeleted, role);
+  }
+  onServerRoleUpdated(payload: {
+    serverId: string;
+    roleId: string;
+    updated: Partial<RawServerRole>;
+  }) {
+    const server = this.client.servers.cache.get(payload.serverId);
+    const role = server?.roles.cache.get(payload.roleId);
+    if (!role) return;
+
+    updateClass<ServerRole>(role, payload.updated);
+
+    this.client.emit(ClientEvents.ServerRoleUpdated, role);
+  }
+  onServerRoleOrderUpdated(payload: { serverId: string; roleIds: string[] }) {
+    const server = this.client.servers.cache.get(payload.serverId);
+
+    for (let i = 0; i < payload.roleIds.length; i++) {
+      const roleId = payload.roleIds[i];
+      const role = server?.roles.cache.get(roleId);
+      if (!role) continue;
+      role.order = i + 1;
+    }
+
+    this.client.emit(ClientEvents.ServerRoleOrderUpdated, server?.roles!);
+  }
+}
+
+function updateClass<T extends object>(classInstance: T, update: Partial<T>) {
+  for (const [key, value] of Object.entries(update) as [
+    keyof T,
+    T[keyof T]
+  ][]) {
+    classInstance[key] = value;
+  }
+}

package/src/classes/ClientUser.ts

@@ -0,0 +1,26 @@
+import { SocketClientEvents } from "../EventNames";
+import { RawUser } from "../RawData";
+import { Client } from "./Client";
+import { User } from "./User";
+
+export interface ActivityOpts {
+  action: string;
+  name: string;
+  startedAt: number;
+  endsAt?: number;
+
+  imgSrc?: string;
+  title?: string;
+  subtitle?: string;
+  link?: string;
+}
+
+export class ClientUser extends User {
+  setActivity(activity?: ActivityOpts | null) {
+    this.client.socket.emit(SocketClientEvents.UPDATE_ACTIVITY, activity);
+  }
+
+  constructor(client: Client, user: RawUser) {
+    super(client, user);
+  }
+}

package/src/classes/Collection.ts

@@ -0,0 +1,5 @@
+export class Collection<K, V> extends Map<K, V> {
+  constructor() {
+    super();
+  }
+}

package/src/classes/Message.ts

@@ -0,0 +1,102 @@
+import {
+  ChannelType,
+  MessageType,
+  RawMessage,
+  RawMessageButton,
+} from "../RawData";
+import { deleteMessage, editMessage } from "../services/MessageService";
+import { AllChannel } from "../types";
+import { Client } from "./Client";
+import { User } from "./User";
+
+const UserMentionRegex = /\[@:([0-9]+)\]/gm;
+const CommandRegex = /^(\/[^:\s]*):(\d+)( .*)?$/m;
+
+export interface MessageOpts {
+  htmlEmbed?: string;
+  nerimityCdnFileId?: string;
+  buttons?: RawMessageButton[];
+  silent?: boolean;
+  replyToMessageIds?: string[];
+  mentionReplies?: boolean;
+}
+
+export class Message {
+  client: Client;
+  id: string;
+  content?: string;
+  type: MessageType;
+  createdAt: number;
+  channelId: string;
+  channel: AllChannel;
+  user: User;
+  mentions: User[] = [];
+  command?: { name: string; args: string[] };
+  constructor(client: Client, message: RawMessage) {
+    this.client = client;
+
+    this.id = message.id;
+    this.channelId = message.channelId;
+    this.channel = client.channels.cache.get(this.channelId)!;
+    this.content = message.content;
+    this.type = message.type;
+    this.createdAt = message.createdAt;
+    this.user = this.client.users.cache.get(message.createdBy.id)!;
+
+    const cmd = message.content?.match(CommandRegex);
+    if (cmd?.[2] === this.client.user?.id) {
+      this.command = {
+        name: cmd?.[1]!.substring(1)!,
+        args: message.content!.split(" ").slice(1),
+      };
+    }
+
+    if (!this.user) {
+      this.user = this.client.users.setCache(message.createdBy);
+    }
+
+    if (!this.channel) {
+      this.channel = this.client.channels.setCache({
+        id: this.channelId,
+        type: ChannelType.DM_TEXT,
+      });
+    }
+
+    if (this.content) {
+      const mentionIds = [...this.content.matchAll(UserMentionRegex)].map(
+        (exp) => exp[1]
+      );
+      this.mentions = mentionIds
+        .map((id) => this.client.users.cache.get(id)!)
+        .filter((u) => u);
+    }
+  }
+  get member() {
+    return this.channel.server?.members.cache.get(this.user.id);
+  }
+  reply(content: string, _opts?: MessageOpts) {
+    const opts: MessageOpts = _opts || {};
+    opts.replyToMessageIds = [this.id];
+    return this.channel.send(content, opts);
+  }
+  async edit(content: string) {
+    const RawMessage = await editMessage({
+      client: this.client,
+      channelId: this.channel.id,
+      messageId: this.id,
+      content: content,
+    });
+    const message = new Message(this.client, RawMessage);
+    return message;
+  }
+  async delete() {
+    return deleteMessage({
+      channelId: this.channel.id,
+      client: this.client,
+      messageId: this.id,
+    });
+  }
+  toString() {
+    return `[q:${this.id}]`;
+  }
+}

package/src/classes/MessageButton.ts

@@ -0,0 +1,48 @@
+import { MessageButtonClickPayload } from "../RawData";
+import {
+  ButtonCallback,
+  buttonClickCallback,
+} from "../services/MessageService";
+import { Channel } from "./Channel";
+import { Client } from "./Client";
+import { User } from "./User";
+
+export class MessageButton {
+  client: Client;
+  id: string;
+
+  userId: string;
+  messageId: string;
+  channelId: string;
+
+  user?: User;
+  channel: Channel;
+
+  data?: Record<string, string>;
+  type: "modal_click" | "button_click";
+
+  constructor(client: Client, payload: MessageButtonClickPayload) {
+    this.client = client;
+
+    this.id = payload.buttonId;
+    this.userId = payload.userId;
+    this.channelId = payload.channelId;
+    this.messageId = payload.messageId;
+    this.user = this.client.users.cache.get(this.userId);
+
+    this.channel = client.channels.cache.get(this.channelId)!;
+    this.data = payload.data;
+    this.type = payload.type;
+  }
+
+  async respond(opts?: ButtonCallback) {
+    await buttonClickCallback({
+      client: this.client,
+      buttonId: this.id,
+      channelId: this.channelId,
+      messageId: this.messageId,
+      userId: this.userId,
+      data: opts,
+    });
+  }
+}

package/src/classes/Post.ts

@@ -0,0 +1,100 @@
+import { RawPost, RawUser } from "../RawData";
+import {
+  deletePost,
+  editPost,
+  getPosts,
+  postPost,
+} from "../services/PostsService";
+import { Client } from "./Client";
+
+export interface PostOpts {
+  nerimityCdnFileId?: string;
+  poll?: {
+    choices: string[];
+  };
+}
+export class Posts {
+  client: Client;
+  constructor(client: Client) {
+    this.client = client;
+  }
+
+  async get(id?: string) {
+    const RawPosts = await getPosts(this.client);
+    const posts = RawPosts.map((post) => new Post(this.client, post));
+    return id ? posts.find((p) => p.id === id) : posts;
+  }
+
+  async create(content: string, opts?: PostOpts) {
+    const RawPost = await postPost({
+      client: this.client,
+      content: content,
+      nerimityCdnFileId: opts?.nerimityCdnFileId,
+      poll: opts?.poll,
+    });
+
+    const post = new Post(this.client, RawPost);
+
+    return post;
+  }
+}
+
+export class Post {
+  client: Client;
+  id: string;
+  content?: string;
+  attachments?: Array<any>;
+  deleted: boolean;
+  block?: boolean;
+  commentToId: string;
+  commentTo?: RawPost;
+  createdBy: RawUser;
+  createdAt: number;
+  editedAt: number;
+  likedBy: { id: string }[]; // if you liked this post, array will not be empty
+  reposts: { id: string; createdBy: { id: string; username: string } }[];
+  repost?: RawPost;
+  _count: { likedBy: number; comments: number; reposts: number };
+  views: number;
+  announcement: any;
+  poll?: any;
+
+  constructor(client: Client, post: RawPost) {
+    this.client = client;
+    this.id = post.id;
+    this.content = post.content;
+    this.attachments = post.attachments;
+    this.deleted = post.deleted;
+    this.block = post.block;
+    this.commentToId = post.commentToId;
+    this.commentTo = post.commentTo;
+    this.createdBy = post.createdBy;
+    this.createdAt = post.createdAt;
+    this.editedAt = post.editedAt;
+    this.likedBy = post.likedBy;
+    this.reposts = post.reposts;
+    this.repost = post.repost;
+    this._count = post._count;
+    this.views = post.views;
+    this.announcement = post.announcement;
+    this.poll = post.poll;
+  }
+
+  async edit(content: string) {
+    const RawPost = await editPost({
+      client: this.client,
+      content: content,
+      postId: this.id,
+    });
+
+    const post = new Post(this.client, RawPost);
+    return post;
+  }
+
+  async delete() {
+    await deletePost({
+      client: this.client,
+      postId: this.id,
+    });
+  }
+}

package/src/{RPCClient.ts → classes/RPCClient.ts}

@@ -19,8 +19,8 @@ export interface EmitPayload {
 }
 function findRunningServer(appId: string) {
   return new Promise<null | WebSocket>((res) => {
-    let servers: WebSocket[] = [];
-    let id = setTimeout(() => {
+    const servers: WebSocket[] = [];
+    const id = setTimeout(() => {
       res(null);
     }, 5000);
     for (let port = PORT_RANGES[0]; port < PORT_RANGES[1] + 1; port++) {
@@ -42,7 +42,7 @@ function findRunningServer(appId: string) {
         }
       });
 
-      server.on("error", (err) => {});
+      server.on("error", () => {});
     }
   });
 }
@@ -79,7 +79,7 @@ export class RPCClient extends EventEmitter<EventMap> {
 const jsonParseCatch = (json: string) => {
   try {
     return JSON.parse(json);
-  } catch (e) {
+  } catch {
     return null;
   }
 };

package/src/classes/Server.ts

@@ -0,0 +1,57 @@
+import { RawServer } from "../RawData";
+import {
+  banServerMember,
+  kickServerMember,
+  unbanServerMember,
+} from "../services/ServerService";
+import { Client } from "./Client";
+import { Collection } from "./Collection";
+import { ServerMembers } from "./ServerMember";
+import { ServerRoles } from "./ServerRole";
+
+export class Servers {
+  client: Client;
+  cache: Collection<string, Server>;
+  constructor(client: Client) {
+    this.client = client;
+    this.cache = new Collection();
+  }
+  setCache(rawServer: RawServer) {
+    const server = new Server(this.client, rawServer);
+    this.cache.set(server.id, server);
+    return server;
+  }
+}
+
+export class Server {
+  client: Client;
+  id: string;
+  name: string;
+  avatar?: string;
+  defaultRoleId: string;
+  createdById: string;
+
+  members: ServerMembers;
+  roles: ServerRoles;
+  constructor(client: Client, server: RawServer) {
+    this.client = client;
+
+    this.id = server.id;
+    this.name = server.name;
+    this.avatar = server.avatar;
+    this.members = new ServerMembers(this.client);
+    this.roles = new ServerRoles(this.client);
+    this.defaultRoleId = server.defaultRoleId;
+    this.createdById = server.createdById;
+  }
+
+  async banMember(userId: string) {
+    return banServerMember(this.client, this.id, userId);
+  }
+  async unbanMember(userId: string) {
+    return unbanServerMember(this.client, this.id, userId);
+  }
+  async kickMember(userId: string) {
+    return kickServerMember(this.client, this.id, userId);
+  }
+}