speedruncom.js 1.3.1 → 2.0.1

package/src/BaseClient.ts

@@ -1,108 +0,0 @@
-import axios, { AxiosResponse, AxiosInstance, AxiosError } from 'axios';
-import * as GetEndpoints from './endpoints/endpoints.get.js';
-import * as PostEndpoints from './endpoints/endpoints.post.js'
-import * as Responses from './responses.js';
-
-const BASE_USER_AGENT = 'speedruncom.js';
-const BASE_URL = 'https://www.speedrun.com/api/v2/';
-const HEADERS = {
-    'Accept-Language': 'en',
-    'Accept': 'application/json'
-}
-
-const isBrowser = typeof window !== 'undefined';
-
-const objectToBase64 = (obj: object) => {
-    const jsonString = JSON.stringify(obj).replace(/\s+/g, '');
-    return Buffer.from(jsonString).toString('base64');
-}
-
-export interface config {
-    PHPSESSID?: string;
-    userAgent?: string;
-}
-
-export class APIError extends Error {
-    status: number;
-
-    constructor(message: string, status: number) {
-        super(message);
-        this.message = message;
-        this.status = status;
-    }
-}
-
-export default class Client {
-
-    /**
-     * `AxiosInstance` used on instance-called methods (called with `POST`).
-     */
-    axiosClient = axios.create({
-        baseURL: BASE_URL,
-        method: 'POST',
-        withCredentials: true,
-        headers: HEADERS
-    });
-
-    /**
-     * `AxiosInstance` used on Client-called methods (called with `GET`).
-     */
-    static axiosClient = axios.create({
-        baseURL: BASE_URL,
-        method: 'GET',
-        headers: HEADERS
-    });
-
-    private username!: string;
-    private password!: string;
-
-    private headers = this.axiosClient.defaults.headers.common;
-
-    constructor(config?: config) {
-        if (config) this.config(config);
-
-        this.axiosClient.interceptors.response.use(
-            (response: AxiosResponse) => response,
-            (error: AxiosError) => {
-                const data = error.response.data as { error?: string };
-                throw new APIError(data.error || 'Unknown error', error.response.status);
-            }
-        );
-    }
-
-    config(config: config) {
-        if (!isBrowser) this.headers['User-Agent'] = BASE_USER_AGENT + (config.userAgent ? `/${config.userAgent}` : '');
-
-        if (config.PHPSESSID) {
-            if (isBrowser) {
-                console.error('You cannot use a PHPSESSID to authenticate in a browser environment.');
-            } else {
-                this.headers['Cookie'] = `PHPSESSID=${config.PHPSESSID}`;
-            }
-        }
-    }
-
-    async request<T>(endpoint: string, params: object = {}): Promise<T> {
-        const response = await this.axiosClient.post<T>(endpoint, params);
-        
-        const cookie = response.headers['set-cookie'];
-        if (cookie && !isBrowser) this.headers['Cookie'] = cookie[0].split(';')[0];
-
-        return response.data;
-    }
-
-    static async request<T>(endpoint: string, params: object = {}): Promise<T> {
-        return (await this.axiosClient.get(`${endpoint}?_r=${objectToBase64(params)}`)).data;
-    }
-
-    /**
-     * Attempts to remove the PHPSESSID cookie if using a browser, otherwise removes your Client's authentication.
-     */
-    async logout() {
-        if (isBrowser) return await this.request('PutAuthLogout');
-
-        delete this.headers['Cookie'];
-    }
-
-    // Endpoints (auto-generated with build-client)
-}

package/src/build-client.ts

@@ -1,80 +0,0 @@
-import { Project, SourceFile, Node, OptionalKind, MethodDeclarationStructure } from 'ts-morph';
-
-const project = new Project({
-    tsConfigFilePath: "tsconfig.json",
-});
-
-const isInterfaceEmpty = (interfaceName: string, sourceFile: SourceFile) => {
-    const declarations = sourceFile.getExportedDeclarations().get(interfaceName);
-    if (!declarations || declarations.length === 0) return false;
-
-    const decl = declarations[0];
-    if (!Node.isInterfaceDeclaration(decl)) return false;
-
-    const type = decl.getType();
-    const allProperties = type.getProperties();
-
-    return allProperties.length === 0;
-};
-
-
-const isInterfaceAllOptional = (name: string, sourceFile: SourceFile) => {
-    const iface = sourceFile.getInterface(name);
-    if (iface) {
-        return iface.getType().getProperties().every(p => p.isOptional());
-    }
-
-    const typeNode = sourceFile.getTypeAliasOrThrow(name).getType();
-    return typeNode
-        .getProperties()
-        .every(p => p.isOptional());
-};
-
-const baseClient = project.getSourceFileOrThrow('src/BaseClient.ts');
-const clientFile = project.createSourceFile('src/Client.ts', baseClient.getFullText(), { overwrite: true });
-const clientClass = clientFile.getClasses()[1];
-
-const getEndpointsFile = project.getSourceFileOrThrow('src/endpoints/endpoints.get.ts');
-const postEndpointsFile = project.getSourceFileOrThrow('src/endpoints/endpoints.post.ts');
-const responsesFile = project.getSourceFileOrThrow('src/responses.ts');
-
-const getEndpointNames = Array.from(getEndpointsFile.getExportedDeclarations().keys());
-const postEndpointNames = Array.from(postEndpointsFile.getExportedDeclarations().keys());
-
-const responseNames = new Set(Array.from(responsesFile.getExportedDeclarations().keys()));
-
-const makeMethod = (name: string, isStatic: boolean, returnType: string, isEmpty: boolean, interfaces: string, isOptional: boolean) => {
-    const method: OptionalKind<MethodDeclarationStructure> = {
-        name,
-        isStatic,
-        isAsync: true,
-        returnType,
-        statements: [`return await this.request('${name}'${!isEmpty ? ', params' : ''});`]
-    }
-    if (!isEmpty) method.parameters = [{
-        name: 'params',
-        type: `${interfaces}.${name}`,
-        hasQuestionToken: isOptional
-    }];
-
-    clientClass.addMethod(method);
-}
-
-for (const endpointName of getEndpointNames) {
-    const returnType = responseNames.has(endpointName) ? `Promise<Readonly<Responses.${endpointName}>>` : 'Promise<void>';
-    const isEmpty = isInterfaceEmpty(endpointName, getEndpointsFile);
-    const isAllOptional = isInterfaceAllOptional(endpointName, getEndpointsFile);
-
-    makeMethod(endpointName, false, returnType, isEmpty, 'GetEndpoints', isAllOptional);
-    makeMethod(endpointName, true, returnType, isEmpty, 'GetEndpoints', isAllOptional);
-}
-
-for (const endpointName of postEndpointNames) {
-    const returnType = responseNames.has(endpointName) ? `Promise<Readonly<Responses.${endpointName}>>` : 'Promise<void>';
-    const isEmpty = isInterfaceEmpty(endpointName, postEndpointsFile);
-    const isAllOptional = isInterfaceAllOptional(endpointName, postEndpointsFile);
-
-    makeMethod(endpointName, false, returnType, isEmpty, 'PostEndpoints', isAllOptional);
-}
-
-clientFile.saveSync();