@jxsuite/server 0.21.4 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "0.21.4",
+  "version": "0.22.0",
   "description": "Jx development server with live reload, server-side proxy, and studio integration",
   "license": "MIT",
   "repository": {
@@ -25,11 +25,11 @@
     "test:coverage": "bun test --isolate --coverage"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.153",
-    "@anthropic-ai/sdk": "^0.99.0",
-    "@jxsuite/compiler": "^0.21.4",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.156",
+    "@anthropic-ai/sdk": "^0.100.1",
+    "@jxsuite/compiler": "^0.22.0",
     "@jxsuite/create": "^0.19.0",
-    "@jxsuite/parser": "^0.21.4",
+    "@jxsuite/parser": "^0.22.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "chokidar": "^5.0.0",
     "zod": "^4.4.3"

package/src/resolve.js

@@ -1,15 +1,42 @@
 /** Resolve.js — Generic $src module proxy + timing: "server" function proxy */
 
 import { resolve, relative, dirname } from "node:path";
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { loadContentTypes } from "@jxsuite/compiler/content-loader";
+
+/**
+ * Lazy-load project context (project.json + content types) for class instantiation.
+ *
+ * @param {string} projectRoot
+ * @returns {Promise<{
+ *   config: Record<string, unknown>;
+ *   contentTypes: Map<string, unknown[]>;
+ *   root: string;
+ * } | null>}
+ */
+async function loadProjectContext(projectRoot) {
+  const projectJsonPath = resolve(projectRoot, "project.json");
+  if (!existsSync(projectJsonPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync(projectJsonPath, "utf8"));
+    const contentTypes = config.contentTypes
+      ? await loadContentTypes(projectRoot, config)
+      : new Map();
+    return { config, contentTypes, root: projectRoot };
+  } catch {
+    return null;
+  }
+}
 
 /**
  * Handle POST /**jx_resolve** — proxy $prototype + $src entries.
  *
  * @param {Request} req
  * @param {string} root
+ * @param {string | null} [activeProjectRoot]
  */
-export async function handleResolve(req, root) {
+export async function handleResolve(req, root, activeProjectRoot = null) {
   let body;
   try {
     body = await req.json();
@@ -22,12 +49,25 @@ export async function handleResolve(req, root) {
 
   let moduleAbsPath;
   try {
-    if ($base) {
-      const docUrlPath = new URL($base).pathname;
-      const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
-      moduleAbsPath = resolve(resolve(root, "." + docDir), $src);
+    if ($src.startsWith("./") || $src.startsWith("../")) {
+      // Relative path
+      if ($base) {
+        const docUrlPath = new URL($base).pathname;
+        const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
+        moduleAbsPath = resolve(resolve(root, "." + docDir), $src);
+      } else {
+        moduleAbsPath = resolve(activeProjectRoot || root, $src);
+      }
     } else {
-      moduleAbsPath = resolve(root, $src);
+      // npm/bare specifier — use createRequire from project root, fall back to server package
+      const projectRoot = activeProjectRoot || root;
+      const projRequire = createRequire(resolve(projectRoot, "package.json"));
+      try {
+        moduleAbsPath = projRequire.resolve($src);
+      } catch {
+        const serverRequire = createRequire(import.meta.url);
+        moduleAbsPath = serverRequire.resolve($src);
+      }
     }
   } catch (/** @type {unknown} */ e) {
     return new Response(
@@ -54,6 +94,14 @@ export async function handleResolve(req, root) {
       const content = readFileSync(moduleAbsPath, "utf8");
       const classDef = JSON.parse(content);
 
+      // Inject project context for classes that need it
+      const projectRoot = activeProjectRoot || root;
+      const projectCtx = await loadProjectContext(projectRoot);
+      if (projectCtx) {
+        config._project = projectCtx;
+      }
+      config._document = { route: { _pathParams: {} }, state: {} };
+
       if (classDef.$implementation) {
         // Hybrid mode: redirect to the JS implementation
         const implPath = resolve(dirname(moduleAbsPath), classDef.$implementation);

package/src/server.js

@@ -196,7 +196,7 @@ export async function createDevServer(options) {
 
       // $prototype + $src proxy
       if (path === "/__jx_resolve__" && req.method === "POST") {
-        return handleResolve(req, absRoot);
+        return handleResolve(req, absRoot, activeProjectRoot);
       }
 
       // timing: "server" function proxy

package/src/studio-api.js

@@ -11,7 +11,6 @@ import { resolve, relative, basename, dirname, isAbsolute } from "node:path";
 import { readdir, stat, readFile, writeFile, rename, unlink, mkdir } from "node:fs/promises";
 import { readFileSync, existsSync } from "node:fs";
 import { transpileJxMarkdown } from "@jxsuite/parser/transpile";
-import { loadContentTypes, queryContentType, findEntry } from "@jxsuite/compiler/content-loader";
 import * as claude from "./claude-session.js";
 
 /** Normalise a path to forward slashes (Windows `path` module returns backslashes). */
@@ -800,12 +799,29 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
 
     let moduleAbsPath;
     try {
-      if (base) {
-        const docUrlPath = new URL(base).pathname;
-        const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
-        moduleAbsPath = resolve(resolve(root, "." + docDir), src);
+      if (src.startsWith("./") || src.startsWith("../")) {
+        // Relative path
+        if (base) {
+          const docUrlPath = new URL(base).pathname;
+          const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
+          moduleAbsPath = resolve(resolve(root, "." + docDir), src);
+        } else {
+          moduleAbsPath = resolve(activeProjectRoot || root, src);
+          if (!existsSync(moduleAbsPath) && activeProjectRoot) {
+            moduleAbsPath = resolve(root, src);
+          }
+        }
       } else {
-        moduleAbsPath = resolve(root, src);
+        // npm/bare specifier — use createRequire from project root, fall back to server package
+        const projectRoot = activeProjectRoot || root;
+        const { createRequire } = await import("node:module");
+        const projRequire = createRequire(resolve(projectRoot, "package.json"));
+        try {
+          moduleAbsPath = projRequire.resolve(src);
+        } catch {
+          const serverRequire = createRequire(import.meta.url);
+          moduleAbsPath = serverRequire.resolve(src);
+        }
       }
     } catch (/** @type {unknown} */ e) {
       return Response.json({
@@ -1067,50 +1083,6 @@ export async function handleStudioApi(req, url, root, activeProjectRoot = null)
     }
   }
 
-  // ─── Content Type Resolution ──────────────────────────────────────────────
-
-  if (path === "/__studio/content" && req.method === "POST") {
-    try {
-      const body = await req.json();
-      const { $prototype, contentType, id, filter, sort, limit } = body;
-      const projectRoot = activeProjectRoot || root;
-
-      let projectConfig;
-      try {
-        projectConfig = JSON.parse(readFileSync(resolve(projectRoot, "project.json"), "utf8"));
-      } catch {
-        return Response.json({ error: "No project.json found" }, { status: 404 });
-      }
-
-      if (!projectConfig.contentTypes?.[contentType]) {
-        return Response.json({ error: `Content type "${contentType}" not found` }, { status: 404 });
-      }
-
-      const contentTypes = await loadContentTypes(projectRoot, projectConfig);
-      const entries = contentTypes.get(contentType);
-      if (!entries || entries.length === 0) {
-        return Response.json($prototype === "ContentCollection" ? [] : null);
-      }
-
-      if ($prototype === "ContentCollection") {
-        const result = queryContentType(entries, { filter, sort, limit });
-        return Response.json(result);
-      }
-
-      if ($prototype === "ContentEntry") {
-        const entry = findEntry(entries, id);
-        return Response.json(entry ?? null);
-      }
-
-      return Response.json({ error: "Invalid $prototype" }, { status: 400 });
-    } catch (/** @type {unknown} */ e) {
-      return Response.json(
-        { error: /** @type {{ message?: string }} */ (e).message },
-        { status: 500 },
-      );
-    }
-  }
-
   // ─── AI Assistant ─────────────────────────────────────────────────────────
 
   if (path === "/__studio/ai/auth-status" && req.method === "GET") {