hypixel-api-reborn 11.3.4 → 12.0.0-0

package/src/Private/CacheHandler.test.ts

@@ -0,0 +1,49 @@
+import CacheHandler from './CacheHandler';
+import Client from '../Client';
+import NodeCache from 'node-cache';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('CacheHandler', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client).toBeDefined();
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  expect(client.cacheHandler).toBeDefined();
+  expectTypeOf(client.cacheHandler).toEqualTypeOf<CacheHandler>();
+
+  expect(client.cacheHandler.cache).toBeDefined();
+  expectTypeOf(client.cacheHandler.cache).toEqualTypeOf<NodeCache>();
+
+  expect(client.cacheHandler.set).toBeDefined();
+  expectTypeOf(client.cacheHandler.set).toBeFunction();
+  expect(() => client.cacheHandler.set('test', 'value')).not.toThrow();
+
+  expect(client.cacheHandler.get).toBeDefined();
+  expectTypeOf(client.cacheHandler.get).toBeFunction();
+  expect(() => client.cacheHandler.has('test')).not.toThrow();
+  expect(client.cacheHandler.has('test')).toBe(true);
+
+  expect(client.cacheHandler.get).toBeDefined();
+  expectTypeOf(client.cacheHandler.get).toBeFunction();
+  expect(() => client.cacheHandler.get('test')).not.toThrow();
+  expect(client.cacheHandler.get('test')).toBe('value');
+
+  expect(client.cacheHandler.keys).toBeDefined();
+  expectTypeOf(client.cacheHandler.keys).toBeFunction();
+  expect(() => client.cacheHandler.keys()).not.toThrow();
+  expect(client.cacheHandler.keys()).toEqual(['test']);
+  expectTypeOf(client.cacheHandler.keys()).toEqualTypeOf<string[]>();
+
+  expect(client.cacheHandler.size).toBeDefined();
+  expectTypeOf(client.cacheHandler.size).toBeFunction();
+  expect(() => client.cacheHandler.size()).not.toThrow();
+  expect(client.cacheHandler.size()).toBe(1);
+  expectTypeOf(client.cacheHandler.size()).toEqualTypeOf<number>();
+
+  expect(client.cacheHandler.clear).toBeDefined();
+  expectTypeOf(client.cacheHandler.clear).toBeFunction();
+  expect(() => client.cacheHandler.clear()).not.toThrow();
+  expect(client.cacheHandler.size()).toBe(0);
+
+  client.destroy();
+});

package/src/Private/CacheHandler.ts

@@ -0,0 +1,41 @@
+import Client from '../Client';
+import NodeCache from 'node-cache';
+
+class CacheHandler {
+  readonly client: Client;
+  declare cache: NodeCache;
+  constructor(client: Client) {
+    this.client = client;
+    this.cache = new NodeCache({
+      stdTTL: this.client.options.cacheTime,
+      maxKeys: this.client.options.cacheMaxKeys,
+      checkperiod: this.client.options.cacheCheckPeriod
+    });
+  }
+
+  set(key: string, value: any): any {
+    return this.cache.set(key, value);
+  }
+
+  has(key: string): boolean {
+    return this.cache.has(key);
+  }
+
+  get(key: string): any {
+    return this.cache.get(key);
+  }
+
+  keys(): string[] {
+    return this.cache.keys();
+  }
+
+  size(): number {
+    return this.cache.keys().length;
+  }
+
+  clear(): void {
+    this.cache.flushAll();
+  }
+}
+
+export default CacheHandler;

package/src/Private/Endpoint.test.ts

@@ -0,0 +1,23 @@
+import Client from '../Client';
+import Endpoint from './Endpoint';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('Endpoint', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client).toBeDefined();
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  const endpoint = new Endpoint(client);
+
+  expect(endpoint).toBeDefined();
+  expectTypeOf(endpoint).toEqualTypeOf<Endpoint>();
+
+  expect(endpoint.client).toBeDefined();
+  expectTypeOf(endpoint.client).toEqualTypeOf<Client>();
+
+  expect(endpoint.execute).toBeDefined();
+  expectTypeOf(endpoint.execute).toBeFunction();
+  expect(() => endpoint.execute()).toThrowError(client.errors.NOT_IMPLEMENTED);
+
+  client.destroy();
+});

