feat: update to djs 14.19.3, node 22, zod 4

Author: Dragory

.nvmrc

@@ -1 +1 @@
-18
+22

backend/package.json

@@ -29,7 +29,7 @@
     "migrate-rollback-prod": "npm run migrate-rollback",
     "migrate-rollback-dev": "npm run build && npm run migrate-rollback",
     "validate-active-configs": "node --enable-source-maps dist/validateActiveConfigs.js > ../config-errors.txt",
-    "export-config-json-schema": "node --enable-source-maps dist/exportSchemas.js > ../config-schema.json",
+    "export-config-json-schema": "node --enable-source-maps dist/exportSchemas.js",
     "test": "npm run build && npm run run-tests",
     "run-tests": "ava",
     "test-watch": "tsc-watch --build --onSuccess \"npx ava\""
@@ -41,15 +41,15 @@
     "cors": "^2.8.5",
     "cross-env": "^7.0.3",
     "deep-diff": "^1.0.2",
-    "discord.js": "^14.14.1",
+    "discord.js": "^14.19.3",
     "dotenv": "^4.0.0",
     "emoji-regex": "^8.0.0",
     "escape-string-regexp": "^1.0.5",
     "express": "^4.19.2",
     "fp-ts": "^2.0.1",
     "humanize-duration": "^3.15.0",
     "js-yaml": "^4.1.0",
-    "knub": "^32.0.0-next.21",
+    "knub": "^32.0.0-next.23",
     "knub-command-manager": "^9.1.0",
     "last-commit-log": "^2.1.0",
     "lodash-es": "^4.17.21",
@@ -76,7 +76,7 @@
     "uuid": "^9.0.0",
     "yawn-yaml": "github:dragory/yawn-yaml#string-number-fix-build",
     "zlib-sync": "^0.1.7",
-    "zod": "^3.7.2"
+    "zod": "^3.25.17"
   },
   "devDependencies": {
     "@types/cors": "^2.8.5",

backend/src/RegExpRunner.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "events";
+import { EventEmitter } from "node:events";
 import { CooldownManager } from "knub";
 import { RegExpWorker, TimeoutError } from "regexp-worker";
 import { MINUTES, SECONDS } from "./utils.js";

backend/src/SimpleCache.ts

@@ -46,7 +46,7 @@ export class SimpleCache<T = any> {
     });
 
     if (this.maxItems && this.store.size > this.maxItems) {
-      const keyToDelete = this.store.keys().next().value;
+      const keyToDelete = this.store.keys().next().value!;
       this.store.delete(keyToDelete);
     }
   }

backend/src/api/docs.ts

@@ -1,97 +1,90 @@
 import express from "express";
-import z from "zod";
+import z from "zod/v4";
 import { availableGuildPlugins } from "../plugins/availablePlugins.js";
 import { ZeppelinGuildPluginInfo } from "../types.js";
 import { indentLines } from "../utils.js";
 import { notFound } from "./responses.js";
 
