@valbuild/server 0.26.0 → 0.27.0

package/src/ValFS.ts

@@ -1,22 +0,0 @@
-/**
- * A filesystem that can update and read files.
- * It does not support creating new files or directories.
- *
- */
-export interface ValFS {
-  readDirectory(
-    rootDir: string,
-    extensions: readonly string[],
-    excludes: readonly string[] | undefined,
-    includes: readonly string[],
-    depth?: number | undefined
-  ): readonly string[];
-
-  writeFile(filePath: string, data: string, encoding: "binary" | "utf8"): void;
-
-  fileExists(filePath: string): boolean;
-
-  readFile(filePath: string): string | undefined;
-
-  realpath(path: string): string;
-}

package/src/ValFSHost.ts

@@ -1,66 +0,0 @@
-import path from "path";
-import ts from "typescript";
-import { ValFS } from "./ValFS";
-
-/**
- * An implementation of methods in the various ts.*Host interfaces
- * that uses ValFS to resolve modules and read/write files.
- */
-export interface IValFSHost
-  extends ts.ParseConfigHost,
-    ts.ModuleResolutionHost {
-  useCaseSensitiveFileNames: boolean;
-
-  writeFile(fileName: string, text: string, encoding: "binary" | "utf8"): void;
-}
-
-export class ValFSHost implements IValFSHost {
-  constructor(
-    protected readonly valFS: ValFS,
-    protected readonly currentDirectory: string
-  ) {}
-
-  useCaseSensitiveFileNames = true;
-  readDirectory(
-    rootDir: string,
-    extensions: readonly string[],
-    excludes: readonly string[] | undefined,
-    includes: readonly string[],
-    depth?: number | undefined
-  ): readonly string[] {
-    return this.valFS.readDirectory(
-      rootDir,
-      extensions,
-      excludes,
-      includes,
-      depth
-    );
-  }
-
-  writeFile(fileName: string, text: string, encoding: "binary" | "utf8"): void {
-    this.valFS.writeFile(fileName, text, encoding);
-  }
-
-  getCurrentDirectory(): string {
-    return this.currentDirectory;
-  }
-
-  getCanonicalFileName(fileName: string): string {
-    if (path.isAbsolute(fileName)) {
-      return path.normalize(fileName);
-    }
-    return path.resolve(this.getCurrentDirectory(), fileName);
-  }
-
-  fileExists(fileName: string): boolean {
-    return this.valFS.fileExists(fileName);
-  }
-
-  readFile(fileName: string): string | undefined {
-    return this.valFS.readFile(fileName);
-  }
-
-  realpath(path: string): string {
-    return this.valFS.realpath(path);
-  }
-}

package/src/ValModuleLoader.test.ts

@@ -1,75 +0,0 @@
-import { createModuleLoader } from "./ValModuleLoader";
-import path from "path";
-
-const TestCaseDir = "../test/example-projects";
-const TestCases = [
-  { name: "basic-next-typescript", valConfigDir: ".", ext: "ts" },
-  {
-    name: "basic-next-src-typescript",
-    valConfigDir: "./src",
-    ext: "ts",
-  },
-  { name: "basic-next-javascript", valConfigDir: ".", ext: "js" },
-  { name: "typescript-description-files", valConfigDir: ".", ext: "js" },
-];
-
-describe("val module loader", () => {
-  test.each(TestCases)(
-    "resolution and smoke test transpilation for: $name",
-    async (testCase) => {
-      const rootDir = path.resolve(__dirname, TestCaseDir, testCase.name);
-      const loader = createModuleLoader(rootDir);
-      expect(
-        await loader.getModule(
-          loader.resolveModulePath(
-            `${testCase.valConfigDir}/val-system.${testCase.ext}`,
-            "./pages/blogs.val"
-          )
-        )
-      ).toContain("/pages/blogs");
-      expect(
-        await loader.getModule(
-          loader.resolveModulePath(
-            `${testCase.valConfigDir}/pages/blogs.val.${testCase.ext}`,
-            "../val.config"
-          )
-        )
-      ).toContain("@valbuild/core");
-    }
-  );
-
-  test("resolution based on baseDir / paths in tsconfig", () => {
-    const rootDir = path.resolve(
-      __dirname,
-      TestCaseDir,
-      "basic-next-src-typescript"
-    );
-    const moduleLoader = createModuleLoader(rootDir);
-
-    const containingFile = "./src/pages/blogs.val.ts";
-    const baseCase = moduleLoader.resolveModulePath(
-      containingFile,
-      "../val.config"
-    ); // tsconfig maps @ to src
-    const pathsMapping = moduleLoader.resolveModulePath(
-      containingFile,
-      "@/val.config"
-    ); // tsconfig maps @ to src
-    expect(baseCase).toBeDefined();
-    expect(baseCase).toEqual(pathsMapping);
-  });
-
-  test("resolution on .d.ts files", () => {
-    const rootDir = path.resolve(
-      __dirname,
-      TestCaseDir,
-      "typescript-description-files"
-    );
-    const moduleLoader = createModuleLoader(rootDir);
-
-    const containingFile = "./pages/blogs.val.js";
-    expect(
-      moduleLoader.resolveModulePath(containingFile, "../val.config")
-    ).toMatch(/val\.config\.js$/);
-  });
-});

