@nerimity/nerimity.js 1.15.2 → 1.16.1

package/src/classes/ServerChannel.ts

@@ -0,0 +1,24 @@
+import { RawChannel } from "../RawData";
+import { Channel } from "./Channel";
+import { Client } from "./Client";
+import { Server } from "./Server";
+
+export class ServerChannel extends Channel {
+  createdById: string;
+  name: string;
+  serverId: string;
+  permissions: number;
+  categoryId?: string;
+  server: Server;
+
+  constructor(client: Client, channel: RawChannel) {
+    super(client, channel);
+    this.name = channel.name;
+    this.permissions = channel.permissions!;
+    this.createdById = channel.createdById!;
+    this.serverId = channel.serverId!;
+    this.categoryId = channel.categoryId!;
+
+    this.server = this.client.servers.cache.get(this.serverId)!;
+  }
+}

package/src/classes/ServerMember.ts

@@ -0,0 +1,95 @@
+import {
+  addBit,
+  AvailablePermissions,
+  hasBit,
+  RolePermissions,
+} from "../bitwise";
+import { RawServerMember } from "../RawData";
+import {
+  banServerMember,
+  kickServerMember,
+  unbanServerMember,
+} from "../services/ServerService";
+import { Client } from "./Client";
+import { Collection } from "./Collection";
+import { Server } from "./Server";
+import { User } from "./User";
+
+export class ServerMembers {
+  client: Client;
+  cache: Collection<string, ServerMember>;
+  constructor(client: Client) {
+    this.client = client;
+    this.cache = new Collection();
+  }
+  setCache(rawMember: RawServerMember) {
+    const member = new ServerMember(this.client, rawMember);
+    this.cache.set(member.user.id, member);
+    return member;
+  }
+}
+
+export class ServerMember {
+  client: Client;
+  id: string;
+  user: User;
+  server: Server;
+  roleIds: string[];
+  nickname?: string | null;
+
+  constructor(client: Client, member: RawServerMember) {
+    this.client = client;
+    this.id = member.user.id;
+    this.roleIds = member.roleIds;
+    this.nickname = member.nickname;
+
+    this.user = this.client.users.cache.get(member.user.id)!;
+    this.server = this.client.servers.cache.get(member.serverId)!;
+  }
+  toString() {
+    return `[@:${this.id}]`;
+  }
+  async ban() {
+    return banServerMember(this.client, this.server.id, this.user.id);
+  }
+  async unban() {
+    return unbanServerMember(this.client, this.server.id, this.user.id);
+  }
+  async kick() {
+    return kickServerMember(this.client, this.server.id, this.user.id);
+  }
+  get roles() {
+    return this.roleIds
+      .map((id) => this.server.roles.cache.get(id)!)
+      .filter(Boolean);
+  }
+
+  permissions(this: ServerMember) {
+    const defaultRoleId = this.server?.defaultRoleId;
+    const defaultRole = this.server.roles.cache.get(defaultRoleId!);
+
+    let currentPermissions = defaultRole?.permissions || 0;
+
+    const memberRoles = this.roles;
+    for (let i = 0; i < memberRoles.length; i++) {
+      const role = memberRoles[i];
+      currentPermissions = addBit(currentPermissions, role?.permissions || 0);
+    }
+
+    return currentPermissions;
+  }
+
+  hasPermission(
+    permission: AvailablePermissions,
+    ignoreAdmin = false,
+    ignoreCreator = false
+  ) {
+    if (!ignoreCreator) {
+      if (this.server.createdById === this.user.id) return true;
+    }
+    if (!ignoreAdmin) {
+      if (hasBit(this.permissions(), RolePermissions.ADMIN)) return true;
+    }
+    return hasBit(this.permissions(), permission);
+  }
+}

package/src/classes/ServerRole.ts

