@valbuild/server 0.16.3 → 0.17.0

package/dist/valbuild-server.cjs.dev.js

@@ -17,8 +17,26 @@ var sizeOf = require('image-size');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 var ts__default = /*#__PURE__*/_interopDefault(ts);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var z__default = /*#__PURE__*/_interopDefault(z);
@@ -572,16 +590,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__default["default"].join(path__default["default"].dirname(valConfigPath), "<val>"));
+    path__namespace["default"].join(path__namespace["default"].dirname(valConfigPath), "<val>"));
     const fatalErrors = [];
     if (result.error) {
       const error = result.error.consume(context.dump);
@@ -686,12 +704,15 @@ function convertDataUrlToBase64(dataUrl) {
   return Buffer.from(base64, "base64");
 }
 const patchSourceFile = (sourceFile, patch$1) => {
+  if (typeof sourceFile === "string") {
+    return patch.applyPatch(ts__default["default"].createSourceFile("<val>", sourceFile, ts__default["default"].ScriptTarget.ES2015), ops, patch$1);
+  }
   return patch.applyPatch(sourceFile, ops, patch$1);
 };
 
 const getCompilerOptions = (rootDir, parseConfigHost) => {
-  const tsConfigPath = path__default["default"].resolve(rootDir, "tsconfig.json");
-  const jsConfigPath = path__default["default"].resolve(rootDir, "jsconfig.json");
+  const tsConfigPath = path__namespace["default"].resolve(rootDir, "tsconfig.json");
+  const jsConfigPath = path__namespace["default"].resolve(rootDir, "jsconfig.json");
   let configFilePath;
   if (parseConfigHost.fileExists(jsConfigPath)) {
     configFilePath = jsConfigPath;
@@ -741,7 +762,7 @@ class ValSourceFileHandler {
     this.host.writeFile(filePath, content, encoding);
   }
   resolveSourceModulePath(containingFilePath, requestedModuleName) {
-    const resolutionRes = ts__default["default"].resolveModuleName(requestedModuleName, path__default["default"].isAbsolute(containingFilePath) ? containingFilePath : path__default["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default["default"].ModuleKind.ESNext);
+    const resolutionRes = ts__default["default"].resolveModuleName(requestedModuleName, path__namespace["default"].isAbsolute(containingFilePath) ? containingFilePath : path__namespace["default"].resolve(this.projectRoot, containingFilePath), this.compilerOptions, this.host, undefined, undefined, ts__default["default"].ModuleKind.ESNext);
     const resolvedModule = resolutionRes.resolvedModule;
     if (!resolvedModule) {
       throw Error(`Could not resolve module "${requestedModuleName}", base: "${containingFilePath}": No resolved modules returned: ${JSON.stringify(resolutionRes)}`);
@@ -861,6 +882,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)
       };
@@ -881,6 +912,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
@@ -917,7 +958,7 @@ class Service {
     const valModule = await readValFile(moduleId, this.valConfigPath, this.runtime);
     if (valModule.source && valModule.schema) {
       const resolved = core.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 core.Schema ? resolved.schema.serialize() : resolved.schema,
@@ -948,15 +989,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__default["default"].json({
-    type: "application/json-patch+json",
+  router.post("/patches/*", express__default["default"].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__default["default"].lazy(() => z__default["default"].union([z__default["default"].string(), z__default["default"].number(), z__default["default"].boolean(), z__default["default"].null(), z__default["default"].array(JSONValueT), z__default["default"].record(JSONValueT)]));
 
 /**
@@ -994,75 +1041,6 @@ const OperationJSONT = z__default["default"].discriminatedUnion("op", [z__defaul
 }).strict()]);
 const PatchJSON = z__default["default"].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] = core.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$1 = patch.parsePatch(patchJSON.data);
-    if (fp.result.isErr(patch$1)) {
-      res.status(401).json(patch$1.error);
-      return;
-    }
-    const id = getPathFromParams(req.params);
-    try {
-      const valModule = await this.options.service.patch(id, patch$1.value);
-      res.json(valModule);
-    } catch (err) {
-      if (err instanceof patch.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) {
@@ -1122,8 +1100,9 @@ function encodeJwt(payload, sessionKey) {
   return `${jwtHeaderBase64}.${payloadBase64}.${crypto__default["default"].createHmac("sha256", sessionKey).update(`${jwtHeaderBase64}.${payloadBase64}`).digest("base64")}`;
 }
 
-const VAL_SESSION_COOKIE = "val_session";
-const VAL_STATE_COOKIE = "val_state";
+const VAL_SESSION_COOKIE = core.Internal.VAL_SESSION_COOKIE;
+const VAL_STATE_COOKIE = core.Internal.VAL_STATE_COOKIE;
+const VAL_ENABLED_COOKIE = core.Internal.VAL_ENABLE_COOKIE_NAME;
 class ProxyValServer {
   constructor(options) {
     this.options = options;
@@ -1148,6 +1127,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,
@@ -1193,7 +1178,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, {
@@ -1209,30 +1193,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
     }) => {
@@ -1248,12 +1240,11 @@ class ProxyValServer {
         res.status(401).json(patch$1.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$1)
       });
       if (fetchRes.ok) {
@@ -1435,6 +1426,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");
 }
@@ -1452,6 +1477,123 @@ const IntegratedServerJwtPayload = z.z.object({
   project: z.z.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 fs.promises.readdir(dir);
+        for (const file of files) {
+          if ((await fs.promises.stat(path__namespace["default"].join(dir, file))).isDirectory()) {
+            if (file === "node_modules") continue;
+            await walk(path__namespace["default"].join(dir, file));
+          } else {
+            const isValFile = file.endsWith(".val.js") || file.endsWith(".val.ts");
+            if (!isValFile) {
+              continue;
+            }
+            if (treePath && !path__namespace["default"].join(dir, file).replace(rootDir, "").startsWith(treePath)) {
+              continue;
+            }
+            moduleIds.push(path__namespace["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$1 = patch.parsePatch(patchJSON.data);
+    if (fp.result.isErr(patch$1)) {
+      res.status(401).json(patch$1.error);
+      return;
+    }
+    try {
+      await this.options.service.patch(id, patch$1.value);
+      res.json({});
+    } catch (err) {
+      if (err instanceof patch.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;
@@ -1472,6 +1614,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");
@@ -1490,18 +1633,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__namespace.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.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__namespace.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 fs.promises.readFile(path__namespace.join(gitDir, ".git", "refs", "heads", branchName), "utf-8")).trim();
+  } catch (err) {
+    return undefined;
+  }
+}
 
 // TODO: rename to createValApiHandlers?
 function createRequestListener(route, opts) {
@@ -1539,10 +1746,10 @@ class ValFSHost {
     return this.currentDirectory;
   }
   getCanonicalFileName(fileName) {
-    if (path__default["default"].isAbsolute(fileName)) {
-      return path__default["default"].normalize(fileName);
+    if (path__namespace["default"].isAbsolute(fileName)) {
+      return path__namespace["default"].normalize(fileName);
     }
-    return path__default["default"].resolve(this.getCurrentDirectory(), fileName);
+    return path__namespace["default"].resolve(this.getCurrentDirectory(), fileName);
   }
   fileExists(fileName) {
     return this.valFS.fileExists(fileName);
@@ -1563,7 +1770,7 @@ async function createFixPatch(config, apply, sourcePath, validationError) {
       // TODO:
       throw Error("Cannot fix image without a file reference");
     }
-    const localFile = path__default["default"].join(config.projectRoot, maybeRef);
+    const localFile = path__namespace["default"].join(config.projectRoot, maybeRef);
     const buffer = fs__default["default"].readFileSync(localFile);
     const sha256 = await getSHA256Hash(buffer);
     const imageSize = sizeOf__default["default"](buffer);
@@ -1680,3 +1887,4 @@ exports.formatSyntaxErrorTree = formatSyntaxErrorTree;
 exports.getCompilerOptions = getCompilerOptions;
 exports.getExpire = getExpire;
 exports.patchSourceFile = patchSourceFile;
+exports.safeReadGit = safeReadGit;