@valbuild/cli 0.97.7 → 0.99.0

package/src/runValidation.ts

@@ -181,45 +181,17 @@ export async function handleFileMetadata(
   return { success: true, shouldApplyPatch: true };
 }
 
-export async function handleRemoteFileUpload(
+// Shared upload core used by both the single-field (handleRemoteFileUpload)
+// and gallery (handleRemoteGalleryFileUpload) handlers. The two differ only in
+// how they derive the local file ref, metadata and serialized image/file
+// schema; everything from auth through upload is identical.
+async function uploadRemoteFileCore(
   ctx: FixHandlerContext,
+  fileRef: string,
+  metadata: Record<string, unknown> | undefined,
+  schema: SerializedImageSchema | SerializedFileSchema,
 ): Promise<FixHandlerResult> {
-  if (!ctx.fix) {
-    return {
-      success: false,
-      errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`,
-    };
-  }
-
-  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(
-    ctx.sourcePath,
-  );
-
-  if (!ctx.valModule.source || !ctx.valModule.schema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`,
-    };
-  }
-
-  const resolvedRemoteFileAtSourcePath = Internal.resolvePath(
-    modulePath,
-    ctx.valModule.source,
-    ctx.valModule.schema,
-  );
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fileRefProp = (resolvedRemoteFileAtSourcePath.source as any)?.[
-    FILE_REF_PROP
-  ];
-  if (!fileRefProp) {
-    return {
-      success: false,
-      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`,
-    };
-  }
-
-  const filePath = path.join(ctx.projectRoot, fileRefProp);
+  const filePath = path.join(ctx.projectRoot, fileRef);
   if (!ctx.fs.fileExists(filePath)) {
     return {
       success: false,
@@ -259,26 +231,6 @@ export async function handleRemoteFileUpload(
     };
   }
 
-  if (!resolvedRemoteFileAtSourcePath.schema) {
-    return {
-      success: false,
-      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`,
-    };
-  }
-
-  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
-  const fileSourceMetadata = Internal.isFile(actualRemoteFileSource)
-    ? actualRemoteFileSource.metadata
-    : undefined;
-  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
-
-  if (!resolveRemoteFileSchema) {
-    return {
-      success: false,
-      errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`,
-    };
-  }
-
   const projectName = ctx.project;
   let publicProjectId = ctx.publicProjectId;
   let remoteFileBuckets = ctx.remoteFileBuckets;
@@ -317,16 +269,6 @@ export async function handleRemoteFileUpload(
     };
   }
 
-  if (
-    resolveRemoteFileSchema.type !== "image" &&
-    resolveRemoteFileSchema.type !== "file"
-  ) {
-    return {
-      success: false,
-      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`,
-    };
-  }
-
   remoteFilesCounter += 1;
   const bucket =
     remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length];
@@ -361,10 +303,6 @@ export async function handleRemoteFileUpload(
   const fileHash = Internal.remote.getFileHash(fileBuffer);
   const coreVersion = Internal.VERSION.core || "unknown";
   const fileExt = getFileExt(filePath);
-  const schema = resolveRemoteFileSchema as
-    | SerializedImageSchema
-    | SerializedFileSchema;
-  const metadata = fileSourceMetadata;
   const ref = Internal.remote.createRemoteRef(ctx.remote.remoteHost, {
     publicProjectId,
     coreVersion,
@@ -399,7 +337,7 @@ export async function handleRemoteFileUpload(
 
   ctx.remoteFiles[ctx.sourcePath] = {
     ref,
-    metadata: fileSourceMetadata,
+    metadata,
   };
 
   return {
@@ -415,6 +353,177 @@ export async function handleRemoteFileUpload(
   };
 }
 
+export async function handleRemoteFileUpload(
+  ctx: FixHandlerContext,
+): Promise<FixHandlerResult> {
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`,
+    };
+  }
+
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(
+    ctx.sourcePath,
+  );
+
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`,
+    };
+  }
+
+  const resolvedRemoteFileAtSourcePath = Internal.resolvePath(
+    modulePath,
+    ctx.valModule.source,
+    ctx.valModule.schema,
+  );
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const fileRefProp = (resolvedRemoteFileAtSourcePath.source as any)?.[
+    FILE_REF_PROP
+  ];
+  if (!fileRefProp) {
+    return {
+      success: false,
+      errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`,
+    };
+  }
+
+  const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema;
+  if (!resolveRemoteFileSchema) {
+    return {
+      success: false,
+      errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`,
+    };
+  }
+
+  if (
+    resolveRemoteFileSchema.type !== "image" &&
+    resolveRemoteFileSchema.type !== "file"
+  ) {
+    return {
+      success: false,
+      errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`,
+    };
+  }
+
+  const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source;
+  const fileSourceMetadata = Internal.isFile(actualRemoteFileSource)
+    ? actualRemoteFileSource.metadata
+    : undefined;
+
+  return uploadRemoteFileCore(
+    ctx,
+    fileRefProp,
+    fileSourceMetadata,
+    resolveRemoteFileSchema,
+  );
+}
+
+// Gallery (s.images({ remote: true }) / s.files({ remote: true })) upload.
+// Unlike a single image/file field, a gallery entry is keyed by its local file
+// path and the value is bare metadata (no FileSource), so we derive the file
+// ref from the key and synthesize the image/file schema from the record's
+// media options.
+export async function handleRemoteGalleryFileUpload(
+  ctx: FixHandlerContext,
+): Promise<FixHandlerResult> {
+  if (!ctx.fix) {
+    return {
+      success: false,
+      // No sourcePath in the message: the reported location already points at it.
+      errorMessage: `Remote file needs to be uploaded (use --fix to upload)`,
+    };
+  }
+
+  const fix = ctx.validationError.fixes?.[0];
+  const mediaType = fix === "files:upload-remote" ? "file" : "image";
+
+  // The gallery entry is keyed by its local file path; validateMediaKey carries
+  // that key as the error value.
+  const fileRef = ctx.validationError.value;
+  if (typeof fileRef !== "string") {
+    return {
+      success: false,
+      errorMessage: `Expected a local file path for gallery entry at ${ctx.sourcePath}`,
+    };
+  }
+
+  const [, modulePath] = Internal.splitModuleFilePathAndModulePath(
+    ctx.sourcePath,
+  );
+
+  if (!ctx.valModule.source || !ctx.valModule.schema) {
+    return {
+      success: false,
+      errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`,
+    };
+  }
+
+  const resolved = Internal.resolvePath(
+    modulePath,
+    ctx.valModule.source,
+    ctx.valModule.schema,
+  );
+  const entrySource = resolved.source;
+  const metadata =
+    entrySource &&
+    typeof entrySource === "object" &&
+    !Array.isArray(entrySource)
+      ? (entrySource as Record<string, unknown>)
+      : undefined;
+
+  // The gallery item schema is an ObjectSchema, not an image/file schema, so
+  // synthesize the serialized image/file schema (matching how single fields
+  // serialize) for the remote ref's validation hash.
+  //
+  // `accept`/`directory` come from the RECORD that holds the entry, resolved
+  // from the entry's PARENT path - not from the module root, which is only the
+  // record when the gallery is the whole module. A nested gallery
+  // (s.object({ gallery: s.images(...) })) would otherwise synthesize a schema
+  // with no options and bake a validation hash into the remote ref that can
+  // never validate, so a mismatch fails fast instead of uploading.
+  const [, parentModulePath] = Internal.splitModuleFilePathAndModulePath(
+    Internal.parentOfSourcePath(ctx.sourcePath),
+  );
+  const recordSchema = Internal.resolvePath(
+    parentModulePath,
+    ctx.valModule.source,
+    ctx.valModule.schema,
+  ).schema;
+  if (recordSchema?.type !== "record") {
+    return {
+      success: false,
+      errorMessage: `Expected a gallery record at the parent of ${ctx.sourcePath}, got ${
+        recordSchema?.type ?? "nothing"
+      }`,
+    };
+  }
+  const { accept, directory } = recordSchema;
+  const schema: SerializedImageSchema | SerializedFileSchema =
+    mediaType === "image"
+      ? {
+          type: "image",
+          opt: false,
+          options: {
+            ...(accept ? { accept } : {}),
+            ...(directory ? { directory } : {}),
+          },
+        }
+      : {
+          type: "file",
+          opt: false,
+          options: {
+            ...(accept ? { accept } : {}),
+          },
+        };
+
+  return uploadRemoteFileCore(ctx, fileRef, metadata, schema);
+}
+
 export async function handleRemoteFileDownload(
   ctx: FixHandlerContext,
 ): Promise<FixHandlerResult> {
@@ -479,6 +588,17 @@ export async function handleUniqueFolderCheck(
   return { success: true };
 }
 
+// Maps a gallery key to its on-disk local path. Remote galleries key uploaded
+// entries by a remote URL while keeping the file on disk; everything else is
+// already a local path and is returned unchanged.
+function remoteKeyToLocalPath(key: string): string {
+  const remoteRefRes = Internal.remote.splitRemoteRef(key);
+  if (remoteRefRes.status === "success") {
+    return `/${remoteRefRes.filePath}`;
+  }
+  return key;
+}
+
 export async function handleCheckAllFiles(
   ctx: FixHandlerContext,
 ): Promise<FixHandlerResult> {
@@ -500,7 +620,12 @@ export async function handleCheckAllFiles(
       errorMessage: `Could not get source for ${ctx.sourcePath}`,
     };
   }
-  const trackedFiles = new Set(Object.keys(source as Record<string, unknown>));
+  // Gallery entries are keyed by their file path. Remote galleries key uploaded
+  // entries by a remote URL, but the file is kept on disk at its local path, so
+  // normalize remote-URL keys back to that local path for the on-disk checks.
+  const trackedFiles = new Set(
+    Object.keys(source as Record<string, unknown>).map(remoteKeyToLocalPath),
+  );
 
   // Check that all tracked files exist on disk
   const missingTrackedFiles = [...trackedFiles].filter((f) => {
@@ -558,6 +683,8 @@ export const currentFixHandlers: Record<
   "file:add-metadata": handleFileMetadata,
   "image:upload-remote": handleRemoteFileUpload,
   "file:upload-remote": handleRemoteFileUpload,
+  "images:upload-remote": handleRemoteGalleryFileUpload,
+  "files:upload-remote": handleRemoteGalleryFileUpload,
   "image:download-remote": handleRemoteFileDownload,
   "file:download-remote": handleRemoteFileDownload,
   "image:check-remote": handleRemoteFileCheck,

package/src/utils/evalValConfigFile.ts

@@ -1,100 +1,6 @@
-import path from "path";
-import fs from "fs/promises";
-import vm from "node:vm";
-import ts from "typescript"; // TODO: make this dependency optional (only required if the file is val.config.ts not val.config.js)
-import z from "zod";
-import { ValConfig } from "@valbuild/core";
-import { createRequire } from "node:module";
-
-const ValConfigSchema = z.object({
-  project: z.string().optional(),
-  root: z.string().optional(),
-  files: z
-    .object({
-      directory: z.string().refine(
-        (val): val is `/public` | `/public/${string}` =>
-          (val === "/public" ||
-            (val.startsWith("/public/") && !val.endsWith("/"))) &&
-          // Reject path traversal so the directory cannot escape /public
-          !val
-            .split("/")
-            .some((segment) => segment === "." || segment === ".."),
-        {
-          message:
-            "files.directory must start with '/public', must not end with '/' and must not contain '.' or '..' segments",
-        },
-      ),
-    })
-    .optional(),
-  gitCommit: z.string().optional(),
-  gitBranch: z.string().optional(),
-  defaultTheme: z.union([z.literal("light"), z.literal("dark")]).optional(),
-  ai: z
-    .object({
-      commitMessages: z
-        .object({
-          disabled: z.boolean().optional(),
-        })
-        .optional(),
-    })
-    .optional(),
-});
-
-export async function evalValConfigFile(
-  projectRoot: string,
-  configFileName: string,
-): Promise<ValConfig | null> {
-  const valConfigPath = path.join(projectRoot, configFileName);
-
-  let code: string | null = null;
-  try {
-    code = await fs.readFile(valConfigPath, "utf-8");
-  } catch {
-    //
-  }
-  if (!code) {
-    return null;
-  }
-
-  const transpiled = ts.transpileModule(code, {
-    compilerOptions: {
-      target: ts.ScriptTarget.ES2020,
-      module: ts.ModuleKind.CommonJS,
-      esModuleInterop: true,
-    },
-    fileName: valConfigPath,
-  });
-
-  const projectRootRequire = createRequire(valConfigPath);
-  const exportsObj = {};
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const sandbox: Record<string, any> = {
-    exports: exportsObj,
-    module: { exports: exportsObj },
-    require: projectRootRequire, // NOTE: this is a security risk, but this code is running in the users own environment at the CLI level
-    __filename: valConfigPath,
-    __dirname: projectRoot,
-    console,
-    process,
-  };
-  sandbox.global = sandbox;
-
-  const context = vm.createContext(sandbox);
-  const script = new vm.Script(transpiled.outputText, {
-    filename: valConfigPath,
-  });
-  script.runInContext(context);
-  const valConfig = sandbox.module.exports.config;
-  if (!valConfig) {
-    throw Error(
-      `Val config file at path: '${valConfigPath}' must export a config object. Got: ${valConfig}`,
-    );
-  }
-  const result = ValConfigSchema.safeParse(valConfig);
-  if (!result.success) {
-    throw Error(
-      `Val config file at path: '${valConfigPath}' has invalid schema: ${result.error.message}`,
-    );
-  }
-  return result.data;
-}
+/**
+ * Moved to `@valbuild/server` so that the CLI and
+ * `@valbuild/language-server` resolve project config through the same code.
+ * Re-exported here to keep existing CLI imports working.
+ */
+export { evalValConfigFile, findAndEvalValConfigFile } from "@valbuild/server";

package/src/validate.ts

@@ -4,7 +4,7 @@ import fs from "fs/promises";
 import { glob } from "fast-glob";
 import { DEFAULT_CONTENT_HOST, DEFAULT_VAL_REMOTE_HOST } from "@valbuild/core";
 import { getSettings, uploadRemoteFile } from "@valbuild/server";
-import { evalValConfigFile } from "./utils/evalValConfigFile";
+import { findAndEvalValConfigFile } from "./utils/evalValConfigFile";
 import { createDefaultValFSHost, runValidation } from "./runValidation";
 import {
   sourcePathToCodeFrame,
@@ -49,9 +49,7 @@ export async function validate({
   // errors found. Re-reads config and val files each call so it always reflects
   // the latest state on disk (used both for one-shot and watch mode).
   async function runOnce(): Promise<number> {
-    const valConfigFile =
-      (await evalValConfigFile(projectRoot, "val.config.ts")) ||
-      (await evalValConfigFile(projectRoot, "val.config.js"));
+    const valConfigFile = await findAndEvalValConfigFile(projectRoot);
 
     const resolvedValConfigFile = valConfigFile
       ? {