@sonoransoftware/sonoran.js 1.0.18 → 1.0.20

package/dist/libs/rest/src/lib/REST.d.ts

@@ -1,101 +1,101 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { RequestData, RequestManager } from './RequestManager';
-import { AllAPITypesType, RESTTypedAPIDataStructs } from './utils/constants';
-import { productEnums } from '../../../../constants';
-import type { AgentOptions } from 'node:https';
-import type { RequestInit, Response } from 'node-fetch';
-import { Instance } from '../../../../instance/Instance';
-import { CADManager } from '../../../../managers/CADManager';
-import { CMSManager } from '../../../../managers/CMSManager';
-/**
- * Options to be passed when creating the REST instance
- */
-export interface RESTOptions {
-    /**
-     * HTTPS Agent options
-     * @default {}
-     */
-    agent: Omit<AgentOptions, 'keepAlive'>;
-    /**
-     * The base api path, without version
-     */
-    api: string;
-    /**
-     * Additional headers to send for all API requests
-     * @default {}
-     */
-    headers: Record<string, string>;
-    /**
-     * Wether the request should be queued if there's a current ratelimit or to reject.
-     * @default true
-     */
-    rejectOnRateLimit: boolean;
-}
-/**
- * Data emitted on `RESTEvents.RateLimited`
- */
-export interface RateLimitData {
-    product: productEnums;
-    type: string;
-    timeTill: NodeJS.Timer;
-}
-export interface APIRequest {
-    /**
-     * The HTTP method used in this request
-     */
-    type: AllAPITypesType;
-    /**
-     * Additional HTTP options for this request
-     */
-    options: RequestInit;
-    /**
-     * The data that was used to form the body of this request
-     */
-    data: RequestData;
-}
-export interface InvalidRequestWarningData {
-    /**
-     * Number of invalid requests that have been made in the window
-     */
-    count: number;
-    /**
-     * API request type which the request is for
-     */
-    type: string;
-    /**
-     * Product which the invalid request is for
-     */
-    product: productEnums;
-}
-export interface RestEvents {
-    invalidRequestWarning: [invalidRequestInfo: InvalidRequestWarningData];
-    restDebug: [info: string];
-    rateLimited: [rateLimitInfo: RateLimitData];
-    request: [request: APIRequest];
-    response: [request: APIRequest, response: Response];
-    newListener: [name: string, listener: (...args: any) => void];
-    removeListener: [name: string, listener: (...args: any) => void];
-}
-export interface REST {
-    on: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
-    once: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
-    emit: (<K extends keyof RestEvents>(event: K, ...args: RestEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, ...args: any[]) => boolean);
-    off: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
-    removeAllListeners: (<K extends keyof RestEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof RestEvents>) => this);
-}
-export type RestManagerTypes = CADManager | CMSManager;
-export declare class REST extends EventEmitter {
-    readonly requestManager: RequestManager;
-    readonly instance: Instance;
-    readonly manager: RestManagerTypes;
-    constructor(_instance: Instance, _manager: RestManagerTypes, _product: productEnums, options: RESTOptions);
-    /**
-     * Runs a request from the api
-     * @param type API Type Enum
-     */
-    request<K extends keyof RESTTypedAPIDataStructs>(type: K, ...args: RESTTypedAPIDataStructs[K]): Promise<unknown>;
-    private formatDataArguments;
-}
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { RequestData, RequestManager } from './RequestManager';
+import { AllAPITypesType, RESTTypedAPIDataStructs } from './utils/constants';
+import { productEnums } from '../../../../constants';
+import type { AgentOptions } from 'node:https';
+import type { RequestInit, Response } from 'node-fetch';
+import { Instance } from '../../../../instance/Instance';
+import { CADManager } from '../../../../managers/CADManager';
+import { CMSManager } from '../../../../managers/CMSManager';
+/**
+ * Options to be passed when creating the REST instance
+ */
+export interface RESTOptions {
+    /**
+     * HTTPS Agent options
+     * @default {}
+     */
+    agent: Omit<AgentOptions, 'keepAlive'>;
+    /**
+     * The base api path, without version
+     */
+    api: string;
+    /**
+     * Additional headers to send for all API requests
+     * @default {}
+     */
+    headers: Record<string, string>;
+    /**
+     * Wether the request should be queued if there's a current ratelimit or to reject.
+     * @default true
+     */
+    rejectOnRateLimit: boolean;
+}
+/**
+ * Data emitted on `RESTEvents.RateLimited`
+ */
+export interface RateLimitData {
+    product: productEnums;
+    type: string;
+    timeTill: NodeJS.Timer;
+}
+export interface APIRequest {
+    /**
+     * The HTTP method used in this request
+     */
+    type: AllAPITypesType;
+    /**
+     * Additional HTTP options for this request
+     */
+    options: RequestInit;
+    /**
+     * The data that was used to form the body of this request
+     */
+    data: RequestData;
+}
+export interface InvalidRequestWarningData {
+    /**
+     * Number of invalid requests that have been made in the window
+     */
+    count: number;
+    /**
+     * API request type which the request is for
+     */
+    type: string;
+    /**
+     * Product which the invalid request is for
+     */
+    product: productEnums;
+}
+export interface RestEvents {
+    invalidRequestWarning: [invalidRequestInfo: InvalidRequestWarningData];
+    restDebug: [info: string];
+    rateLimited: [rateLimitInfo: RateLimitData];
+    request: [request: APIRequest];
+    response: [request: APIRequest, response: Response];
+    newListener: [name: string, listener: (...args: any) => void];
+    removeListener: [name: string, listener: (...args: any) => void];
+}
+export interface REST {
+    on: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+    once: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+    emit: (<K extends keyof RestEvents>(event: K, ...args: RestEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, ...args: any[]) => boolean);
+    off: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+    removeAllListeners: (<K extends keyof RestEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof RestEvents>) => this);
+}
+export type RestManagerTypes = CADManager | CMSManager;
+export declare class REST extends EventEmitter {
+    readonly requestManager: RequestManager;
+    readonly instance: Instance;
+    readonly manager: RestManagerTypes;
+    constructor(_instance: Instance, _manager: RestManagerTypes, _product: productEnums, options: RESTOptions);
+    /**
+     * Runs a request from the api
+     * @param type API Type Enum
+     */
+    request<K extends keyof RESTTypedAPIDataStructs>(type: K, ...args: RESTTypedAPIDataStructs[K]): Promise<unknown>;
+    private formatDataArguments;
+}