@@ -0,0 +1,40 @@
+import { RawServerRole } from "../RawData";
+import { Client } from "./Client";
+import { Collection } from "./Collection";
+import { Server } from "./Server";
+
+export class ServerRoles {
+  client: Client;
+  cache: Collection<string, ServerRole>;
+  constructor(client: Client) {
+    this.client = client;
+    this.cache = new Collection();
+  }
+  setCache(rawServerRole: RawServerRole) {
+    const server = new ServerRole(this.client, rawServerRole);
+    this.cache.set(server.id, server);
+    return server;
+  }
+}
+
+export class ServerRole {
+  client: Client;
+  id: string;
+  name: string;
+  permissions: number;
+  hexColor: string;
+  server: Server;
+  order: number;
+  isDefaultRole?: boolean;
+  constructor(client: Client, role: RawServerRole) {
+    this.client = client;
+    this.server = this.client.servers.cache.get(role.serverId)!;
+
+    this.id = role.id;
+    this.name = role.name;
+    this.permissions = role.permissions;
+    this.hexColor = role.hexColor;
+    this.order = role.order;
+    this.isDefaultRole = this.server.defaultRoleId === this.id;
+  }
+}

package/src/classes/User.ts

@@ -0,0 +1,46 @@
+import { RawUser } from "../RawData";
+import { Client } from "./Client";
+import { Collection } from "./Collection";
+
+export class Users {
+  client: Client;
+  cache: Collection<string, User>;
+  constructor(client: Client) {
+    this.client = client;
+    this.cache = new Collection();
+  }
+  setCache(rawUser: RawUser) {
+    const user = new User(this.client, rawUser);
+    this.cache.set(rawUser.id, user);
+    return user;
+  }
+}
+export class User {
+  client: Client;
+  id: string;
+  avatar?: string;
+  banner?: string;
+  username: string;
+  hexColor: string;
+  tag: string;
+  badges: number;
+  joinedAt?: number;
+  bot?: boolean;
+  constructor(client: Client, user: RawUser) {
+    this.client = client;
+
+    this.id = user.id;
+    this.username = user.username;
+    this.tag = user.tag;
+
+    this.hexColor = user.hexColor;
+    this.badges = user.badges;
+    this.joinedAt = user.joinedAt;
+    this.avatar = user.avatar;
+    this.banner = user.banner;
+    this.bot = user.bot;
+  }
+  toString() {
+    return `[@:${this.id}]`;
+  }
+}

package/src/classes/Webhooks.ts

