@valbuild/server 0.12.0 → 0.13.3

package/src/readValFile.test.ts

@@ -0,0 +1,49 @@
+import {
+  TestQuickJSWASMModule,
+  newQuickJSAsyncWASMModule,
+} from "quickjs-emscripten";
+import { readValFile } from "./readValFile";
+import path from "path";
+import { createModuleLoader } from "./ValModuleLoader";
+import { newValQuickJSRuntime } from "./ValQuickJSRuntime";
+
+const TestCaseDir = "../test/example-projects";
+const TestCases = [
+  { name: "basic-next-typescript", valConfigPath: "./val.config" },
+  {
+    name: "basic-next-src-typescript",
+    valConfigPath: "./src/val.config",
+  },
+  { name: "basic-next-javascript", valConfigPath: "./val.config" },
+  { name: "typescript-description-files", valConfigPath: "./val.config" },
+];
+
+describe("read val file", () => {
+  // We cannot, currently use TestQuickJSWASMModule
+  let QuickJS: TestQuickJSWASMModule;
+
+  beforeEach(async () => {
+    QuickJS = new TestQuickJSWASMModule(await newQuickJSAsyncWASMModule());
+  });
+
+  afterEach(() => {
+    QuickJS.disposeAll();
+    QuickJS.assertNoMemoryAllocated();
+  });
+
+  test.each(TestCases)("read basic val file from: $name", async (testCase) => {
+    const rootDir = path.resolve(__dirname, TestCaseDir, testCase.name);
+    const loader = createModuleLoader(rootDir);
+    const testRuntime = await newValQuickJSRuntime(QuickJS, loader, {
+      maxStackSize: 1024 * 640,
+      memoryLimit: 1024 * 640,
+    });
+    const result = await readValFile(
+      "/pages/blogs",
+      testCase.valConfigPath,
+      testRuntime
+    );
+    expect(result).toHaveProperty("source");
+    expect(result).toHaveProperty("schema");
+  });
+});

package/src/readValFile.ts

@@ -0,0 +1,73 @@
+import path from "path";
+import { QuickJSRuntime } from "quickjs-emscripten";
+import { SerializedModuleContent } from "./SerializedModuleContent";
+
+export const readValFile = async (
+  id: string,
+  valConfigPath: string,
+  runtime: QuickJSRuntime
+): Promise<SerializedModuleContent> => {
+  const context = runtime.newContext();
+  try {
+    const modulePath = `.${id}.val`;
+    const code = `import * as valModule from ${JSON.stringify(modulePath)};
+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),
+};
+`;
+    const result = context.evalCode(
+      code,
+      // Synthetic module name
+      path.join(path.dirname(valConfigPath), "<val>")
+    );
+    if (result.error) {
+      const error = result.error.consume(context.dump);
+      console.error("Got error", error); // TODO: use this to figure out how to strip out QuickJS specific errors and get the actual stack
+
+      throw new Error(
+        `Could not read val id: ${id}. Cause:\n${error.name}: ${error.message}${
+          error.stack ? error.stack : ""
+        }`
+      );
+    } else {
+      result.value.dispose();
+      const valModule = context
+        .getProp(context.global, "valModule")
+        .consume(context.dump);
+
+      const errors: string[] = [];
+
+      if (!valModule) {
+        errors.push(`Could not find any modules at: ${id}`);
+      } else {
+        if (valModule.id !== id) {
+          errors.push(`Expected val id: '${id}' but got: '${valModule.id}'`);
+        }
+        if (!valModule?.schema) {
+          errors.push(`Expected val id: '${id}' to have a schema`);
+        }
+        if (!valModule?.source) {
+          errors.push(`Expected val id: '${id}' to have a source`);
+        }
+      }
+
+      if (errors.length > 0) {
+        throw Error(
+          `While processing module of id: ${id}, we got the following errors:\n${errors.join(
+            "\n"
+          )}`
+        );
+      }
+      return {
+        path: valModule.id, // This might not be the asked id/path, however, that should be handled further up in the call chain
+        source: valModule.source,
+        schema: valModule.schema,
+      };
+    }
+  } finally {
+    context.dispose();
+  }
+};