@valbuild/server 0.26.0 → 0.27.0

package/src/patch/ts/syntax.ts

@@ -1,371 +0,0 @@
-import ts from "typescript";
-import { result, pipe } from "@valbuild/core/fp";
-import { JSONValue } from "@valbuild/core/patch";
-import { FileSource, FILE_REF_PROP } from "@valbuild/core";
-import { JsonPrimitive } from "@valbuild/core/src/Json";
-
-export class ValSyntaxError {
-  constructor(public message: string, public node: ts.Node) {}
-}
-
-export type ValSyntaxErrorTree =
-  | ValSyntaxError
-  | [ValSyntaxErrorTree, ...ValSyntaxErrorTree[]];
-
-function forEachError(
-  tree: ValSyntaxErrorTree,
-  callback: (error: ValSyntaxError) => void
-) {
-  if (Array.isArray(tree)) {
-    for (const subtree of tree) {
-      forEachError(subtree, callback);
-    }
-  } else {
-    callback(tree);
-  }
-}
-
-export function flattenErrors(
-  tree: ValSyntaxErrorTree
-): [ValSyntaxError, ...ValSyntaxError[]] {
-  const result: ValSyntaxError[] = [];
-  forEachError(tree, result.push.bind(result));
-  return result as [ValSyntaxError, ...ValSyntaxError[]];
-}
-
-export function flatMapErrors<T>(
-  tree: ValSyntaxErrorTree,
-  cb: (error: ValSyntaxError) => T
-): [T, ...T[]] {
-  const result: T[] = [];
-  forEachError(tree, (error) => result.push(cb(error)));
-  return result as [T, ...T[]];
-}
-
-export function formatSyntaxError(
-  error: ValSyntaxError,
-  sourceFile: ts.SourceFile
-): string {
-  const pos = sourceFile.getLineAndCharacterOfPosition(error.node.pos);
-  return `${pos.line}:${pos.character} ${error.message}`;
-}
-
-export function formatSyntaxErrorTree(
-  tree: ValSyntaxErrorTree,
-  sourceFile: ts.SourceFile
-): string[] {
-  return flatMapErrors(tree, (error) => formatSyntaxError(error, sourceFile));
-}
-
-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;
-};
-
-function isLiteralPropertyName(
-  name: ts.PropertyName
-): name is LiteralPropertyName {
-  return (
-    ts.isIdentifier(name) ||
-    ts.isStringLiteral(name) ||
-    ts.isNumericLiteral(name)
-  );
-}
-
-type LiteralPropertyAssignment = ts.PropertyAssignment & {
-  name: LiteralPropertyName;
-};
-
-function validateObjectProperties<
-  T extends readonly ts.ObjectLiteralElementLike[]
->(
-  nodes: T
-): result.Result<T & readonly LiteralPropertyAssignment[], ValSyntaxErrorTree> {
-  const errors: ValSyntaxError[] = [];
-  for (const node of nodes) {
-    if (!ts.isPropertyAssignment(node)) {
-      errors.push(
-        new ValSyntaxError(
-          "Object literal element must be property assignment",
-          node
-        )
-      );
-    } else if (!isLiteralPropertyName(node.name)) {
-      errors.push(
-        new ValSyntaxError(
-          "Object literal element key must be an identifier or a literal",
-          node
-        )
-      );
-    }
-  }
-  if (errors.length > 0) {
-    return result.err(errors as ValSyntaxErrorTree);
-  }
-  return result.ok(nodes as T & LiteralPropertyAssignment[]);
-}
-
-/**
- * Validates that the expression is a JSON compatible type of expression without
- * validating its children.
- */
-export function shallowValidateExpression(
-  value: ts.Expression
-): ValSyntaxError | undefined {
-  return ts.isStringLiteralLike(value) ||
-    ts.isNumericLiteral(value) ||
-    value.kind === ts.SyntaxKind.TrueKeyword ||
-    value.kind === ts.SyntaxKind.FalseKeyword ||
-    value.kind === ts.SyntaxKind.NullKeyword ||
-    ts.isArrayLiteralExpression(value) ||
-    ts.isObjectLiteralExpression(value) ||
-    isValFileMethodCall(value)
-    ? undefined
-    : new ValSyntaxError(
-        "Expression must be a literal or call val.file",
-        value
-      );
-}
-
-/**
- * Validates that the expression is JSON compatible.
- */
-export function deepValidateExpression(
-  value: ts.Expression
-): result.Result<void, ValSyntaxErrorTree> {
-  if (ts.isStringLiteralLike(value)) {
-    return result.voidOk;
-  } else if (ts.isNumericLiteral(value)) {
-    return result.voidOk;
-  } else if (value.kind === ts.SyntaxKind.TrueKeyword) {
-    return result.voidOk;
-  } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
-    return result.voidOk;
-  } else if (value.kind === ts.SyntaxKind.NullKeyword) {
-    return result.voidOk;
-  } else if (ts.isArrayLiteralExpression(value)) {
-    return result.allV(value.elements.map(deepValidateExpression));
-  } else if (ts.isObjectLiteralExpression(value)) {
-    return pipe(
-      validateObjectProperties(value.properties),
-      result.flatMap((assignments: ts.NodeArray<LiteralPropertyAssignment>) =>
-        pipe(
-          assignments.map((assignment) =>
-            deepValidateExpression(assignment.initializer)
-          ),
-          result.allV
-        )
-      )
-    );
-  } else if (isValFileMethodCall(value)) {
-    if (value.arguments.length >= 1) {
-      if (!ts.isStringLiteralLike(value.arguments[0])) {
-        return result.err(
-          new ValSyntaxError(
-            "First argument of val.file must be a string literal",
-            value.arguments[0]
-          )
-        );
-      }
-    }
-    if (value.arguments.length === 2) {
-      if (!ts.isObjectLiteralExpression(value.arguments[1])) {
-        return result.err(
-          new ValSyntaxError(
-            "Second argument of val.file must be an object literal",
-            value.arguments[1]
-          )
-        );
-      }
-    }
-    return result.voidOk;
-  } else {
-    return result.err(
-      new ValSyntaxError("Expression must be a literal or call val.file", value)
-    );
-  }
-}
-
-/**
- * Evaluates the expression as a JSON value
- */
-export function evaluateExpression(
-  value: ts.Expression
-): result.Result<JSONValue, ValSyntaxErrorTree> {
-  // 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
-
-  if (ts.isStringLiteralLike(value)) {
-    return result.ok(value.text);
-  } else if (ts.isNumericLiteral(value)) {
-    return result.ok(Number(value.text));
-  } else if (value.kind === ts.SyntaxKind.TrueKeyword) {
-    return result.ok(true);
-  } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
-    return result.ok(false);
-  } else if (value.kind === ts.SyntaxKind.NullKeyword) {
-    return result.ok(null);
-  } else if (ts.isArrayLiteralExpression(value)) {
-    return result.all(value.elements.map(evaluateExpression));
-  } else if (ts.isObjectLiteralExpression(value)) {
-    return pipe(
-      validateObjectProperties(value.properties),
-      result.flatMap((assignments: ts.NodeArray<LiteralPropertyAssignment>) =>
-        pipe(
-          assignments.map((assignment) =>
-            pipe(
-              evaluateExpression(assignment.initializer),
-              result.map<JSONValue, [key: string, value: JSONValue]>(
-                (value) => [assignment.name.text, value]
-              )
-            )
-          ),
-          result.all
-        )
-      ),
-      result.map(Object.fromEntries)
-    );
-  } else if (isValFileMethodCall(value)) {
-    return pipe(
-      findValFileNodeArg(value),
-      result.flatMap((ref) => {
-        if (value.arguments.length === 2) {
-          return pipe(
-            evaluateExpression(value.arguments[1]),
-            result.map(
-              (metadata) =>
-                ({
-                  [FILE_REF_PROP]: ref.text,
-                  _type: "file",
-                  metadata,
-                } as FileSource<{ [key: string]: JsonPrimitive }>)
-            )
-          );
-        } else {
-          return result.ok({
-            [FILE_REF_PROP]: ref.text,
-            _type: "file",
-          } as FileSource<{ [key: string]: JsonPrimitive }>);
-        }
-      })
-    );
-  } else {
-    return result.err(
-      new ValSyntaxError("Expression must be a literal or call val.file", value)
-    );
-  }
-}
-
-export function findObjectPropertyAssignment(
-  value: ts.ObjectLiteralExpression,
-  key: string
-): result.Result<LiteralPropertyAssignment | undefined, ValSyntaxErrorTree> {
-  return pipe(
-    validateObjectProperties(value.properties),
-    result.flatMap((assignments: ts.NodeArray<LiteralPropertyAssignment>) => {
-      const matchingAssignments = assignments.filter(
-        (assignment) => assignment.name.text === key
-      );
-      if (matchingAssignments.length === 0) return result.ok(undefined);
-      if (matchingAssignments.length > 1) {
-        return result.err(
-          new ValSyntaxError(`Object key "${key}" is ambiguous`, value)
-        );
-      }
-      const [assignment] = matchingAssignments;
-      return result.ok(assignment);
-    })
-  );
-}
-
-export function isValFileMethodCall(
-  node: ts.Expression
-): node is ts.CallExpression {
-  return (
-    ts.isCallExpression(node) &&
-    ts.isPropertyAccessExpression(node.expression) &&
-    ts.isIdentifier(node.expression.expression) &&
-    node.expression.expression.text === "val" &&
-    node.expression.name.text === "file"
-  );
-}
-
-export function findValFileNodeArg(
-  node: ts.CallExpression
-): result.Result<ts.StringLiteral, ValSyntaxErrorTree> {
-  if (node.arguments.length === 0) {
-    return result.err(
-      new ValSyntaxError(`Invalid val.file() call: missing ref argument`, node)
-    );
-  } else if (node.arguments.length > 2) {
-    return result.err(
-      new ValSyntaxError(
-        `Invalid val.file() call: too many arguments ${node.arguments.length}}`,
-        node
-      )
-    );
-  } else if (!ts.isStringLiteral(node.arguments[0])) {
-    return result.err(
-      new ValSyntaxError(
-        `Invalid val.file() call: ref must be a string literal`,
-        node
-      )
-    );
-  }
-  const refNode = node.arguments[0];
-  return result.ok(refNode);
-}
-export function findValFileMetadataArg(
-  node: ts.CallExpression
-): result.Result<ts.ObjectLiteralExpression | undefined, ValSyntaxErrorTree> {
-  if (node.arguments.length === 0) {
-    return result.err(
-      new ValSyntaxError(`Invalid val.file() call: missing ref argument`, node)
-    );
-  } else if (node.arguments.length > 2) {
-    return result.err(
-      new ValSyntaxError(
-        `Invalid val.file() call: too many arguments ${node.arguments.length}}`,
-        node
-      )
-    );
-  } else if (node.arguments.length === 2) {
-    if (!ts.isObjectLiteralExpression(node.arguments[1])) {
-      return result.err(
-        new ValSyntaxError(
-          `Invalid val.file() call: metadata must be a object literal`,
-          node
-        )
-      );
-    }
-    return result.ok(node.arguments[1]);
-  }
-  return result.ok(undefined);
-}
-
-/**
- * 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 function validateInitializers(
-  nodes: ReadonlyArray<ts.Expression>
-): ValSyntaxErrorTree | undefined {
-  for (const node of nodes) {
-    if (ts.isSpreadElement(node)) {
-      return new ValSyntaxError("Unexpected spread element", node);
-    }
-  }
-  return undefined;
-}

package/src/patch/ts/valModule.test.ts

@@ -1,26 +0,0 @@
-import { result } from "@valbuild/core/fp";
-import ts from "typescript";
-import { analyzeValModule, ValModuleAnalysis } from "./valModule";
-
-test("analyzeValModule", () => {
-  const sourceText = `import {s, val } from "./val.config";
-export default val.content("/test", s.string(), "test");`;
-  const sourceFile = ts.createSourceFile(
-    "test.ts",
-    sourceText,
-    ts.ScriptTarget.ES2020,
-    true
-  );
-
-  const analysis = analyzeValModule(sourceFile);
-  expect(analysis).toEqual(
-    result.ok<ValModuleAnalysis>({
-      schema: expect.anything(),
-      source: expect.anything(),
-    })
-  );
-
-  const { schema, source } = (analysis as result.Ok<ValModuleAnalysis>).value;
-  expect(schema.getStart(sourceFile)).toBe(sourceText.indexOf("s.string()"));
-  expect(source.getStart(sourceFile)).toBe(sourceText.indexOf(`"test"`));
-});

package/src/patch/ts/valModule.ts

@@ -1,110 +0,0 @@
-import ts from "typescript";
-import { result, pipe } from "@valbuild/core/fp";
-import { ValSyntaxError, ValSyntaxErrorTree } from "./syntax";
-
-export type ValModuleAnalysis = {
-  schema: ts.Expression;
-  source: ts.Expression;
-};
-
-function isPath(
-  node: ts.Expression,
-  path: readonly [string, ...string[]]
-): boolean {
-  let currentNode = node;
-  for (let i = path.length - 1; i > 0; --i) {
-    const name = path[i];
-    if (!ts.isPropertyAccessExpression(currentNode)) {
-      return false;
-    }
-    if (!ts.isIdentifier(currentNode.name) || currentNode.name.text !== name) {
-      return false;
-    }
-    currentNode = currentNode.expression;
-  }
-  return ts.isIdentifier(currentNode) && currentNode.text === path[0];
-}
-
-function validateArguments(
-  node: ts.CallExpression,
-  validators: readonly ((
-    node: ts.Expression
-  ) => result.Result<void, ValSyntaxError>)[]
-): result.Result<void, ValSyntaxErrorTree> {
-  return result.allV<ValSyntaxError>([
-    node.arguments.length === validators.length
-      ? result.voidOk
-      : result.err(
-          new ValSyntaxError(`Expected ${validators.length} arguments`, node)
-        ),
-    ...node.arguments
-      .slice(0, validators.length)
-      .map((argument, index) => validators[index](argument)),
-  ]);
-}
-
-function analyzeDefaultExport(
-  node: ts.ExportAssignment
-): result.Result<ValModuleAnalysis, ValSyntaxErrorTree> {
-  const valContentCall = node.expression;
-  if (!ts.isCallExpression(valContentCall)) {
-    return result.err(
-      new ValSyntaxError(
-        "Expected default expression to be a call expression",
-        valContentCall
-      )
-    );
-  }
-
-  if (!isPath(valContentCall.expression, ["val", "content"])) {
-    return result.err(
-      new ValSyntaxError(
-        "Expected default expression to be calling val.content",
-        valContentCall.expression
-      )
-    );
-  }
-
-  return pipe(
-    validateArguments(valContentCall, [
-      (id: ts.Node) => {
-        // TODO: validate ID value here?
-        if (!ts.isStringLiteralLike(id)) {
-          return result.err(
-            new ValSyntaxError(
-              "Expected first argument to val.content to be a string literal",
-              id
-            )
-          );
-        }
-        return result.voidOk;
-      },
-      () => {
-        return result.voidOk;
-      },
-      () => {
-        return result.voidOk;
-      },
-    ]),
-    result.map(() => {
-      const [, schema, source] = valContentCall.arguments;
-      return { schema, source };
-    })
-  );
-}
-
-export function analyzeValModule(
-  sourceFile: ts.SourceFile
-): result.Result<ValModuleAnalysis, ValSyntaxErrorTree> {
-  const analysis = sourceFile.forEachChild((node) => {
-    if (ts.isExportAssignment(node)) {
-      return analyzeDefaultExport(node);
-    }
-  });
-
-  if (!analysis) {
-    throw Error("Failed to find fixed content node in val module");
-  }
-
-  return analysis;
-}

package/src/patch/validation.ts

@@ -1,81 +0,0 @@
-import type {
-  JSONValue as JSONValueT,
-  OperationJSON as OperationJSONT,
-  PatchJSON as PatchJSONT,
-} from "@valbuild/core/patch";
-import z from "zod";
-
-const JSONValueT: z.ZodType<JSONValueT> = z.lazy(() =>
-  z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(JSONValueT),
-    z.record(JSONValueT),
-  ])
-);
-
-/**
- * Raw JSON patch operation.
- */
-const OperationJSONT: z.ZodType<OperationJSONT> = z.discriminatedUnion("op", [
-  z
-    .object({
-      op: z.literal("add"),
-      path: z.string(),
-      value: JSONValueT,
-    })
-    .strict(),
-  z
-    .object({
-      op: z.literal("remove"),
-      /**
-       * Must be non-root
-       */
-      path: z.string(),
-    })
-    .strict(),
-  z
-    .object({
-      op: z.literal("replace"),
-      path: z.string(),
-      value: JSONValueT,
-    })
-    .strict(),
-  z
-    .object({
-      op: z.literal("move"),
-      /**
-       * Must be non-root and not a proper prefix of "path".
-       */
-      from: z.string(),
-      path: z.string(),
-    })
-    .strict(),
-  z
-    .object({
-      op: z.literal("copy"),
-      from: z.string(),
-      path: z.string(),
-    })
-    .strict(),
-  z
-    .object({
-      op: z.literal("test"),
-      path: z.string(),
-      value: JSONValueT,
-    })
-    .strict(),
-  z
-    .object({
-      op: z.literal("file"),
-      path: z.string(),
-      filePath: z.string(),
-      value: z.string(),
-    })
-    .strict(),
-]);
-
-export const PatchJSON: z.ZodType<PatchJSONT> = z.array(OperationJSONT);
-export type PatchJSON = PatchJSONT;

