@valbuild/server 0.108.3 → 0.108.5

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

@@ -14,10 +14,24 @@ export declare class Service {
      * The module file paths that are registered in the project's val.modules.
      */
     getModuleFilePaths(): ModuleFilePath[];
+    private serializedSchemaOf;
     get(moduleFilePath: ModuleFilePath, modulePath: ModulePath, options?: {
         validate: boolean;
     }): Promise<SerializedModuleContent>;
+    /**
+     * Applies a patch to a module's files.
+     *
+     * A `.jsonValues()` entry's content is not in the `.val.ts` — that file holds
+     * only `c.json(() => import("./x.val.json"))` — so an op whose path descends
+     * into an entry has to be replayed against the backing `*.val.json` instead.
+     * That routing is the same one the Studio's commit flow does in
+     * `ValOps.prepare`; both classify with {@link classifyJsonValuesOp} and rebase
+     * with {@link rebaseContentOp}, so a CLI fix and a Studio publish write the
+     * same file the same way.
+     */
     patch(moduleFilePath: ModuleFilePath, patch: Patch): Promise<void>;
+    /** Replays content ops against one `.jsonValues()` entry's `*.val.json`. */
+    private patchJsonValuesEntry;
     dispose(): void;
 }
 export {};

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

@@ -5,4 +5,4 @@ import { ValidationError } from "@valbuild/core";
  * 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;
+export declare function getValidationErrorFileRef(validationError: ValidationError): any;

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

