@sylphx/lens-server 3.0.1 → 4.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "3.0.1",
+	"version": "4.0.1",
 	"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": "^3.0.1"
+		"@sylphx/lens-core": "^4.0.2"
 	},
 	"devDependencies": {
 		"typescript": "^5.9.3",

package/src/e2e/server.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { describe, expect, it } from "bun:test";
-import { entity, firstValueFrom, isError, isSnapshot, lens, mutation, query, t } from "@sylphx/lens-core";
+import { firstValueFrom, id, isError, isSnapshot, model, mutation, query, resolver, string } from "@sylphx/lens-core";
 import { z } from "zod";
 import { optimisticPlugin } from "../plugin/optimistic.js";
 import { createApp } from "../server/create.js";
@@ -18,18 +18,18 @@ import { createApp } from "../server/create.js";
 // =============================================================================
 
 // Entities
-const User = entity("User", {
-	id: t.id(),
-	name: t.string(),
-	email: t.string(),
-	status: t.string(),
+const User = model("User", {
+	id: id(),
+	name: string(),
+	email: string(),
+	status: string(),
 });
 
-const Post = entity("Post", {
-	id: t.id(),
-	title: t.string(),
-	content: t.string(),
-	authorId: t.string(),
+const Post = model("Post", {
+	id: id(),
+	title: string(),
+	content: string(),
+	authorId: string(),
 });
 
 // Mock data
@@ -68,10 +68,10 @@ 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(({ input }) => {
-				const user = mockUsers.find((u) => u.id === input.id);
+			.resolve(({ args }) => {
+				const user = mockUsers.find((u) => u.id === args.id);
 				if (!user) throw new Error("User not found");
 				return user;
 			});
@@ -96,12 +96,12 @@ 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(({ input }) => ({
+			.resolve(({ args }) => ({
 				id: "user-new",
-				name: input.name,
-				email: input.email,
+				name: args.name,
+				email: args.email,
 				status: "offline",
 			}));
 
@@ -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,10 +240,10 @@ 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(({ input }) => {
-				const user = mockUsers.find((u) => u.id === input.id);
+			.resolve(({ args }) => {
+				const user = mockUsers.find((u) => u.id === args.id);
 				if (!user) throw new Error("User not found");
 				return user;
 			});
@@ -278,9 +278,9 @@ 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(({ input }) => mockUsers.find((u) => u.id === input.id)!);
+			.resolve(({ args }) => mockUsers.find((u) => u.id === args.id)!);
 
 		const server = createApp({
 			entities: { User },
@@ -323,28 +323,36 @@ describe("E2E - Entity Resolvers", () => {
 			{ id: "post-2", title: "Second Post", content: "More content", authorId: "user-1" },
 		];
 
+		// Define User model
+		const UserWithPosts = model("UserWithPosts", {
+			id: id(),
+			name: string(),
+			email: string(),
+		});
+
+		// Define resolver with posts relation (new API)
+		const userResolver = resolver(UserWithPosts, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			email: t.expose("email"),
+			// Plain function for relations
+			posts: ({ source }) => posts.filter((p) => p.authorId === source.id),
+		}));
+
 		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => {
-				const user = users.find((u) => u.id === input.id);
+			.args(z.object({ id: z.string() }))
+			.returns(UserWithPosts)
+			.resolve(({ args }) => {
+				const user = users.find((u) => u.id === args.id);
 				if (!user) throw new Error("Not found");
 				return user;
 			});
 
-		// Create entity resolvers using lens() factory
-		const { resolver } = lens();
-		const userResolver = resolver(User, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			email: f.expose("email"),
-			posts: f.many(Post).resolve(({ parent }) => posts.filter((p) => p.authorId === parent.id)),
-		}));
-
 		const server = createApp({
-			entities: { User, Post },
+			entities: { UserWithPosts, Post },
 			queries: { getUser },
 			resolvers: [userResolver],
+			context: () => ({}),
 		});
 
 		// Test with $select for nested posts
@@ -367,14 +375,10 @@ describe("E2E - Entity Resolvers", () => {
 
 		expect(isSnapshot(result)).toBe(true);
 		if (isSnapshot(result)) {
-			expect(result.data).toMatchObject({
-				id: "user-1",
-				name: "Alice",
-				posts: [
-					{ id: "post-1", title: "Hello World" },
-					{ id: "post-2", title: "Second Post" },
-				],
-			});
+			// Verify base fields and posts work with new resolver() API
+			expect(result.data).toHaveProperty("name", "Alice");
+			expect((result.data as any).posts).toHaveLength(2);
+			expect((result.data as any).posts[0]).toHaveProperty("title", "Hello World");
 		}
 	});
 
@@ -392,25 +396,32 @@ describe("E2E - Entity Resolvers", () => {
 			{ id: "post-2", title: "Post 2", authorId: "user-2" },
 		];
 
-		const getUsers = query()
-			.returns([User])
-			.resolve(() => users);
+		// Define User model
+		const UserBatched = model("UserBatched", {
+			id: id(),
+			name: string(),
+		});
 
-		// Create entity resolvers using lens() factory
-		const { resolver } = lens();
-		const userResolver = resolver(User, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f.many(Post).resolve(({ parent }) => {
+		// Define resolver with posts relation (new API)
+		const userResolver = resolver(UserBatched, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			// Plain function for relations
+			posts: ({ source }) => {
 				batchCallCount++;
-				return posts.filter((p) => p.authorId === parent.id);
-			}),
+				return posts.filter((p) => p.authorId === source.id);
+			},
 		}));
 
+		const getUsers = query()
+			.returns([UserBatched])
+			.resolve(() => users);
+
 		const server = createApp({
-			entities: { User, Post },
+			entities: { UserBatched, Post },
 			queries: { getUsers },
 			resolvers: [userResolver],
+			context: () => ({}),
 		});
 
 		// Execute query with nested selection for all users
@@ -432,9 +443,12 @@ describe("E2E - Entity Resolvers", () => {
 
 		expect(isSnapshot(result)).toBe(true);
 		if (isSnapshot(result)) {
-			// Resolvers are called - exact count depends on DataLoader batching behavior
+			// Should batch calls - with DataLoader we get 2 calls (one per user)
 			expect(batchCallCount).toBeGreaterThanOrEqual(2);
 			expect(result.data).toHaveLength(2);
+			// Verify posts are resolved
+			expect((result.data as any)[0].posts).toHaveLength(1);
+			expect((result.data as any)[1].posts).toHaveLength(1);
 		}
 	});
 });
@@ -446,14 +460,14 @@ 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(({ input }) => mockUsers.find((u) => u.id === input.id)!);
+			.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(({ input }) => ({ id: "new", name: input.name, email: "", status: "" }));
+			.resolve(({ args }) => ({ id: "new", name: args.name, email: "", status: "" }));
 
 		const server = createApp({
 			entities: { User },
@@ -475,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(({ input }) => ({ ...mockUsers[0], name: input.name }));
+			.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/framework.ts

@@ -196,45 +196,78 @@ export function handleWebSSE(
 	signal?: AbortSignal,
 ): Response {
 	const inputParam = url.searchParams.get("input");
-	const input = inputParam ? JSON.parse(inputParam) : undefined;
+
+	// Parse input with error handling
+	let input: unknown;
+	if (inputParam) {
+		try {
+			input = JSON.parse(inputParam);
+		} catch (parseError) {
+			// Return error response for malformed JSON
+			const encoder = new TextEncoder();
+			const errorStream = new ReadableStream({
+				start(controller) {
+					const errMsg = parseError instanceof Error ? parseError.message : "Invalid JSON";
+					const data = `event: error\ndata: ${JSON.stringify({ error: `Invalid input JSON: ${errMsg}` })}\n\n`;
+					controller.enqueue(encoder.encode(data));
+					controller.close();
+				},
+			});
+			return new Response(errorStream, {
+				headers: {
+					"Content-Type": "text/event-stream",
+					"Cache-Control": "no-cache",
+					Connection: "keep-alive",
+				},
+			});
+		}
+	}
 
 	const stream = new ReadableStream({
 		start(controller) {
 			const encoder = new TextEncoder();
 
-			const result = server.execute({ path, input });
-
-			if (result && typeof result === "object" && "subscribe" in result) {
-				const observable = result as {
-					subscribe: (handlers: {
-						next: (value: { data?: unknown }) => void;
-						error: (err: Error) => void;
-						complete: () => void;
-					}) => { unsubscribe: () => void };
-				};
-
-				const subscription = observable.subscribe({
-					next: (value) => {
-						const data = `data: ${JSON.stringify(value.data)}\n\n`;
-						controller.enqueue(encoder.encode(data));
-					},
-					error: (err) => {
-						const data = `event: error\ndata: ${JSON.stringify({ error: err.message })}\n\n`;
-						controller.enqueue(encoder.encode(data));
-						controller.close();
-					},
-					complete: () => {
-						controller.close();
-					},
-				});
-
-				// Clean up on abort
-				if (signal) {
-					signal.addEventListener("abort", () => {
-						subscription.unsubscribe();
-						controller.close();
+			try {
+				const result = server.execute({ path, input });
+
+				if (result && typeof result === "object" && "subscribe" in result) {
+					const observable = result as {
+						subscribe: (handlers: {
+							next: (value: { data?: unknown }) => void;
+							error: (err: Error) => void;
+							complete: () => void;
+						}) => { unsubscribe: () => void };
+					};
+
+					const subscription = observable.subscribe({
+						next: (value) => {
+							const data = `data: ${JSON.stringify(value.data)}\n\n`;
+							controller.enqueue(encoder.encode(data));
+						},
+						error: (err) => {
+							const data = `event: error\ndata: ${JSON.stringify({ error: err.message })}\n\n`;
+							controller.enqueue(encoder.encode(data));
+							controller.close();
+						},
+						complete: () => {
+							controller.close();
+						},
 					});
+
+					// Clean up on abort
+					if (signal) {
+						signal.addEventListener("abort", () => {
+							subscription.unsubscribe();
+							controller.close();
+						});
+					}
 				}
+			} catch (execError) {
+				// Handle synchronous errors from server.execute() or subscribe()
+				const errMsg = execError instanceof Error ? execError.message : "Internal error";
+				const data = `event: error\ndata: ${JSON.stringify({ error: errMsg })}\n\n`;
+				controller.enqueue(encoder.encode(data));
+				controller.close();
 			}
 		},
 	});

package/src/handlers/http.test.ts

@@ -13,17 +13,17 @@ import { createHTTPHandler } from "./http.js";
 // =============================================================================
 
 const getUser = query()
-	.input(z.object({ id: z.string() }))
-	.resolve(({ input }) => ({
-		id: input.id,
+	.args(z.object({ id: z.string() }))
+	.resolve(({ args }) => ({
+		id: args.id,
 		name: "Test User",
 	}));
 
 const createUser = mutation()
-	.input(z.object({ name: z.string() }))
-	.resolve(({ input }) => ({
+	.args(z.object({ name: z.string() }))
+	.resolve(({ args }) => ({
 		id: "new-id",
-		name: input.name,
+		name: args.name,
 	}));
 
 // =============================================================================
@@ -74,7 +74,7 @@ describe("createHTTPHandler", () => {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({
-				operation: "getUser",
+				path: "getUser",
 				input: { id: "123" },
 			}),
 		});
@@ -97,7 +97,7 @@ describe("createHTTPHandler", () => {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({
-				operation: "createUser",
+				path: "createUser",
 				input: { name: "New User" },
 			}),
 		});
@@ -128,7 +128,7 @@ describe("createHTTPHandler", () => {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({
-				operation: "getUser",
+				path: "getUser",
 				input: { id: "456" },
 			}),
 		});
@@ -234,7 +234,7 @@ describe("createHTTPHandler", () => {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({
-				operation: "unknownOperation",
+				path: "unknownOperation",
 				input: {},
 			}),
 		});

package/src/handlers/http.ts

@@ -314,7 +314,7 @@ export function createHTTPHandler(
 			(pathname === operationPath || pathname === `${pathPrefix}/`)
 		) {
 			// Parse JSON body with proper error handling
-			let body: { operation?: string; path?: string; input?: unknown };
+			let body: { path?: string; input?: unknown };
 			try {
 				body = (await request.json()) as typeof body;
 			} catch {
@@ -328,9 +328,7 @@ export function createHTTPHandler(
 			}
 
 			try {
-				// Support both 'operation' and 'path' for backwards compatibility
-				const operationPath = body.operation ?? body.path;
-				if (!operationPath) {
+				if (!body.path) {
 					return new Response(JSON.stringify({ error: "Missing operation path" }), {
 						status: 400,
 						headers: {
@@ -342,7 +340,7 @@ export function createHTTPHandler(
 
 				const result = await firstValueFrom(
 					server.execute({
-						path: operationPath,
+						path: body.path,
 						input: body.input,
 					}),
 				);

package/src/handlers/ws-types.ts

@@ -16,6 +16,7 @@ export interface WSHandlerOptions {
 	 * Logger for debugging.
 	 */
 	logger?: {
+		debug?: (message: string, ...args: unknown[]) => void;
 		info?: (message: string, ...args: unknown[]) => void;
 		warn?: (message: string, ...args: unknown[]) => void;
 		error?: (message: string, ...args: unknown[]) => void;

package/src/handlers/ws.test.ts

@@ -55,9 +55,9 @@ function wait(ms = 10): Promise<void> {
 // =============================================================================
 
 const getUser = query()
-	.input(z.object({ id: z.string() }))
-	.resolve(({ input }) => ({
-		id: input.id,
+	.args(z.object({ id: z.string() }))
+	.resolve(({ args }) => ({
+		id: args.id,
 		name: "Test User",
 		__typename: "User",
 	}));
@@ -68,17 +68,17 @@ const listUsers = query().resolve(() => [
 ]);
 
 const createUser = mutation()
-	.input(z.object({ name: z.string() }))
-	.resolve(({ input }) => ({
+	.args(z.object({ name: z.string() }))
+	.resolve(({ args }) => ({
 		id: "new-id",
-		name: input.name,
+		name: args.name,
 		__typename: "User",
 	}));
 
 const slowQuery = query()
-	.input(z.object({ delay: z.number() }))
-	.resolve(async ({ input }) => {
-		await new Promise((r) => setTimeout(r, input.delay));
+	.args(z.object({ delay: z.number() }))
+	.resolve(async ({ args }) => {
+		await new Promise((r) => setTimeout(r, args.delay));
 		return { done: true };
 	});
 

package/src/handlers/ws.ts

@@ -172,8 +172,13 @@ export function createWSHandler(server: LensServer, options: WSHandlerOptions =
 					error: { code, message },
 				}),
 			);
-		} catch {
-			// Connection may already be closed
+		} catch (sendError) {
+			// Log actual error - don't silently swallow
+			// Common case is "connection already closed" but could be serialization failure
+			logger.debug?.(
+				`Failed to send error to client ${conn.id}:`,
+				sendError instanceof Error ? sendError.message : String(sendError),
+			);
 		}
 	}
 
@@ -513,7 +518,13 @@ export function createWSHandler(server: LensServer, options: WSHandlerOptions =
 
 		// Notify plugins of field updates
 		for (const entityKey of sub.entityKeys) {
-			const [entity, entityId] = entityKey.split(":");
+			const parts = entityKey.split(":");
+			// Validate entityKey format (must be "Entity:id")
+			if (parts.length < 2) {
+				logger.warn?.(`Invalid entityKey format: "${entityKey}" (expected "Entity:id")`);
+				continue;
+			}
+			const [entity, entityId] = parts;
 			await pluginManager.runOnUpdateFields({
 				clientId: conn.id,
 				subscriptionId: sub.id,

package/src/index.ts

@@ -45,8 +45,6 @@ export {
 	type QueryDef,
 	// Operations
 	query,
-	type ResolverContext,
-	type ResolverFn,
 	type RouterDef,
 	type RouterRoutes,
 	router,

package/src/plugin/optimistic.ts

@@ -17,7 +17,7 @@
  *   .input(z.object({ id: z.string(), name: z.string() }))
  *   .returns(User)
  *   .optimistic('merge')  // ✅ Type-safe
- *   .resolve(({ input }) => db.user.update(input));
+ *   .resolve(({ args }) => db.user.update(args));
  *
  * const server = createApp({ router, plugins });
  * ```
@@ -151,7 +151,7 @@ interface ReifyPipeline {
  * Sugar syntax:
  * - "merge" → entity.update with input fields
  * - "create" → entity.create from output
- * - "delete" → entity.delete by input.id
+ * - "delete" → entity.delete by args.id
  *
  * Returns the original value if already a Pipeline.
  *
@@ -176,7 +176,7 @@ function sugarToPipeline(
 
 	switch (sugar) {
 		case "merge": {
-			// entity.update('Entity', { id: input.id, ...fields })
+			// entity.update('Entity', { id: args.id, ...fields })
 			const updateData: Record<string, unknown> = {
 				type: entity,
 				id: $input("id"),
@@ -217,14 +217,14 @@ function sugarToPipeline(
 			return pipeline as unknown as Pipeline;
 		}
 		case "delete": {
-			// entity.delete('Entity', { id: input.id })
+			// entity.delete('Entity', { id: args.id })
 			const pipeline: ReifyPipeline = {
 				$pipe: [
 					{
 						$do: "entity.delete",
 						$with: {
 							type: entity,
-							id: { id: $input("id") },
+							id: $input("id"), // Fixed: was incorrectly nested as { id: $input("id") }
 						},
 						$as: "result",
 					},
@@ -298,7 +298,7 @@ export type OptimisticPlugin = OptimisticPluginMarker & ServerPlugin;
  *   .input(z.object({ id: z.string(), name: z.string() }))
  *   .returns(User)
  *   .optimistic('merge')
- *   .resolve(({ input }) => db.user.update(input));
+ *   .resolve(({ args }) => db.user.update(args));
  *
  * const server = createApp({ router, plugins });
  * ```