package/src/Private/Endpoint.ts

@@ -0,0 +1,14 @@
+import Client from '../Client';
+
+class Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    this.client = client;
+  }
+
+  execute(...args: any[]): Promise<any> | any {
+    throw new Error(this.client.errors.NOT_IMPLEMENTED);
+  }
+}
+
+export default Endpoint;

package/src/Private/RateLimit.test.ts

@@ -0,0 +1,99 @@
+import Client from '../Client';
+import RateLimit from './RateLimit';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+
+test('RateLimit (None)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { rateLimit: 'NONE' });
+  expect(client).toBeDefined();
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  expect(client.rateLimit).toBeDefined();
+  expectTypeOf(client.rateLimit).toEqualTypeOf<RateLimit>();
+
+  expect(client.rateLimit.requests).toBe(0);
+  expectTypeOf(client.rateLimit.requests).toEqualTypeOf<number>();
+  expect(client.rateLimit.limit).toBe(0);
+  expectTypeOf(client.rateLimit.limit).toEqualTypeOf<number>();
+  expect(client.rateLimit.initialized).toBe(false);
+  expectTypeOf(client.rateLimit.initialized).toEqualTypeOf<boolean>();
+
+  expect(client.rateLimit.sync).toBeDefined();
+  expectTypeOf(client.rateLimit.sync).toBeFunction();
+  expect(() => client.rateLimit.sync()).not.toThrow();
+
+  expect(client.rateLimit.reset).toBeDefined();
+  expectTypeOf(client.rateLimit.reset).toBeFunction();
+  expect(() => client.rateLimit.reset()).not.toThrow();
+
+  expect(client.rateLimit.initialize).toBeDefined();
+  expectTypeOf(client.rateLimit.initialize).toBeFunction();
+  expect(() => client.rateLimit.initialize()).not.toThrow();
+
+  client.destroy();
+});
+
+test('RateLimit (Auto)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { rateLimit: 'NONE' });
+  expect(client).toBeDefined();
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  expect(client.rateLimit).toBeDefined();
+  expectTypeOf(client.rateLimit).toEqualTypeOf<RateLimit>();
+  await client.rateLimit.initialize();
+
+  expect(client.rateLimit.requests).greaterThan(0);
+  expectTypeOf(client.rateLimit.requests).toEqualTypeOf<number>();
+  expect(client.rateLimit.limit).toBe(300);
+  expectTypeOf(client.rateLimit.limit).toEqualTypeOf<number>();
+  expect(client.rateLimit.initialized).toBe(true);
+  expectTypeOf(client.rateLimit.initialized).toEqualTypeOf<boolean>();
+
+  expect(client.rateLimit.sync).toBeDefined();
+  expectTypeOf(client.rateLimit.sync).toBeFunction();
+  expect(() => client.rateLimit.sync()).not.toThrow();
+
+  expect(client.rateLimit.reset).toBeDefined();
+  expectTypeOf(client.rateLimit.reset).toBeFunction();
+  expect(() => client.rateLimit.reset()).not.toThrow();
+
+  expect(client.rateLimit.initialize).toBeDefined();
+  expectTypeOf(client.rateLimit.initialize).toBeFunction();
+  expect(() => client.rateLimit.initialize()).not.toThrow();
+
+  client.destroy();
+});
+
+test('Ratelimit (Sync)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  client.updater.currentVersion = '1.0.0';
+  const mockRequest = {
+    status: 200,
+    data: { success: true },
+    headers: {
+      'ratelimit-limit': 30,
+      'ratelimit-remaining': 27
+    }
+  };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  expect(() => client.rateLimit.sync()).not.toThrowError();
+  await client.rateLimit.sync();
+  expect(client.rateLimit.requests).toBe(3);
+  expect(client.rateLimit.limit).toBe(30);
+  vi.restoreAllMocks();
+  client.destroy();
+});
+
+test('Ratelimit (Bad Sync Data)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  client.updater.currentVersion = '1.0.0';
+  const mockRequest = {
+    status: 200,
+    data: { success: true },
+    headers: { hello: 100 }
+  };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  expect(() => client.rateLimit.sync()).rejects.toThrowError(client.errors.RATE_LIMIT_INIT_ERROR);
+  vi.restoreAllMocks();
+  client.destroy();
+});

