@valbuild/server 0.16.2 → 0.16.4

package/dist/declarations/src/LocalValServer.d.ts

@@ -7,7 +7,9 @@ export type LocalValServerOptions = {
 export declare class LocalValServer implements ValServer {
     readonly options: LocalValServerOptions;
     constructor(options: LocalValServerOptions);
+    getAllModules(req: express.Request, res: express.Response): Promise<void>;
     session(_req: express.Request, res: express.Response): Promise<void>;
+    enable(req: express.Request, res: express.Response): Promise<void>;
     getIds(req: express.Request<{
         0: string;
     }>, res: express.Response): Promise<void>;

package/dist/declarations/src/ValServer.d.ts

@@ -7,8 +7,12 @@ export interface ValServer {
     getIds(req: express.Request<{
         0: string;
     }>, res: express.Response): Promise<void>;
+    getAllModules(req: express.Request<{
+        0: string;
+    }>, res: express.Response): Promise<void>;
     patchIds(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>;
 }

package/dist/declarations/src/jwt.d.ts

@@ -1,3 +1,9 @@
-export declare function decodeJwt(token: string, secretKey?: string): unknown | null;
+export type JwtPayload = {
+    sub: string;
+    exp: number;
+    org: string;
+    project: string;
+};
+export declare function decodeJwt(token: string, secretKey?: string): JwtPayload | null;
 export declare function getExpire(): number;
 export declare function encodeJwt(payload: object, sessionKey: string): string;

package/dist/declarations/src/patchValFile.d.ts

@@ -6,4 +6,4 @@ import { QuickJSRuntime } from "quickjs-emscripten";
 import ts from "typescript";
 import { SerializedModuleContent } from "./SerializedModuleContent.js";
 export declare const patchValFile: (id: string, valConfigPath: string, patch: Patch, sourceFileHandler: ValSourceFileHandler, runtime: QuickJSRuntime) => Promise<SerializedModuleContent>;
-export declare const patchSourceFile: (sourceFile: ts.SourceFile, patch: Patch) => result.Result<ts.SourceFile, ValSyntaxErrorTree | PatchError>;
+export declare const patchSourceFile: (sourceFile: ts.SourceFile | string, patch: Patch) => result.Result<ts.SourceFile, ValSyntaxErrorTree | PatchError>;

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

@@ -686,6 +686,9 @@ 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);
 };
 
@@ -949,14 +952,20 @@ function createRequestHandler(valServer) {
   router.get("/callback", valServer.callback.bind(valServer));
   router.get("/logout", valServer.logout.bind(valServer));
   router.get("/ids/*", valServer.getIds.bind(valServer));
+  router.get("/ids", valServer.getAllModules.bind(valServer));
   router.patch("/ids/*", express__default["default"].json({
     type: "application/json-patch+json",
     limit: "10mb"
   }), valServer.patchIds.bind(valServer));
   router.post("/commit", valServer.commit.bind(valServer));
+  router.get("/enable", valServer.enable.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 +1003,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) {
@@ -1124,10 +1064,17 @@ function encodeJwt(payload, sessionKey) {
 
 const VAL_SESSION_COOKIE = "val_session";
 const VAL_STATE_COOKIE = "val_state";
+const VAL_ENABLED_COOKIE = core.Internal.VAL_ENABLE_COOKIE_NAME;
 class ProxyValServer {
   constructor(options) {
     this.options = options;
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getAllModules(_req, _res) {
+    // TODO:
+    throw new Error("Method not implemented.");
+  }
   async authorize(req, res) {
     const {
       redirect_to
@@ -1148,6 +1095,9 @@ class ProxyValServer {
       expires: new Date(Date.now() + 1000 * 60 * 60) // 1 hour
     }).redirect(appAuthorizeUrl);
   }
+  async enable(req, res) {
+    return enable(req, res);
+  }
   async callback(req, res) {
     const {
       success: callbackReqSuccess,
@@ -1193,7 +1143,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, {
@@ -1435,6 +1384,19 @@ function getStateFromCookie(stateCookie) {
     };
   }
 }
+async function enable(req, res) {
+  const {
+    redirect_to
+  } = req.query;
+  if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    res.cookie(VAL_ENABLED_COOKIE, "true", {
+      httpOnly: false,
+      sameSite: "lax"
+    }).redirect(redirect_to || "/");
+  } else {
+    res.sendStatus(400);
+  }
+}
 function createStateCookie(state) {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }
@@ -1452,6 +1414,98 @@ const IntegratedServerJwtPayload = z.z.object({
   project: z.z.string()
 });
 
+class LocalValServer {
+  constructor(options) {
+    this.options = options;
+  }
+  getAllModules(req, res) {
+    // TODO: this barely works,
+    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__default["default"].join(dir, file))).isDirectory()) {
+          if (file === "node_modules") continue;
+          await walk(path__default["default"].join(dir, file));
+        } else {
+          if (file.endsWith(".val.js") || file.endsWith(".val.ts")) {
+            moduleIds.push(path__default["default"].join(dir, file).replace(rootDir, "").replace(".val.js", "").replace(".val.ts", ""));
+          }
+        }
+      }
+    };
+    return walk(rootDir).then(async () => {
+      res.send(JSON.stringify(await Promise.all(moduleIds.map(async moduleId => {
+        return await this.options.service.get(moduleId, "");
+      }))));
+    });
+  }
+  async session(_req, res) {
+    res.json({
+      mode: "local"
+    });
+  }
+  async enable(req, res) {
+    return enable(req, res);
+  }
+  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);
+  }
+}
+
 async function _createRequestListener(route, opts) {
   const serverOpts = await initHandlerOptions(route, opts);
   let valServer;

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

@@ -686,6 +686,9 @@ 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);
 };
 
