Switch from ajv to io-ts for config validation; validate configs on save in the API/dashboard; start work on creating io-ts schemas for all plugins

src/api/guilds.ts

@@ -3,9 +3,11 @@ import passport from "passport";
 import { AllowedGuilds } from "../data/AllowedGuilds";
 import { requireAPIToken } from "./auth";
 import { ApiPermissions } from "../data/ApiPermissions";
-import { clientError, ok, unauthorized } from "./responses";
+import { clientError, error, ok, serverError, unauthorized } from "./responses";
 import { Configs } from "../data/Configs";
 import { ApiRoles } from "../data/ApiRoles";
+import { validateGuildConfig } from "../configValidator";
+import yaml, { YAMLException } from "js-yaml";
 
 export function initGuildsAPI(app: express.Express) {
   const guildAPIRouter = express.Router();
@@ -35,6 +37,28 @@ export function initGuildsAPI(app: express.Express) {
     const config = req.body.config;
     if (config == null) return clientError(res, "No config supplied");
 
+    // Validate config
+    let parsedConfig;
+    try {
+      parsedConfig = yaml.safeLoad(config);
+    } catch (e) {
+      if (e instanceof YAMLException) {
+        return error(res, e.message, 400);
+      }
+
+      console.error("Error when loading YAML: " + e.message);
+      return serverError(res, "Server error");
+    }
+
+    if (parsedConfig == null) {
+      parsedConfig = {};
+    }
+
+    const errors = validateGuildConfig(parsedConfig);
+    if (errors) {
+      return res.status(422).json({ errors });
+    }
+
     await configs.saveNewRevision(`guild-${req.params.guildId}`, config, req.user.userId);
     ok(res);
   });

src/api/responses.ts

@@ -8,7 +8,7 @@ export function error(res: Response, message: string, statusCode: number = 500)
   res.status(statusCode).json({ error: message });
 }
 