package/src/Private/RateLimit.ts

@@ -0,0 +1,38 @@
+import Client from '../Client';
+
+class RateLimit {
+  readonly client: Client;
+  declare requests: number;
+  declare limit: number;
+  declare initialized: boolean;
+  declare interval: NodeJS.Timeout;
+  constructor(client: Client) {
+    this.client = client;
+    this.requests = 0;
+    this.limit = 0;
+    this.initialized = false;
+    this.interval = setInterval(() => this.reset(), 300000);
+  }
+
+  async sync() {
+    const { headers } = await this.client.requests.request('/boosters', { raw: true });
+    if (headers?.['ratelimit-limit'] === undefined || headers?.['ratelimit-remaining'] === undefined) {
+      throw new Error(this.client.errors.RATE_LIMIT_INIT_ERROR);
+    }
+    this.requests = headers['ratelimit-limit'] - headers['ratelimit-remaining'];
+    this.limit = Number(headers['ratelimit-limit']);
+  }
+
+  reset() {
+    if (false === this.initialized) return;
+    this.requests = 0;
+  }
+
+  async initialize() {
+    if (this.initialized) return;
+    await this.sync();
+    this.initialized = true;
+  }
+}
+
+export default RateLimit;

package/src/Private/Requests.test.ts

@@ -0,0 +1,59 @@
+import Client from '../Client';
+import Requests from './Requests';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+
+test('Requests', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client).toBeDefined();
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  expect(client.requests).toBeDefined();
+  expectTypeOf(client.requests).toEqualTypeOf<Requests>();
+
+  expect(client.requests.toUUID).toBeDefined();
+  expectTypeOf(client.requests.toUUID).toBeFunction();
+  const data = await client.requests.toUUID('pixelic');
+  expect(data).toBe('14727faefbdc4aff848cd2713eb9939e');
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  expect(() => client.requests.toUUID()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  expect(() => client.requests.toUUID(-1)).rejects.toThrowError(client.errors.UUID_NICKNAME_MUST_BE_A_STRING);
+
+  client.destroy();
+});
+
+test('Requests (Invalid API Key)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client.requests.request).toBeDefined();
+  expectTypeOf(client.requests.request).toBeFunction();
+  const mockRequest = { status: 403, data: {} };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  expect(() => client.requests.request('/boosters')).rejects.toThrowError(client.errors.INVALID_API_KEY);
+  vi.restoreAllMocks();
+  client.destroy();
+});
+
+test('Requests (Unprocessable Entity)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client.requests.request).toBeDefined();
+  expectTypeOf(client.requests.request).toBeFunction();
+  const mockRequest = { status: 422, data: {} };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  expect(() => client.requests.request('/boosters')).rejects.toThrowError(client.errors.UNEXPECTED_ERROR);
+  vi.restoreAllMocks();
+  client.destroy();
+});
+
+test('Requests (Rate Limited)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client.requests.request).toBeDefined();
+  expectTypeOf(client.requests.request).toBeFunction();
+  const mockRequest = { status: 429, data: {} };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  expect(() => client.requests.request('/boosters')).rejects.toThrowError(client.errors.RATE_LIMIT_EXCEEDED);
+  vi.restoreAllMocks();
+  client.destroy();
+});

package/src/Private/Requests.ts

