@valbuild/server 0.21.2 → 0.22.0

package/src/ValModuleLoader.ts

@@ -3,7 +3,7 @@ import { getCompilerOptions } from "./getCompilerOptions";
 import type { IValFSHost } from "./ValFSHost";
 import { ValSourceFileHandler } from "./ValSourceFileHandler";
 import fs from "fs";
-
+import { transform } from "sucrase";
 const JsFileLookupMapping: [resolvedFileExt: string, replacements: string[]][] =
   [
     // NOTE: first one matching will be used
@@ -35,16 +35,26 @@ export const createModuleLoader = (
   return loader;
 };
 
+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
+
 export class ValModuleLoader {
+  private cache: Record<string, string>;
+  private cacheSize: number;
   constructor(
     public readonly projectRoot: string,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     private readonly compilerOptions: ts.CompilerOptions,
     private readonly sourceFileHandler: ValSourceFileHandler,
     private readonly host: IValFSHost = {
       ...ts.sys,
       writeFile: fs.writeFileSync,
-    }
-  ) {}
+    },
+    private readonly disableCache: boolean = false
+  ) {
+    this.cache = {};
+    this.cacheSize = 0;
+  }
 
   getModule(modulePath: string): string {
     if (!modulePath) {
@@ -54,16 +64,29 @@ export 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(

package/src/ValServer.ts

@@ -20,4 +20,5 @@ export interface ValServer {
   disable(req: express.Request, res: express.Response): Promise<void>;
 
   getTree(req: express.Request, res: express.Response): Promise<void>;
+  getFiles(req: express.Request, res: express.Response): Promise<void>;
 }

package/src/createRequestHandler.ts

@@ -22,5 +22,6 @@ export function createRequestHandler(valServer: ValServer): RequestHandler {
   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;
 }

package/src/patch/validation.ts

@@ -71,6 +71,7 @@ const OperationJSONT: z.ZodType<OperationJSONT> = z.discriminatedUnion("op", [
     .object({
       op: z.literal("file"),
       path: z.string(),
+      filePath: z.string(),
       value: z.string(),
     })
     .strict(),

package/src/patchValFile.ts

@@ -85,14 +85,6 @@ export const patchValFile = async (
     }
   }
 
-  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);

package/src/readValFile.ts

@@ -1,4 +1,4 @@
-import { ModuleId } from "@valbuild/core";
+import { ModuleId, SourcePath } from "@valbuild/core";
 import path from "path";
 import { QuickJSRuntime } from "quickjs-emscripten";
 import { SerializedModuleContent } from "./SerializedModuleContent";
@@ -36,6 +36,7 @@ globalThis.valModule = {
         error.stack
       );
       return {
+        path: id as SourcePath,
         errors: {
           invalidModuleId: id as ModuleId,
           fatal: [
@@ -59,13 +60,13 @@ globalThis.valModule = {
       } else {
         if (valModule.id !== id) {
           fatalErrors.push(
-            `Expected val id: '${id}' but got: '${valModule.id}'`
+            `Wrong val.content id! In the file of with: '${id}', found: '${valModule.id}'`
           );
         }
         if (!valModule?.schema) {
           fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
-        if (!valModule?.source) {
+        if (valModule?.source === undefined) {
           fatalErrors.push(`Expected val id: '${id}' to have a source`);
         }
       }
@@ -83,7 +84,7 @@ globalThis.valModule = {
         };
       }
       return {
-        path: valModule.id, // NOTE: we use path here, since SerializedModuleContent (maybe bad name?) can be used for whole modules as well as subparts of modules
+        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,
         errors,