fnapi-js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ajaxfnc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,75 @@
+# fnapi-js
+
+An unofficial JavaScript/Typescript wrapper for the [Fortnite-API](https://fortnite-api.com/) REST API.
+
+## Installation
+
+```bash
+npm install fnapi-js
+```
+
+## Usage
+
+```javascript
+// ESM
+import { ApiClient, Enums } from 'fnapi-js';
+
+// CommonJS
+const { ApiClient, Enums } = require('fnapi-js');
+
+// Initialize the client
+const fnApi = new ApiClient({ apiKey: 'your-api-key' });
+
+// Get player stats
+const stats = await fnApi.stats.get(
+    'username',
+    Enums.accountType.epic(),
+    Enums.timeWindow.lifetime(),
+    Enums.statsImage.all()
+);
+
+// Search cosmetics
+const searchOptions = new SearchOptions()
+    .setType('outfit')
+    .setRarity('epic')
+    .setMatchMethod(Enums.matchMethod.contains());
+
+const cosmetics = await fnApi.cosmetics.searchCosmetics(searchOptions);
+
+// Get creator code
+const creatorCode = await fnApi.sac.get('code');
+
+// Get AES keys
+const aesKeys = await fnApi.aes.getKeys();
+```
+
+## Available Endpoints
+
+- Stats
+  - Get player stats
+  - Get stats by account ID
+- Cosmetics
+  - Search cosmetics
+  - Get new cosmetics
+  - Get by ID
+  - Get tracks, instruments, cars, LEGO items, etc.
+- Creator Codes
+  - Get creator code info
+- AES
+  - Get encryption keys
+- Map
+  - Get current map info
+- News
+  - Get game news
+- Playlists
+  - Get available playlists
+  - Get playlist by ID
+- Shop
+  - Get current shop items
+- Banners
+  - Get all available banners
+  - Get all avaible banner colors
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "fnapi-js",
+  "version": "1.0.0",
+  "description": "Unofficial API Wrapper for https://fortnite-api.com/",
+  "main": "src/index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "echo hi"
+  },
+  "keywords": [
+    "api",
+    "wrapper",
+    "fortnite",
+    "fortnite-api",
+    "lobbybot",
+    "fortnite-bot"
+  ],
+  "author": "Ajaxfnc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ajaxfnc/fnapi-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ajaxfnc/fnapi-js/issues"
+  },
+  "homepage": "https://github.com/ajaxfnc/fnapi-js#readme",
+  "dependencies": {
+    "axios": "^1.9.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "jest": "^29.5.0"
+  }
+}

package/src/client/Aes.js

@@ -0,0 +1,23 @@
+class Aes {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async get() {
+        const requestData = await this.client.request('GET', '/v2/aes');
+
+        const data = requestData.body().data;
+        const build = data.build.replace(/\\u002B/g, '+').replace(/\\u002F/g, '/');
+        const mainKey = data.mainKey;
+        const dynamicKeys = data.dynamicKeys;
+
+        return {
+            build: build,
+            mainKey: mainKey,
+            dynamicKeys: dynamicKeys
+        }
+
+    }
+}
+
+export default Aes;

package/src/client/ApiClient.js

