@valbuild/server 0.16.3 → 0.17.0

package/dist/valbuild-server.esm.js

@@ -3,8 +3,9 @@ import ts from 'typescript';
 import { result, pipe } from '@valbuild/core/fp';
 import { FILE_REF_PROP, derefPatch, Internal, Schema } from '@valbuild/core';
 import { deepEqual, isNotRoot, PatchError, parseAndValidateArrayIndex, applyPatch, parsePatch, sourceToPatchPath } from '@valbuild/core/patch';
-import path from 'path';
-import fs from 'fs';
+import * as path from 'path';
+import path__default from 'path';
+import fs, { promises } from 'fs';
 import express, { Router } from 'express';
 import { createRequestHandler as createRequestHandler$1 } from '@valbuild/ui/server';
 import z, { z as z$1 } from 'zod';
@@ -558,16 +559,16 @@ 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)
   )
 };
 `;
     const result = context.evalCode(code,
     // Synthetic module name
-    path.join(path.dirname(valConfigPath), "<val>"));
+    path__default.join(path__default.dirname(valConfigPath), "<val>"));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -672,12 +673,15 @@ function convertDataUrlToBase64(dataUrl) {
   return Buffer.from(base64, "base64");
 }
 const patchSourceFile = (sourceFile, patch) => {
+  if (typeof sourceFile === "string") {
+    return applyPatch(ts.createSourceFile("<val>", sourceFile, ts.ScriptTarget.ES2015), ops, patch);
+  }
   return applyPatch(sourceFile, ops, patch);
 };
 
 const getCompilerOptions = (rootDir, parseConfigHost) => {
-  const tsConfigPath = path.resolve(rootDir, "tsconfig.json");
-  const jsConfigPath = path.resolve(rootDir, "jsconfig.json");
+  const tsConfigPath = path__default.resolve(rootDir, "tsconfig.json");
+  const jsConfigPath = path__default.resolve(rootDir, "jsconfig.json");
   let configFilePath;
   if (parseConfigHost.fileExists(jsConfigPath)) {
     configFilePath = jsConfigPath;
@@ -727,7 +731,7 @@ class ValSourceFileHandler {
     this.host.writeFile(filePath, content, encoding);
   }
   resolveSourceModulePath(containingFilePath, requestedModuleName) {
-    const resolutionRes = ts.resolveModuleName(requestedModuleName, path.isAbsolute(containingFilePath) ? containingFilePath : path.resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts.ModuleKind.ESNext);
+    const resolutionRes = ts.resolveModuleName(requestedModuleName, path__default.isAbsolute(containingFilePath) ? containingFilePath : path__default.resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts.ModuleKind.ESNext);
     const resolvedModule = resolutionRes.resolvedModule;
     if (!resolvedModule) {
       throw Error(`Could not resolve module "${requestedModuleName}", base: "${containingFilePath}": No resolved modules returned: ${JSON.stringify(resolutionRes)}`);
@@ -847,6 +851,16 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
           value: "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)
       };
@@ -867,6 +881,16 @@ async function newValQuickJSRuntime(quickJSModule, moduleLoader, {
           value: requestedName
         };
       }
+      if (requestedName.startsWith("next")) {
+        return {
+          value: requestedName
+        };
+      }
+      if (requestedName.startsWith("react")) {
+        return {
+          value: requestedName
+        };
+      }
       const modulePath = moduleLoader.resolveModulePath(baseModuleName, requestedName);
       return {
         value: modulePath
@@ -903,7 +927,7 @@ class Service {
     const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime);
     if (valModule.source && valModule.schema) {
       const resolved = Internal.resolvePath(modulePath, valModule.source, valModule.schema);
-      const sourcePath = [moduleId, resolved.path].join(".");
+      const sourcePath = resolved.path ? [moduleId, resolved.path].join(".") : moduleId;
       return {
         path: sourcePath,
         schema: resolved.schema instanceof Schema ? resolved.schema.serialize() : resolved.schema,
@@ -934,15 +958,21 @@ function createRequestHandler(valServer) {
   router.get("/authorize", valServer.authorize.bind(valServer));
   router.get("/callback", valServer.callback.bind(valServer));
   router.get("/logout", valServer.logout.bind(valServer));
-  router.get("/ids/*", valServer.getIds.bind(valServer));
-  router.patch("/ids/*", express.json({
-    type: "application/json-patch+json",
+  router.post("/patches/*", express.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;
 }
 
+function getPathFromParams(params) {
+  return `/${params[0]}`;
+}
+
 const JSONValueT = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(JSONValueT), z.record(JSONValueT)]));
 
 /**
@@ -980,75 +1010,6 @@ const OperationJSONT = z.discriminatedUnion("op", [z.object({
 }).strict()]);
 const PatchJSON = z.array(OperationJSONT);
 
-function getPathFromParams(params) {
-  return `/${params[0]}`;
-}
-
-class LocalValServer {
-  constructor(options) {
-    this.options = options;
-  }
-  async session(_req, res) {
-    res.json({
-      mode: "local"
-    });
-  }
-  async getIds(req, res) {
-    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);
-      res.json(valModule);
-    } catch (err) {
-      console.error(err);
-      res.sendStatus(500);
-    }
-  }
-  async patchIds(req, res) {
-    // First validate that the body has the right structure
-    const patchJSON = PatchJSON.safeParse(req.body);
-    if (!patchJSON.success) {
-      res.status(401).json(patchJSON.error.issues);
-      return;
-    }
-    // Then parse/validate
-    const patch = parsePatch(patchJSON.data);
-    if (result.isErr(patch)) {
-      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);
-    } catch (err) {
-      if (err instanceof PatchError) {
-        res.status(401).send(err.message);
-      } else {
-        console.error(err);
-        res.status(500).send(err instanceof Error ? err.message : "Unknown error");
-      }
-    }
-  }
-  async badRequest(req, res) {
-    console.debug("Local server does handle this request", req.url);
-    res.sendStatus(400);
-  }
-  commit(req, res) {
-    return this.badRequest(req, res);
-  }
-  authorize(req, res) {
-    return this.badRequest(req, res);
-  }
-  callback(req, res) {
-    return this.badRequest(req, res);
-  }
-  logout(req, res) {
-    return this.badRequest(req, res);
-  }
-}
-
 function decodeJwt(token, secretKey) {
   const [headerBase64, payloadBase64, signatureBase64, ...rest] = token.split(".");
   if (!headerBase64 || !payloadBase64 || !signatureBase64 || rest.length > 0) {
@@ -1108,8 +1069,9 @@ function encodeJwt(payload, sessionKey) {
   return `${jwtHeaderBase64}.${payloadBase64}.${crypto.createHmac("sha256", sessionKey).update(`${jwtHeaderBase64}.${payloadBase64}`).digest("base64")}`;
 }
 
-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;
 class ProxyValServer {
   constructor(options) {
     this.options = options;
@@ -1134,6 +1096,12 @@ class ProxyValServer {
       expires: new Date(Date.now() + 1000 * 60 * 60) // 1 hour
     }).redirect(appAuthorizeUrl);
   }
+  async enable(req, res) {
+    return enable(req, res, this.options.valEnableRedirectUrl);
+  }
+  async disable(req, res) {
+    return disable(req, res, this.options.valEnableRedirectUrl);
+  }
   async callback(req, res) {
     const {
       success: callbackReqSuccess,
@@ -1179,7 +1147,6 @@ class ProxyValServer {
     }
   }
   async session(req, res) {
-    console.log("hit session");
     return this.withAuth(req, res, async data => {
       const url = new URL(`/api/val/${this.options.valName}/auth/session`, this.options.valBuildUrl);
       const fetchRes = await fetch(url, {
@@ -1195,30 +1162,38 @@ class ProxyValServer {
       }
     });
   }
-  async getIds(req, res) {
-    return this.withAuth(req, res, async ({
-      token
-    }) => {
-      const id = getPathFromParams(req.params);
-      const url = new URL(`/api/val/modules/${encodeURIComponent(this.options.gitCommit)}${id}`, this.options.valBuildUrl);
-      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 === null || e === void 0 ? void 0 : e.message,
-          status: 500
-        }
+  async getTree(req, res) {
+    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(`/v1/tree/${this.options.valName}/heads/${this.options.gitBranch}/${req.params["0"]}/?${params}`, this.options.valContentUrl);
+      const json = await fetch(url, {
+        headers: this.getAuthHeaders(data.token, "application/json")
+      }).then(res => res.json());
+      res.send(json);
     });
   }
-  async patchIds(req, res) {
+  async postPatches(req, res) {
+    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
     }) => {
@@ -1234,12 +1209,11 @@ class ProxyValServer {
         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);
+      const url = new URL(`/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) {
@@ -1421,6 +1395,40 @@ function getStateFromCookie(stateCookie) {
     };
   }
 }