package/src/ValModuleLoader.ts

@@ -1,158 +0,0 @@
-import ts from "typescript";
-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
-    [".cjs.d.ts", [".esm.js", ".mjs.js"]],
-    [".cjs.js", [".esm.js", ".mjs.js"]],
-    [".cjs", [".mjs"]],
-    [".d.ts", [".js", ".esm.js", ".mjs.js"]],
-  ];
-
-export const createModuleLoader = (
-  rootDir: string,
-  host: IValFSHost = {
-    ...ts.sys,
-    writeFile: fs.writeFileSync,
-  }
-): ValModuleLoader => {
-  const compilerOptions = getCompilerOptions(rootDir, host);
-  const sourceFileHandler = new ValSourceFileHandler(
-    rootDir,
-    compilerOptions,
-    host
-  );
-  const loader = new ValModuleLoader(
-    rootDir,
-    compilerOptions,
-    sourceFileHandler,
-    host
-  );
-  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) {
-      throw Error(`Illegal module path: "${modulePath}"`);
-    }
-    const code = this.host.readFile(modulePath);
-    if (!code) {
-      throw Error(`Could not read file "${modulePath}"`);
-    }
-    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: string,
-    requestedModuleName: string
-  ): string {
-    let sourceFileName = this.sourceFileHandler.resolveSourceModulePath(
-      containingFilePath,
-      requestedModuleName
-    );
-
-    if (requestedModuleName === "@vercel/stega") {
-      sourceFileName = this.sourceFileHandler
-        .resolveSourceModulePath(containingFilePath, "@vercel/stega")
-        .replace("stega/dist", "stega/dist/esm");
-    }
-    const matches = this.findMatchingJsFile(sourceFileName);
-    if (matches.match === false) {
-      throw Error(
-        `Could not find matching js file for module "${requestedModuleName}" requested by: "${containingFilePath}". Tried:\n${matches.tried.join(
-          "\n"
-        )}`
-      );
-    }
-    const filePath = matches.match;
-    // resolve all symlinks (preconstruct for example symlinks the dist folder)
-    const followedPath = this.host.realpath?.(filePath) ?? filePath;
-    if (!followedPath) {
-      throw Error(
-        `File path was empty: "${filePath}", containing file: "${containingFilePath}", requested module: "${requestedModuleName}"`
-      );
-    }
-    return followedPath;
-  }
-
-  private findMatchingJsFile(
-    filePath: string
-  ): { match: string } | { match: false; tried: string[] } {
-    let requiresReplacements = false;
-    for (const [currentEnding] of JsFileLookupMapping) {
-      if (filePath.endsWith(currentEnding)) {
-        requiresReplacements = true;
-        break;
-      }
-    }
-    // avoid unnecessary calls to fileExists if we don't need to replace anything
-    if (!requiresReplacements) {
-      if (this.host.fileExists(filePath)) {
-        return { match: filePath };
-      }
-    }
-    const tried = [];
-    for (const [currentEnding, replacements] of JsFileLookupMapping) {
-      if (filePath.endsWith(currentEnding)) {
-        for (const replacement of replacements) {
-          const newFilePath =
-            filePath.slice(0, -currentEnding.length) + replacement;
-          if (this.host.fileExists(newFilePath)) {
-            return { match: newFilePath };
-          } else {
-            tried.push(newFilePath);
-          }
-        }
-      }
-    }
-
-    return { match: false, tried: tried.concat(filePath) };
-  }
-}

