@erinjs/core 1.0.0

package/core/packages/fluxer-core/src/structures/Invite.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Client, Invite } from '../';
+import { Routes } from '@erinjs/types';
+
+function createMockClient() {
+  return {} as Client;
+}
+
+function createMockClientWithInviteResponse(response: {
+  code?: string;
+  type?: number;
+  guild?: { id: string; name: string };
+  channel?: { id: string; name: string; type: number };
+}) {
+  const get = vi.fn().mockResolvedValue({
+    code: response.code ?? 'abc123',
+    type: response.type ?? 0,
+    guild: response.guild ?? { id: 'g1', name: 'Test' },
+    channel: response.channel ?? { id: 'ch1', name: 'general', type: 0 },
+  });
+
+  return {
+    client: {
+      rest: { get },
+      guilds: new Map(),
+    } as unknown as Client,
+    get,
+  };
+}
+
+function createInvite(overrides: { code?: string } = {}) {
+  return new Invite(createMockClient(), {
+    code: overrides.code ?? 'abc123',
+    type: 0,
+    guild: { id: 'g1', name: 'Test' },
+    channel: { id: 'ch1', name: 'general', type: 0 },
+  });
+}
+
+describe('Invite', () => {
+  describe('url', () => {
+    it('returns full invite URL with code', () => {
+      const invite = createInvite({ code: 'xyz789' });
+      expect(invite.url).toBe('https://fluxer.gg/xyz789');
+    });
+
+    it('uses invite code from constructor', () => {
+      const invite = createInvite({ code: 'discord' });
+      expect(invite.url).toBe('https://fluxer.gg/discord');
+    });
+  });
+
+  describe('constructor', () => {
+    it('parses invite code and channel', () => {
+      const invite = createInvite({ code: 'testcode' });
+      expect(invite.code).toBe('testcode');
+      expect(invite.channel.name).toBe('general');
+    });
+  });
+
+  describe('fetch()', () => {
+    it('fetches invite by raw code', async () => {
+      const { client, get } = createMockClientWithInviteResponse({ code: 'abc123' });
+
+      const invite = await Invite.fetch(client, 'abc123');
+
+      expect(get).toHaveBeenCalledWith(Routes.invite('abc123'));
+      expect(invite.code).toBe('abc123');
+    });
+
+    it('fetches invite by full URL', async () => {
+      const { client, get } = createMockClientWithInviteResponse({ code: 'xyz789' });
+
+      const invite = await Invite.fetch(client, 'https://fluxer.gg/xyz789');
+
+      expect(get).toHaveBeenCalledWith(Routes.invite('xyz789'));
+      expect(invite.code).toBe('xyz789');
+    });
+
+    it('fetches invite by /invite/{code} URL', async () => {
+      const { client, get } = createMockClientWithInviteResponse({ code: 'code123' });
+
+      const invite = await Invite.fetch(client, 'https://web.fluxer.app/invite/code123');
+
+      expect(get).toHaveBeenCalledWith(Routes.invite('code123'));
+      expect(invite.code).toBe('code123');
+    });
+
+    it('throws for empty input', async () => {
+      const { client } = createMockClientWithInviteResponse({});
+
+      await expect(Invite.fetch(client, '   ')).rejects.toThrow('Invite code cannot be empty');
+    });
+
+    it('throws for URL without code', async () => {
+      const { client } = createMockClientWithInviteResponse({});
+
+      await expect(Invite.fetch(client, 'https://fluxer.gg/')).rejects.toThrow(
+        'Invalid invite code or URL',
+      );
+    });
+  });
+});

package/core/packages/fluxer-core/src/structures/Invite.ts

