@sylphx/lens-server 4.0.0 → 4.1.0

package/dist/index.js

@@ -39,12 +39,15 @@ import {
   collectModelsFromRouter,
   createEmit,
   createResolverFromEntity,
+  firstValueFrom,
   flattenRouter,
   hashValue,
+  isError,
   isLiveQueryDef,
   isModelDef,
   isMutationDef,
   isQueryDef,
+  isSnapshot,
   isSubscriptionDef,
   mergeModelCollections,
   toOps,
@@ -515,7 +518,7 @@ class LensServerImpl {
               observer.complete?.();
               return;
             }
-            const publisher = subscriber({ input, ctx: context });
+            const publisher = subscriber({ args: input, ctx: context });
             if (publisher) {
               const emit = createEmit((command) => {
                 if (cancelled)
@@ -1009,353 +1012,91 @@ class LensServerImpl {
   getPluginManager() {
     return this.pluginManager;
   }
-}
-function createApp(config) {
-  const server = new LensServerImpl(config);
-  return server;
-}
-// src/sse/handler.ts
-class SSEHandler {
-  heartbeatInterval;
-  onConnectCallback;
-  onDisconnectCallback;
-  clients = new Map;
-  clientCounter = 0;
-  constructor(config = {}) {
-    this.heartbeatInterval = config.heartbeatInterval ?? 30000;
-    this.onConnectCallback = config.onConnect;
-    this.onDisconnectCallback = config.onDisconnect;
-  }
-  handleConnection(_req) {
-    const clientId = `sse_${++this.clientCounter}_${Date.now()}`;
-    const encoder = new TextEncoder;
-    const stream = new ReadableStream({
-      start: (controller) => {
-        const heartbeat = setInterval(() => {
-          try {
-            controller.enqueue(encoder.encode(`: heartbeat ${Date.now()}
-
-`));
-          } catch {
-            this.removeClient(clientId);
-          }
-        }, this.heartbeatInterval);
-        this.clients.set(clientId, { controller, heartbeat, encoder });
-        controller.enqueue(encoder.encode(`event: connected
-data: ${JSON.stringify({ clientId })}
-
-`));
-        const client = {
-          id: clientId,
-          send: (message) => this.send(clientId, message),
-          sendEvent: (event, data) => this.sendEvent(clientId, event, data),
-          close: () => this.closeClient(clientId)
-        };
-        this.onConnectCallback?.(client);
-      },
-      cancel: () => {
-        this.removeClient(clientId);
-      }
-    });
-    return new Response(stream, {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
-        "Access-Control-Allow-Origin": "*"
-      }
-    });
-  }
-  send(clientId, message) {
-    const client = this.clients.get(clientId);
-    if (!client)
-      return false;
-    try {
-      const data = `data: ${JSON.stringify(message)}
-
-`;
-      client.controller.enqueue(client.encoder.encode(data));
-      return true;
-    } catch {
-      this.removeClient(clientId);
-      return false;
-    }
-  }
-  sendEvent(clientId, event, data) {
-    const client = this.clients.get(clientId);
-    if (!client)
-      return false;
-    if (/[\r\n:]/.test(event)) {
-      return false;
-    }
-    try {
-      const message = `event: ${event}
-data: ${JSON.stringify(data)}
-
-`;
-      client.controller.enqueue(client.encoder.encode(message));
-      return true;
-    } catch {
-      this.removeClient(clientId);
-      return false;
-    }
-  }
-  broadcast(message) {
-    for (const clientId of this.clients.keys()) {
-      this.send(clientId, message);
-    }
-  }
-  removeClient(clientId) {
-    const client = this.clients.get(clientId);
-    if (client) {
-      clearInterval(client.heartbeat);
-      this.clients.delete(clientId);
-      this.onDisconnectCallback?.(clientId);
-    }
-  }
-  closeClient(clientId) {
-    const client = this.clients.get(clientId);
-    if (client) {
-      try {
-        client.controller.close();
-      } catch {}
-      this.removeClient(clientId);
-    }
-  }
-  getClientCount() {
-    return this.clients.size;
-  }
-  getClientIds() {
-    return Array.from(this.clients.keys());
-  }
-  hasClient(clientId) {
-    return this.clients.has(clientId);
-  }
-  closeAll() {
-    for (const clientId of this.clients.keys()) {
-      this.closeClient(clientId);
-    }
-  }
-}
-function createSSEHandler(config = {}) {
-  return new SSEHandler(config);
-}
-
-// src/handlers/http.ts
-import { firstValueFrom, isError, isSnapshot } from "@sylphx/lens-core";
-function sanitizeError(error, isDevelopment) {
-  if (isDevelopment) {
-    return error.message;
-  }
-  const message = error.message;
-  const safePatterns = [
-    /^Invalid input:/,
-    /^Missing operation/,
-    /^Not found/,
-    /^Unauthorized/,
-    /^Forbidden/,
-    /^Bad request/,
-    /^Validation failed/
-  ];
-  if (safePatterns.some((pattern) => pattern.test(message))) {
-    return message;
-  }
-  const sensitivePatterns = [
-    /\/[^\s]+\.(ts|js|json)/,
-    /at\s+[^\s]+\s+\(/,
-    /ENOENT|EACCES|ECONNREFUSED/,
-    /SELECT|INSERT|UPDATE|DELETE|FROM|WHERE/i,
-    /password|secret|token|key|auth/i
-  ];
-  if (sensitivePatterns.some((pattern) => pattern.test(message))) {
-    return "An internal error occurred";
-  }
-  if (message.length < 100 && !message.includes(`
-`)) {
-    return message;
-  }
-  return "An internal error occurred";
-}
-function createHTTPHandler(server, options = {}) {
-  const { pathPrefix = "", cors, errors, health } = options;
-  const isDevelopment = errors?.development ?? false;
-  const healthEnabled = health?.enabled !== false;
-  const healthPath = health?.path ?? "/__lens/health";
-  const startTime = Date.now();
-  const sanitize = (error) => {
-    if (errors?.sanitize) {
-      return errors.sanitize(error);
-    }
-    return sanitizeError(error, isDevelopment);
-  };
-  const allowedOrigin = cors?.origin ? Array.isArray(cors.origin) ? cors.origin.join(", ") : cors.origin : isDevelopment ? "*" : "";
-  const baseHeaders = {
-    "Content-Type": "application/json",
-    "X-Content-Type-Options": "nosniff",
-    "X-Frame-Options": "DENY",
-    "Access-Control-Allow-Methods": cors?.methods?.join(", ") ?? "GET, POST, OPTIONS",
-    "Access-Control-Allow-Headers": cors?.headers?.join(", ") ?? "Content-Type, Authorization"
-  };
-  if (allowedOrigin) {
-    baseHeaders["Access-Control-Allow-Origin"] = allowedOrigin;
-  }
-  const handler = async (request) => {
+  fetch = async (request) => {
     const url = new URL(request.url);
     const pathname = url.pathname;
+    const baseHeaders = {
+      "Content-Type": "application/json",
+      "X-Content-Type-Options": "nosniff",
+      "X-Frame-Options": "DENY",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization"
+    };
     if (request.method === "OPTIONS") {
-      return new Response(null, {
-        status: 204,
-        headers: baseHeaders
-      });
+      return new Response(null, { status: 204, headers: baseHeaders });
     }
-    const fullHealthPath = `${pathPrefix}${healthPath}`;
-    if (healthEnabled && request.method === "GET" && pathname === fullHealthPath) {
-      const metadata = server.getMetadata();
-      const uptimeSeconds = Math.floor((Date.now() - startTime) / 1000);
-      let customChecks = {};
-      let hasFailure = false;
-      if (health?.checks) {
-        try {
-          customChecks = await health.checks();
-          hasFailure = Object.values(customChecks).some((c) => c.status === "fail");
-        } catch (error) {
-          customChecks.healthCheck = {
-            status: "fail",
-            message: error instanceof Error ? error.message : "Health check failed"
-          };
-          hasFailure = true;
-        }
-      }
-      const response = {
-        status: hasFailure ? "degraded" : "healthy",
+    if (request.method === "GET" && pathname === "/__lens/health") {
+      const metadata = this.getMetadata();
+      return new Response(JSON.stringify({
+        status: "healthy",
         service: "lens-server",
         version: metadata.version,
-        uptime: uptimeSeconds,
         timestamp: new Date().toISOString()
-      };
-      if (Object.keys(customChecks).length > 0) {
-        response.checks = customChecks;
-      }
-      return new Response(JSON.stringify(response), {
-        status: hasFailure ? 503 : 200,
+      }), {
         headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache, no-store, must-revalidate",
-          ...baseHeaders
+          ...baseHeaders,
+          "Cache-Control": "no-cache, no-store, must-revalidate"
         }
       });
     }
-    const metadataPath = `${pathPrefix}/__lens/metadata`;
-    if (request.method === "GET" && pathname === metadataPath) {
-      return new Response(JSON.stringify(server.getMetadata()), {
-        headers: {
-          "Content-Type": "application/json",
-          ...baseHeaders
-        }
+    if (request.method === "GET" && pathname === "/__lens/metadata") {
+      return new Response(JSON.stringify(this.getMetadata()), {
+        headers: baseHeaders
       });
     }
-    const operationPath = pathPrefix || "/";
-    if (request.method === "POST" && (pathname === operationPath || pathname === `${pathPrefix}/`)) {
+    if (request.method === "POST" && (pathname === "/" || pathname === "")) {
       let body;
       try {
         body = await request.json();
       } catch {
         return new Response(JSON.stringify({ error: "Invalid JSON in request body" }), {
           status: 400,
-          headers: {
-            "Content-Type": "application/json",
-            ...baseHeaders
-          }
+          headers: baseHeaders
+        });
+      }
+      if (!body.path) {
+        return new Response(JSON.stringify({ error: "Missing operation path" }), {
+          status: 400,
+          headers: baseHeaders
         });
       }
       try {
-        if (!body.path) {
-          return new Response(JSON.stringify({ error: "Missing operation path" }), {
-            status: 400,
-            headers: {
-              "Content-Type": "application/json",
-              ...baseHeaders
-            }
-          });
-        }
-        const result2 = await firstValueFrom(server.execute({
-          path: body.path,
-          input: body.input
-        }));
-        if (isError(result2)) {
-          return new Response(JSON.stringify({ error: result2.error }), {
+        const result = await firstValueFrom(this.execute({ path: body.path, input: body.input }));
+        if (isError(result)) {
+          return new Response(JSON.stringify({ error: result.error }), {
             status: 500,
-            headers: {
-              "Content-Type": "application/json",
-              ...baseHeaders
-            }
+            headers: baseHeaders
           });
         }
-        if (isSnapshot(result2)) {
-          return new Response(JSON.stringify({ data: result2.data }), {
-            headers: {
-              "Content-Type": "application/json",
-              ...baseHeaders
-            }
+        if (isSnapshot(result)) {
+          return new Response(JSON.stringify({ data: result.data }), {
+            headers: baseHeaders
           });
         }
-        return new Response(JSON.stringify(result2), {
-          headers: {
-            "Content-Type": "application/json",
-            ...baseHeaders
-          }
-        });
+        return new Response(JSON.stringify(result), { headers: baseHeaders });
       } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        return new Response(JSON.stringify({ error: sanitize(err) }), {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        return new Response(JSON.stringify({ error: errMsg }), {
           status: 500,
-          headers: {
-            "Content-Type": "application/json",
-            ...baseHeaders
-          }
+          headers: baseHeaders
         });
       }
     }
     return new Response(JSON.stringify({ error: "Not found" }), {
       status: 404,
-      headers: {
-        "Content-Type": "application/json",
-        ...baseHeaders
-      }
+      headers: baseHeaders
     });
   };
-  const result = handler;
-  result.handle = handler;
-  return result;
 }
-
-// src/handlers/unified.ts
-function createHandler(server, options = {}) {
-  const { ssePath = "/__lens/sse", heartbeatInterval, ...httpOptions } = options;
-  const pathPrefix = httpOptions.pathPrefix ?? "";
-  const fullSsePath = `${pathPrefix}${ssePath}`;
-  const httpHandler = createHTTPHandler(server, httpOptions);
-  const pluginManager = server.getPluginManager();
-  const sseHandler = new SSEHandler({
-    ...heartbeatInterval !== undefined && { heartbeatInterval },
-    onConnect: (client) => {
-      pluginManager.runOnConnect({ clientId: client.id });
-    },
-    onDisconnect: (clientId) => {
-      pluginManager.runOnDisconnect({ clientId, subscriptionCount: 0 });
-    }
-  });
-  const handler = async (request) => {
-    const url = new URL(request.url);
-    if (request.method === "GET" && url.pathname === fullSsePath) {
-      return sseHandler.handleConnection(request);
-    }
-    return httpHandler(request);
-  };
-  const result = handler;
-  result.handle = handler;
-  result.sse = sseHandler;
-  return result;
+function createApp(config) {
+  const server = new LensServerImpl(config);
+  const app = (request) => server.fetch(request);
+  app.fetch = server.fetch;
+  app.execute = server.execute.bind(server);
+  app.getMetadata = server.getMetadata.bind(server);
+  app.getPluginManager = server.getPluginManager.bind(server);
+  return app;
 }
 // src/handlers/framework.ts
 import { firstValueFrom as firstValueFrom2, isError as isError2, isSnapshot as isSnapshot2 } from "@sylphx/lens-core";
@@ -1514,6 +1255,132 @@ function createFrameworkHandler(server, options = {}) {
     return new Response("Method not allowed", { status: 405 });
   };
 }
+// src/sse/handler.ts
+class SSEHandler {
+  heartbeatInterval;
+  onConnectCallback;
+  onDisconnectCallback;
+  clients = new Map;
+  clientCounter = 0;
+  constructor(config = {}) {
+    this.heartbeatInterval = config.heartbeatInterval ?? 30000;
+    this.onConnectCallback = config.onConnect;
+    this.onDisconnectCallback = config.onDisconnect;
+  }
+  handleConnection(_req) {
+    const clientId = `sse_${++this.clientCounter}_${Date.now()}`;
+    const encoder = new TextEncoder;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const heartbeat = setInterval(() => {
+          try {
+            controller.enqueue(encoder.encode(`: heartbeat ${Date.now()}
+
+`));
+          } catch {
+            this.removeClient(clientId);
+          }
+        }, this.heartbeatInterval);
+        this.clients.set(clientId, { controller, heartbeat, encoder });
+        controller.enqueue(encoder.encode(`event: connected
+data: ${JSON.stringify({ clientId })}
+
+`));
+        const client = {
+          id: clientId,
+          send: (message) => this.send(clientId, message),
+          sendEvent: (event, data) => this.sendEvent(clientId, event, data),
+          close: () => this.closeClient(clientId)
+        };
+        this.onConnectCallback?.(client);
+      },
+      cancel: () => {
+        this.removeClient(clientId);
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      }
+    });
+  }
+  send(clientId, message) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return false;
+    try {
+      const data = `data: ${JSON.stringify(message)}
+
+`;
+      client.controller.enqueue(client.encoder.encode(data));
+      return true;
+    } catch {
+      this.removeClient(clientId);
+      return false;
+    }
+  }
+  sendEvent(clientId, event, data) {
+    const client = this.clients.get(clientId);
+    if (!client)
+      return false;
+    if (/[\r\n:]/.test(event)) {
+      return false;
+    }
+    try {
+      const message = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+      client.controller.enqueue(client.encoder.encode(message));
+      return true;
+    } catch {
+      this.removeClient(clientId);
+      return false;
+    }
+  }
+  broadcast(message) {
+    for (const clientId of this.clients.keys()) {
+      this.send(clientId, message);
+    }
+  }
+  removeClient(clientId) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      clearInterval(client.heartbeat);
+      this.clients.delete(clientId);
+      this.onDisconnectCallback?.(clientId);
+    }
+  }
+  closeClient(clientId) {
+    const client = this.clients.get(clientId);
+    if (client) {
+      try {
+        client.controller.close();
+      } catch {}
+      this.removeClient(clientId);
+    }
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  getClientIds() {
+    return Array.from(this.clients.keys());
+  }
+  hasClient(clientId) {
+    return this.clients.has(clientId);
+  }
+  closeAll() {
+    for (const clientId of this.clients.keys()) {
+      this.closeClient(clientId);
+    }
+  }
+}
+function createSSEHandler(config = {}) {
+  return new SSEHandler(config);
+}
 // src/handlers/ws.ts
 import {
   firstValueFrom as firstValueFrom3,
@@ -2961,8 +2828,6 @@ export {
   createServerClientProxy,
   createSSEHandler,
   createPluginManager,
-  createHandler,
-  createHTTPHandler,
   createFrameworkHandler,
   createContext,
   createApp,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "4.0.0",
+	"version": "4.1.0",
 	"description": "Server runtime for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -30,7 +30,7 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-core": "^4.0.1"
+		"@sylphx/lens-core": "^4.1.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.9.3",

package/src/e2e/server.test.ts

@@ -68,7 +68,7 @@ describe("E2E - Basic Operations", () => {
 
 	it("query with input", async () => {
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.returns(User)
 			.resolve(({ args }) => {
 				const user = mockUsers.find((u) => u.id === args.id);
@@ -96,7 +96,7 @@ describe("E2E - Basic Operations", () => {
 
 	it("mutation", async () => {
 		const createUser = mutation()
-			.input(z.object({ name: z.string(), email: z.string() }))
+			.args(z.object({ name: z.string(), email: z.string() }))
 			.returns(User)
 			.resolve(({ args }) => ({
 				id: "user-new",
@@ -130,7 +130,7 @@ describe("E2E - Basic Operations", () => {
 
 	it("handles query errors", async () => {
 		const failingQuery = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.resolve(() => {
 				throw new Error("Query failed");
 			});
@@ -178,7 +178,7 @@ describe("E2E - Context", () => {
 		let capturedContext: unknown = null;
 
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.resolve(({ ctx }) => {
 				capturedContext = ctx;
 				return mockUsers[0];
@@ -206,7 +206,7 @@ describe("E2E - Context", () => {
 		let capturedContext: unknown = null;
 
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.resolve(({ ctx }) => {
 				capturedContext = ctx;
 				return mockUsers[0];
@@ -240,7 +240,7 @@ describe("E2E - Context", () => {
 describe("E2E - Selection", () => {
 	it("applies $select to filter fields", async () => {
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.returns(User)
 			.resolve(({ args }) => {
 				const user = mockUsers.find((u) => u.id === args.id);
@@ -278,7 +278,7 @@ describe("E2E - Selection", () => {
 
 	it("includes id by default in selection", async () => {
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.returns(User)
 			.resolve(({ args }) => mockUsers.find((u) => u.id === args.id)!);
 
@@ -340,7 +340,7 @@ describe("E2E - Entity Resolvers", () => {
 		}));
 
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.returns(UserWithPosts)
 			.resolve(({ args }) => {
 				const user = users.find((u) => u.id === args.id);
@@ -460,12 +460,12 @@ describe("E2E - Entity Resolvers", () => {
 describe("E2E - Metadata", () => {
 	it("returns correct metadata structure", () => {
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.returns(User)
 			.resolve(({ args }) => mockUsers.find((u) => u.id === args.id)!);
 
 		const createUser = mutation()
-			.input(z.object({ name: z.string() }))
+			.args(z.object({ name: z.string() }))
 			.returns(User)
 			.resolve(({ args }) => ({ id: "new", name: args.name, email: "", status: "" }));
 
@@ -489,12 +489,12 @@ describe("E2E - Metadata", () => {
 
 	it("auto-derives optimistic hints from naming with plugin", () => {
 		const updateUser = mutation()
-			.input(z.object({ id: z.string(), name: z.string() }))
+			.args(z.object({ id: z.string(), name: z.string() }))
 			.returns(User)
 			.resolve(({ args }) => ({ ...mockUsers[0], name: args.name }));
 
 		const deleteUser = mutation()
-			.input(z.object({ id: z.string() }))
+			.args(z.object({ id: z.string() }))
 			.resolve(() => ({ success: true }));
 
 		const server = createApp({

package/src/handlers/http.test.ts

@@ -13,14 +13,14 @@ import { createHTTPHandler } from "./http.js";
 // =============================================================================
 
 const getUser = query()
-	.input(z.object({ id: z.string() }))
+	.args(z.object({ id: z.string() }))
 	.resolve(({ args }) => ({
 		id: args.id,
 		name: "Test User",
 	}));
 
 const createUser = mutation()
-	.input(z.object({ name: z.string() }))
+	.args(z.object({ name: z.string() }))
 	.resolve(({ args }) => ({
 		id: "new-id",
 		name: args.name,