-function isZodObject(schema: z.ZodTypeAny): schema is z.ZodObject<any> {
-  return schema._def.typeName === "ZodObject";
+function isZodObject(schema: z.ZodType): schema is z.ZodObject<any> {
+  return schema.def.type === "object";
 }
 
-function isZodRecord(schema: z.ZodTypeAny): schema is z.ZodRecord<any> {
-  return schema._def.typeName === "ZodRecord";
+function isZodRecord(schema: z.ZodType): schema is z.ZodRecord<any> {
+  return schema.def.type === "record";
 }
 
-function isZodEffects(schema: z.ZodTypeAny): schema is z.ZodEffects<any, any> {
-  return schema._def.typeName === "ZodEffects";
+function isZodOptional(schema: z.ZodType): schema is z.ZodOptional<any> {
+  return schema.def.type === "optional";
 }
 
-function isZodOptional(schema: z.ZodTypeAny): schema is z.ZodOptional<any> {
-  return schema._def.typeName === "ZodOptional";
+function isZodArray(schema: z.ZodType): schema is z.ZodArray<any> {
+  return schema.def.type === "array";
 }
 
-function isZodArray(schema: z.ZodTypeAny): schema is z.ZodArray<any> {
-  return schema._def.typeName === "ZodArray";
+function isZodUnion(schema: z.ZodType): schema is z.ZodUnion<any> {
+  return schema.def.type === "union";
 }
 
-function isZodUnion(schema: z.ZodTypeAny): schema is z.ZodUnion<any> {
-  return schema._def.typeName === "ZodUnion";
+function isZodNullable(schema: z.ZodType): schema is z.ZodNullable<any> {
+  return schema.def.type === "nullable";
 }
 
-function isZodNullable(schema: z.ZodTypeAny): schema is z.ZodNullable<any> {
-  return schema._def.typeName === "ZodNullable";
+function isZodDefault(schema: z.ZodType): schema is z.ZodDefault<any> {
+  return schema.def.type === "default";
 }
 
-function isZodDefault(schema: z.ZodTypeAny): schema is z.ZodDefault<any> {
-  return schema._def.typeName === "ZodDefault";
+function isZodLiteral(schema: z.ZodType): schema is z.ZodLiteral<any> {
+  return schema.def.type === "literal";
 }
 
-function isZodLiteral(schema: z.ZodTypeAny): schema is z.ZodLiteral<any> {
-  return schema._def.typeName === "ZodLiteral";
+function isZodIntersection(schema: z.ZodType): schema is z.ZodIntersection<any, any> {
+  return schema.def.type === "intersection";
 }
 
-function isZodIntersection(schema: z.ZodTypeAny): schema is z.ZodIntersection<any, any> {
-  return schema._def.typeName === "ZodIntersection";
-}
-
-function formatZodConfigSchema(schema: z.ZodTypeAny) {
+function formatZodConfigSchema(schema: z.ZodType) {
   if (isZodObject(schema)) {
     return (
       `{\n` +
       Object.entries(schema._def.shape())
-        .map(([k, value]) => indentLines(`${k}: ${formatZodConfigSchema(value as z.ZodTypeAny)}`, 2))
+        .map(([k, value]) => indentLines(`${k}: ${formatZodConfigSchema(value as z.ZodType)}`, 2))
         .join("\n") +
       "\n}"
     );
   }
   if (isZodRecord(schema)) {
-    return "{\n" + indentLines(`[string]: ${formatZodConfigSchema(schema._def.valueType)}`, 2) + "\n}";
-  }
-  if (isZodEffects(schema)) {
-    return formatZodConfigSchema(schema._def.schema);
+    return "{\n" + indentLines(`[string]: ${formatZodConfigSchema(schema.valueType as z.ZodType)}`, 2) + "\n}";
   }
   if (isZodOptional(schema)) {
-    return `Optional<${formatZodConfigSchema(schema._def.innerType)}>`;
+    return `Optional<${formatZodConfigSchema(schema.def.innerType)}>`;
   }
   if (isZodArray(schema)) {
-    return `Array<${formatZodConfigSchema(schema._def.type)}>`;
+    return `Array<${formatZodConfigSchema(schema.def.element)}>`;
   }
   if (isZodUnion(schema)) {
     return schema._def.options.map((t) => formatZodConfigSchema(t)).join(" | ");
   }
   if (isZodNullable(schema)) {
-    return `Nullable<${formatZodConfigSchema(schema._def.innerType)}>`;
+    return `Nullable<${formatZodConfigSchema(schema.def.innerType)}>`;
   }
   if (isZodDefault(schema)) {
-    return formatZodConfigSchema(schema._def.innerType);
+    return formatZodConfigSchema(schema.def.innerType);
   }
   if (isZodLiteral(schema)) {
-    return schema._def.value;
+    return schema.def.values;
   }
   if (isZodIntersection(schema)) {
-    return [formatZodConfigSchema(schema._def.left), formatZodConfigSchema(schema._def.right)].join(" & ");
+    return [formatZodConfigSchema(schema.def.left as z.ZodType), formatZodConfigSchema(schema.def.right as z.ZodType)].join(" & ");
   }
-  if (schema._def.typeName === "ZodString") {
+  if (schema.def.type === "string") {
     return "string";
   }
-  if (schema._def.typeName === "ZodNumber") {
+  if (schema.def.type === "number") {
     return "number";
   }
-  if (schema._def.typeName === "ZodBoolean") {
+  if (schema.def.type === "boolean") {
     return "boolean";
   }
-  if (schema._def.typeName === "ZodNever") {
+  if (schema.def.type === "never") {
     return "never";
   }
   return "unknown";

backend/src/api/guilds/importExport.ts

@@ -1,7 +1,7 @@
 import { ApiPermissions } from "@zeppelinbot/shared/apiPermissions.js";
 import express, { Request, Response } from "express";
 import moment from "moment-timezone";
-import { z } from "zod";
+import { z } from "zod/v4";
 import { GuildCases } from "../../data/GuildCases.js";
 import { Case } from "../../data/entities/Case.js";
 import { MINUTES } from "../../utils.js";

backend/src/configValidator.ts

@@ -1,5 +1,5 @@
 import { BaseConfig, ConfigValidationError, GuildPluginBlueprint, PluginConfigManager } from "knub";
-import { ZodError } from "zod";
+import { ZodError } from "zod/v4";
 import { availableGuildPlugins } from "./plugins/availablePlugins.js";
 import { zZeppelinGuildConfig } from "./types.js";
 import { formatZodIssue } from "./utils/formatZodIssue.js";

backend/src/env.ts

@@ -1,7 +1,7 @@
 import dotenv from "dotenv";
 import fs from "fs";
 import path from "path";
-import { z } from "zod";
+import { z } from "zod/v4";
 import { rootDir } from "./paths.js";
 
 const envType = z.object({

backend/src/exportSchemas.ts

@@ -1,21 +1,89 @@
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { z } from "zod/v4";
 import { availableGuildPlugins } from "./plugins/availablePlugins.js";
 import { zZeppelinGuildConfig } from "./types.js";
+import { deepPartial } from "./utils/zodDeepPartial.js";
+import fs from "node:fs";
+
+const basePluginOverrideCriteriaSchema = z.strictObject({
+  channel: z
+    .union([z.string(), z.array(z.string())])
+    .nullable()
+    .optional(),
+  category: z
+    .union([z.string(), z.array(z.string())])
+    .nullable()
+    .optional(),
+  level: z
+    .union([z.string(), z.array(z.string())])
+    .nullable()
+    .optional(),
+  user: z
+    .union([z.string(), z.array(z.string())])
+    .nullable()
+    .optional(),
+  role: z
+    .union([z.string(), z.array(z.string())])
+    .nullable()
+    .optional(),
+  thread: z
+    .union([z.string(), z.array(z.string())])
+    .nullable()
+    .optional(),
+  is_thread: z.boolean().nullable().optional(),
+  thread_type: z.literal(["public", "private"]).nullable().optional(),
+  extra: z.any().optional(),
+});
+
+const pluginOverrideCriteriaSchema = basePluginOverrideCriteriaSchema.extend({
+  get zzz_dummy_property_do_not_use() {
+    return pluginOverrideCriteriaSchema.optional();
+  },
+  get all() {
+    return z.array(pluginOverrideCriteriaSchema).optional();
+  },
+  get any() {
+    return z.array(pluginOverrideCriteriaSchema).optional();
+  },
+  get not() {
+    return pluginOverrideCriteriaSchema.optional();
+  },
+});
+
+const outputPath = process.argv[2];
+if (!outputPath) {
+  console.error("Output path required");
+  process.exit(1);
+}
+
+const partialConfigs = new Map<any, z.ZodType>();
+function getPartialConfig(configSchema: z.ZodType) {
+  if (!partialConfigs.has(configSchema)) {
+    partialConfigs.set(configSchema, deepPartial(configSchema));
+  }
+  return partialConfigs.get(configSchema)!;
+}
+
+function overrides(configSchema: z.ZodType): z.ZodType {
+  const partialConfig = getPartialConfig(configSchema);
+  return pluginOverrideCriteriaSchema.extend({
+    config: partialConfig,
+  });
+}
 
 const pluginSchemaMap = availableGuildPlugins.reduce((map, pluginInfo) => {
-  map[pluginInfo.plugin.name] = pluginInfo.docs.configSchema;
+  map[pluginInfo.plugin.name] = z.object({
+    config: pluginInfo.docs.configSchema.optional(),
+    overrides: overrides(pluginInfo.docs.configSchema).optional(),
+  });
   return map;
 }, {});
 
-const fullSchema = zZeppelinGuildConfig.omit({ plugins: true }).merge(
-  z.strictObject({
-    plugins: z.strictObject(pluginSchemaMap).partial(),
-  }),
-);
+const fullSchema = zZeppelinGuildConfig.omit({ plugins: true }).extend({
+  plugins: z.strictObject(pluginSchemaMap).partial().optional(),
+});
 
-const jsonSchema = zodToJsonSchema(fullSchema);
+const jsonSchema = z.toJSONSchema(fullSchema, { io: "input", cycles: "ref" });
 
-console.log(JSON.stringify(jsonSchema, null, 2));
+fs.writeFileSync(outputPath, JSON.stringify(jsonSchema, null, 2), { encoding: "utf8" });
 
 process.exit(0);

backend/src/index.ts

@@ -12,7 +12,6 @@ import {
   TextChannel,
   ThreadChannel,
 } from "discord.js";
-import { EventEmitter } from "events";
 import { Knub, PluginError, PluginLoadError, PluginNotLoadedError } from "knub";
 import moment from "moment-timezone";
 import { performance } from "perf_hooks";
@@ -252,9 +251,8 @@ connect().then(async () => {
       GatewayIntentBits.GuildVoiceStates,
     ],
   });
-  // FIXME: TS doesn't see Client as a child of EventEmitter for some reason
-  // If you're here because of an error from TS 5.5.2, see https://github.com/discordjs/discord.js/issues/10358
-  (client as unknown as EventEmitter).setMaxListeners(200);
+
+  client.setMaxListeners(200);
 
   const safe429DecayInterval = 5 * SECONDS;
   const safe429MaxCount = 5;