@valbuild/server 0.15.0 → 0.16.1

package/dist/declarations/src/LocalValServer.d.ts

@@ -0,0 +1,22 @@
+import express from "express";
+import { Service } from "./Service.js";
+import { ValServer } from "./ValServer.js";
+export type LocalValServerOptions = {
+    service: Service;
+};
+export declare class LocalValServer implements ValServer {
+    readonly options: LocalValServerOptions;
+    constructor(options: LocalValServerOptions);
+    session(_req: express.Request, res: express.Response): Promise<void>;
+    getIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    patchIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    private badRequest;
+    commit(req: express.Request, res: express.Response): Promise<void>;
+    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>;
+}

package/dist/declarations/src/SerializedModuleContent.d.ts

@@ -1,7 +1,22 @@
-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 declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module"];
 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/dist/declarations/src/Service.d.ts

@@ -1,5 +1,6 @@
 import { QuickJSRuntime } from "quickjs-emscripten";
 import { Patch } from "@valbuild/core/patch";
+import { ValModuleLoader } from "./ValModuleLoader.js";
 import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
 import { IValFSHost } from "./ValFSHost.js";
 import { SerializedModuleContent } from "./SerializedModuleContent.js";
@@ -12,7 +13,7 @@ export type ServiceOptions = {
      */
     valConfigPath: string;
 };
-export declare function createService(projectRoot: string, opts: ServiceOptions, host?: IValFSHost): Promise<Service>;
+export declare function createService(projectRoot: string, opts: ServiceOptions, host?: IValFSHost, loader?: ValModuleLoader): Promise<Service>;
 export declare class Service {
     private readonly sourceFileHandler;
     private readonly runtime;

package/dist/declarations/src/createFixPatch.d.ts

@@ -0,0 +1,8 @@
+import { SourcePath, ValidationError } from "@valbuild/core";
+import { Patch } from "@valbuild/core/patch";
+export declare function createFixPatch(config: {
+    projectRoot: string;
+}, apply: boolean, sourcePath: SourcePath, validationError: ValidationError): Promise<{
+    patch: Patch;
+    remainingErrors: ValidationError[];
+} | undefined>;

package/dist/declarations/src/hosting.d.ts

@@ -66,6 +66,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;
 }>;
 export declare function createRequestListener(route: string, opts: Opts): RequestListener;
 export {};

package/dist/declarations/src/index.d.ts

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

package/dist/declarations/src/patch/validation.d.ts

@@ -0,0 +1,4 @@
+import type { PatchJSON as PatchJSONT } from "@valbuild/core/patch";
+import z from "zod";
+export declare const PatchJSON: z.ZodType<PatchJSONT>;
+export type PatchJSON = PatchJSONT;

package/dist/valbuild-server.cjs.dev.js

@@ -13,6 +13,7 @@ var express = require('express');
 var server = require('@valbuild/ui/server');
 var z = require('zod');
 var crypto = require('crypto');
+var sizeOf = require('image-size');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
@@ -22,6 +23,7 @@ var fs__default = /*#__PURE__*/_interopDefault(fs);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var z__default = /*#__PURE__*/_interopDefault(z);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var sizeOf__default = /*#__PURE__*/_interopDefault(sizeOf);
 
 class ValSyntaxError {
   constructor(message, node) {
@@ -571,41 +573,64 @@ 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(code,
     // Synthetic module name
     path__default["default"].join(path__default["default"].dirname(valConfigPath), "<val>"));
+    const fatalErrors = [];
     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,
+          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 = [];
       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 !== null && valModule !== void 0 && valModule.schema)) {
-          errors.push(`Expected val id: '${id}' to have a schema`);
+          fatalErrors.push(`Expected val id: '${id}' to have a schema`);
         }
         if (!(valModule !== null && valModule !== void 0 && 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 = false;
+      if (fatalErrors.length > 0) {
+        errors = {
+          invalidModuleId: valModule.id !== id ? id : undefined,
+          fatal: fatalErrors.map(message => ({
+            message
+          }))
+        };
+      }
+      if (valModule !== null && valModule !== void 0 && 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
+        // 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
+        schema: valModule.schema,
+        errors
       };
     }
   } finally {
@@ -752,7 +777,7 @@ class ValModuleLoader {
       // allowJs: true,
       // rootDir: this.compilerOptions.rootDir,
       module: ts__default["default"].ModuleKind.ESNext,
-      target: ts__default["default"].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__default["default"].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
     });
