@valbuild/server 0.58.0 → 0.60.0

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

@@ -1,38 +1,54 @@
+/// <reference types="node" />
 import { Service } from "./Service.js";
-import { ApiGetPatchResponse, ApiPostPatchResponse, ApiTreeResponse } from "@valbuild/core";
-import { VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValServerJsonResult, ValServerRedirectResult, ValServerResult, ValSession } from "@valbuild/shared/internal";
+import { result } from "@valbuild/core/fp";
+import { Patch } from "./patch/validation.js";
+import { ApiGetPatchResponse, ApiPostPatchResponse, ModuleId, PatchId, ApiDeletePatchResponse } from "@valbuild/core";
+import { VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValServerError, ValServerJsonResult, ValServerRedirectResult, ValServerResult, ValSession } from "@valbuild/shared/internal";
 import { ValServer, ValServerCallbacks } from "./ValServer.js";
+import { SerializedModuleContent } from "./SerializedModuleContent.js";
 export type LocalValServerOptions = {
     service: Service;
     valEnableRedirectUrl?: string;
     valDisableRedirectUrl?: string;
+    cacheDir?: string;
     git: {
         commit?: string;
         branch?: string;
     };
 };
-export declare class LocalValServer implements ValServer {
+export interface ValServerBufferHost {
+    readBuffer: (fileName: string) => Promise<Buffer | undefined>;
+}
+export declare class LocalValServer extends ValServer {
     readonly options: LocalValServerOptions;
     readonly callbacks: ValServerCallbacks;
+    private static readonly PATCHES_DIR;
+    private static readonly FILES_DIR;
+    private readonly patchesRootPath;
     constructor(options: LocalValServerOptions, callbacks: ValServerCallbacks);
     session(): Promise<ValServerJsonResult<ValSession>>;
-    getTree(treePath: string, query: {
-        patch?: string;
-        schema?: string;
-        source?: string;
-    }): Promise<ValServerJsonResult<ApiTreeResponse>>;
-    enable(query: {
-        redirect_to?: string;
-    }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
-    disable(query: {
-        redirect_to?: string;
-    }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
+    deletePatches(query: {
+        id?: string[];
+    }): Promise<ValServerJsonResult<ApiDeletePatchResponse>>;
     postPatches(body: unknown): Promise<ValServerJsonResult<ApiPostPatchResponse>>;
+    getFiles(filePath: string, query: {
+        sha256?: string;
+    }): Promise<ValServerResult<never, ReadableStream<Uint8Array>>>;
+    getPatches(query: {
+        id?: string[];
+    }): Promise<ValServerJsonResult<ApiGetPatchResponse>>;
+    private getFilePath;
+    private getFileMetadataPath;
+    private getPatchFilePath;
     private badRequest;
-    postCommit(): Promise<ValServerJsonResult<{}>>;
+    protected ensureRemoteFSInitialized(): Promise<result.Result<undefined, ValServerError>>;
+    protected getModule(moduleId: ModuleId): Promise<SerializedModuleContent>;
+    protected execCommit(patches: [PatchId, ModuleId, Patch][]): Promise<Record<ModuleId, {
+        patches: {
+            applied: PatchId[];
+        };
+    }>>;
     authorize(): Promise<ValServerRedirectResult<VAL_STATE_COOKIE>>;
     callback(): Promise<ValServerRedirectResult<VAL_STATE_COOKIE | VAL_SESSION_COOKIE | VAL_ENABLE_COOKIE_NAME>>;
     logout(): Promise<ValServerResult<VAL_STATE_COOKIE | VAL_SESSION_COOKIE>>;
-    getFiles(): Promise<ValServerResult<never, ReadableStream<Uint8Array>>>;
-    getPatches(): Promise<ValServerJsonResult<ApiGetPatchResponse>>;
 }

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

@@ -1,7 +1,5 @@
 import { type Source, type SerializedSchema, ValidationErrors } from "@valbuild/core";
-import type { ModuleId, SourcePath } from "@valbuild/core";
-export declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module"];
-export type FatalErrorType = (typeof FATAL_ERROR_TYPES)[number];
+import type { FatalErrorType, ModuleId, SourcePath } from "@valbuild/core";
 export type SerializedModuleContent = {
     source: Source;
     schema: SerializedSchema;

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

@@ -21,11 +21,11 @@ export type ServiceOptions = {
 };
 export declare function createService(projectRoot: string, opts: ServiceOptions, host?: IValFSHost, loader?: ValModuleLoader): Promise<Service>;
 export declare class Service {
-    private readonly sourceFileHandler;
+    readonly sourceFileHandler: ValSourceFileHandler;
     private readonly runtime;
     readonly valConfigPath: string;
     constructor({ valConfigPath }: ServiceOptions, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime);
-    get(moduleId: ModuleId, modulePath: ModulePath): Promise<SerializedModuleContent>;
-    patch(moduleId: string, patch: Patch): Promise<void>;
+    get(moduleId: ModuleId, modulePath?: ModulePath): Promise<SerializedModuleContent>;
+    patch(moduleId: ModuleId, patch: Patch): Promise<void>;
     dispose(): void;
 }

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 /**
  * A filesystem that can update and read files.
  * It does not support creating new files or directories.
@@ -5,8 +6,9 @@
  */
 export interface ValFS {
     readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined): readonly string[];
-    writeFile(filePath: string, data: string, encoding: "binary" | "utf8"): void;
+    writeFile(filePath: string, data: string | Buffer, encoding: "binary" | "utf8"): void;
     fileExists(filePath: string): boolean;
     readFile(filePath: string): string | undefined;
+    rmFile(filePath: string): void;
     realpath(path: string): string;
 }

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import ts from "typescript";
 import { ValFS } from "./ValFS.js";
 /**
@@ -6,7 +7,8 @@ import { ValFS } from "./ValFS.js";
  */
 export interface IValFSHost extends ts.ParseConfigHost, ts.ModuleResolutionHost {
     useCaseSensitiveFileNames: boolean;
-    writeFile(fileName: string, text: string, encoding: "binary" | "utf8"): void;
+    writeFile(fileName: string, data: string | Buffer, encoding: "binary" | "utf8"): void;
+    rmFile(fileName: string): void;
 }
 export declare class ValFSHost implements IValFSHost {
     protected readonly valFS: ValFS;
@@ -14,7 +16,8 @@ export declare class ValFSHost implements IValFSHost {
     constructor(valFS: ValFS, currentDirectory: string);
     useCaseSensitiveFileNames: boolean;
     readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined): readonly string[];
-    writeFile(fileName: string, text: string, encoding: "binary" | "utf8"): void;
+    rmFile(fileName: string): void;
+    writeFile(fileName: string, text: string | Buffer, encoding: "binary" | "utf8"): void;
     getCurrentDirectory(): string;
     getCanonicalFileName(fileName: string): string;
     fileExists(fileName: string): boolean;

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

@@ -1,5 +1,89 @@
-import { ApiGetPatchResponse, ApiPostPatchResponse, ApiTreeResponse } from "@valbuild/core";
+/// <reference types="node" />
+import { ApiCommitResponse, ApiGetPatchResponse, ApiPostPatchResponse, ApiPostValidationErrorResponse, ApiTreeResponse, ApiDeletePatchResponse, ApiPostValidationResponse } from "@valbuild/core";
 import { VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValCookies, ValServerError, ValServerJsonResult, ValServerRedirectResult, ValServerResult, ValSession } from "@valbuild/shared/internal";
+import { result } from "@valbuild/core/fp";
+import { Patch } from "./patch/validation.js";
+import { ModuleId, PatchId } from "@valbuild/core";
+import { SerializedModuleContent } from "./SerializedModuleContent.js";
+import { IValFSHost } from "./ValFSHost.js";
+export type ValServerOptions = {
+    valEnableRedirectUrl?: string;
+    valDisableRedirectUrl?: string;
+    git: {
+        commit?: string;
+        branch?: string;
+    };
+};
+export declare abstract class ValServer implements IValServer {
+    readonly cwd: string;
+    readonly host: IValFSHost;
+    readonly options: ValServerOptions;
+    readonly callbacks: ValServerCallbacks;
+    constructor(cwd: string, host: IValFSHost, options: ValServerOptions, callbacks: ValServerCallbacks);
+    enable(query: {
+        redirect_to?: string;
+    }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
+    disable(query: {
+        redirect_to?: string;
+    }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
+    private getAllModules;
+    getTree(treePath: string, query: {
+        patch?: string;
+        schema?: string;
+        source?: string;
+    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiTreeResponse>>;
+    postValidate(rawBody: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiPostValidationResponse | ApiPostValidationErrorResponse>>;
+    postCommit(rawBody: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiCommitResponse, ApiPostValidationErrorResponse>>;
+    private applyAllPatchesThenValidate;
+    private revalidateImageAndFileValidation;
+    protected sortPatchIds(patchesByModule: Record<ModuleId, {
+        patch: Patch;
+        patch_id: PatchId;
+        created_at: string;
+        commit_sha?: string;
+        author?: string;
+    }[]>): PatchId[];
+    protected readStaticBinaryFile(filePath: string): Promise<Buffer | undefined>;
+    private readPatches;
+    private validateThenMaybeCommit;
+    protected getPatchedModules(patches: [PatchId, ModuleId, Patch][]): Promise<Record<ModuleId, {
+        patches: {
+            applied: PatchId[];
+        };
+    }>>;
+    /**
+     * Runs before remoteFS dependent methods (e.g.getModule, ...) are called to make sure that:
+     * 1) The remote FS, if applicable, is initialized
+     * 2) The error is returned via API if the remote FS could not be initialized
+     * */
+    protected abstract ensureRemoteFSInitialized(errorMessageType: string, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<result.Result<undefined, ValServerError>>;
+    protected abstract getModule(moduleId: ModuleId): Promise<SerializedModuleContent>;
+    protected abstract execCommit(patches: [PatchId, ModuleId, Patch][], cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<Record<ModuleId, {
+        patches: {
+            applied: PatchId[];
+        };
+    }>>;
+    abstract getFiles(filePath: string, query: {
+        sha256?: string;
+    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerResult<never, ReadableStream<Uint8Array>>>;
+    abstract session(cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ValSession>>;
+    abstract authorize(query: {
+        redirect_to?: string;
+    }): Promise<ValServerRedirectResult<VAL_STATE_COOKIE>>;
+    abstract logout(): Promise<ValServerResult<VAL_STATE_COOKIE | VAL_SESSION_COOKIE>>;
+    abstract callback(query: {
+        code?: string;
+        state?: string;
+    }, cookies: ValCookies<VAL_STATE_COOKIE>): Promise<ValServerRedirectResult<VAL_STATE_COOKIE | VAL_SESSION_COOKIE | VAL_ENABLE_COOKIE_NAME>>;
+    abstract deletePatches(query: {
+        id?: string[];
+    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiDeletePatchResponse>>;
+    abstract postPatches(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiPostPatchResponse>>;
+    abstract getPatches(query: {
+        id?: string[];
+    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiGetPatchResponse>>;
+}
+export declare function bufferToReadableStream(buffer: Buffer): ReadableStream<any>;
 export declare const ENABLE_COOKIE_VALUE: {
     readonly value: "true";
     readonly options: {
@@ -10,12 +94,18 @@ export declare const ENABLE_COOKIE_VALUE: {
 export declare function getRedirectUrl(query: {
     redirect_to?: string | undefined;
 }, overrideHost: string | undefined): string | ValServerError;
+export declare function getMimeTypeFromBase64(content: string): string | null;
+export declare function bufferFromDataUrl(dataUrl: string, contentType: string | null): Buffer | undefined;
+export type PatchFileMetadata = {
+    mimeType: string;
+    sha256: string;
+};
 export type ValServerCallbacks = {
     isEnabled: () => Promise<boolean>;
     onEnable: (success: boolean) => Promise<void>;
     onDisable: (success: boolean) => Promise<void>;
 };
-export interface ValServer {
+export interface IValServer {
     authorize(query: {
         redirect_to?: string;
     }): Promise<ValServerRedirectResult<VAL_STATE_COOKIE>>;
@@ -40,8 +130,13 @@ export interface ValServer {
         id?: string[];
     }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiGetPatchResponse>>;
     postPatches(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiPostPatchResponse>>;
-    postCommit(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<{}>>;
-    getFiles(treePath: string, query: {
+    deletePatches(query: {
+        id?: string[];
+    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiDeletePatchResponse>>;
+    postValidate(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiPostValidationResponse | ApiPostValidationErrorResponse>>;
+    postCommit(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiCommitResponse, ApiPostValidationErrorResponse>>;
+    getFiles(filePath: string, query: {
         sha256?: string;
     }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerResult<never, ReadableStream<Uint8Array>>>;
 }
+export declare function guessMimeTypeFromPath(filePath: string): string | null;

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

@@ -1,9 +1,9 @@
 import ts from "typescript";
 import { IValFSHost } from "./ValFSHost.js";
 export declare class ValSourceFileHandler {
-    private readonly projectRoot;
+    readonly projectRoot: string;
     private readonly compilerOptions;
-    private readonly host;
+    readonly host: IValFSHost;
     constructor(projectRoot: string, compilerOptions: ts.CompilerOptions, host?: IValFSHost);
     getSourceFile(filePath: string): ts.SourceFile | undefined;
     writeSourceFile(sourceFile: ts.SourceFile): void;

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

@@ -1,7 +1,8 @@
 import { ServiceOptions } from "./Service.js";
-import { ValServer, ValServerCallbacks } from "./ValServer.js";
+import { IValServer, ValServerCallbacks } from "./ValServer.js";
+import { ValConfig } from "@valbuild/core";
 import { ValServerGenericResult } from "@valbuild/shared/internal";
-type Opts = ValServerOverrides & ServiceOptions;
+export type ValApiOptions = ValServerOverrides & ServiceOptions & ValConfig;
 type ValServerOverrides = Partial<{
     /**
      * Override the Val API key.
@@ -102,11 +103,15 @@ type ValServerOverrides = Partial<{
      * @example "/api/draft/enable"
      */
     valDisableRedirectUrl?: string;
+    /**
+     * Disable the cache.
+     */
+    disableCache?: boolean;
 }>;
-export declare function createValServer(route: string, opts: Opts, callbacks: ValServerCallbacks): Promise<ValServer>;
+export declare function createValServer(route: string, opts: ValApiOptions, callbacks: ValServerCallbacks): Promise<IValServer>;
 export declare function safeReadGit(cwd: string): Promise<{
     commit?: string;
     branch?: string;
 }>;
-export declare function createValApiRouter<Res>(route: string, valServerPromise: Promise<ValServer>, convert: (valServerRes: ValServerGenericResult) => Res): (req: Request) => Promise<Res>;
+export declare function createValApiRouter<Res>(route: string, valServerPromise: Promise<IValServer>, convert: (valServerRes: ValServerGenericResult) => Res): (req: Request) => Promise<Res>;
 export {};

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

@@ -11,5 +11,5 @@ 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";
+export { PatchJSON, Patch } from "./patch/validation.js";
 export * from "./jwt.js";

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

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