Updated Series/Sets fetchers to filter and sort

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

endpoints/series.ts

@@ -27,6 +27,6 @@ export default class implements Endpoint<SerieList, SerieSingle, {}, Array<Serie
 	}
 
 	public async common() {
-		return getSeries()
+		return getSeries(this.lang)
 	}
 }

endpoints/sets.ts

@@ -32,8 +32,7 @@ export default class implements Endpoint<SetList, SetSingle, CardSingle, Array<S
 	}
 
 	public async common() {
-		return (await getSets())
-			.filter((set) => isSetAvailable(set, this.lang))
+		return (await getSets(undefined, this.lang))
 	}
 
 	public async sub(common: Array<Set>, item: string) {

utils/serieUtil.ts

@@ -1,16 +1,29 @@
 import { smartGlob } from "./util"
-import { setToSetSimple, getSets } from "./setUtil"
+import { setToSetSimple, getSets, getSet, isSetAvailable } from "./setUtil"
 import { Serie, SupportedLanguages, Set } from 'db/interfaces'
 import { Serie as SerieSingle, SerieResume } from '@tcgdex/sdk/interfaces'
 
-export async function getSeries(): Promise<Array<Serie>> {
-	const series = await Promise.all((await smartGlob('./db/data/*.js'))
+export async function getSeries(lang: SupportedLanguages): Promise<Array<Serie>> {
+	let series: Array<Serie> = (await Promise.all((await smartGlob('./db/data/*.js'))
+		//Find Serie's name
 		.map((it) => it.substring(it.lastIndexOf('/') + 1, it.length - 3))
-		.map((it) => getSerie(it)))
+		// Fetch the Serie
+		.map((it) => getSerie(it))))
+		// Filter the serie if no name's exists in the selected lang
+		.filter((serie) => !!serie.name[lang])
+
+	// Filter available series
+	const isAvailable = await Promise.all(series.map((serie) => isSerieAvailable(serie, lang)))
+	series = series.filter((_, index) => isAvailable[index])
+
+	// Sort series by the first set release date
 	const tmp: Array<[Serie, Set | undefined]> = await Promise.all(series.map(async (it) => {
-		return [it, (await getSets(it.name.en)).reduce<Set | undefined>((p, c) => p ? p.releaseDate < c.releaseDate ? p : c : c, undefined) as Set] as [Serie, Set]
+		return [
+			it,
+			(await getSets(it.name.en, lang))
+				.reduce<Set | undefined>((p, c) => p ? p.releaseDate < c.releaseDate ? p : c : c, undefined) as Set] as [Serie, Set]
 	}))
-	tmp.forEach((t) => !t[1] && console.log(t[0].name) )
+
 	return tmp.sort((a, b) => (a[1] ? a[1].releaseDate : '0') > (b[1] ? b[1].releaseDate : '0') ? 1 : -1).map((it) => it[0])
 }
 
@@ -18,6 +31,14 @@ export async function getSerie(name: string): Promise<Serie> {
 	return (await import(`../db/data/${name}.js`)).default
 }
 
+export async function isSerieAvailable(serie: Serie, lang: SupportedLanguages) {
+	if (!serie.name[lang]) {
+		return false
+	}
+	const sets = (await getSets(serie.name.en, lang))
+	return sets.length > 0
+}
+
 export async function serieToSerieSimple(serie: Serie, lang: SupportedLanguages): Promise<SerieResume> {
 	return {
 		id: serie.id,
@@ -26,7 +47,7 @@ export async function serieToSerieSimple(serie: Serie, lang: SupportedLanguages)
 }
 
 export async function serieToSerieSingle(serie: Serie, lang: SupportedLanguages): Promise<SerieSingle> {
-	const setsTmp = await getSets(serie.name.en)
+	const setsTmp = await getSets(serie.name.en, lang)
 	const sets = await Promise.all(setsTmp
 		.sort((a, b) => {
 			return a.releaseDate > b.releaseDate ? 1 : -1

utils/setUtil.ts

@@ -10,22 +10,31 @@ interface t {
 const setCache: t = {}
 
 // Dont use cache as it wont necessary have them all
-export async function getSets(serie = '*'): Promise<Array<Set>> {
-	const sets = (await smartGlob(`./db/data/${serie}/*.js`)).map((set) => set.substring(set.lastIndexOf('/')+1, set.lastIndexOf('.')))
-	return Promise.all(sets.map((set) => getSet(set, serie)))
+export async function getSets(serie = '*', lang: SupportedLanguages): Promise<Array<Set>> {
+	// list sets names
+	const rawSets = (await smartGlob(`./db/data/${serie}/*.js`)).map((set) => set.substring(set.lastIndexOf('/')+1, set.lastIndexOf('.')))
+	// Fetch sets
+	const sets = (await Promise.all(rawSets.map((set) => getSet(set, serie, lang))))
+		// Filter sets
+		.filter((set) => isSetAvailable(set, lang))
+		// Sort sets by release date
+		.sort((a, b) => {
+			return a.releaseDate > b.releaseDate ? 1 : -1
+		})
+	return sets
 }
 
 /**
  * Return the set
  * @param name the name of the set (don't include.js/.ts)
  */
-export async function getSet(name: string, serie = '*'): Promise<Set> {
+export async function getSet(name: string, serie = '*', lang: SupportedLanguages): Promise<Set> {
 	if (!setCache[name]) {
 		try {
 			const [path] = await smartGlob(`./db/data/${serie}/${name}.js`)
 			setCache[name] = (await import(path.replace('./', '../'))).default
 		} catch (e) {
-			const set = (await getSets()).find((s) => s.id === name)
+			const set = (await getSets(undefined, lang)).find((s) => s.id === name)
 			if (set) {
 				return set
 			}