-export function serverError(res: Response, message: string) {
+export function serverError(res: Response, message = "Server error") {
   error(res, message, 500);
 }
 

src/configValidator.ts

@@ -0,0 +1,51 @@
+import * as t from "io-ts";
+import { IPluginOptions } from "knub";
+import { pipe } from "fp-ts/lib/pipeable";
+import { fold } from "fp-ts/lib/Either";
+import { PathReporter } from "io-ts/lib/PathReporter";
+import { availablePlugins } from "./plugins/availablePlugins";
+import { ZeppelinPlugin } from "./plugins/ZeppelinPlugin";
+import { validateStrict } from "./validatorUtils";
+
+const pluginNameToClass = new Map<string, typeof ZeppelinPlugin>();
+for (const pluginClass of availablePlugins) {
+  // @ts-ignore
+  pluginNameToClass.set(pluginClass.pluginName, pluginClass);
+}
+
+const guildConfigRootSchema = t.type({
+  prefix: t.string,
+  levels: t.record(t.string, t.number),
+  plugins: t.record(t.string, t.unknown),
+});
+const partialGuildConfigRootSchema = t.exact(t.partial(guildConfigRootSchema.props));
+
+const globalConfigRootSchema = t.type({
+  url: t.string,
+  owners: t.array(t.string),
+  plugins: t.record(t.string, t.unknown),
+});
+
+const partialMegaTest = t.partial({ name: t.string });
+
+export function validateGuildConfig(config: any): string[] | null {
+  const rootErrors = validateStrict(partialGuildConfigRootSchema, config);
+  if (rootErrors) return rootErrors;
+
+  if (config.plugins) {
+    for (const [pluginName, pluginOptions] of Object.entries(config.plugins)) {
+      if (!pluginNameToClass.has(pluginName)) {
+        return [`Unknown plugin: ${pluginName}`];
+      }
+
+      const pluginClass = pluginNameToClass.get(pluginName);
+      let pluginErrors = pluginClass.validateOptions(pluginOptions);
+      if (pluginErrors) {
+        pluginErrors = pluginErrors.map(err => `${pluginName}: ${err}`);
+        return pluginErrors;
+      }
+    }
+  }
+
+  return null;
+}

src/plugins/AutoReactionsPlugin.ts

@@ -5,20 +5,23 @@ import { GuildAutoReactions } from "../data/GuildAutoReactions";
 import { Message } from "eris";
 import { customEmojiRegex, errorMessage, isEmoji, successMessage } from "../utils";
 import { ZeppelinPlugin } from "./ZeppelinPlugin";
+import * as t from "io-ts";
 
-interface IAutoReactionsPluginConfig {
-  can_manage: boolean;
-}
+const configSchema = t.type({
+  can_manage: t.boolean,
+});
+type TConfigSchema = t.TypeOf<typeof configSchema>;
 
-export class AutoReactionsPlugin extends ZeppelinPlugin<IAutoReactionsPluginConfig> {
+export class AutoReactionsPlugin extends ZeppelinPlugin<TConfigSchema> {
   public static pluginName = "auto_reactions";
+  protected static configSchema = configSchema;
 
   protected savedMessages: GuildSavedMessages;
   protected autoReactions: GuildAutoReactions;
 
   private onMessageCreateFn;
 
-  getDefaultOptions(): IPluginOptions<IAutoReactionsPluginConfig> {
+  getDefaultOptions(): IPluginOptions<TConfigSchema> {
     return {
       config: {
         can_manage: false,

src/plugins/GlobalZeppelinPlugin.ts

@@ -0,0 +1,39 @@
+import { GlobalPlugin, IBasePluginConfig, IPluginOptions, logger } from "knub";
+import { PluginRuntimeError } from "../PluginRuntimeError";
+import * as t from "io-ts";
+import { pipe } from "fp-ts/lib/pipeable";
+import { fold } from "fp-ts/lib/Either";
+import { PathReporter } from "io-ts/lib/PathReporter";
+import { isSnowflake, isUnicodeEmoji, resolveMember, resolveUser, UnknownUser } from "../utils";
+import { Member, User } from "eris";
+import { performance } from "perf_hooks";
+import { validateStrict } from "../validatorUtils";
+
+const SLOW_RESOLVE_THRESHOLD = 1500;
+
+export class GlobalZeppelinPlugin<TConfig extends {} = IBasePluginConfig> extends GlobalPlugin<TConfig> {
+  protected static configSchema: t.TypeC<any>;
+  public static dependencies = [];
+
+  public static validateOptions(options: IPluginOptions): string[] | null {
+    // Validate config values
+    if (this.configSchema) {
+      if (options.config) {
+        const errors = validateStrict(this.configSchema, options.config);
+        if (errors) return errors;
+      }
+
+      if (options.overrides) {
+        for (const override of options.overrides) {
+          if (override.config) {
+            const errors = validateStrict(this.configSchema, override.config);
+            if (errors) return errors;
+          }
+        }
+      }
+    }
+
+    // No errors, return null
+    return null;
+  }
+}

src/plugins/MessageSaver.ts

@@ -2,12 +2,13 @@ import { Plugin, decorators as d, IPluginOptions } from "knub";
 import { GuildChannel, Message, TextChannel } from "eris";
 import { GuildSavedMessages } from "../data/GuildSavedMessages";
 import { successMessage } from "../utils";
+import { ZeppelinPlugin } from "./ZeppelinPlugin";
 
 interface IMessageSaverPluginConfig {
   can_manage: boolean;
 }
 
-export class MessageSaverPlugin extends Plugin<IMessageSaverPluginConfig> {
+export class MessageSaverPlugin extends ZeppelinPlugin<IMessageSaverPluginConfig> {
   public static pluginName = "message_saver";
 
   protected savedMessages: GuildSavedMessages;

src/plugins/ZeppelinPlugin.ts

@@ -1,15 +1,18 @@
 import { IBasePluginConfig, IPluginOptions, logger, Plugin } from "knub";
 import { PluginRuntimeError } from "../PluginRuntimeError";
-import Ajv, { ErrorObject } from "ajv";
+import * as t from "io-ts";
+import { pipe } from "fp-ts/lib/pipeable";
+import { fold } from "fp-ts/lib/Either";
+import { PathReporter } from "io-ts/lib/PathReporter";
 import { isSnowflake, isUnicodeEmoji, resolveMember, resolveUser, UnknownUser } from "../utils";
 import { Member, User } from "eris";
-
 import { performance } from "perf_hooks";
+import { validateStrict } from "../validatorUtils";
 
 const SLOW_RESOLVE_THRESHOLD = 1500;
 
 export class ZeppelinPlugin<TConfig extends {} = IBasePluginConfig> extends Plugin<TConfig> {
-  protected static configSchema: any;
+  protected static configSchema: t.TypeC<any>;
   public static dependencies = [];
 
   protected throwPluginRuntimeError(message: string) {
@@ -26,22 +29,19 @@ export class ZeppelinPlugin<TConfig extends {} = IBasePluginConfig> extends Plug
     return ourLevel > memberLevel;
   }
 
-  public static validateOptions(options: IPluginOptions): ErrorObject[] | null {
+  public static validateOptions(options: any): string[] | null {
     // Validate config values
     if (this.configSchema) {
-      const ajv = new Ajv();
-      const validate = ajv.compile(this.configSchema);
-
       if (options.config) {
-        const isValid = validate(options.config);
-        if (!isValid) return validate.errors;
+        const errors = validateStrict(this.configSchema, options.config);
+        if (errors) return errors;
       }
 
       if (options.overrides) {
         for (const override of options.overrides) {
           if (override.config) {
-            const isValid = validate(override.config);
-            if (!isValid) return validate.errors;
+            const errors = validateStrict(this.configSchema, override.config);
+            if (errors) return errors;
           }
         }
       }

src/validatorUtils.ts

@@ -0,0 +1,27 @@
+import * as t from "io-ts";
+import { pipe } from "fp-ts/lib/pipeable";
+import { fold } from "fp-ts/lib/Either";
+import { PathReporter } from "io-ts/lib/PathReporter";
+
+/**
+ * Validates the given value against the given schema while also disallowing extra properties
+ * See: https://github.com/gcanti/io-ts/issues/322
+ */
+export function validateStrict(schema: t.Type<any, any, any>, value: any): string[] | null {
+  const validationResult = schema.decode(value);
+  return pipe(
+    validationResult,
+    fold(
+      err => PathReporter.report(validationResult),
+      result => {
+        // Make sure there are no extra properties
+        if (JSON.stringify(value) !== JSON.stringify(result)) {
+          // TODO: Actually mention what the unknown property is
+          return ["Found unknown properties"];
+        }
+
+        return null;
+      },
+    ),
+  );
+}