@valbuild/server 0.26.0 → 0.27.0

package/src/getCompilerOptions.ts

@@ -1,50 +0,0 @@
-import path from "path";
-import ts from "typescript";
-
-export const getCompilerOptions = (
-  rootDir: string,
-  parseConfigHost: ts.ParseConfigHost
-): ts.CompilerOptions => {
-  const tsConfigPath = path.resolve(rootDir, "tsconfig.json");
-  const jsConfigPath = path.resolve(rootDir, "jsconfig.json");
-  let configFilePath: string;
-  if (parseConfigHost.fileExists(jsConfigPath)) {
-    configFilePath = jsConfigPath;
-  } else if (parseConfigHost.fileExists(tsConfigPath)) {
-    configFilePath = tsConfigPath;
-  } else {
-    throw Error(
-      `Could not read config from: "${tsConfigPath}" nor "${jsConfigPath}". Root dir: "${rootDir}"`
-    );
-  }
-  const { config, error } = ts.readConfigFile(
-    configFilePath,
-    parseConfigHost.readFile.bind(parseConfigHost)
-  );
-  if (error) {
-    if (typeof error.messageText === "string") {
-      throw Error(
-        `Could not parse config file: ${configFilePath}. Error: ${error.messageText}`
-      );
-    }
-    throw Error(
-      `Could not parse config file: ${configFilePath}. Error: ${error.messageText.messageText}`
-    );
-  }
-  const optionsOverrides = undefined;
-  const parsedConfigFile = ts.parseJsonConfigFileContent(
-    config,
-    parseConfigHost,
-    rootDir,
-    optionsOverrides,
-    configFilePath
-  );
-  if (parsedConfigFile.errors.length > 0) {
-    throw Error(
-      `Could not parse config file: ${configFilePath}. Errors: ${parsedConfigFile.errors
-        .map((e) => e.messageText)
-        .join("\n")}`
-    );
-  }
-  return parsedConfigFile.options;
-};

package/src/hosting.ts

