Nomchy/discord.js
1
0
Fork 0
mirror of https://github.com/discordjs/discord.js.git synced 2026-03-11 00:53:31 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: merge collections with keeping entries at max (#6242)

Browse Source
This commit is contained in:
1Computer1
2021-07-31 16:03:58 -04:00
committed by GitHub
parent a25e16599a
commit bb5e648f3d
9 changed files with 209 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/client/Client.js
View File

@@ -176,7 +176,7 @@ class Client extends BaseClient {
if (this.options.messageSweepInterval > 0) {
process.emitWarning(
'The message sweeping client options are deprecated, use the makeCache option with a SweptCollection instead.',
'The message sweeping client options are deprecated, use the makeCache option with LimitedCollection instead.',
'DeprecationWarning',
);
this.sweepMessageInterval = setInterval(

1
src/index.js
View File

@@ -27,7 +27,6 @@ module.exports = {
Permissions: require('./util/Permissions'),
RateLimitError: require('./rest/RateLimitError'),
SnowflakeUtil: require('./util/SnowflakeUtil'),
SweptCollection: require('./util/SweptCollection'),
SystemChannelFlags: require('./util/SystemChannelFlags'),
ThreadMemberFlags: require('./util/ThreadMemberFlags'),
UserFlags: require('./util/UserFlags'),

4
src/managers/CachedManager.js
View File

@@ -14,14 +14,14 @@ class CachedManager extends DataManager {
Object.defineProperty(this, '_cache', { value: this.client.options.makeCache(this.constructor, this.holds) });
let cleanup = this._cache[_cleanupSymbol];
let cleanup = this._cache[_cleanupSymbol]?.();
if (cleanup) {
cleanup = cleanup.bind(this._cache);
client._cleanups.add(cleanup);
client._finalizers.register(this, {
cleanup,
message:
`Garbage Collection completed on ${this.constructor.name}, ` +
`Garbage collection completed on ${this.constructor.name}, ` +
`which had a ${this._cache.constructor.name} of ${this.holds.name}.`,
name: this.constructor.name,
});

131
src/util/LimitedCollection.js
View File

@@ -1,30 +1,151 @@
'use strict';
const { Collection } = require('@discordjs/collection');
const { _cleanupSymbol } = require('./Constants.js');
const { TypeError } = require('../errors/DJSError.js');
/**
* A Collection which holds a max amount of entries. The first key is deleted if the Collection has
* reached max size.
* @typedef {Function} SweepFilter
* @param {LimitedCollection} collection The collection being swept
* @returns {Function|null} Return `null` to skip sweeping, otherwise a function passed to `sweep()`,
* See {@link [Collection#sweep](https://discord.js.org/#/docs/collection/master/class/Collection?scrollTo=sweep)}
* for the definition of this function.
*/
/**
* Options for defining the behavior of a LimitedCollection
* @typedef {Object} LimitedCollectionOptions
* @property {?number} [maxSize=0] The maximum size of the Collection
* @property {?Function} [keepOverLimit=null] A function, which is passed the value and key of an entry, ran to decide
* to keep an entry past the maximum size
* @property {?SweepFilter} [sweepFilter=null] A function ran every `sweepInterval` to determine how to sweep
* @property {?number} [sweepInterval=0] How frequently, in seconds, to sweep the collection.
*/
/**
* A Collection which holds a max amount of entries and sweeps periodically.
* @extends {Collection}
* @param {number} [maxSize=0] The maximum size of the Collection
* @param {LimitedCollectionOptions} [options={}] Options for constructing the Collection.
* @param {Iterable} [iterable=null] Optional entries passed to the Map constructor.
*/
class LimitedCollection extends Collection {
constructor(maxSize = 0, iterable = null) {
constructor(options = {}, iterable) {
if (typeof options !== 'object' || options === null) {
throw new TypeError('INVALID_TYPE', 'options', 'object', true);
}
const { maxSize = Infinity, keepOverLimit = null, sweepInterval = 0, sweepFilter = null } = options;
if (typeof maxSize !== 'number') {
throw new TypeError('INVALID_TYPE', 'maxSize', 'number');
}
if (keepOverLimit !== null && typeof keepOverLimit !== 'function') {
throw new TypeError('INVALID_TYPE', 'keepOverLimit', 'function');
}
if (typeof sweepInterval !== 'number') {
throw new TypeError('INVALID_TYPE', 'sweepInterval', 'number');
}
if (sweepFilter !== null && typeof sweepFilter !== 'function') {
throw new TypeError('INVALID_TYPE', 'sweepFilter', 'function');
}
super(iterable);
/**
* The max size of the Collection.
* @type {number}
*/
this.maxSize = maxSize;
/**
* A function called to check if an entry should be kept when the Collection is at max size.
* @type {?Function}
*/
this.keepOverLimit = keepOverLimit;
/**
* A function called every sweep interval that returns a function passed to `sweep`.
* @type {?SweepFilter}
*/
this.sweepFilter = sweepFilter;
/**
* The id of the interval being used to sweep.
* @type {?Timeout}
*/
this.interval =
sweepInterval > 0 && sweepInterval !== Infinity && sweepFilter
? setInterval(() => {
const sweepFn = this.sweepFilter(this);
if (sweepFn === null) return;
if (typeof sweepFn !== 'function') throw new TypeError('SWEEP_FILTER_RETURN');
this.sweep(sweepFn);
}, sweepInterval * 1000).unref()
: null;
}
set(key, value) {
if (this.maxSize === 0) return this;
if (this.size >= this.maxSize && !this.has(key)) this.delete(this.firstKey());
if (this.size >= this.maxSize && !this.has(key)) {
for (const [k, v] of this.entries()) {
const keep = this.keepOverLimit?.(v, k, this) ?? false;
if (!keep) {
this.delete(k);
break;
}
}
}
return super.set(key, value);
}
/**
* Options for generating a filter function based on lifetime
* @typedef {Object} LifetimeFilterOptions
* @property {number} [lifetime=14400] How long an entry should stay in the collection before it is considered
* sweepable.
* @property {Function} [getComparisonTimestamp=`e => e.createdTimestamp`] A function that takes an entry, key,
* and the collection and returns a timestamp to compare against in order to determine the lifetime of the entry.
* @property {Function} [excludeFromSweep=`() => false`] A function that takes an entry, key, and the collection
* and returns a boolean, `true` when the entry should not be checked for sweepability.
*/
/**
* Create a sweepFilter function that uses a lifetime to determine sweepability.
* @param {LifetimeFilterOptions} [options={}] The options used to generate the filter function
* @returns {SweepFilter}
*/
static filterByLifetime({
lifetime = 14400,
getComparisonTimestamp = e => e?.createdTimestamp,
excludeFromSweep = () => false,
} = {}) {
if (typeof lifetime !== 'number') {
throw new TypeError('INVALID_TYPE', 'lifetime', 'number');
}
if (typeof getComparisonTimestamp !== 'function') {
throw new TypeError('INVALID_TYPE', 'getComparisonTimestamp', 'function');
}
if (typeof excludeFromSweep !== 'function') {
throw new TypeError('INVALID_TYPE', 'excludeFromSweep', 'function');
}
return () => {
if (lifetime <= 0) return null;
const lifetimeMs = lifetime * 1000;
const now = Date.now();
return (entry, key, coll) => {
if (excludeFromSweep(entry, key, coll)) {
return false;
}
const comparisonTimestamp = getComparisonTimestamp(entry, key, coll);
if (!comparisonTimestamp || typeof comparisonTimestamp !== 'number') return false;
return now - comparisonTimestamp > lifetimeMs;
};
};
}
[_cleanupSymbol]() {
return this.interval ? () => clearInterval(this.interval) : null;
}
static get [Symbol.species]() {
return Collection;
}

47
src/util/Options.js
View File

@@ -35,9 +35,9 @@
* (e.g. recommended shard count, shard count of the ShardingManager)
* @property {CacheFactory} [makeCache] Function to create a cache.
* You can use your own function, or the {@link Options} class to customize the Collection used for the cache.
* @property {number} [messageCacheLifetime=0] DEPRECATED: Use `makeCache` with a `SweptCollection` instead.
* @property {number} [messageCacheLifetime=0] DEPRECATED: Use `makeCache` with a `LimitedCollection` instead.
* How long a message should stay in the cache until it is considered sweepable (in seconds, 0 for forever)
* @property {number} [messageSweepInterval=0] DEPRECATED: Use `makeCache` with a `SweptCollection` instead.
* @property {number} [messageSweepInterval=0] DEPRECATED: Use `makeCache` with a `LimitedCollection` instead.
* How frequently to remove messages from the cache that are older than the message cache lifetime
* (in seconds, 0 for never)
* @property {MessageMentionOptions} [allowedMentions] Default value for {@link MessageOptions#allowedMentions}
@@ -103,7 +103,8 @@ class Options extends null {
makeCache: this.cacheWithLimits({
MessageManager: 200,
ThreadManager: {
sweepFilter: require('./SweptCollection').filterByLifetime({
sweepInterval: 3600,
sweepFilter: require('./LimitedCollection').filterByLifetime({
getComparisonTimestamp: e => e.archiveTimestamp,
excludeFromSweep: e => !e.archived,
}),
@@ -144,17 +145,18 @@ class Options extends null {
/**
* Create a cache factory using predefined settings to sweep or limit.
* @param {Object<string, SweptCollectionOptions|number>} [settings={}] Settings passed to the relevant constructor.
* @param {Object<string, LimitedCollectionOptions|number>} [settings={}] Settings passed to the relevant constructor.
* If no setting is provided for a manager, it uses Collection.
* If SweptCollectionOptions are provided for a manager, it uses those settings to form a SweptCollection
* If a number is provided for a manager, it uses that number as the max size for a LimitedCollection
* If a number is provided for a manager, it uses that number as the max size for a LimitedCollection.
* If LimitedCollectionOptions are provided for a manager, it uses those settings to form a LimitedCollection.
* @returns {CacheFactory}
* @example
* // Store up to 200 messages per channel and discard archived threads if they were archived more than 4 hours ago.
* Options.cacheWithLimits({
* MessageManager: 200,
* ThreadManager: {
* sweepFilter: SweptCollection.filterByLifetime({
* sweepInterval: 3600,
* sweepFilter: LimitedCollection.filterByLifetime({
* getComparisonTimestamp: e => e.archiveTimestamp,
* excludeFromSweep: e => !e.archived,
* }),
@@ -165,7 +167,7 @@ class Options extends null {
* Options.cacheWithLimits({
* MessageManager: {
* sweepInterval: 300,
* sweepFilter: SweptCollection.filterByLifetime({
* sweepFilter: LimitedCollection.filterByLifetime({
* lifetime: 1800,
* getComparisonTimestamp: e => e.editedTimestamp ?? e.createdTimestamp,
* })
@@ -175,20 +177,31 @@ class Options extends null {
static cacheWithLimits(settings = {}) {
const { Collection } = require('@discordjs/collection');
const LimitedCollection = require('./LimitedCollection');
const SweptCollection = require('./SweptCollection');
return manager => {
const setting = settings[manager.name];
if (typeof setting === 'number' && setting !== Infinity) return new LimitedCollection(setting);
if (
/* eslint-disable-next-line eqeqeq */
(setting?.sweepInterval == null && setting?.sweepFilter == null) ||
setting.sweepInterval <= 0 ||
setting.sweepInterval === Infinity
) {
/* eslint-disable-next-line eqeqeq */
if (setting == null) {
return new Collection();
}
return new SweptCollection(setting);
if (typeof setting === 'number') {
if (setting === Infinity) {
return new Collection();
}
return new LimitedCollection({ maxSize: setting });
}
/* eslint-disable eqeqeq */
const noSweeping =
setting.sweepFilter == null ||
setting.sweepInterval == null ||
setting.sweepInterval <= 0 ||
setting.sweepInterval === Infinity;
const noLimit = setting.maxSize == null || setting.maxSize === Infinity;
/* eslint-enable eqeqeq */
if (noSweeping && noLimit) {
return new Collection();
}
return new LimitedCollection(setting);
};
}

115
src/util/SweptCollection.js
View File

@@ -1,115 +0,0 @@
'use strict';
const { Collection } = require('@discordjs/collection');
const { _cleanupSymbol } = require('./Constants.js');
const { TypeError } = require('../errors/DJSError.js');
/**
* @typedef {Function} SweepFilter
* @param {SweptCollection} collection The collection being swept
* @returns {Function|null} Return `null` to skip sweeping, otherwise a function passed to `sweep()`,
* See {@link [Collection#sweep](https://discord.js.org/#/docs/collection/master/class/Collection?scrollTo=sweep)}
* for the definition of this function.
*/
/**
* Options for defining the behavior of a Swept Collection
* @typedef {Object} SweptCollectionOptions
* @property {?SweepFitler} [sweepFilter=null] A function run every `sweepInterval` to determine how to sweep
* @property {number} [sweepInterval=3600] How frequently, in seconds, to sweep the collection.
*/
/**
* A Collection which holds a max amount of entries and sweeps periodically.
* @extends {Collection}
* @param {SweptCollectionOptions} [options={}] Options for constructing the swept collection.
* @param {Iterable} [iterable=null] Optional entries passed to the Map constructor.
*/
class SweptCollection extends Collection {
constructor(options = {}, iterable) {
if (typeof options !== 'object' || options === null) {
throw new TypeError('INVALID_TYPE', 'options', 'object or iterable', true);
}
const { sweepFilter = null, sweepInterval = 3600 } = options;
if (sweepFilter !== null && typeof sweepFilter !== 'function') {
throw new TypeError('INVALID_TYPE', 'sweepFunction', 'function');
}
if (typeof sweepInterval !== 'number') throw new TypeError('INVALID_TYPE', 'sweepInterval', 'number');
super(iterable);
/**
* A function called every sweep interval that returns a function passed to `sweep`
* @type {?SweepFilter}
*/
this.sweepFilter = sweepFilter;
/**
* The id of the interval being used to sweep.
* @type {?Timeout}
*/
this.interval =
sweepInterval > 0 && sweepFilter
? setInterval(() => {
const sweepFn = this.sweepFilter(this);
if (sweepFn === null) return;
if (typeof sweepFn !== 'function') throw new TypeError('SWEEP_FILTER_RETURN');
this.sweep(sweepFn);
}, sweepInterval * 1000).unref()
: null;
}
/**
* Options for generating a filter function based on lifetime
* @typedef {Object} LifetimeFilterOptions
* @property {number} [lifetime=14400] How long an entry should stay in the collection
* before it is considered sweepable
* @property {Function} [getComparisonTimestamp=`e => e.createdTimestamp`] A function that takes an entry, key,
* and the collection and returns a timestamp to compare against in order to determine the lifetime of the entry.
* @property {Function} [excludeFromSweep=`() => false`] A function that takes an entry, key, and the collection
* and returns a boolean, `true` when the entry should not be checked for sweepability.
*/
/**
* Create a sweepFilter function that uses a lifetime to determine sweepability.
* @param {LifetimeFilterOptions} [options={}] The options used to generate the filter function
* @returns {SweepFilter}
*/
static filterByLifetime({
lifetime = 14400,
getComparisonTimestamp = e => e?.createdTimestamp,
excludeFromSweep = () => false,
} = {}) {
if (typeof lifetime !== 'number') throw new TypeError('INVALID_TYPE', 'lifetime', 'number');
if (typeof getComparisonTimestamp !== 'function') {
throw new TypeError('INVALID_TYPE', 'getComparisonTimestamp', 'function');
}
if (typeof excludeFromSweep !== 'function') {
throw new TypeError('INVALID_TYPE', 'excludeFromSweep', 'function');
}
return () => {
if (lifetime <= 0) return null;
const lifetimeMs = lifetime * 1000;
const now = Date.now();
return (entry, key, coll) => {
if (excludeFromSweep(entry, key, coll)) {
return false;
}
const comparisonTimestamp = getComparisonTimestamp(entry, key, coll);
if (!comparisonTimestamp || typeof comparisonTimestamp !== 'number') return false;
return now - comparisonTimestamp > lifetimeMs;
};
};
}
[_cleanupSymbol]() {
clearInterval(this.interval);
}
static get [Symbol.species]() {
return Collection;
}
}
module.exports = SweptCollection;