@@ -0,0 +1,121 @@
+import { Client } from '../client/Client.js';
+import { Base } from './Base.js';
+import { APIInvite, APIGuildPartial, APIChannelPartial, APIUser } from '@erinjs/types';
+import { Routes } from '@erinjs/types';
+import { Guild } from './Guild.js';
+import { User } from './User.js';
+
+/** Represents an invite to a guild or channel. */
+export class Invite extends Base {
+  readonly client: Client;
+  readonly code: string;
+  readonly type: number;
+  readonly guild: APIGuildPartial;
+  readonly channel: APIChannelPartial;
+  readonly inviter: User | null;
+  readonly memberCount: number | null;
+  readonly presenceCount: number | null;
+  readonly expiresAt: string | null;
+  readonly temporary: boolean | null;
+  readonly createdAt: string | null;
+  readonly uses: number | null;
+  readonly maxUses: number | null;
+  readonly maxAge: number | null;
+
+  /**
+   * Normalize an invite input into a raw invite code.
+   * Accepts either an invite code (e.g. "abc123") or a URL (e.g. "https://fluxer.gg/abc123").
+   */
+  private static normalizeCode(codeOrUrl: string): string {
+    const input = codeOrUrl.trim();
+    if (!input) {
+      throw new RangeError('Invite code cannot be empty');
+    }
+
+    const parseAsUrl = (value: string): string | null => {
+      try {
+        const url = new URL(value);
+        const segments = url.pathname.split('/').filter(Boolean);
+        if (segments.length === 0) {
+          return null;
+        }
+
+        const inviteSegmentIdx = segments.findIndex((segment) => {
+          const lower = segment.toLowerCase();
+          return lower === 'invite' || lower === 'invites';
+        });
+
+        const code =
+          inviteSegmentIdx >= 0 && segments[inviteSegmentIdx + 1]
+            ? segments[inviteSegmentIdx + 1]
+            : segments[segments.length - 1];
+
+        return decodeURIComponent(code).trim();
+      } catch {
+        return null;
+      }
+    };
+
+    const directCode = decodeURIComponent(input).trim();
+    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(input);
+    const fromAbsoluteUrl = parseAsUrl(input);
+    const fromHostLike = hasScheme ? null : parseAsUrl(`https://${input}`);
+    const code = fromAbsoluteUrl ?? fromHostLike ?? directCode;
+
+    if (!code || /[\s/?#]/.test(code)) {
+      throw new RangeError('Invalid invite code or URL');
+    }
+
+    return code;
+  }
+
+  /** @param data - API invite from GET /invites/{code}, channel/guild invite list, or gateway INVITE_CREATE */
+  constructor(client: Client, data: APIInvite) {
+    super();
+    this.client = client;
+    this.code = data.code;
+    this.type = data.type;
+    this.guild = data.guild;
+    this.channel = data.channel;
+    this.inviter = data.inviter ? client.getOrCreateUser(data.inviter as APIUser) : null;
+    this.memberCount = data.member_count ?? null;
+    this.presenceCount = data.presence_count ?? null;
+    this.expiresAt = data.expires_at ?? null;
+    this.temporary = data.temporary ?? null;
+    this.createdAt = data.created_at ?? null;
+    this.uses = data.uses ?? null;
+    this.maxUses = data.max_uses ?? null;
+    this.maxAge = data.max_age ?? null;
+  }
+
+  /**
+   * Fetch invite information by code or URL.
+   * Does not consume or accept the invite.
+   */
+  static async fetch(client: Client, codeOrUrl: string): Promise<Invite> {
+    const code = Invite.normalizeCode(codeOrUrl);
+    const data = await client.rest.get(Routes.invite(code));
+    return new Invite(client, data as APIInvite);
+  }
+
+  /** Full invite URL (https://fluxer.gg/{code} or instance-specific). */
+  get url(): string {
+    return `https://fluxer.gg/${this.code}`;
+  }
+
+  /**
+   * Resolve the guild from cache if available.
+   * @returns The guild, or null if not cached
+   */
+  getGuild(): Guild | null {
+    return this.guild?.id ? (this.client.guilds.get(this.guild.id) ?? null) : null;
+  }
+
+  /**
+   * Delete this invite.
+   * Requires Manage Guild or Create Instant Invite permission.
+   */
+  async delete(): Promise<void> {
+    await this.client.rest.delete(Routes.invite(this.code), { auth: true });
+  }
+}

package/core/packages/fluxer-core/src/structures/Message.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { Message } from '../';
+
+describe('Message._createMessageBody', () => {
+  describe('reply (message_reference)', () => {
+    it('includes message_reference in body when replying (API expects this field)', async () => {
+      const ref = {
+        channel_id: 'ch1',
+        message_id: 'msg1',
+        guild_id: 'g1',
+      };
+      const payload = await Message._createMessageBody('Pong!', ref);
+      expect(payload.body).toHaveProperty('message_reference');
+      expect(payload.body.message_reference).toEqual(ref);
+      expect(payload.body.content).toBe('Pong!');
+    });
+
+    it('must NOT use referenced_message (that is for API response only)', async () => {
+      const ref = { channel_id: 'ch1', message_id: 'msg1' };
+      const payload = await Message._createMessageBody('Reply', ref);
+      expect(payload.body).not.toHaveProperty('referenced_message');
+      expect(payload.body).toHaveProperty('message_reference');
+    });
+
+    it('includes message_reference with options object', async () => {
+      const ref = { channel_id: 'ch1', message_id: 'msg1', guild_id: 'g1' };
+      const payload = await Message._createMessageBody({ content: 'Hello', embeds: [] }, ref);
+      expect(payload.body.message_reference).toEqual(ref);
+      expect(payload.body.content).toBe('Hello');
+    });
+
+    it('works without guild_id for DMs', async () => {
+      const ref = { channel_id: 'dm1', message_id: 'msg1' };
+      const payload = await Message._createMessageBody('DM reply', ref);
+      expect(payload.body.message_reference).toEqual(ref);
+      expect(payload.body.message_reference).not.toHaveProperty('guild_id');
+    });
+  });
+
+  describe('send (no reference)', () => {
+    it('does not include message_reference when not replying', async () => {
+      const payload = await Message._createMessageBody('Standalone message');
+      expect(payload.body).not.toHaveProperty('message_reference');
+      expect(payload.body).not.toHaveProperty('referenced_message');
+      expect(payload.body.content).toBe('Standalone message');
+    });
+
+    it('passes through content from options', async () => {
+      const payload = await Message._createMessageBody({ content: 'Test' });
+      expect(payload.body.content).toBe('Test');
+    });
+  });
+
+  describe('validation', () => {
+    it('throws RangeError for empty string', async () => {
+      await expect(Message._createMessageBody('')).rejects.toThrow(RangeError);
+      await expect(Message._createMessageBody('')).rejects.toThrow('Cannot send an empty message');
+    });
+
+    it('accepts non-empty string', async () => {
+      const payload = await Message._createMessageBody('x');
+      expect(payload.body.content).toBe('x');
+    });
+  });
+
+  describe('files', () => {
+    it('includes files in payload when provided', async () => {
+      const data = Buffer.from('hello');
+      const payload = await Message._createMessageBody({
+        content: 'File attached',
+        files: [{ name: 'test.txt', data }],
+      });
+      expect(payload.files).toHaveLength(1);
+      expect(payload.files![0].name).toBe('test.txt');
+      expect(payload.body.content).toBe('File attached');
+    });
+
+    it('reply with files includes message_reference', async () => {
+      const ref = { channel_id: 'ch1', message_id: 'msg1' };
+      const payload = await Message._createMessageBody(
+        { content: 'Reply with file', files: [{ name: 'a.txt', data: Buffer.from('x') }] },
+        ref,
+      );
+      expect(payload.body.message_reference).toEqual(ref);
+      expect(payload.files).toHaveLength(1);
+    });
+
+    it('reply with ping: false includes SuppressNotifications flag', async () => {
+      const ref = { channel_id: 'ch1', message_id: 'msg1' };
+      const payload = await Message._createMessageBody('No ping', ref, false);
+      expect(payload.body.message_reference).toEqual(ref);
+      expect(payload.body.flags).toBe(4096); // MessageFlags.SuppressNotifications
+    });
+
+    it('reply with ping: true does not add flags', async () => {
+      const ref = { channel_id: 'ch1', message_id: 'msg1' };
+      const payload = await Message._createMessageBody('Ping!', ref, true);
+      expect(payload.body.message_reference).toEqual(ref);
+      expect(payload.body.flags).toBeUndefined();
+    });
+
+    it('reply without ping param (default) does not add flags', async () => {
+      const ref = { channel_id: 'ch1', message_id: 'msg1' };
+      const payload = await Message._createMessageBody('Default ping', ref);
+      expect(payload.body.message_reference).toEqual(ref);
+      expect(payload.body.flags).toBeUndefined();
+    });
+  });
+});