@yaelouuu/fortnite-api 1.0.1 → 1.2.0

package/dist/client.d.ts

@@ -3,6 +3,8 @@ import { TournamentsResource } from "./resources/tournaments";
 import { ProfilesResource } from "./resources/profiles";
 import { CalendarResource } from "./resources/calendar";
 import { BundlesResource } from "./resources/bundles";
+import { OauthResource } from "./resources/oauth";
+import { ParsingResource } from "./resources/parsing";
 export interface ClientOptions {
     apiKey: string;
     baseUrl?: string;
@@ -15,9 +17,15 @@ export declare class FortniteAPI {
     profiles: ProfilesResource;
     calendar: CalendarResource;
     bundles: BundlesResource;
+    oauth: OauthResource;
+    parsing: ParsingResource;
     constructor(options: ClientOptions);
     /**
      * Internal method to make HTTP requests
      */
     request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    /**
+     * Internal method for multipart/form-data requests (file uploads)
+     */
+    requestMultipart<T>(endpoint: string, formData: FormData): Promise<T>;
 }

package/dist/client.js

@@ -7,6 +7,8 @@ const profiles_1 = require("./resources/profiles");
 const calendar_1 = require("./resources/calendar");
 const errors_1 = require("./errors");
 const bundles_1 = require("./resources/bundles");
+const oauth_1 = require("./resources/oauth");
+const parsing_1 = require("./resources/parsing");
 class FortniteAPI {
     constructor(options) {
         this.apiKey = options.apiKey;
@@ -18,6 +20,8 @@ class FortniteAPI {
         this.profiles = new profiles_1.ProfilesResource(this);
         this.calendar = new calendar_1.CalendarResource(this);
         this.bundles = new bundles_1.BundlesResource(this);
+        this.oauth = new oauth_1.OauthResource(this);
+        this.parsing = new parsing_1.ParsingResource(this);
     }
     /**
      * Internal method to make HTTP requests
@@ -45,5 +49,31 @@ class FortniteAPI {
         const data = await response.json();
         return data;
     }
+    /**
+     * Internal method for multipart/form-data requests (file uploads)
+     */
+    async requestMultipart(endpoint, formData) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "x-api-key": this.apiKey,
+                // Don't set Content-Type - browser/node will set it with boundary
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            let errorData;
+            try {
+                errorData = await response.json();
+            }
+            catch {
+                errorData = { error: "Request failed" };
+            }
+            throw new errors_1.FortniteAPIError(errorData.error || `Request failed with status ${response.status}`, response.status, errorData);
+        }
+        const data = await response.json();
+        return data;
+    }
 }
 exports.FortniteAPI = FortniteAPI;

package/dist/resources/oauth.d.ts

@@ -0,0 +1,30 @@
+import { FortniteAPI } from "../client";
+import { OAuthCompleteResponse, OAuthDeviceRefreshResponse, OAuthFlowResponse, OAuthRefreshResponse } from "../types";
+export declare class OauthResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Initiate OAuth flow - GET /oauth/get-token
+     * Returns a verification URL for the user to authenticate
+     */
+    getToken(): Promise<OAuthFlowResponse>;
+    /**
+     * Complete OAuth flow - POST /oauth/complete
+     * Call this after user has visited the verification URL
+     */
+    completeOauth(flowId: string): Promise<OAuthCompleteResponse>;
+    /**
+     * Refresh access token - POST /oauth/refresh-token
+     * Use when access token expires (~2 hours)
+     */
+    refreshToken(refreshToken: string): Promise<OAuthRefreshResponse>;
+    /**
+     * Refresh with device auth - POST /oauth/refresh-device
+     * Use device auth credentials to get fresh tokens (never expires)
+     */
+    refreshDevice(params: {
+        accountId: string;
+        deviceId: string;
+        secret: string;
+    }): Promise<OAuthDeviceRefreshResponse>;
+}

