Update beta versioning

V2 migration

.eslintignore

@@ -0,0 +1,2 @@
+node_modules
+dist

.eslintrc.json

@@ -0,0 +1,19 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "plugins": [
+    "@typescript-eslint",
+    "prettier"
+  ],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/eslint-recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier"
+  ],
+  "rules": {
+    "@typescript-eslint/no-empty-interface": 0,
+    "@typescript-eslint/no-empty-function": 0,
+    "no-console": 1
+  }
+}

.github/workflows/sdk_test.yaml

@@ -0,0 +1,36 @@
+name: Build
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - dev
+
+jobs:
+  test:
+    name: Pokemon TCG TypeScript Integration Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout'
+        uses: actions/checkout@v1
+
+      - name: 'Setup Node'
+        uses: actions/setup-node@v1
+        with:
+          node-version: 12
+
+      - name: 'Install dependencies'
+        run: 'npm ci'
+
+      - name: 'Format SDK'
+        run: 'npm run prettier'
+
+      - name: 'Lint SDK'
+        run: 'npm run lint'
+
+      - name: 'Test SDK'
+        run: 'npm run test'
+
+      - name: 'Build SDK'
+        run: 'npm run build'

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 dist
 *.tgz
+.idea

.prettierignore

@@ -0,0 +1,2 @@
+node_modules
+dist

.prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 4,
+  "semi": true,
+  "singleQuote": true
+}

MIGRATING.md