@@ -29,6 +29,8 @@ export { startValLogin, awaitValLoginConfirmation, persistPersonalAccessToken, V
 export type { ValLoginErrorCode, ValLoginResult, ValLoginSession, } from "./login.js";
 export { createModulePathMap, createJsonEntryPathMap, getModulePathRange, } from "./modulePathMap.js";
 export { findJsonEntryFilePath } from "./jsonEntryLocation.js";
+export { classifyJsonValuesOp, rebaseContentOp } from "./patch/jsonValuesPatch.js";
+export type { JsonValuesOpClass } from "./patch/jsonValuesPatch.js";
 export { extractJsonValuesEntry } from "./extractJsonValuesEntry.js";
 export type { ModulePathMap } from "./modulePathMap.js";
 export { ValOpsFS } from "./ValOpsFS.js";

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

@@ -0,0 +1,107 @@
+import type { PatchId, SerializedSchema } from "@valbuild/core";
+import type { PatchSourceError } from "../ValOps.js";
+import { result } from "@valbuild/core/fp";
+import { JSONValue, Operation, Patch, PatchError } from "@valbuild/core/patch";
+/**
+ * Classification of a single patch op against a module's serialized schema,
+ * used by the commit flow to route ops for `.jsonValues()` records:
+ *
+ * - `normal`: the op does not descend into a `.jsonValues()` entry; apply it to
+ *   the `.val.ts` as usual.
+ * - `entry`: the op targets a `.jsonValues()` entry. `recordPath` is the path to
+ *   the record within the module source (empty for a root record/router),
+ *   `entryKey` is the entry key, and `subPath` is the remaining path inside the
+ *   entry (empty when the op targets the entry value itself, e.g. add/remove of
+ *   the whole entry).
+ */
+export type JsonValuesOpClass = {
+    kind: "normal";
+} | {
+    kind: "entry";
+    recordPath: string[];
+    entryKey: string;
+    subPath: string[];
+};
+/**
+ * Walks the serialized schema following the op path. When a `.jsonValues()`
+ * record is encountered, the next path segment is the entry key and everything
+ * after it lives inside the entry's `*.val.json` (so it does not touch the
+ * `.val.ts`). Returns `{ kind: "normal" }` when the op never enters a
+ * `.jsonValues()` record.
+ */
+export declare function classifyJsonValuesOp(schema: SerializedSchema, opPath: string[]): JsonValuesOpClass;
+/**
+ * Finds every `.jsonValues()` record in a module's schema that is NOT the
+ * module's root, returning the path to each within the module source.
+ *
+ * `.jsonValues()` is only supported on a module's ROOT record/router: the
+ * `/json` endpoint keys entries by a single string, the Studio substitutes
+ * loaded content at the top level of the module source, and
+ * `validateJsonValuesEntries` only visits a root record. A nested one would
+ * silently skip content validation and hang the Studio on a 404, so we reject
+ * it up front instead (see {@link ValOps.initSources}).
+ */
+export declare function findNestedJsonValuesRecords(schema: SerializedSchema, path?: string[]): string[][];
+/**
+ * Computes the `*.val.json` file path (relative to rootDir) and the `import(...)`
+ * path (relative to the module's directory) for a NEW `.jsonValues()` entry,
+ * following the locked filename convention: the file mirrors the entry key under
+ * a folder named after the `.val.ts` (its `.val.ts` suffix becomes the folder).
+ *
+ * For module `/app/support/[slug]/page.val.ts` and key `/support/faq`:
+ * - jsonPath:   `/app/support/[slug]/page/support/faq.val.json`
+ * - importPath: `./page/support/faq.val.json`
+ */
+export declare function getNewJsonEntryPaths(moduleFilePath: string, entryKey: string): result.Result<{
+    jsonPath: string;
+    importPath: string;
+}, PatchSourceError>;
+/**
+ * Rebases a patch op that targets a `.jsonValues()` entry's content so its paths
+ * are relative to the entry's `*.val.json` root (drops the record + entry-key
+ * prefix). Used to replay the op against the backing JSON file.
+ */
+export declare function rebaseContentOp(op: Operation, prefixLen: number): result.Result<Operation, PatchError>;
+/** The outcome of replaying pending patches onto one `.jsonValues()` entry. */
+export type JsonEntryResolution = {
+    kind: "content";
+    content: JSONValue | null;
+    appliedPatchIds: PatchId[];
+} | {
+    kind: "deleted";
+    appliedPatchIds: PatchId[];
+} | {
+    kind: "error";
+    message: string;
+    patchId?: PatchId;
+};
+/**
+ * Replays the ops of `patches` that target ONE `.jsonValues()` entry onto its
+ * committed content, yielding the entry's draft content.
+ *
+ * This is the read-side counterpart to the commit flow in `ValOps.prepare`:
+ * both route ops with {@link classifyJsonValuesOp} and replay content sub-ops
+ * with {@link rebaseContentOp}, but this one produces a value instead of files
+ * and never touches the `.val.ts`.
+ *
+ * Root-only, like the rest of the `.jsonValues()` machinery: ops targeting a
+ * nested record are ignored (nested `.jsonValues()` is rejected at startup).
+ */
+export declare function applyJsonValuesEntryPatches(args: {
+    serializedSchema: SerializedSchema | undefined;
+    entryKey: string;
+    /** `undefined` when the entry does not exist in the committed source. */
+    baseContent: JSONValue | undefined;
+    /** Ordered, already filtered to the entry's module. */
+    patches: {
+        patchId: PatchId;
+        patch: Patch;
+    }[];
+}): JsonEntryResolution;
+/**
+ * Resolves an EXISTING entry's `*.val.json` path (relative to rootDir) from the
+ * `import(...)` path recorded in the `.val.ts` thunk (from
+ * {@link analyzeJsonValuesEntries}). Existing files may have been hand-placed,
+ * so the import path is authoritative (hybrid authoring).
+ */
+export declare function resolveExistingJsonPath(moduleFilePath: string, importPath: string): string;

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

@@ -1,4 +1,4 @@
-import { ModuleFilePath, PatchId } from "@valbuild/core";
+import { PatchId } from "@valbuild/core";
 import { z } from "zod";
 import type { AuthorId, BaseSha } from "./ValOps.js";
 import { PatchLogEntry, PatchLogProblem } from "./patchLog.js";