@valbuild/server 0.12.0

package/.babelrc.json

@@ -0,0 +1,5 @@
+{
+  "targets": {
+    "node": 16
+  }
+}

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

@@ -0,0 +1,22 @@
+import express from "express";
+import { Service } from "./Service";
+import { ValServer } from "./ValServer";
+export type LocalValServerOptions = {
+    service: Service;
+};
+export declare class LocalValServer implements ValServer {
+    readonly options: LocalValServerOptions;
+    constructor(options: LocalValServerOptions);
+    session(_req: express.Request, res: express.Response): Promise<void>;
+    getIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    patchIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    private badRequest;
+    commit(req: express.Request, res: express.Response): Promise<void>;
+    authorize(req: express.Request, res: express.Response): Promise<void>;
+    callback(req: express.Request, res: express.Response): Promise<void>;
+    logout(req: express.Request, res: express.Response): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+import express from "express";
+import { ValServer } from "./ValServer";
+import { z } from "zod";
+export type ProxyValServerOptions = {
+    apiKey: string;
+    route: string;
+    valSecret: string;
+    valBuildUrl: string;
+    gitCommit: string;
+    gitBranch: string;
+};
+export declare class ProxyValServer implements ValServer {
+    readonly options: ProxyValServerOptions;
+    constructor(options: ProxyValServerOptions);
+    authorize(req: express.Request, res: express.Response): Promise<void>;
+    callback(req: express.Request, res: express.Response): Promise<void>;
+    logout(_req: express.Request, res: express.Response): Promise<void>;
+    withAuth<T>(req: express.Request, res: express.Response, handler: (data: IntegratedServerJwtPayload) => Promise<T>): Promise<T | undefined>;
+    session(req: express.Request, res: express.Response): Promise<void>;
+    getIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    patchIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    commit(req: express.Request, res: express.Response): Promise<void>;
+    private getAuthHeaders;
+    private consumeCode;
+    private getAuthorizeUrl;
+    private getAppErrorUrl;
+}
+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 {};

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

@@ -0,0 +1,7 @@
+import { type Source, type SerializedSchema } from "@valbuild/core";
+import { type SourcePath } from "@valbuild/core/src/val";
+export type SerializedModuleContent = {
+    source: Source;
+    schema: SerializedSchema;
+    path: SourcePath;
+};

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

@@ -0,0 +1,24 @@
+import { QuickJSRuntime } from "quickjs-emscripten";
+import { Patch } from "@valbuild/core/patch";
+import { ValSourceFileHandler } from "./ValSourceFileHandler";
+import { IValFSHost } from "./ValFSHost";
+import { SerializedModuleContent } from "./SerializedModuleContent";
+import { ModuleId, ModulePath } from "@valbuild/core";
+export type ServiceOptions = {
+    /**
+     * Relative path to the val.config.js file from the root directory.
+     *
+     * @example src/val.config
+     */
+    valConfigPath: string;
+};
+export declare function createService(projectRoot: string, opts: ServiceOptions, host?: IValFSHost): Promise<Service>;
+export declare class Service {
+    private readonly sourceFileHandler;
+    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<SerializedModuleContent>;
+    dispose(): void;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * A filesystem that can update and read files.
+ * It does not support creating new files or directories.
+ *
+ */
+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;
+    fileExists(filePath: string): boolean;
+    readFile(filePath: string): string | undefined;
+    realpath(path: string): string;
+}

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

@@ -0,0 +1,23 @@
+import ts from "typescript";
+import { ValFS } from "./ValFS";
+/**
+ * An implementation of methods in the various ts.*Host interfaces
+ * that uses ValFS to resolve modules and read/write files.
+ */
+export interface IValFSHost extends ts.ParseConfigHost, ts.ModuleResolutionHost {
+    useCaseSensitiveFileNames: boolean;
+    writeFile(fileName: string, text: string, encoding: "binary" | "utf8"): void;
+}
+export declare class ValFSHost implements IValFSHost {
+    protected readonly valFS: ValFS;
+    protected readonly currentDirectory: string;
+    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;
+    getCurrentDirectory(): string;
+    getCanonicalFileName(fileName: string): string;
+    fileExists(fileName: string): boolean;
+    readFile(fileName: string): string | undefined;
+    realpath(path: string): string;
+}

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

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import type { IValFSHost } from "./ValFSHost";
+import { ValSourceFileHandler } from "./ValSourceFileHandler";
+export declare const createModuleLoader: (rootDir: string, host?: IValFSHost) => ValModuleLoader;
+export declare class ValModuleLoader {
+    readonly projectRoot: string;
+    private readonly compilerOptions;
+    private readonly sourceFileHandler;
+    private readonly host;
+    constructor(projectRoot: string, compilerOptions: ts.CompilerOptions, sourceFileHandler: ValSourceFileHandler, host?: IValFSHost);
+    getModule(modulePath: string): string;
+    resolveModulePath(containingFilePath: string, requestedModuleName: string): string;
+    private findMatchingJsFile;
+}

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

@@ -0,0 +1,7 @@
+import { QuickJSWASMModule } from "quickjs-emscripten";
+import { ValModuleLoader } from "./ValModuleLoader";
+export declare function newValQuickJSRuntime(quickJSModule: Pick<QuickJSWASMModule, "newRuntime">, moduleLoader: ValModuleLoader, { maxStackSize, // TODO: these were randomly chosen, we should figure out what the right values are:
+memoryLimit, }?: {
+    maxStackSize?: number;
+    memoryLimit?: number;
+}): Promise<import("quickjs-emscripten").QuickJSRuntime>;

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

@@ -0,0 +1,14 @@
+import express from "express";
+export interface ValServer {
+    authorize(req: express.Request, res: express.Response): Promise<void>;
+    callback(req: express.Request, res: express.Response): Promise<void>;
+    logout(req: express.Request, res: express.Response): Promise<void>;
+    session(req: express.Request, res: express.Response): Promise<void>;
+    getIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    patchIds(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
+    commit(req: express.Request, res: express.Response): Promise<void>;
+}

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

@@ -0,0 +1,12 @@
+import ts from "typescript";
+import { IValFSHost } from "./ValFSHost";
+export declare class ValSourceFileHandler {
+    private readonly projectRoot;
+    private readonly compilerOptions;
+    private readonly host;
+    constructor(projectRoot: string, compilerOptions: ts.CompilerOptions, host?: IValFSHost);
+    getSourceFile(filePath: string): ts.SourceFile | undefined;
+    writeSourceFile(sourceFile: ts.SourceFile): void;
+    writeFile(filePath: string, content: string, encoding: "binary" | "utf8"): void;
+    resolveSourceModulePath(containingFilePath: string, requestedModuleName: string): string;
+}

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

@@ -0,0 +1,3 @@
+import { RequestHandler } from "express";
+import { ValServer } from "./ValServer";
+export declare function createRequestHandler(valServer: ValServer): RequestHandler;

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

@@ -0,0 +1,4 @@
+import { SourcePath } from "@valbuild/core/src/val";
+export declare function getPathFromParams(params: {
+    0: string;
+}): SourcePath;

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare const getCompilerOptions: (rootDir: string, parseConfigHost: ts.ParseConfigHost) => ts.CompilerOptions;

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

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import type { RequestListener } from "node:http";
+import { ServiceOptions } from "./Service";
+type Opts = ValServerOverrides & ServiceOptions;
+type ValServerOverrides = Partial<{
+    /**
+     * Override the Val API key.
+     *
+     * Typically this is set using VAL_API_KEY env var.
+     *
+     * NOTE: if this is set you must also set valSecret or VAL_SECRET env var.
+     */
+    apiKey: string;
+    /**
+     * Override the Val session key.
+     *
+     * This can be any randomly generated string.
+     * It will be used for authentication between the frontend and val api
+     * endpoints in this app.
+     *
+     * Typically this is set using VAL_SECRET env var.
+     *
+     * NOTE: if this is set you must also set apiKey or VAL_API_KEY env var.
+     */
+    valSecret: string;
+    /**
+     * Override the default the mode of operation.
+     *
+     * Typically this should not be set.
+     *
+     * "local" means that changes will be written to the local filesystem,
+     * which is what you want when developing locally.
+     *
+     * "proxy" means that changes will proxied to https://app.val.build
+     * and eventually be committed in the Git repository.
+     *
+     * It will automatically be "proxy" if both VAL_API_KEY env var (or the apiKey property) and VAL_SECRET env var (or the valSecret property)
+     * is set.
+     *
+     * If both is missing, it will default to "local".
+     */
+    mode: "proxy" | "local";
+    /**
+     * Current git commit.
+     *
+     * Required if mode is "proxy".
+     *
+     * @example "e83c5163316f89bfbde7d9ab23ca2e25604af290"
+     */
+    gitCommit: string;
+    /**
+     * Current git branch.
+     *
+     * Required if mode is "proxy".
+     *
+     * @example "main"
+     */
+    gitBranch: string;
+    /**
+     * The base url of Val.
+     *
+     * Typically this should not be set.
+     *
+     * Can also be overridden using the VAL_BUILD_URL env var.
+     *
+     * @example "https://app.val.build"
+     */
+    valBuildUrl: string;
+}>;
+export declare function createRequestListener(route: string, opts: Opts): RequestListener;
+export {};

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

@@ -0,0 +1,12 @@
+export type { ServiceOptions } from "./Service";
+export { createService, Service } from "./Service";
+export { createRequestHandler } from "./createRequestHandler";
+export { createRequestListener } from "./hosting";
+export { ValModuleLoader } from "./ValModuleLoader";
+export { getCompilerOptions } from "./getCompilerOptions";
+export { ValSourceFileHandler } from "./ValSourceFileHandler";
+export { ValFSHost } from "./ValFSHost";
+export type { IValFSHost } from "./ValFSHost";
+export type { ValFS } from "./ValFS";
+export { patchSourceFile } from "./patchValFile";
+export { formatSyntaxErrorTree } from "./patch/ts/syntax";

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

@@ -0,0 +1,3 @@
+export declare function decodeJwt(token: string, secretKey?: string): unknown | null;
+export declare function getExpire(): number;
+export declare function encodeJwt(payload: object, sessionKey: string): string;

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

@@ -0,0 +1,27 @@
+import ts from "typescript";
+import { result, array } from "@valbuild/core/fp";
+import { ValSyntaxErrorTree } from "./syntax";
+import { Ops, PatchError, JSONValue } from "@valbuild/core/patch";
+type TSOpsResult<T> = result.Result<T, PatchError | ValSyntaxErrorTree>;
+declare module "typescript" {
+    interface PrinterOptions {
+        /**
+         * Internal option that stops printing unnecessary ASCII escape sequences
+         * in strings, though it might have unintended effects. Might be useful?
+         */
+        neverAsciiEscape?: boolean;
+    }
+}
+export declare function getFromNode(node: ts.Expression, key: string): TSOpsResult<ts.Expression | undefined>;
+export declare class TSOps implements Ops<ts.SourceFile, ValSyntaxErrorTree> {
+    private findRoot;
+    constructor(findRoot: (document: ts.SourceFile) => result.Result<ts.Expression, ValSyntaxErrorTree>);
+    get(document: ts.SourceFile, path: string[]): TSOpsResult<JSONValue>;
+    add(document: ts.SourceFile, path: string[], value: JSONValue): TSOpsResult<ts.SourceFile>;
+    remove(document: ts.SourceFile, path: array.NonEmptyArray<string>): TSOpsResult<ts.SourceFile>;
+    replace(document: ts.SourceFile, path: string[], value: JSONValue): TSOpsResult<ts.SourceFile>;
+    move(document: ts.SourceFile, from: array.NonEmptyArray<string>, path: string[]): TSOpsResult<ts.SourceFile>;
+    copy(document: ts.SourceFile, from: string[], path: string[]): TSOpsResult<ts.SourceFile>;
+    test(document: ts.SourceFile, path: string[], value: JSONValue): TSOpsResult<boolean>;
+}
+export {};

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

@@ -0,0 +1,49 @@
+import ts from "typescript";
+import { result } from "@valbuild/core/fp";
+import { JSONValue } from "@valbuild/core/patch";
+export declare class ValSyntaxError {
+    message: string;
+    node: ts.Node;
+    constructor(message: string, node: ts.Node);
+}
+export type ValSyntaxErrorTree = ValSyntaxError | [ValSyntaxErrorTree, ...ValSyntaxErrorTree[]];
+export declare function flattenErrors(tree: ValSyntaxErrorTree): [ValSyntaxError, ...ValSyntaxError[]];
+export declare function flatMapErrors<T>(tree: ValSyntaxErrorTree, cb: (error: ValSyntaxError) => T): [T, ...T[]];
+export declare function formatSyntaxError(error: ValSyntaxError, sourceFile: ts.SourceFile): string;
+export declare function formatSyntaxErrorTree(tree: ValSyntaxErrorTree, sourceFile: ts.SourceFile): string[];
+type LiteralPropertyName = (ts.Identifier | ts.StringLiteral | ts.NumericLiteral) & {
+    /**
+     * The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
+     * or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.
+     * For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
+     * https://github.com/microsoft/TypeScript/blob/4b794fe1dd0d184d3f8f17e94d8187eace57c91e/src/compiler/types.ts#L2127-L2131
+     */
+    name: string;
+};
+type LiteralPropertyAssignment = ts.PropertyAssignment & {
+    name: LiteralPropertyName;
+};
+/**
+ * Validates that the expression is a JSON compatible type of expression without
+ * validating its children.
+ */
+export declare function shallowValidateExpression(value: ts.Expression): ValSyntaxError | undefined;
+/**
+ * Validates that the expression is JSON compatible.
+ */
+export declare function deepValidateExpression(value: ts.Expression): result.Result<void, ValSyntaxErrorTree>;
+/**
+ * Evaluates the expression as a JSON value
+ */
+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 findValFileNodeArg(node: ts.CallExpression): result.Result<ts.StringLiteral, ValSyntaxErrorTree>;
+export declare function findValFileMetadataArg(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 {};

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

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { result } from "@valbuild/core/fp";
+import { ValSyntaxErrorTree } from "./syntax";
+export type ValModuleAnalysis = {
+    schema: ts.Expression;
+    source: ts.Expression;
+};
+export declare function analyzeValModule(sourceFile: ts.SourceFile): result.Result<ValModuleAnalysis, ValSyntaxErrorTree>;

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

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

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

@@ -0,0 +1,9 @@
+import { Patch, PatchError } from "@valbuild/core/patch";
+import { result } from "@valbuild/core/fp";
+import { type ValSyntaxErrorTree } from "./patch/ts/syntax";
+import { ValSourceFileHandler } from "./ValSourceFileHandler";
+import { QuickJSRuntime } from "quickjs-emscripten";
+import ts from "typescript";
+import { SerializedModuleContent } from "./SerializedModuleContent";
+export declare const patchValFile: (id: string, valConfigPath: string, patch: Patch, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime) => Promise<SerializedModuleContent>;
+export declare const patchSourceFile: (sourceFile: ts.SourceFile, patch: Patch) => result.Result<ts.SourceFile, ValSyntaxErrorTree | PatchError>;

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

@@ -0,0 +1,3 @@
+import { QuickJSRuntime } from "quickjs-emscripten";
+import { SerializedModuleContent } from "./SerializedModuleContent";
+export declare const readValFile: (id: string, valConfigPath: string, runtime: QuickJSRuntime) => Promise<SerializedModuleContent>;

package/dist/valbuild-server.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index";
+//# sourceMappingURL=valbuild-server.cjs.d.ts.map

package/dist/valbuild-server.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valbuild-server.cjs.d.ts","sourceRoot":"","sources":["./declarations/src/index.d.ts"],"names":[],"mappings":"AAAA"}