@@ -0,0 +1,157 @@
+# Migrating from v1 to v2
+
+The functions and typings in V2 the SDK have been re-named to improve developer experience. 
+The guide will provide you with the steps to help you migrate your application.
+
+## Type Changes
+Interfaces are no longer prefixed with the letter `I`. **Interfaces in the TypeScript compile are used solely for type-checking purposes.**
+Originally, `ICard` and `ISet` existed to be implemented with the `Card` and `Set` classes respectively. Because each function is now an independently exported function,
+the TypeScript interfaces can be used as intended, which is to simply describe the shape of the data from the API:
+
+`IQuery` was also changed to `Parameter` to complement the [new parameter syntax](https://docs.pokemontcg.io/#api_v2cards_list) in V2 of the API.
+
+* `ICard` -> `Card`
+* `ISet` -> `Set`
+* `IAbility` -> `Ability`
+* `IResistance` -> `Resistance`
+* `IWeakness` -> `Weakness`
+* `IAttack` -> `Attack`
+* `IQuery` -> `Parameter`
+
+## Function Changes
+The API functions are no longer abstracted in classes. Instead, each function is an individual export which still returns
+data of type `Card` or `Set` to reduce redundancy in the SDK. The function names were renamed to reveal intent as clearly as possible. This results
+in code that is self documenting, and enforces a convention where the API functionality is described
+thoroughly for developers. 
+
+There is no change in the function return types, nor underlying functionality. Functions will continue to return a generic promised based on the resource (i.e. `Promise<Card>`, `Promise<Set>`).
+
+It is recommended to refactor the function names with the find-and-replace tool in your IDE or text editor in order for your project
+to be compatible with V2 of the SDK. 
+
+## Card Functions
+### `PokemonTCG.Card.all()` -> `PokemonTCG.getAllCards()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+PokemonTCG.Card.all();
+
+// V2
+PokemonTCG.getAllCards();
+```
+
+### `PokemonTCG.Card.find()` -> `PokemonTCG.findCardByID()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+PokemonTCG.Card.find('xy7-54').then((card: PokemonTCG.Card) => {
+  console.log(card.name) // Gardevoir
+});
+
+// V2
+PokemonTCG.findCardByID('xy7-54').then((card: PokemonTCG.Card) => {
+    console.log(card.name) // Gardevoir
+});
+```
+
+### `PokemonTCG.Card.where()` -> `PokemonTCG.findCardsByQueries()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+const paramsV1: PokemonTCG.IQuery[] = [{ name: 'name', value: 'Gardevoir' }];
+
+PokemonTCG.Card.where(paramsV1).then((cards: PokemonTCG.Card[]) => {
+  console.log(card[0].name) // Gardevoir
+});
+
+// V2
+const paramsV2: PokemonTCG.Parameter[] = { q: 'id:xy7-54' };
+
+PokemonTCG.findCardsByQueries(paramsV2).then((cards: PokemonTCG.Card[]) => {
+   console.log(card[0].name) // Gardevoir
+});
+```
+## Set Functions
+### `PokemonTCG.Set.all()` -> `PokemonTCG.getAllSets()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+PokemonTCG.Set.all();
+
+// V2
+PokemonTCG.getAllSets();
+```
+### `PokemonTCG.Set.find()` -> `PokemonTCG.findSetByID()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+PokemonTCG.Set.find('base1').then((set: PokemonTCG.Set) => {
+  console.log(set.name) // Base
+});
+
+// V2
+PokemonTCG.findSetByID('base1').then((set: PokemonTCG.Set) => {
+    console.log(set.name) // Base
+});
+```
+
+### `PokemonTCG.Set.where()` -> `PokemonTCG.findSetsByQueries()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+const paramsV1: PokemonTCG.IQuery[] = [{ name: 'name', value:'Base' }];
+
+PokemonTCG.Set.where(paramsV1).then((sets: PokemonTCG.Set[]) => {
+  console.log(sets[0].name) // Base
+});
+
+// V2
+const paramsV2: PokemonTCG.Parameter[] = { q: 'name:Base' };
+
+PokemonTCG.findSetsByQueries(paramsV2).then((sets: PokemonTCG.Set[]) => {
+   console.log(sets[0].name) // Base
+});
+```
+
+## Meta Functions 
+
+### `PokemonTCG.Meta.allTypes()` -> `PokemonTCG.getTypes()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+PokemonTCG.Meta.getAllTypes();
+
+// V2
+PokemonTCG.getTypes();
+```
+
+### `PokemonTCG.Meta.allSupertypes()` -> `PokemonTCG.getSupertypes()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+PokemonTCG.Meta.allSupertypes();
+
+// V2
+PokemonTCG.getSupertypes();
+```
+
+### `PokemonTCG.Meta.allSubtypes()` -> `PokemonTCG.getSubtypes()`
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+// V1
+PokemonTCG.Meta.allSubtypes();
+
+// V2
+PokemonTCG.getSubtypes();
+```
+
+

README.md

@@ -1,156 +1,163 @@
-# Pokemon TCG SDK TypeScript
+# Pokémon TCG TypeScript SDK
 
-This is the TypeScript SDK for the [Pokemon TCG API](https://pokemontcg.io).
+*Now supporting Version 2 of the Pokémon TCG API! Please refer to the [V1 to V2 Migration](https://docs.pokemontcg.io/#documentationmigration) section of the 
+official API docs for more information.*
+
+***See the [migration guide](MIGRATING.md) for steps to update your app to use the latest supported version of the SDK***
+
+[![pokemontcg-developers on discord](https://img.shields.io/badge/discord-pokemontcg--developers-738bd7.svg)](https://discord.gg/dpsTCvg)
+![pokemon-tcg-sdk-typescript build status](https://github.com/acupoftee/pokemon-tcg-sdk-typescript/actions/workflows/sdk_test.yaml/badge.svg
+)
+
+This is the TypeScript SDK for the [Pokémon Trading Card Game API](https://docs.pokemontcg.io).
 
 ## Installation
 
 **npm**
 
-    npm install --save pokemon-tcg-sdk-typescript
+    npm install pokemon-tcg-sdk-typescript
 
 **yarn**
 
     yarn add pokemon-tcg-sdk-typescript
 
-## Class Definitions
-
-### Card
-
+# Configuration
+The SDK works out of the box! Simply import the SDK, and you're ready to go:
 ```typescript
-ability: IAbility;
-ancientTrait?: IAncientTrait;
-artist: string;
-attacks: IAttack[];
-convertedRetreatCost: number;
-evolvesFrom: string;
-hp: string;
-id: string;
-imageUrl: string;
-imageUrlHiRes: string;
-name: string;
-nationalPokedexNumber: number;
-number: string;
-rarity: string;
-resistances: IResistance[];
-retreatCost: string[];
-series: string;
-set: string;
-setCode: string;
-subtype: string;
-supertype: string;
-text: string[];
-types: string[];
-weaknesses: IWeakness[];
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+PokemonTCG.findCardByID('xy7-54').then((card: PokemonTCG.Card) => {
+    console.log(card.name) // Gardevoir
+})
 ```
 
-### IAbility
+It is recommended to use an API key for version 2 of the API. By default, requests are limited to 20,000/day. Requests are rate limited to 1000 requests a day, and a maximum of 30 per minute. 
 
+To use the SDK with an API key, create an account at https://dev.pokemontcg.io to grab an API key.
+Then set your API key to the environment variable `POKEMONTCG_API_KEY` in a `.env` file. 
+**Make sure to use this exact environment variable, otherwise the SDK will not be able to read the API key.** 
+
+# Usage
+All function calls return generic promises like `Promise<T>` or `Promise<T[]>`
+
+## Card Methods
+* [findCardByID()](#findcardbyid)
+* [findCardsByQueries()](#findcardbyqueries)
+* [getAllCards()](#getallcards)
+* [getTypes()](#gettypes)
+* [getSupertypes()](#getsupertypes)
+* [getSubtypes()](#getsubtypes)
+* [getRarities()](#getrarities)
+
+## Set Methods
+* [findSetByID()](#findsetbyid)
+* [findSetsByQueries()](#findsetbyqueries)
+* [getAllSets()](#getallsets)
+
+### findCardByID()
+Returns a single Pokémon card given an ID. 
 ```typescript
-name: string;
-text: string;
-type: string;
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+PokemonTCG.findCardByID('xy7-54').then((card: PokemonTCG.Card) => {
+    console.log(card.name) // Gardevoir
+});
 ```
 
-### IAttack
-
+### findCardByQueries()
+Returns an array of cards filtered through a search query.
 ```typescript
-cost: string[];
-name: string;
-text: string;
-damage: string;
-convertedEnergyCost: string;
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+const params: PokemonTCG.Query[] = { q: 'id:xy7-54' };
+
+PokemonTCG.findCardsByQueries(params).then((cards: PokemonTCG.Card[]) => {
+   console.log(card[0].name) // Gardevoir
+});
+```
+### getAllCards()
+Returns all Pokémon cards available through recursive pagination.
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+PokemonTCG.getAllCards();
 ```
 
-### IResistance, IWeakness
-
+### getTypes()
+Returns all Energy Types
 ```typescript
-type: string;
-value: string;
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+PokemonTCG.getTypes();
 ```
 
-### Set
-
+### getSupertypes()
+Returns all Super Types
 ```typescript
-code: string;
-expandedLegal: boolean;
-logoUrl: string;
-name: string;
-ptcgoCode: string;
-releaseDate: string;
-series: string;
-standardLegal: boolean;
-symbolUrl: string;
-totalCards: number;
-updatedAt: string;
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+PokemonTCG.getSupertypes();
 ```
 
-### IQuery
-
+### getSubtypes()
+Returns all Sub Types
 ```typescript
-{ name: string, value: string | number }
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
+
+PokemonTCG.getSubtypes();
 ```
 
-## Method Definitions
-
+### getRarities()
+Returns all card Rarities
 ```typescript
-Card.find(id: string): Promise<Card>
-Card.where(params: IQuery[]): Promise<Card[]>
-Card.all(): Promise<Card[]>
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
 
-Set.find(id: string): Promise<Set>
-Set.where(params: IQuery[]): Promise<Set[]>
-Set.all(): Promise<Set[]>
+PokemonTCG.getRarities();
+```
+### findSetByID()
+Returns a single Pokémon card given an ID.
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
 
-Meta.allTypes(): Promise<string[]>
-Meta.allSubtypes(): Promise<string[]>
-Meta.allSupertypes(): Promise<string[]>
+PokemonTCG.findSetByID('base1').then((set: PokemonTCG.Set) => {
+    console.log(set.name) // Base
+});
 ```
 
-## Usage
-
-All of the calls return generic promises like `Promise<T>` or `Promise<T[]>`. The type is determined from the class making the call. The examples here are using the `Card` class but the usage for the other classes are the same.
-
+### findSetByQueries()
+Returns an array of cards filtered through a search query.
 ```typescript
-import { PokemonTCG } from 'pokemon-tcg-sdk-typescript'
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
 
-PokemonTCG.Card.find('xy1')
-  .then(card => {
-    // do stuff with the card
-  })
-  .catch(error => {
-    // do something with the error
-  });
+const params: PokemonTCG.Query[] = { q: 'name:Base' };
 
-let params: PokemonTCG.IQuery[] = [{ name: 'name', value: 'Charizard' }];
-PokemonTCG.Card.where(params)
-  .then(cards => {
-    // do stuff with the cards
-  })
-  .catch(error => {
-    // do something with the error
-  });
+PokemonTCG.findSetsByQueries(params).then((sets: PokemonTCG.Set[]) => {
+   console.log(sets[0].name) // Base
+});
+```
+### getAllSets()
+Returns all Pokémon sets available through recursive pagination.
+```typescript
+import { PokemonTCG } from 'pokemon-tcg-sdk-typescript';
 
-PokemonTCG.Card.all()
-  .then(cards => {
-    // do stuff with the cards
-  })
-  .catch(error => {
-    // do something with the error
-  });
+PokemonTCG.getAllSets();
 ```
 
 ## Contributing
- * Fork it (click the Fork button at the top of the page)
- * Create your feature branch (git checkout -b my-new-feature)
- * Make some changes and fix some bugs!
- * Run the tests `npm run-script test`
- * Test your changes in a project of yours:
-   * Create a link with [npm](https://docs.npmjs.com/cli/link.html) or [yarn](https://yarnpkg.com/lang/en/docs/cli/link/) (depending on what tool you installed this SDK with)
-   * In your project that **uses** the SDK, install the linked package with `yarn/npm link pokemon-tcg-sdk-typescript`
-   * Verify the SDK behaves as expected, and your changes took effect
- * Commit your changes (git commit -am 'Add some feature')
- * Push to the branch (git push origin my-new-feature)
- * Create a new Pull Request
+Contributions are welcome! If you want to contribute, feel free to fork the repository, open and issue, then submit a pull request. 
+ESLint and Prettier are used to enforce a consistent coding style. 
+
+### Setup
+Raring to code your heart out? Awesome! Here's how to get started:
+1. Open and issue with a bug or feature. Ensure the change is not already being worked on. 
+2. Fork and clone the repository from the `master` branch.
+3. Create a feature branch.
+4. Run `npm ci` to install exact versions specified in the `package-lock.json`.
+5. Code your heart out!
+6. Run `npm run test` to run ESLint and Jest tests. 
+7. (OPTIONAL) Test your changes in a project of yours:
+   1. Create a link with `npm` or `yarn` (depending on what tool you installed this SDK with)
+   2. In your project that uses the SDK, install the linked package with `yarn/npm link pokemon-tcg-sdk-typescript`
+   3. Verify the SDK behaves as expected, and your changes took effect
+8. Submit a [pull request](https://github.com/PokemonTCG/pokemon-tcg-sdk-typescript/compare)! 🎉
 
-## TODO
-* Add more testing?

jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+    "testRegex": '.*\\.test\\.ts$',
+    "transform": {
+        "^.+\\.(ts|tsx)$": "ts-jest"
+    },
+    "testTimeout": 300000
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pokemon-tcg-sdk-typescript",
-  "version": "1.2.5",
+  "version": "2.1.0-beta.1",
   "description": "Typescript SDK for the PokemonTCG API (https://pokemontcg.io)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,8 +11,11 @@
     "SDK"
   ],
   "scripts": {
-    "test": "mocha --reporter spec --require ts-node/register 'src/**/*.test.ts'",
-    "build": "tsc"
+    "prettier": "prettier --config .prettierrc.json 'src/**/*.ts' --write",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "test": "npm run lint && jest",
+    "build": "npm run lint:fix && tsc"
   },
   "repository": {
     "type": "git",
@@ -22,18 +25,24 @@
     "Bradyn Glines (https://github.com/glinesbdev)",
     "CptSpaceToaster (https://github.com/CptSpaceToaster)",
     "Monbrey (https://github.com/Monbrey)",
-    "Jonathan Meyer (https://github.com/jonathan-meyer)"
+    "Jonathan Meyer (https://github.com/jonathan-meyer)",
+    "Elisabeth Diang (https://github.com/acupoftee)"
   ],
   "license": "MIT",
   "dependencies": {
-    "axios": "^0.19.0",
-    "typescript": "^2.6.2"
+    "axios": "0.21.1"
   },
   "devDependencies": {
-    "@types/chai": "^4.1.1",
-    "@types/mocha": "^2.2.46",
-    "chai": "^4.1.2",
-    "mocha": "^8.2.1",
-    "ts-node": "^4.1.0"
+    "@types/jest": "26.0.20",
+    "@typescript-eslint/eslint-plugin": "4.17.0",
+    "@typescript-eslint/parser": "4.17.0",
+    "eslint": "7.22.0",
+    "eslint-config-prettier": "8.1.0",
+    "eslint-plugin-prettier": "3.3.1",
+    "jest": "26.6.3",
+    "prettier": "2.2.1",
+    "ts-jest": "26.5.3",
+    "ts-node": "4.1.0",
+    "typescript": "4.1.5"
   }
 }

src/classes/card.ts

@@ -1,63 +0,0 @@
-import { IAbility } from '../interfaces/ability';
-import { IAncientTrait } from '../interfaces/ancientTrait';
-import { IAttack } from '../interfaces/attack';
-import { ICard } from '../interfaces/card';
-import { IQuery } from '../interfaces/query';
-import { IResistance } from '../interfaces/resistance';
-import { IWeakness } from '../interfaces/weakness';
-import { QueryBuilder } from '../queryBuilder';
-
-export class Card implements ICard {
-  ability: IAbility;
-  artist: string;
-  ancientTrait?: IAncientTrait;
-  attacks: IAttack[];
-  convertedRetreatCost: number;
-  evolvesFrom: string;
-  hp: string;
-  id: string;
-  imageUrl: string;
-  imageUrlHiRes: string;
-  name: string;
-  nationalPokedexNumber: number;
-  number: string;
-  rarity: string;
-  resistances: IResistance[];
-  retreatCost: string[];
-  series: string;
-  set: string;
-  setCode: string;
-  subtype: string;
-  supertype: string;
-  text: string[];
-  types: string[];
-  weaknesses: IWeakness[];
-
-  resource(): string {
-    return 'cards';
-  }
-
-  static async find(id: string): Promise<Card> {
-    return QueryBuilder.find(this, id)
-      .then(response => {
-        return response;
-      })
-      .catch(error => Promise.reject(error));
-  }
-
-  static async all(): Promise<Card[]> {
-    return QueryBuilder.all(this)
-      .then(response => {
-        return response;
-      })
-      .catch(error => Promise.reject(error));
-  }
-
-  static async where(params: IQuery[]): Promise<Card[]> {
-    return QueryBuilder.where(this, params)
-      .then(response => {
-        return response;
-      })
-      .catch(error => Promise.reject(error));
-  }
-}

src/classes/meta.ts

@@ -1,15 +0,0 @@
-import { Client } from '../client';
-
-export class Meta {
-  static async allTypes(): Promise<string[]> {
-    return Client.get('types');
-  }
-
-  static async allSubtypes(): Promise<string[]> {
-    return Client.get('subtypes');
-  }
-
-  static async allSupertypes(): Promise<string[]> {
-    return Client.get('supertypes');
-  }
-}

src/classes/set.ts

@@ -1,45 +0,0 @@
-import { ISet } from '../interfaces/set';
-import { IQuery } from '../interfaces/query';
-import { QueryBuilder } from '../queryBuilder';
-
-export class Set implements ISet {
-  code: string;
-  expandedLegal: boolean;
-  logoUrl: string;
-  name: string;
-  ptcgoCode: string;
-  releaseDate: string;
-  series: string;
-  standardLegal: boolean;
-  symbolUrl: string;
-  totalCards: number;
-  updatedAt: string;
-
-  resource(): string {
-    return 'sets';
-  }
-
-  static async find(id: string): Promise<Set> {
-    return QueryBuilder.find(this, id)
-      .then(response => {
-        return response;
-      })
-      .catch(error => Promise.reject(error));
-  }
-
-  static async all(): Promise<Set[]> {
-    return QueryBuilder.all(this)
-      .then(response => {
-        return response;
-      })
-      .catch(error => Promise.reject(error));
-  }
-
-  static async where(params: IQuery[]): Promise<Set[]> {
-    return QueryBuilder.where(this, params)
-      .then(response => {
-        return response;
-      })
-      .catch(error => Promise.reject(error));
-  }
-}

src/client.ts

@@ -1,37 +1,64 @@
 import * as axios from 'axios';
-import { API_URL, API_VERSION } from './sdk';
-import { IQuery } from './interfaces/query';
+import { Parameter } from './interfaces/parameter';
 
 export class Client {
-  static apiUrl: string = `${API_URL}/v${API_VERSION}`;
+    private readonly POKEMONTCG_API_BASE_URL: string =
+        'https://api.pokemontcg.io';
+    private readonly POKEMONTCG_API_VERSION: string = '2';
+    private readonly POKEMONTCG_API_URL: string = `${this.POKEMONTCG_API_BASE_URL}/v${this.POKEMONTCG_API_VERSION}`;
+    private readonly POKEMONTCG_API_KEY?: string =
+        process.env.POKEMONTCG_API_KEY;
 
-  static async get(resource: string, params?: IQuery[] | string): Promise<any> {
-    let url: string = `${this.apiUrl}/${resource}`;
-    const config: axios.AxiosRequestConfig = {
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    };
+    private static instance: Client;
 
-    if(typeof params === 'string') url += `/${params}`;
-    else url += `?${this.paramsToQuery(params)}`;
+    private constructor() {}
 
-    return axios.default.get<any>(url, config)
-      .then(response => {
-        return response.data[Object.keys(response.data)[0]];
-      })
-      .catch(error => Promise.reject(error));
-  }
+    public static getInstance(): Client {
+        if (!Client.instance) {
+            Client.instance = new Client();
+        }
 
-  private static paramsToQuery(params?: IQuery[]): string {
-    let query: string = '';
-
-    if (params) {
-      params.map((q: IQuery) => {
-        query += `${q.name}=${encodeURIComponent(q.value.toString())}`.concat('&');
-      });
+        return Client.instance;
     }
 
-    return query;
-  }
-}
+    async get<T>(resource: string, params?: Parameter | string): Promise<T> {
+        let url = `${this.POKEMONTCG_API_URL}/${resource}`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+
+        if (this.POKEMONTCG_API_KEY) {
+            headers['X-Api-Key'] = this.POKEMONTCG_API_KEY;
+        }
+
+        const config: axios.AxiosRequestConfig = {
+            headers,
+        };
+
+        if (typeof params === 'string') {
+            url += `/${params}`;
+        } else if (params) {
+            url += `?${this.stringify(params)}`;
+        }
+
+        return axios.default
+            .get<T>(url, config)
+            .then((response) => {
+                return response.data[Object.keys(response.data)[0]];
+            })
+            .catch((error) => Promise.reject(error));
+    }
+
+    private stringify(params: Parameter): string {
+        const queryString = Object.keys(params)
+            .map(
+                (key: string) =>
+                    `${encodeURIComponent(key)}=${encodeURIComponent(
+                        params[key]
+                    )}`
+            )
+            .join('&');
+
+        return queryString;
+    }
+}

src/coverage/client.test.ts

@@ -1,86 +0,0 @@
-import * as chai from 'chai';
-import { Client } from '../client';
-import { IQuery } from '../interfaces/query';
-
-const expect = chai.expect;
-describe('Client', () => {
-  it('should get a single using the cards resource and query params' , () => {
-    const params: IQuery[] = [{
-      name: 'id',
-      value: 'xy7-54'
-    }];
-
-    Client.get('cards', params)
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response[0].name).to.equal('Gardevoir');
-      });
-  });
-
-  it('should get a default list of cards using the cards resource with no query params', () => {
-    Client.get('cards')
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response.length).to.equal(100);
-      });
-  });
-
-  it('should get sets using the sets resource and query params', () => {
-    const params: IQuery[] = [{
-      name: 'name',
-      value: 'Base'
-    }];
-
-    Client.get('sets', params)
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response[0]).to.be.a('object');
-      });
-  });
-
-  it('should get a single set using the sets resource and query params', () => {
-    const params: IQuery[] = [{
-      name: 'id',
-      value: 'base1'
-    }];
-
-    Client.get('sets', params)
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response[0].name).to.equal('Base');
-      });
-  });
-
-  it('should get a default list of sets using the sets resource with no query params', () => {
-    Client.get('sets')
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response[0]).to.be.a('object');
-        expect(response[0].code).to.equal('base1');
-      });
-  });
-
-  it('should get a list of types using the types resource', () => {
-    Client.get('types')
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response[0]).to.be.a('string');
-      });
-  });
-
-  it('should get a list of supertypes using the supertypes resource', () => {
-    Client.get('supertypes')
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response[0]).to.be.a('string');
-      });
-  });
-
-  it('should get a list of subtypes using the subtypes resource', () => {
-    Client.get('subtypes')
-      .then(response => {
-        expect(response).to.be.a('array');
-        expect(response[0]).to.be.a('string');
-      });
-  });
-});

