@valbuild/server 0.15.0 → 0.16.1

package/src/ProxyValServer.ts

@@ -18,6 +18,7 @@ export type ProxyValServerOptions = {
   valBuildUrl: string;
   gitCommit: string;
   gitBranch: string;
+  valName: string;
 };
 
 export class ProxyValServer implements ValServer {
@@ -112,9 +113,10 @@ export class ProxyValServer implements ValServer {
   }
 
   async session(req: express.Request, res: express.Response): Promise<void> {
+    console.log("hit session");
     return this.withAuth(req, res, async (data) => {
       const url = new URL(
-        "/api/val/auth/user/session",
+        `/api/val/${this.options.valName}/auth/session`,
         this.options.valBuildUrl
       );
       const fetchRes = await fetch(url, {
@@ -233,7 +235,10 @@ export class ProxyValServer implements ValServer {
     project: string;
     token: string;
   } | null> {
-    const url = new URL("/api/val/auth/user/token", this.options.valBuildUrl);
+    const url = new URL(
+      `/api/val/${this.options.valName}/auth/token`,
+      this.options.valBuildUrl
+    );
     url.searchParams.set("code", encodeURIComponent(code));
     return fetch(url, {
       method: "POST",
@@ -262,7 +267,10 @@ export class ProxyValServer implements ValServer {
   }
 
   private getAuthorizeUrl(publicValApiRoute: string, token: string): string {
-    const url = new URL("/authorize", this.options.valBuildUrl);
+    const url = new URL(
+      `/auth/${this.options.valName}/authorize`,
+      this.options.valBuildUrl
+    );
     url.searchParams.set(
       "redirect_uri",
       encodeURIComponent(`${publicValApiRoute}/callback`)

package/src/SerializedModuleContent.ts

@@ -1,8 +1,35 @@
-import { type Source, type SerializedSchema } from "@valbuild/core";
-import { type SourcePath } from "@valbuild/core/src/val";
+import {
+  type Source,
+  type SerializedSchema,
+  ValidationErrors,
+} from "@valbuild/core";
+import { ModuleId, type SourcePath } from "@valbuild/core/src/val";
 
-export type SerializedModuleContent = {
-  source: Source;
-  schema: SerializedSchema;
-  path: SourcePath;
-};
+export const FATAL_ERROR_TYPES = [
+  "no-schema",
+  "no-source",
+  "invalid-id",
+  "no-module",
+] as const;
+
+export type SerializedModuleContent =
+  | {
+      source: Source;
+      schema: SerializedSchema;
+      path: SourcePath;
+      errors: false;
+    }
+  | {
+      source?: Source;
+      schema?: SerializedSchema;
+      path?: SourcePath;
+      errors: {
+        invalidModuleId?: ModuleId;
+        validation?: ValidationErrors;
+        fatal?: {
+          message: string;
+          stack?: string[];
+          type?: (typeof FATAL_ERROR_TYPES)[number];
+        }[];
+      };
+    };

package/src/Service.ts

@@ -34,7 +34,8 @@ export async function createService(
   host: IValFSHost = {
     ...ts.sys,
     writeFile: fs.writeFileSync,
-  }
+  },
+  loader?: ValModuleLoader
 ): Promise<Service> {
   const compilerOptions = getCompilerOptions(projectRoot, host);
   const sourceFileHandler = new ValSourceFileHandler(
@@ -42,14 +43,12 @@ export async function createService(
     compilerOptions,
     host
   );
-  const loader = new ValModuleLoader(
-    projectRoot,
-    compilerOptions,
-    sourceFileHandler,
-    host
-  );
   const module = await newQuickJSWASMModule();
-  const runtime = await newValQuickJSRuntime(module, loader);
+  const runtime = await newValQuickJSRuntime(
+    module,
+    loader ||
+      new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host)
+  );
   return new Service(opts, sourceFileHandler, runtime);
 }
 
@@ -74,19 +73,40 @@ export class Service {
       this.runtime
     );
 
-    const resolved = Internal.resolvePath(
-      modulePath,
-      valModule.source,
-      valModule.schema
-    );
-    return {
-      path: [moduleId, resolved.path].join(".") as SourcePath,
-      schema:
-        resolved.schema instanceof Schema<SelectorSource>
-          ? resolved.schema.serialize()
-          : resolved.schema,
-      source: resolved.source,
-    };
+    if (valModule.source && valModule.schema) {
+      const resolved = Internal.resolvePath(
+        modulePath,
+        valModule.source,
+        valModule.schema
+      );
+      const sourcePath = [moduleId, resolved.path].join(".") as SourcePath;
+      return {
+        path: sourcePath,
+        schema:
+          resolved.schema instanceof Schema<SelectorSource>
+            ? 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,
+              }
+            : false,
+      };
+    } else {
+      return valModule;
+    }
   }
 
   async patch(

package/src/ValModuleLoader.ts

@@ -60,7 +60,7 @@ export class ValModuleLoader {
       // allowJs: true,
       // rootDir: this.compilerOptions.rootDir,
       module: ts.ModuleKind.ESNext,
-      target: ts.ScriptTarget.ES2020, // QuickJS supports a lot of ES2020: https://test262.report/, however not all cases are in that report (e.g. export const {} = {})
+      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
     });

package/src/createFixPatch.ts

@@ -0,0 +1,175 @@
+import { FILE_REF_PROP, 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";
+import crypto from "crypto";
+
+// 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 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,
+  };
+}
+
+const getSHA256Hash = async (bits: Uint8Array) => {
+  const hashBuffer = await crypto.subtle.digest("SHA-256", bits);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hash = hashArray
+    .map((item) => item.toString(16).padStart(2, "0"))
+    .join("");
+  return hash;
+};

package/src/hosting.ts

@@ -73,6 +73,14 @@ type ValServerOverrides = Partial<{
    * @example "https://app.val.build"
    */
   valBuildUrl: string;
+  /**
+   * The full name of this Val project.
+   *
+   * Typically this is set using the VAL_NAME env var.
+   *
+   * @example "myorg/my-project"
+   */
+  valName: string;
 }>;
 
 async function _createRequestListener(
@@ -119,6 +127,10 @@ async function initHandlerOptions(
     if (!maybeGitBranch) {
       throw new Error("VAL_GIT_BRANCH env var must be set in proxy mode");
     }
+    const maybeValName = opts.gitBranch || process.env.VAL_NAME;
+    if (!maybeValName) {
+      throw new Error("VAL_NAME env var must be set in proxy mode");
+    }
     return {
       mode: "proxy",
       route,
@@ -127,6 +139,7 @@ async function initHandlerOptions(
       valBuildUrl,
       gitCommit: maybeGitCommit,
       gitBranch: maybeGitBranch,
+      valName: maybeValName,
     };
   } else {
     const service = await createService(process.cwd(), opts);

package/src/index.ts

@@ -10,3 +10,6 @@ export type { IValFSHost } from "./ValFSHost";
 export type { ValFS } from "./ValFS";
 export { patchSourceFile } from "./patchValFile";
 export { formatSyntaxErrorTree } from "./patch/ts/syntax";
+export { LocalValServer } from "./LocalValServer";
+export { createFixPatch } from "./createFixPatch";
+export { PatchJSON } from "./patch/validation";

package/src/readValFile.ts

@@ -1,3 +1,4 @@
+import { ModuleId } from "@valbuild/core";
 import path from "path";
 import { QuickJSRuntime } from "quickjs-emscripten";
 import { SerializedModuleContent } from "./SerializedModuleContent";
@@ -16,6 +17,10 @@ globalThis.valModule = {
   id: valModule?.default && Internal.getValPath(valModule?.default),
   schema: valModule?.default && Internal.getSchema(valModule?.default)?.serialize(),
   source: valModule?.default && Internal.getRawSource(valModule?.default),
+  validation: valModule?.default && Internal.getSchema(valModule?.default)?.validate(
+    valModule?.default && Internal.getValPath(valModule?.default) || "/",
+    valModule?.default && Internal.getRawSource(valModule?.default)
+  )
 };
 `;
     const result = context.evalCode(
@@ -23,48 +28,61 @@ globalThis.valModule = {
       // Synthetic module name
       path.join(path.dirname(valConfigPath), "<val>")
     );
+    const fatalErrors: string[] = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
-      console.error("Got error", error); // TODO: use this to figure out how to strip out QuickJS specific errors and get the actual stack
-
-      throw new Error(
-        `Could not read val id: ${id}. Cause:\n${error.name}: ${error.message}${
-          error.stack ? error.stack : ""
-        }`
-      );
+      return {
+        errors: {
+          invalidModuleId: id as ModuleId,
+          fatal: [
+            {
+              message: `${error.name || "Unknown error"}: ${
+                error.message || "<no message>"
+              }`,
+              stack: error.stack,
+            },
+          ],
+        },
+      };
     } else {
       result.value.dispose();
       const valModule = context
         .getProp(context.global, "valModule")
         .consume(context.dump);
 
-      const errors: string[] = [];
-
       if (!valModule) {
-        errors.push(`Could not find any modules at: ${id}`);
+        fatalErrors.push(`Could not find any modules at: ${id}`);
       } else {
         if (valModule.id !== id) {
-          errors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
+          fatalErrors.push(
+            `Expected val id: '${id}' but got: '${valModule.id}'`
+          );
         }
         if (!valModule?.schema) {
-          errors.push(`Expected val id: '${id}' to have a schema`);
+          fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
         if (!valModule?.source) {
-          errors.push(`Expected val id: '${id}' to have a source`);
+          fatalErrors.push(`Expected val id: '${id}' to have a source`);
         }
       }
-
-      if (errors.length > 0) {
-        throw Error(
-          `While processing module of id: ${id}, we got the following errors:\n${errors.join(
-            "\n"
-          )}`
-        );
+      let errors: SerializedModuleContent["errors"] = false;
+      if (fatalErrors.length > 0) {
+        errors = {
+          invalidModuleId: valModule.id !== id ? (id as ModuleId) : undefined,
+          fatal: fatalErrors.map((message) => ({ message })),
+        };
+      }
+      if (valModule?.validation) {
+        errors = {
+          ...(errors ? errors : {}),
+          validation: valModule.validation,
+        };
       }
       return {
-        path: valModule.id, // This might not be the asked id/path, however, that should be handled further up in the call chain
+        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
         source: valModule.source,
         schema: valModule.schema,
+        errors,
       };
     }
   } finally {