@valbuild/server 0.21.2 → 0.22.0

package/dist/valbuild-server.esm.js

@@ -6,10 +6,12 @@ import { deepEqual, isNotRoot, PatchError, parseAndValidateArrayIndex, applyPatc
 import * as path from 'path';
 import path__default from 'path';
 import fs, { promises } from 'fs';
+import { transform } from 'sucrase';
 import express, { Router } from 'express';
 import { createRequestHandler as createRequestHandler$1 } from '@valbuild/ui/server';
 import z, { z as z$1 } from 'zod';
 import crypto from 'crypto';
+import { Readable } from 'stream';
 import sizeOf from 'image-size';
 
 class ValSyntaxError {
@@ -609,6 +611,7 @@ globalThis.valModule = {
       const error = result.error.consume(context.dump);
       console.error(`Fatal error reading val file: ${error.message}\n`, error.stack);
       return {
+        path: id,
         errors: {
           invalidModuleId: id,
           fatal: [{
@@ -624,12 +627,12 @@ globalThis.valModule = {
         fatalErrors.push(`Could not find any modules at: ${id}`);
       } else {
         if (valModule.id !== id) {
-          fatalErrors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
+          fatalErrors.push(`Wrong val.content id! In the file of with: '${id}', found: '${valModule.id}'`);
         }
         if (!(valModule !== null && valModule !== void 0 && valModule.schema)) {
           fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
-        if (!(valModule !== null && valModule !== void 0 && valModule.source)) {
+        if ((valModule === null || valModule === void 0 ? void 0 : valModule.source) === undefined) {
           fatalErrors.push(`Expected val id: '${id}' to have a source`);
         }
       }
@@ -649,7 +652,7 @@ globalThis.valModule = {
         };
       }
       return {
-        path: valModule.id,
+        path: valModule.id || id,
         // NOTE: we use path here, since SerializedModuleContent (maybe bad name?) can be used for whole modules as well as subparts of modules
         source: valModule.source,
         schema: valModule.schema,
@@ -703,9 +706,6 @@ const patchValFile = async (id, valConfigPath, patch, sourceFileHandler, runtime
       sourceFileHandler.writeFile("." + filePath, convertDataUrlToBase64(content).toString("binary"), "binary");
     }
   }
-  for (const [ref, patch] of Object.entries(derefRes.value.remotePatches)) {
-    throw Error(`Cannot update remote ${ref} with ${JSON.stringify(patch)}: not implemented`);
-  }
   sourceFileHandler.writeSourceFile(newSourceFile.value);
   return readValFile(id, valConfigPath, runtime);
 };
@@ -784,15 +784,23 @@ class ValSourceFileHandler {
 const JsFileLookupMapping = [
 // NOTE: first one matching will be used
 [".cjs.d.ts", [".esm.js", ".mjs.js"]], [".cjs.js", [".esm.js", ".mjs.js"]], [".cjs", [".mjs"]], [".d.ts", [".js", ".esm.js", ".mjs.js"]]];
+const MAX_CACHE_SIZE = 100 * 1024 * 1024; // 100 mb
+const MAX_OBJECT_KEY_SIZE = 2 ** 27; // https://stackoverflow.com/questions/13367391/is-there-a-limit-on-length-of-the-key-string-in-js-object
+
 class ValModuleLoader {
-  constructor(projectRoot, compilerOptions, sourceFileHandler, host = {
+  constructor(projectRoot,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  compilerOptions, sourceFileHandler, host = {
     ...ts.sys,
     writeFile: fs.writeFileSync
-  }) {
+  }, disableCache = false) {
     this.projectRoot = projectRoot;
     this.compilerOptions = compilerOptions;
     this.sourceFileHandler = sourceFileHandler;
     this.host = host;
+    this.disableCache = disableCache;
+    this.cache = {};
+    this.cacheSize = 0;
   }
   getModule(modulePath) {
     if (!modulePath) {
@@ -802,18 +810,31 @@ class ValModuleLoader {
     if (!code) {
       throw Error(`Could not read file "${modulePath}"`);
     }
-    return ts.transpile(code, {
-      ...this.compilerOptions,
-      jsx: ts.JsxEmit.React,
-      // allowJs: true,
-      // rootDir: this.compilerOptions.rootDir,
-      module: ts.ModuleKind.ESNext,
-      target: ts.ScriptTarget.ES2015 // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
-      // moduleResolution: ts.ModuleResolutionKind.NodeNext,
-      // target: ts.ScriptTarget.ES2020, // QuickJs runs in ES2020 so we must use that
-    });
-  }
+    let compiledCode;
+    if (this.cache[code] && !this.disableCache) {
+      // TODO: use hash instead of code as key
+      compiledCode = this.cache[code];
+    } else {
+      compiledCode = transform(code, {
+        filePath: modulePath,
+        disableESTransforms: true,
+        transforms: ["typescript"]
+      }).code;
+      if (!this.disableCache) {
+        if (this.cacheSize > MAX_CACHE_SIZE) {
+          console.warn("Cache size exceeded, clearing cache");
+          this.cache = {};
+          this.cacheSize = 0;
+        }
+        if (code.length < MAX_OBJECT_KEY_SIZE) {
+          this.cache[code] = compiledCode;
+          this.cacheSize += code.length + compiledCode.length; // code is mostly ASCII so 1 byte per char
+        }
+      }
+    }
 
+    return compiledCode;
+  }
   resolveModulePath(containingFilePath, requestedModuleName) {
     var _this$host$realpath, _this$host;
     let sourceFileName = this.sourceFileHandler.resolveSourceModulePath(containingFilePath, requestedModuleName);
@@ -973,11 +994,9 @@ class Service {
         path: sourcePath,
         schema: resolved.schema instanceof Schema ? resolved.schema.serialize() : resolved.schema,
         source: resolved.source,
-        errors: valModule.errors && valModule.errors.validation && valModule.errors.validation[sourcePath] ? {
-          validation: valModule.errors.validation[sourcePath] ? {
-            [sourcePath]: valModule.errors.validation[sourcePath]
-          } : undefined,
-          fatal: valModule.errors && valModule.errors.fatal ? valModule.errors.fatal : undefined
+        errors: valModule.errors && valModule.errors.validation ? {
+          validation: valModule.errors.validation || undefined,
+          fatal: valModule.errors.fatal || undefined
         } : false
       };
     } else {
@@ -1007,13 +1026,10 @@ function createRequestHandler(valServer) {
   router.get("/enable", valServer.enable.bind(valServer));
   router.get("/disable", valServer.disable.bind(valServer));
   router.get("/tree/*", valServer.getTree.bind(valServer));
+  router.get("/files/*", valServer.getFiles.bind(valServer));
   return router;
 }
 
-function getPathFromParams(params) {
-  return `/${params[0]}`;
-}
-
 const JSONValueT = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(JSONValueT), z.record(JSONValueT)]));
 
 /**
@@ -1051,6 +1067,7 @@ const OperationJSONT = z.discriminatedUnion("op", [z.object({
 }).strict(), z.object({
   op: z.literal("file"),
   path: z.string(),
+  filePath: z.string(),
   value: z.string()
 }).strict()]);
 const PatchJSON = z.array(OperationJSONT);
@@ -1117,10 +1134,61 @@ function encodeJwt(payload, sessionKey) {
 const VAL_SESSION_COOKIE = Internal.VAL_SESSION_COOKIE;
 const VAL_STATE_COOKIE = Internal.VAL_STATE_COOKIE;
 const VAL_ENABLED_COOKIE = Internal.VAL_ENABLE_COOKIE_NAME;
+class BrowserReadableStreamWrapper extends Readable {
+  constructor(readableStream) {
+    super();
+    this.reader = readableStream.getReader();
+  }
+  _read() {
+    this.reader.read().then(({
+      done,
+      value
+    }) => {
+      if (done) {
+        this.push(null); // No more data to read
+      } else {
+        this.push(Buffer.from(value));
+      }
+    }).catch(error => {
+      this.emit("error", error);
+    });
+  }
+}
 class ProxyValServer {
   constructor(options) {
     this.options = options;
   }
+  async getFiles(req, res) {
+    return this.withAuth(req, res, async data => {
+      const url = new URL(`/v1/files/${this.options.valName}/${req.params["0"]}`, this.options.valContentUrl);
+      if (typeof req.query.sha256 === "string") {
+        url.searchParams.append("sha256", req.query.sha256);
+      } else {
+        console.warn("Missing sha256 query param");
+      }
+      const fetchRes = await fetch(url, {
+        headers: this.getAuthHeaders(data.token)
+      });
+      const contentType = fetchRes.headers.get("content-type");
+      if (contentType !== null) {
+        res.setHeader("Content-Type", contentType);
+      }
+      const contentLength = fetchRes.headers.get("content-length");
+      if (contentLength !== null) {
+        res.setHeader("Content-Length", contentLength);
+      }
+      if (fetchRes.ok) {
+        if (fetchRes.body) {
+          new BrowserReadableStreamWrapper(fetchRes.body).pipe(res);
+        } else {
+          console.warn("No body in response");
+          res.sendStatus(500);
+        }
+      } else {
+        res.sendStatus(fetchRes.status);
+      }
+    });
+  }
   async authorize(req, res) {
     const {
       redirect_to
@@ -1214,10 +1282,18 @@ class ProxyValServer {
         schema,
         source
       } = req.query;
+      const commit = this.options.gitCommit;
+      if (!commit) {
+        res.status(401).json({
+          error: "Could not detect the git commit. Check if env is missing VAL_GIT_COMMIT."
+        });
+        return;
+      }
       const params = new URLSearchParams({
         patch: (patch === "true").toString(),
         schema: (schema === "true").toString(),
-        source: (source === "true").toString()
+        source: (source === "true").toString(),
+        commit
       });
       const url = new URL(`/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`, this.options.valContentUrl);
       const json = await fetch(url, {
@@ -1227,12 +1303,10 @@ class ProxyValServer {
     });
   }
   async postPatches(req, res) {
-    const {
-      commit
-    } = req.query;
-    if (typeof commit !== "string" || typeof commit === "undefined") {
+    const commit = this.options.gitCommit;
+    if (!commit) {
       res.status(401).json({
-        error: "Missing or invalid commit query param"
+        error: "Could not detect the git commit. Check if env is missing VAL_GIT_COMMIT."
       });
       return;
     }
@@ -1243,18 +1317,20 @@ class ProxyValServer {
       token
     }) => {
       // First validate that the body has the right structure
-      const patchJSON = PatchJSON.safeParse(req.body);
+      const patchJSON = z$1.record(PatchJSON).safeParse(req.body);
       if (!patchJSON.success) {
         res.status(401).json(patchJSON.error.issues);
         return;
       }
       // Then parse/validate
-      const patch = parsePatch(patchJSON.data);
-      if (result.isErr(patch)) {
-        res.status(401).json(patch.error);
-        return;
-      }
-      const url = new URL(`/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`, this.options.valContentUrl);
+      // TODO:
+      const patch = patchJSON.data;
+      // const patch = parsePatch(patchJSON.data);
+      // if (result.isErr(patch)) {
+      //   res.status(401).json(patch.error);
+      //   return;
+      // }
+      const url = new URL(`/v1/patches/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`, this.options.valContentUrl);
       // Proxy patch to val.build
       const fetchRes = await fetch(url, {
         method: "POST",
@@ -1535,7 +1611,8 @@ class LocalValServer {
       const modules = Object.fromEntries(serializedModuleContent.map(serializedModuleContent => {
         const module = {
           schema: serializedModuleContent.schema,
-          source: serializedModuleContent.source
+          source: serializedModuleContent.source,
+          errors: serializedModuleContent.errors
         };
         return [serializedModuleContent.path, module];
       }));
@@ -1543,9 +1620,7 @@ class LocalValServer {
         modules,
         git: this.options.git
       };
-      return walk(rootDir).then(async () => {
-        res.send(JSON.stringify(apiTreeResponse));
-      });
+      res.send(JSON.stringify(apiTreeResponse));
     } catch (err) {
       console.error(err);
       res.sendStatus(500);
@@ -1558,24 +1633,23 @@ class LocalValServer {
     return disable(req, res);
   }
   async postPatches(req, res) {
-    var _getPathFromParams;
-    const id = (_getPathFromParams = getPathFromParams(req.params)) === null || _getPathFromParams === void 0 ? void 0 : _getPathFromParams.replace("/~", "");
-
     // First validate that the body has the right structure
-    const patchJSON = PatchJSON.safeParse(req.body);
-    console.log("patch id", id, patchJSON);
+    const patchJSON = z$1.record(PatchJSON).safeParse(req.body);
     if (!patchJSON.success) {
       res.status(401).json(patchJSON.error.issues);
       return;
     }
-    // Then parse/validate
-    const patch = parsePatch(patchJSON.data);
-    if (result.isErr(patch)) {
-      res.status(401).json(patch.error);
-      return;
-    }
     try {
-      await this.options.service.patch(id, patch.value);
+      for (const moduleId in patchJSON.data) {
+        // Then parse/validate
+        // TODO: validate all and then fail instead:
+        const patch = parsePatch(patchJSON.data[moduleId]);
+        if (result.isErr(patch)) {
+          res.status(401).json(patch.error);
+          return;
+        }
+        await this.options.service.patch(moduleId, patch.value);
+      }
       res.json({});
     } catch (err) {
       if (err instanceof PatchError) {
@@ -1606,6 +1680,9 @@ class LocalValServer {
   logout(req, res) {
     return this.badRequest(req, res);
   }
+  getFiles(req, res) {
+    return this.badRequest(req, res);
+  }
 }
 
 async function _createRequestListener(route, opts) {

package/package.json

@@ -12,7 +12,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.21.2",
+  "version": "0.22.0",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "jest",
@@ -25,11 +25,12 @@
     "concurrently": "^7.6.0"
   },
   "dependencies": {
-    "@valbuild/core": "~0.21.2",
-    "@valbuild/ui": "~0.21.2",
+    "@valbuild/core": "~0.22.0",
+    "@valbuild/ui": "~0.22.0",
     "express": "^4.18.2",
     "image-size": "^1.0.2",
     "quickjs-emscripten": "^0.21.1",
+    "sucrase": "^3.34.0",
     "ts-morph": "^17.0.1",
     "typescript": "^4.9.4",
     "zod": "^3.20.6"

package/src/LocalValServer.ts

@@ -2,13 +2,13 @@ import express from "express";
 import { Service } from "./Service";
 import { result } from "@valbuild/core/fp";
 import { parsePatch, PatchError } from "@valbuild/core/patch";
-import { getPathFromParams } from "./expressHelpers";
 import { PatchJSON } from "./patch/validation";
 import { ValServer } from "./ValServer";
 import { ApiTreeResponse, ModuleId, ModulePath } from "@valbuild/core";
 import { disable, enable } from "./ProxyValServer";
 import { promises as fs } from "fs";
 import path from "path";
+import { z } from "zod";
 
 export type LocalValServerOptions = {
   service: Service;
@@ -80,6 +80,7 @@ export class LocalValServer implements ValServer {
             {
               schema: serializedModuleContent.schema,
               source: serializedModuleContent.source,
+              errors: serializedModuleContent.errors,
             };
           return [serializedModuleContent.path, module];
         })
@@ -88,9 +89,7 @@ export class LocalValServer implements ValServer {
         modules,
         git: this.options.git,
       };
-      return walk(rootDir).then(async () => {
-        res.send(JSON.stringify(apiTreeResponse));
-      });
+      res.send(JSON.stringify(apiTreeResponse));
     } catch (err) {
       console.error(err);
       res.sendStatus(500);
@@ -109,23 +108,24 @@ export class LocalValServer implements ValServer {
     req: express.Request<{ 0: string }>,
     res: express.Response
   ): Promise<void> {
-    const id = getPathFromParams(req.params)?.replace("/~", "");
-
     // First validate that the body has the right structure
-    const patchJSON = PatchJSON.safeParse(req.body);
-    console.log("patch id", id, patchJSON);
+    const patchJSON = z.record(PatchJSON).safeParse(req.body);
     if (!patchJSON.success) {
       res.status(401).json(patchJSON.error.issues);
       return;
     }
-    // Then parse/validate
-    const patch = parsePatch(patchJSON.data);
-    if (result.isErr(patch)) {
-      res.status(401).json(patch.error);
-      return;
-    }
+
     try {
-      await this.options.service.patch(id, patch.value);
+      for (const moduleId in patchJSON.data) {
+        // Then parse/validate
+        // TODO: validate all and then fail instead:
+        const patch = parsePatch(patchJSON.data[moduleId]);
+        if (result.isErr(patch)) {
+          res.status(401).json(patch.error);
+          return;
+        }
+        await this.options.service.patch(moduleId, patch.value);
+      }
       res.json({});
     } catch (err) {
       if (err instanceof PatchError) {
@@ -161,4 +161,7 @@ export class LocalValServer implements ValServer {
   logout(req: express.Request, res: express.Response): Promise<void> {
     return this.badRequest(req, res);
   }
+  getFiles(req: express.Request, res: express.Response): Promise<void> {
+    return this.badRequest(req, res);
+  }
 }

package/src/ProxyValServer.ts

@@ -2,11 +2,10 @@ import express from "express";
 import crypto from "crypto";
 import { decodeJwt, encodeJwt, getExpire } from "./jwt";
 import { PatchJSON } from "./patch/validation";
-import { result } from "@valbuild/core/fp";
 import { ValServer } from "./ValServer";
 import { z } from "zod";
-import { parsePatch } from "@valbuild/core/patch";
 import { Internal } from "@valbuild/core";
+import { Readable } from "stream";
 
 const VAL_SESSION_COOKIE = Internal.VAL_SESSION_COOKIE;
 const VAL_STATE_COOKIE = Internal.VAL_STATE_COOKIE;
@@ -25,9 +24,68 @@ export type ProxyValServerOptions = {
   valDisableRedirectUrl?: string;
 };
 
+class BrowserReadableStreamWrapper extends Readable {
+  private reader: ReadableStreamDefaultReader<Uint8Array>;
+
+  constructor(readableStream: ReadableStream<Uint8Array>) {
+    super();
+    this.reader = readableStream.getReader();
+  }
+
+  _read() {
+    this.reader
+      .read()
+      .then(({ done, value }) => {
+        if (done) {
+          this.push(null); // No more data to read
+        } else {
+          this.push(Buffer.from(value));
+        }
+      })
+      .catch((error) => {
+        this.emit("error", error);
+      });
+  }
+}
+
 export class ProxyValServer implements ValServer {
   constructor(readonly options: ProxyValServerOptions) {}
 
+  async getFiles(req: express.Request, res: express.Response): Promise<void> {
+    return this.withAuth(req, res, async (data) => {
+      const url = new URL(
+        `/v1/files/${this.options.valName}/${req.params["0"]}`,
+        this.options.valContentUrl
+      );
+      if (typeof req.query.sha256 === "string") {
+        url.searchParams.append("sha256", req.query.sha256 as string);
+      } else {
+        console.warn("Missing sha256 query param");
+      }
+      const fetchRes = await fetch(url, {
+        headers: this.getAuthHeaders(data.token),
+      });
+      const contentType = fetchRes.headers.get("content-type");
+      if (contentType !== null) {
+        res.setHeader("Content-Type", contentType);
+      }
+      const contentLength = fetchRes.headers.get("content-length");
+      if (contentLength !== null) {
+        res.setHeader("Content-Length", contentLength);
+      }
+      if (fetchRes.ok) {
+        if (fetchRes.body) {
+          new BrowserReadableStreamWrapper(fetchRes.body).pipe(res);
+        } else {
+          console.warn("No body in response");
+          res.sendStatus(500);
+        }
+      } else {
+        res.sendStatus(fetchRes.status);
+      }
+    });
+  }
+
   async authorize(req: express.Request, res: express.Response): Promise<void> {
     const { redirect_to } = req.query;
     if (typeof redirect_to !== "string") {
@@ -145,10 +203,19 @@ export class ProxyValServer implements ValServer {
   async getTree(req: express.Request, res: express.Response): Promise<void> {
     return this.withAuth(req, res, async (data) => {
       const { patch, schema, source } = req.query;
+      const commit = this.options.gitCommit;
+      if (!commit) {
+        res.status(401).json({
+          error:
+            "Could not detect the git commit. Check if env is missing VAL_GIT_COMMIT.",
+        });
+        return;
+      }
       const params = new URLSearchParams({
         patch: (patch === "true").toString(),
         schema: (schema === "true").toString(),
         source: (source === "true").toString(),
+        commit,
       });
       const url = new URL(
         `/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`,
@@ -165,9 +232,12 @@ export class ProxyValServer implements ValServer {
     req: express.Request<{ 0: string }>,
     res: express.Response
   ): Promise<void> {
-    const { commit } = req.query;
-    if (typeof commit !== "string" || typeof commit === "undefined") {
-      res.status(401).json({ error: "Missing or invalid commit query param" });
+    const commit = this.options.gitCommit;
+    if (!commit) {
+      res.status(401).json({
+        error:
+          "Could not detect the git commit. Check if env is missing VAL_GIT_COMMIT.",
+      });
       return;
     }
     const params = new URLSearchParams({
@@ -175,19 +245,21 @@ export class ProxyValServer implements ValServer {
     });
     this.withAuth(req, res, async ({ token }) => {
       // First validate that the body has the right structure
-      const patchJSON = PatchJSON.safeParse(req.body);
+      const patchJSON = z.record(PatchJSON).safeParse(req.body);
       if (!patchJSON.success) {
         res.status(401).json(patchJSON.error.issues);
         return;
       }
       // Then parse/validate
-      const patch = parsePatch(patchJSON.data);
-      if (result.isErr(patch)) {
-        res.status(401).json(patch.error);
-        return;
-      }
+      // TODO:
+      const patch = patchJSON.data;
+      // const patch = parsePatch(patchJSON.data);
+      // if (result.isErr(patch)) {
+      //   res.status(401).json(patch.error);
+      //   return;
+      // }
       const url = new URL(
-        `/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`,
+        `/v1/patches/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`,
         this.options.valContentUrl
       );
       // Proxy patch to val.build

package/src/SerializedModuleContent.ts

@@ -11,6 +11,7 @@ export const FATAL_ERROR_TYPES = [
   "invalid-id",
   "no-module",
 ] as const;
+export type FatalErrorType = (typeof FATAL_ERROR_TYPES)[number];
 
 export type SerializedModuleContent =
   | {
@@ -22,14 +23,14 @@ export type SerializedModuleContent =
   | {
       source?: Source;
       schema?: SerializedSchema;
-      path?: SourcePath;
+      path: SourcePath;
       errors: {
         invalidModuleId?: ModuleId;
         validation?: ValidationErrors;
         fatal?: {
           message: string;
-          stack?: string[];
-          type?: (typeof FATAL_ERROR_TYPES)[number];
+          stack?: string;
+          type?: FatalErrorType;
         }[];
       };
     };

package/src/Service.ts

@@ -22,9 +22,15 @@ export type ServiceOptions = {
   /**
    * Relative path to the val.config.js file from the root directory.
    *
-   * @example src/val.config
+   * @example "./val.config"
    */
   valConfigPath: string;
+  /**
+   * Disable cache for transpilation
+   *
+   * @default false
+   *    */
+  disableCache?: boolean;
 };
 
 export async function createService(
@@ -89,19 +95,10 @@ export class Service {
             : resolved.schema,
         source: resolved.source,
         errors:
-          valModule.errors &&
-          valModule.errors.validation &&
-          valModule.errors.validation[sourcePath]
+          valModule.errors && valModule.errors.validation
             ? {
-                validation: valModule.errors.validation[sourcePath]
-                  ? {
-                      [sourcePath]: valModule.errors.validation[sourcePath],
-                    }
-                  : undefined,
-                fatal:
-                  valModule.errors && valModule.errors.fatal
-                    ? valModule.errors.fatal
-                    : undefined,
+                validation: valModule.errors.validation || undefined,
+                fatal: valModule.errors.fatal || undefined,
               }
             : false,
       };