x

src/client/client.ts

@@ -38,7 +38,7 @@ export interface ClientOptions {
   /** Token of the Bot/User */
   token?: string
   /** Gateway Intents */
-  intents?: GatewayIntents[]
+  intents?: Array<GatewayIntents | keyof typeof GatewayIntents>
   /** Cache Adapter to use, defaults to Collections one */
   cache?: ICacheAdapter
   /** Force New Session and don't use cached Session (by persistent caching) */
@@ -77,10 +77,29 @@ export class Client extends HarmonyEventEmitter<ClientEvents> {
   rest: RESTManager
   /** User which Client logs in to, undefined until logs in */
   user?: User
+
+  #token?: string
+
   /** Token of the Bot/User */
-  token?: string
+  get token(): string | undefined {
+    return this.#token
+  }
+
+  set token(val: string | undefined) {
+    this.#token = val
+  }
+
   /** Cache Adapter */
-  cache: ICacheAdapter = new DefaultCacheAdapter()
+  get cache(): ICacheAdapter {
+    return this.#cache
+  }
+
+  set cache(val: ICacheAdapter) {
+    this.#cache = val
+  }
+
+  #cache: ICacheAdapter = new DefaultCacheAdapter()
+
   /** Gateway Intents */
   intents?: GatewayIntents[]
   /** Whether to force new session or not */
@@ -91,21 +110,23 @@ export class Client extends HarmonyEventEmitter<ClientEvents> {
   reactionCacheLifetime: number = 3600000
   /** Whether to fetch Uncached Message of Reaction or not? */
   fetchUncachedReactions: boolean = false
+
   /** Client Properties */
-  clientProperties: ClientProperties
+  readonly clientProperties!: ClientProperties
+
   /** Slash-Commands Management client */
   slash: SlashClient
   /** Whether to fetch Gateway info or not */
   fetchGatewayInfo: boolean = true
 
   /** Users Manager, containing all Users cached */
-  users: UsersManager = new UsersManager(this)
+  readonly users: UsersManager = new UsersManager(this)
   /** Guilds Manager, providing cache & API interface to Guilds */
-  guilds: GuildManager = new GuildManager(this)
+  readonly guilds: GuildManager = new GuildManager(this)
   /** Channels Manager, providing cache interface to Channels */
-  channels: ChannelsManager = new ChannelsManager(this)
+  readonly channels: ChannelsManager = new ChannelsManager(this)
   /** Channels Manager, providing cache interface to Channels */
-  emojis: EmojisManager = new EmojisManager(this)
+  readonly emojis: EmojisManager = new EmojisManager(this)
 
   /** Last READY timestamp */
   upSince?: Date
@@ -146,7 +167,9 @@ export class Client extends HarmonyEventEmitter<ClientEvents> {
     super()
     this._id = options.id
     this.token = options.token
-    this.intents = options.intents
+    this.intents = options.intents?.map((e) =>
+      typeof e === 'string' ? GatewayIntents[e] : e
+    )
     this.shards = new ShardManager(this)
     this.forceNewSession = options.forceNewSession
     if (options.cache !== undefined) this.cache = options.cache
@@ -172,14 +195,17 @@ export class Client extends HarmonyEventEmitter<ClientEvents> {
       ;(this as any)._decoratedEvents = undefined
     }
 
-    this.clientProperties =
-      options.clientProperties === undefined
-        ? {
-            os: Deno.build.os,
-            browser: 'harmony',
-            device: 'harmony'
-          }
-        : options.clientProperties
+    Object.defineProperty(this, 'clientProperties', {
+      value:
+        options.clientProperties === undefined
+          ? {
+              os: Deno.build.os,
+              browser: 'harmony',
+              device: 'harmony'
+            }
+          : options.clientProperties,
+      enumerable: false
+    })
 
     if (options.shard !== undefined) this.shard = options.shard
     if (options.shardCount !== undefined) this.shardCount = options.shardCount

src/gateway/mod.ts

@@ -62,7 +62,7 @@ export class Gateway extends HarmonyEventEmitter<GatewayTypedEvents> {
   lastPingTimestamp = 0
   sessionID?: string
   private heartbeatServerResponded = false
-  client: Client
+  client!: Client
   cache: GatewayCache
   private timedIdentify: number | null = null
   shards?: number[]
@@ -70,7 +70,7 @@ export class Gateway extends HarmonyEventEmitter<GatewayTypedEvents> {
 
   constructor(client: Client, shards?: number[]) {
     super()
-    this.client = client
+    Object.defineProperty(this, 'client', { value: client, enumerable: false })
     this.cache = new GatewayCache(client)
     this.shards = shards
   }

src/interactions/slashClient.ts

@@ -47,11 +47,21 @@ export type SlashClientEvents = {
 export class SlashClient extends HarmonyEventEmitter<SlashClientEvents> {
   id: string | (() => string)
   client?: Client
-  token?: string
+
+  #token?: string
+
+  get token(): string | undefined {
+    return this.#token
+  }
+
+  set token(val: string | undefined) {
+    this.#token = val
+  }
+
   enabled: boolean = true
   commands: SlashCommandsManager
   handlers: SlashCommandHandler[] = []
-  rest: RESTManager
+  readonly rest!: RESTManager
   modules: SlashModule[] = []
   publicKey?: string
 
@@ -62,7 +72,14 @@ export class SlashClient extends HarmonyEventEmitter<SlashClientEvents> {
     if (id === undefined)
       throw new Error('ID could not be found. Pass at least client or token')
     this.id = id
-    this.client = options.client
+
+    if (options.client !== undefined) {
+      Object.defineProperty(this, 'client', {
+        value: options.client,
+        enumerable: false
+      })
+    }
+
     this.token = options.token
     this.publicKey = options.publicKey
 
@@ -85,14 +102,17 @@ export class SlashClient extends HarmonyEventEmitter<SlashClientEvents> {
       })
     }
 
-    this.rest =
-      options.client === undefined
-        ? options.rest === undefined
-          ? new RESTManager({
-              token: this.token
-            })
-          : options.rest
-        : options.client.rest
+    Object.defineProperty(this, 'rest', {
+      value:
+        options.client === undefined
+          ? options.rest === undefined
+            ? new RESTManager({
+                token: this.token
+              })
+            : options.rest
+          : options.client.rest,
+      enumerable: false
+    })
 
     this.client?.on(
       'interactionCreate',

src/interactions/slashCommand.ts

@@ -198,12 +198,15 @@ export class SlashBuilder {
 
 /** Manages Slash Commands, allows fetching/modifying/deleting/creating Slash Commands. */
 export class SlashCommandsManager {
-  slash: SlashClient
-  rest: RESTManager
+  readonly slash!: SlashClient
+  readonly rest!: RESTManager
 
   constructor(client: SlashClient) {
-    this.slash = client
-    this.rest = client.rest
+    Object.defineProperty(this, 'slash', { value: client, enumerable: false })
+    Object.defineProperty(this, 'rest', {
+      enumerable: false,
+      value: client.rest
+    })
   }
 
   /** Get all Global Slash Commands */

src/managers/base.ts

@@ -1,4 +1,5 @@
 import type { Client } from '../client/mod.ts'
+import { Base } from '../structures/base.ts'
 import { Collection } from '../utils/collection.ts'
 
 /**
@@ -6,15 +7,14 @@ import { Collection } from '../utils/collection.ts'
  *
  * You should not be making Managers yourself.
  */
-export class BaseManager<T, T2> {
-  client: Client
+export class BaseManager<T, T2> extends Base {
   /** Caches Name or Key used to differentiate caches */
   cacheName: string
   /** Which data type does this cache have */
   DataType: any
 
   constructor(client: Client, cacheName: string, DataType: any) {
-    this.client = client
+    super(client)
     this.cacheName = cacheName
     this.DataType = DataType
   }
@@ -87,4 +87,8 @@ export class BaseManager<T, T2> {
   flush(): any {
     return this.client.cache.deleteCache(this.cacheName)
   }
+
+  [Deno.customInspect](): string {
+    return `Manager(${this.cacheName})`
+  }
 }

src/managers/baseChild.ts

@@ -1,15 +1,15 @@
 import type { Client } from '../client/mod.ts'
+import { Base } from '../structures/base.ts'
 import { Collection } from '../utils/collection.ts'
 import { BaseManager } from './base.ts'
 
 /** Child Managers validate data from their parents i.e. from Managers */
-export class BaseChildManager<T, T2> {
-  client: Client
+export class BaseChildManager<T, T2> extends Base {
   /** Parent Manager */
   parent: BaseManager<T, T2>
 
   constructor(client: Client, parent: BaseManager<T, T2>) {
-    this.client = client
+    super(client)
     this.parent = parent
   }
 
@@ -62,4 +62,8 @@ export class BaseChildManager<T, T2> {
       if (fetchValue !== undefined) return fetchValue
     }
   }
+
+  [Deno.customInspect](): string {
+    return `ChildManager(${this.parent.cacheName})`
+  }
 }

src/rest/manager.ts

@@ -103,8 +103,18 @@ export class RESTManager {
    *   ```
    */
   api: APIMap
+
+  #token?: string | (() => string | undefined)
+
   /** Token being used for Authorization */
-  token?: string | (() => string | undefined)
+  get token(): string | (() => string | undefined) | undefined {
+    return this.#token
+  }
+
+  set token(val: string | (() => string | undefined) | undefined) {
+    this.#token = val
+  }
+
   /** Token Type of the Token if any */
   tokenType: TokenType = TokenType.Bot
   /** Headers object which patch the current ones */
@@ -114,13 +124,13 @@ export class RESTManager {
   /** Whether REST Manager is using Canary API */
   canary?: boolean
   /** Optional Harmony Client object */
-  client?: Client
+  readonly client?: Client
   endpoints: RESTEndpoints
   requestTimeout = 30000
-  timers: Set<number> = new Set()
+  readonly timers!: Set<number>
   apiURL = Constants.DISCORD_API_URL
 
-  handlers = new Collection<string, BucketHandler>()
+  readonly handlers!: Collection<string, BucketHandler>
   globalLimit = Infinity
   globalRemaining = this.globalLimit
   globalReset: number | null = null
@@ -136,11 +146,28 @@ export class RESTManager {
     if (options?.tokenType !== undefined) this.tokenType = options.tokenType
     if (options?.userAgent !== undefined) this.userAgent = options.userAgent
     if (options?.canary !== undefined) this.canary = options.canary
-    if (options?.client !== undefined) this.client = options.client
     if (options?.retryLimit !== undefined) this.retryLimit = options.retryLimit
     if (options?.requestTimeout !== undefined)
       this.requestTimeout = options.requestTimeout
+
+    if (options?.client !== undefined) {
+      Object.defineProperty(this, 'client', {
+        value: options.client,
+        enumerable: false
+      })
+    }
+
     this.endpoints = new RESTEndpoints(this)
+
+    Object.defineProperty(this, 'timers', {
+      value: new Set(),
+      enumerable: false
+    })
+
+    Object.defineProperty(this, 'handlers', {
+      value: new Collection<string, BucketHandler>(),
+      enumerable: false
+    })
   }
 
   setTimeout(fn: (...args: any[]) => any, ms: number): number {