@@ -0,0 +1,128 @@
+const BASE_URL = 'https://api.hypixel.net/v2';
+import Client from '../Client';
+import axios from 'axios';
+import isUUID from '../utils/isUUID';
+
+export interface RequestOptions {
+  raw?: boolean;
+  noCache?: boolean;
+}
+
+class RequestData {
+  readonly data: any;
+  readonly headers: Record<string, any>;
+  readonly statusCode: number;
+  readonly options: RequestOptions;
+  readonly requestTimestamp: number;
+  readonly requestAt: Date;
+  readonly requestUrl: string;
+  readonly cached: boolean;
+  constructor(
+    data: Record<string, any>,
+    headers: Record<string, any>,
+    info: { status: number; url: string; options: RequestOptions; cached: boolean; timestamp?: number }
+  ) {
+    this.data = data;
+    this.headers = headers;
+    this.statusCode = info.status;
+    this.options = info.options;
+    this.requestTimestamp = info.timestamp || Date.now();
+    this.requestAt = new Date(this.requestTimestamp);
+    this.requestUrl = info.url;
+    this.cached = info.cached;
+  }
+}
+
+class Requests {
+  readonly client: Client;
+  constructor(client: Client) {
+    this.client = client;
+  }
+
+  async request(endpoint: string, options?: RequestOptions): Promise<RequestData> {
+    options = { raw: options?.raw ?? false, noCache: options?.noCache ?? false };
+    if (this.client.cacheHandler.has(endpoint)) {
+      const data = this.client.cacheHandler.get(endpoint);
+      return new RequestData(data.data, data.headers, {
+        status: 200,
+        options,
+        url: endpoint,
+        cached: true,
+        timestamp: data.timestamp
+      });
+    }
+    const res = await axios.get(BASE_URL + endpoint, { headers: { 'API-Key': this.client.key } });
+    if (500 <= res.status && 528 > res.status) {
+      throw new Error(
+        this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, `Server Error : ${res.status} ${res.statusText}`)
+      );
+    }
+    const parsedRes = await res.data;
+    if (400 === res.status) {
+      throw new Error(
+        this.client.errors.ERROR_CODE_CAUSE.replace(/{code}/, '400 Bad Request').replace(
+          /{cause}/,
+          parsedRes.cause || ''
+        )
+      );
+    }
+    if (403 === res.status) throw new Error(this.client.errors.INVALID_API_KEY);
+    if (422 === res.status) throw new Error(this.client.errors.UNEXPECTED_ERROR);
+    if (429 === res.status) throw new Error(this.client.errors.RATE_LIMIT_EXCEEDED);
+    if (200 !== res.status) {
+      throw new Error(this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, res.statusText));
+    }
+    if (!parsedRes.success && !endpoint.startsWith('/housing')) {
+      throw new Error(this.client.errors.SOMETHING_WENT_WRONG.replace(/{cause}/, res.statusText));
+    }
+    this.client.rateLimit.requests++;
+    const requestData = new RequestData(parsedRes, res.headers, {
+      status: res.status,
+      options,
+      url: endpoint,
+      cached: false
+    });
+    if (options.noCache) return requestData;
+    if (this.client.options.cache && !options.raw) {
+      this.client.cacheHandler.set(endpoint, requestData);
+    }
+    return requestData;
+  }
+
+  async toUUID(input: string): Promise<string> {
+    if (!input) throw new Error(this.client.errors.NO_NICKNAME_UUID);
+    if ('string' !== typeof input) throw new Error(this.client.errors.UUID_NICKNAME_MUST_BE_A_STRING);
+    if (isUUID(input)) return input.replace(/-/g, '');
+    const url = `https://mowojang.matdoes.dev/${input}`;
+    if (this.client.cacheHandler.has(url)) {
+      return this.client.cacheHandler.get(url);
+    }
+    const res = await axios.get(url);
+    if (500 <= res.status && 528 > res.status) {
+      throw new Error(
+        this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, `Server Error : ${res.status} ${res.statusText}`)
+      );
+    }
+    const parsedRes = await res.data;
+    if (400 === res.status) {
+      throw new Error(
+        this.client.errors.ERROR_CODE_CAUSE.replace(/{code}/, '400 Bad Request').replace(
+          /{cause}/,
+          parsedRes.cause || ''
+        )
+      );
+    }
+    if (200 !== res.status) {
+      throw new Error(this.client.errors.ERROR_STATUSTEXT.replace(/{statustext}/, res.statusText));
+    }
+    if ('string' !== typeof parsedRes.id || 'string' !== typeof parsedRes.name) {
+      throw new Error(this.client.errors.MALFORMED_UUID);
+    }
+    if (this.client.options.cache) {
+      this.client.cacheHandler.set(url, parsedRes.id);
+    }
+    return parsedRes.id;
+  }
+}
+
+export default Requests;

package/src/Private/Updater.test.ts