src/coverage/queryBuilder.test.ts

@@ -1,43 +0,0 @@
-import * as chai from 'chai';
-import { Card } from '../classes/card';
-import { QueryBuilder } from '../queryBuilder';
-import { IQuery } from '../interfaces/query';
-
-const expect = chai.expect;
-describe('QueryBuilder', () => {
-  it('should use find to get a single instance', () => {
-    QueryBuilder.find<Card>(Card, 'xy7-54')
-      .then(card => {
-        expect(card).to.be.a('object');
-        expect(card.name).to.equal('Gardevoir');
-      });
-  });
-
-  it('should use where to filter data', () => {
-    const params: IQuery[] = [
-      {
-        name: 'name',
-        value: 'Charizard'
-  
-      },
-      {
-        name: 'setCode',
-        value: 'base1'
-      }
-    ];
-
-    QueryBuilder.where<Card>(Card, params)
-      .then(cards => {
-        expect(cards.length).to.equal(1);
-        expect(cards[0].id).to.equal('base1-4');
-        expect(cards[0].set).to.equal('Base');
-      });
-  });
-
-  it('should use all to get all cards', () => {
-    QueryBuilder.all<Card>(Card)
-      .then(cards => {
-        expect(cards.length).to.equal(1000);
-      });
-  });
-});

