StyAndCo/zeppelin
3
0
Fork 0
mirror of https://github.com/ZeppelinBot/Zeppelin.git synced 2025-03-15 05:41:51 +00:00
Code Releases Activity

refactor: replace io-ts with zod

Browse source
This commit is contained in:
Dragory 2024-01-14 14:25:42 +00:00
parent fafaefa1fb
commit 28692962bc
No known key found for this signature in database
161 changed files with 1450 additions and 2105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
backend/package-lock.json generated
View file

@ -22,7 +22,6 @@
"express": "^4.17.0",
"fp-ts": "^2.0.1",
"humanize-duration": "^3.15.0",
"io-ts": "^2.0.0",
"js-yaml": "^3.13.1",
"knub": "^32.0.0-next.16",
"knub-command-manager": "^9.1.0",
@ -4975,14 +4974,6 @@
"resolved": "https://registry.npmjs.org/internmap/-/internmap-1.0.1.tgz",
"integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw=="
},
"node_modules/io-ts": {
"version": "2.2.20",
"resolved": "https://registry.npmjs.org/io-ts/-/io-ts-2.2.20.tgz",
"integrity": "sha512-Rq2BsYmtwS5vVttie4rqrOCIfHCS9TgpRLFpKQCM1wZBBRY9nWVGmEvm2FnDbSE2un1UE39DvFpTR5UL47YDcA==",
"peerDependencies": {
"fp-ts": "^2.5.0"
}
},
"node_modules/iota-array": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/iota-array/-/iota-array-1.0.0.tgz",

1
backend/package.json
View file

@ -43,7 +43,6 @@
"express": "^4.17.0",
"fp-ts": "^2.0.1",
"humanize-duration": "^3.15.0",
"io-ts": "^2.0.0",
"js-yaml": "^3.13.1",
"knub": "^32.0.0-next.16",
"knub-command-manager": "^9.1.0",

2
backend/src/commandTypes.ts
View file

