Updated sdk to 1.3.0

Signed-off-by: Avior <florian.bouillon@delta-wings.net>

Request.ts

@@ -0,0 +1,51 @@
+import fetch from 'isomorphic-unfetch'
+
+export default class RequestWrapper {
+	private static cache: Array<Request<any>> = []
+
+	public static getRequest<T>(url: string) {
+		let req = this.cache.find((req) => req.url === url) as Request<T>|undefined
+		if (!req) {
+			req = new Request<T>(url)
+			this.cache.push(req)
+		}
+		return req
+	}
+}
+
+export class Request<T = any> {
+	public static ttl = 1000 * 60 * 60 // 1 hour
+	private response?: T
+	private fetched?: Date
+	public url: string // url is public for quick url test
+
+	public constructor(url: string) {
+		this.url = url
+	}
+
+	public async get(): Promise<T> {
+		const now = new Date()
+		if (
+			this.fetched &&
+			this.response &&
+			now.getTime() - this.fetched.getTime() < Request.ttl
+		) {
+			return this.response
+		}
+
+		// Fetch Response
+		try {
+			const resp = await fetch(this.url)
+			if (resp.status !== 200) {
+				throw new Error(`Error request ended with the code (${resp.status})`)
+			}
+			const response = await resp.json()
+			this.response = response
+			this.fetched = now
+			return response
+		} catch (e) {
+			console.error(e)
+			throw new Error('An error occured')
+		}
+	}
+}

interfaces/Card.ts

@@ -41,40 +41,11 @@ export interface CardSingle {
 		name: string
 		effect: string
 	}
-	cardTypes?: {
-		/**
-		 * normal card without anything special
-		 *
-		 *
-		 * @type {boolean} consider `undefined` to true
-		 */
-		normal?: boolean
-		/**
-		 * Card which has a holographic background
-		 * but not the picture
-		 *
-		 * @type {boolean} `undefined` === `true`
-		 */
-		reverse?: boolean
-		/**
-		 * Card which has a hologaphic picture
-		 *
-		 * @type {boolean} `undefined` === `false`
-		 */
-		holo?: boolean
-		/**
-		 * Card which can have a `1st ed` icon
-		 *
-		 * only the base expansion should received it
-		 *
-		 * @type {boolean} `undefined` === `false`
-		 */
-		firstEd?: boolean
-	}
 
 	// Pokémon only
 	hp?: number
 	dexId?: number
+	lvl?: number
 	type?: Array<TypeSimple>
 	evolveFrom?: string
 	evolveTo?: Array<string>

interfaces/Tag.ts

@@ -1,8 +1,19 @@
 import { List } from "./General"
 import { CardSimple } from "./Card"
