Validation implementation

more light-weight than using a fully fledged library like avj,
and most likely more than sufficient to handle edge cases.

Author: WorldSEnder

src/hlsBinaries.ts

@@ -6,10 +6,11 @@ import * as path from 'path';
 import { promisify } from 'util';
 import { env, ExtensionContext, ProgressLocation, Uri, window, WorkspaceFolder } from 'vscode';
 import { downloadFile, executableExists, httpsGetSilently } from './utils';
+import * as validate from './validation';
 
 /** GitHub API release */
 interface IRelease {
-  assets: [IAsset];
+  assets: IAsset[];
   tag_name: string;
   prerelease: boolean;
 }
@@ -19,6 +20,21 @@ interface IAsset {
   name: string;
 }
 
+const assetValidator: validate.Validator<IAsset> = validate.object({
+  browser_download_url: validate.string(),
+  name: validate.string(),
+});
+
+const releaseValidator: validate.Validator<IRelease> = validate.object({
+  assets: validate.array(assetValidator),
+  tag_name: validate.string(),
+  prerelease: validate.boolean(),
+});
+
+const githubReleaseApiValidator: validate.Validator<IRelease[]> = validate.array(releaseValidator);
+
+const cachedReleaseValidator: validate.Validator<IRelease | null> = validate.optional(releaseValidator);
+
 // On Windows the executable needs to be stored somewhere with an .exe extension
 const exeExt = process.platform === 'win32' ? '.exe' : '';
 
@@ -141,7 +157,7 @@ async function getProjectGhcVersion(context: ExtensionContext, dir: string, rele
   return callWrapper(downloadedWrapper);
 }
 