src/enums/rarity.ts

@@ -0,0 +1,25 @@
+export enum Rarity {
+    AmazingRare = 'Amazing Rare',
+    Common = 'Common',
+    Legend = 'LEGEND',
+    Promo = 'Promo',
+    Rare = 'Rare',
+    RareAce = 'Rare ACE',
+    RareBreak = 'Rare BREAK',
+    RareHolo = 'Rare Holo',
+    RareHoloEX = 'Rare Holo EX',
+    RareHoloGX = 'Rare Holo GX',
+    RareHoloLVX = 'Rare Holo LV.X',
+    RareHoloStar = 'Rare Holo Star',
+    RareHoloV = 'Rare Holo V',
+    RareHoloVMAX = 'Rare Holo VMAX',
+    RarePrime = 'Rare Prime',
+    RarePrimeStar = 'Rare Prism Star',
+    RareRainbow = 'Rare Rainbow',
+    RareSecret = 'Rare Secret',
+    RareShining = 'Rare Shining',
+    RareShiny = 'Rare Shiny',
+    RareShinyGX = 'Rare Shiny GX',
+    RareUltra = 'Rare Ultra',
+    Uncommon = 'Uncommon',
+}

src/enums/subtype.ts

@@ -0,0 +1,27 @@
+export enum Subtype {
+    Break = 'BREAK',
+    Baby = 'Baby',
+    Basic = 'Basic',
+    EX = 'EX',
+    GX = 'GX',
+    GoldenrodGameCorner = 'Goldenrod Game Corner',
+    Item = 'Item',
+    Legend = 'LEGEND',
+    LevelUp = 'Level-Up',
+    Mega = 'MEGA',
+    PokemonTool = 'Pokémon Tool',
+    PokemonToolF = 'Pokémon Tool F',
+    Restored = 'Restored',
+    RocketsSecretMachine = "Rocket's Secret Machine",
+    Special = 'Special',
+    Stadium = 'Stadium',
+    StageOne = 'Stage 1',
+    StageTwo = 'Stage 2',
+    Supporter = 'Supporter',
+    TagTeam = 'TAG TEAM',
+    TechnicalMachine = 'Technical Machine',
+    V = 'V',
+    VMax = 'VMAX',
+    RapidStrike = 'Rapid Strike',
+    SingleStrike = 'Single Strike'
+}