package/src/patchValFile.ts

@@ -1,110 +0,0 @@
-import { analyzeValModule } from "./patch/ts/valModule";
-import { applyPatch, Patch, PatchError } from "@valbuild/core/patch";
-import { TSOps } from "./patch/ts/ops";
-import { result, pipe } from "@valbuild/core/fp";
-import {
-  flatMapErrors,
-  formatSyntaxError,
-  type ValSyntaxErrorTree,
-} from "./patch/ts/syntax";
-import { ValSourceFileHandler } from "./ValSourceFileHandler";
-import { derefPatch } from "@valbuild/core";
-import { readValFile } from "./readValFile";
-import { QuickJSRuntime } from "quickjs-emscripten";
-import ts from "typescript";
-import { SerializedModuleContent } from "./SerializedModuleContent";
-
-const ops = new TSOps((document) => {
-  return pipe(
-    analyzeValModule(document),
-    result.map(({ source }) => source)
-  );
-});
-
-// TODO: rename to patchValFiles since we may write multiple files
-export const patchValFile = async (
-  id: string,
-  valConfigPath: string,
-  patch: Patch,
-  sourceFileHandler: ValSourceFileHandler,
-  runtime: QuickJSRuntime
-): Promise<SerializedModuleContent> => {
-  const filePath = sourceFileHandler.resolveSourceModulePath(
-    valConfigPath,
-    `.${id}.val`
-  );
-
-  const sourceFile = sourceFileHandler.getSourceFile(filePath);
-
-  if (!sourceFile) {
-    throw Error(`Source file ${filePath} not found`);
-  }
-
-  const derefRes = derefPatch(patch, sourceFile, ops);
-  if (result.isErr(derefRes)) {
-    throw derefRes.error;
-  }
-
-  const dereferencedPatch = derefRes.value.dereferencedPatch; // TODO: add ref changes to remote replace/add, ...
-  const newSourceFile = patchSourceFile(sourceFile, dereferencedPatch);
-  if (result.isErr(newSourceFile)) {
-    if (newSourceFile.error instanceof PatchError) {
-      throw newSourceFile.error;
-    } else {
-      throw new Error(
-        `${filePath}\n${flatMapErrors(newSourceFile.error, (error) =>
-          formatSyntaxError(error, sourceFile)
-        ).join("\n")}`
-      );
-    }
-  }
-  for (const [filePath, content] of Object.entries(
-    derefRes.value.fileUpdates
-  )) {
-    // Evaluate if we want to make these writes (more) atomic with a temp file and a move.
-    // This can potentially fill mid-way if there is not enough space on disk for example...
-    // However, that might be add add bit more complexity in our host and virtual file systems?
-    // Example:
-    // const tempFilePath = sourceFileHandler.writeTempFile(
-    //   Buffer.from(content, "base64").toString("binary")
-    // );
-    // sourceFileHandler.moveFile(tempFilePath, "." + filePath);
-    // TODO: ensure that directory exists
-    if (content.startsWith("data:/image/svg+xml")) {
-      sourceFileHandler.writeFile(
-        "." + filePath,
-        convertDataUrlToBase64(content).toString("utf8"),
-        "utf8"
-      );
-    } else {
-      sourceFileHandler.writeFile(
-        "." + filePath,
-        convertDataUrlToBase64(content).toString("binary"),
-        "binary"
-      );
-    }
-  }
-
-  sourceFileHandler.writeSourceFile(newSourceFile.value);
-
-  return readValFile(id, valConfigPath, runtime);
-};
-
-function convertDataUrlToBase64(dataUrl: string): Buffer {
-  const base64 = dataUrl.slice(dataUrl.indexOf(",") + 1);
-  return Buffer.from(base64, "base64");
-}
-
-export const patchSourceFile = (
-  sourceFile: ts.SourceFile | string,
-  patch: Patch
-): result.Result<ts.SourceFile, ValSyntaxErrorTree | PatchError> => {
-  if (typeof sourceFile === "string") {
-    return applyPatch(
-      ts.createSourceFile("<val>", sourceFile, ts.ScriptTarget.ES2015),
-      ops,
-      patch
-    );
-  }
-  return applyPatch(sourceFile, ops, patch);
-};