@ -17,6 +17,7 @@ import { createTypeHelper } from "knub-command-manager";
import {
channelMentionRegex,
convertDelayStringToMS,
inputPatternToRegExp,
isValidSnowflake,
resolveMember,
resolveUser,
@ -26,7 +27,6 @@ import {
} from "./utils";
import { isValidTimezone } from "./utils/isValidTimezone";
import { MessageTarget, resolveMessageTarget } from "./utils/resolveMessageTarget";
import { inputPatternToRegExp } from "./validatorUtils";
export const commandTypes = {
...messageCommandBaseTypeConverters,

16
backend/src/configValidator.ts
View file

@ -1,9 +1,9 @@
import { ConfigValidationError, PluginConfigManager } from "knub";
import { PluginConfigManager } from "knub";
import moment from "moment-timezone";
import { ZodError } from "zod";
import { ZeppelinPlugin } from "./plugins/ZeppelinPlugin";
import { guildPlugins } from "./plugins/availablePlugins";
import { PartialZeppelinGuildConfigSchema, ZeppelinGuildConfig } from "./types";
import { StrictValidationError, decodeAndValidateStrict } from "./validatorUtils";
import { ZeppelinGuildConfig, zZeppelinGuildConfig } from "./types";
const pluginNameToPlugin = new Map<string, ZeppelinPlugin>();
for (const plugin of guildPlugins) {
@ -11,8 +11,10 @@ for (const plugin of guildPlugins) {
}
export async function validateGuildConfig(config: any): Promise<string | null> {
const validationResult = decodeAndValidateStrict(PartialZeppelinGuildConfigSchema, config);
if (validationResult instanceof StrictValidationError) return validationResult.getErrors();
const validationResult = zZeppelinGuildConfig.safeParse(config);
if (!validationResult.success) {
return validationResult.error.issues.join("\n");
}
const guildConfig = config as ZeppelinGuildConfig;
@ -41,8 +43,8 @@ export async function validateGuildConfig(config: any): Promise<string | null> {
try {
await configManager.init();
} catch (err) {
if (err instanceof ConfigValidationError || err instanceof StrictValidationError) {
return `${pluginName}: ${err.message}`;
if (err instanceof ZodError) {
return `${pluginName}: ${err.issues.join("\n")}`;
}
throw err;

48
backend/src/pluginUtils.ts
View file

@ -10,22 +10,18 @@ import {
PermissionsBitField,
TextBasedChannel,
} from "discord.js";
import * as t from "io-ts";
import {
AnyPluginData,
CommandContext,
ConfigValidationError,
ExtendedMatchParams,
GuildPluginData,
PluginOverrideCriteria,
helpers,
helpers
} from "knub";
import { logger } from "./logger";
import { isStaff } from "./staff";
import { TZeppelinKnub } from "./types";
import { errorMessage, successMessage, tNullable } from "./utils";
import { errorMessage, successMessage } from "./utils";
import { Tail } from "./utils/typeUtils";
import { StrictValidationError, parseIoTsSchema } from "./validatorUtils";
const { getMemberLevel } = helpers;
@ -59,46 +55,6 @@ export async function hasPermission(
return helpers.hasPermission(config, permission);
}
const PluginOverrideCriteriaType: t.Type<PluginOverrideCriteria<unknown>> = t.recursion(
"PluginOverrideCriteriaType",
() =>
t.partial({
channel: tNullable(t.union([t.string, t.array(t.string)])),
category: tNullable(t.union([t.string, t.array(t.string)])),
level: tNullable(t.union([t.string, t.array(t.string)])),
user: tNullable(t.union([t.string, t.array(t.string)])),
role: tNullable(t.union([t.string, t.array(t.string)])),
all: tNullable(t.array(PluginOverrideCriteriaType)),
any: tNullable(t.array(PluginOverrideCriteriaType)),
not: tNullable(PluginOverrideCriteriaType),
extra: t.unknown,
}),
);
export function strictValidationErrorToConfigValidationError(err: StrictValidationError) {
return new ConfigValidationError(
err
.getErrors()
.map((e) => e.toString())
.join("\n"),
);
}
export function makeIoTsConfigParser<Schema extends t.Type<any>>(schema: Schema): (input: unknown) => t.TypeOf<Schema> {
return (input: unknown) => {
try {
return parseIoTsSchema(schema, input);
} catch (err) {
if (err instanceof StrictValidationError) {
throw strictValidationErrorToConfigValidationError(err);
}
throw err;
}
};
}
export async function sendSuccessMessage(
pluginData: AnyPluginData<any>,
channel: TextBasedChannel,

7
backend/src/plugins/AutoDelete/AutoDeletePlugin.ts
View file

@ -1,11 +1,10 @@
import { PluginOptions } from "knub";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { LogsPlugin } from "../Logs/LogsPlugin";
import { TimeAndDatePlugin } from "../TimeAndDate/TimeAndDatePlugin";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { AutoDeletePluginType, ConfigSchema } from "./types";
import { AutoDeletePluginType, zAutoDeleteConfig } from "./types";
import { onMessageCreate } from "./util/onMessageCreate";
import { onMessageDelete } from "./util/onMessageDelete";
import { onMessageDeleteBulk } from "./util/onMessageDeleteBulk";
@ -24,11 +23,11 @@ export const AutoDeletePlugin = zeppelinGuildPlugin<AutoDeletePluginType>()({
prettyName: "Auto-delete",
description: "Allows Zeppelin to auto-delete messages from a channel after a delay",
configurationGuide: "Maximum deletion delay is currently 5 minutes",
configSchema: ConfigSchema,
configSchema: zAutoDeleteConfig,
},
dependencies: () => [TimeAndDatePlugin, LogsPlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zAutoDeleteConfig.parse(input),
defaultOptions,
beforeLoad(pluginData) {

13
backend/src/plugins/AutoDelete/types.ts
View file

@ -1,10 +1,10 @@
import * as t from "io-ts";
import { BasePluginType } from "knub";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { SavedMessage } from "../../data/entities/SavedMessage";
import { MINUTES, tDelayString } from "../../utils";
import { MINUTES, zDelayString } from "../../utils";
import Timeout = NodeJS.Timeout;
import z from "zod";
export const MAX_DELAY = 5 * MINUTES;
@ -13,14 +13,13 @@ export interface IDeletionQueueItem {
message: SavedMessage;
}
export const ConfigSchema = t.type({
enabled: t.boolean,
delay: tDelayString,
export const zAutoDeleteConfig = z.strictObject({
enabled: z.boolean(),
delay: zDelayString,
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface AutoDeletePluginType extends BasePluginType {
config: TConfigSchema;
config: z.output<typeof zAutoDeleteConfig>;
state: {
guildSavedMessages: GuildSavedMessages;
guildLogs: GuildLogs;

7
backend/src/plugins/AutoReactions/AutoReactionsPlugin.ts
View file

@ -1,14 +1,13 @@
import { PluginOptions } from "knub";
import { GuildAutoReactions } from "../../data/GuildAutoReactions";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { trimPluginDescription } from "../../utils";
import { LogsPlugin } from "../Logs/LogsPlugin";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { DisableAutoReactionsCmd } from "./commands/DisableAutoReactionsCmd";
import { NewAutoReactionsCmd } from "./commands/NewAutoReactionsCmd";
import { AddReactionsEvt } from "./events/AddReactionsEvt";
import { AutoReactionsPluginType, ConfigSchema } from "./types";
import { AutoReactionsPluginType, zAutoReactionsConfig } from "./types";
const defaultOptions: PluginOptions<AutoReactionsPluginType> = {
config: {
@ -32,7 +31,7 @@ export const AutoReactionsPlugin = zeppelinGuildPlugin<AutoReactionsPluginType>(
description: trimPluginDescription(`
Allows setting up automatic reactions to all new messages on a channel
`),
configSchema: ConfigSchema,
configSchema: zAutoReactionsConfig,
},
// prettier-ignore
@ -40,7 +39,7 @@ export const AutoReactionsPlugin = zeppelinGuildPlugin<AutoReactionsPluginType>(
LogsPlugin,
],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zAutoReactionsConfig.parse(input),
defaultOptions,
// prettier-ignore

9
backend/src/plugins/AutoReactions/types.ts
View file

@ -1,17 +1,16 @@
import * as t from "io-ts";
import { BasePluginType, guildPluginEventListener, guildPluginMessageCommand } from "knub";
import z from "zod";
import { GuildAutoReactions } from "../../data/GuildAutoReactions";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { AutoReaction } from "../../data/entities/AutoReaction";
export const ConfigSchema = t.type({
can_manage: t.boolean,
export const zAutoReactionsConfig = z.strictObject({
can_manage: z.boolean(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface AutoReactionsPluginType extends BasePluginType {
config: TConfigSchema;
config: z.output<typeof zAutoReactionsConfig>;
state: {
logs: GuildLogs;
savedMessages: GuildSavedMessages;

132
backend/src/plugins/Automod/AutomodPlugin.ts
View file

@ -1,4 +1,4 @@
import { configUtils, CooldownManager } from "knub";
import { CooldownManager } from "knub";
import { GuildAntiraidLevels } from "../../data/GuildAntiraidLevels";
import { GuildArchives } from "../../data/GuildArchives";
import { GuildLogs } from "../../data/GuildLogs";
@ -8,7 +8,6 @@ import { discardRegExpRunner, getRegExpRunner } from "../../regExpRunners";
import { MINUTES, SECONDS } from "../../utils";
import { registerEventListenersFromMap } from "../../utils/registerEventListenersFromMap";
import { unregisterEventListenersFromMap } from "../../utils/unregisterEventListenersFromMap";
import { parseIoTsSchema, StrictValidationError } from "../../validatorUtils";
import { CountersPlugin } from "../Counters/CountersPlugin";
import { InternalPosterPlugin } from "../InternalPoster/InternalPosterPlugin";
import { LogsPlugin } from "../Logs/LogsPlugin";
@ -17,7 +16,6 @@ import { MutesPlugin } from "../Mutes/MutesPlugin";
import { PhishermanPlugin } from "../Phisherman/PhishermanPlugin";
import { RoleManagerPlugin } from "../RoleManager/RoleManagerPlugin";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { availableActions } from "./actions/availableActions";
import { AntiraidClearCmd } from "./commands/AntiraidClearCmd";
import { SetAntiraidCmd } from "./commands/SetAntiraidCmd";
import { ViewAntiraidCmd } from "./commands/ViewAntiraidCmd";
@ -35,8 +33,7 @@ import { clearOldRecentNicknameChanges } from "./functions/clearOldNicknameChang
import { clearOldRecentActions } from "./functions/clearOldRecentActions";
import { clearOldRecentSpam } from "./functions/clearOldRecentSpam";
import { pluginInfo } from "./info";
import { availableTriggers } from "./triggers/availableTriggers";
import { AutomodPluginType, ConfigSchema } from "./types";
import { AutomodPluginType, zAutomodConfig } from "./types";
const defaultOptions = {
config: {
@ -61,129 +58,6 @@ const defaultOptions = {
],
};
/**
* Config preprocessor to set default values for triggers and perform extra validation
* TODO: Separate input and output types
*/
const configParser = (input: unknown) => {
const rules = (input as any).rules;
if (rules) {
// Loop through each rule
for (const [name, rule] of Object.entries(rules)) {
if (rule == null) {
delete rules[name];
continue;
}
rule["name"] = name;
// If the rule doesn't have an explicitly set "enabled" property, set it to true
if (rule["enabled"] == null) {
rule["enabled"] = true;
}
if (rule["allow_further_rules"] == null) {
rule["allow_further_rules"] = false;
}
if (rule["affects_bots"] == null) {
rule["affects_bots"] = false;
}
if (rule["affects_self"] == null) {
rule["affects_self"] = false;
}
// Loop through the rule's triggers
if (rule["triggers"]) {
for (const triggerObj of rule["triggers"]) {
for (const triggerName in triggerObj) {
if (!availableTriggers[triggerName]) {
throw new StrictValidationError([`Unknown trigger '${triggerName}' in rule '${rule["name"]}'`]);
}
const triggerBlueprint = availableTriggers[triggerName];
if (typeof triggerBlueprint.defaultConfig === "object" && triggerBlueprint.defaultConfig != null) {
triggerObj[triggerName] = configUtils.mergeConfig(
triggerBlueprint.defaultConfig,
triggerObj[triggerName] || {},
);
} else {
triggerObj[triggerName] = triggerObj[triggerName] || triggerBlueprint.defaultConfig;
}
if (triggerObj[triggerName].match_attachment_type) {
const white = triggerObj[triggerName].match_attachment_type.whitelist_enabled;
const black = triggerObj[triggerName].match_attachment_type.blacklist_enabled;
if (white && black) {
throw new StrictValidationError([
`Cannot have both blacklist and whitelist enabled at rule <${rule["name"]}/match_attachment_type>`,
]);
} else if (!white && !black) {
throw new StrictValidationError([
`Must have either blacklist or whitelist enabled at rule <${rule["name"]}/match_attachment_type>`,
]);
}
}
if (triggerObj[triggerName].match_mime_type) {
const white = triggerObj[triggerName].match_mime_type.whitelist_enabled;
const black = triggerObj[triggerName].match_mime_type.blacklist_enabled;
if (white && black) {
throw new StrictValidationError([
`Cannot have both blacklist and whitelist enabled at rule <${rule["name"]}/match_mime_type>`,
]);
} else if (!white && !black) {
throw new StrictValidationError([
`Must have either blacklist or whitelist enabled at rule <${rule["name"]}/match_mime_type>`,
]);
}
}
}
}
}
if (rule["actions"]) {
for (const actionName in rule["actions"]) {
if (!availableActions[actionName]) {
throw new StrictValidationError([`Unknown action '${actionName}' in rule '${rule["name"]}'`]);
}
const actionBlueprint = availableActions[actionName];
const actionConfig = rule["actions"][actionName];
if (typeof actionConfig !== "object" || Array.isArray(actionConfig) || actionConfig == null) {
rule["actions"][actionName] = actionConfig;
} else {
rule["actions"][actionName] = configUtils.mergeConfig(actionBlueprint.defaultConfig, actionConfig);
}
}
}
// Enable logging of automod actions by default
if (rule["actions"]) {
for (const actionName in rule["actions"]) {
if (!availableActions[actionName]) {
throw new StrictValidationError([`Unknown action '${actionName}' in rule '${rule["name"]}'`]);
}
}
if (rule["actions"]["log"] == null) {
rule["actions"]["log"] = true;
}
if (rule["actions"]["clean"] && rule["actions"]["start_thread"]) {
throw new StrictValidationError([`Cannot have both clean and start_thread at rule '${rule["name"]}'`]);
}
}
}
}
return parseIoTsSchema(ConfigSchema, input);
};
export const AutomodPlugin = zeppelinGuildPlugin<AutomodPluginType>()({
name: "automod",
showInDocs: true,
@ -201,7 +75,7 @@ export const AutomodPlugin = zeppelinGuildPlugin<AutomodPluginType>()({
],
defaultOptions,
configParser,
configParser: (input) => zAutomodConfig.parse(input),
customOverrideCriteriaFunctions: {
antiraid_level: (pluginData, matchParams, value) => {

9
backend/src/plugins/Automod/actions/addRoles.ts
View file

@ -1,6 +1,6 @@
import { PermissionFlagsBits, Snowflake } from "discord.js";
import * as t from "io-ts";
import { nonNullish, unique } from "../../../utils";
import z from "zod";
import { nonNullish, unique, zSnowflake } from "../../../utils";
import { canAssignRole } from "../../../utils/canAssignRole";
import { getMissingPermissions } from "../../../utils/getMissingPermissions";
import { missingPermissionError } from "../../../utils/missingPermissionError";
@ -11,9 +11,10 @@ import { automodAction } from "../helpers";
const p = PermissionFlagsBits;
const configSchema = z.array(zSnowflake);
export const AddRolesAction = automodAction({
configType: t.array(t.string),
defaultConfig: [],
configSchema,
async apply({ pluginData, contexts, actionConfig, ruleName }) {
const members = unique(contexts.map((c) => c.member).filter(nonNullish));

15
backend/src/plugins/Automod/actions/addToCounter.ts
View file

@ -1,15 +1,16 @@
import * as t from "io-ts";
import z from "zod";
import { zBoundedCharacters } from "../../../utils";
import { CountersPlugin } from "../../Counters/CountersPlugin";
import { LogsPlugin } from "../../Logs/LogsPlugin";
import { automodAction } from "../helpers";
export const AddToCounterAction = automodAction({
configType: t.type({
counter: t.string,
amount: t.number,
}),
const configSchema = z.object({
counter: zBoundedCharacters(0, 100),
amount: z.number(),
});
defaultConfig: {},
export const AddToCounterAction = automodAction({
configSchema,
async apply({ pluginData, contexts, actionConfig, ruleName }) {
const countersPlugin = pluginData.getPlugin(CountersPlugin);

22
backend/src/plugins/Automod/actions/alert.ts
View file

@ -1,6 +1,6 @@
import { Snowflake } from "discord.js";
import * as t from "io-ts";
import { erisAllowedMentionsToDjsMentionOptions } from "src/utils/erisAllowedMentionsToDjsMentionOptions";
import z from "zod";
import { LogType } from "../../../data/LogType";
import {
createTypedTemplateSafeValueContainer,
@ -12,10 +12,12 @@ import {
chunkMessageLines,
isTruthy,
messageLink,
tAllowedMentions,
tNormalizedNullOptional,
validateAndParseMessageContent,
verboseChannelMention,
zAllowedMentions,
zBoundedCharacters,
zNullishToUndefined,
zSnowflake
} from "../../../utils";
import { messageIsEmpty } from "../../../utils/messageIsEmpty";
import { userToTemplateSafeUser } from "../../../utils/templateSafeObjects";
@ -23,14 +25,14 @@ import { InternalPosterPlugin } from "../../InternalPoster/InternalPosterPlugin"
import { LogsPlugin } from "../../Logs/LogsPlugin";
import { automodAction } from "../helpers";
export const AlertAction = automodAction({
configType: t.type({
channel: t.string,
text: t.string,
allowed_mentions: tNormalizedNullOptional(tAllowedMentions),
}),
const configSchema = z.object({
channel: zSnowflake,
text: zBoundedCharacters(1, 4000),
allowed_mentions: zNullishToUndefined(zAllowedMentions.nullable().default(null)),
});
defaultConfig: {},
export const AlertAction = automodAction({
configSchema,
async apply({ pluginData, contexts, actionConfig, ruleName, matchResult }) {
const channel = pluginData.guild.channels.cache.get(actionConfig.channel as Snowflake);

7
backend/src/plugins/Automod/actions/archiveThread.ts
View file

@ -1,11 +1,12 @@
import { AnyThreadChannel } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { noop } from "../../../utils";
import { automodAction } from "../helpers";
const configSchema = z.strictObject({});
export const ArchiveThreadAction = automodAction({
configType: t.type({}),
defaultConfig: {},
configSchema,
async apply({ pluginData, contexts }) {
const threads = contexts

26
backend/src/plugins/Automod/actions/availableActions.ts
View file

@ -1,4 +1,3 @@
import * as t from "io-ts";
import { AutomodActionBlueprint } from "../helpers";
import { AddRolesAction } from "./addRoles";
import { AddToCounterAction } from "./addToCounter";
@ -19,7 +18,7 @@ import { SetSlowmodeAction } from "./setSlowmode";
import { StartThreadAction } from "./startThread";
import { WarnAction } from "./warn";
export const availableActions: Record<string, AutomodActionBlueprint<any>> = {
export const availableActions = {
clean: CleanAction,
warn: WarnAction,
mute: MuteAction,
@ -38,25 +37,4 @@ export const availableActions: Record<string, AutomodActionBlueprint<any>> = {
start_thread: StartThreadAction,
archive_thread: ArchiveThreadAction,
change_perms: ChangePermsAction,
};
export const AvailableActions = t.type({
clean: CleanAction.configType,
warn: WarnAction.configType,
mute: MuteAction.configType,
kick: KickAction.configType,
ban: BanAction.configType,
alert: AlertAction.configType,
change_nickname: ChangeNicknameAction.configType,
log: LogAction.configType,
add_roles: AddRolesAction.configType,
remove_roles: RemoveRolesAction.configType,
set_antiraid_level: SetAntiraidLevelAction.configType,
reply: ReplyAction.configType,
add_to_counter: AddToCounterAction.configType,
set_counter: SetCounterAction.configType,
set_slowmode: SetSlowmodeAction.configType,
start_thread: StartThreadAction.configType,
archive_thread: ArchiveThreadAction.configType,
change_perms: ChangePermsAction.configType,
});
} satisfies Record<string, AutomodActionBlueprint<any>>;

30
backend/src/plugins/Automod/actions/ban.ts
View file

@ -1,25 +1,23 @@
import * as t from "io-ts";
import { convertDelayStringToMS, nonNullish, tDelayString, tNullable, unique } from "../../../utils";
import z from "zod";
import { convertDelayStringToMS, nonNullish, unique, zBoundedCharacters, zDelayString, zSnowflake } from "../../../utils";
import { CaseArgs } from "../../Cases/types";
import { ModActionsPlugin } from "../../ModActions/ModActionsPlugin";
import { resolveActionContactMethods } from "../functions/resolveActionContactMethods";
import { automodAction } from "../helpers";
import { zNotify } from "../types";
const configSchema = z.strictObject({
reason: zBoundedCharacters(0, 4000).nullable().default(null),
duration: zDelayString.nullable().default(null),
notify: zNotify.nullable().default(null),
notifyChannel: zSnowflake.nullable().default(null),
deleteMessageDays: z.number().nullable().default(null),
postInCaseLog: z.boolean().nullable().default(null),
hide_case: z.boolean().nullable().default(false),
});
export const BanAction = automodAction({
configType: t.type({
reason: tNullable(t.string),
duration: tNullable(tDelayString),
notify: tNullable(t.string),
notifyChannel: tNullable(t.string),
deleteMessageDays: tNullable(t.number),
postInCaseLog: tNullable(t.boolean),
hide_case: tNullable(t.boolean),
}),
defaultConfig: {
notify: null, // Use defaults from ModActions
hide_case: false,
},
configSchema,
async apply({ pluginData, contexts, actionConfig, matchResult }) {
const reason = actionConfig.reason || "Kicked automatically";

14
backend/src/plugins/Automod/actions/changeNickname.ts
View file

@ -1,18 +1,16 @@
import * as t from "io-ts";
import { nonNullish, unique } from "../../../utils";
import z from "zod";
import { nonNullish, unique, zBoundedCharacters } from "../../../utils";
import { LogsPlugin } from "../../Logs/LogsPlugin";
import { automodAction } from "../helpers";
export const ChangeNicknameAction = automodAction({
configType: t.union([
t.string,
t.type({
name: t.string,
configSchema: z.union([
zBoundedCharacters(0, 32),
z.strictObject({
name: zBoundedCharacters(0, 32),
}),
]),
defaultConfig: {},
async apply({ pluginData, contexts, actionConfig }) {
const members = unique(contexts.map((c) => c.member).filter(nonNullish));

22
backend/src/plugins/Automod/actions/changePerms.ts
View file

@ -1,7 +1,8 @@
import { PermissionsBitField, PermissionsString } from "discord.js";
import * as t from "io-ts";
import { U } from "ts-toolbelt";
import z from "zod";
import { TemplateSafeValueContainer, renderTemplate } from "../../../templateFormatter";
import { isValidSnowflake, noop, tNullable, tPartialDictionary } from "../../../utils";
import { isValidSnowflake, keys, noop, zSnowflake } from "../../../utils";
import {
guildToTemplateSafeGuild,
savedMessageToTemplateSafeSavedMessage,
@ -59,16 +60,19 @@ const realToLegacyMap = Object.entries(legacyPermMap).reduce((map, pair) => {
return map;
}, {}) as Record<keyof typeof PermissionsBitField.Flags, keyof typeof legacyPermMap>;
const permissionNames = keys(PermissionsBitField.Flags) as U.ListOf<keyof typeof PermissionsBitField.Flags>;
const legacyPermissionNames = keys(legacyPermMap) as U.ListOf<keyof typeof legacyPermMap>;
const allPermissionNames = [...permissionNames, ...legacyPermissionNames] as const;
export const ChangePermsAction = automodAction({
configType: t.type({
target: t.string,
channel: tNullable(t.string),
perms: tPartialDictionary(
t.union([t.keyof(PermissionsBitField.Flags), t.keyof(legacyPermMap)]),
tNullable(t.boolean),
configSchema: z.strictObject({
target: zSnowflake,
channel: zSnowflake.nullable().default(null),
perms: z.record(
z.enum(allPermissionNames),
z.boolean().nullable(),
),
}),
defaultConfig: {},
async apply({ pluginData, contexts, actionConfig }) {
const user = contexts.find((c) => c.user)?.user;

5
backend/src/plugins/Automod/actions/clean.ts
View file

@ -1,12 +1,11 @@
import { GuildTextBasedChannel, Snowflake } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { LogType } from "../../../data/LogType";
import { noop } from "../../../utils";
import { automodAction } from "../helpers";
export const CleanAction = automodAction({
configType: t.boolean,
defaultConfig: false,
configSchema: z.boolean().default(false),
async apply({ pluginData, contexts, ruleName }) {
const messageIdsToDeleteByChannelId: Map<string, string[]> = new Map();

9
backend/src/plugins/Automod/actions/exampleAction.ts
View file

@ -1,13 +1,12 @@
import * as t from "io-ts";
import z from "zod";
import { zBoundedCharacters } from "../../../utils";
import { automodAction } from "../helpers";
export const ExampleAction = automodAction({
configType: t.type({
someValue: t.string,
configSchema: z.strictObject({
someValue: zBoundedCharacters(0, 1000),
}),
defaultConfig: {},
// eslint-disable-next-line @typescript-eslint/no-unused-vars
async apply({ pluginData, contexts, actionConfig }) {
// TODO: Everything

22
backend/src/plugins/Automod/actions/kick.ts
View file

@ -1,24 +1,20 @@
import * as t from "io-ts";
import { asyncMap, nonNullish, resolveMember, tNullable, unique } from "../../../utils";
import z from "zod";
import { asyncMap, nonNullish, resolveMember, unique, zBoundedCharacters, zSnowflake } from "../../../utils";
import { CaseArgs } from "../../Cases/types";
import { ModActionsPlugin } from "../../ModActions/ModActionsPlugin";
import { resolveActionContactMethods } from "../functions/resolveActionContactMethods";
import { automodAction } from "../helpers";
import { zNotify } from "../types";
export const KickAction = automodAction({
configType: t.type({
reason: tNullable(t.string),
notify: tNullable(t.string),
notifyChannel: tNullable(t.string),
postInCaseLog: tNullable(t.boolean),
hide_case: tNullable(t.boolean),
configSchema: z.strictObject({
reason: zBoundedCharacters(0, 4000).nullable().default(null),
notify: zNotify.nullable().default(null),
notifyChannel: zSnowflake.nullable().default(null),
postInCaseLog: z.boolean().nullable().default(null),
hide_case: z.boolean().nullable().default(false),
}),
defaultConfig: {
notify: null, // Use defaults from ModActions
hide_case: false,
},
async apply({ pluginData, contexts, actionConfig, matchResult }) {
const reason = actionConfig.reason || "Kicked automatically";
const contactMethods = actionConfig.notify ? resolveActionContactMethods(pluginData, actionConfig) : undefined;

5
backend/src/plugins/Automod/actions/log.ts
View file

@ -1,11 +1,10 @@
import * as t from "io-ts";
import z from "zod";
import { isTruthy, unique } from "../../../utils";
import { LogsPlugin } from "../../Logs/LogsPlugin";
import { automodAction } from "../helpers";
export const LogAction = automodAction({
configType: t.boolean,
defaultConfig: true,
configSchema: z.boolean().default(true),
async apply({ pluginData, contexts, ruleName, matchResult }) {
const users = unique(contexts.map((c) => c.user)).filter(isTruthy);

28
backend/src/plugins/Automod/actions/mute.ts
View file

@ -1,29 +1,25 @@
import * as t from "io-ts";
import z from "zod";
import { ERRORS, RecoverablePluginError } from "../../../RecoverablePluginError";
import { convertDelayStringToMS, nonNullish, tDelayString, tNullable, unique } from "../../../utils";
import { convertDelayStringToMS, nonNullish, unique, zBoundedCharacters, zDelayString, zSnowflake } from "../../../utils";
import { CaseArgs } from "../../Cases/types";
import { LogsPlugin } from "../../Logs/LogsPlugin";
import { MutesPlugin } from "../../Mutes/MutesPlugin";
import { resolveActionContactMethods } from "../functions/resolveActionContactMethods";
import { automodAction } from "../helpers";
import { zNotify } from "../types";
export const MuteAction = automodAction({
configType: t.type({
reason: tNullable(t.string),
duration: tNullable(tDelayString),
notify: tNullable(t.string),
notifyChannel: tNullable(t.string),
remove_roles_on_mute: tNullable(t.union([t.boolean, t.array(t.string)])),
restore_roles_on_mute: tNullable(t.union([t.boolean, t.array(t.string)])),
postInCaseLog: tNullable(t.boolean),
hide_case: tNullable(t.boolean),
configSchema: z.strictObject({
reason: zBoundedCharacters(0, 4000).nullable().default(null),
duration: zDelayString.nullable().default(null),
notify: zNotify.nullable().default(null),
notifyChannel: zSnowflake.nullable().default(null),
remove_roles_on_mute: z.union([z.boolean(), z.array(zSnowflake)]).nullable().default(null),
restore_roles_on_mute: z.union([z.boolean(), z.array(zSnowflake)]).nullable().default(null),
postInCaseLog: z.boolean().nullable().default(null),
hide_case: z.boolean().nullable().default(false),
}),
defaultConfig: {
notify: null, // Use defaults from ModActions
hide_case: false,
},
async apply({ pluginData, contexts, actionConfig, ruleName, matchResult }) {
const duration = actionConfig.duration ? convertDelayStringToMS(actionConfig.duration)! : undefined;
const reason = actionConfig.reason || "Muted automatically";

8
backend/src/plugins/Automod/actions/removeRoles.ts
View file

@ -1,6 +1,6 @@
import { PermissionFlagsBits, Snowflake } from "discord.js";
import * as t from "io-ts";
import { nonNullish, unique } from "../../../utils";
import z from "zod";
import { nonNullish, unique, zSnowflake } from "../../../utils";
import { canAssignRole } from "../../../utils/canAssignRole";
import { getMissingPermissions } from "../../../utils/getMissingPermissions";
import { memberRolesLock } from "../../../utils/lockNameHelpers";
@ -12,9 +12,7 @@ import { automodAction } from "../helpers";
const p = PermissionFlagsBits;
export const RemoveRolesAction = automodAction({
configType: t.array(t.string),
defaultConfig: [],
configSchema: z.array(zSnowflake).default([]),
async apply({ pluginData, contexts, actionConfig, ruleName }) {
const members = unique(contexts.map((c) => c.member).filter(nonNullish));

22
backend/src/plugins/Automod/actions/reply.ts
View file

@ -1,16 +1,16 @@
import { GuildTextBasedChannel, MessageCreateOptions, PermissionsBitField, Snowflake, User } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { TemplateSafeValueContainer, renderTemplate } from "../../../templateFormatter";
import {
convertDelayStringToMS,
noop,
renderRecursively,
tDelayString,
tMessageContent,
tNullable,
unique,
validateAndParseMessageContent,
verboseChannelMention,
zBoundedCharacters,
zDelayString,
zMessageContent
} from "../../../utils";
import { hasDiscordPermissions } from "../../../utils/hasDiscordPermissions";
import { messageIsEmpty } from "../../../utils/messageIsEmpty";
@ -20,17 +20,15 @@ import { automodAction } from "../helpers";
import { AutomodContext } from "../types";
export const ReplyAction = automodAction({
configType: t.union([
t.string,
t.type({
text: tMessageContent,
auto_delete: tNullable(t.union([tDelayString, t.number])),
inline: tNullable(t.boolean),
configSchema: z.union([
zBoundedCharacters(0, 4000),
z.strictObject({
text: zMessageContent,
auto_delete: z.union([zDelayString, z.number()]).nullable().default(null),
inline: z.boolean().default(false),
}),
]),
defaultConfig: {},
async apply({ pluginData, contexts, actionConfig, ruleName }) {
const contextsWithTextChannels = contexts
.filter((c) => c.message?.channel_id)

6
backend/src/plugins/Automod/actions/setAntiraidLevel.ts
View file

@ -1,11 +1,9 @@
import * as t from "io-ts";
import { tNullable } from "../../../utils";
import { zBoundedCharacters } from "../../../utils";
import { setAntiraidLevel } from "../functions/setAntiraidLevel";
import { automodAction } from "../helpers";
export const SetAntiraidLevelAction = automodAction({
configType: tNullable(t.string),
defaultConfig: "",
configSchema: zBoundedCharacters(0, 100).nullable(),
async apply({ pluginData, actionConfig }) {
setAntiraidLevel(pluginData, actionConfig ?? null);

11
backend/src/plugins/Automod/actions/setCounter.ts
View file

@ -1,16 +1,15 @@
import * as t from "io-ts";
import z from "zod";
import { zBoundedCharacters } from "../../../utils";
import { CountersPlugin } from "../../Counters/CountersPlugin";
import { LogsPlugin } from "../../Logs/LogsPlugin";
import { automodAction } from "../helpers";
export const SetCounterAction = automodAction({
configType: t.type({
counter: t.string,
value: t.number,
configSchema: z.strictObject({
counter: zBoundedCharacters(0, 100),
value: z.number(),
}),
defaultConfig: {},
async apply({ pluginData, contexts, actionConfig, ruleName }) {
const countersPlugin = pluginData.getPlugin(CountersPlugin);
if (!countersPlugin.counterExists(actionConfig.counter)) {

14
backend/src/plugins/Automod/actions/setSlowmode.ts
View file

@ -1,19 +1,15 @@
import { ChannelType, GuildTextBasedChannel, Snowflake } from "discord.js";
import * as t from "io-ts";
import { convertDelayStringToMS, isDiscordAPIError, tDelayString, tNullable } from "../../../utils";
import z from "zod";
import { convertDelayStringToMS, isDiscordAPIError, zDelayString, zSnowflake } from "../../../utils";
import { LogsPlugin } from "../../Logs/LogsPlugin";
import { automodAction } from "../helpers";
export const SetSlowmodeAction = automodAction({
configType: t.type({
channels: t.array(t.string),
duration: tNullable(tDelayString),
configSchema: z.strictObject({
channels: z.array(zSnowflake),
duration: zDelayString.nullable().default("10s"),
}),
defaultConfig: {
duration: "10s",
},
async apply({ pluginData, actionConfig }) {
const slowmodeMs = Math.max(actionConfig.duration ? convertDelayStringToMS(actionConfig.duration)! : 0, 0);

20
backend/src/plugins/Automod/actions/startThread.ts
View file

@ -5,9 +5,9 @@ import {
ThreadAutoArchiveDuration,
ThreadChannel,
} from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { TemplateSafeValueContainer, renderTemplate } from "../../../templateFormatter";
import { MINUTES, convertDelayStringToMS, noop, tDelayString, tNullable } from "../../../utils";
import { MINUTES, convertDelayStringToMS, noop, zBoundedCharacters, zDelayString } from "../../../utils";
import { savedMessageToTemplateSafeSavedMessage, userToTemplateSafeUser } from "../../../utils/templateSafeObjects";
import { automodAction } from "../helpers";
@ -19,18 +19,14 @@ const validThreadAutoArchiveDurations: ThreadAutoArchiveDuration[] = [
];
export const StartThreadAction = automodAction({
configType: t.type({
name: tNullable(t.string),
auto_archive: tDelayString,
private: tNullable(t.boolean),
slowmode: tNullable(tDelayString),
limit_per_channel: tNullable(t.number),
configSchema: z.strictObject({
name: zBoundedCharacters(1, 100).nullable(),
auto_archive: zDelayString,
private: z.boolean().default(false),
slowmode: zDelayString.nullable().default(null),
limit_per_channel: z.number().nullable().default(5),
}),
defaultConfig: {
limit_per_channel: 5,
},
async apply({ pluginData, contexts, actionConfig }) {
// check if the message still exists, we don't want to create threads for deleted messages
const threads = contexts.filter((c) => {

22
backend/src/plugins/Automod/actions/warn.ts
View file

@ -1,24 +1,20 @@
import * as t from "io-ts";
import { asyncMap, nonNullish, resolveMember, tNullable, unique } from "../../../utils";
import z from "zod";
import { asyncMap, nonNullish, resolveMember, unique, zBoundedCharacters, zSnowflake } from "../../../utils";
import { CaseArgs } from "../../Cases/types";
import { ModActionsPlugin } from "../../ModActions/ModActionsPlugin";
import { resolveActionContactMethods } from "../functions/resolveActionContactMethods";
import { automodAction } from "../helpers";
import { zNotify } from "../types";
export const WarnAction = automodAction({
configType: t.type({
reason: tNullable(t.string),
notify: tNullable(t.string),
notifyChannel: tNullable(t.string),
postInCaseLog: tNullable(t.boolean),
hide_case: tNullable(t.boolean),
configSchema: z.strictObject({
reason: zBoundedCharacters(0, 4000).nullable().default(null),
notify: zNotify.nullable().default(null),
notifyChannel: zSnowflake.nullable().default(null),
postInCaseLog: z.boolean().nullable().default(null),
hide_case: z.boolean().nullable().default(false),
}),
defaultConfig: {
notify: null, // Use defaults from ModActions
hide_case: false,
},
async apply({ pluginData, contexts, actionConfig, matchResult }) {
const reason = actionConfig.reason || "Warned automatically";
const contactMethods = actionConfig.notify ? resolveActionContactMethods(pluginData, actionConfig) : undefined;

19
backend/src/plugins/Automod/functions/createMessageSpamTrigger.ts
View file

@ -1,28 +1,27 @@
import * as t from "io-ts";
import { SavedMessage } from "../../../data/entities/SavedMessage";
import { humanizeDurationShort } from "../../../humanizeDurationShort";
import { getBaseUrl } from "../../../pluginUtils";
import { convertDelayStringToMS, sorter, tDelayString, tNullable } from "../../../utils";
import { convertDelayStringToMS, sorter, zDelayString } from "../../../utils";
import { RecentActionType } from "../constants";
import { automodTrigger } from "../helpers";
import { findRecentSpam } from "./findRecentSpam";
import { getMatchingMessageRecentActions } from "./getMatchingMessageRecentActions";
import { getMessageSpamIdentifier } from "./getSpamIdentifier";
const MessageSpamTriggerConfig = t.type({
amount: t.number,
within: tDelayString,
per_channel: tNullable(t.boolean),
});
import z from "zod";
interface TMessageSpamMatchResultType {
archiveId: string;
}
const configSchema = z.strictObject({
amount: z.number().int(),
within: zDelayString,
per_channel: z.boolean().optional(),
});
export function createMessageSpamTrigger(spamType: RecentActionType, prettyName: string) {
return automodTrigger<TMessageSpamMatchResultType>()({
configType: MessageSpamTriggerConfig,
defaultConfig: {},
configSchema,
async match({ pluginData, context, triggerConfig }) {
if (!context.message) {

38
backend/src/plugins/Automod/helpers.ts
View file

@ -1,7 +1,7 @@
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import { Awaitable } from "../../utils/typeUtils";
import { AutomodContext, AutomodPluginType } from "./types";
import z, { ZodTypeAny } from "zod";
interface BaseAutomodTriggerMatchResult {
extraContexts?: AutomodContext[];
@ -31,21 +31,19 @@ type AutomodTriggerRenderMatchInformationFn<TConfigType, TMatchResultExtra> = (m
matchResult: AutomodTriggerMatchResult<TMatchResultExtra>;
}) => Awaitable<string>;
export interface AutomodTriggerBlueprint<TConfigType extends t.Any, TMatchResultExtra> {
configType: TConfigType;
defaultConfig: Partial<t.TypeOf<TConfigType>>;
match: AutomodTriggerMatchFn<t.TypeOf<TConfigType>, TMatchResultExtra>;
renderMatchInformation: AutomodTriggerRenderMatchInformationFn<t.TypeOf<TConfigType>, TMatchResultExtra>;
export interface AutomodTriggerBlueprint<TConfigSchema extends ZodTypeAny, TMatchResultExtra> {
configSchema: TConfigSchema;
match: AutomodTriggerMatchFn<z.output<TConfigSchema>, TMatchResultExtra>;
renderMatchInformation: AutomodTriggerRenderMatchInformationFn<z.output<TConfigSchema>, TMatchResultExtra>;
}
export function automodTrigger<TMatchResultExtra>(): <TConfigType extends t.Any>(
blueprint: AutomodTriggerBlueprint<TConfigType, TMatchResultExtra>,
) => AutomodTriggerBlueprint<TConfigType, TMatchResultExtra>;
export function automodTrigger<TMatchResultExtra>(): <TConfigSchema extends ZodTypeAny>(
blueprint: AutomodTriggerBlueprint<TConfigSchema, TMatchResultExtra>,
) => AutomodTriggerBlueprint<TConfigSchema, TMatchResultExtra>;
export function automodTrigger<TConfigType extends t.Any>(
blueprint: AutomodTriggerBlueprint<TConfigType, unknown>,
): AutomodTriggerBlueprint<TConfigType, unknown>;
export function automodTrigger<TConfigSchema extends ZodTypeAny>(
blueprint: AutomodTriggerBlueprint<TConfigSchema, unknown>,
): AutomodTriggerBlueprint<TConfigSchema, unknown>;
export function automodTrigger(...args) {
if (args.length) {
@ -63,15 +61,13 @@ type AutomodActionApplyFn<TConfigType> = (meta: {
matchResult: AutomodTriggerMatchResult;
}) => Awaitable<void>;
export interface AutomodActionBlueprint<TConfigType extends t.Any> {
configType: TConfigType;
defaultConfig: Partial<t.TypeOf<TConfigType>>;
apply: AutomodActionApplyFn<t.TypeOf<TConfigType>>;
export interface AutomodActionBlueprint<TConfigSchema extends ZodTypeAny> {
configSchema: TConfigSchema;
apply: AutomodActionApplyFn<z.output<TConfigSchema>>;
}
export function automodAction<TConfigType extends t.Any>(
blueprint: AutomodActionBlueprint<TConfigType>,
): AutomodActionBlueprint<TConfigType> {
export function automodAction<TConfigSchema extends ZodTypeAny>(
blueprint: AutomodActionBlueprint<TConfigSchema>,
): AutomodActionBlueprint<TConfigSchema> {
return blueprint;
}

4
backend/src/plugins/Automod/info.ts
View file

@ -1,6 +1,6 @@
import { trimPluginDescription } from "../../utils";
import { ZeppelinGuildPluginBlueprint } from "../ZeppelinPluginBlueprint";
import { ConfigSchema } from "./types";
import { zAutomodConfig } from "./types";
export const pluginInfo: ZeppelinGuildPluginBlueprint["info"] = {
prettyName: "Automod",
@ -100,5 +100,5 @@ export const pluginInfo: ZeppelinGuildPluginBlueprint["info"] = {
{matchSummary}
~~~
`),
configSchema: ConfigSchema,
configSchema: zAutomodConfig,
};

13
backend/src/plugins/Automod/triggers/antiraidLevel.ts
View file

@ -1,15 +1,14 @@
import * as t from "io-ts";
import { tNullable } from "../../../utils";
import { automodTrigger } from "../helpers";
import z from "zod";
interface AntiraidLevelTriggerResult {}
export const AntiraidLevelTrigger = automodTrigger<AntiraidLevelTriggerResult>()({
configType: t.type({
level: tNullable(t.string),
}),
const configSchema = z.strictObject({
level: z.nullable(z.string().max(100)),
});
defaultConfig: {},
export const AntiraidLevelTrigger = automodTrigger<AntiraidLevelTriggerResult>()({
configSchema,
async match({ triggerConfig, context }) {
if (!context.antiraid) {

8
backend/src/plugins/Automod/triggers/anyMessage.ts
View file

@ -1,14 +1,14 @@
import { Snowflake } from "discord.js";
import * as t from "io-ts";
import { verboseChannelMention } from "../../../utils";
import { automodTrigger } from "../helpers";
import z from "zod";
interface AnyMessageResultType {}
export const AnyMessageTrigger = automodTrigger<AnyMessageResultType>()({
configType: t.type({}),
const configSchema = z.strictObject({});
defaultConfig: {},
export const AnyMessageTrigger = automodTrigger<AnyMessageResultType>()({
configSchema,
async match({ context }) {
if (!context.message) {

45
backend/src/plugins/Automod/triggers/availableTriggers.ts
View file

@ -1,4 +1,3 @@
import * as t from "io-ts";
import { AutomodTriggerBlueprint } from "../helpers";
import { AntiraidLevelTrigger } from "./antiraidLevel";
import { AnyMessageTrigger } from "./anyMessage";
@ -45,6 +44,7 @@ export const availableTriggers: Record<string, AutomodTriggerBlueprint<any, any>
match_attachment_type: MatchAttachmentTypeTrigger,
match_mime_type: MatchMimeTypeTrigger,
member_join: MemberJoinTrigger,
member_leave: MemberLeaveTrigger,
role_added: RoleAddedTrigger,
role_removed: RoleRemovedTrigger,
@ -76,46 +76,3 @@ export const availableTriggers: Record<string, AutomodTriggerBlueprint<any, any>
thread_archive: ThreadArchiveTrigger,
thread_unarchive: ThreadUnarchiveTrigger,
};
export const AvailableTriggers = t.type({
any_message: AnyMessageTrigger.configType,
match_words: MatchWordsTrigger.configType,
match_regex: MatchRegexTrigger.configType,
match_invites: MatchInvitesTrigger.configType,
match_links: MatchLinksTrigger.configType,
match_attachment_type: MatchAttachmentTypeTrigger.configType,
match_mime_type: MatchMimeTypeTrigger.configType,
member_join: MemberJoinTrigger.configType,
member_leave: MemberLeaveTrigger.configType,
role_added: RoleAddedTrigger.configType,
role_removed: RoleRemovedTrigger.configType,
message_spam: MessageSpamTrigger.configType,
mention_spam: MentionSpamTrigger.configType,
link_spam: LinkSpamTrigger.configType,
attachment_spam: AttachmentSpamTrigger.configType,
emoji_spam: EmojiSpamTrigger.configType,
line_spam: LineSpamTrigger.configType,
character_spam: CharacterSpamTrigger.configType,
member_join_spam: MemberJoinSpamTrigger.configType,
sticker_spam: StickerSpamTrigger.configType,
thread_create_spam: ThreadCreateSpamTrigger.configType,
counter_trigger: CounterTrigger.configType,
note: NoteTrigger.configType,
warn: WarnTrigger.configType,
mute: MuteTrigger.configType,
unmute: UnmuteTrigger.configType,
kick: KickTrigger.configType,
ban: BanTrigger.configType,
unban: UnbanTrigger.configType,
antiraid_level: AntiraidLevelTrigger.configType,
thread_create: ThreadCreateTrigger.configType,
thread_delete: ThreadDeleteTrigger.configType,
thread_archive: ThreadArchiveTrigger.configType,
thread_unarchive: ThreadUnarchiveTrigger.configType,
});

17
backend/src/plugins/Automod/triggers/ban.ts
View file

@ -1,19 +1,16 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line:no-empty-interface
interface BanTriggerResultType {}
export const BanTrigger = automodTrigger<BanTriggerResultType>()({
configType: t.type({
manual: t.boolean,
automatic: t.boolean,
}),
const configSchema = z.strictObject({
manual: z.boolean().default(true),
automatic: z.boolean().default(true),
});
defaultConfig: {
manual: true,
automatic: true,
},
export const BanTrigger = automodTrigger<BanTriggerResultType>()({
configSchema,
async match({ context, triggerConfig }) {
if (context.modAction?.type !== "ban") {

17
backend/src/plugins/Automod/triggers/counterTrigger.ts
View file

@ -1,18 +1,17 @@
import * as t from "io-ts";
import { tNullable } from "../../../utils";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line
interface CounterTriggerResult {}
export const CounterTrigger = automodTrigger<CounterTriggerResult>()({
configType: t.type({
counter: t.string,
trigger: t.string,
reverse: tNullable(t.boolean),
}),
const configSchema = z.strictObject({
counter: z.string().max(100),
trigger: z.string().max(100),
reverse: z.boolean().optional(),
});
defaultConfig: {},
export const CounterTrigger = automodTrigger<CounterTriggerResult>()({
configSchema,
async match({ triggerConfig, context }) {
if (!context.counterTrigger) {

14
backend/src/plugins/Automod/triggers/exampleTrigger.ts
View file

@ -1,18 +1,16 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
interface ExampleMatchResultType {
isBanana: boolean;
}
export const ExampleTrigger = automodTrigger<ExampleMatchResultType>()({
configType: t.type({
allowedFruits: t.array(t.string),
}),
const configSchema = z.strictObject({
allowedFruits: z.array(z.string().max(100)).max(50).default(["peach", "banana"]),
});
defaultConfig: {
allowedFruits: ["peach", "banana"],
},
export const ExampleTrigger = automodTrigger<ExampleMatchResultType>()({
configSchema,
async match({ triggerConfig, context }) {
const foundFruit = triggerConfig.allowedFruits.find((fruit) => context.message?.data.content === fruit);

17
backend/src/plugins/Automod/triggers/kick.ts
View file

@ -1,19 +1,16 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line:no-empty-interface
interface KickTriggerResultType {}
export const KickTrigger = automodTrigger<KickTriggerResultType>()({
configType: t.type({
manual: t.boolean,
automatic: t.boolean,
}),
const configSchema = z.strictObject({
manual: z.boolean().default(true),
automatic: z.boolean().default(true),
});
defaultConfig: {
manual: true,
automatic: true,
},
export const KickTrigger = automodTrigger<KickTriggerResultType>()({
configSchema,
async match({ context, triggerConfig }) {
if (context.modAction?.type !== "kick") {

39
backend/src/plugins/Automod/triggers/matchAttachmentType.ts
View file

@ -1,5 +1,5 @@
import { escapeInlineCode, Snowflake } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { asSingleLine, messageSummary, verboseChannelMention } from "../../../utils";
import { automodTrigger } from "../helpers";
@ -8,20 +8,31 @@ interface MatchResultType {
mode: "blacklist" | "whitelist";
}
export const MatchAttachmentTypeTrigger = automodTrigger<MatchResultType>()({
configType: t.type({
filetype_blacklist: t.array(t.string),
blacklist_enabled: t.boolean,
filetype_whitelist: t.array(t.string),
whitelist_enabled: t.boolean,
}),
const configSchema = z.strictObject({
filetype_blacklist: z.array(z.string().max(32)).max(255).default([]),
blacklist_enabled: z.boolean().default(false),
filetype_whitelist: z.array(z.string().max(32)).max(255).default([]),
whitelist_enabled: z.boolean().default(false),
}).transform((parsed, ctx) => {
if (parsed.blacklist_enabled && parsed.whitelist_enabled) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Cannot have both blacklist and whitelist enabled",
});
return z.NEVER;
}
if (! parsed.blacklist_enabled && ! parsed.whitelist_enabled) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Must have either blacklist or whitelist enabled",
});
return z.NEVER;
}
return parsed;
});
defaultConfig: {
filetype_blacklist: [],
blacklist_enabled: false,
filetype_whitelist: [],
whitelist_enabled: false,
},
export const MatchAttachmentTypeTrigger = automodTrigger<MatchResultType>()({
configSchema,
async match({ context, triggerConfig: trigger }) {
if (!context.message) {

42
backend/src/plugins/Automod/triggers/matchInvites.ts
View file

@ -1,5 +1,5 @@
import * as t from "io-ts";
import { getInviteCodesInString, GuildInvite, isGuildInvite, resolveInvite, tNullable } from "../../../utils";
import z from "zod";
import { getInviteCodesInString, GuildInvite, isGuildInvite, resolveInvite, zSnowflake } from "../../../utils";
import { getTextMatchPartialSummary } from "../functions/getTextMatchPartialSummary";
import { MatchableTextType, matchMultipleTextTypesOnMessage } from "../functions/matchMultipleTextTypesOnMessage";
import { automodTrigger } from "../helpers";
@ -10,30 +10,22 @@ interface MatchResultType {
invite?: GuildInvite;
}
export const MatchInvitesTrigger = automodTrigger<MatchResultType>()({
configType: t.type({
include_guilds: tNullable(t.array(t.string)),
exclude_guilds: tNullable(t.array(t.string)),
include_invite_codes: tNullable(t.array(t.string)),
exclude_invite_codes: tNullable(t.array(t.string)),
allow_group_dm_invites: t.boolean,
match_messages: t.boolean,
match_embeds: t.boolean,
match_visible_names: t.boolean,
match_usernames: t.boolean,
match_nicknames: t.boolean,
match_custom_status: t.boolean,
}),
const configSchema = z.strictObject({
include_guilds: z.array(zSnowflake).max(255).optional(),
exclude_guilds: z.array(zSnowflake).max(255).optional(),
include_invite_codes: z.array(z.string().max(32)).max(255).optional(),
exclude_invite_codes: z.array(z.string().max(32)).max(255).optional(),
allow_group_dm_invites: z.boolean().default(false),
match_messages: z.boolean().default(true),
match_embeds: z.boolean().default(false),
match_visible_names: z.boolean().default(false),
match_usernames: z.boolean().default(false),
match_nicknames: z.boolean().default(false),
match_custom_status: z.boolean().default(false),
});
defaultConfig: {
allow_group_dm_invites: false,
match_messages: true,
match_embeds: false,
match_visible_names: false,
match_usernames: false,
match_nicknames: false,
match_custom_status: false,
},
export const MatchInvitesTrigger = automodTrigger<MatchResultType>()({
configSchema,
async match({ pluginData, context, triggerConfig: trigger }) {
if (!context.message) {

60
backend/src/plugins/Automod/triggers/matchLinks.ts
View file

@ -1,11 +1,10 @@
import { escapeInlineCode } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { allowTimeout } from "../../../RegExpRunner";
import { phishermanDomainIsSafe } from "../../../data/Phisherman";
import { getUrlsInString, tNullable } from "../../../utils";
import { getUrlsInString, zRegex } from "../../../utils";
import { mergeRegexes } from "../../../utils/mergeRegexes";
import { mergeWordsIntoRegex } from "../../../utils/mergeWordsIntoRegex";
import { TRegex } from "../../../validatorUtils";
import { PhishermanPlugin } from "../../Phisherman/PhishermanPlugin";
import { getTextMatchPartialSummary } from "../functions/getTextMatchPartialSummary";
import { MatchableTextType, matchMultipleTextTypesOnMessage } from "../functions/matchMultipleTextTypesOnMessage";
@ -21,40 +20,29 @@ const regexCache = new WeakMap<any, RegExp[]>();
const quickLinkCheck = /^https?:\/\//i;
export const MatchLinksTrigger = automodTrigger<MatchResultType>()({
configType: t.type({
include_domains: tNullable(t.array(t.string)),
exclude_domains: tNullable(t.array(t.string)),
include_subdomains: t.boolean,
include_words: tNullable(t.array(t.string)),
exclude_words: tNullable(t.array(t.string)),
include_regex: tNullable(t.array(TRegex)),
exclude_regex: tNullable(t.array(TRegex)),
phisherman: tNullable(
t.type({
include_suspected: tNullable(t.boolean),
include_verified: tNullable(t.boolean),
}),
),
only_real_links: t.boolean,
match_messages: t.boolean,
match_embeds: t.boolean,
match_visible_names: t.boolean,
match_usernames: t.boolean,
match_nicknames: t.boolean,
match_custom_status: t.boolean,
}),
const configSchema = z.strictObject({
include_domains: z.array(z.string().max(255)).max(255).optional(),
exclude_domains: z.array(z.string().max(255)).max(255).optional(),
include_subdomains: z.boolean().default(true),
include_words: z.array(z.string().max(2000)).max(512).optional(),
exclude_words: z.array(z.string().max(2000)).max(512).optional(),
include_regex: z.array(zRegex(z.string().max(2000))).max(512).optional(),
exclude_regex: z.array(zRegex(z.string().max(2000))).max(512).optional(),
phisherman: z.strictObject({
include_suspected: z.boolean().optional(),
include_verified: z.boolean().optional(),
}).optional(),
only_real_links: z.boolean(),
match_messages: z.boolean().default(true),
match_embeds: z.boolean().default(true),
match_visible_names: z.boolean().default(false),
match_usernames: z.boolean().default(false),
match_nicknames: z.boolean().default(false),
match_custom_status: z.boolean().default(false),
});
defaultConfig: {
include_subdomains: true,
match_messages: true,
match_embeds: false,
match_visible_names: false,
match_usernames: false,
match_nicknames: false,
match_custom_status: false,
only_real_links: true,
},
export const MatchLinksTrigger = automodTrigger<MatchResultType>()({
configSchema,
async match({ pluginData, context, triggerConfig: trigger }) {
if (!context.message) {

39
backend/src/plugins/Automod/triggers/matchMimeType.ts
View file

@ -1,5 +1,5 @@
import { escapeInlineCode } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { asSingleLine, messageSummary, verboseChannelMention } from "../../../utils";
import { automodTrigger } from "../helpers";
@ -8,20 +8,31 @@ interface MatchResultType {
mode: "blacklist" | "whitelist";
}
export const MatchMimeTypeTrigger = automodTrigger<MatchResultType>()({
configType: t.type({
mime_type_blacklist: t.array(t.string),
blacklist_enabled: t.boolean,
mime_type_whitelist: t.array(t.string),
whitelist_enabled: t.boolean,
}),
const configSchema = z.strictObject({
mime_type_blacklist: z.array(z.string().max(255)).max(255).default([]),
blacklist_enabled: z.boolean().default(false),
mime_type_whitelist: z.array(z.string().max(255)).max(255).default([]),
whitelist_enabled: z.boolean().default(false),
}).transform((parsed, ctx) => {
if (parsed.blacklist_enabled && parsed.whitelist_enabled) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Cannot have both blacklist and whitelist enabled",
});
return z.NEVER;
}
if (! parsed.blacklist_enabled && ! parsed.whitelist_enabled) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Must have either blacklist or whitelist enabled",
});
return z.NEVER;
}
return parsed;
});
defaultConfig: {
mime_type_blacklist: [],
blacklist_enabled: false,
mime_type_whitelist: [],
whitelist_enabled: false,
},
export const MatchMimeTypeTrigger = automodTrigger<MatchResultType>()({
configSchema,
async match({ context, triggerConfig: trigger }) {
if (!context.message) return;

42
backend/src/plugins/Automod/triggers/matchRegex.ts
View file

@ -1,9 +1,9 @@
import * as t from "io-ts";
import z from "zod";
import { allowTimeout } from "../../../RegExpRunner";
import { zRegex } from "../../../utils";
import { mergeRegexes } from "../../../utils/mergeRegexes";
import { normalizeText } from "../../../utils/normalizeText";
import { stripMarkdown } from "../../../utils/stripMarkdown";
import { TRegex } from "../../../validatorUtils";
import { getTextMatchPartialSummary } from "../functions/getTextMatchPartialSummary";
import { MatchableTextType, matchMultipleTextTypesOnMessage } from "../functions/matchMultipleTextTypesOnMessage";
import { automodTrigger } from "../helpers";
@ -13,33 +13,23 @@ interface MatchResultType {
type: MatchableTextType;
}
const configSchema = z.strictObject({
patterns: z.array(zRegex(z.string().max(2000))).max(512),
case_sensitive: z.boolean().default(false),
normalize: z.boolean().default(false),
strip_markdown: z.boolean().default(false),
match_messages: z.boolean().default(true),
match_embeds: z.boolean().default(false),
match_visible_names: z.boolean().default(false),
match_usernames: z.boolean().default(false),
match_nicknames: z.boolean().default(false),
match_custom_status: z.boolean().default(false),
});
const regexCache = new WeakMap<any, RegExp[]>();
export const MatchRegexTrigger = automodTrigger<MatchResultType>()({
configType: t.type({
patterns: t.array(TRegex),
case_sensitive: t.boolean,
normalize: t.boolean,
strip_markdown: t.boolean,
match_messages: t.boolean,
match_embeds: t.boolean,
match_visible_names: t.boolean,
match_usernames: t.boolean,
match_nicknames: t.boolean,
match_custom_status: t.boolean,
}),
defaultConfig: {
case_sensitive: false,
normalize: false,
strip_markdown: false,
match_messages: true,
match_embeds: false,
match_visible_names: false,
match_usernames: false,
match_nicknames: false,
match_custom_status: false,
},
configSchema,
async match({ pluginData, context, triggerConfig: trigger }) {
if (!context.message) {

49
backend/src/plugins/Automod/triggers/matchWords.ts
View file

@ -1,5 +1,5 @@
import escapeStringRegexp from "escape-string-regexp";
import * as t from "io-ts";
import z from "zod";
import { normalizeText } from "../../../utils/normalizeText";
import { stripMarkdown } from "../../../utils/stripMarkdown";
import { getTextMatchPartialSummary } from "../functions/getTextMatchPartialSummary";
@ -13,37 +13,24 @@ interface MatchResultType {
const regexCache = new WeakMap<any, RegExp[]>();
export const MatchWordsTrigger = automodTrigger<MatchResultType>()({
configType: t.type({
words: t.array(t.string),
case_sensitive: t.boolean,
only_full_words: t.boolean,
normalize: t.boolean,
loose_matching: t.boolean,
loose_matching_threshold: t.number,
strip_markdown: t.boolean,
match_messages: t.boolean,
match_embeds: t.boolean,
match_visible_names: t.boolean,
match_usernames: t.boolean,
match_nicknames: t.boolean,
match_custom_status: t.boolean,
}),
const configSchema = z.strictObject({
words: z.array(z.string().max(2000)).max(512),
case_sensitive: z.boolean().default(false),
only_full_words: z.boolean().default(true),
normalize: z.boolean().default(false),
loose_matching: z.boolean().default(false),
loose_matching_threshold: z.number().int().default(4),
strip_markdown: z.boolean().default(false),
match_messages: z.boolean().default(true),
match_embeds: z.boolean().default(false),
match_visible_names: z.boolean().default(false),
match_usernames: z.boolean().default(false),
match_nicknames: z.boolean().default(false),
match_custom_status: z.boolean().default(false),
});
defaultConfig: {
case_sensitive: false,
only_full_words: true,
normalize: false,
loose_matching: false,
loose_matching_threshold: 4,
strip_markdown: false,
match_messages: true,
match_embeds: false,
match_visible_names: false,
match_usernames: false,
match_nicknames: false,
match_custom_status: false,
},
export const MatchWordsTrigger = automodTrigger<MatchResultType>()({
configSchema,
async match({ pluginData, context, triggerConfig: trigger }) {
if (!context.message) {

19
backend/src/plugins/Automod/triggers/memberJoin.ts
View file

@ -1,17 +1,14 @@
import * as t from "io-ts";
import { convertDelayStringToMS, tDelayString } from "../../../utils";
import z from "zod";
import { convertDelayStringToMS, zDelayString } from "../../../utils";
import { automodTrigger } from "../helpers";
export const MemberJoinTrigger = automodTrigger<unknown>()({
configType: t.type({
only_new: t.boolean,
new_threshold: tDelayString,
}),
const configSchema = z.strictObject({
only_new: z.boolean().default(false),
new_threshold: zDelayString.default("1h"),
});
defaultConfig: {
only_new: false,
new_threshold: "1h",
},
export const MemberJoinTrigger = automodTrigger<unknown>()({
configSchema,
async match({ context, triggerConfig }) {
if (!context.joined || !context.member) {

16
backend/src/plugins/Automod/triggers/memberJoinSpam.ts
View file

@ -1,18 +1,18 @@
import * as t from "io-ts";
import { convertDelayStringToMS, tDelayString } from "../../../utils";
import z from "zod";
import { convertDelayStringToMS, zDelayString } from "../../../utils";
import { RecentActionType } from "../constants";
import { findRecentSpam } from "../functions/findRecentSpam";
import { getMatchingRecentActions } from "../functions/getMatchingRecentActions";
import { sumRecentActionCounts } from "../functions/sumRecentActionCounts";
import { automodTrigger } from "../helpers";
export const MemberJoinSpamTrigger = automodTrigger<unknown>()({
configType: t.type({
amount: t.number,
within: tDelayString,
}),
const configSchema = z.strictObject({
amount: z.number().int(),
within: zDelayString,
});
defaultConfig: {},
export const MemberJoinSpamTrigger = automodTrigger<unknown>()({
configSchema,
async match({ pluginData, context, triggerConfig }) {
if (!context.joined || !context.member) {

8
backend/src/plugins/Automod/triggers/memberLeave.ts
View file

@ -1,10 +1,10 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
export const MemberLeaveTrigger = automodTrigger<unknown>()({
configType: t.type({}),
const configSchema = z.strictObject({});
defaultConfig: {},
export const MemberLeaveTrigger = automodTrigger<unknown>()({
configSchema,
async match({ context }) {
if (!context.joined || !context.member) {

17
backend/src/plugins/Automod/triggers/mute.ts
View file

@ -1,19 +1,16 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line:no-empty-interface
interface MuteTriggerResultType {}
export const MuteTrigger = automodTrigger<MuteTriggerResultType>()({
configType: t.type({
manual: t.boolean,
automatic: t.boolean,
}),
const configSchema = z.strictObject({
manual: z.boolean().default(true),
automatic: z.boolean().default(true),
});
defaultConfig: {
manual: true,
automatic: true,
},
export const MuteTrigger = automodTrigger<MuteTriggerResultType>()({
configSchema,
async match({ context, triggerConfig }) {
if (context.modAction?.type !== "mute") {

7
backend/src/plugins/Automod/triggers/note.ts
View file

@ -1,12 +1,13 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line:no-empty-interface
interface NoteTriggerResultType {}
const configSchema = z.strictObject({});
export const NoteTrigger = automodTrigger<NoteTriggerResultType>()({
configType: t.type({}),
defaultConfig: {},
configSchema,
async match({ context }) {
if (context.modAction?.type !== "note") {

13
backend/src/plugins/Automod/triggers/roleAdded.ts
View file

@ -1,6 +1,6 @@
import { Snowflake } from "discord.js";
import * as t from "io-ts";
import { renderUserUsername } from "../../../utils";
import z from "zod";
import { renderUserUsername, zSnowflake } from "../../../utils";
import { consumeIgnoredRoleChange } from "../functions/ignoredRoleChanges";
import { automodTrigger } from "../helpers";
@ -8,10 +8,13 @@ interface RoleAddedMatchResult {
matchedRoleId: string;
}
export const RoleAddedTrigger = automodTrigger<RoleAddedMatchResult>()({
configType: t.union([t.string, t.array(t.string)]),
const configSchema = z.union([
zSnowflake,
z.array(zSnowflake).max(255),
]).default([]);
defaultConfig: "",
export const RoleAddedTrigger = automodTrigger<RoleAddedMatchResult>()({
configSchema,
async match({ triggerConfig, context, pluginData }) {
if (!context.member || !context.rolesChanged || context.rolesChanged.added!.length === 0) {

13
backend/src/plugins/Automod/triggers/roleRemoved.ts
View file

@ -1,6 +1,6 @@
import { Snowflake } from "discord.js";
import * as t from "io-ts";
import { renderUserUsername } from "../../../utils";
import z from "zod";
import { renderUserUsername, zSnowflake } from "../../../utils";
import { consumeIgnoredRoleChange } from "../functions/ignoredRoleChanges";
import { automodTrigger } from "../helpers";
@ -8,10 +8,13 @@ interface RoleAddedMatchResult {
matchedRoleId: string;
}
export const RoleRemovedTrigger = automodTrigger<RoleAddedMatchResult>()({
configType: t.union([t.string, t.array(t.string)]),
const configSchema = z.union([
zSnowflake,
z.array(zSnowflake).max(255),
]).default([]);
defaultConfig: "",
export const RoleRemovedTrigger = automodTrigger<RoleAddedMatchResult>()({
configSchema,
async match({ triggerConfig, context, pluginData }) {
if (!context.member || !context.rolesChanged || context.rolesChanged.removed!.length === 0) {

13
backend/src/plugins/Automod/triggers/threadArchive.ts
View file

@ -1,6 +1,5 @@
import { User, escapeBold, type Snowflake } from "discord.js";
import * as t from "io-ts";
import { tNullable } from "../../../utils";
import z from "zod";
import { automodTrigger } from "../helpers";
interface ThreadArchiveResult {
@ -11,12 +10,12 @@ interface ThreadArchiveResult {
matchedThreadOwner: User | undefined;
}
export const ThreadArchiveTrigger = automodTrigger<ThreadArchiveResult>()({
configType: t.type({
locked: tNullable(t.boolean),
}),
const configSchema = z.strictObject({
locked: z.boolean().optional(),
});
defaultConfig: {},
export const ThreadArchiveTrigger = automodTrigger<ThreadArchiveResult>()({
configSchema,
async match({ context, triggerConfig }) {
if (!context.threadChange?.archived) {

7
backend/src/plugins/Automod/triggers/threadCreate.ts
View file

@ -1,5 +1,5 @@
import { User, escapeBold, type Snowflake } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
interface ThreadCreateResult {
@ -10,9 +10,10 @@ interface ThreadCreateResult {
matchedThreadOwner: User | undefined;
}
const configSchema = z.strictObject({});
export const ThreadCreateTrigger = automodTrigger<ThreadCreateResult>()({
configType: t.type({}),
defaultConfig: {},
configSchema,
async match({ context }) {
if (!context.threadChange?.created) {

16
backend/src/plugins/Automod/triggers/threadCreateSpam.ts
View file

@ -1,18 +1,18 @@
import * as t from "io-ts";
import { convertDelayStringToMS, tDelayString } from "../../../utils";
import z from "zod";
import { convertDelayStringToMS, zDelayString } from "../../../utils";
import { RecentActionType } from "../constants";
import { findRecentSpam } from "../functions/findRecentSpam";
import { getMatchingRecentActions } from "../functions/getMatchingRecentActions";
import { sumRecentActionCounts } from "../functions/sumRecentActionCounts";
import { automodTrigger } from "../helpers";
export const ThreadCreateSpamTrigger = automodTrigger<unknown>()({
configType: t.type({
amount: t.number,
within: tDelayString,
}),
const configSchema = z.strictObject({
amount: z.number().int(),
within: zDelayString,
});
defaultConfig: {},
export const ThreadCreateSpamTrigger = automodTrigger<unknown>()({
configSchema,
async match({ pluginData, context, triggerConfig }) {
if (!context.threadChange?.created) {

7
backend/src/plugins/Automod/triggers/threadDelete.ts
View file

@ -1,5 +1,5 @@
import { User, escapeBold, type Snowflake } from "discord.js";
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
interface ThreadDeleteResult {
@ -10,9 +10,10 @@ interface ThreadDeleteResult {
matchedThreadOwner: User | undefined;
}
const configSchema = z.strictObject({});
export const ThreadDeleteTrigger = automodTrigger<ThreadDeleteResult>()({
configType: t.type({}),
defaultConfig: {},
configSchema,
async match({ context }) {
if (!context.threadChange?.deleted) {

13
backend/src/plugins/Automod/triggers/threadUnarchive.ts
View file

@ -1,6 +1,5 @@
import { User, escapeBold, type Snowflake } from "discord.js";
import * as t from "io-ts";
import { tNullable } from "../../../utils";
import z from "zod";
import { automodTrigger } from "../helpers";
interface ThreadUnarchiveResult {
@ -11,12 +10,12 @@ interface ThreadUnarchiveResult {
matchedThreadOwner: User | undefined;
}
export const ThreadUnarchiveTrigger = automodTrigger<ThreadUnarchiveResult>()({
configType: t.type({
locked: tNullable(t.boolean),
}),
const configSchema = z.strictObject({
locked: z.boolean().optional(),
});
defaultConfig: {},
export const ThreadUnarchiveTrigger = automodTrigger<ThreadUnarchiveResult>()({
configSchema,
async match({ context, triggerConfig }) {
if (!context.threadChange?.unarchived) {

7
backend/src/plugins/Automod/triggers/unban.ts
View file

@ -1,12 +1,13 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line:no-empty-interface
interface UnbanTriggerResultType {}
const configSchema = z.strictObject({});
export const UnbanTrigger = automodTrigger<UnbanTriggerResultType>()({
configType: t.type({}),
defaultConfig: {},
configSchema,
async match({ context }) {
if (context.modAction?.type !== "unban") {

7
backend/src/plugins/Automod/triggers/unmute.ts
View file

@ -1,12 +1,13 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line:no-empty-interface
interface UnmuteTriggerResultType {}
const configSchema = z.strictObject({});
export const UnmuteTrigger = automodTrigger<UnmuteTriggerResultType>()({
configType: t.type({}),
defaultConfig: {},
configSchema,
async match({ context }) {
if (context.modAction?.type !== "unmute") {

17
backend/src/plugins/Automod/triggers/warn.ts
View file

@ -1,19 +1,16 @@
import * as t from "io-ts";
import z from "zod";
import { automodTrigger } from "../helpers";
// tslint:disable-next-line:no-empty-interface
interface WarnTriggerResultType {}
export const WarnTrigger = automodTrigger<WarnTriggerResultType>()({
configType: t.type({
manual: t.boolean,
automatic: t.boolean,
}),
const configSchema = z.strictObject({
manual: z.boolean().default(true),
automatic: z.boolean().default(true),
});
defaultConfig: {
manual: true,
automatic: true,
},
export const WarnTrigger = automodTrigger<WarnTriggerResultType>()({
configSchema,
async match({ context, triggerConfig }) {
if (context.modAction?.type !== "warn") {

88
backend/src/plugins/Automod/types.ts
View file

@ -1,6 +1,6 @@
import { GuildMember, GuildTextBasedChannel, PartialGuildMember, ThreadChannel, User } from "discord.js";
import * as t from "io-ts";
import { BasePluginType, CooldownManager } from "knub";
import z from "zod";
import { Queue } from "../../Queue";
import { RegExpRunner } from "../../RegExpRunner";
import { GuildAntiraidLevels } from "../../data/GuildAntiraidLevels";
@ -8,39 +8,81 @@ import { GuildArchives } from "../../data/GuildArchives";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { SavedMessage } from "../../data/entities/SavedMessage";
import { tNullable } from "../../utils";
import { entries, zBoundedRecord, zDelayString } from "../../utils";
import { CounterEvents } from "../Counters/types";
import { ModActionType, ModActionsEvents } from "../ModActions/types";
import { MutesEvents } from "../Mutes/types";
import { AvailableActions } from "./actions/availableActions";
import { availableActions } from "./actions/availableActions";
import { RecentActionType } from "./constants";
import { AvailableTriggers } from "./triggers/availableTriggers";
import { availableTriggers } from "./triggers/availableTriggers";
import Timeout = NodeJS.Timeout;
export const Rule = t.type({
enabled: t.boolean,
name: t.string,
presets: tNullable(t.array(t.string)),
affects_bots: t.boolean,
affects_self: t.boolean,
triggers: t.array(t.partial(AvailableTriggers.props)),
actions: t.partial(AvailableActions.props),
cooldown: tNullable(t.string),
allow_further_rules: t.boolean,
});
export type TRule = t.TypeOf<typeof Rule>;
export type ZTriggersMapHelper = {
[TriggerName in keyof typeof availableTriggers]: typeof availableTriggers[TriggerName]["configSchema"];
};
const zTriggersMap = z.strictObject(entries(availableTriggers).reduce((map, [triggerName, trigger]) => {
map[triggerName] = trigger.configSchema;
return map;
}, {} as ZTriggersMapHelper)).partial();
export const ConfigSchema = t.type({
rules: t.record(t.string, Rule),
antiraid_levels: t.array(t.string),
can_set_antiraid: t.boolean,
can_view_antiraid: t.boolean,
type ZActionsMapHelper = {
[ActionName in keyof typeof availableActions]: typeof availableActions[ActionName]["configSchema"];
};
const zActionsMap = z.strictObject(entries(availableActions).reduce((map, [actionName, action]) => {
// @ts-expect-error TS can't infer this properly but it works fine thanks to our helper
map[actionName] = action.configSchema;
return map;
}, {} as ZActionsMapHelper)).partial();
const zRule = z.strictObject({
enabled: z.boolean().default(true),
// Typed as "never" because you are not expected to supply this directly.
// The transform instead picks it up from the property key and the output type is a string.
name: z.never().optional().transform((_, ctx) => {
const ruleName = String(ctx.path[ctx.path.length - 2]).trim();
if (! ruleName) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Automod rules must have names",
});
return z.NEVER;
}
return ruleName;
}),
presets: z.array(z.string().max(100)).max(25).default([]),
affects_bots: z.boolean().default(false),
affects_self: z.boolean().default(false),
cooldown: zDelayString.nullable().default(null),
allow_further_rules: z.boolean().default(false),
triggers: z.array(zTriggersMap),
actions: zActionsMap.refine(
(v) => ! (v.clean && v.start_thread),
{
message: "Cannot have both clean and start_thread active at the same time",
}
),
});
export type TRule = z.infer<typeof zRule>;
export const zNotify = z.union([
z.literal("dm"),
z.literal("channel"),
]);
export const zAutomodConfig = z.strictObject({
rules: zBoundedRecord(
z.record(z.string().max(100), zRule),
0,
100,
),
antiraid_levels: z.array(z.string().max(100)).max(10),
can_set_antiraid: z.boolean(),
can_view_antiraid: z.boolean(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface AutomodPluginType extends BasePluginType {
config: TConfigSchema;
config: z.output<typeof zAutomodConfig>;
customOverrideCriteria: {
antiraid_level?: string;

6
backend/src/plugins/BotControl/BotControlPlugin.ts
View file

@ -3,7 +3,7 @@ import { AllowedGuilds } from "../../data/AllowedGuilds";
import { ApiPermissionAssignments } from "../../data/ApiPermissionAssignments";
import { Configs } from "../../data/Configs";
import { GuildArchives } from "../../data/GuildArchives";
import { makeIoTsConfigParser, sendSuccessMessage } from "../../pluginUtils";
import { sendSuccessMessage } from "../../pluginUtils";
import { zeppelinGlobalPlugin } from "../ZeppelinPluginBlueprint";
import { getActiveReload, resetActiveReload } from "./activeReload";
import { AddDashboardUserCmd } from "./commands/AddDashboardUserCmd";
@ -22,7 +22,7 @@ import { ReloadServerCmd } from "./commands/ReloadServerCmd";
import { RemoveDashboardUserCmd } from "./commands/RemoveDashboardUserCmd";
import { RestPerformanceCmd } from "./commands/RestPerformanceCmd";
import { ServersCmd } from "./commands/ServersCmd";
import { BotControlPluginType, ConfigSchema } from "./types";
import { BotControlPluginType, zBotControlConfig } from "./types";
const defaultOptions = {
config: {
@ -37,7 +37,7 @@ const defaultOptions = {
export const BotControlPlugin = zeppelinGlobalPlugin<BotControlPluginType>()({
name: "bot_control",
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zBotControlConfig.parse(input),
defaultOptions,
// prettier-ignore

21
backend/src/plugins/BotControl/types.ts
View file

@ -1,23 +1,22 @@
import * as t from "io-ts";
import { BasePluginType, globalPluginEventListener, globalPluginMessageCommand } from "knub";
import z from "zod";
import { AllowedGuilds } from "../../data/AllowedGuilds";
import { ApiPermissionAssignments } from "../../data/ApiPermissionAssignments";
import { Configs } from "../../data/Configs";
import { GuildArchives } from "../../data/GuildArchives";
import { tNullable } from "../../utils";
import { zBoundedCharacters } from "../../utils";
export const ConfigSchema = t.type({
can_use: t.boolean,
can_eligible: t.boolean,
can_performance: t.boolean,
can_add_server_from_invite: t.boolean,
can_list_dashboard_perms: t.boolean,
update_cmd: tNullable(t.string),
export const zBotControlConfig = z.strictObject({
can_use: z.boolean(),
can_eligible: z.boolean(),
can_performance: z.boolean(),
can_add_server_from_invite: z.boolean(),
can_list_dashboard_perms: z.boolean(),
update_cmd: zBoundedCharacters(0, 2000).nullable(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface BotControlPluginType extends BasePluginType {
config: TConfigSchema;
config: z.output<typeof zBotControlConfig>;
state: {
archives: GuildArchives;
allowedGuilds: AllowedGuilds;

8
backend/src/plugins/Cases/CasesPlugin.ts
View file

@ -3,7 +3,7 @@ import { Case } from "../../data/entities/Case";
import { GuildArchives } from "../../data/GuildArchives";
import { GuildCases } from "../../data/GuildCases";
import { GuildLogs } from "../../data/GuildLogs";
import { makeIoTsConfigParser, mapToPublicFn } from "../../pluginUtils";
import { mapToPublicFn } from "../../pluginUtils";
import { trimPluginDescription } from "../../utils";
import { InternalPosterPlugin } from "../InternalPoster/InternalPosterPlugin";
import { TimeAndDatePlugin } from "../TimeAndDate/TimeAndDatePlugin";
@ -16,7 +16,7 @@ import { getCaseTypeAmountForUserId } from "./functions/getCaseTypeAmountForUser
import { getRecentCasesByMod } from "./functions/getRecentCasesByMod";
import { getTotalCasesByMod } from "./functions/getTotalCasesByMod";
import { postCaseToCaseLogChannel } from "./functions/postToCaseLogChannel";
import { CaseArgs, CaseNoteArgs, CasesPluginType, ConfigSchema } from "./types";
import { CaseArgs, CaseNoteArgs, CasesPluginType, zCasesConfig } from "./types";
// The `any` cast here is to prevent TypeScript from locking up from the circular dependency
function getLogsPlugin(): Promise<any> {
@ -42,11 +42,11 @@ export const CasesPlugin = zeppelinGuildPlugin<CasesPluginType>()({
description: trimPluginDescription(`
This plugin contains basic configuration for cases created by other plugins
`),
configSchema: ConfigSchema,
configSchema: zCasesConfig,
},
dependencies: async () => [TimeAndDatePlugin, InternalPosterPlugin, (await getLogsPlugin()).LogsPlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zCasesConfig.parse(input),
defaultOptions,
public: {

26
backend/src/plugins/Cases/types.ts
View file

@ -1,24 +1,26 @@
import * as t from "io-ts";
import { BasePluginType } from "knub";
import { U } from "ts-toolbelt";
import z from "zod";
import { CaseNameToType, CaseTypes } from "../../data/CaseTypes";
import { GuildArchives } from "../../data/GuildArchives";
import { GuildCases } from "../../data/GuildCases";
import { GuildLogs } from "../../data/GuildLogs";
import { tDelayString, tNullable, tPartialDictionary } from "../../utils";
import { tColor } from "../../utils/tColor";
import { keys, zBoundedCharacters, zDelayString, zSnowflake } from "../../utils";
import { zColor } from "../../utils/zColor";
export const ConfigSchema = t.type({
log_automatic_actions: t.boolean,
case_log_channel: tNullable(t.string),
show_relative_times: t.boolean,
relative_time_cutoff: tDelayString,
case_colors: tNullable(tPartialDictionary(t.keyof(CaseNameToType), tColor)),
case_icons: tNullable(tPartialDictionary(t.keyof(CaseNameToType), t.string)),
const caseKeys = keys(CaseNameToType) as U.ListOf<keyof typeof CaseNameToType>;
export const zCasesConfig = z.strictObject({
log_automatic_actions: z.boolean(),
case_log_channel: zSnowflake.nullable(),
show_relative_times: z.boolean(),
relative_time_cutoff: zDelayString.default("1w"),
case_colors: z.record(z.enum(caseKeys), zColor).nullable(),
case_icons: z.record(z.enum(caseKeys), zBoundedCharacters(0, 32)).nullable(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface CasesPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zCasesConfig>;
state: {
logs: GuildLogs;
cases: GuildCases;

7
backend/src/plugins/Censor/CensorPlugin.ts
View file

@ -1,12 +1,11 @@
import { PluginOptions } from "knub";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { discardRegExpRunner, getRegExpRunner } from "../../regExpRunners";
import { trimPluginDescription } from "../../utils";
import { LogsPlugin } from "../Logs/LogsPlugin";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { CensorPluginType, ConfigSchema } from "./types";
import { CensorPluginType, zCensorConfig } from "./types";
import { onMessageCreate } from "./util/onMessageCreate";
import { onMessageUpdate } from "./util/onMessageUpdate";
@ -54,11 +53,11 @@ export const CensorPlugin = zeppelinGuildPlugin<CensorPluginType>()({
For more advanced filtering, check out the Automod plugin!
`),
legacy: true,
configSchema: ConfigSchema,
configSchema: zCensorConfig,
},
dependencies: () => [LogsPlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zCensorConfig.parse(input),
defaultOptions,
beforeLoad(pluginData) {

36
backend/src/plugins/Censor/types.ts
View file

@ -1,30 +1,28 @@
import * as t from "io-ts";
import { BasePluginType } from "knub";
import z from "zod";
import { RegExpRunner } from "../../RegExpRunner";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { tNullable } from "../../utils";
import { TRegex } from "../../validatorUtils";
import { zBoundedCharacters, zRegex, zSnowflake } from "../../utils";
export const ConfigSchema = t.type({
filter_zalgo: t.boolean,
filter_invites: t.boolean,
invite_guild_whitelist: tNullable(t.array(t.string)),
invite_guild_blacklist: tNullable(t.array(t.string)),
invite_code_whitelist: tNullable(t.array(t.string)),
invite_code_blacklist: tNullable(t.array(t.string)),
allow_group_dm_invites: t.boolean,
filter_domains: t.boolean,
domain_whitelist: tNullable(t.array(t.string)),
domain_blacklist: tNullable(t.array(t.string)),
blocked_tokens: tNullable(t.array(t.string)),
blocked_words: tNullable(t.array(t.string)),
blocked_regex: tNullable(t.array(TRegex)),
export const zCensorConfig = z.strictObject({
filter_zalgo: z.boolean(),
filter_invites: z.boolean(),
invite_guild_whitelist: z.array(zSnowflake).nullable(),
invite_guild_blacklist: z.array(zSnowflake).nullable(),
invite_code_whitelist: z.array(zBoundedCharacters(0, 16)).nullable(),
invite_code_blacklist: z.array(zBoundedCharacters(0, 16)).nullable(),
allow_group_dm_invites: z.boolean(),
filter_domains: z.boolean(),
domain_whitelist: z.array(zBoundedCharacters(0, 255)).nullable(),
domain_blacklist: z.array(zBoundedCharacters(0, 255)).nullable(),
blocked_tokens: z.array(zBoundedCharacters(0, 2000)).nullable(),
blocked_words: z.array(zBoundedCharacters(0, 2000)).nullable(),
blocked_regex: z.array(zRegex(z.string().max(1000))).nullable(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface CensorPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zCensorConfig>;
state: {
serverLogs: GuildLogs;
savedMessages: GuildSavedMessages;

7
backend/src/plugins/ChannelArchiver/ChannelArchiverPlugin.ts
View file

@ -1,18 +1,15 @@
import * as t from "io-ts";
import { makeIoTsConfigParser } from "../../pluginUtils";
import z from "zod";
import { TimeAndDatePlugin } from "../TimeAndDate/TimeAndDatePlugin";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { ArchiveChannelCmd } from "./commands/ArchiveChannelCmd";
import { ChannelArchiverPluginType } from "./types";
const ConfigSchema = t.type({});
export const ChannelArchiverPlugin = zeppelinGuildPlugin<ChannelArchiverPluginType>()({
name: "channel_archiver",
showInDocs: false,
dependencies: () => [TimeAndDatePlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => z.strictObject({}).parse(input),
// prettier-ignore
messageCommands: [

7
backend/src/plugins/CompanionChannels/CompanionChannelsPlugin.ts
View file

@ -1,11 +1,10 @@
import { CooldownManager } from "knub";
import { GuildLogs } from "../../data/GuildLogs";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { trimPluginDescription } from "../../utils";
import { LogsPlugin } from "../Logs/LogsPlugin";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { VoiceStateUpdateEvt } from "./events/VoiceStateUpdateEvt";
import { CompanionChannelsPluginType, ConfigSchema } from "./types";
import { CompanionChannelsPluginType, zCompanionChannelsConfig } from "./types";
const defaultOptions = {
config: {
@ -23,11 +22,11 @@ export const CompanionChannelsPlugin = zeppelinGuildPlugin<CompanionChannelsPlug
Once set up, any time a user joins one of the specified voice channels,
they'll get channel permissions applied to them for the text channels.
`),
configSchema: ConfigSchema,
configSchema: zCompanionChannelsConfig,
},
dependencies: () => [LogsPlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zCompanionChannelsConfig.parse(input),
defaultOptions,
events: [VoiceStateUpdateEvt],

29
backend/src/plugins/CompanionChannels/types.ts
View file

@ -1,28 +1,23 @@
import * as t from "io-ts";
import { BasePluginType, CooldownManager, guildPluginEventListener } from "knub";
import z from "zod";
import { GuildLogs } from "../../data/GuildLogs";
import { tNullable } from "../../utils";
import { zBoundedCharacters, zSnowflake } from "../../utils";
// Permissions using these numbers: https://abal.moe/Eris/docs/reference (add all allowed/denied ones up)
export const CompanionChannelOpts = t.type({
voice_channel_ids: t.array(t.string),
text_channel_ids: t.array(t.string),
permissions: t.number,
enabled: tNullable(t.boolean),
export const zCompanionChannelOpts = z.strictObject({
voice_channel_ids: z.array(zSnowflake),
text_channel_ids: z.array(zSnowflake),
// See https://discord.com/developers/docs/topics/permissions#permissions-bitwise-permission-flags
permissions: z.number(),
enabled: z.boolean().nullable().default(true),
});
export type TCompanionChannelOpts = t.TypeOf<typeof CompanionChannelOpts>;
export type TCompanionChannelOpts = z.infer<typeof zCompanionChannelOpts>;
export const ConfigSchema = t.type({
entries: t.record(t.string, CompanionChannelOpts),
export const zCompanionChannelsConfig = z.strictObject({
entries: z.record(zBoundedCharacters(0, 100), zCompanionChannelOpts),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface ICompanionChannelMap {
[channelId: string]: TCompanionChannelOpts;
}
export interface CompanionChannelsPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zCompanionChannelsConfig>;
state: {
errorCooldownManager: CooldownManager;
serverLogs: GuildLogs;

5
backend/src/plugins/ContextMenus/ContextMenuPlugin.ts
View file

@ -1,12 +1,11 @@
import { PluginOptions } from "knub";
import { GuildContextMenuLinks } from "../../data/GuildContextMenuLinks";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { LogsPlugin } from "../Logs/LogsPlugin";
import { MutesPlugin } from "../Mutes/MutesPlugin";
import { UtilityPlugin } from "../Utility/UtilityPlugin";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { ContextClickedEvt } from "./events/ContextClickedEvt";
import { ConfigSchema, ContextMenuPluginType } from "./types";
import { ContextMenuPluginType, zContextMenusConfig } from "./types";
import { loadAllCommands } from "./utils/loadAllCommands";
const defaultOptions: PluginOptions<ContextMenuPluginType> = {
@ -37,7 +36,7 @@ export const ContextMenuPlugin = zeppelinGuildPlugin<ContextMenuPluginType>()({
showInDocs: false,
dependencies: () => [MutesPlugin, LogsPlugin, UtilityPlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zContextMenusConfig.parse(input),
defaultOptions,
// prettier-ignore

4
backend/src/plugins/ContextMenus/actions/mute.ts
View file

@ -45,9 +45,9 @@ export async function muteAction(
try {
const result = await mutes.muteUser(userId, durationMs, "Context Menu Action", { caseArgs });
const muteMessage = `Muted **${result.case.user_name}** ${
const muteMessage = `Muted **${result.case!.user_name}** ${
durationMs ? `for ${humanizeDuration(durationMs)}` : "indefinitely"
} (Case #${result.case.case_number}) (user notified via ${
} (Case #${result.case!.case_number}) (user notified via ${
result.notifyResult.method ?? "dm"
})\nPlease update the new case with the \`update\` command`;

24
backend/src/plugins/ContextMenus/types.ts
View file

@ -1,22 +1,20 @@
import * as t from "io-ts";
import { BasePluginType, guildPluginEventListener } from "knub";
import z from "zod";
import { GuildContextMenuLinks } from "../../data/GuildContextMenuLinks";
export const ConfigSchema = t.type({
can_use: t.boolean,
user_muteindef: t.boolean,
user_mute1d: t.boolean,
user_mute1h: t.boolean,
user_info: t.boolean,
message_clean10: t.boolean,
message_clean25: t.boolean,
message_clean50: t.boolean,
export const zContextMenusConfig = z.strictObject({
can_use: z.boolean(),
user_muteindef: z.boolean(),
user_mute1d: z.boolean(),
user_mute1h: z.boolean(),
user_info: z.boolean(),
message_clean10: z.boolean(),
message_clean25: z.boolean(),
message_clean50: z.boolean(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface ContextMenuPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zContextMenusConfig>;
state: {
contextMenuLinks: GuildContextMenuLinks;
};

68
backend/src/plugins/Counters/CountersPlugin.ts
View file

@ -1,15 +1,12 @@
import { EventEmitter } from "events";
import { PluginOptions } from "knub";
import {
buildCounterConditionString,
CounterTrigger,
getReverseCounterComparisonOp,
parseCounterConditionString,
} from "../../data/entities/CounterTrigger";
import { GuildCounters } from "../../data/GuildCounters";
import {
CounterTrigger,
parseCounterConditionString
} from "../../data/entities/CounterTrigger";
import { mapToPublicFn } from "../../pluginUtils";
import { convertDelayStringToMS, MINUTES } from "../../utils";
import { parseIoTsSchema, StrictValidationError } from "../../validatorUtils";
import { MINUTES, convertDelayStringToMS, values } from "../../utils";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { AddCounterCmd } from "./commands/AddCounterCmd";
import { CountersListCmd } from "./commands/CountersListCmd";
@ -25,10 +22,8 @@ import { getPrettyNameForCounterTrigger } from "./functions/getPrettyNameForCoun
import { offCounterEvent } from "./functions/offCounterEvent";
import { onCounterEvent } from "./functions/onCounterEvent";
import { setCounterValue } from "./functions/setCounterValue";
import { ConfigSchema, CountersPluginType, TTrigger } from "./types";
import { CountersPluginType, zCountersConfig } from "./types";
const MAX_COUNTERS = 5;
const MAX_TRIGGERS_PER_COUNTER = 5;
const DECAY_APPLY_INTERVAL = 5 * MINUTES;
const defaultOptions: PluginOptions<CountersPluginType> = {
@ -72,50 +67,12 @@ export const CountersPlugin = zeppelinGuildPlugin<CountersPluginType>()({
description:
"Keep track of per-user, per-channel, or global numbers and trigger specific actions based on this number",
configurationGuide: "See <a href='/docs/setup-guides/counters'>Counters setup guide</a>",
configSchema: ConfigSchema,
configSchema: zCountersConfig,
},
defaultOptions,
// TODO: Separate input and output types
configParser: (input) => {
for (const [counterName, counter] of Object.entries<any>((input as any).counters || {})) {
counter.name = counterName;
counter.per_user = counter.per_user ?? false;
counter.per_channel = counter.per_channel ?? false;
counter.initial_value = counter.initial_value ?? 0;
counter.triggers = counter.triggers || {};
if (Object.values(counter.triggers).length > MAX_TRIGGERS_PER_COUNTER) {
throw new StrictValidationError([`You can only have at most ${MAX_TRIGGERS_PER_COUNTER} triggers per counter`]);
}
// Normalize triggers
for (const [triggerName, trigger] of Object.entries(counter.triggers)) {
const triggerObj = (typeof trigger === "string" ? { condition: trigger } : trigger) as Partial<TTrigger>;
triggerObj.name = triggerName;
const parsedCondition = parseCounterConditionString(triggerObj.condition || "");
if (!parsedCondition) {
throw new StrictValidationError([
`Invalid comparison in counter trigger ${counterName}/${triggerName}: "${triggerObj.condition}"`,
]);
}
triggerObj.condition = buildCounterConditionString(parsedCondition[0], parsedCondition[1]);
triggerObj.reverse_condition =
triggerObj.reverse_condition ||
buildCounterConditionString(getReverseCounterComparisonOp(parsedCondition[0]), parsedCondition[1]);
counter.triggers[triggerName] = triggerObj as TTrigger;
}
}
if (Object.values((input as any).counters || {}).length > MAX_COUNTERS) {
throw new StrictValidationError([`You can only have at most ${MAX_COUNTERS} counters`]);
}
return parseIoTsSchema(ConfigSchema, input);
},
configParser: (input) => zCountersConfig.parse(input),
public: {
counterExists: mapToPublicFn(counterExists),
@ -163,13 +120,12 @@ export const CountersPlugin = zeppelinGuildPlugin<CountersPluginType>()({
state.counterTriggersByCounterId.set(dbCounter.id, thisCounterTriggers);
// Initialize triggers
for (const trigger of Object.values(counter.triggers)) {
const theTrigger = trigger as TTrigger;
const parsedCondition = parseCounterConditionString(theTrigger.condition)!;
const parsedReverseCondition = parseCounterConditionString(theTrigger.reverse_condition)!;
for (const trigger of values(counter.triggers)) {
const parsedCondition = parseCounterConditionString(trigger.condition)!;
const parsedReverseCondition = parseCounterConditionString(trigger.reverse_condition)!;
const counterTrigger = await state.counters.initCounterTrigger(
dbCounter.id,
theTrigger.name,
trigger.name,
parsedCondition[0],
parsedCondition[1],
parsedReverseCondition[0],

4
backend/src/plugins/Counters/functions/getPrettyNameForCounterTrigger.ts
View file

@ -1,5 +1,5 @@
import { GuildPluginData } from "knub";
import { CountersPluginType, TTrigger } from "../types";
import { CountersPluginType } from "../types";
export function getPrettyNameForCounterTrigger(
pluginData: GuildPluginData<CountersPluginType>,
@ -12,6 +12,6 @@ export function getPrettyNameForCounterTrigger(
return "Unknown Counter Trigger";
}
const trigger = counter.triggers[triggerName] as TTrigger | undefined;
const trigger = counter.triggers[triggerName];
return trigger ? trigger.pretty_name || trigger.name : "Unknown Counter Trigger";
}

119
backend/src/plugins/Counters/types.ts
View file

@ -1,45 +1,98 @@
import { EventEmitter } from "events";
import * as t from "io-ts";
import { BasePluginType } from "knub";
import z from "zod";
import { GuildCounters } from "../../data/GuildCounters";
import { CounterTrigger } from "../../data/entities/CounterTrigger";
import { tDelayString, tNullable } from "../../utils";
import { CounterTrigger, buildCounterConditionString, getReverseCounterComparisonOp, parseCounterConditionString } from "../../data/entities/CounterTrigger";
import { zBoundedCharacters, zBoundedRecord, zDelayString } from "../../utils";
import Timeout = NodeJS.Timeout;
export const Trigger = t.type({
name: t.string,
pretty_name: tNullable(t.string),
condition: t.string,
reverse_condition: t.string,
});
export type TTrigger = t.TypeOf<typeof Trigger>;
const MAX_COUNTERS = 5;
const MAX_TRIGGERS_PER_COUNTER = 5;
export const Counter = t.type({
name: t.string,
pretty_name: tNullable(t.string),
per_channel: t.boolean,
per_user: t.boolean,
initial_value: t.number,
triggers: t.record(t.string, t.union([t.string, Trigger])),
decay: tNullable(
t.type({
amount: t.number,
every: tDelayString,
}),
export const zTrigger = z.strictObject({
// Dummy type because name gets replaced by the property key in zTriggerInput
name: z.never().optional().transform(() => ""),
pretty_name: zBoundedCharacters(0, 100).nullable().default(null),
condition: zBoundedCharacters(1, 64).refine(
(str) => parseCounterConditionString(str) !== null,
{ message: "Invalid counter trigger condition" },
),
reverse_condition: zBoundedCharacters(1, 64).refine(
(str) => parseCounterConditionString(str) !== null,
{ message: "Invalid counter trigger reverse condition" },
),
can_view: tNullable(t.boolean),
can_edit: tNullable(t.boolean),
can_reset_all: tNullable(t.boolean),
});
export type TCounter = t.TypeOf<typeof Counter>;
export const ConfigSchema = t.type({
counters: t.record(t.string, Counter),
can_view: t.boolean,
can_edit: t.boolean,
can_reset_all: t.boolean,
const zTriggerInput = z.union([zBoundedCharacters(0, 100), zTrigger])
.transform((val, ctx) => {
const ruleName = String(ctx.path[ctx.path.length - 2]).trim();
if (typeof val === "string") {
const parsedCondition = parseCounterConditionString(val);
if (!parsedCondition) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Invalid counter trigger condition",
});
return z.NEVER;
}
return {
name: ruleName,
pretty_name: null,
condition: buildCounterConditionString(parsedCondition[0], parsedCondition[1]),
reverse_condition: buildCounterConditionString(getReverseCounterComparisonOp(parsedCondition[0]), parsedCondition[1]),
};
}
return {
...val,
name: ruleName,
};
});
export const zCounter = z.strictObject({
// Typed as "never" because you are not expected to supply this directly.
// The transform instead picks it up from the property key and the output type is a string.
name: z.never().optional().transform((_, ctx) => {
const ruleName = String(ctx.path[ctx.path.length - 2]).trim();
if (! ruleName) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: "Counters must have names",
});
return z.NEVER;
}
return ruleName;
}),
pretty_name: zBoundedCharacters(0, 100).nullable().default(null),
per_channel: z.boolean().default(false),
per_user: z.boolean().default(false),
initial_value: z.number().default(0),
triggers: zBoundedRecord(
z.record(
zBoundedCharacters(0, 100),
zTriggerInput,
),
1,
MAX_TRIGGERS_PER_COUNTER,
),
decay: z.strictObject({
amount: z.number(),
every: zDelayString,
}).nullable().default(null),
can_view: z.boolean(),
can_edit: z.boolean(),
can_reset_all: z.boolean(),
});
export const zCountersConfig = z.strictObject({
counters: zBoundedRecord(
z.record(zBoundedCharacters(0, 100), zCounter),
0,
MAX_COUNTERS,
),
can_view: z.boolean(),
can_edit: z.boolean(),
can_reset_all: z.boolean(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface CounterEvents {
trigger: (counterName: string, triggerName: string, channelId: string | null, userId: string | null) => void;
@ -52,7 +105,7 @@ export interface CounterEventEmitter extends EventEmitter {
}
export interface CountersPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zCountersConfig>;
state: {
counters: GuildCounters;
counterIds: Record<string, number>;

5
backend/src/plugins/CustomEvents/CustomEventsPlugin.ts
View file

@ -2,7 +2,6 @@ import { GuildChannel, GuildMember, User } from "discord.js";
import { guildPluginMessageCommand, parseSignature } from "knub";
import { TSignature } from "knub-command-manager";
import { commandTypes } from "../../commandTypes";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { TemplateSafeValueContainer, createTypedTemplateSafeValueContainer } from "../../templateFormatter";
import { UnknownUser } from "../../utils";
import { isScalar } from "../../utils/isScalar";
@ -14,7 +13,7 @@ import {
} from "../../utils/templateSafeObjects";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { runEvent } from "./functions/runEvent";
import { ConfigSchema, CustomEventsPluginType } from "./types";
import { CustomEventsPluginType, zCustomEventsConfig } from "./types";
const defaultOptions = {
config: {
@ -26,7 +25,7 @@ export const CustomEventsPlugin = zeppelinGuildPlugin<CustomEventsPluginType>()(
name: "custom_events",
showInDocs: false,
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zCustomEventsConfig.parse(input),
defaultOptions,
afterLoad(pluginData) {

14
backend/src/plugins/CustomEvents/actions/addRoleAction.ts
View file

@ -1,17 +1,17 @@
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import z from "zod";
import { canActOn } from "../../../pluginUtils";
import { renderTemplate, TemplateSafeValueContainer } from "../../../templateFormatter";
import { resolveMember } from "../../../utils";
import { resolveMember, zSnowflake } from "../../../utils";
import { ActionError } from "../ActionError";
import { CustomEventsPluginType, TCustomEvent } from "../types";
export const AddRoleAction = t.type({
type: t.literal("add_role"),
target: t.string,
role: t.union([t.string, t.array(t.string)]),
export const zAddRoleAction = z.strictObject({
type: z.literal("add_role"),
target: zSnowflake,
role: z.union([zSnowflake, z.array(zSnowflake)]),
});
export type TAddRoleAction = t.TypeOf<typeof AddRoleAction>;
export type TAddRoleAction = z.infer<typeof zAddRoleAction>;
export async function addRoleAction(
pluginData: GuildPluginData<CustomEventsPluginType>,

19
backend/src/plugins/CustomEvents/actions/createCaseAction.ts
View file

@ -1,19 +1,20 @@
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import z from "zod";
import { CaseTypes } from "../../../data/CaseTypes";
import { renderTemplate, TemplateSafeValueContainer } from "../../../templateFormatter";
import { zBoundedCharacters, zSnowflake } from "../../../utils";
import { CasesPlugin } from "../../Cases/CasesPlugin";
import { ActionError } from "../ActionError";
import { CustomEventsPluginType, TCustomEvent } from "../types";
export const CreateCaseAction = t.type({
type: t.literal("create_case"),
case_type: t.string,
mod: t.string,
target: t.string,
reason: t.string,
export const zCreateCaseAction = z.strictObject({
type: z.literal("create_case"),
case_type: zBoundedCharacters(0, 32),
mod: zSnowflake,
target: zSnowflake,
reason: zBoundedCharacters(0, 4000),
});
export type TCreateCaseAction = t.TypeOf<typeof CreateCaseAction>;
export type TCreateCaseAction = z.infer<typeof zCreateCaseAction>;
export async function createCaseAction(
pluginData: GuildPluginData<CustomEventsPluginType>,
@ -32,7 +33,7 @@ export async function createCaseAction(
}
const casesPlugin = pluginData.getPlugin(CasesPlugin);
await casesPlugin.createCase({
await casesPlugin!.createCase({
userId: targetId,
modId,
type: CaseTypes[action.case_type],

14
backend/src/plugins/CustomEvents/actions/makeRoleMentionableAction.ts
View file

@ -1,17 +1,17 @@
import { Snowflake } from "discord.js";
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import z from "zod";
import { TemplateSafeValueContainer } from "../../../templateFormatter";
import { convertDelayStringToMS, noop, tDelayString } from "../../../utils";
import { convertDelayStringToMS, noop, zDelayString, zSnowflake } from "../../../utils";
import { ActionError } from "../ActionError";
import { CustomEventsPluginType, TCustomEvent } from "../types";
export const MakeRoleMentionableAction = t.type({
type: t.literal("make_role_mentionable"),
role: t.string,
timeout: tDelayString,
export const zMakeRoleMentionableAction = z.strictObject({
type: z.literal("make_role_mentionable"),
role: zSnowflake,
timeout: zDelayString,
});
export type TMakeRoleMentionableAction = t.TypeOf<typeof MakeRoleMentionableAction>;
export type TMakeRoleMentionableAction = z.infer<typeof zMakeRoleMentionableAction>;
export async function makeRoleMentionableAction(
pluginData: GuildPluginData<CustomEventsPluginType>,

11
backend/src/plugins/CustomEvents/actions/makeRoleUnmentionableAction.ts
View file

@ -1,15 +1,16 @@
import { Snowflake } from "discord.js";
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import z from "zod";
import { TemplateSafeValueContainer } from "../../../templateFormatter";
import { zSnowflake } from "../../../utils";
import { ActionError } from "../ActionError";
import { CustomEventsPluginType, TCustomEvent } from "../types";
export const MakeRoleUnmentionableAction = t.type({
type: t.literal("make_role_unmentionable"),
role: t.string,
export const zMakeRoleUnmentionableAction = z.strictObject({
type: z.literal("make_role_unmentionable"),
role: zSnowflake,
});
export type TMakeRoleUnmentionableAction = t.TypeOf<typeof MakeRoleUnmentionableAction>;
export type TMakeRoleUnmentionableAction = z.infer<typeof zMakeRoleUnmentionableAction>;
export async function makeRoleUnmentionableAction(
pluginData: GuildPluginData<CustomEventsPluginType>,

13
backend/src/plugins/CustomEvents/actions/messageAction.ts
View file

@ -1,16 +1,17 @@
import { Snowflake, TextChannel } from "discord.js";
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import z from "zod";
import { TemplateSafeValueContainer, renderTemplate } from "../../../templateFormatter";
import { zBoundedCharacters, zSnowflake } from "../../../utils";
import { ActionError } from "../ActionError";
import { CustomEventsPluginType } from "../types";
export const MessageAction = t.type({
type: t.literal("message"),
channel: t.string,
content: t.string,
export const zMessageAction = z.strictObject({
type: z.literal("message"),
channel: zSnowflake,
content: zBoundedCharacters(0, 4000),
});
export type TMessageAction = t.TypeOf<typeof MessageAction>;
export type TMessageAction = z.infer<typeof zMessageAction>;
export async function messageAction(
pluginData: GuildPluginData<CustomEventsPluginType>,

14
backend/src/plugins/CustomEvents/actions/moveToVoiceChannelAction.ts
View file

@ -1,18 +1,18 @@
import { Snowflake, VoiceChannel } from "discord.js";
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import z from "zod";
import { canActOn } from "../../../pluginUtils";
import { TemplateSafeValueContainer, renderTemplate } from "../../../templateFormatter";
import { resolveMember } from "../../../utils";
import { resolveMember, zSnowflake } from "../../../utils";
import { ActionError } from "../ActionError";
import { CustomEventsPluginType, TCustomEvent } from "../types";
export const MoveToVoiceChannelAction = t.type({
type: t.literal("move_to_vc"),
target: t.string,
channel: t.string,
export const zMoveToVoiceChannelAction = z.strictObject({
type: z.literal("move_to_vc"),
target: zSnowflake,
channel: zSnowflake,
});
export type TMoveToVoiceChannelAction = t.TypeOf<typeof MoveToVoiceChannelAction>;
export type TMoveToVoiceChannelAction = z.infer<typeof zMoveToVoiceChannelAction>;
export async function moveToVoiceChannelAction(
pluginData: GuildPluginData<CustomEventsPluginType>,

25
backend/src/plugins/CustomEvents/actions/setChannelPermissionOverrides.ts
View file

@ -1,23 +1,24 @@
import { PermissionsBitField, PermissionsString, Snowflake } from "discord.js";
import * as t from "io-ts";
import { GuildPluginData } from "knub";
import z from "zod";
import { TemplateSafeValueContainer } from "../../../templateFormatter";
import { zSnowflake } from "../../../utils";
import { ActionError } from "../ActionError";
import { CustomEventsPluginType, TCustomEvent } from "../types";
export const SetChannelPermissionOverridesAction = t.type({
type: t.literal("set_channel_permission_overrides"),
channel: t.string,
overrides: t.array(
t.type({
type: t.union([t.literal("member"), t.literal("role")]),
id: t.string,
allow: t.number,
deny: t.number,
export const zSetChannelPermissionOverridesAction = z.strictObject({
type: z.literal("set_channel_permission_overrides"),
channel: zSnowflake,
overrides: z.array(
z.strictObject({
type: z.union([z.literal("member"), z.literal("role")]),
id: zSnowflake,
allow: z.number(),
deny: z.number(),
}),
),
).max(15),
});
export type TSetChannelPermissionOverridesAction = t.TypeOf<typeof SetChannelPermissionOverridesAction>;
export type TSetChannelPermissionOverridesAction = z.infer<typeof zSetChannelPermissionOverridesAction>;
export async function setChannelPermissionOverridesAction(
pluginData: GuildPluginData<CustomEventsPluginType>,

67
backend/src/plugins/CustomEvents/types.ts
View file

@ -1,47 +1,50 @@
import * as t from "io-ts";
import { BasePluginType } from "knub";
import { AddRoleAction } from "./actions/addRoleAction";
import { CreateCaseAction } from "./actions/createCaseAction";
import { MakeRoleMentionableAction } from "./actions/makeRoleMentionableAction";
import { MakeRoleUnmentionableAction } from "./actions/makeRoleUnmentionableAction";
import { MessageAction } from "./actions/messageAction";
import { MoveToVoiceChannelAction } from "./actions/moveToVoiceChannelAction";
import { SetChannelPermissionOverridesAction } from "./actions/setChannelPermissionOverrides";
import z from "zod";
import { zBoundedCharacters, zBoundedRecord } from "../../utils";
import { zAddRoleAction } from "./actions/addRoleAction";
import { zCreateCaseAction } from "./actions/createCaseAction";
import { zMakeRoleMentionableAction } from "./actions/makeRoleMentionableAction";
import { zMakeRoleUnmentionableAction } from "./actions/makeRoleUnmentionableAction";
import { zMessageAction } from "./actions/messageAction";
import { zMoveToVoiceChannelAction } from "./actions/moveToVoiceChannelAction";
import { zSetChannelPermissionOverridesAction } from "./actions/setChannelPermissionOverrides";
// Triggers
const CommandTrigger = t.type({
type: t.literal("command"),
name: t.string,
params: t.string,
can_use: t.boolean,
const zCommandTrigger = z.strictObject({
type: z.literal("command"),
name: zBoundedCharacters(0, 100),
params: zBoundedCharacters(0, 255),
can_use: z.boolean(),
});
const AnyTrigger = CommandTrigger; // TODO: Make into a union once we have more triggers
const zAnyTrigger = zCommandTrigger; // TODO: Make into a union once we have more triggers
const AnyAction = t.union([
AddRoleAction,
CreateCaseAction,
MoveToVoiceChannelAction,
MessageAction,
MakeRoleMentionableAction,
MakeRoleUnmentionableAction,
SetChannelPermissionOverridesAction,
const zAnyAction = z.union([
zAddRoleAction,
zCreateCaseAction,
zMoveToVoiceChannelAction,
zMessageAction,
zMakeRoleMentionableAction,
zMakeRoleUnmentionableAction,
zSetChannelPermissionOverridesAction,
]);
export const CustomEvent = t.type({
name: t.string,
trigger: AnyTrigger,
actions: t.array(AnyAction),
export const zCustomEvent = z.strictObject({
name: zBoundedCharacters(0, 100),
trigger: zAnyTrigger,
actions: z.array(zAnyAction).max(10),
});
export type TCustomEvent = t.TypeOf<typeof CustomEvent>;
export type TCustomEvent = z.infer<typeof zCustomEvent>;
export const ConfigSchema = t.type({
events: t.record(t.string, CustomEvent),
export const zCustomEventsConfig = z.strictObject({
events: zBoundedRecord(
z.record(zBoundedCharacters(0, 100), zCustomEvent),
0,
100,
),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface CustomEventsPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zCustomEventsConfig>;
state: {
clearTriggers: () => void;
};

5
backend/src/plugins/GuildAccessMonitor/GuildAccessMonitorPlugin.ts
View file

@ -1,11 +1,10 @@
import { Guild } from "discord.js";
import * as t from "io-ts";
import { BasePluginType, GlobalPluginData, globalPluginEventListener } from "knub";
import { AllowedGuilds } from "../../data/AllowedGuilds";
import { Configs } from "../../data/Configs";
import { env } from "../../env";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { zeppelinGlobalPlugin } from "../ZeppelinPluginBlueprint";
import z from "zod";
interface GuildAccessMonitorPluginType extends BasePluginType {
state: {
@ -26,7 +25,7 @@ async function checkGuild(pluginData: GlobalPluginData<GuildAccessMonitorPluginT
*/
export const GuildAccessMonitorPlugin = zeppelinGlobalPlugin<GuildAccessMonitorPluginType>()({
name: "guild_access_monitor",
configParser: makeIoTsConfigParser(t.type({})),
configParser: (input) => z.strictObject({}).parse(input),
events: [
globalPluginEventListener<GuildAccessMonitorPluginType>()({

5
backend/src/plugins/GuildConfigReloader/GuildConfigReloaderPlugin.ts
View file

@ -1,6 +1,5 @@
import * as t from "io-ts";
import z from "zod";
import { Configs } from "../../data/Configs";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { zeppelinGlobalPlugin } from "../ZeppelinPluginBlueprint";
import { reloadChangedGuilds } from "./functions/reloadChangedGuilds";
import { GuildConfigReloaderPluginType } from "./types";
@ -9,7 +8,7 @@ export const GuildConfigReloaderPlugin = zeppelinGlobalPlugin<GuildConfigReloade
name: "guild_config_reloader",
showInDocs: false,
configParser: makeIoTsConfigParser(t.type({})),
configParser: (input) => z.strictObject({}).parse(input),
async beforeLoad(pluginData) {
const { state } = pluginData;

5
backend/src/plugins/GuildInfoSaver/GuildInfoSaverPlugin.ts
View file

@ -1,18 +1,17 @@
import { Guild } from "discord.js";
import * as t from "io-ts";
import { guildPluginEventListener } from "knub";
import { AllowedGuilds } from "../../data/AllowedGuilds";
import { ApiPermissionAssignments } from "../../data/ApiPermissionAssignments";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { MINUTES } from "../../utils";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { GuildInfoSaverPluginType } from "./types";
import z from "zod";
export const GuildInfoSaverPlugin = zeppelinGuildPlugin<GuildInfoSaverPluginType>()({
name: "guild_info_saver",
showInDocs: false,
configParser: makeIoTsConfigParser(t.type({})),
configParser: (input) => z.strictObject({}).parse(input),
events: [
guildPluginEventListener({

6
backend/src/plugins/GuildMemberCache/GuildMemberCachePlugin.ts
View file

@ -1,6 +1,6 @@
import * as t from "io-ts";
import z from "zod";
import { GuildMemberCache } from "../../data/GuildMemberCache";
import { makeIoTsConfigParser, mapToPublicFn } from "../../pluginUtils";
import { mapToPublicFn } from "../../pluginUtils";
import { SECONDS } from "../../utils";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { cancelDeletionOnMemberJoin } from "./events/cancelDeletionOnMemberJoin";
@ -18,7 +18,7 @@ export const GuildMemberCachePlugin = zeppelinGuildPlugin<GuildMemberCachePlugin
name: "guild_member_cache",
showInDocs: false,
configParser: makeIoTsConfigParser(t.type({})),
configParser: (input) => z.strictObject({}).parse(input),
events: [
updateMemberCacheOnMemberUpdate,

7
backend/src/plugins/InternalPoster/InternalPosterPlugin.ts
View file

@ -1,11 +1,12 @@
import { PluginOptions } from "knub";
import z from "zod";
import { Queue } from "../../Queue";
import { Webhooks } from "../../data/Webhooks";
import { makeIoTsConfigParser, mapToPublicFn } from "../../pluginUtils";
import { mapToPublicFn } from "../../pluginUtils";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { editMessage } from "./functions/editMessage";
import { sendMessage } from "./functions/sendMessage";
import { ConfigSchema, InternalPosterPluginType } from "./types";
import { InternalPosterPluginType } from "./types";
const defaultOptions: PluginOptions<InternalPosterPluginType> = {
config: {},
@ -16,7 +17,7 @@ export const InternalPosterPlugin = zeppelinGuildPlugin<InternalPosterPluginType
name: "internal_poster",
showInDocs: false,
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => z.strictObject({}).parse(input),
defaultOptions,
// prettier-ignore

6
backend/src/plugins/InternalPoster/types.ts
View file

@ -1,15 +1,9 @@
import { WebhookClient } from "discord.js";
import * as t from "io-ts";
import { BasePluginType } from "knub";
import { Queue } from "../../Queue";
import { Webhooks } from "../../data/Webhooks";
export const ConfigSchema = t.type({});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface InternalPosterPluginType extends BasePluginType {
config: TConfigSchema;
state: {
queue: Queue;
webhooks: Webhooks;

7
backend/src/plugins/LocateUser/LocateUserPlugin.ts
View file

@ -1,7 +1,6 @@
import { PluginOptions } from "knub";
import { onGuildEvent } from "../../data/GuildEvents";
import { GuildVCAlerts } from "../../data/GuildVCAlerts";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { trimPluginDescription } from "../../utils";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { FollowCmd } from "./commands/FollowCmd";
@ -9,7 +8,7 @@ import { DeleteFollowCmd, ListFollowCmd } from "./commands/ListFollowCmd";
import { WhereCmd } from "./commands/WhereCmd";
import { GuildBanRemoveAlertsEvt } from "./events/BanRemoveAlertsEvt";
import { VoiceStateUpdateAlertEvt } from "./events/SendAlertsEvts";
import { ConfigSchema, LocateUserPluginType } from "./types";
import { LocateUserPluginType, zLocateUserConfig } from "./types";
import { clearExpiredAlert } from "./utils/clearExpiredAlert";
import { fillActiveAlertsList } from "./utils/fillAlertsList";
@ -39,10 +38,10 @@ export const LocateUserPlugin = zeppelinGuildPlugin<LocateUserPluginType>()({
* Instantly receive an invite to the voice channel of a user
* Be notified as soon as a user switches or joins a voice channel
`),
configSchema: ConfigSchema,
configSchema: zLocateUserConfig,
},
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zLocateUserConfig.parse(input),
defaultOptions,
// prettier-ignore

11
backend/src/plugins/LocateUser/types.ts
View file

@ -1,15 +1,14 @@
import * as t from "io-ts";
import { BasePluginType, guildPluginEventListener, guildPluginMessageCommand } from "knub";
import z from "zod";
import { GuildVCAlerts } from "../../data/GuildVCAlerts";
export const ConfigSchema = t.type({
can_where: t.boolean,
can_alert: t.boolean,
export const zLocateUserConfig = z.strictObject({
can_where: z.boolean(),
can_alert: z.boolean(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface LocateUserPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zLocateUserConfig>;
state: {
alerts: GuildVCAlerts;
usersWithAlerts: string[];

18
backend/src/plugins/Logs/LogsPlugin.ts
View file

@ -6,7 +6,7 @@ import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { LogType } from "../../data/LogType";
import { logger } from "../../logger";
import { makeIoTsConfigParser, mapToPublicFn } from "../../pluginUtils";
import { mapToPublicFn } from "../../pluginUtils";
import { discardRegExpRunner, getRegExpRunner } from "../../regExpRunners";
import { TypedTemplateSafeValueContainer, createTypedTemplateSafeValueContainer } from "../../templateFormatter";
import { TimeAndDatePlugin } from "../TimeAndDate/TimeAndDatePlugin";
@ -31,7 +31,7 @@ import {
import { LogsThreadCreateEvt, LogsThreadDeleteEvt, LogsThreadUpdateEvt } from "./events/LogsThreadModifyEvts";
import { LogsGuildMemberUpdateEvt } from "./events/LogsUserUpdateEvts";
import { LogsVoiceStateUpdateEvt } from "./events/LogsVoiceChannelEvts";
import { ConfigSchema, FORMAT_NO_TIMESTAMP, ILogTypeData, LogsPluginType, TLogChannel } from "./types";
import { FORMAT_NO_TIMESTAMP, ILogTypeData, LogsPluginType, TLogChannel, zLogsConfig } from "./types";
import { getLogMessage } from "./util/getLogMessage";
import { log } from "./util/log";
import { onMessageDelete } from "./util/onMessageDelete";
@ -110,7 +110,6 @@ import { logVoiceChannelForceMove } from "./logFunctions/logVoiceChannelForceMov
import { logVoiceChannelJoin } from "./logFunctions/logVoiceChannelJoin";
import { logVoiceChannelLeave } from "./logFunctions/logVoiceChannelLeave";
import { logVoiceChannelMove } from "./logFunctions/logVoiceChannelMove";
import { asBoundedString } from "../../utils/iotsUtils";
// The `any` cast here is to prevent TypeScript from locking up from the circular dependency
function getCasesPlugin(): Promise<any> {
@ -121,12 +120,12 @@ const defaultOptions: PluginOptions<LogsPluginType> = {
config: {
channels: {},
format: {
timestamp: asBoundedString(FORMAT_NO_TIMESTAMP), // Legacy/deprecated, use timestamp_format below instead
timestamp: FORMAT_NO_TIMESTAMP,
...DefaultLogMessages,
},
ping_user: true, // Legacy/deprecated, if below is false mentions wont actually ping. In case you really want the old behavior, set below to true
ping_user: true,
allow_user_mentions: false,
timestamp_format: asBoundedString("[<t:]X[>]"),
timestamp_format: "[<t:]X[>]",
include_embed_timestamp: true,
},
@ -134,7 +133,8 @@ const defaultOptions: PluginOptions<LogsPluginType> = {
{
level: ">=50",
config: {
ping_user: false, // Legacy/deprecated, read comment on global ping_user option
// Legacy/deprecated, read comment on global ping_user option
ping_user: false,
},
},
],
@ -145,11 +145,11 @@ export const LogsPlugin = zeppelinGuildPlugin<LogsPluginType>()({
showInDocs: true,
info: {
prettyName: "Logs",
configSchema: ConfigSchema,
configSchema: zLogsConfig,
},
dependencies: async () => [TimeAndDatePlugin, InternalPosterPlugin, (await getCasesPlugin()).CasesPlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zLogsConfig.parse(input),
defaultOptions,
events: [

2
backend/src/plugins/Logs/logFunctions/logMessageDelete.ts
View file

@ -32,7 +32,7 @@ export function logMessageDelete(pluginData: GuildPluginData<LogsPluginType>, da
// See comment on FORMAT_NO_TIMESTAMP in types.ts
const config = pluginData.config.get();
const timestampFormat =
(config.format.timestamp !== FORMAT_NO_TIMESTAMP ? config.format.timestamp : null) ?? config.timestamp_format;
(config.format.timestamp !== FORMAT_NO_TIMESTAMP ? config.format.timestamp : null) ?? config.timestamp_format ?? undefined;
return log(
pluginData,

82
backend/src/plugins/Logs/types.ts
View file

@ -1,4 +1,3 @@
import * as t from "io-ts";
import { BasePluginType, CooldownManager, guildPluginEventListener } from "knub";
import { z } from "zod";
import { RegExpRunner } from "../../RegExpRunner";
@ -7,7 +6,7 @@ import { GuildCases } from "../../data/GuildCases";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { LogType } from "../../data/LogType";
import { tMessageContent, tNullable } from "../../utils";
import { zBoundedCharacters, zMessageContent, zRegex, zSnowflake } from "../../utils";
import { MessageBuffer } from "../../utils/MessageBuffer";
import {
TemplateSafeCase,
@ -22,55 +21,56 @@ import {
TemplateSafeUnknownUser,
TemplateSafeUser,
} from "../../utils/templateSafeObjects";
import { TRegex } from "../../validatorUtils";
import { tBoundedString } from "../../utils/iotsUtils";
export const tLogFormats = t.record(t.string, t.union([t.string, tMessageContent]));
export type TLogFormats = t.TypeOf<typeof tLogFormats>;
const DEFAULT_BATCH_TIME = 1000;
const MIN_BATCH_TIME = 250;
const MAX_BATCH_TIME = 5000;
const LogChannel = t.partial({
include: t.array(t.string),
exclude: t.array(t.string),
batched: t.boolean,
batch_time: t.number,
excluded_users: t.array(t.string),
excluded_message_regexes: t.array(TRegex),
excluded_channels: t.array(t.string),
excluded_categories: t.array(t.string),
excluded_threads: t.array(t.string),
exclude_bots: t.boolean,
excluded_roles: t.array(t.string),
format: tNullable(tLogFormats),
timestamp_format: t.string,
include_embed_timestamp: t.boolean,
export const zLogFormats = z.record(
zBoundedCharacters(1, 255),
zMessageContent,
);
export type TLogFormats = z.infer<typeof zLogFormats>;
const zLogChannel = z.strictObject({
include: z.array(zBoundedCharacters(1, 255)).default([]),
exclude: z.array(zBoundedCharacters(1, 255)).default([]),
batched: z.boolean().default(true),
batch_time: z.number().min(MIN_BATCH_TIME).max(MAX_BATCH_TIME).default(DEFAULT_BATCH_TIME),
excluded_users: z.array(zSnowflake).nullable().default(null),
excluded_message_regexes: z.array(zRegex(z.string())).nullable().default(null),
excluded_channels: z.array(zSnowflake).nullable().default(null),
excluded_categories: z.array(zSnowflake).nullable().default(null),
excluded_threads: z.array(zSnowflake).nullable().default(null),
exclude_bots: z.boolean().default(false),
excluded_roles: z.array(zSnowflake).nullable().default(null),
format: zLogFormats.default({}),
timestamp_format: z.string().nullable().default(null),
include_embed_timestamp: z.boolean().nullable().default(null),
});
export type TLogChannel = t.TypeOf<typeof LogChannel>;
export type TLogChannel = z.infer<typeof zLogChannel>;
const LogChannelMap = t.record(t.string, LogChannel);
export type TLogChannelMap = t.TypeOf<typeof LogChannelMap>;
const zLogChannelMap = z.record(zSnowflake, zLogChannel);
export type TLogChannelMap = z.infer<typeof zLogChannelMap>;
export const ConfigSchema = t.type({
channels: LogChannelMap,
format: t.intersection([
tLogFormats,
t.type({
timestamp: tBoundedString(0, 64), // Legacy/deprecated
}),
]),
ping_user: t.boolean, // Legacy/deprecated, if below is false mentions wont actually ping
allow_user_mentions: t.boolean,
timestamp_format: tBoundedString(0, 64),
include_embed_timestamp: t.boolean,
export const zLogsConfig = z.strictObject({
channels: zLogChannelMap,
format: z.intersection(zLogFormats, z.strictObject({
// Legacy/deprecated, use timestamp_format below instead
timestamp: zBoundedCharacters(0, 64).nullable(),
})),
// Legacy/deprecated, if below is false mentions wont actually ping. In case you really want the old behavior, set below to true
ping_user: z.boolean(),
allow_user_mentions: z.boolean(),
timestamp_format: z.string().nullable(),
include_embed_timestamp: z.boolean(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
// Hacky way of allowing a """null""" default value for config.format.timestamp
// The type cannot be made nullable properly because io-ts's intersection type still considers
// that it has to match the record type of tLogFormats, which includes string.
// Hacky way of allowing a """null""" default value for config.format.timestamp due to legacy io-ts reasons
export const FORMAT_NO_TIMESTAMP = "__NO_TIMESTAMP__";
export interface LogsPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zLogsConfig>;
state: {
guildLogs: GuildLogs;
savedMessages: GuildSavedMessages;

5
backend/src/plugins/MessageSaver/MessageSaverPlugin.ts
View file

@ -1,11 +1,10 @@
import { PluginOptions } from "knub";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
import { makeIoTsConfigParser } from "../../pluginUtils";
import { zeppelinGuildPlugin } from "../ZeppelinPluginBlueprint";
import { SaveMessagesToDBCmd } from "./commands/SaveMessagesToDB";
import { SavePinsToDBCmd } from "./commands/SavePinsToDB";
import { MessageCreateEvt, MessageDeleteBulkEvt, MessageDeleteEvt, MessageUpdateEvt } from "./events/SaveMessagesEvts";
import { ConfigSchema, MessageSaverPluginType } from "./types";
import { MessageSaverPluginType, zMessageSaverConfig } from "./types";
const defaultOptions: PluginOptions<MessageSaverPluginType> = {
config: {
@ -25,7 +24,7 @@ export const MessageSaverPlugin = zeppelinGuildPlugin<MessageSaverPluginType>()(
name: "message_saver",
showInDocs: false,
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zMessageSaverConfig.parse(input),
defaultOptions,
// prettier-ignore

9
backend/src/plugins/MessageSaver/types.ts
View file

@ -1,14 +1,13 @@
import * as t from "io-ts";
import { BasePluginType, guildPluginEventListener, guildPluginMessageCommand } from "knub";
import z from "zod";
import { GuildSavedMessages } from "../../data/GuildSavedMessages";
export const ConfigSchema = t.type({
can_manage: t.boolean,
export const zMessageSaverConfig = z.strictObject({
can_manage: z.boolean(),
});
export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
export interface MessageSaverPluginType extends BasePluginType {
config: TConfigSchema;
config: z.infer<typeof zMessageSaverConfig>;
state: {
savedMessages: GuildSavedMessages;
};

8
backend/src/plugins/ModActions/ModActionsPlugin.ts
View file

@ -6,7 +6,7 @@ import { onGuildEvent } from "../../data/GuildEvents";
import { GuildLogs } from "../../data/GuildLogs";
import { GuildMutes } from "../../data/GuildMutes";
import { GuildTempbans } from "../../data/GuildTempbans";
import { makeIoTsConfigParser, mapToPublicFn } from "../../pluginUtils";
import { mapToPublicFn } from "../../pluginUtils";
import { MINUTES, trimPluginDescription } from "../../utils";
import { CasesPlugin } from "../Cases/CasesPlugin";
import { LogsPlugin } from "../Logs/LogsPlugin";
@ -47,7 +47,7 @@ import { offModActionsEvent } from "./functions/offModActionsEvent";
import { onModActionsEvent } from "./functions/onModActionsEvent";
import { updateCase } from "./functions/updateCase";
import { warnMember } from "./functions/warnMember";
import { BanOptions, ConfigSchema, KickOptions, ModActionsPluginType, WarnOptions } from "./types";
import { BanOptions, KickOptions, ModActionsPluginType, WarnOptions, zModActionsConfig } from "./types";
const defaultOptions = {
config: {
@ -121,11 +121,11 @@ export const ModActionsPlugin = zeppelinGuildPlugin<ModActionsPluginType>()({
description: trimPluginDescription(`
This plugin contains the 'typical' mod actions such as warning, muting, kicking, banning, etc.
`),
configSchema: ConfigSchema,
configSchema: zModActionsConfig,
},
dependencies: () => [TimeAndDatePlugin, CasesPlugin, MutesPlugin, LogsPlugin],
configParser: makeIoTsConfigParser(ConfigSchema),
configParser: (input) => zModActionsConfig.parse(input),
defaultOptions,
events: [CreateBanCaseOnManualBanEvt, CreateUnbanCaseOnManualUnbanEvt, PostAlertOnMemberJoinEvt, AuditLogEvents],

Some files were not shown because too many files have changed in this diff Show more