@@ -0,0 +1,144 @@
+/**
+ * Options for sending a webhook message.
+ */
+export interface WebhookOptions {
+  /** Message content. */
+  content?: string;
+  /** Username to display. */
+  username?: string;
+  /** Avatar URL to display. */
+  avatarUrl?: string;
+}
+
+/**
+ * Nerimity.js implementation for sending Nerimity webhooks.
+ */
+export class WebhookBuilder {
+  private channelId: string = "";
+  private token: string = "";
+  private options: WebhookOptions;
+
+  /**
+   * Creates a new WebhookBuilder instance.
+   *
+   * @param webhook - The webhook identifier. Can be:
+   *   - Full URL: `"https://nerimity.com/api/webhooks/{channelId}/{token}"`
+   * @param options - Optional webhook message options (content, username, avatarUrl).
+   *
+   * @throws If the webhook format is invalid or missing required fields.
+   */
+  constructor(
+    webhook: string | { channelId: string; token: string },
+    options: WebhookOptions = {}
+  ) {
+    this.options = options;
+
+    if (typeof webhook === "object") {
+      if (!webhook.channelId || !webhook.token)
+        throw new Error("Webhook object must have channelId and token");
+      this.channelId = webhook.channelId;
+      this.token = webhook.token;
+    } else {
+      this.parseWebhookString(webhook);
+    }
+
+    this.validateOptions(this.options);
+  }
+
+  /**
+   * Parse webhook string format and extract channelId + token.
+   *
+   * @param webhook - Webhook string in one of the accepted formats.
+   * @throws If the string is not a valid webhook format.
+   */
+  private parseWebhookString(webhook: string) {
+    if (!webhook || typeof webhook !== "string")
+      throw new Error("Webhook must be a non-empty string");
+
+    if (webhook.startsWith("http")) {
+      const match = webhook.match(/\/webhooks\/(\d+)\/(.+)$/);
+      if (!match) throw new Error(`Invalid webhook URL: ${webhook}`);
+      this.channelId = match[1];
+      this.token = match[2];
+    } else {
+      throw new Error(`Unrecognized webhook format: ${webhook}`);
+    }
+  }
+
+  /**
+   * Validate message options (content, username, avatarUrl).
+   *
+   * @param options - The options object to validate.
+   * @throws If an option type is invalid.
+   */
+  private validateOptions(options: WebhookOptions) {
+    if (options.username && typeof options.username !== "string")
+      throw new Error("Webhook option 'username' must be a string");
+    if (options.avatarUrl && typeof options.avatarUrl !== "string")
+      throw new Error("Webhook option 'avatarUrl' must be a string");
+  }
+
+  /**
+   * Set the username override for the webhook.
+   *
+   * @param username - The custom username.
+   * @returns The current WebhookBuilder instance (for chaining).
+   *
+   * @throws If username is not a string.
+   */
+  public setUsername(username: string) {
+    if (typeof username !== "string")
+      throw new Error("Username must be a string");
+    this.options.username = username;
+    return this;
+  }
+
+  /**
+   * Set the avatar image for the webhook.
+   *
+   * @param avatarUrl - The avatar image URL.
+   * @returns The current WebhookBuilder instance (for chaining).
+   *
+   * @throws If avatarUrl is not a string.
+   */
+  public setAvatar(avatarUrl: string) {
+    if (typeof avatarUrl !== "string")
+      throw new Error("Avatar URL must be a string");
+    this.options.avatarUrl = avatarUrl;
+    return this;
+  }
+
+  /**
+   * Sends the webhook request to Nerimity's API.
+   *
+   * @returns A Promise resolving with the JSON response from the API.
+   *
+   * @throws If the request fails, is unauthorized, or returns invalid JSON.
+   */
+  public async send(content: string): Promise<any> {
+    const url = `https://nerimity.com/api/webhooks/${this.channelId}/${this.token}`;
+
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content, ...this.options }),
+      });
+
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(
+          `HTTP ${res.status} ${res.statusText}${body ? ` - ${body}` : ""}`
+        );
+      }
+
+      const json = await res.json().catch(() => {
+        throw new Error("Webhook returned invalid JSON");
+      });
+
+      return json;
+    } catch (err: any) {
+      throw new Error(`Failed to send webhook: ${err.message}`);
+    }
+  }
+}

package/src/example.ts

@@ -1,27 +1,25 @@
-import { Client, Events } from './Client';
+import { Client, Events } from "./classes/Client";
 
 const client = new Client();
 
-
 client.on(Events.Ready, () => {
-    console.log(`Connected as ${client.user?.username}!`);
+  console.log(`Connected as ${client.user?.username}!`);
 });
 