+async function enable(req, res, redirectUrl) {
+  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);
+  }
+}
+async function disable(req, res, redirectUrl) {
+  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) {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }
@@ -1438,6 +1446,123 @@ const IntegratedServerJwtPayload = z$1.object({
   project: z$1.string()
 });
 
+class LocalValServer {
+  constructor(options) {
+    this.options = options;
+  }
+  async session(_req, res) {
+    res.json({
+      mode: "local"
+    });
+  }
+  async getTree(req, res) {
+    try {
+      // TODO: use the params: patch, schema, source
+      const treePath = req.params["0"].replace("~", "");
+      const rootDir = process.cwd();
+      const moduleIds = [];
+      // iterate over all .val files in the root directory
+      const walk = async dir => {
+        const files = await promises.readdir(dir);
+        for (const file of files) {
+          if ((await promises.stat(path__default.join(dir, file))).isDirectory()) {
+            if (file === "node_modules") continue;
+            await walk(path__default.join(dir, file));
+          } else {
+            const isValFile = file.endsWith(".val.js") || file.endsWith(".val.ts");
+            if (!isValFile) {
+              continue;
+            }
+            if (treePath && !path__default.join(dir, file).replace(rootDir, "").startsWith(treePath)) {
+              continue;
+            }
+            moduleIds.push(path__default.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, "");
+        }));
+      });
+
+      //
+      const modules = Object.fromEntries(serializedModuleContent.map(serializedModuleContent => {
+        const module = {
+          schema: serializedModuleContent.schema,
+          source: serializedModuleContent.source
+        };
+        return [serializedModuleContent.path, module];
+      }));
+      const 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 enable(req, res) {
+    return enable(req, res);
+  }
+  async disable(req, res) {
+    return disable(req, res);
+  }
+  async postPatches(req, res) {
+    var _getPathFromParams;
+    const id = (_getPathFromParams = getPathFromParams(req.params)) === null || _getPathFromParams === void 0 ? void 0 : _getPathFromParams.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;
+    }
+    // Then parse/validate
+    const patch = parsePatch(patchJSON.data);
+    if (result.isErr(patch)) {
+      res.status(401).json(patch.error);
+      return;
+    }
+    try {
+      await this.options.service.patch(id, patch.value);
+      res.json({});
+    } catch (err) {
+      if (err instanceof PatchError) {
+        res.status(400).send({
+          message: err.message
+        });
+      } else {
+        console.error(err);
+        res.status(500).send({
+          message: err instanceof Error ? err.message : "Unknown error"
+        });
+      }
+    }
+  }
+  async badRequest(req, res) {
+    console.debug("Local server does handle this request", req.url);
+    res.sendStatus(400);
+  }
+  commit(req, res) {
+    return this.badRequest(req, res);
+  }
+  authorize(req, res) {
+    return this.badRequest(req, res);
+  }
+  callback(req, res) {
+    return this.badRequest(req, res);
+  }
+  logout(req, res) {
+    return this.badRequest(req, res);
+  }
+}
+
 async function _createRequestListener(route, opts) {
   const serverOpts = await initHandlerOptions(route, opts);
   let valServer;
@@ -1458,6 +1583,7 @@ async function initHandlerOptions(route, opts) {
     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");
@@ -1476,18 +1602,82 @@ async function initHandlerOptions(route, opts) {
       apiKey: maybeApiKey,
       valSecret: maybeValSecret,
       valBuildUrl,
+      valContentUrl,
       gitCommit: maybeGitCommit,
       gitBranch: maybeGitBranch,
-      valName: maybeValName
+      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
+      service,
+      git: {
+        commit: process.env.VAL_GIT_COMMIT || git.commit,
+        branch: process.env.VAL_GIT_BRANCH || git.branch
+      }
     };
   }
 }