@@ -949,14 +952,20 @@ function createRequestHandler(valServer) {
   router.get("/callback", valServer.callback.bind(valServer));
   router.get("/logout", valServer.logout.bind(valServer));
   router.get("/ids/*", valServer.getIds.bind(valServer));
+  router.get("/ids", valServer.getAllModules.bind(valServer));
   router.patch("/ids/*", express__default["default"].json({
     type: "application/json-patch+json",
     limit: "10mb"
   }), valServer.patchIds.bind(valServer));
   router.post("/commit", valServer.commit.bind(valServer));
+  router.get("/enable", valServer.enable.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 +1003,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) {
@@ -1124,10 +1064,17 @@ function encodeJwt(payload, sessionKey) {
 
 const VAL_SESSION_COOKIE = "val_session";
 const VAL_STATE_COOKIE = "val_state";
+const VAL_ENABLED_COOKIE = core.Internal.VAL_ENABLE_COOKIE_NAME;
 class ProxyValServer {
   constructor(options) {
     this.options = options;
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getAllModules(_req, _res) {
+    // TODO:
+    throw new Error("Method not implemented.");
+  }
   async authorize(req, res) {
     const {
       redirect_to
@@ -1148,6 +1095,9 @@ class ProxyValServer {
       expires: new Date(Date.now() + 1000 * 60 * 60) // 1 hour
     }).redirect(appAuthorizeUrl);
   }
+  async enable(req, res) {
+    return enable(req, res);
+  }
   async callback(req, res) {
     const {
       success: callbackReqSuccess,
@@ -1193,7 +1143,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, {
@@ -1435,6 +1384,19 @@ function getStateFromCookie(stateCookie) {
     };
   }
 }
+async function enable(req, res) {
+  const {
+    redirect_to
+  } = req.query;
+  if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    res.cookie(VAL_ENABLED_COOKIE, "true", {
+      httpOnly: false,
+      sameSite: "lax"
+    }).redirect(redirect_to || "/");
+  } else {
+    res.sendStatus(400);
+  }
+}
 function createStateCookie(state) {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }
@@ -1452,6 +1414,98 @@ const IntegratedServerJwtPayload = z.z.object({
   project: z.z.string()
 });
 
+class LocalValServer {
+  constructor(options) {
+    this.options = options;
+  }
+  getAllModules(req, res) {
+    // TODO: this barely works,
+    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__default["default"].join(dir, file))).isDirectory()) {
+          if (file === "node_modules") continue;
+          await walk(path__default["default"].join(dir, file));
+        } else {
+          if (file.endsWith(".val.js") || file.endsWith(".val.ts")) {
+            moduleIds.push(path__default["default"].join(dir, file).replace(rootDir, "").replace(".val.js", "").replace(".val.ts", ""));
+          }
+        }
+      }
+    };
+    return walk(rootDir).then(async () => {
+      res.send(JSON.stringify(await Promise.all(moduleIds.map(async moduleId => {
+        return await this.options.service.get(moduleId, "");
+      }))));
+    });
+  }
+  async session(_req, res) {
+    res.json({
+      mode: "local"
+    });
+  }
+  async enable(req, res) {
+    return enable(req, res);
+  }
+  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);
+  }
+}
+
 async function _createRequestListener(route, opts) {
   const serverOpts = await initHandlerOptions(route, opts);
   let valServer;

package/dist/valbuild-server.esm.js

@@ -4,7 +4,7 @@ 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 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';
@@ -672,6 +672,9 @@ 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);
 };
 