-client.on(Events.MessageCreate, message => {
-    console.log(message.content);
-    if (message.content === '!ping') {
-        message.reply('Pong!', {buttons: [{id: 'hello', label: 'Hello!'}]});
-    }
+client.on(Events.MessageCreate, (message) => {
+  console.log(message.content);
+  if (message.content === "!ping") {
+    message.reply("Pong!", { buttons: [{ id: "hello", label: "Hello!" }] });
+  }
 });
 
-client.on(Events.MessageButtonClick, button => {  
-    if (button.id === 'hello') {
-
-        button.respond({
-            title: 'Hey!',
-            content: `Hey there **${button.user?.username}**!`
-        });
-    }
+client.on(Events.MessageButtonClick, (button) => {
+  if (button.id === "hello") {
+    button.respond({
+      title: "Hey!",
+      content: `Hey there **${button.user?.username}**!`,
+    });
+  }
 });
 
-client.login('token');
+client.login("token");

package/src/factory/ChannelFactory.ts

@@ -0,0 +1,22 @@
+// Import the base class and the subclass for runtime construction
+
+import { Channel } from "../classes/Channel";
+import { Client } from "../classes/Client";
+import { ServerChannel } from "../classes/ServerChannel";
+import { RawChannel } from "../RawData";
+import { AllChannel } from "../types";
+
+// Define the function that decides which class to instantiate
+export function createChannel(
+  client: Client,
+  rawChannel: { id: string } & Partial<RawChannel>
+): AllChannel {
+  const channelData = rawChannel as RawChannel; // Cast once for convenience
+
+  if (channelData.serverId) {
+    // Here, ServerChannel is imported as a runtime value and is available
+    return new ServerChannel(client, channelData);
+  } else {
+    return new Channel(client, channelData);
+  }
+}

package/src/index.ts

@@ -1,5 +1,5 @@
-export { Client, Events } from "./Client";
-export { AttachmentBuilder } from "./Attachment";
-export { RPCClient, EmitPayload } from "./RPCClient";
-export { WebhookBuilder } from "./Webhooks";
+export { Client, Events } from "./classes/Client";
+export { AttachmentBuilder } from "./classes/Attachment";
+export { RPCClient, EmitPayload } from "./classes/RPCClient";
+export { WebhookBuilder } from "./classes/Webhooks";
 export { RolePermissions } from "./bitwise";

package/src/services/MessageService.ts

@@ -1,4 +1,4 @@
-import { Client } from "../Client";
+import { Client } from "../classes/Client";
 import { RawMessage, RawMessageButton } from "../RawData";
 import { ServiceEndpoints } from "./serviceEndpoints";
 import fetch from "node-fetch";
@@ -184,7 +184,7 @@ export async function request<T>(opts: RequestOpts): Promise<T> {
       return Promise.reject(json);
     }
     return json;
-  } catch (e) {
+  } catch {
     throw { message: text };
   }
 }

package/src/services/PostsService.ts

@@ -1,71 +1,75 @@
-import { Client } from '../Client';
-import { RawPost } from '../RawData';
-import { request } from './MessageService'
-import { ServiceEndpoints } from './serviceEndpoints';
+import { Client } from "../classes/Client";
+import { RawPost } from "../RawData";
+import { request } from "./MessageService";
+import { ServiceEndpoints } from "./serviceEndpoints";
 
 interface PostPostOpts {
-    client: Client;
-    postId?: string;
-    content: string;
-    nerimityCdnFileId?: string;
-    poll?: {
-        choices: string[];
-    };
+  client: Client;
+  postId?: string;
+  content: string;
+  nerimityCdnFileId?: string;
+  poll?: {
+    choices: string[];
+  };
 }
 
 interface EditPostOpts {
-    client: Client;
-    postId: string;
-    content: string;
+  client: Client;
+  postId: string;
+  content: string;
 }
 
 interface DeletePostOpts {
-    client: Client;
-    postId: string;
+  client: Client;
+  postId: string;
 }
 
 export async function getPosts(client: Client) {
-    return await request<RawPost[]>({
-        client: client,
-        url: ServiceEndpoints.GetPosts(),
-        method: 'GET',
-        useToken: true,
-    }).catch(err => {
-        throw new Error(`Failed to get posts. ${err.message}`);
-    });
+  return await request<RawPost[]>({
+    client: client,
+    url: ServiceEndpoints.GetPosts(),
+    method: "GET",
+    useToken: true,
+  }).catch((err) => {
+    throw new Error(`Failed to get posts. ${err.message}`);
+  });
 }
 
 export async function postPost(opts: PostPostOpts) {
-    return await request<RawPost>({
-        client: opts.client,
-        url: ServiceEndpoints.PostPost(),
-        method: 'POST',
-        body: {content: opts.content, nerimityCdnFileId: opts.nerimityCdnFileId, poll: opts.poll},
-        useToken: true,
-    }).catch(err => {
-        throw new Error(`Failed to send post. ${err.message}`);
-    });
+  return await request<RawPost>({
+    client: opts.client,
+    url: ServiceEndpoints.PostPost(),
+    method: "POST",
+    body: {
+      content: opts.content,
+      nerimityCdnFileId: opts.nerimityCdnFileId,
+      poll: opts.poll,
+    },
+    useToken: true,
+  }).catch((err) => {
+    throw new Error(`Failed to send post. ${err.message}`);
+  });
 }
 
 export async function editPost(opts: EditPostOpts) {
-    return await request<RawPost>({
-        client: opts.client,
-        url: ServiceEndpoints.EditPost(opts.postId),
-        method: 'PATCH',
-        body: {content: opts.content},
-        useToken: true,
-    }).catch(err => {
-        throw new Error(`Failed to edit post. ${err.message}`);
-    })
+  return await request<RawPost>({
+    client: opts.client,
+    url: ServiceEndpoints.EditPost(opts.postId),
+    method: "PATCH",
+    body: { content: opts.content },
+    useToken: true,
+  }).catch((err) => {
+    throw new Error(`Failed to edit post. ${err.message}`);
+  });
 }
 
 export async function deletePost(opts: DeletePostOpts) {
-    return await request({
-        client: opts.client,
-        url: ServiceEndpoints.DeletePost(opts.postId),
-        method: 'DELETE',
-        useToken: true,
-    }).catch(err => {
-        throw new Error(`Failed to delete post. ${err.message}`);
-    });
-}
+  return await request({
+    client: opts.client,
+    url: ServiceEndpoints.DeletePost(opts.postId),
+    method: "DELETE",
+    useToken: true,
+  }).catch((err) => {
+    throw new Error(`Failed to delete post. ${err.message}`);
+  });
+}

package/src/services/ServerService.ts

@@ -1,4 +1,4 @@
-import { Client } from "../Client";
+import { Client } from "../classes/Client";
 import { request } from "./MessageService";
 import { ServiceEndpoints } from "./serviceEndpoints";
 
@@ -16,3 +16,32 @@ export async function banServerMember(
     throw new Error(`Failed to ban server member. ${err.message}`);
   });
 }
