ps99-api 1.0.0

package/src/ps99-api.ts

@@ -0,0 +1,104 @@
+import { ApiRequestParams, RequestClient } from "./request-client/common";
+import { getAxiosRequest } from "./request-client/axios";
+import { CollectionsResponseBody } from "./responses/collections";
+import { Collection } from "./common";
+import { CollectionResponseBody } from "./responses/collection";
+import { ClanResponseBody } from "./responses/clan";
+import { ClansResponseBody } from "./responses/clans";
+import { ClansSort, GetClansParams, SortOrder } from "./params/clans";
+import { ExistsResponseBody } from "./responses/exists";
+import { RAPResponseBody } from "./responses/rap";
+import { ActiveClanBattleResponseBody } from "./responses/activeClanBattle";
+
+export type PetSimulator99APIOptions = {
+  requestClient?: RequestClient;
+};
+export class PetSimulator99API {
+  public requestClient: RequestClient;
+
+  constructor(params?: PetSimulator99APIOptions) {
+    this.requestClient =
+      params && params.requestClient ? params.requestClient : getAxiosRequest();
+  }
+
+  private request<T>(
+    path: string,
+    {
+      params,
+      responseType,
+      responseEncoding,
+    }: {
+      params?: Record<string, unknown>;
+      responseType?: ApiRequestParams["responseType"];
+      responseEncoding?: ApiRequestParams["responseEncoding"];
+    } = {
+      params: {},
+      responseType: "json",
+      responseEncoding: "utf8",
+    },
+  ) {
+    params = params || {};
+    responseType = responseType || "json";
+    responseEncoding = responseEncoding || "utf8";
+    return this.requestClient.send<T>({
+      method: "GET",
+      url: `https://biggamesapi.io${path}`,
+      params,
+      responseType,
+      responseEncoding,
+    });
+  }
+
+  getCollections() {
+    return this.request<CollectionsResponseBody>("/api/collections");
+  }
+
+  getCollection(collection: Collection) {
+    return this.request<CollectionResponseBody>(
+      `/api/collection/${collection}`,
+    );
+  }
+
+  getClans(params?: GetClansParams) {
+    let page: number | undefined;
+    let pageSize: number | undefined;
+    let sort: ClansSort | undefined;
+    let sortOrder: SortOrder | undefined;
+    if (params) {
+      ({ page, pageSize, sort, sortOrder } = params);
+    }
+    params = {
+      page: page || 1,
+      pageSize: pageSize || 10,
+      sort: sort || "Points",
+      sortOrder: sortOrder || "desc",
+    };
+    return this.request<ClansResponseBody>("/api/clans", { params });
+  }
+
+  getClan(name: string) {
+    return this.request<ClanResponseBody>(`/api/clan/${name}`);
+  }
+
+  getExists() {
+    return this.request<ExistsResponseBody>(`/api/exists`);
+  }
+
+  getRAP() {
+    return this.request<RAPResponseBody>(`/api/rap`);
+  }
+
+  getActiveClanBattle() {
+    return this.request<ActiveClanBattleResponseBody>(`/api/activeClanBattle`);
+  }
+
+  getImage(rbxassetid: string) {
+    if (rbxassetid.startsWith("rbxassetid://")) {
+      rbxassetid = rbxassetid.slice(13);
+    }
+    return this.request<Blob>(`/api/image/${rbxassetid}`, {
+      responseType: "arraybuffer",
+      responseEncoding: "BINARY",
+    });
+  }
+}

package/src/request-client/axios.ts

@@ -0,0 +1,27 @@
+import axios, { AxiosInstance, AxiosError } from "axios";
+import { ApiRequestParams, RequestClient } from "./common";
+
+export function getAxiosRequest(instance?: AxiosInstance): RequestClient {
+  return {
+    async send<T>(options: ApiRequestParams) {
+      try {
+        const { data } = await (instance ? instance(options) : axios(options));
+
+        return data as T;
+      } catch (e: unknown) {
+        if (isAxiosError<{ message?: string }>(e)) {
+          const message: string = e?.response?.data?.message || e.message;
+          throw new Error(`${options.method} ${options.url}: ${message}`);
+        }
+
+        throw e;
+      }
+    },
+  };
+}
+
+function isAxiosError<TResponse>(
+  err: unknown | AxiosError<TResponse>,
+): err is AxiosError<TResponse> {
+  return Object.prototype.hasOwnProperty.call(err, "isAxiosError");
+}

