refractor: improve general code quality (#13)

* refractor: remove duplicate type definition

* chore(types): add foreign key fields to types

* refractor: remove unused dependency

* refractor: remove unused module declaration

* feat: add mock for request utility

* chore(tests): add test for utilities and main class

* chore(publish): bump package version to 1.0.4

__mocks__/utils/request.ts

@@ -0,0 +1,21 @@
+import { mock } from "bun:test";
+
+import buildQuery from "utils/query-generator";
+import type { APIRequestInit, Entity } from "types/api-entities";
+
+mock.module("utils/request", () => ({
+  request: async <T extends Entity = any>(
+    _url: any,
+    _options: APIRequestInit<T> = {},
+  ) => {
+    return {
+      ok: true,
+      url: `${_url}${
+        _options.query && Object.keys(_options.query).length
+          ? `?${buildQuery(_options.query)}`
+          : ""
+      }`,
+      json: async () => ({ data: null, error: null, pagination: null }),
+    };
+  },
+}));

__tests__/classes/export.test.ts

@@ -0,0 +1,9 @@
+import "__mocks__/utils/request";
+
+import HellHub from "index";
+import { it } from "bun:test";
+
+it("Main class correctly infers types", async () => {
+  const response = await HellHub.planets(1);
+  const { data: _ } = await response.json();
+});

__tests__/utils/query-generator.test.ts

@@ -0,0 +1,13 @@
+import { it, expect } from "bun:test";
+
+import buildQuery from "utils/query-generator";
+import type { Planet } from "types/api-entities";
+
+it("Query generator works as expected", () => {
+  const query = buildQuery<Planet[]>({
+    limit: 10,
+    filters: { name: { $contains: "earth" } },
+  });
+
+  expect(query).toBe("limit=10&filters[name][contains]=earth");
+});

__tests__/utils/request-generator.test.ts

@@ -0,0 +1,52 @@
+import "__mocks__/utils/request";
+
+import {
+  generateDynamicRequestFn,
+  generateSingleRequestFn,
+} from "utils/request-generator";
+
+import { it, expect } from "bun:test";
+import type { Planet } from "types/api-entities";
+
+it("SingleRequestFn works as expected", async () => {
+  const singleRequest = generateSingleRequestFn<Planet>("https://example.com");
+
+  const response = await singleRequest({
+    query: {
+      limit: 10,
+      filters: { name: { $contains: "earth" } },
+    },
+  });
+
+  expect(response.ok).toBe(true);
+
+  expect(response.url).toBe(
+    "https://example.com?limit=10&filters[name][contains]=earth",
+  );
+
+  const json = await response.json();
+  expect(json).toHaveProperty("data", null);
+  expect(json).toHaveProperty("error", null);
+});
+
+it("DynamicRequestFn works as expected", async () => {
+  const dynamicRequest = generateDynamicRequestFn<Planet>(
+    "https://example.com",
+  );
+
+  const response = await dynamicRequest({
+    limit: 10,
+    filters: { name: { $contains: "earth" } },
+  });
+
+  expect(response.ok).toBe(true);
+
+  expect(response.url).toBe(
+    "https://example.com?limit=10&filters[name][contains]=earth",
+  );
+
+  const json = await response.json();
+  expect(json).toHaveProperty("data", null);
+  expect(json).toHaveProperty("error", null);
+  expect(json).toHaveProperty("pagination", null);
+});

__tests__/utils/request.test.ts

@@ -0,0 +1,26 @@
+import "__mocks__/utils/request";
+
+import { it, expect } from "bun:test";
+import { request } from "utils/request";
+import type { Planet } from "types/api-entities";
+
+it("Request util works as expected", async () => {
+  const response = await request<Planet[]>("https://example.com", {
+    query: {
+      limit: 10,
+      filters: { name: { $contains: "earth" } },
+    },
+  });
+
+  expect(response.ok).toBe(true);
+
+  expect(response.url).toBe(
+    "https://example.com?limit=10&filters[name][contains]=earth",
+  );
+
+  expect(await response.json()).toEqual({
+    data: null,
+    error: null,
+    pagination: null as any,
+  });
+});

package.json

@@ -3,7 +3,7 @@
   "license": "MIT",
   "private": false,
   "description": "The official SDK for HellHub API. Filter and collect data with full type safety out of the box.",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "keywords": [
@@ -46,8 +46,5 @@
   "author": {
     "name": "Fabio Nettis",
     "email": "nettisfabio@gmail.com"
-  },
-  "dependencies": {
-    "fast-qs": "^1.0.2"
   }
 }

types/api-entities.ts

@@ -41,7 +41,9 @@ export interface Faction extends RemoteEntity {
 export interface Planet extends RemoteEntity {
   name: string;
   owner?: Faction;
+  ownerId: number;
   sector: Sector;
+  sectorId: number;
   health: number;
   orders?: Order[];
   maxHealth: number;
@@ -50,18 +52,22 @@ export interface Planet extends RemoteEntity {
   positionX: number;
   positionY: number;
   statistics?: Stat;
+  statisticId: number;
   attacking: Attack[];
   defending: Attack[];
   campaign?: Campaign;
   regeneration: number;
   homeWorld?: HomeWorld;
   initialOwner?: Faction;
+  initialOwnerId: number;
   globalEvent?: GlobalEvent;
+  globalEventId: number;
 }
 
 export interface GlobalEvent extends RemoteEntity {
   title: string;
   faction?: Faction;
+  factionId: number;
   message: string;
   planets: Planet[];
 }
@@ -70,23 +76,31 @@ export interface Campaign extends RemoteEntity {
   type: number;
   count: number;
   planet?: Planet;
+  planetId: number;
   orders?: Order[];
 }
 
 export interface HomeWorld extends RemoteEntity {
   faction?: Faction;
+  factionId: number;
   planet?: Planet;
+  planetId: number;
 }
 
 export interface Attack extends RemoteEntity {
   target?: Planet;
+  targetId: number;
   source?: Planet;
+  sourceId: number;
 }
 
 export interface Order extends RemoteEntity {
   planet?: Planet;
+  planetId?: number;
   faction?: Faction;
+  factionId?: number;
   campaign?: Campaign;
+  campaignId?: number;
   eventType: "DEFEND" | "ATTACK";
   health: number;
   maxHealth: number;
@@ -146,6 +160,7 @@ export interface Assignment extends RemoteEntity {
   title: string;
   briefing: string;
   reward?: Reward;
+  rewardId: number;
   progress: number;
   expiresAt: string;
   description: string;

types/query-generator.ts

@@ -29,23 +29,18 @@ export type FieldOperator<T, K extends keyof T> = {
   $equals?: T[K];
   $in?: Array<T[K]>;
   $notIn?: Array<T[K]>;
+  $lt?: T[K];
+  $gt?: T[K];
+  $lte?: T[K];
+  $gte?: T[K];
 } & (T[K] extends string
   ? {
       $search?: T[K];
       $contains?: T[K];
       $endsWith?: T[K];
       $startsWith?: T[K];
-      $lt?: T[K];
-      $gt?: T[K];
-      $lte?: T[K];
-      $gte?: T[K];
     }
-  : {
-      $lt?: T[K];
-      $gt?: T[K];
-      $lte?: T[K];
-      $gte?: T[K];
-    });
+  : {});
 
 export interface RootOperator<T> {
   $or?: Array<Filter<Defined<T>>>;