src/enums/supertype.ts

@@ -0,0 +1,5 @@
+export enum Supertype {
+    Energy = 'Energy',
+    Pokemon = 'Pokémon',
+    Trainer = 'Trainer',
+}

src/enums/type.ts

@@ -0,0 +1,13 @@
+export enum Type {
+    Colorless = 'Colorless',
+    Darkness = 'Darkness',
+    Dragon = 'Dragon',
+    Fairy = 'Fairy',
+    Fighting = 'Fighting',
+    Fire = 'Fire',
+    Grass = 'Grass',
+    Lightening = 'Lightning',
+    Metal = 'Metal',
+    Psychic = 'Psychic',
+    Water = 'Water',
+}

src/interfaces/ability.ts

@@ -1,5 +1,5 @@
-export interface IAbility {
-  name: string;
-  text: string;
-  type: string;
-}
+export interface Ability {
+    name: string;
+    text: string;
+    type: string;
+}

src/interfaces/ancientTrait.ts

@@ -1,4 +1,4 @@
-export interface IAncientTrait {
-  name: string;
-  text: string;
-}
+export interface AncientTrait {
+    name: string;
+    text: string;
+}

src/interfaces/attack.ts

@@ -1,7 +1,7 @@
-export interface IAttack {
-  convertedEnergyCost: string;
-  cost: string[];
-  damage: string;
-  name: string;
-  text: string;
-}
+export interface Attack {
+    convertedEnergyCost: number;
+    cost: string[];
+    damage: string;
+    name: string;
+    text: string;
+}