package/src/request-client/common.ts

@@ -0,0 +1,13 @@
+export type ApiRequestParams = {
+  method: "GET" | "POST" | "DELETE" | "PATCH";
+  url: string;
+  params?: { [key: string]: any };
+  data?: { [key: string]: any };
+  headers?: { [key: string]: any };
+  responseType?: "json" | "arraybuffer";
+  responseEncoding?: "utf8" | "BINARY";
+};
+
+export type RequestClient = {
+  send<T>(options: ApiRequestParams): Promise<T>;
+};

package/src/responses/activeClanBattle.ts

@@ -0,0 +1,20 @@
+export type ActiveClanBattleResponseBody = {
+  status: string;
+  data: {
+    _id: string;
+    configName: string;
+    category: string;
+    configData: {
+      _script: {};
+      FinishTime: number;
+      Title: string;
+      _id: string;
+      StartTime: number;
+      Rewards: {
+        Bronze: { _data: { id: string } }[];
+        Silver: { _data: { id: string } }[];
+        Gold: { _data: { id: string } }[];
+      };
+    };
+  };
+};

package/src/responses/clan.ts

@@ -0,0 +1,65 @@
+export type ClanResponseBody = {
+  status: string;
+  data: {
+    Created: number;
+    Owner: number;
+    Name: string;
+    Icon: string;
+    Desc: string;
+    MemberCapacity: number;
+    OfficerCapacity: number;
+    GuildLevel: number;
+    Members: { UserID: number; PermissionLevel: number; JoinTime: number }[];
+    DepositedDiamonds: number;
+    DiamondContributions: {
+      AllTime: { Sum: number; Data: { UserID: number; Diamonds: number }[] };
+    };
+    Status: string;
+    StatusTimestamp: number;
+    StatusUsername: string;
+    Battles: {
+      Christmas2023: {
+        ProcessedAwards: boolean;
+        AwardUserIDs: number[];
+        BattleID: string;
+        Points: number;
+        PointContributions: { UserID: number; Points: number }[];
+        EarnedMedal: string;
+      };
+      DecemberActiveHugePets: {
+        ProcessedAwards: boolean;
+        AwardUserIDs: number[];
+        BattleID: string;
+        Points: number;
+        PointContributions: { UserID: number; Points: number }[];
+        EarnedMedal: string;
+      };
+      IndexBattle: {
+        ProcessedAwards: boolean;
+        AwardUserIDs: number[];
+        BattleID: string;
+        Points: number;
+        PointContributions: { UserID: number; Points: number }[];
+        EarnedMedal: string;
+      };
+      AchBattle: {
+        ProcessedAwards: boolean;
+        AwardUserIDs: number[];
+        BattleID: string;
+        Points: number;
+        PointContributions: { UserID: number; Points: number }[];
+        EarnedMedal: string;
+      };
+      RaidBattle: {
+        ProcessedAwards: boolean;
+        AwardUserIDs: any[];
+        BattleID: string;
+        Points: number;
+        PointContributions: { UserID: number; Points: number }[];
+      };
+    };
+    CountryCode: string;
+    BronzeMedals: number;
+    LastKickTimestamp: number;
+  };
+};

package/src/responses/clans.ts

@@ -0,0 +1,25 @@
+import { ClanName } from "../common";
+
+export type ClansResponseBody = {
+  status: string;
+  data: (
+    | {
+        Created: number;
+        Name: string;
+        MemberCapacity: number;
+        DepositedDiamonds: number;
+        CountryCode: string;
+        Members: number;
+        Points: number;
+      }
+    | {
+        Created: number;
+        Name: ClanName;
+        CountryCode: string;
+        MemberCapacity: number;
+        DepositedDiamonds: number;
+        Members: number;
+        Points: number;
+      }
+  )[];
+};