@@ -873,12 +898,11 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
 async function createService(projectRoot, opts, host = {
   ...ts__default["default"].sys,
   writeFile: fs__default["default"].writeFileSync
-}) {
+}, loader) {
   const compilerOptions = getCompilerOptions(projectRoot, host);
   const sourceFileHandler = new ValSourceFileHandler(projectRoot, compilerOptions, host);
-  const loader = new ValModuleLoader(projectRoot, compilerOptions, sourceFileHandler, host);
   const module = await quickjsEmscripten.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);
 }
 class Service {
@@ -891,12 +915,23 @@ class Service {
   }
   async get(moduleId, modulePath) {
     const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime);
-    const resolved = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-    return {
-      path: [moduleId, resolved.path].join("."),
-      schema: resolved.schema instanceof core.Schema ? resolved.schema.serialize() : resolved.schema,
-      source: resolved.source
-    };
+    if (valModule.source && valModule.schema) {
+      const resolved = core.Internal.resolvePath(modulePath, valModule.source, valModule.schema);
+      const sourcePath = [moduleId, resolved.path].join(".");
+      return {
+        path: sourcePath,
+        schema: resolved.schema instanceof core.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
+        } : false
+      };
+    } else {
+      return valModule;
+    }
   }
   async patch(moduleId, patch) {
     return patchValFile(moduleId, this.valConfigPath, patch, this.sourceFileHandler, this.runtime);
@@ -1158,8 +1193,9 @@ class ProxyValServer {
     }
   }
   async session(req, res) {
+    console.log("hit session");
     return this.withAuth(req, res, async data => {
-      const url = new URL("/api/val/auth/user/session", this.options.valBuildUrl);
+      const url = new URL(`/api/val/${this.options.valName}/auth/session`, this.options.valBuildUrl);
       const fetchRes = await fetch(url, {
         headers: this.getAuthHeaders(data.token, "application/json")
       });
@@ -1262,7 +1298,7 @@ class ProxyValServer {
     };
   }
   async consumeCode(code) {
-    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",
@@ -1288,7 +1324,7 @@ class ProxyValServer {
     });
   }
   getAuthorizeUrl(publicValApiRoute, token) {
-    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`));
     url.searchParams.set("state", token);
     return url.toString();
@@ -1444,6 +1480,10 @@ async function initHandlerOptions(route, opts) {
     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,
@@ -1451,7 +1491,8 @@ async function initHandlerOptions(route, opts) {
       valSecret: maybeValSecret,
       valBuildUrl,
       gitCommit: maybeGitCommit,
-      gitBranch: maybeGitBranch
+      gitBranch: maybeGitBranch,
+      valName: maybeValName
     };
   } else {
     const service = await createService(process.cwd(), opts);
@@ -1514,10 +1555,122 @@ class ValFSHost {
   }
 }
 
+// TODO: find a better name? transformFixesToPatch?
+async function createFixPatch(config, apply, sourcePath, validationError) {
+  async function getImageMetadata() {
+    const maybeRef = validationError.value && typeof validationError.value === "object" && core.FILE_REF_PROP in validationError.value && typeof validationError.value[core.FILE_REF_PROP] === "string" ? validationError.value[core.FILE_REF_PROP] : undefined;
+    if (!maybeRef) {
+      // TODO:
+      throw Error("Cannot fix image without a file reference");
+    }
+    const localFile = path__default["default"].join(config.projectRoot, maybeRef);
+    const buffer = fs__default["default"].readFileSync(localFile);
+    const sha256 = await getSHA256Hash(buffer);
+    const imageSize = sizeOf__default["default"](buffer);
+    return {
+      ...imageSize,
+      sha256
+    };
+  }
+  const remainingErrors = [];
+  const patch$1 = [];
+  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$1.push({
+              op: "replace",
+              path: patch.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$1.push({
+          op: "add",
+          path: patch.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: patch$1,
+    remainingErrors
+  };
+}
+const getSHA256Hash = async bits => {
+  const hashBuffer = await crypto__default["default"].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;
+};
+
+exports.LocalValServer = LocalValServer;
+exports.PatchJSON = PatchJSON;
 exports.Service = Service;
 exports.ValFSHost = ValFSHost;
 exports.ValModuleLoader = ValModuleLoader;
 exports.ValSourceFileHandler = ValSourceFileHandler;
+exports.createFixPatch = createFixPatch;
 exports.createRequestHandler = createRequestHandler;
 exports.createRequestListener = createRequestListener;
 exports.createService = createService;