@valbuild/server 0.61.0 → 0.62.0

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

@@ -1,5 +1,5 @@
 import { type Source, type SerializedSchema, ValidationErrors } from "@valbuild/core";
-import type { FatalErrorType, ModuleId, SourcePath } from "@valbuild/core";
+import type { FatalErrorType, ModuleFilePath, SourcePath } from "@valbuild/core";
 export type SerializedModuleContent = {
     source: Source;
     schema: SerializedSchema;
@@ -10,7 +10,7 @@ export type SerializedModuleContent = {
     schema?: SerializedSchema;
     path: SourcePath;
     errors: {
-        invalidModuleId?: ModuleId;
+        invalidModulePath?: ModuleFilePath;
         validation?: ValidationErrors;
         fatal?: {
             message: string;

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

@@ -4,7 +4,7 @@ import { ValModuleLoader } from "./ValModuleLoader.js";
 import { ValSourceFileHandler } from "./ValSourceFileHandler.js";
 import { IValFSHost } from "./ValFSHost.js";
 import { SerializedModuleContent } from "./SerializedModuleContent.js";
-import { ModuleId, ModulePath } from "@valbuild/core";
+import { ModuleFilePath, ModulePath } from "@valbuild/core";
 export type ServiceOptions = {
     /**
      * Disable cache for transpilation
@@ -19,11 +19,11 @@ export declare class Service {
     private readonly runtime;
     readonly projectRoot: string;
     constructor(projectRoot: string, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime);
-    get(moduleId: ModuleId, modulePath: ModulePath, options?: {
+    get(moduleFilePath: ModuleFilePath, modulePath: ModulePath, options?: {
         validate: boolean;
         source: boolean;
         schema: boolean;
     }): Promise<SerializedModuleContent>;
-    patch(moduleId: ModuleId, patch: Patch): Promise<void>;
+    patch(moduleFilePath: ModuleFilePath, patch: Patch): Promise<void>;
     dispose(): void;
 }

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

@@ -1,96 +1,112 @@
 /// <reference types="node" />
-import { ApiCommitResponse, ApiGetPatchResponse, ApiPostPatchResponse, ApiPostValidationErrorResponse, ApiTreeResponse, ApiDeletePatchResponse, ApiPostValidationResponse, ValModules } 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 { Operation } from "@valbuild/core/patch";
-import { Patch } from "./patch/validation.js";
-import { ModuleId, PatchId, FileMetadata, ImageMetadata } from "@valbuild/core";
-import { SerializedModuleContent } from "./SerializedModuleContent.js";
+import { ApiCommitResponse, ApiGetPatchResponse, ApiPostValidationErrorResponse, ApiTreeResponse, ApiDeletePatchResponse, ValModules, ApiSchemaResponse } from "@valbuild/core";
+import { VAL_ENABLE_COOKIE_NAME, VAL_SESSION_COOKIE, VAL_STATE_COOKIE, ValCookies, ValServerError, ValServerJsonResult, ValServerRedirectResult, ValServerResult, ValServerResultCookies, ValSession } from "@valbuild/shared/internal";
+import { z } from "zod";
 export type ValServerOptions = {
+    route: string;
     valEnableRedirectUrl?: string;
     valDisableRedirectUrl?: string;
-    git: {
-        commit?: string;
-        branch?: string;
-    };
+    formatter?: (code: string, filePath: string) => string;
+    valBuildUrl?: string;
+    valSecret?: string;
+    apiKey?: string;
+    project?: string;
 };
-export declare abstract class ValServer implements IValServer {
-    readonly cwd: string;
+export type ValServerConfig = ValServerOptions & ({
+    mode: "fs";
+    cwd: string;
+    formatter?: (code: string, filePath: string) => string;
+} | {
+    mode: "http";
+    valContentUrl: string;
+    apiKey: string;
+    project: string;
+    commit: string;
+    branch: string;
+    root?: string;
+});
+export declare class ValServer {
     readonly valModules: ValModules;
-    readonly options: ValServerOptions;
+    private readonly options;
     readonly callbacks: ValServerCallbacks;
-    constructor(cwd: string, valModules: ValModules, options: ValServerOptions, callbacks: ValServerCallbacks);
+    private serverOps;
+    constructor(valModules: ValModules, options: ValServerConfig, callbacks: ValServerCallbacks);
     enable(query: {
         redirect_to?: string;
     }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
     disable(query: {
         redirect_to?: string;
     }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
-    getTree(treePath: string, query: {
-        patch?: string;
-        schema?: string;
-        source?: string;
-    }, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerJsonResult<ApiTreeResponse>>;
-    postValidate(rawBody: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerJsonResult<ApiPostValidationResponse | ApiPostValidationErrorResponse>>;
-    postCommit(rawBody: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerJsonResult<ApiCommitResponse, ApiPostValidationErrorResponse>>;
-    private applyAllPatchesThenValidate;
-    abstract getMetadata(fileRef: string, sha256?: string): Promise<FileMetadata | ImageMetadata | undefined>;
-    private revalidateImageAndFileValidation;
-    protected abstract getAllModules(treePath: string): Promise<ModuleId[]>;
-    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 ensureInitialized(errorMessageType: string, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<result.Result<undefined, ValServerError>>;
-    protected abstract getModule(moduleId: ModuleId, options: {
-        source: boolean;
-        schema: boolean;
-    }): Promise<SerializedModuleContent>;
-    protected abstract execCommit(patches: [PatchId, ModuleId, Patch][], cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<{
-        status: 200;
-        json: Record<ModuleId, {
-            patches: {
-                applied: PatchId[];
-            };
-        }>;
-    } | ValServerError>;
-    abstract getFiles(filePath: string, query: {
-        sha256?: string;
-    }, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerResult<never, ReadableStream<Uint8Array>> | ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
-    abstract session(cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ValSession>>;
-    abstract authorize(query: {
+    authorize(query: {
         redirect_to?: string;
     }): Promise<ValServerRedirectResult<VAL_STATE_COOKIE>>;
-    abstract logout(): Promise<ValServerResult<VAL_STATE_COOKIE | VAL_SESSION_COOKIE>>;
-    abstract callback(query: {
+    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: {
+    }, cookies: ValCookies<"val_state">): Promise<ValServerRedirectResult<"val_state" | "val_session" | "val_enable">>;
+    log(): Promise<ValServerResult<VAL_SESSION_COOKIE | VAL_STATE_COOKIE>>;
+    session(cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ValSession>>;
+    private consumeCode;
+    private getAuthorizeUrl;
+    private getAppErrorUrl;
+    getAuth(cookies: Partial<Record<"val_session", string>>): {
+        error: string;
+    } | {
+        id: string;
+        error?: undefined;
+    } | {
+        error: null;
+        id: null;
+    };
+    logout(): Promise<ValServerResult<VAL_SESSION_COOKIE | VAL_STATE_COOKIE>>;
+    getPatches(query: {
+        authors?: string[];
+    }, cookies: Partial<Record<"val_session", string>>): Promise<ValServerJsonResult<ApiGetPatchResponse>>;
+    deletePatches(query: {
         id?: string[];
-    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiGetPatchResponse>>;
+    }, cookies: Partial<Record<"val_session", string>>): Promise<ValServerJsonResult<ApiDeletePatchResponse>>;
+    getSchema(cookies: Partial<Record<"val_session", string>>): Promise<ValServerJsonResult<ApiSchemaResponse>>;
+    putTree(body: unknown, treePath: string, query: {
+        patches_sha?: string;
+        validate_all?: string;
+        validate_sources?: string;
+        validate_binary_files?: string;
+    }, cookies: Partial<Record<"val_session", string>>): Promise<ValServerJsonResult<ApiTreeResponse>>;
+    postSave(body: unknown, cookies: Partial<Record<"val_session", string>>): Promise<ValServerJsonResult<ApiCommitResponse, ApiPostValidationErrorResponse>>;
+    getFiles(filePath: string, query: {
+        patch_id?: string;
+    }): Promise<ValServerError | {
+        status: 200 | 201;
+        headers?: Record<string, string>;
+        cookies?: ValServerResultCookies<never>;
+        body?: ReadableStream<Uint8Array>;
+    }>;
 }
-export declare function bufferToReadableStream(buffer: Buffer): ReadableStream<any>;
+export type ValServerCallbacks = {
+    isEnabled: () => Promise<boolean>;
+    onEnable: (success: boolean) => Promise<void>;
+    onDisable: (success: boolean) => Promise<void>;
+};
+declare const IntegratedServerJwtPayload: z.ZodObject<{
+    sub: z.ZodString;
+    exp: z.ZodNumber;
+    token: z.ZodString;
+    org: z.ZodString;
+    project: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    sub: string;
+    exp: number;
+    token: string;
+    org: string;
+}, {
+    project: string;
+    sub: string;
+    exp: number;
+    token: string;
+    org: string;
+}>;
+export type IntegratedServerJwtPayload = z.infer<typeof IntegratedServerJwtPayload>;
 export declare const ENABLE_COOKIE_VALUE: {
     readonly value: "true";
     readonly options: {
@@ -98,66 +114,9 @@ export declare const ENABLE_COOKIE_VALUE: {
         readonly sameSite: "lax";
     };
 };
+export declare function bufferToReadableStream(buffer: Buffer): ReadableStream<any>;
 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 IValServer {
-    authorize(query: {
-        redirect_to?: string;
-    }): Promise<ValServerRedirectResult<VAL_STATE_COOKIE>>;
-    callback(query: {
-        code?: string;
-        state?: string;
-    }, cookies: ValCookies<VAL_STATE_COOKIE>): Promise<ValServerRedirectResult<VAL_STATE_COOKIE | VAL_SESSION_COOKIE | VAL_ENABLE_COOKIE_NAME>>;
-    enable(query: {
-        redirect_to?: string;
-    }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
-    disable(query: {
-        redirect_to?: string;
-    }): Promise<ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
-    logout(): Promise<ValServerResult<VAL_STATE_COOKIE | VAL_SESSION_COOKIE>>;
-    session(cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ValSession>>;
-    getTree(treePath: string, query: {
-        patch?: string;
-        schema?: string;
-        source?: string;
-        validate?: string;
-    }, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerJsonResult<ApiTreeResponse>>;
-    getPatches(query: {
-        id?: string[];
-    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiGetPatchResponse>>;
-    postPatches(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiPostPatchResponse>>;
-    deletePatches(query: {
-        id?: string[];
-    }, cookies: ValCookies<VAL_SESSION_COOKIE>): Promise<ValServerJsonResult<ApiDeletePatchResponse>>;
-    postValidate(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerJsonResult<ApiPostValidationResponse | ApiPostValidationErrorResponse>>;
-    postCommit(body: unknown, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerJsonResult<ApiCommitResponse, ApiPostValidationErrorResponse>>;
-    getFiles(filePath: string, query: {
-        sha256?: string;
-    }, cookies: ValCookies<VAL_SESSION_COOKIE>, requestHeaders: RequestHeaders): Promise<ValServerResult<never, ReadableStream<Uint8Array>> | ValServerRedirectResult<VAL_ENABLE_COOKIE_NAME>>;
-}
 export declare function guessMimeTypeFromPath(filePath: string): string | null;
-export declare function isCachedPatchFileOp(op: Operation): op is {
-    op: "file";
-    path: string[];
-    filePath: string;
-    value: {
-        sha256: string;
-    };
-};
-export type RequestHeaders = {
-    host?: string | null;
-    "x-forwarded-proto"?: string | null;
-};
-export declare function debugTiming<R>(id: string, fn: () => Promise<R>): Promise<R>;
+export {};

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

@@ -1,14 +1,13 @@
-import { ServiceOptions } from "./Service.js";
-import { IValServer, ValServerCallbacks } from "./ValServer.js";
 import { ValConfig, ValModules } from "@valbuild/core";
 import { ValServerGenericResult } from "@valbuild/shared/internal";
+import { ValServer, ValServerCallbacks } from "./ValServer.js";
 type Versions = {
     versions?: {
         core?: string;
         next?: string;
     };
 };
-export type ValApiOptions = ValServerOverrides & ServiceOptions & ValConfig & Versions;
+export type ValApiOptions = ValServerOverrides & ValConfig & Versions;
 type ValServerOverrides = Partial<{
     /**
      * Override the Val API key.
@@ -84,11 +83,11 @@ type ValServerOverrides = Partial<{
      */
     valContentUrl: string;
     /**
-     * The cloud name of this Val project.
+     * The full project name of the Val project.
      *
      * @example "myorg/my-project"
      */
-    remote: string;
+    project: string;
     /**
      * After Val is enabled, redirect to this url.
      *
@@ -114,10 +113,10 @@ type ValServerOverrides = Partial<{
      */
     disableCache?: boolean;
 }>;
-export declare function createValServer(valModules: ValModules, route: string, opts: ValApiOptions, callbacks: ValServerCallbacks): Promise<IValServer>;
+export declare function createValServer(valModules: ValModules, route: string, opts: ValApiOptions, callbacks: ValServerCallbacks, formatter?: (code: string, filePath: string) => string): Promise<ValServer>;
 export declare function safeReadGit(cwd: string): Promise<{
     commit?: string;
     branch?: string;
 }>;
-export declare function createValApiRouter<Res>(route: string, valServerPromise: Promise<IValServer>, convert: (valServerRes: ValServerGenericResult) => Res): (req: Request) => Promise<Res>;
+export declare function createValApiRouter<Res>(route: string, valServerPromise: Promise<ValServer>, convert: (valServerRes: ValServerGenericResult) => Res): (req: Request) => Promise<Res>;
 export {};

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

@@ -9,7 +9,6 @@ export type { IValFSHost } from "./ValFSHost.js";
 export type { ValFS } from "./ValFS.js";
 export { patchSourceFile } from "./patchValFile.js";
 export { formatSyntaxErrorTree } from "./patch/ts/syntax.js";
-export { LocalValServer } from "./LocalValServer.js";
 export { createFixPatch } from "./createFixPatch.js";
 export { PatchJSON, Patch } from "./patch/validation.js";
 export * from "./jwt.js";