package/src/ValQuickJSRuntime.ts

@@ -1,85 +0,0 @@
-import { JSModuleNormalizeResult, QuickJSWASMModule } from "quickjs-emscripten";
-import { ValModuleLoader } from "./ValModuleLoader";
-
-export async function newValQuickJSRuntime(
-  quickJSModule: Pick<QuickJSWASMModule, "newRuntime">,
-  moduleLoader: ValModuleLoader,
-  {
-    maxStackSize = 1024 * 640, // TODO: these were randomly chosen, we should figure out what the right values are:
-    memoryLimit = 1024 * 640,
-  }: {
-    maxStackSize?: number;
-    memoryLimit?: number;
-  } = {}
-) {
-  const runtime = quickJSModule.newRuntime();
-
-  runtime.setMaxStackSize(maxStackSize);
-  runtime.setMemoryLimit(memoryLimit);
-
-  runtime.setModuleLoader(
-    (modulePath) => {
-      try {
-        // Special cases to avoid loading the React packages since currently React does not have a ESM build:
-        // TODO: this is not stable, find a better way to do this
-        if (modulePath === "@valbuild/react") {
-          return {
-            value:
-              "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export function ValProvider() { throw Error(`Cannot use 'ValProvider' in this type of file`) }; export function ValRichText() { throw Error(`Cannot use 'ValRichText' in this type of file`)};",
-          };
-        }
-        if (modulePath === "@valbuild/react/stega") {
-          return {
-            value:
-              "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export const fetchVal = () => { throw Error(`Cannot use 'fetchVal' in this type of file`) }; export const autoTagJSX = () => { /* ignore */ };",
-          };
-        }
-        if (modulePath.startsWith("next")) {
-          return {
-            value:
-              "export default new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'next' in this file`) } } } )",
-          };
-        }
-        if (modulePath.startsWith("react")) {
-          return {
-            value:
-              "export default new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'react' in this file`) } } } )",
-          };
-        }
-        return { value: moduleLoader.getModule(modulePath) };
-      } catch (e) {
-        return {
-          error: Error(`Could not resolve module: '${modulePath}': `),
-        };
-      }
-    },
-    (baseModuleName, requestedName): JSModuleNormalizeResult => {
-      try {
-        if (requestedName === "@valbuild/react") {
-          return { value: requestedName };
-        }
-        if (requestedName === "@valbuild/react/stega") {
-          return { value: requestedName };
-        }
-        if (requestedName.startsWith("next")) {
-          return { value: requestedName };
-        }
-        if (requestedName.startsWith("react")) {
-          return { value: requestedName };
-        }
-        const modulePath = moduleLoader.resolveModulePath(
-          baseModuleName,
-          requestedName
-        );
-        return { value: modulePath };
-      } catch (e) {
-        console.debug(
-          `Could not resolve ${requestedName} in ${baseModuleName}`,
-          e
-        );
-        return { value: requestedName };
-      }
-    }
-  );
-  return runtime;
-}

package/src/ValServer.ts