+
+export async function unbanServerMember(
+  client: Client,
+  serverId: string,
+  userId: string
+) {
+  return await request<any>({
+    client: client,
+    url: ServiceEndpoints.serverMemberBan(serverId, userId),
+    method: "DELETE",
+    useToken: true,
+  }).catch((err) => {
+    throw new Error(`Failed to unban server member. ${err.message}`);
+  });
+}
+export async function kickServerMember(
+  client: Client,
+  serverId: string,
+  userId: string
+) {
+  return await request<any>({
+    client: client,
+    url: ServiceEndpoints.serverMemberKick(serverId, userId),
+    method: "DELETE",
+    useToken: true,
+  }).catch((err) => {
+    throw new Error(`Failed to kick server member. ${err.message}`);
+  });
+}

package/src/services/serviceEndpoints.ts

@@ -31,6 +31,9 @@ const ButtonClickCallback = (
 const serverMemberBan = (serverId: string, userId: string) =>
   `${BaseUrl}/servers/${serverId}/bans/${userId}`;
 
+const serverMemberKick = (serverId: string, userId: string) =>
+  `${BaseUrl}/servers/${serverId}/members/${userId}/kick`;
+
 export const ServiceEndpoints = {
   GetMessages,
   PostMessage,
@@ -42,4 +45,5 @@ export const ServiceEndpoints = {
   BotCommands,
   ButtonClickCallback,
   serverMemberBan,
+  serverMemberKick,
 };

package/src/types.ts

@@ -0,0 +1,4 @@
+import { type Channel } from "./classes/Channel";
+import { type ServerChannel } from "./classes/ServerChannel";
+
+export type AllChannel = ServerChannel | Channel;

package/.eslintrc.js

@@ -1,21 +0,0 @@
-module.exports = {
-  env: {
-    browser: true,
-    es2021: true,
-    node: true,
-  },
-  extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
-  overrides: [],
-  parser: "@typescript-eslint/parser",
-  parserOptions: {
-    ecmaVersion: "latest",
-    sourceType: "module",
-  },
-  plugins: ["@typescript-eslint"],
-  rules: {
-    indent: ["error", 2],
-    "linebreak-style": ["error", "windows"],
-    quotes: ["error", "multi"],
-    semi: ["error", "always"],
-  },
-};