@@ -0,0 +1,113 @@
+import axios from 'axios';
+import Response from '../http/Response.js';
+import Cosmetics from './Cosmetics.js';
+import Aes from './Aes.js'
+import CreatorCode from './CreatorCode.js';
+import Map from './Map.js';
+import News from './News.js';
+import Playlists from './Playlists.js';
+import Shop from './Shop.js';
+import Stats from './Stats.js';
+import Banners from './Banners.js';
+
+
+class ApiClient {
+    constructor(config = {}) {
+        this.baseUrl = 'https://fortnite-api.com';
+        this.options = {
+            timeout: 30000,
+            headers: {},
+            ...config
+        };
+
+        if (config.apiKey) {
+            this.options.headers['Authorization'] = `${config.apiKey}`;
+        }
+
+        this.client = axios.create({
+            baseURL: this.baseUrl,
+            timeout: this.options.timeout,
+            headers: this.options.headers
+        });
+
+        this.cosmetics = new Cosmetics(this);
+        this.aes = new Aes(this)
+        this.sac = new CreatorCode(this);
+        this.news = new News(this);
+        this.map = new Map(this);
+        this.playlists = new Playlists(this);
+        this.stats = new Stats(this);
+        this.shop = new Shop(this);
+        this.banners = new Banners(this);
+    }
+
+    async request(method, path, data = null, options = {}) {
+        const maxRetries = 3;
+        let lastError;
+
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await this.client.request({
+                    method,
+                    url: path,
+                    data,
+                    headers: { ...this.options.headers, ...options.headers },
+                    params: { ...this.options.query, ...options.params },
+                    timeout: 60000
+                });
+
+                return new Response(
+                    response.status,
+                    response.data,
+                    response.headers
+                );
+            } catch (error) {
+                lastError = error;
+
+                if (error.response) {
+                    return new Response(
+                        error.response.status,
+                        error.response.data,
+                        error.response.headers
+                    );
+                }
+
+                if (error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT' || error.code === 'ECONNABORTED') {
+                    if (attempt < maxRetries) {
+                        console.log(`Request failed (${error.code}). Retrying... (${attempt}/${maxRetries})`);
+                        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                        continue;
+                    }
+                }
+
+                throw error;
+            }
+        }
+
+        throw lastError;
+    }
+
+    setHeader(key, value) {
+        this.options.headers[key] = value;
+        this.client.defaults.headers[key] = value;
+    }
+
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+
+    _getTypeValue(item) {
+        if (!item.type?.backendValue) return null;
+
+        const typeMapping = {
+            'AthenaCharacter': 'outfit',
+            'AthenaDance': 'emote',
+            'AthenaPickaxe': 'pickaxe',
+            'AthenaBackpack': 'backpack'
+        };
+
+        return typeMapping[item.type.backendValue] || null;
+    }
+}
+
+export default ApiClient;

package/src/client/Banners.js

@@ -0,0 +1,23 @@
+class Banners {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async get() {
+        const requestData = await this.client.request('GET', '/v1/banners');
+
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        const data = requestData.body().data;
+        return data;
+    }
+
+    async getColors() {
+        const requestData = await this.client.request('GET', '/v1/banners/colors');
+
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        const data = requestData.body().data;
+        return data;
+    }
+}
+
+export default Banners;

package/src/client/Cosmetics.js

