@valbuild/server 0.99.1 → 0.100.0

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

@@ -1,10 +1,10 @@
 import { FileMetadata, FileSource, ImageMetadata, ModuleFilePath, PatchId, RemoteSource, Schema, SelectorSource, SerializedSchema, Source, SourcePath, ValConfig, ValModules, ValidationError } from "@valbuild/core";
 import { result } from "@valbuild/core/fp";
-import { ParentRef, Patch, PatchError } from "@valbuild/core/patch";
+import { JSONValue, ParentRef, Patch, PatchError } from "@valbuild/core/patch";
 import { ValSyntaxError, ValSyntaxErrorTree } from "./patch/ts/syntax.js";
 import { ParentPatchId } from "@valbuild/core";
+import type { ReifiedRender } from "@valbuild/core";
 import { ValCommit, ValDeployment } from "@valbuild/shared/internal";
-import { ReifiedRender } from "@valbuild/core";
 export type BaseSha = string & {
     readonly _tag: unique symbol;
 };
@@ -72,12 +72,20 @@ export declare abstract class ValOps {
         schemaSha: SchemaSha;
         patches?: PatchId[];
         profileId?: AuthorId;
+        /**
+         * FS mode only (see ValOpsFS): the fingerprint of the `.jsonValues()` entry
+         * FILES the client last saw. Absent in http mode, where content does not
+         * change under a running server — a deploy restarts it.
+         */
+        jsonEntriesSha?: string;
     } | null): Promise<{
         type: "request-again" | "no-change" | "did-change";
         baseSha: BaseSha;
         schemaSha: SchemaSha;
         sourcesSha: SourcesSha;
         patches: PatchId[];
+        /** FS mode only — see the `params` counterpart. */
+        jsonEntriesSha?: string;
     } | {
         type: "use-websocket";
         url: string;
@@ -96,6 +104,82 @@ export declare abstract class ValOps {
     private initSources;
     init(): Promise<void>;
     getBaseSources(): Promise<Sources>;
+    /**
+     * Resolves the content of ONE `.jsonValues()` entry.
+     *
+     * The committed content comes from the entry's import thunk on the base
+     * source (so it works in both fs and http mode, with no extra I/O). With
+     * `applyPatches` (the default) any pending patches for that entry are then
+     * replayed on top, which is what makes draft edits visible to the runtime.
+     *
+     * Callers that apply patches themselves (the Studio, which owns
+     * in-flight client patches the server has not seen) must pass
+     * `applyPatches: false` or the same edits would be applied twice.
+     */
+    getJsonEntry(moduleFilePath: ModuleFilePath, entryKey: string, opts?: {
+        applyPatches?: boolean;
+    }): Promise<{
+        status: "success";
+        content: JSONValue | null;
+    } | {
+        status: "not-found";
+        message: string;
+    } | {
+        status: "error";
+        message: string;
+    } | {
+        status: "unauthorized";
+        message: string;
+    }>;
+    /**
+     * Resolves the content of MANY `.jsonValues()` entries in one pass.
+     *
+     * This is the single implementation; {@link getJsonEntry} is a one-key wrapper.
+     * Batching matters because the expensive parts — `initSources()` and
+     * `fetchPatches()` — are hoisted OUT of the per-entry loop: resolving 500
+     * entries one-by-one would otherwise mean 500 patch fetches.
+     *
+     * Per-entry problems stay per-entry (`missing` / `errors`) so one corrupt
+     * `*.val.json` cannot fail a whole batch. Only a missing or non-record MODULE
+     * is a whole-request `not-found`.
+     *
+     * `selector` is either explicit `keys` or an `offset`/`limit` window over every
+     * key of the record, in module key order. The window form requires
+     * `applyPatches: false`: enumerating from the base source would silently omit
+     * draft-added keys, and a silently-short key list is exactly the class of bug
+     * this endpoint exists to avoid.
+     */
+    getJsonEntries(moduleFilePath: ModuleFilePath, selector: {
+        keys: string[];
+    } | {
+        offset: number;
+        limit: number;
+    }, opts?: {
+        applyPatches?: boolean;
+    }): Promise<{
+        status: "success";
+        entries: {
+            key: string;
+            content: JSONValue | null;
+        }[];
+        missing: string[];
+        errors: {
+            key: string;
+            message: string;
+        }[];
+        total: number;
+        offset?: number;
+        limit?: number;
+    } | {
+        status: "not-found";
+        message: string;
+    } | {
+        status: "error";
+        message: string;
+    } | {
+        status: "unauthorized";
+        message: string;
+    }>;
     getSchemas(): Promise<Schemas>;
     getSerializedSchemas(): Promise<Record<ModuleFilePath, SerializedSchema>>;
     getModuleErrors(): Promise<ModulesError[]>;
@@ -104,6 +188,15 @@ export declare abstract class ValOps {
     getSourcesSha(): Promise<SourcesSha>;
     getSchemaSha(): Promise<SchemaSha>;
     analyzePatches(sortedPatches: OrderedPatches["patches"], commits?: ValCommit[], currentCommitSha?: CommitSha): PatchAnalysis;
+    /**
+     * Reifies each module's render from its schema INSTANCE.
+     *
+     * Kept even though the Studio also computes renders client-side: `select` is a
+     * user function that lives on the instance and is not part of the serialized
+     * schema, so a host app that does not render `<ValModulesClient>` has no
+     * instances in the browser and would otherwise get no renders at all. See
+     * #470.
+     */
     getRenders(schemas: Schemas, sources: Sources): Promise<{
         renders: Record<ModuleFilePath, ReifiedRender | null>;
     }>;

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

@@ -9,6 +9,11 @@ export declare class ValOpsFS extends ValOps {
     private static readonly VAL_DIR;
     private readonly host;
     constructor(contentUrl: string, rootDir: string, valModules: ValModules, options?: ValOpsOptions);
+    /**
+     * Change detection for `.jsonValues()` entry files, which no sha can see (their
+     * content lives behind a thunk that `JSON.stringify` drops).
+     */
+    private readonly jsonEntryFilesFingerprint;
     onInit(): Promise<void>;
     getPresignedAuthNonce(project: string, corsOrigin: string, auth: {
         pat: string;
@@ -38,12 +43,14 @@ export declare class ValOpsFS extends ValOps {
         sourcesSha: SourcesSha;
         patches: PatchId[];
         profileId?: AuthorId;
+        jsonEntriesSha?: string;
     } | null): Promise<{
         type: "request-again" | "no-change" | "did-change";
         baseSha: BaseSha;
         schemaSha: SchemaSha;
         sourcesSha: SourcesSha;
         patches: PatchId[];
+        jsonEntriesSha?: string;
     } | {
         type: "use-websocket";
         url: string;

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

@@ -0,0 +1,17 @@
+import type { Json, ModuleFilePath } from "@valbuild/core";
+import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
+/**
+ * Moves ONE `.jsonValues()` entry that was written inline in the `.val.ts` into
+ * its own `*.val.json`, replacing the inline value with
+ * `c.json(() => import("./<key>.val.json"))`.
+ *
+ * This is the fix for the `jsonValues:extract-entry` validation error. It is not
+ * expressible as a patch (a patch edits one `.val.ts` and cannot create the
+ * backing JSON file), so it writes both files directly — JSON first, so a
+ * failure part-way through never leaves the module pointing at a file that does
+ * not exist.
+ *
+ * Root-only, like the rest of the `.jsonValues()` machinery: the entry is looked
+ * up in the module's root record/router object literal.
+ */
+export declare function extractJsonValuesEntry(moduleFilePath: ModuleFilePath, rootDir: string, entryKey: string, content: Json, sourceFileHandler: ValSourceFileHandler): void;

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

@@ -1,2 +1,2 @@
 import { ValidationError } from "@valbuild/core";
-export declare function getValidationErrorFileRef(validationError: ValidationError): any;
+export declare function getValidationErrorFileRef(validationError: ValidationError): string | null;

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

@@ -25,7 +25,9 @@ export { getFileExt } from "./getFileExt.js";
 export { evalValConfigFile, findAndEvalValConfigFile, } from "./evalValConfigFile.js";
 export { startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, ValLoginError, DEFAULT_LOGIN_HOST, DEFAULT_LOGIN_MAX_DURATION, DEFAULT_LOGIN_POLL_INTERVAL, } from "./login.js";
 export type { ValLoginErrorCode, ValLoginResult, ValLoginSession, } from "./login.js";
-export { createModulePathMap, getModulePathRange } from "./modulePathMap.js";
+export { createModulePathMap, createJsonEntryPathMap, getModulePathRange, } from "./modulePathMap.js";
+export { findJsonEntryFilePath } from "./jsonEntryLocation.js";
+export { extractJsonValuesEntry } from "./extractJsonValuesEntry.js";
 export type { ModulePathMap } from "./modulePathMap.js";
 export { ValOpsFS } from "./ValOpsFS.js";
 export { ValOpsHttp } from "./ValOpsHttp.js";

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

@@ -0,0 +1,17 @@
+import ts from "typescript";
+/**
+ * Which `*.val.json` holds a `.jsonValues()` entry's content, given the module's
+ * `.val.ts`.
+ *
+ * Tooling that maps a validation `sourcePath` back to a place in a file needs
+ * this: for a jsonValues module the offending value is NOT in the `.val.ts` at
+ * all — that file only holds `c.json(() => import("./x.val.json"))` — so a
+ * resolver that only ever looks at the `.val.ts` can report the error but not
+ * where it lives, which for a record with hundreds of entries is not much of a
+ * report.
+ *
+ * Returns a path relative to the project root (leading slash), or undefined when
+ * the module has no such entry (not a jsonValues module, unparseable, or the key
+ * is not backed by a `c.json` thunk).
+ */
+export declare function findJsonEntryFilePath(moduleFilePath: string, valTsSourceFile: ts.SourceFile, entryKey: string): string | undefined;

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

@@ -27,3 +27,13 @@ export declare function getModulePathRange(modulePath: string, modulePathMap: Mo
     };
 } | undefined;
 export declare function createModulePathMap(sourceFile: ts.SourceFile): ModulePathMap | undefined;
+/**
+ * The {@link createModulePathMap} equivalent for a `.jsonValues()` entry's
+ * backing `*.val.json`.
+ *
+ * The file IS the entry's value, so the map is rooted at the JSON document
+ * rather than at a `c.define` argument — but everything below is the same shape,
+ * which means a module path like `"title"` (the part after the entry key)
+ * resolves against it exactly as it would inside a `.val.ts`.
+ */
+export declare function createJsonEntryPathMap(jsonSourceFile: ts.JsonSourceFile): ModulePathMap | undefined;