package/dist/libs/rest/src/lib/REST.js

@@ -1,129 +1,136 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REST = void 0;
-const events_1 = require("events");
-const RequestManager_1 = require("./RequestManager");
-const constants_1 = require("./utils/constants");
-const constants_2 = require("../../../../constants");
-class REST extends events_1.EventEmitter {
-    constructor(_instance, _manager, _product, options) {
-        super();
-        this.instance = _instance;
-        this.manager = _manager;
-        this.requestManager = new RequestManager_1.RequestManager(_instance, _product, options)
-            .on("restDebug" /* RESTEvents.Debug */, this.emit.bind(this, "restDebug" /* RESTEvents.Debug */))
-            .on("rateLimited" /* RESTEvents.RateLimited */, this.emit.bind(this, "rateLimited" /* RESTEvents.RateLimited */))
-            .on("invalidRequestWarning" /* RESTEvents.InvalidRequestWarning */, this.emit.bind(this, "invalidRequestWarning" /* RESTEvents.InvalidRequestWarning */));
-        this.on('newListener', (name, listener) => {
-            if (name === "request" /* RESTEvents.Request */ || name === "response" /* RESTEvents.Response */)
-                this.requestManager.on(name, listener);
-        });
-        this.on('removeListener', (name, listener) => {
-            if (name === "request" /* RESTEvents.Request */ || name === "response" /* RESTEvents.Response */)
-                this.requestManager.off(name, listener);
-        });
-    }
-    /**
-     * Runs a request from the api
-     * @param type API Type Enum
-     */
-    request(type, ...args) {
-        const apiType = constants_1.AllAPITypes.find((aT) => aT.type === type);
-        if (!apiType)
-            throw new Error('Invalid API Type given for request.');
-        let communityId;
-        let apiKey;
-        switch (apiType.product) {
-            case constants_2.productEnums.CAD: {
-                communityId = this.instance.cadCommunityId;
-                apiKey = this.instance.cadApiKey;
-                break;
-            }
-            case constants_2.productEnums.CMS: {
-                communityId = this.instance.cmsCommunityId;
-                apiKey = this.instance.cmsApiKey;
-                break;
-            }
-        }
-        if (!communityId || !apiKey)
-            throw new Error(`Community ID or API Key could not be found for request. P${apiType.product}`);
-        // if (apiType.minVersion > this.manager.version) throw new Error(`[${type}] Subscription version too low for this API type request. Current Version: ${convertSubNumToName(this.manager.version)} Needed Version: ${convertSubNumToName(apiType.minVersion)}`);  // Verifies API Subscription Level Requirement which is deprecated currently
-        const formattedData = this.formatDataArguments(apiType.type, args);
-        const options = {
-            id: communityId,
-            key: apiKey,
-            type,
-            data: formattedData,
-            product: apiType.product
-        };
-        return this.requestManager.queueRequest(options);
-    }
-    formatDataArguments(type, args) {
-        switch (type) {
-            case 'VERIFY_WHITELIST': {
-                return {
-                    apiId: args[0],
-                    accId: constants_2.uuidRegex.test(args[1]) ? args[1] : undefined,
-                    serverId: args[2]
-                };
-            }
-            case 'FULL_WHITELIST': {
-                return {
-                    serverId: args[0]
-                };
-            }
-            case 'RSVP': {
-                return {
-                    eventId: args[0],
-                    apiId: args[1],
-                    accId: args[2],
-                };
-            }
-            case 'GET_COM_ACCOUNT': {
-                return {
-                    apiId: args[0],
-                    username: args[1],
-                    accId: args[2],
-                    discord: args[3]
-                };
-            }
-            case 'GET_ACCOUNT_RANKS': {
-                return {
-                    apiId: args[0],
-                    username: args[1],
-                    accId: args[2],
-                    discord: args[3]
-                };
-            }
-            case 'CLOCK_IN_OUT': {
-                return {
-                    apiId: args[0],
-                    accId: args[1],
-                    forceClockIn: args[2]
-                };
-            }
-            case 'CHECK_COM_APIID': {
-                return {
-                    apiId: args[0]
-                };
-            }
-            case 'SET_ACCOUNT_RANKS': {
-                return {
-                    accountId: args[0],
-                    set: args[1],
-                    add: args[2],
-                    remove: args[3],
-                };
-            }
-            case 'VERIFY_SECRET': {
-                return {
-                    secret: args[0],
-                };
-            }
-            default: {
-                return args;
-            }
-        }
-    }
-}
-exports.REST = REST;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REST = void 0;
+const events_1 = require("events");
+const RequestManager_1 = require("./RequestManager");
+const constants_1 = require("./utils/constants");
+const constants_2 = require("../../../../constants");
+class REST extends events_1.EventEmitter {
+    constructor(_instance, _manager, _product, options) {
+        super();
+        this.instance = _instance;
+        this.manager = _manager;
+        this.requestManager = new RequestManager_1.RequestManager(_instance, _product, options)
+            .on("restDebug" /* RESTEvents.Debug */, this.emit.bind(this, "restDebug" /* RESTEvents.Debug */))
+            .on("rateLimited" /* RESTEvents.RateLimited */, this.emit.bind(this, "rateLimited" /* RESTEvents.RateLimited */))
+            .on("invalidRequestWarning" /* RESTEvents.InvalidRequestWarning */, this.emit.bind(this, "invalidRequestWarning" /* RESTEvents.InvalidRequestWarning */));
+        this.on('newListener', (name, listener) => {
+            if (name === "request" /* RESTEvents.Request */ || name === "response" /* RESTEvents.Response */)
+                this.requestManager.on(name, listener);
+        });
+        this.on('removeListener', (name, listener) => {
+            if (name === "request" /* RESTEvents.Request */ || name === "response" /* RESTEvents.Response */)
+                this.requestManager.off(name, listener);
+        });
+    }
+    /**
+     * Runs a request from the api
+     * @param type API Type Enum
+     */
+    request(type, ...args) {
+        const apiType = constants_1.AllAPITypes.find((aT) => aT.type === type);
+        if (!apiType)
+            throw new Error('Invalid API Type given for request.');
+        let communityId;
+        let apiKey;
+        switch (apiType.product) {
+            case constants_2.productEnums.CAD: {
+                communityId = this.instance.cadCommunityId;
+                apiKey = this.instance.cadApiKey;
+                break;
+            }
+            case constants_2.productEnums.CMS: {
+                communityId = this.instance.cmsCommunityId;
+                apiKey = this.instance.cmsApiKey;
+                break;
+            }
+        }
+        if (!communityId || !apiKey)
+            throw new Error(`Community ID or API Key could not be found for request. P${apiType.product}`);
+        // if (apiType.minVersion > this.manager.version) throw new Error(`[${type}] Subscription version too low for this API type request. Current Version: ${convertSubNumToName(this.manager.version)} Needed Version: ${convertSubNumToName(apiType.minVersion)}`);  // Verifies API Subscription Level Requirement which is deprecated currently
+        const formattedData = this.formatDataArguments(apiType.type, args);
+        const options = {
+            id: communityId,
+            key: apiKey,
+            type,
+            data: formattedData,
+            product: apiType.product
+        };
+        return this.requestManager.queueRequest(options);
+    }
+    formatDataArguments(type, args) {
+        switch (type) {
+            case 'VERIFY_WHITELIST': {
+                return {
+                    apiId: args[0],
+                    accId: constants_2.uuidRegex.test(args[1]) ? args[1] : undefined,
+                    serverId: args[2]
+                };
+            }
+            case 'FULL_WHITELIST': {
+                return {
+                    serverId: args[0]
+                };
+            }
+            case 'RSVP': {
+                return {
+                    eventId: args[0],
+                    apiId: args[1],
+                    accId: args[2],
+                };
+            }
+            case 'GET_COM_ACCOUNT': {
+                return {
+                    apiId: args[0],
+                    username: args[1],
+                    accId: args[2],
+                    discord: args[3]
+                };
+            }
+            case 'GET_ACCOUNT_RANKS': {
+                return {
+                    apiId: args[0],
+                    username: args[1],
+                    accId: args[2],
+                    discord: args[3]
+                };
+            }
+            case 'CLOCK_IN_OUT': {
+                return {
+                    apiId: args[0],
+                    accId: args[1],
+                    forceClockIn: args[2]
+                };
+            }
+            case 'CHECK_COM_APIID': {
+                return {
+                    apiId: args[0]
+                };
+            }
+            case 'SET_ACCOUNT_RANKS': {
+                return {
+                    accountId: args[0],
+                    set: args[1],
+                    add: args[2],
+                    remove: args[3],
+                };
+            }
+            case 'VERIFY_SECRET': {
+                return {
+                    secret: args[0],
+                };
+            }
+            case 'CHANGE_FORM_STAGE': {
+                return {
+                    accId: args[0],
+                    formId: args[1],
+                    newStageId: args[2],
+                };
+            }
+            default: {
+                return args;
+            }
+        }
+    }
+}
+exports.REST = REST;