src/interfaces/card.ts

@@ -1,32 +1,41 @@
-import { IAbility } from '../interfaces/ability';
-import { IAncientTrait } from './ancientTrait';
-import { IAttack } from '../interfaces/attack';
-import { IResistance } from '../interfaces/resistance';
-import { IWeakness } from '../interfaces/weakness';
+import { Ability } from './ability';
+import { AncientTrait } from './ancientTrait';
+import { Attack } from './attack';
+import { Resistance, Weakness } from './stats';
+import { CardImage } from './image';
+import { ILegality } from './legality';
+import { Set } from './set';
+import { TCGPlayer } from './tcgplayer';
 
-export interface ICard {
-  ability: IAbility;
-  ancientTrait?: IAncientTrait;
-  artist: string;
-  attacks: IAttack[];
-  convertedRetreatCost: number;
-  evolvesFrom: string;
-  hp: string;
-  id: string;
-  imageUrl: string;
-  imageUrlHiRes: string;
-  name: string;
-  nationalPokedexNumber: number;
-  number: string;
-  rarity: string;
-  resistances: IResistance[];
-  retreatCost: string[];
-  series: string;
-  set: string;
-  setCode: string;
-  subtype: string;
-  supertype: string;
-  text: string[];
-  types: string[];
-  weaknesses: IWeakness[];
-}
+import { Type } from '../enums/type';
+import { Supertype } from '../enums/supertype';
+import { Subtype } from '../enums/subtype';
+import { Rarity } from '../enums/rarity';
+
+export interface Card {
+    id: string;
+    name: string;
+    supertype: Supertype;
+    subtypes: Subtype[];
+    hp?: string;
+    types?: Type[];
+    evolesFrom?: string;
+    evolvesTo?: string[];
+    rules?: string[];
+    ancientTrait?: AncientTrait;
+    abilities?: Ability[];
+    attacks?: Attack[];
+    weaknesses?: Weakness[];
+    resistances?: Resistance[];
+    retreatCost?: string[];
+    convertedRetreatCost?: number;
+    set: Set;
+    number: string;
+    artist?: string;
+    rarity: Rarity;
+    flavorText?: string;
+    nationalPokedexNumbers?: number[];
+    legalities: ILegality;
+    images: CardImage;
+    tcgplayer?: TCGPlayer;
+}