+async function safeReadGit(cwd) {
+  async function findGitHead(currentDir, depth) {
+    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 promises.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, branchName) {
+  try {
+    return (await promises.readFile(path.join(gitDir, ".git", "refs", "heads", branchName), "utf-8")).trim();
+  } catch (err) {
+    return undefined;
+  }
+}
 
 // TODO: rename to createValApiHandlers?
 function createRequestListener(route, opts) {
@@ -1525,10 +1715,10 @@ class ValFSHost {
     return this.currentDirectory;
   }
   getCanonicalFileName(fileName) {
-    if (path.isAbsolute(fileName)) {
-      return path.normalize(fileName);
+    if (path__default.isAbsolute(fileName)) {
+      return path__default.normalize(fileName);
     }
-    return path.resolve(this.getCurrentDirectory(), fileName);
+    return path__default.resolve(this.getCurrentDirectory(), fileName);
   }
   fileExists(fileName) {
     return this.valFS.fileExists(fileName);
@@ -1549,7 +1739,7 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
       // TODO:
       throw Error("Cannot fix image without a file reference");
     }
-    const localFile = path.join(config.projectRoot, maybeRef);
+    const localFile = path__default.join(config.projectRoot, maybeRef);
     const buffer = fs.readFileSync(localFile);
     const sha256 = await getSHA256Hash(buffer);
     const imageSize = sizeOf(buffer);
@@ -1650,4 +1840,4 @@ const getSHA256Hash = async bits => {
   return hash;
 };
 
-export { LocalValServer, PatchJSON, Service, ValFSHost, ValModuleLoader, ValSourceFileHandler, createFixPatch, createRequestHandler, createRequestListener, createService, decodeJwt, encodeJwt, formatSyntaxErrorTree, getCompilerOptions, getExpire, patchSourceFile };
+export { LocalValServer, PatchJSON, Service, ValFSHost, ValModuleLoader, ValSourceFileHandler, createFixPatch, createRequestHandler, createRequestListener, createService, decodeJwt, encodeJwt, formatSyntaxErrorTree, getCompilerOptions, getExpire, patchSourceFile, safeReadGit };

package/package.json

@@ -12,7 +12,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "jest",
@@ -25,8 +25,8 @@
     "concurrently": "^7.6.0"
   },
   "dependencies": {
-    "@valbuild/core": "~0.16.0",
-    "@valbuild/ui": "~0.15.0",
+    "@valbuild/core": "~0.17.0",
+    "@valbuild/ui": "~0.17.0",
     "express": "^4.18.2",
     "image-size": "^1.0.2",
     "quickjs-emscripten": "^0.21.1",