-async function getLatestReleaseMetadata(context: ExtensionContext): Promise<IRelease | undefined> {
+async function getLatestReleaseMetadata(context: ExtensionContext): Promise<IRelease | null> {
   const opts: https.RequestOptions = {
     host: 'api.github.com',
     path: '/repos/haskell/haskell-language-server/releases',
@@ -150,7 +166,8 @@ async function getLatestReleaseMetadata(context: ExtensionContext): Promise<IRel
 
   try {
     const releaseInfo = await httpsGetSilently(opts);
-    const latestInfoParsed = (JSON.parse(releaseInfo) as IRelease[]).find((x) => !x.prerelease);
+    const latestInfoParsed =
+      validate.parseAndValidate(releaseInfo, githubReleaseApiValidator).find((x) => !x.prerelease) || null;
 
     // Cache the latest successfully fetched release information
     await promisify(fs.writeFile)(offlineCache, JSON.stringify(latestInfoParsed), { encoding: 'utf-8' });
@@ -160,7 +177,7 @@ async function getLatestReleaseMetadata(context: ExtensionContext): Promise<IRel
     try {
       const cachedInfo = await promisify(fs.readFile)(offlineCache, { encoding: 'utf-8' });
 
-      const cachedInfoParsed = JSON.parse(cachedInfo);
+      const cachedInfoParsed = validate.parseAndValidate(cachedInfo, cachedReleaseValidator);
       window.showWarningMessage(
         `Couldn't get the latest haskell-language-server releases from GitHub, used local cache instead:\n${githubError.message}`
       );

src/validation.ts

@@ -0,0 +1,188 @@
+// Open for other validation libraries, but I haven't found any that were small enough,
+// strongly typed and maintained.
+
+export interface IValidationError {
+  path: PropertyKey[];
+  message: string;
+}
+
+export type ValidationResult<T> =
+  | {
+      success: true;
+      value: T;
+    }
+  | {
+      success: false;
+      errors: IValidationError[];
+    };
+
+export type Validator<T> = (scrutinee: unknown) => ValidationResult<T>;
+
+function success<T>(t: T): ValidationResult<T> {
+  return {
+    success: true,
+    value: t,
+  };
+}
+function failure<T>(errors: IValidationError[]): ValidationResult<T> {
+  return {
+    success: false,
+    errors,
+  };
+}
+
+function typeGuard<T>(name: string, guard: (arg: unknown) => arg is T): Validator<T> {
+  return (scrutinee) => {
+    if (guard(scrutinee)) {
+      return success(scrutinee);
+    }
+    return failure([
+      {
+        path: [],
+        message: `expected a ${name}`,
+      },
+    ]);
+  };
+}
+
+export function string(): Validator<string> {
+  function stringGuard(arg: unknown): arg is string {
+    return typeof arg === 'string';
+  }
+  return typeGuard('string', stringGuard);
+}
+
+export function boolean(): Validator<boolean> {
+  function boolGuard(arg: unknown): arg is boolean {
+    return typeof arg === 'boolean';
+  }
+  return typeGuard('boolean', boolGuard);
+}
+
+function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown> {
+  return obj.hasOwnProperty(prop);
+}
+
+export function object<S>(schema: { [P in keyof S]: Validator<S[P]> }): Validator<{ [P in keyof S]: S[P] }> {
+  return (scrutinee) => {
+    if (typeof scrutinee !== 'object' || scrutinee === null) {
+      return failure([
+        {
+          path: [],
+          message: 'expected an object',
+        },
+      ]);
+    }
+
+    const errors: IValidationError[] = [];
+    let validationFailed = false;
+    for (const key in schema) {
+      if (!schema[key]) {
+        continue;
+      }
+
+      // If the deserialized value doesn't have the key, use `undefined` as a placeholder
+      // might get replaced with a default value
+      const existingSub = hasOwnProperty(scrutinee, key) ? scrutinee[key] : undefined;
+      const subResult = schema[key](existingSub);
+
+      if (subResult.success) {
+        Object.assign(scrutinee, { [key]: subResult.value });
+      } else {
+        subResult.errors.forEach((val) =>
+          errors.push({
+            path: [key, ...val.path],
+            message: val.message,
+          })
+        );
+        validationFailed = true;
+      }
+    }
+
+    if (!validationFailed) {
+      return {
+        success: true,
+        // when we get here, all properties in S have been validated and assigned, so
+        // this type assertion is okay.
+        value: scrutinee as { [P in keyof S]: S[P] },
+      };
+    }
+
+    return {
+      success: false,
+      errors,
+    };
+  };
+}
+
+export function array<S>(memberValidator: Validator<S>): Validator<S[]> {
+  return (scrutinee) => {
+    if (!(scrutinee instanceof Array)) {
+      return {
+        success: false,
+        errors: [
+          {
+            path: [],
+            message: 'expected an array',
+          },
+        ],
+      };
+    }
+
+    const errors: IValidationError[] = [];
+    let validationFailed = false;
+    for (let i = 0; i < scrutinee.length; ++i) {
+      const subResult = memberValidator(scrutinee[i]);
+      if (subResult.success) {
+        scrutinee[i] = subResult.value;
+      } else {
+        subResult.errors.forEach((val) =>
+          errors.push({
+            path: [i, ...val.path],
+            message: val.message,
+          })
+        );
+        validationFailed = true;
+      }
+    }
+
+    if (!validationFailed) {
+      return {
+        success: true,
+        value: scrutinee,
+      };
+    }
+
+    return {
+      success: false,
+      errors,
+    };
+  };
+}
+
+export function optional<T>(validator: Validator<T>): Validator<T | null> {
+  return (scrutinee) => {
+    if (scrutinee === null) {
+      return {
+        success: true,
+        value: null,
+      };
+    }
+    return validator(scrutinee);
+  };
+}
+
+export class ValidationError extends Error {
+  constructor(public errors: IValidationError[], message?: string) {
+    super(`validation failure: ${errors.length} errors`);
+  }
+}
+
+export function parseAndValidate<T>(text: string, validator: Validator<T>): T {
+  const value: unknown = JSON.parse(text);
+  const result = validator(value);
+  if (result.success) {
+    return result.value;
+  }
+  throw new ValidationError(result.errors);
+}

tsconfig.json

@@ -9,6 +9,7 @@
     "rootDir": ".",
     "noUnusedLocals": true,
     "strict": true,
+    "noImplicitAny": true,
     "noImplicitReturns": true,
     "noFallthroughCasesInSwitch": true,
     "strictNullChecks": true