@@ -935,14 +938,20 @@ function createRequestHandler(valServer) {
   router.get("/callback", valServer.callback.bind(valServer));
   router.get("/logout", valServer.logout.bind(valServer));
   router.get("/ids/*", valServer.getIds.bind(valServer));
+  router.get("/ids", valServer.getAllModules.bind(valServer));
   router.patch("/ids/*", express.json({
     type: "application/json-patch+json",
     limit: "10mb"
   }), valServer.patchIds.bind(valServer));
   router.post("/commit", valServer.commit.bind(valServer));
+  router.get("/enable", valServer.enable.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 +989,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) {
@@ -1110,10 +1050,17 @@ function encodeJwt(payload, sessionKey) {
 
 const VAL_SESSION_COOKIE = "val_session";
 const VAL_STATE_COOKIE = "val_state";
+const VAL_ENABLED_COOKIE = Internal.VAL_ENABLE_COOKIE_NAME;
 class ProxyValServer {
   constructor(options) {
     this.options = options;
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getAllModules(_req, _res) {
+    // TODO:
+    throw new Error("Method not implemented.");
+  }
   async authorize(req, res) {
     const {
       redirect_to
@@ -1134,6 +1081,9 @@ class ProxyValServer {
       expires: new Date(Date.now() + 1000 * 60 * 60) // 1 hour
     }).redirect(appAuthorizeUrl);
   }
+  async enable(req, res) {
+    return enable(req, res);
+  }
   async callback(req, res) {
     const {
       success: callbackReqSuccess,
@@ -1179,7 +1129,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, {
@@ -1421,6 +1370,19 @@ function getStateFromCookie(stateCookie) {
     };
   }
 }
+async function enable(req, res) {
+  const {
+    redirect_to
+  } = req.query;
+  if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    res.cookie(VAL_ENABLED_COOKIE, "true", {
+      httpOnly: false,
+      sameSite: "lax"
+    }).redirect(redirect_to || "/");
+  } else {
+    res.sendStatus(400);
+  }
+}
 function createStateCookie(state) {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }
@@ -1438,6 +1400,98 @@ const IntegratedServerJwtPayload = z$1.object({
   project: z$1.string()
 });
 
+class LocalValServer {
+  constructor(options) {
+    this.options = options;
+  }
+  getAllModules(req, res) {
+    // TODO: this barely works,
+    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.join(dir, file))).isDirectory()) {
+          if (file === "node_modules") continue;
+          await walk(path.join(dir, file));
+        } else {
+          if (file.endsWith(".val.js") || file.endsWith(".val.ts")) {
+            moduleIds.push(path.join(dir, file).replace(rootDir, "").replace(".val.js", "").replace(".val.ts", ""));
+          }
+        }
+      }
+    };
+    return walk(rootDir).then(async () => {
+      res.send(JSON.stringify(await Promise.all(moduleIds.map(async moduleId => {
+        return await this.options.service.get(moduleId, "");
+      }))));
+    });
+  }
+  async session(_req, res) {
+    res.json({
+      mode: "local"
+    });
+  }
+  async enable(req, res) {
+    return enable(req, res);
+  }
+  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);
+  }
+}
+
 async function _createRequestListener(route, opts) {
   const serverOpts = await initHandlerOptions(route, opts);
   let valServer;

package/package.json

@@ -12,7 +12,7 @@
     "./package.json": "./package.json"
   },
   "types": "dist/valbuild-server.cjs.d.ts",
-  "version": "0.16.2",
+  "version": "0.16.4",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "jest",

package/src/LocalValServer.ts

@@ -1,11 +1,14 @@
 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 { Internal, ModuleId, ModulePath } from "@valbuild/core";