@@ -0,0 +1,68 @@
+import Client from '../Client';
+import Updater from './Updater';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+import { version } from '../../package.json';
+
+test('Updater', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client).toBeDefined();
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  expect(client.updater).toBeDefined();
+  expectTypeOf(client.updater).toEqualTypeOf<Updater>();
+
+  expect(client.updater.currentVersion).toBe(version);
+  expect(client.updater.latestVersion).toBe('0.0.0');
+
+  expect(client.updater.checkForUpdates).toBeDefined();
+  expectTypeOf(client.updater.checkForUpdates).toBeFunction();
+  expect(() => client.updater.checkForUpdates()).not.toThrow();
+
+  expect(client.updater.getLatestVersion).toBeDefined();
+  expectTypeOf(client.updater.getLatestVersion).toBeFunction();
+  expect(() => client.updater.getLatestVersion()).not.toThrow();
+
+  expect(client.updater.compareVersions).toBeDefined();
+  expectTypeOf(client.updater.compareVersions).toBeFunction();
+  expect(() => client.updater.compareVersions('1.0.0', '1.0.0')).not.toThrow();
+  expect(client.updater.compareVersions('1.0.0', '1.0.0')).toBe(false);
+  expect(client.updater.compareVersions('1.0.0', '1.0.1')).toBe(true);
+  expect(client.updater.compareVersions('1.0.1', '1.0.0')).toBe(false);
+  expect(client.updater.compareVersions('meow', '1.0.0')).toBe(false);
+
+  client.destroy();
+});
+
+test('Updater (get latest version)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  const mockRequest = { status: 200, data: { 'dist-tags': { latest: '1.0.0' } } };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  const data = await client.updater.getLatestVersion();
+  expect(data).toBe('1.0.0');
+  vi.restoreAllMocks();
+  client.destroy();
+});
+
+test('Updater (get latest version error)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  const mockRequest = { status: 404, data: { 'dist-tags': { latest: '1.0.0' } } };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  expect(() => client.updater.getLatestVersion()).rejects.toThrowError(client.errors.UPDATER_REQUEST_NOT_OK);
+  vi.restoreAllMocks();
+  client.destroy();
+});
+
+test('Updater (check version)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  const consoleLogSpy = vi.spyOn(console, 'log');
+  client.updater.currentVersion = '1.0.0';
+  const mockRequest = { status: 200, data: { 'dist-tags': { latest: version } } };
+  vi.spyOn(axios, 'get').mockResolvedValue(mockRequest);
+  await client.updater.checkForUpdates();
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    `New version of hypixel-api-reborn is available! Current version: 1.0.0, Latest version: ${version}`
+  );
+  vi.restoreAllMocks();
+  client.destroy();
+});

package/src/Private/Updater.ts

@@ -0,0 +1,48 @@
+/* eslint-disable no-console */
+import Client from '../Client';
+import axios from 'axios';
+import { version } from '../../package.json';
+
+class Updater {
+  readonly client: Client;
+  currentVersion: string;
+  latestVersion: string;
+  constructor(client: Client) {
+    this.client = client;
+    this.currentVersion = version;
+    this.latestVersion = '0.0.0';
+  }
+
+  async checkForUpdates(): Promise<void> {
+    this.latestVersion = await this.getLatestVersion();
+    const compare = this.compareVersions(this.currentVersion, this.latestVersion);
+    if (compare) {
+      console.log(
+        `New version of hypixel-api-reborn is available! Current version: ${
+          this.currentVersion
+        }, Latest version: ${this.latestVersion}`
+      );
+    }
+  }
+
+  async getLatestVersion(): Promise<string> {
+    const request = await axios.get('https://registry.npmjs.org/hypixel-api-reborn');
+    if (200 !== request.status) throw new Error(this.client.errors.UPDATER_REQUEST_NOT_OK);
+    return request.data['dist-tags'].latest;
+  }
+
+  compareVersions(a: string, b: string): boolean {
+    const pa = a.split('.');
+    const pb = b.split('.');
+    for (let i = 0; 3 > i; i++) {
+      const na = Number(pa[i]);
+      const nb = Number(pb[i]);
+      if (isNaN(na) || isNaN(nb)) return false;
+      if (na > nb) return false;
+      if (nb > na) return true;
+    }
+    return false;
+  }
+}
+
+export default Updater;