src/interfaces/image.ts

@@ -0,0 +1,9 @@
+export interface SetImage {
+    symbol: string;
+    logo: string;
+}
+
+export interface CardImage {
+    small: string;
+    large: string;
+}

src/interfaces/legality.ts

@@ -0,0 +1,10 @@
+export enum Legality {
+    Legal = 'Legal',
+    Banned = 'Banned',
+}
+
+export interface ILegality {
+    expanded?: Legality;
+    standard?: Legality;
+    unlimited?: Legality;
+}

src/interfaces/parameter.ts

@@ -0,0 +1,6 @@
+export interface Parameter {
+    q?: string;
+    orderBy?: string;
+    page?: number;
+    pageSize?: number;
+}

src/interfaces/query.ts

@@ -1,4 +0,0 @@
-export interface IQuery {
-  name: string;
-  value: string | number;
-}

src/interfaces/resistance.ts

@@ -1,4 +0,0 @@
-export interface IResistance {
-  type: string;
-  value: string;
-}

src/interfaces/set.ts

@@ -1,14 +1,15 @@
-export interface ISet {
-  code: string;
-  expandedLegal: boolean;
-  logoUrl: string;
-  name: string;
-  ptcgoCode: string;
-  releaseDate: string;
-  series: string;
-  standardLegal: boolean;
-  symbolUrl: string;
-  totalCards: number;
-  updatedAt: string;
-  updatedSince: string;
-}
+import { SetImage } from './image';
+import { ILegality } from './legality';
+
+export interface Set {
+    id: string;
+    name: string;
+    series: string;
+    printedTotal: number;
+    total: number;
+    legalities: ILegality;
+    ptcgoCode: string;
+    releaseDate: string;
+    updatedAt: string;
+    images: SetImage;
+}

src/interfaces/stats.ts

@@ -0,0 +1,8 @@
+interface Stats {
+    type: string;
+    value: string;
+}
+
+export interface Resistance extends Stats {}
+
+export interface Weakness extends Stats {}

src/interfaces/tcgplayer.ts

@@ -0,0 +1,17 @@
+export interface TCGPlayer {
+    url: string;
+    updatedAt: string;
+    prices: {
+        normal?: Price;
+        holofoil?: Price;
+        reverseHolofoil?: Price;
+    };
+}
+
+export interface Price {
+    low: number | null;
+    mid: number | null;
+    high: number | null;
+    market: number | null;
+    directLow: number | null;
+}

src/interfaces/weakness.ts

@@ -1,4 +0,0 @@
-export interface IWeakness {
-  type: string;
-  value: string;
-}

src/queryBuilder.ts

@@ -1,28 +0,0 @@
-import { Client } from './client';
-import { Card } from './classes/card';
-import { Set } from './classes/set';
-import { IQuery } from './interfaces/query';
-
-export class QueryBuilder {
-    static all<T extends Card | Set>(type: {new (): T}): Promise<T[]> {
-        const t = new type();
-        const params: IQuery[] = [{
-            name: 'pageSize',
-            value: 1000
-        }];
-
-        return Client.get(t.resource(), params);
-    }
-
-    static find<T extends Card | Set>(type: {new (): T}, id: string): Promise<T> {
-        const t = new type();
-
-        return Client.get(t.resource(), id);
-    }
-
-    static where<T extends Card | Set>(type: {new (): T}, params: IQuery[]): Promise<T[]> {
-        const t = new type();
-
-        return Client.get(t.resource(), params);
-    }
-}

src/sdk.ts

@@ -1,16 +1,20 @@
-// Constants
-export const API_URL: string = 'https://api.pokemontcg.io';
-export const API_VERSION: string = '1';
-
-// Classes
-export * from './classes/card';
-export * from './classes/set';
-export * from './classes/meta';
-
 // Interfaces
 export * from './interfaces/ability';
 export * from './interfaces/attack';
 export * from './interfaces/card';
-export * from './interfaces/query';
-export * from './interfaces/resistance';
-export * from './interfaces/weakness';
+export * from './interfaces/parameter';
+export * from './interfaces/stats';
+export * from './interfaces/set';
+export * from './interfaces/image';
+export * from './interfaces/tcgplayer';
+export * from './interfaces/legality';
+
+// Enums
+export * from './enums/type';
+export * from './enums/supertype';
+export * from './enums/subtype';
+export * from './enums/rarity';
+
+// Services
+export * from './services/cardService';
+export * from './services/setService';

src/services/cardService.ts