package/dist/libs/rest/src/lib/RequestManager.d.ts

@@ -1,59 +1,59 @@
-/// <reference types="node" />
-import { Collection } from '@discordjs/collection';
-import { EventEmitter } from 'events';
-import type { Instance } from '../../../../instance/Instance';
-import { RESTOptions, RateLimitData, RestEvents } from './REST';
-import { productEnums } from '../../../../constants';
-import { IHandler } from './handlers/IHandler';
-export type RouteLike = `/${string}`;
-export declare const enum RequestMethod {
-    Delete = "delete",
-    Get = "get",
-    Patch = "patch",
-    Post = "post",
-    Put = "put"
-}
-export type ReqDataType = Array<unknown> | unknown;
-export interface RequestData {
-    id: string;
-    key: string;
-    type: string;
-    data: any;
-}
-export interface InternalRequestData extends RequestData {
-    product: productEnums;
-}
-export interface RequestHeaders {
-    'User-Agent': string;
-}
-export interface APIData {
-    requestTypeId: string;
-    typePath: string;
-    fullUrl: string;
-    method: string;
-    fetchOptions: RequestInit;
-    data: RequestData;
-    product: productEnums;
-    type: string;
-}
-export interface RequestManager {
-    on: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
-    once: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
-    emit: (<K extends keyof RestEvents>(event: K, ...args: RestEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, ...args: any[]) => boolean);
-    off: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
-    removeAllListeners: (<K extends keyof RestEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof RestEvents>) => this);
-}
-export declare class RequestManager extends EventEmitter {
-    readonly ratelimitedTypes: Collection<string, RateLimitData>;
-    readonly handlers: Collection<string, IHandler>;
-    readonly product: productEnums;
-    readonly options: RESTOptions;
-    private instance;
-    constructor(_instance: Instance, _product: productEnums, options: RESTOptions);
-    queueRequest(request: InternalRequestData): Promise<unknown>;
-    onRateLimit(id: string, rateLimitData: RateLimitData): void;
-    removeRateLimit(id: string): void;
-    private createHandler;
-    private static resolveRequestData;
-    debug(log: string): void;
-}
+/// <reference types="node" />
+import { Collection } from '@discordjs/collection';
+import { EventEmitter } from 'events';
+import type { Instance } from '../../../../instance/Instance';
+import { RESTOptions, RateLimitData, RestEvents } from './REST';
+import { productEnums } from '../../../../constants';
+import { IHandler } from './handlers/IHandler';
+export type RouteLike = `/${string}`;
+export declare const enum RequestMethod {
+    Delete = "delete",
+    Get = "get",
+    Patch = "patch",
+    Post = "post",
+    Put = "put"
+}
+export type ReqDataType = Array<unknown> | unknown;
+export interface RequestData {
+    id: string;
+    key: string;
+    type: string;
+    data: any;
+}
+export interface InternalRequestData extends RequestData {
+    product: productEnums;
+}
+export interface RequestHeaders {
+    'User-Agent': string;
+}
+export interface APIData {
+    requestTypeId: string;
+    typePath: string;
+    fullUrl: string;
+    method: string;
+    fetchOptions: RequestInit;
+    data: RequestData;
+    product: productEnums;
+    type: string;
+}
+export interface RequestManager {
+    on: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+    once: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+    emit: (<K extends keyof RestEvents>(event: K, ...args: RestEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, ...args: any[]) => boolean);
+    off: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+    removeAllListeners: (<K extends keyof RestEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof RestEvents>) => this);
+}
+export declare class RequestManager extends EventEmitter {
+    readonly ratelimitedTypes: Collection<string, RateLimitData>;
+    readonly handlers: Collection<string, IHandler>;
+    readonly product: productEnums;
+    readonly options: RESTOptions;
+    private instance;
+    constructor(_instance: Instance, _product: productEnums, options: RESTOptions);
+    queueRequest(request: InternalRequestData): Promise<unknown>;
+    onRateLimit(id: string, rateLimitData: RateLimitData): void;
+    removeRateLimit(id: string): void;
+    private createHandler;
+    private static resolveRequestData;
+    debug(log: string): void;
+}