package/dist/resources/oauth.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OauthResource = void 0;
+class OauthResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Initiate OAuth flow - GET /oauth/get-token
+     * Returns a verification URL for the user to authenticate
+     */
+    async getToken() {
+        return this.client.request("/oauth/get-token");
+    }
+    /**
+     * Complete OAuth flow - POST /oauth/complete
+     * Call this after user has visited the verification URL
+     */
+    async completeOauth(flowId) {
+        return this.client.request("/oauth/complete", {
+            method: "POST",
+            body: JSON.stringify({ flowId }),
+        });
+    }
+    /**
+     * Refresh access token - POST /oauth/refresh-token
+     * Use when access token expires (~2 hours)
+     */
+    async refreshToken(refreshToken) {
+        return this.client.request("/oauth/refresh-token", {
+            method: "POST",
+            body: JSON.stringify({ refreshToken }),
+        });
+    }
+    /**
+     * Refresh with device auth - POST /oauth/refresh-device
+     * Use device auth credentials to get fresh tokens (never expires)
+     */
+    async refreshDevice(params) {
+        return this.client.request("/oauth/refresh-device", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+}
+exports.OauthResource = OauthResource;

package/dist/resources/parsing.d.ts

@@ -0,0 +1,18 @@
+import { FortniteAPI } from "../client";
+import { ParsedReplayData } from "../types";
+export declare class ParsingResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Parse a single Fortnite replay file
+     * @param file - File object (Browser) or Blob/Buffer (Node.js)
+     * @param filename - Optional filename (required in Node.js)
+     */
+    parseReplay(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse multiple Fortnite replay files in batch
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Optional array of filenames (required in Node.js)
+     */
+    parseMultipleReplays(files: (File | Blob)[], filenames?: string[]): Promise<ParsedReplayData[]>;
+}

package/dist/resources/parsing.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsingResource = void 0;
+class ParsingResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Parse a single Fortnite replay file
+     * @param file - File object (Browser) or Blob/Buffer (Node.js)
+     * @param filename - Optional filename (required in Node.js)
+     */
+    async parseReplay(file, filename) {
+        const formData = new FormData();
+        // In browser: File object has name
+        // In Node.js: Need to pass filename
+        if (file instanceof File) {
+            formData.append("File", file);
+        }
+        else {
+            formData.append("File", file, filename || "replay.replay");
+        }
+        const response = await this.client.requestMultipart("/parsing", formData);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay");
+        }
+        return response.data;
+    }
+    /**
+     * Parse multiple Fortnite replay files in batch
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Optional array of filenames (required in Node.js)
+     */
+    async parseMultipleReplays(files, filenames) {
+        const formData = new FormData();
+        files.forEach((file, index) => {
+            if (file instanceof File) {
+                formData.append("Files", file);
+            }
+            else {
+                const name = filenames?.[index] || `replay-${index}.replay`;
+                formData.append("Files", file, name);
+            }
+        });
+        const response = await this.client.requestMultipart("/parsing/multiple", formData);
+        if (!response.success || !response.results) {
+            throw new Error(response.error || "Failed to parse replays");
+        }
+        return response.results;
+    }
+}
+exports.ParsingResource = ParsingResource;

package/dist/types/index.d.ts

@@ -58,3 +58,51 @@ export interface SeasonInfo {
     seasonNumber: number;
     exTime: number;
 }
+export interface OAuthFlowResponse {
+    success: boolean;
+    flowId: string;
+    verificationUri: string;
+    expiresIn: number;
+}
+export interface OAuthCompleteResponse {
+    success: boolean;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    accountId: string;
+    displayName: string;
+    deviceAuth: {
+        accountId: string;
+        deviceId: string;
+        secret: string;
+    };
+}
+export interface OAuthRefreshResponse {
+    success: boolean;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    accountId: string;
+    tokenChanged: boolean;
+}
+export interface OAuthDeviceRefreshResponse {
+    success: boolean;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    accountId: string;
+    displayName: string;
+}
+export interface ParsedReplayData {
+    [key: string]: any;
+}
+export interface ParsingResponse {
+    success: boolean;
+    data?: ParsedReplayData;
+    error?: string;
+}
+export interface BatchParsingResponse {
+    success: boolean;
+    results?: ParsedReplayData[];
+    error?: string;
+}

package/dist/types/index.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// Oauth types

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@yaelouuu/fortnite-api",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "SDK for Fortnite Tournaments API by Royal Arena - Author : yaelouuu",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postpublish": "node scripts/notify-discord.js"
   },
   "keywords": [
     "fortnite",