@@ -0,0 +1,103 @@
+import RequestFlags from '../enums/requestFlags.js';
+import SearchOptions from '../types/SearchOptions.js';
+
+class Cosmetics {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async getAll(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/br', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getAllNew(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/new', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getAllTracks(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/tracks', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getAllInstrument(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/instruments', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getAllCars(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/cars', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getAllLego(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/lego', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getAllLegoKits(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/lego/kits', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getAllBeans(flags = RequestFlags.none()) {
+        return await this.client.request('GET', '/v2/cosmetics/beans', null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async getById(cosmeticId, flags = RequestFlags.none()) {
+        if (!cosmeticId) throw new Error('Cosmetic ID is required');
+        
+        return await this.client.request('GET', `/v2/cosmetics/br/${cosmeticId}`, null, {
+            params: { 
+                ...flags && { responseFlags: flags }
+            }
+        });
+    }
+
+    async search(searchOptions = new SearchOptions(), flags = RequestFlags.none(), searchAll = true) {
+        const params = searchOptions.build();
+        if (searchAll) {
+            return await this.client.request('GET', '/v2/cosmetics/br/search/all', null, {
+                params: {
+                    ...params,
+                    ...flags && { responseFlags: flags }
+                }
+            });
+        } else {
+            return await this.client.request('GET', '/v2/cosmetics/br/search', null, {
+                params: {
+                    ...params,
+                    ...flags && { responseFlags: flags }
+                }
+            });
+        }
+    }
+}
+
+export default Cosmetics;

package/src/client/CreatorCode.js

@@ -0,0 +1,19 @@
+class CreatorCode {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async get(code) {
+        if (!code) throw new Error('Code parameter is required');
+        
+        const requestData = await this.client.request('GET', '/v2/creatorcode', null, {
+            params: {
+                name: code
+            }
+        });
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        return requestData.body().data;
+    }
+}
+
+export default CreatorCode;

package/src/client/Map.js

@@ -0,0 +1,15 @@
+class Map {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async get() {
+        const requestData = await this.client.request('GET', '/v1/map');
+
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        const data = requestData.body().data;
+        return data;
+    }
+}
+
+export default Map;

package/src/client/News.js

@@ -0,0 +1,16 @@
+class News {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async get() {
+        const requestData = await this.client.request('GET', '/v2/news');
+        const data = requestData.body().data;
+
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        return data;
+
+    }
+}
+
+export default News;

package/src/client/Playlists.js

@@ -0,0 +1,25 @@
+class Playlists {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async all() {
+        const requestData = await this.client.request('GET', '/v1/playlists');
+
+        const data = requestData.body().data;
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        return data;
+    }
+
+    async byId(id) {
+        if(!id) throw new Error("Id is required.")
+
+        const requestData = await this.client.request('GET', `/v1/playlists/${id}`);
+
+        const data = requestData.body().data;
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        return data;
+    }
+}
+
+export default Playlists;

package/src/client/Shop.js

@@ -0,0 +1,17 @@
+class Shop {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async get() {
+        const requestData = await this.client.request('GET', '/v2/shop');
+
+        const data = requestData.body().data;
+
+        if (!requestData.isSuccess()) throw new Error(requestData.body().error);
+        return data;
+
+    }
+}
+
+export default Shop;

package/src/client/Stats.js

@@ -0,0 +1,50 @@
+class Stats {
+    constructor(apiClient) {
+        this.client = apiClient;
+    }
+
+    async get(name, accountType, timeWindow, image) {
+        if (!this.client.options.apiKey) throw new Error('API key is required for stats');
+        if (!name) throw new Error('Name parameter is required');
+        if (!accountType) throw new Error('Account type parameter is required');
+        if (!timeWindow) throw new Error('Time window parameter is required');
+
+        const requestData = await this.client.request('GET', '/v2/stats/br/v2', null, {
+            params: {
+                name: name,
+                accountType: accountType,
+                timeWindow: timeWindow,
+                image: image || 'all'
+            }
+        });
+
+        if (!requestData.isSuccess()) {
+            throw new Error(requestData.body().error || 'Failed to fetch stats');
+        }
+
+        return requestData.body().data;
+
+    }
+
+    async byId(id, timeWindow, image) {
+        if (!this.client.options.apiKey) throw new Error('API key is required for stats');
+        if (!id) throw new Error('ID parameter is required');
+        if (!timeWindow) throw new Error('Time window parameter is required');
+
+        const requestData = await this.client.request('GET', `/v2/stats/br/v2/${id}`, null, {
+            params: {
+                timeWindow: timeWindow,
+                image: image || 'all'
+            }
+        });
+
+        if (!requestData.isSuccess()) {
+            throw new Error(requestData.body().error || 'Failed to fetch stats');
+        }
+
+        return requestData.body().data;
+
+    }
+}
+
+export default Stats;

package/src/enums/AccountType.js

@@ -0,0 +1,11 @@
+class AccountType {
+    static EPIC = 'epic';
+    static PSN = 'psn';
+    static XBL = 'xbl';
+
+    static epic() { return this.EPIC; }
+    static psn() { return this.PSN; }
+    static xbl() { return this.XBL; }
+}
+
+export default AccountType;