@valbuild/server 0.102.0 → 0.103.0

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

@@ -1,4 +1,4 @@
-import { FileMetadata, FileSource, ImageMetadata, ModuleFilePath, PatchId, RemoteSource, Schema, SelectorSource, SerializedSchema, Source, SourcePath, ValConfig, ValModules, ValidationError } from "@valbuild/core";
+import { MediaSource, FileMetadata, FileSource, ImageMetadata, ModuleFilePath, PatchId, Schema, SelectorSource, SerializedSchema, Source, SourcePath, ValConfig, ValModules, ValidationError } from "@valbuild/core";
 import { result } from "@valbuild/core/fp";
 import { JSONValue, ParentRef, Patch, PatchError } from "@valbuild/core/patch";
 import { ValSyntaxError, ValSyntaxErrorTree } from "./patch/ts/syntax.js";
@@ -225,9 +225,9 @@ export declare abstract class ValOps {
             validations: Record<SourcePath, ValidationError[]>;
         }>;
         files: Record<SourcePath, FileSource>;
-        remoteFiles: Record<SourcePath, RemoteSource>;
+        remoteFiles: Record<SourcePath, MediaSource>;
     }>;
-    validateRemoteFiles(schemas: Schemas, sources: Sources, remoteFiles: Record<SourcePath, RemoteSource>): Promise<Record<SourcePath, ValidationError[]>>;
+    validateRemoteFiles(schemas: Schemas, sources: Sources, remoteFiles: Record<SourcePath, MediaSource>): Promise<Record<SourcePath, ValidationError[]>>;
     validateFiles(schemas: Schemas, sources: Sources, files: Record<SourcePath, FileSource>, fileLastUpdatedByPatchId?: PatchAnalysis["fileLastUpdatedByPatchId"]): Promise<Record<SourcePath, ValidationError[]>>;
     /**
      * Applies the pending patches to the source files so they can be committed.

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

@@ -1,8 +1,19 @@
 import { FileMetadata, ImageMetadata, SerializedSchema, Source, SourcePath, ValidationError } from "@valbuild/core";
-import { Patch } from "@valbuild/core/patch";
+import { JSONValue, Patch } from "@valbuild/core/patch";
 export type FixPatchRemainingError = ValidationError & {
     sourcePath?: SourcePath;
 };
+/**
+ * A whole media value, for the fixes that replace one outright.
+ *
+ * The three remote fixes each wrote this shape out by hand, and one of them was
+ * left behind when the shape changed. One name, so the next change cannot miss a
+ * site.
+ *
+ * `path` last is deliberate: it is the field the fix is about, and a stray
+ * `path` inside the metadata must not win over it.
+ */
+export declare function mediaValue(path: string, metadata: unknown): Record<string, JSONValue>;
 export declare function createFixPatch(config: {
     projectRoot: string;
     remoteHost: string;

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

@@ -0,0 +1,162 @@
+/**
+ * The fix handlers behind `val validate --fix`, and the editor quick fixes that
+ * must agree with it.
+ *
+ * ## Why this lives in `@valbuild/server`
+ *
+ * A fix is two layers. `createFixPatch` is the second: given a validation
+ * error it produces a patch. The first is everything that has to happen before a
+ * patch can be produced — read the file, check it is actually on disk, extract
+ * metadata, pick a remote bucket, upload the bytes, download them back. That
+ * layer used to live in `packages/cli/src/runValidation.ts`, which made it
+ * reachable only from the CLI: `@valbuild/cli` exports nothing but `./cli`, and
+ * `@valbuild/language-server` cannot depend on it anyway without creating a
+ * cycle (the CLI depends on the language server).
+ *
+ * The consequence was that an editor could offer the fixes needing no
+ * precondition and had to reimplement or skip the rest. Both happened: the
+ * VS Code extension grew its own remote-upload client, and the language server
+ * declined to offer remote fixes at all.
+ *
+ * So the layer sits here, next to `createFixPatch`, and the CLI and the language
+ * server are both callers. {@link FixHandlerContext} is deliberately made of
+ * things any caller already has — a `Service`, an `IValFSHost`, a project root —
+ * rather than of CLI concepts.
+ *
+ * What stays in the CLI is the driver: the `runValidation` async generator that
+ * walks every module, decides what to report, and renders it to a terminal.
+ */
+import { ModuleFilePath, SourcePath, ValidationFix } from "@valbuild/core";
+import type { Service } from "./Service.js";
+import type { IValFSHost } from "./ValFSHost.js";
+export type { IValFSHost };
+export type IValRemote = {
+    remoteHost: string;
+    getSettings(projectName: string, options: {
+        pat: string;
+    }): Promise<{
+        success: true;
+        data: {
+            publicProjectId: string;
+            remoteFileBuckets: {
+                bucket: string;
+            }[];
+        };
+    } | {
+        success: false;
+        message: string;
+    }>;
+    uploadFile(project: string, bucket: string, fileHash: string, fileExt: string | undefined, fileBuffer: Buffer, options: {
+        pat: string;
+    }): Promise<{
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    }>;
+};
+export type ValModule = Awaited<ReturnType<Service["get"]>>;
+export type ValidationError = {
+    message: string;
+    value?: unknown;
+    fixes?: ValidationFix[];
+    keyError?: boolean;
+};
+export type FixHandlerContext = {
+    sourcePath: SourcePath;
+    validationError: ValidationError;
+    valModule: ValModule;
+    projectRoot: string;
+    fix: boolean;
+    service: Service;
+    valFiles: string[];
+    moduleFilePath: ModuleFilePath;
+    file: string;
+    fs: IValFSHost;
+    remoteFiles: Record<SourcePath, {
+        ref: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    publicProjectId?: string;
+    remoteFileBuckets?: string[];
+    remoteFilesCounter: number;
+    remote: IValRemote;
+    project: string | undefined;
+};
+export type FixHandlerResult = {
+    success: boolean;
+    errorMessage?: string;
+    shouldApplyPatch?: boolean;
+    appliedFix?: boolean;
+    fixableErrorMessage?: string;
+    publicProjectId?: string;
+    remoteFileBuckets?: string[];
+    remoteFilesCounter?: number;
+    events?: ValidationEvent[];
+};
+export type FixHandler = (ctx: FixHandlerContext) => Promise<FixHandlerResult>;
+export type ValidationEvent = {
+    type: "file-valid";
+    file: string;
+    durationMs: number;
+} | {
+    type: "file-error-count";
+    file: string;
+    errorCount: number;
+    durationMs: number;
+} | {
+    type: "validation-error";
+    sourcePath: string;
+    message: string;
+    keyError?: boolean;
+} | {
+    type: "validation-fixable-error";
+    sourcePath: string;
+    message: string;
+    fixable: boolean;
+    keyError?: boolean;
+} | {
+    type: "unknown-fix";
+    sourcePath: string;
+    fixes: string[];
+    keyError?: boolean;
+} | {
+    type: "unregistered-module";
+    file: string;
+} | {
+    type: "fix-applied";
+    file: string;
+    sourcePath: string;
+} | {
+    type: "fatal-error";
+    file: string;
+    message: string;
+} | {
+    type: "remote-uploading";
+    ref: string;
+} | {
+    type: "remote-uploaded";
+    ref: string;
+} | {
+    type: "remote-already-uploaded";
+    filePath: string;
+} | {
+    type: "remote-downloading";
+    sourcePath: string;
+} | {
+    type: "summary-errors";
+    count: number;
+} | {
+    type: "summary-success";
+};
+export declare function handleFileMetadata(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteFileUpload(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteGalleryFileUpload(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteFileDownload(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleRemoteFileCheck(): Promise<FixHandlerResult>;
+export declare function handleUniqueFolderCheck(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleCheckAllFiles(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare function handleJsonValuesExtractEntry(ctx: FixHandlerContext): Promise<FixHandlerResult>;
+export declare const currentFixHandlers: Record<Exclude<ValidationFix, "keyof:check-keys" | "router:check-route">, FixHandler>;
+export declare const fixHandlers: Record<string, FixHandler>;
+export declare function createDefaultValFSHost(): IValFSHost;

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

@@ -1,2 +1,8 @@
 import { ValidationError } from "@valbuild/core";
+/**
+ * The media path a validation error is about, if it is about media at all.
+ *
+ * There is no schema in hand here — a `ValidationError` carries only the value
+ * it flagged — so the shape is all there is to go on.
+ */
 export declare function getValidationErrorFileRef(validationError: ValidationError): string | null;

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

@@ -11,6 +11,8 @@ export { formatSyntaxErrorTree } from "./patch/ts/syntax.js";
 export { analyzeValModule } from "./patch/ts/valModule.js";
 export type { ValModuleAnalysis } from "./patch/ts/valModule.js";
 export { createFixPatch } from "./createFixPatch.js";
+export { fixHandlers, currentFixHandlers, createDefaultValFSHost, handleFileMetadata, handleRemoteFileUpload, handleRemoteGalleryFileUpload, handleRemoteFileDownload, handleRemoteFileCheck, handleUniqueFolderCheck, handleCheckAllFiles, handleJsonValuesExtractEntry, } from "./fixHandlers.js";
+export type { FixHandler, FixHandlerContext, FixHandlerResult, IValRemote, ValidationEvent, ValidationError, ValModule, } from "./fixHandlers.js";
 export * from "./jwt.js";
 export type { ValServer } from "./ValServer.js";
 export { getSettings } from "./getSettings.js";

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

@@ -37,19 +37,5 @@ export declare function deepValidateExpression(value: ts.Expression): result.Res
  */
 export declare function evaluateExpression(value: ts.Expression): result.Result<JSONValue, ValSyntaxErrorTree>;
 export declare function findObjectPropertyAssignment(value: ts.ObjectLiteralExpression, key: string): result.Result<LiteralPropertyAssignment | undefined, ValSyntaxErrorTree>;
-export declare function isValFileMethodCall(node: ts.Expression): node is ts.CallExpression;
-export declare function isValImageMethodCall(node: ts.Expression): node is ts.CallExpression;
-export declare function isValRemoteMethodCall(node: ts.Expression): node is ts.CallExpression;
-export declare function findValFileNodeArg(node: ts.CallExpression): result.Result<ts.StringLiteral, ValSyntaxErrorTree>;
-export declare function findValRemoteNodeArg(node: ts.CallExpression): result.Result<ts.StringLiteral, ValSyntaxErrorTree>;
-export declare function findValImageNodeArg(node: ts.CallExpression): result.Result<ts.StringLiteral, ValSyntaxErrorTree>;
-export declare function findValFileMetadataArg(node: ts.CallExpression): result.Result<ts.ObjectLiteralExpression | undefined, ValSyntaxErrorTree>;
-export declare function findValImageMetadataArg(node: ts.CallExpression): result.Result<ts.ObjectLiteralExpression | undefined, ValSyntaxErrorTree>;
-export declare function findValRemoteMetadataArg(node: ts.CallExpression): result.Result<ts.ObjectLiteralExpression | undefined, ValSyntaxErrorTree>;
-/**
- * Given a list of expressions, validates that all the expressions are not
- * spread elements. In other words, it ensures that the expressions are the
- * initializers of the values at their respective indices in the evaluated list.
- */
 export declare function validateInitializers(nodes: ReadonlyArray<ts.Expression>): ValSyntaxErrorTree | undefined;
 export {};