+import { enable } from "./ProxyValServer";
+import { promises as fs } from "fs";
+import path from "path";
 
 export type LocalValServerOptions = {
   service: Service;
@@ -13,6 +16,46 @@ export type LocalValServerOptions = {
 
 export class LocalValServer implements ValServer {
   constructor(readonly options: LocalValServerOptions) {}
+  getAllModules(req: express.Request, res: express.Response): Promise<void> {
+    // TODO: this barely works,
+    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 {
+          if (file.endsWith(".val.js") || file.endsWith(".val.ts")) {
+            moduleIds.push(
+              path
+                .join(dir, file)
+                .replace(rootDir, "")
+                .replace(".val.js", "")
+                .replace(".val.ts", "")
+            );
+          }
+        }
+      }
+    };
+
+    return walk(rootDir).then(async () => {
+      res.send(
+        JSON.stringify(
+          await Promise.all(
+            moduleIds.map(async (moduleId) => {
+              return await this.options.service.get(
+                moduleId as ModuleId,
+                "" as ModulePath
+              );
+            })
+          )
+        )
+      );
+    });
+  }
 
   async session(_req: express.Request, res: express.Response): Promise<void> {
     res.json({
@@ -20,6 +63,10 @@ export class LocalValServer implements ValServer {
     });
   }
 
+  async enable(req: express.Request, res: express.Response): Promise<void> {
+    return enable(req, res);
+  }
+
   async getIds(
     req: express.Request<{ 0: string }>,
     res: express.Response
@@ -28,6 +75,7 @@ export class LocalValServer implements ValServer {
       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);

package/src/ProxyValServer.ts

@@ -7,9 +7,11 @@ 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_ENABLED_COOKIE = Internal.VAL_ENABLE_COOKIE_NAME;
 
 export type ProxyValServerOptions = {
   apiKey: string;
@@ -24,6 +26,12 @@ export type ProxyValServerOptions = {
 export class ProxyValServer implements ValServer {
   constructor(readonly options: ProxyValServerOptions) {}
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getAllModules(_req: express.Request, _res: express.Response): Promise<void> {
+    // TODO:
+    throw new Error("Method not implemented.");
+  }
+
   async authorize(req: express.Request, res: express.Response): Promise<void> {
     const { redirect_to } = req.query;
     if (typeof redirect_to !== "string") {
@@ -47,6 +55,10 @@ export class ProxyValServer implements ValServer {
       .redirect(appAuthorizeUrl);
   }
 
+  async enable(req: express.Request, res: express.Response): Promise<void> {
+    return enable(req, res);
+  }
+
   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 +125,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`,
@@ -387,6 +398,23 @@ function getStateFromCookie(stateCookie: string):
   }
 }
 
+export async function enable(
+  req: express.Request,
+  res: express.Response
+): Promise<void> {
+  const { redirect_to } = req.query;
+  if (typeof redirect_to === "string" || typeof redirect_to === "undefined") {
+    res
+      .cookie(VAL_ENABLED_COOKIE, "true", {
+        httpOnly: false,
+        sameSite: "lax",
+      })
+      .redirect(redirect_to || "/");
+  } else {
+    res.sendStatus(400);
+  }
+}
+
 function createStateCookie(state: StateCookie): string {
   return Buffer.from(JSON.stringify(state), "utf8").toString("base64");
 }

package/src/ValServer.ts

@@ -14,10 +14,17 @@ export interface ValServer {
     res: express.Response
   ): Promise<void>;
 
+  getAllModules(
+    req: express.Request<{ 0: string }>,
+    res: express.Response
+  ): Promise<void>;
+
   patchIds(
     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>;
 }

package/src/createRequestHandler.ts

@@ -11,6 +11,7 @@ export function createRequestHandler(valServer: ValServer): RequestHandler {
   router.get("/callback", valServer.callback.bind(valServer));
   router.get("/logout", valServer.logout.bind(valServer));
   router.get<{ 0: string }>("/ids/*", valServer.getIds.bind(valServer));
+  router.get("/ids", valServer.getAllModules.bind(valServer));
   router.patch<{ 0: string }>(
     "/ids/*",
     express.json({
@@ -20,5 +21,6 @@ export function createRequestHandler(valServer: ValServer): RequestHandler {
     valServer.patchIds.bind(valServer)
   );
   router.post("/commit", valServer.commit.bind(valServer));
+  router.get("/enable", valServer.enable.bind(valServer));
   return router;
 }

package/src/jwt.ts

@@ -1,7 +1,17 @@
 import crypto from "crypto";
 import { z } from "zod";
 
-export function decodeJwt(token: string, secretKey?: string): unknown | null {
+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) {
@@ -47,7 +57,7 @@ export function decodeJwt(token: string, secretKey?: string): unknown | null {
   try {
     const parsedPayload = JSON.parse(
       Buffer.from(payloadBase64, "base64").toString("utf8")
-    ) as unknown;
+    ) as JwtPayload;
     return parsedPayload;
   } catch (err) {
     console.debug("Invalid JWT: could not parse payload", err);

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);
 };