@valbuild/server 0.16.3 → 0.17.0

package/src/LocalValServer.ts

@@ -1,14 +1,21 @@
 import express from "express";
 import { Service } from "./Service";
-import { PatchJSON } from "./patch/validation";
 import { result } from "@valbuild/core/fp";
 import { parsePatch, PatchError } from "@valbuild/core/patch";
 import { getPathFromParams } from "./expressHelpers";
+import { PatchJSON } from "./patch/validation";
 import { ValServer } from "./ValServer";
-import { Internal } from "@valbuild/core";
+import { ApiTreeResponse, ModuleId, ModulePath } from "@valbuild/core";
+import { disable, enable } from "./ProxyValServer";
+import { promises as fs } from "fs";
+import path from "path";
 
 export type LocalValServerOptions = {
   service: Service;
+  git: {
+    commit?: string;
+    branch?: string;
+  };
 };
 
 export class LocalValServer implements ValServer {
@@ -20,29 +27,93 @@ export class LocalValServer implements ValServer {
     });
   }
 
-  async getIds(
-    req: express.Request<{ 0: string }>,
-    res: express.Response
-  ): Promise<void> {
+  async getTree(req: express.Request, res: express.Response): Promise<void> {
     try {
-      console.log(req.params);
-      const path = getPathFromParams(req.params);
-      const [moduleId, modulePath] = Internal.splitModuleIdAndModulePath(path);
-      const valModule = await this.options.service.get(moduleId, modulePath);
+      // TODO: use the params: patch, schema, source
+      const treePath = req.params["0"].replace("~", "");
+      const rootDir = process.cwd();
+      const moduleIds: string[] = [];
+      // iterate over all .val files in the root directory
+      const walk = async (dir: string) => {
+        const files = await fs.readdir(dir);
+        for (const file of files) {
+          if ((await fs.stat(path.join(dir, file))).isDirectory()) {
+            if (file === "node_modules") continue;
+            await walk(path.join(dir, file));
+          } else {
+            const isValFile =
+              file.endsWith(".val.js") || file.endsWith(".val.ts");
+            if (!isValFile) {
+              continue;
+            }
+            if (
+              treePath &&
+              !path.join(dir, file).replace(rootDir, "").startsWith(treePath)
+            ) {
+              continue;
+            }
+            moduleIds.push(
+              path
+                .join(dir, file)
+                .replace(rootDir, "")
+                .replace(".val.js", "")
+                .replace(".val.ts", "")
+            );
+          }
+        }
+      };
+      const serializedModuleContent = await walk(rootDir).then(async () => {
+        return Promise.all(
+          moduleIds.map(async (moduleId) => {
+            return await this.options.service.get(
+              moduleId as ModuleId,
+              "" as ModulePath
+            );
+          })
+        );
+      });
 
-      res.json(valModule);
+      //
+      const modules = Object.fromEntries(
+        serializedModuleContent.map((serializedModuleContent) => {
+          const module: ApiTreeResponse["modules"][keyof ApiTreeResponse["modules"]] =
+            {
+              schema: serializedModuleContent.schema,
+              source: serializedModuleContent.source,
+            };
+          return [serializedModuleContent.path, module];
+        })
+      );
+      const apiTreeResponse: ApiTreeResponse = {
+        modules,
+        git: this.options.git,
+      };
+      return walk(rootDir).then(async () => {
+        res.send(JSON.stringify(apiTreeResponse));
+      });
     } catch (err) {
       console.error(err);
       res.sendStatus(500);
     }
   }
 
-  async patchIds(
+  async enable(req: express.Request, res: express.Response): Promise<void> {
+    return enable(req, res);
+  }
+
+  async disable(req: express.Request, res: express.Response): Promise<void> {
+    return disable(req, res);
+  }
+
+  async postPatches(
     req: express.Request<{ 0: string }>,
     res: express.Response
   ): Promise<void> {
+    const id = getPathFromParams(req.params)?.replace("/~", "");
+
     // First validate that the body has the right structure
     const patchJSON = PatchJSON.safeParse(req.body);
+    console.log("patch id", id, patchJSON);
     if (!patchJSON.success) {
       res.status(401).json(patchJSON.error.issues);
       return;
@@ -53,18 +124,17 @@ export class LocalValServer implements ValServer {
       res.status(401).json(patch.error);
       return;
     }
-    const id = getPathFromParams(req.params);
     try {
-      const valModule = await this.options.service.patch(id, patch.value);
-      res.json(valModule);
+      await this.options.service.patch(id, patch.value);
+      res.json({});
     } catch (err) {
       if (err instanceof PatchError) {
-        res.status(401).send(err.message);
+        res.status(400).send({ message: err.message });
       } else {
         console.error(err);
-        res
-          .status(500)
-          .send(err instanceof Error ? err.message : "Unknown error");
+        res.status(500).send({
+          message: err instanceof Error ? err.message : "Unknown error",
+        });
       }
     }
   }

package/src/ProxyValServer.ts

@@ -3,22 +3,26 @@ import crypto from "crypto";
 import { decodeJwt, encodeJwt, getExpire } from "./jwt";
 import { PatchJSON } from "./patch/validation";
 import { result } from "@valbuild/core/fp";
-import { getPathFromParams } from "./expressHelpers";
 import { ValServer } from "./ValServer";
 import { z } from "zod";
 import { parsePatch } from "@valbuild/core/patch";
+import { Internal } from "@valbuild/core";
 
-const VAL_SESSION_COOKIE = "val_session";
-const VAL_STATE_COOKIE = "val_state";
+const VAL_SESSION_COOKIE = Internal.VAL_SESSION_COOKIE;
+const VAL_STATE_COOKIE = Internal.VAL_STATE_COOKIE;
+const VAL_ENABLED_COOKIE = Internal.VAL_ENABLE_COOKIE_NAME;
 
 export type ProxyValServerOptions = {
   apiKey: string;
   route: string;
   valSecret: string;
   valBuildUrl: string;
+  valContentUrl: string;
   gitCommit: string;
   gitBranch: string;
   valName: string;
+  valEnableRedirectUrl?: string;
+  valDisableRedirectUrl?: string;
 };
 
 export class ProxyValServer implements ValServer {
@@ -47,6 +51,13 @@ export class ProxyValServer implements ValServer {
       .redirect(appAuthorizeUrl);
   }
 
+  async enable(req: express.Request, res: express.Response): Promise<void> {
+    return enable(req, res, this.options.valEnableRedirectUrl);
+  }
+  async disable(req: express.Request, res: express.Response): Promise<void> {
+    return disable(req, res, this.options.valEnableRedirectUrl);
+  }
+
   async callback(req: express.Request, res: express.Response): Promise<void> {
     const { success: callbackReqSuccess, error: callbackReqError } =
       verifyCallbackReq(req.cookies[VAL_STATE_COOKIE], req.query);
@@ -113,7 +124,6 @@ export class ProxyValServer implements ValServer {
   }
 
   async session(req: express.Request, res: express.Response): Promise<void> {
-    console.log("hit session");
     return this.withAuth(req, res, async (data) => {
       const url = new URL(
         `/api/val/${this.options.valName}/auth/session`,
@@ -132,33 +142,37 @@ export class ProxyValServer implements ValServer {
     });
   }
 
-  async getIds(
-    req: express.Request<{ 0: string }>,
-    res: express.Response
-  ): Promise<void> {
-    return this.withAuth(req, res, async ({ token }) => {
-      const id = getPathFromParams(req.params);
+  async getTree(req: express.Request, res: express.Response): Promise<void> {
+    return this.withAuth(req, res, async (data) => {
+      const { patch, schema, source } = req.query;
+      const params = new URLSearchParams({
+        patch: (patch === "true").toString(),
+        schema: (schema === "true").toString(),
+        source: (source === "true").toString(),
+      });
       const url = new URL(
-        `/api/val/modules/${encodeURIComponent(this.options.gitCommit)}${id}`,
-        this.options.valBuildUrl
+        `/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`,
+        this.options.valContentUrl
       );
-      const fetchRes = await fetch(url, {
-        headers: this.getAuthHeaders(token),
-      });
-      if (fetchRes.ok) {
-        res.status(fetchRes.status).json(await fetchRes.json());
-      } else {
-        res.sendStatus(fetchRes.status);
-      }
-    }).catch((e) => {
-      res.status(500).send({ error: { message: e?.message, status: 500 } });
+      const json = await fetch(url, {
+        headers: this.getAuthHeaders(data.token, "application/json"),
+      }).then((res) => res.json());
+      res.send(json);
     });
   }
 
-  async patchIds(
+  async postPatches(
     req: express.Request<{ 0: string }>,
     res: express.Response
   ): Promise<void> {
+    const { commit } = req.query;
+    if (typeof commit !== "string" || typeof commit === "undefined") {
+      res.status(401).json({ error: "Missing or invalid commit query param" });
+      return;
+    }
+    const params = new URLSearchParams({
+      commit,
+    });
     this.withAuth(req, res, async ({ token }) => {
       // First validate that the body has the right structure
       const patchJSON = PatchJSON.safeParse(req.body);
@@ -172,15 +186,14 @@ export class ProxyValServer implements ValServer {
         res.status(401).json(patch.error);
         return;
       }
-      const id = getPathFromParams(req.params);
       const url = new URL(
-        `/api/val/modules/${encodeURIComponent(this.options.gitCommit)}${id}`,
-        this.options.valBuildUrl
+        `/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`,
+        this.options.valContentUrl
       );
       // Proxy patch to val.build
       const fetchRes = await fetch(url, {
-        method: "PATCH",
-        headers: this.getAuthHeaders(token, "application/json-patch+json"),
+        method: "POST",
+        headers: this.getAuthHeaders(token, "application/json"),
         body: JSON.stringify(patch),
       });
       if (fetchRes.ok) {
@@ -387,6 +400,51 @@ function getStateFromCookie(stateCookie: string):
   }
 }
 
+export async function enable(
+  req: express.Request,
+  res: express.Response,
+  redirectUrl?: string
+): Promise<void> {
+  const { redirect_to } = req.query;
+  if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    let redirectUrlToUse = redirect_to || "/";
+    if (redirectUrl) {
+      redirectUrlToUse =
+        redirectUrl + "?redirect_to=" + encodeURIComponent(redirectUrlToUse);
+    }
+    res
+      .cookie(VAL_ENABLED_COOKIE, "true", {
+        httpOnly: false,
+        sameSite: "lax",
+      })
+      .redirect(redirectUrlToUse);
+  } else {
+    res.sendStatus(400);
+  }
+}
+export async function disable(
+  req: express.Request,
+  res: express.Response,
+  redirectUrl?: string
+): Promise<void> {
+  const { redirect_to } = req.query;
+  if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    let redirectUrlToUse = redirect_to || "/";
+    if (redirectUrl) {
+      redirectUrlToUse =
+        redirectUrl + "?redirect_to=" + encodeURIComponent(redirectUrlToUse);
+    }
+    res
+      .cookie(VAL_ENABLED_COOKIE, "false", {
+        httpOnly: false,
+        sameSite: "lax",
+      })
+      .redirect(redirectUrlToUse);
+  } else {
+    res.sendStatus(400);
+  }
+}
+
 function createStateCookie(state: StateCookie): string {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }

package/src/Service.ts

@@ -16,7 +16,6 @@ import {
   Internal,
   SourcePath,
   Schema,
-  SelectorSource,
 } from "@valbuild/core";
 
 export type ServiceOptions = {
@@ -79,11 +78,13 @@ export class Service {
         valModule.source,
         valModule.schema
       );
-      const sourcePath = [moduleId, resolved.path].join(".") as SourcePath;
+      const sourcePath = (
+        resolved.path ? [moduleId, resolved.path].join(".") : moduleId
+      ) as SourcePath;
       return {
         path: sourcePath,
         schema:
-          resolved.schema instanceof Schema<SelectorSource>
+          resolved.schema instanceof Schema
             ? resolved.schema.serialize()
             : resolved.schema,
         source: resolved.source,

package/src/ValQuickJSRuntime.ts

@@ -34,6 +34,18 @@ export async function newValQuickJSRuntime(
               "export const useVal = () => { throw Error(`Cannot use 'useVal' in this type of file`) }; export const fetchVal = () => { throw Error(`Cannot use 'fetchVal' in this type of file`) }; export const autoTagJSX = () => { /* ignore */ };",
           };
         }
+        if (modulePath.startsWith("next")) {
+          return {
+            value:
+              "export default new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'next' in this file`) } } } )",
+          };
+        }
+        if (modulePath.startsWith("react")) {
+          return {
+            value:
+              "export default new Proxy({}, { get() { return () => { throw new Error(`Cannot import 'react' in this file`) } } } )",
+          };
+        }
         return { value: moduleLoader.getModule(modulePath) };
       } catch (e) {
         return {
@@ -49,6 +61,12 @@ export async function newValQuickJSRuntime(
         if (requestedName === "@valbuild/react/stega") {
           return { value: requestedName };
         }
+        if (requestedName.startsWith("next")) {
+          return { value: requestedName };
+        }
+        if (requestedName.startsWith("react")) {
+          return { value: requestedName };
+        }
         const modulePath = moduleLoader.resolveModulePath(
           baseModuleName,
           requestedName

package/src/ValServer.ts

@@ -9,15 +9,15 @@ export interface ValServer {
 
   session(req: express.Request, res: express.Response): Promise<void>;
 
-  getIds(
-    req: express.Request<{ 0: string }>,
-    res: express.Response
-  ): Promise<void>;
-
-  patchIds(
+  postPatches(
     req: express.Request<{ 0: string }>,
     res: express.Response
   ): Promise<void>;
 
   commit(req: express.Request, res: express.Response): Promise<void>;
+
+  enable(req: express.Request, res: express.Response): Promise<void>;
+  disable(req: express.Request, res: express.Response): Promise<void>;
+
+  getTree(req: express.Request, res: express.Response): Promise<void>;
 }

package/src/createRequestHandler.ts

@@ -10,15 +10,17 @@ export function createRequestHandler(valServer: ValServer): RequestHandler {
   router.get("/authorize", valServer.authorize.bind(valServer));
   router.get("/callback", valServer.callback.bind(valServer));
   router.get("/logout", valServer.logout.bind(valServer));
-  router.get<{ 0: string }>("/ids/*", valServer.getIds.bind(valServer));
-  router.patch<{ 0: string }>(
-    "/ids/*",
+  router.post<{ 0: string }>(
+    "/patches/*",
     express.json({
-      type: "application/json-patch+json",
+      type: "application/json",
       limit: "10mb",
     }),
-    valServer.patchIds.bind(valServer)
+    valServer.postPatches.bind(valServer)
   );
   router.post("/commit", valServer.commit.bind(valServer));
+  router.get("/enable", valServer.enable.bind(valServer));
+  router.get("/disable", valServer.disable.bind(valServer));
+  router.get("/tree/*", valServer.getTree.bind(valServer));
   return router;
 }

package/src/hosting.ts

@@ -5,6 +5,8 @@ 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;
 
@@ -73,6 +75,16 @@ type ValServerOverrides = Partial<{
    * @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.
    *
@@ -81,6 +93,26 @@ type ValServerOverrides = Partial<{
    * @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(
@@ -119,6 +151,10 @@ async function initHandlerOptions(
         "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");
@@ -137,19 +173,104 @@ async function initHandlerOptions(
       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 service = await createService(process.cwd(), opts);
+    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,

package/src/index.ts

@@ -1,7 +1,7 @@
 export type { ServiceOptions } from "./Service";
 export { createService, Service } from "./Service";
 export { createRequestHandler } from "./createRequestHandler";
-export { createRequestListener } from "./hosting";
+export { createRequestListener, safeReadGit } from "./hosting";
 export { ValModuleLoader } from "./ValModuleLoader";
 export { getCompilerOptions } from "./getCompilerOptions";
 export { ValSourceFileHandler } from "./ValSourceFileHandler";

package/src/patch/ts/ops.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "@jest/globals";
 import ts from "typescript";
 import { TSOps } from "./ops";
 import { result, array, pipe } from "@valbuild/core/fp";

package/src/patchValFile.ts

@@ -95,8 +95,15 @@ function convertDataUrlToBase64(dataUrl: string): Buffer {
 }
 
 export const patchSourceFile = (
-  sourceFile: ts.SourceFile,
+  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);
 };

package/src/readValFile.ts

@@ -16,10 +16,10 @@ import { Internal } from "@valbuild/core";
 globalThis.valModule = { 
   id: valModule?.default && Internal.getValPath(valModule?.default),
   schema: valModule?.default && Internal.getSchema(valModule?.default)?.serialize(),
-  source: valModule?.default && Internal.getRawSource(valModule?.default),
+  source: valModule?.default && Internal.getSource(valModule?.default),
   validation: valModule?.default && Internal.getSchema(valModule?.default)?.validate(
     valModule?.default && Internal.getValPath(valModule?.default) || "/",
-    valModule?.default && Internal.getRawSource(valModule?.default)
+    valModule?.default && Internal.getSource(valModule?.default)
   )
 };
 `;