@@ -0,0 +1,66 @@
+import { Parameter } from '../interfaces/parameter';
+import { Card } from '../interfaces/card';
+import { Type } from '../enums/type';
+import { Supertype } from '../enums/supertype';
+import { Subtype } from '../enums/subtype';
+import { Rarity } from '../enums/rarity';
+import { Client } from '../client';
+
+async function paginateAllCards(pageNumber: number, params?: Parameter): Promise<Card[]> {
+    let currentPage = pageNumber;
+    const client: Client = Client.getInstance();
+    const response: Card[] = await client.get<Card[]>('cards', { pageSize: 250, page: currentPage, ...params });
+
+    if (response.length === 0) {
+        return response;
+    } else {
+        currentPage++;
+        return response.concat(await paginateAllCards(currentPage));
+    }
+}
+
+export async function getAllCards(params?: Parameter): Promise<Card[]> {
+    const startingPage = 1;
+    const response: Card[] = await paginateAllCards(startingPage, params);
+    return response;
+}
+
+export async function findCardByID(id: string): Promise<Card> {
+    const client: Client = Client.getInstance();
+    const response: Card = await client.get<Card>('cards', id);
+    return response;
+}
+
+export async function findCardsByQueries(params: Parameter): Promise<Card[]> {
+    const client: Client = Client.getInstance();
+    const response: Card[] = await client.get<Card[]>('cards', params);
+    return response;
+}
+
+export async function getTypes(): Promise<Type[]> {
+    const client: Client = Client.getInstance();
+
+    const response: Type[] = await client.get<Type[]>('types');
+    return response;
+}
+
+export async function getSupertypes(): Promise<Supertype[]> {
+    const client: Client = Client.getInstance();
+
+    const response: Supertype[] = await client.get<Supertype[]>('supertypes');
+    return response;
+}
+
+export async function getSubtypes(): Promise<Subtype[]> {
+    const client: Client = Client.getInstance();
+
+    const response: Subtype[] = await client.get<Subtype[]>('subtypes');
+    return response;
+}
+
+export async function getRarities(): Promise<Rarity[]> {
+    const client: Client = Client.getInstance();
+
+    const response: Rarity[] = await client.get<Rarity[]>('rarities');
+    return response;
+}

src/services/setService.ts

@@ -0,0 +1,23 @@
+import { Parameter } from '../interfaces/parameter';
+import { Set } from '../interfaces/set';
+import { Client } from '../client';
+
+export async function findSetByID(id: string): Promise<Set> {
+    const client: Client = Client.getInstance();
+    const response: Set = await client.get<Set>('sets', id);
+    return response;
+}
+
+export async function findSetsByQueries(params: Parameter): Promise<Set[]> {
+    const client: Client = Client.getInstance();
+    const response: Set[] = await client.get<Set[]>('sets', params);
+    return response;
+}
+
+export async function getAllSets(): Promise<Set[]> {
+    const params: Parameter = { pageSize: 250 };
+
+    const client: Client = Client.getInstance();
+    const response: Set[] = await client.get<Set[]>('sets', params);
+    return response;
+}

test/cardService.test.ts

@@ -0,0 +1,55 @@
+import { findCardByID, findCardsByQueries, getSupertypes, getSubtypes, getTypes, getRarities } from "../src/services/cardService";
+import { Parameter } from "../src/interfaces/parameter";
+import { Card } from "../src/interfaces/card";
+import { Type } from '../src/enums/type';
+import { Supertype } from '../src/enums/supertype';
+import { Subtype } from '../src/enums/subtype';
+import { Rarity } from '../src/enums/rarity';
+
+describe('Card Service', () => {
+    it('should get a single card using query parameters', async () => {
+        const params: Parameter = { q: 'id:xy7-54' }
+
+        const result: Card[] = await findCardsByQueries(params);
+        expect(result[0].name).toEqual('Gardevoir');
+    })
+
+    it('should get a single card using a card id', async () => {
+        const result: Card = await findCardByID('xy7-54');
+        expect(result.name).toEqual('Gardevoir');
+    })
+
+    it('should get a maximum of 250 cards given a page number by default', async () => {
+        const totalCards = 250
+        const results: Card[] = await findCardsByQueries({ page: 1});
+        expect(results).toHaveLength(totalCards);
+    });
+
+    it('should get a list of card supertypes', async () => {
+        const expected: Supertype[] = Object.values(Supertype);
+        const result: Supertype[] = await getSupertypes();
+
+        expect(expected.sort()).toEqual(result.sort());
+    });
+
+    it('should get a list of card subtypes', async () => {
+        const expected: Subtype[] = Object.values(Subtype);
+        const result: Subtype[] = await getSubtypes();
+
+        expect(expected.sort()).toEqual(result.sort());
+    });
+
+    it('should get a list of card rarities', async () => {
+        const expected: Rarity[] = Object.values(Rarity);
+        const result: Rarity[] = await getRarities();
+
+        expect(expected.sort()).toEqual(result.sort());
+    });
+
+    it('should get a list of card types', async () => {
+        const expected: Type[] = Object.values(Type);
+        const result: Type[] = await getTypes();
+
+        expect(expected.sort()).toEqual(result.sort());
+    });
+})

test/setService.test.ts

@@ -0,0 +1,22 @@
+import { findSetByID, findSetsByQueries, getAllSets } from '../src/services/setService';
+import { Parameter } from "../src/interfaces/parameter";
+import { Set } from "../src/interfaces/set";
+
+describe('Set Service', () => {
+    it('should get a single set using query parameters', async () => {
+        const params: Parameter = { q: 'name:Base' };
+
+        const result: Set[] = await findSetsByQueries(params);
+        expect(result[0].name).toEqual('Base');
+    })
+
+    it('should get a single set using a set id', async () => {
+        const result: Set = await findSetByID('base1');
+        expect(result.name).toEqual('Base');
+    })
+
+    it('should get a default list of sets using the sets resource with no query params', async () => {
+        const results: Set[] = await getAllSets();
+        expect(results.length).toBeLessThanOrEqual(250);
+    });
+})

tsconfig.json

@@ -6,9 +6,13 @@
     "outDir": "./dist",
     "sourceMap": true,
     "experimentalDecorators": true,
-    "lib": ["ES2015"]
+    "lib": ["ES6"]
   },
   "include": [
     "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "test"
   ]
 }