@@ -1,24 +0,0 @@
-import express from "express";
-
-export interface ValServer {
-  authorize(req: express.Request, res: express.Response): Promise<void>;
-
-  callback(req: express.Request, res: express.Response): Promise<void>;
-
-  logout(req: express.Request, res: express.Response): Promise<void>;
-
-  session(req: express.Request, res: express.Response): Promise<void>;
-
-  postPatches(
-    req: express.Request<{ 0: string }>,
-    res: express.Response
-  ): Promise<void>;
-
-  commit(req: express.Request, res: express.Response): Promise<void>;
-
-  enable(req: express.Request, res: express.Response): Promise<void>;
-  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/ValSourceFileHandler.ts

@@ -1,57 +0,0 @@
-import ts from "typescript";
-import path from "path";
-import { IValFSHost } from "./ValFSHost";
-import fs from "fs";
-
-export class ValSourceFileHandler {
-  constructor(
-    private readonly projectRoot: string,
-    private readonly compilerOptions: ts.CompilerOptions,
-    private readonly host: IValFSHost = {
-      ...ts.sys,
-      writeFile: fs.writeFileSync,
-    }
-  ) {}
-
-  getSourceFile(filePath: string): ts.SourceFile | undefined {
-    const fileContent = this.host.readFile(filePath);
-    const scriptTarget = this.compilerOptions.target ?? ts.ScriptTarget.ES2020;
-    if (fileContent) {
-      return ts.createSourceFile(filePath, fileContent, scriptTarget);
-    }
-  }
-
-  writeSourceFile(sourceFile: ts.SourceFile) {
-    return this.writeFile(sourceFile.fileName, sourceFile.text, "utf8");
-  }
-
-  writeFile(filePath: string, content: string, encoding: "binary" | "utf8") {
-    this.host.writeFile(filePath, content, encoding);
-  }
-
-  resolveSourceModulePath(
-    containingFilePath: string,
-    requestedModuleName: string
-  ): string {
-    const resolutionRes = ts.resolveModuleName(
-      requestedModuleName,
-      path.isAbsolute(containingFilePath)
-        ? containingFilePath
-        : path.resolve(this.projectRoot, containingFilePath),
-      this.compilerOptions,
-      this.host,
-      undefined,
-      undefined,
-      ts.ModuleKind.ESNext
-    );
-    const resolvedModule = resolutionRes.resolvedModule;
-    if (!resolvedModule) {
-      throw Error(
-        `Could not resolve module "${requestedModuleName}", base: "${containingFilePath}": No resolved modules returned: ${JSON.stringify(
-          resolutionRes
-        )}`
-      );
-    }
-    return resolvedModule.resolvedFileName;
-  }
-}

package/src/createFixPatch.ts

@@ -1,170 +0,0 @@
-import {
-  FILE_REF_PROP,
-  Internal,
-  SourcePath,
-  ValidationError,
-} from "@valbuild/core";
-import { Patch, sourceToPatchPath } from "@valbuild/core/patch";
-import sizeOf from "image-size";
-import path from "path";
-import fs from "fs";
-
-// TODO: find a better name? transformFixesToPatch?
-export async function createFixPatch(
-  config: { projectRoot: string },
-  apply: boolean,
-  sourcePath: SourcePath,
-  validationError: ValidationError
-): Promise<{ patch: Patch; remainingErrors: ValidationError[] } | undefined> {
-  async function getImageMetadata() {
-    const maybeRef =
-      validationError.value &&
-      typeof validationError.value === "object" &&
-      FILE_REF_PROP in validationError.value &&
-      typeof validationError.value[FILE_REF_PROP] === "string"
-        ? validationError.value[FILE_REF_PROP]
-        : undefined;
-
-    if (!maybeRef) {
-      // TODO:
-      throw Error("Cannot fix image without a file reference");
-    }
-    const localFile = path.join(config.projectRoot, maybeRef);
-    const buffer = fs.readFileSync(localFile);
-    const sha256 = await Internal.getSHA256Hash(buffer);
-    const imageSize = sizeOf(buffer);
-    return {
-      ...imageSize,
-      sha256,
-    };
-  }
-  const remainingErrors: ValidationError[] = [];
-  const patch: Patch = [];
-  for (const fix of validationError.fixes || []) {
-    if (fix === "image:replace-metadata" || fix === "image:add-metadata") {
-      const imageMetadata = await getImageMetadata();
-      if (
-        imageMetadata.width === undefined ||
-        imageMetadata.height === undefined ||
-        imageMetadata.sha256 === undefined
-      ) {
-        remainingErrors.push({
-          ...validationError,
-          message: "Failed to get image metadata",
-          fixes: undefined,
-        });
-      } else if (fix === "image:replace-metadata") {
-        const currentValue = validationError.value;
-        const metadataIsCorrect =
-          // metadata is a prop that is an object
-          typeof currentValue === "object" &&
-          currentValue &&
-          "metadata" in currentValue &&
-          currentValue.metadata &&
-          typeof currentValue.metadata === "object" &&
-          // sha256 is correct
-          "sha256" in currentValue.metadata &&
-          currentValue.metadata.sha256 === imageMetadata.sha256 &&
-          // width is correct
-          "width" in currentValue.metadata &&
-          currentValue.metadata.width === imageMetadata.width &&
-          // height is correct
-          "height" in currentValue.metadata &&
-          currentValue.metadata.height === imageMetadata.height;
-
-        // skips if the metadata is already correct
-        if (!metadataIsCorrect) {
-          if (apply) {
-            patch.push({
-              op: "replace",
-              path: sourceToPatchPath(sourcePath).concat("metadata"),
-              value: {
-                width: imageMetadata.width,
-                height: imageMetadata.height,
-                sha256: imageMetadata.sha256,
-              },
-            });
-          } else {
-            if (
-              typeof currentValue === "object" &&
-              currentValue &&
-              "metadata" in currentValue &&
-              currentValue.metadata &&
-              typeof currentValue.metadata === "object"
-            ) {
-              if (
-                !("sha256" in currentValue.metadata) ||
-                currentValue.metadata.sha256 !== imageMetadata.sha256
-              ) {
-                remainingErrors.push({
-                  message:
-                    "Image metadata sha256 is incorrect! Found: " +
-                    ("sha256" in currentValue.metadata
-                      ? currentValue.metadata.sha256
-                      : "<empty>") +
-                    ". Expected: " +
-                    imageMetadata.sha256 +
-                    ".",
-                  fixes: undefined,
-                });
-              }
-              if (
-                !("width" in currentValue.metadata) ||
-                currentValue.metadata.width !== imageMetadata.width
-              ) {
-                remainingErrors.push({
-                  message:
-                    "Image metadata width is incorrect! Found: " +
-                    ("width" in currentValue.metadata
-                      ? currentValue.metadata.width
-                      : "<empty>") +
-                    ". Expected: " +
-                    imageMetadata.width,
-                  fixes: undefined,
-                });
-              }
-              if (
-                !("height" in currentValue.metadata) ||
-                currentValue.metadata.height !== imageMetadata.height
-              ) {
-                remainingErrors.push({
-                  message:
-                    "Image metadata height is incorrect! Found: " +
-                    ("height" in currentValue.metadata
-                      ? currentValue.metadata.height
-                      : "<empty>") +
-                    ". Expected: " +
-                    imageMetadata.height,
-                  fixes: undefined,
-                });
-              }
-            } else {
-              remainingErrors.push({
-                ...validationError,
-                message: "Image metadata is not an object!",
-                fixes: undefined,
-              });
-            }
-          }
-        }
-      } else if (fix === "image:add-metadata") {
-        patch.push({
-          op: "add",
-          path: sourceToPatchPath(sourcePath).concat("metadata"),
-          value: {
-            width: imageMetadata.width,
-            height: imageMetadata.height,
-            sha256: imageMetadata.sha256,
-          },
-        });
-      }
-    }
-  }
-  if (!validationError.fixes || validationError.fixes.length === 0) {
-    remainingErrors.push(validationError);
-  }
-  return {
-    patch,
-    remainingErrors,
-  };
-}

package/src/createRequestHandler.ts

@@ -1,27 +0,0 @@
-import express, { RequestHandler, Router } from "express";
-import { ValServer } from "./ValServer";
-import { createRequestHandler as createUIRequestHandler } from "@valbuild/ui/server";
-
-export function createRequestHandler(valServer: ValServer): RequestHandler {
-  const router = Router();
-
-  router.use("/static", createUIRequestHandler());
-  router.get("/session", valServer.session.bind(valServer));
-  router.get("/authorize", valServer.authorize.bind(valServer));
-  router.get("/callback", valServer.callback.bind(valServer));
-  router.get("/logout", valServer.logout.bind(valServer));
-  router.post<{ 0: string }>(
-    "/patches/*",
-    express.json({
-      type: "application/json",
-      limit: "10mb",
-    }),
-    valServer.postPatches.bind(valServer)
-  );
-  router.post("/commit", valServer.commit.bind(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;
-}

package/src/expressHelpers.ts

@@ -1,5 +0,0 @@
-import { SourcePath } from "@valbuild/core/src/val";
-
-export function getPathFromParams(params: { 0: string }): SourcePath {
-  return `/${params[0]}` as SourcePath;
-}