-
+/**
+ * Anum of "Tags" each card can contains
+ *
+ * @enum {number}
+ */
 enum Tag {
+	/**
+	 * basic pokémon
+	 */
 	BASIC,
+
+	/**
+	 * Basic Energy
+	 */
 	BASICENERGY,
 	BREAK,
 	EX,
@@ -16,14 +27,44 @@ enum Tag {
 	SP,
 	SPECIAL,
 	STADIUM,
+	/**
+	 * Stage 1 pokémon
+	 */
 	STAGE1,
+
+	/**
+	 * Stage 2 Pokémon
+	 */
 	STAGE2,
 	SUPPORTER,
 	TAGTEAM,
 	TECHNICALMACHINE,
 	TOOL,
+
+	/**
+	 * V Pokémon
+	 */
 	V,
+
+	/**
+	 * VMAX Pokémon
+	 */
 	VMAX,
+
+	/**
+	 * The card is available with the holographic picture
+	 */
+	HASHOLO,
+
+	/**
+	 * Card can have a 1st badge
+	 */
+	HAS1ST,
+
+	/**
+	 * Card is full art (art is not in the frame)
+	 */
+	ISFULLART,
 }
 
 export default Tag

tcgdex.ts

@@ -1,8 +1,8 @@
-import fetch from 'isomorphic-unfetch'
 import { Langs } from './interfaces/Langs'
-import { SetSingle, SetRequest, SetSimple, SetList } from './interfaces/Set'
+import { SetSingle, SetSimple, SetList } from './interfaces/Set'
 import { CardSingle, CardList, CardSimple } from './interfaces/Card'
 import { ExpansionSingle, ExpansionList } from './interfaces/Expansion'
+import RequestWrapper from './Request'
 
 export default class TCGdex {
 	public lang: Langs = "en"
@@ -22,114 +22,49 @@ export default class TCGdex {
 	public async getCard(id: string|number, set: string): Promise<CardSingle>;
 	public async getCard(id: string): Promise<CardSingle>;
 	public async getCard(id: string|number, set?: string): Promise<CardSingle> {
-		try {
+		const txt = set ? `sets/${set}` : "cards"
-			const txt = set ? `sets/${set}` : "cards"
+		const req = this.rwgr<CardSingle>(`${this.gbu()}/${txt}/${id}/`)
-			const resp = await fetch(`${this.gbu()}/${txt}/${id}/`)
+		return req.get()
-			if (resp.status !== 200) throw new Error("Card not found")
-			try {
-				return await resp.json()
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
 	public async getCards(set?: string): Promise<Array<CardSimple>> {
 		if (set) {
-			try {
+			const setSingle = await this.getSet(set)
-				const setSingle = await this.getSet(set)
+			return setSingle.list
-				return setSingle.list
-			} catch (e) {
-				throw e
-			}
-		}
-		try {
-			console.warn("note: while it's possible to fetch every cards at once it's not recommended as it take much more time than any other requests")
-			const resp = await fetch(`${this.gbu()}/cards/`)
-			if (resp.status !== 200) {
-				throw new Error("Could not fetch cards")
-			}
-			try {
-				const t: CardList = await resp.json()
-				return t.list
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
 		}
+		console.warn("note: while it's possible to fetch every cards at once it's not recommended as it take much more time than any other requests")
+		const req = this.rwgr<CardList>(`${this.gbu()}/cards/`)
+		const resp = await req.get()
+		return resp.list
 	}
 
 	public async getSet(set: string): Promise<SetSingle> {
-		try {
+		const req = this.rwgr<SetSingle>(`${this.gbu()}/sets/${set}/`)
-			const resp = await fetch(`${this.gbu()}/sets/${set}/`)
+		const resp = await req.get()
-			console.log(resp.status)
+		return Object.assign(resp, {releaseDate: new Date(resp.releaseDate)}) as SetSingle
-			if (resp.status !== 200) throw new Error("Set not found")
-			try {
-				const setTmp: SetRequest = await resp.json();
-				return Object.assign(setTmp, {releaseDate: new Date(setTmp.releaseDate)}) as SetSingle
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
 	public async getExpansion(expansion: string): Promise<ExpansionSingle> {
-		try {
+		const req = this.rwgr<ExpansionSingle>(`${this.gbu()}/expansions/${expansion}/`)
-			const resp = await fetch(`${this.gbu()}/expansions/${expansion}/`)
+		return req.get()
-			if (resp.status !== 200) throw new Error("Expansion not found")
-			try {
-				return await resp.json()
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
 	public async getExpansions(): Promise<ExpansionList> {
-		try {
+		const req = this.rwgr<ExpansionList>(`${this.gbu()}/expansions/`)
-			const resp = await fetch(`${this.gbu()}/expansions/`)
+		return req.get()
-			if (resp.status !== 200) throw new Error("Could not fetch expansions")
-			try {
-				return await resp.json()
-			} catch (e) {
-				throw e
-			}
-		} catch (e) {
-			throw e
-		}
 	}
 
 	public async getSets(expansion?: string): Promise<Array<SetSimple>> {
 		if (expansion) {
-			try {
+			const expansionSingle = await this.getExpansion(expansion)
-				const expansionSingle = await this.getExpansion(expansion)
+			return expansionSingle.sets
-				return expansionSingle.sets
-			} catch (e) {
-				throw e
-			}
-		} else {
-			try {
-				const resp = await fetch(`${this.gbu()}/sets/`)
-				if (resp.status !== 200) {
-					throw new Error("Could not fetch sets")
-				}
-				try {
-					const sets: SetList = await resp.json()
-					return sets.list
-				} catch (e) {
-					throw e
-				}
-
-			} catch (e) {
-				throw e
-			}
 		}
+		const req = this.rwgr<SetList>(`${this.gbu()}/sets/`)
+		const list = await req.get()
+		return list.list
+	}
+
+	private rwgr<T>(url: string) {
+		return RequestWrapper.getRequest<T>(url)
 	}
 }