@@ -1,290 +0,0 @@
-import type { RequestListener } from "node:http";
-import express from "express";
-import { createService, ServiceOptions } from "./Service";
-import { createRequestHandler } from "./createRequestHandler";
-import { ValServer } from "./ValServer";
-import { LocalValServer, LocalValServerOptions } from "./LocalValServer";
-import { ProxyValServer, ProxyValServerOptions } from "./ProxyValServer";
-import { promises as fs } from "fs";
-import * as path from "path";
-
-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;
-  /**
-   * The base url of Val content.
-   *
-   * Typically this should not be set.
-   *
-   * Can also be overridden using the VAL_CONTENT_URL env var.
-   *
-   * @example "https://content.val.build"
-   */
-  valContentUrl: string;
-  /**
-   * The full name of this Val project.
-   *
-   * Typically this is set using the VAL_NAME env var.
-   *
-   * @example "myorg/my-project"
-   */
-  valName: string;
-  /**
-   * After Val is enabled, redirect to this url.
-   *
-   * May be used to setup a custom flow after enabling Val.
-   *
-   *This can be set using the VAL_ENABLE_REDIRECT_URL env var.
-   *
-   * @example "/api/draft/enable"
-   */
-  valEnableRedirectUrl?: string;
-  /**
-   * After Val is disabled, redirect to this url.
-   *
-   * May be used to setup a custom flow after disabling Val.
-   *
-   * This can be set using the VAL_DISABLE_REDIRECT_URL env var.
-   *
-   * @example "/api/draft/enable"
-   */
-  valDisableRedirectUrl?: string;
-}>;
-
-async function _createRequestListener(
-  route: string,
-  opts: Opts
-): Promise<RequestListener> {
-  const serverOpts = await initHandlerOptions(route, opts);
-  let valServer: ValServer;
-  if (serverOpts.mode === "proxy") {
-    valServer = new ProxyValServer(serverOpts);
-  } else {
-    valServer = new LocalValServer(serverOpts);
-  }
-  const reqHandler = createRequestHandler(valServer);
-  return express().use(route, reqHandler);
-}
-
-type ValServerOptions =
-  | ({ mode: "proxy" } & ProxyValServerOptions)
-  | ({ mode: "local" } & LocalValServerOptions);
-async function initHandlerOptions(
-  route: string,
-  opts: ValServerOverrides & ServiceOptions
-): Promise<ValServerOptions> {
-  const maybeApiKey = opts.apiKey || process.env.VAL_API_KEY;
-  const maybeValSecret = opts.valSecret || process.env.VAL_SECRET;
-  const isProxyMode =
-    opts.mode === "proxy" ||
-    (opts.mode === undefined && (maybeApiKey || maybeValSecret));
-
-  if (isProxyMode) {
-    const valBuildUrl =
-      opts.valBuildUrl || process.env.VAL_BUILD_URL || "https://app.val.build";
-    if (!maybeApiKey || !maybeValSecret) {
-      throw new Error(
-        "VAL_API_KEY and VAL_SECRET env vars must both be set in proxy mode"
-      );
-    }
-    const valContentUrl =
-      opts.valContentUrl ||
-      process.env.VAL_CONTENT_URL ||
-      "https://content.val.build";
-    const maybeGitCommit = opts.gitCommit || process.env.VAL_GIT_COMMIT;
-    if (!maybeGitCommit) {
-      throw new Error("VAL_GIT_COMMIT env var must be set in proxy mode");
-    }
-    const maybeGitBranch = opts.gitBranch || process.env.VAL_GIT_BRANCH;
-    if (!maybeGitBranch) {
-      throw new Error("VAL_GIT_BRANCH env var must be set in proxy mode");
-    }
-    const maybeValName = opts.gitBranch || process.env.VAL_NAME;
-    if (!maybeValName) {
-      throw new Error("VAL_NAME env var must be set in proxy mode");
-    }
-    return {
-      mode: "proxy",
-      route,
-      apiKey: maybeApiKey,
-      valSecret: maybeValSecret,
-      valBuildUrl,
-      valContentUrl,
-      gitCommit: maybeGitCommit,
-      gitBranch: maybeGitBranch,
-      valName: maybeValName,
-      valEnableRedirectUrl:
-        opts.valEnableRedirectUrl || process.env.VAL_ENABLE_REDIRECT_URL,
-      valDisableRedirectUrl:
-        opts.valDisableRedirectUrl || process.env.VAL_DISABLE_REDIRECT_URL,
-    };
-  } else {
-    const cwd = process.cwd();
-    const service = await createService(cwd, opts);
-    const git = await safeReadGit(cwd);
-    return {
-      mode: "local",
-      service,
-      git: {
-        commit: process.env.VAL_GIT_COMMIT || git.commit,
-        branch: process.env.VAL_GIT_BRANCH || git.branch,
-      },
-    };
-  }
-}
-
-export async function safeReadGit(
-  cwd: string
-): Promise<{ commit?: string; branch?: string }> {
-  async function findGitHead(
-    currentDir: string,
-    depth: number
-  ): Promise<{ commit?: string; branch?: string }> {
-    const gitHeadPath = path.join(currentDir, ".git", "HEAD");
-    if (depth > 1000) {
-      console.error(
-        `Reached max depth while scanning for .git folder. Current working dir: ${cwd}.`
-      );
-      return {
-        commit: undefined,
-        branch: undefined,
-      };
-    }
-
-    try {
-      const headContents = await fs.readFile(gitHeadPath, "utf-8");
-      const match = headContents.match(/^ref: refs\/heads\/(.+)/);
-      if (match) {
-        const branchName = match[1];
-        return {
-          branch: branchName,
-          commit: await readCommit(currentDir, branchName),
-        };
-      } else {
-        return {
-          commit: undefined,
-          branch: undefined,
-        };
-      }
-    } catch (error) {
-      const parentDir = path.dirname(currentDir);
-
-      // We've reached the root directory
-      if (parentDir === currentDir) {
-        return {
-          commit: undefined,
-          branch: undefined,
-        };
-      }
-      return findGitHead(parentDir, depth + 1);
-    }
-  }
-
-  try {
-    return findGitHead(cwd, 0);
-  } catch (err) {
-    console.error("Error while reading .git", err);
-    return {
-      commit: undefined,
-      branch: undefined,
-    };
-  }
-}
-
-async function readCommit(
-  gitDir: string,
-  branchName: string
-): Promise<string | undefined> {
-  try {
-    return (
-      await fs.readFile(
-        path.join(gitDir, ".git", "refs", "heads", branchName),
-        "utf-8"
-      )
-    ).trim();
-  } catch (err) {
-    return undefined;
-  }
-}
-
-// TODO: rename to createValApiHandlers?
-export function createRequestListener(
-  route: string,
-  opts: Opts
-): RequestListener {
-  const handler = _createRequestListener(route, opts);
-  return async (req, res) => {
-    try {
-      return (await handler)(req, res);
-    } catch (e) {
-      res.statusCode = 500;
-      res.write(e instanceof Error ? e.message : "Unknown error");
-      res.end();
-      return;
-    }
-  };
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-export type { ServiceOptions } from "./Service";
-export { createService, Service } from "./Service";
-export { createRequestHandler } from "./createRequestHandler";
-export { createRequestListener, safeReadGit } 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";
-export { LocalValServer } from "./LocalValServer";
-export { createFixPatch } from "./createFixPatch";
-export { PatchJSON } from "./patch/validation";
-export * from "./jwt";

package/src/jwt.ts

@@ -1,93 +0,0 @@
-import crypto from "crypto";
-import { z } from "zod";
-
-export type JwtPayload = {
-  sub: string;
-  exp: number;
-  org: string;
-  project: string;
-};
-
-export function decodeJwt(
-  token: string,
-  secretKey?: string
-): JwtPayload | null {
-  const [headerBase64, payloadBase64, signatureBase64, ...rest] =
-    token.split(".");
-  if (!headerBase64 || !payloadBase64 || !signatureBase64 || rest.length > 0) {
-    console.debug(
-      "Invalid JWT: format is not exactly {header}.{payload}.{signature}",
-      token
-    );
-    return null;
-  }
-
-  try {
-    const parsedHeader = JSON.parse(
-      Buffer.from(headerBase64, "base64").toString("utf8")
-    ) as unknown;
-    const headerVerification = JwtHeaderSchema.safeParse(parsedHeader);
-    if (!headerVerification.success) {
-      console.debug("Invalid JWT: invalid header", parsedHeader);
-      return null;
-    }
-    if (headerVerification.data.typ !== jwtHeader.typ) {
-      console.debug("Invalid JWT: invalid header typ", parsedHeader);
-      return null;
-    }
-    if (headerVerification.data.alg !== jwtHeader.alg) {
-      console.debug("Invalid JWT: invalid header alg", parsedHeader);
-      return null;
-    }
-  } catch (err) {
-    console.debug("Invalid JWT: could not parse header", err);
-    return null;
-  }
-
-  if (secretKey) {
-    const signature = crypto
-      .createHmac("sha256", secretKey)
-      .update(`${headerBase64}.${payloadBase64}`)
-      .digest("base64");
-    if (signature !== signatureBase64) {
-      console.debug("Invalid JWT: invalid signature");
-      return null;
-    }
-  }
-  try {
-    const parsedPayload = JSON.parse(
-      Buffer.from(payloadBase64, "base64").toString("utf8")
-    ) as JwtPayload;
-    return parsedPayload;
-  } catch (err) {
-    console.debug("Invalid JWT: could not parse payload", err);
-    return null;
-  }
-}
-
-export function getExpire(): number {
-  return Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 4; // 4 days
-}
-
-const JwtHeaderSchema = z.object({
-  alg: z.literal("HS256"),
-  typ: z.literal("JWT"),
-});
-type JwtHeader = z.infer<typeof JwtHeaderSchema>;
-const jwtHeader: JwtHeader = {
-  alg: "HS256",
-  typ: "JWT",
-};
-
-const jwtHeaderBase64 = Buffer.from(JSON.stringify(jwtHeader)).toString(
-  "base64"
-);
-
-export function encodeJwt(payload: object, sessionKey: string): string {
-  // NOTE: this is only used for authentication, not for authorization (i.e. what a user can do) - this is handled when actually doing operations
-  const payloadBase64 = Buffer.from(JSON.stringify(payload)).toString("base64");
-  return `${jwtHeaderBase64}.${payloadBase64}.${crypto
-    .createHmac("sha256", sessionKey)
-    .update(`${jwtHeaderBase64}.${payloadBase64}`)
-    .digest("base64")}`;
-}