@sylphx/lens-server 2.1.0 → 2.3.0

package/src/server/create.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { describe, expect, it } from "bun:test";
-import { entity, mutation, query, router } from "@sylphx/lens-core";
+import { entity, firstValueFrom, mutation, query, resolver, router, t } from "@sylphx/lens-core";
 import { z } from "zod";
 import { optimisticPlugin } from "../plugin/optimistic.js";
 import { createApp } from "./create.js";
@@ -190,10 +190,12 @@ describe("execute", () => {
 			queries: { getUser },
 		});
 
-		const result = await server.execute({
-			path: "getUser",
-			input: { id: "123" },
-		});
+		const result = await firstValueFrom(
+			server.execute({
+				path: "getUser",
+				input: { id: "123" },
+			}),
+		);
 
 		expect(result.data).toEqual({
 			id: "123",
@@ -208,10 +210,12 @@ describe("execute", () => {
 			mutations: { createUser },
 		});
 
-		const result = await server.execute({
-			path: "createUser",
-			input: { name: "New User", email: "new@example.com" },
-		});
+		const result = await firstValueFrom(
+			server.execute({
+				path: "createUser",
+				input: { name: "New User", email: "new@example.com" },
+			}),
+		);
 
 		expect(result.data).toEqual({
 			id: "new-id",
@@ -226,10 +230,12 @@ describe("execute", () => {
 			queries: { getUser },
 		});
 
-		const result = await server.execute({
-			path: "unknownOperation",
-			input: {},
-		});
+		const result = await firstValueFrom(
+			server.execute({
+				path: "unknownOperation",
+				input: {},
+			}),
+		);
 
 		expect(result.data).toBeUndefined();
 		expect(result.error).toBeInstanceOf(Error);
@@ -241,10 +247,12 @@ describe("execute", () => {
 			queries: { getUser },
 		});
 
-		const result = await server.execute({
-			path: "getUser",
-			input: { invalid: true }, // Missing required 'id'
-		});
+		const result = await firstValueFrom(
+			server.execute({
+				path: "getUser",
+				input: { invalid: true }, // Missing required 'id'
+			}),
+		);
 
 		expect(result.data).toBeUndefined();
 		expect(result.error).toBeInstanceOf(Error);
@@ -260,10 +268,12 @@ describe("execute", () => {
 
 		const server = createApp({ router: appRouter });
 
-		const queryResult = await server.execute({
-			path: "user.get",
-			input: { id: "456" },
-		});
+		const queryResult = await firstValueFrom(
+			server.execute({
+				path: "user.get",
+				input: { id: "456" },
+			}),
+		);
 
 		expect(queryResult.data).toEqual({
 			id: "456",
@@ -271,10 +281,12 @@ describe("execute", () => {
 			email: "test@example.com",
 		});
 
-		const mutationResult = await server.execute({
-			path: "user.create",
-			input: { name: "Router User" },
-		});
+		const mutationResult = await firstValueFrom(
+			server.execute({
+				path: "user.create",
+				input: { name: "Router User" },
+			}),
+		);
 
 		expect(mutationResult.data).toEqual({
 			id: "new-id",
@@ -294,10 +306,12 @@ describe("execute", () => {
 			queries: { errorQuery },
 		});
 
-		const result = await server.execute({
-			path: "errorQuery",
-			input: { id: "1" },
-		});
+		const result = await firstValueFrom(
+			server.execute({
+				path: "errorQuery",
+				input: { id: "1" },
+			}),
+		);
 
 		expect(result.data).toBeUndefined();
 		expect(result.error).toBeInstanceOf(Error);
@@ -309,9 +323,11 @@ describe("execute", () => {
 			queries: { getUsers },
 		});
 
-		const result = await server.execute({
-			path: "getUsers",
-		});
+		const result = await firstValueFrom(
+			server.execute({
+				path: "getUsers",
+			}),
+		);
 
 		expect(result.data).toHaveLength(2);
 	});
@@ -337,10 +353,12 @@ describe("context", () => {
 			context: () => ({ userId: "user-123", role: "admin" }),
 		});
 
-		await server.execute({
-			path: "contextQuery",
-			input: { id: "1" },
-		});
+		await firstValueFrom(
+			server.execute({
+				path: "contextQuery",
+				input: { id: "1" },
+			}),
+		);
 
 		expect(capturedContext).toMatchObject({
 			userId: "user-123",
@@ -366,10 +384,12 @@ describe("context", () => {
 			},
 		});
 
-		await server.execute({
-			path: "contextQuery",
-			input: { id: "1" },
-		});
+		await firstValueFrom(
+			server.execute({
+				path: "contextQuery",
+				input: { id: "1" },
+			}),
+		);
 
 		expect(capturedContext).toMatchObject({
 			userId: "async-user",
@@ -387,13 +407,15 @@ describe("selection", () => {
 			queries: { getUser },
 		});
 
-		const result = await server.execute({
-			path: "getUser",
-			input: {
-				id: "123",
-				$select: { name: true },
-			},
-		});
+		const result = await firstValueFrom(
+			server.execute({
+				path: "getUser",
+				input: {
+					id: "123",
+					$select: { name: true },
+				},
+			}),
+		);
 
 		expect(result.data).toEqual({
 			id: "123", // id always included
@@ -422,3 +444,635 @@ describe("type inference", () => {
 		expect((server as { _types?: unknown })._types).toBeUndefined(); // Runtime undefined, compile-time exists
 	});
 });
+
+// =============================================================================
+// Field Resolver Tests (GraphQL-style per-field resolution)
+// =============================================================================
+
+describe("field resolvers", () => {
+	// Test entities for field resolver tests
+	const Author = entity("Author", {
+		id: t.id(),
+		name: t.string(),
+	});
+
+	const Post = entity("Post", {
+		id: t.id(),
+		title: t.string(),
+		content: t.string(),
+		published: t.boolean(),
+		authorId: t.string(),
+	});
+
+	// Mock data
+	const mockDb = {
+		authors: [
+			{ id: "a1", name: "Alice" },
+			{ id: "a2", name: "Bob" },
+		],
+		posts: [
+			{ id: "p1", title: "Post 1", content: "Content 1", published: true, authorId: "a1" },
+			{ id: "p2", title: "Post 2", content: "Content 2", published: false, authorId: "a1" },
+			{ id: "p3", title: "Post 3", content: "Content 3", published: true, authorId: "a1" },
+			{ id: "p4", title: "Post 4", content: "Content 4", published: true, authorId: "a2" },
+		],
+	};
+
+	type TestContext = { db: typeof mockDb };
+
+	it("resolves field with nested input args (like GraphQL)", async () => {
+		// Define field resolver with args (like GraphQL)
+		const authorResolver = resolver<TestContext>()(Author, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			posts: f
+				.many(Post)
+				.args(
+					z.object({
+						limit: z.number().optional(),
+						published: z.boolean().optional(),
+					}),
+				)
+				.resolve(({ parent, args, ctx }) => {
+					let posts = ctx.db.posts.filter((p) => p.authorId === parent.id);
+					if (args.published !== undefined) {
+						posts = posts.filter((p) => p.published === args.published);
+					}
+					if (args.limit !== undefined) {
+						posts = posts.slice(0, args.limit);
+					}
+					return posts;
+				}),
+		}));
+
+		const getAuthor = query<TestContext>()
+			.input(z.object({ id: z.string() }))
+			.returns(Author)
+			.resolve(({ input, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === input.id);
+				if (!author) throw new Error("Author not found");
+				return author;
+			});
+
+		const server = createApp({
+			entities: { Author, Post },
+			queries: { getAuthor },
+			resolvers: [authorResolver],
+			context: () => ({ db: mockDb }),
+		});
+
+		// Test with nested input: get author with only published posts, limit 2
+		const result = await firstValueFrom(
+			server.execute({
+				path: "getAuthor",
+				input: {
+					id: "a1",
+					$select: {
+						id: true,
+						name: true,
+						posts: {
+							input: { published: true, limit: 2 },
+							select: { id: true, title: true },
+						},
+					},
+				},
+			}),
+		);
+
+		expect(result.error).toBeUndefined();
+		expect(result.data).toBeDefined();
+
+		const data = result.data as { id: string; name: string; posts: { id: string; title: string }[] };
+		expect(data.id).toBe("a1");
+		expect(data.name).toBe("Alice");
+		expect(data.posts).toHaveLength(2); // limit: 2
+		expect(data.posts.every((p) => p.title)).toBe(true); // only selected fields
+	});
+
+	it("passes context to field resolvers", async () => {
+		let capturedContext: TestContext | null = null;
+
+		const authorResolver = resolver<TestContext>()(Author, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			posts: f.many(Post).resolve(({ parent, ctx }) => {
+				capturedContext = ctx;
+				return ctx.db.posts.filter((p) => p.authorId === parent.id);
+			}),
+		}));
+
+		const getAuthor = query<TestContext>()
+			.input(z.object({ id: z.string() }))
+			.returns(Author)
+			.resolve(({ input, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === input.id);
+				if (!author) throw new Error("Author not found");
+				return author;
+			});
+
+		const server = createApp({
+			entities: { Author, Post },
+			queries: { getAuthor },
+			resolvers: [authorResolver],
+			context: () => ({ db: mockDb }),
+		});
+
+		await firstValueFrom(
+			server.execute({
+				path: "getAuthor",
+				input: {
+					id: "a1",
+					$select: {
+						id: true,
+						posts: true,
+					},
+				},
+			}),
+		);
+
+		expect(capturedContext).toBeDefined();
+		expect(capturedContext?.db).toBe(mockDb);
+	});
+
+	it("supports nested input at multiple levels", async () => {
+		// Comment entity for deeper nesting
+		const Comment = entity("Comment", {
+			id: t.id(),
+			body: t.string(),
+			postId: t.string(),
+		});
+
+		const mockDbWithComments = {
+			...mockDb,
+			comments: [
+				{ id: "c1", body: "Comment 1", postId: "p1" },
+				{ id: "c2", body: "Comment 2", postId: "p1" },
+				{ id: "c3", body: "Comment 3", postId: "p2" },
+			],
+		};
+
+		type CtxWithComments = { db: typeof mockDbWithComments };
+
+		const postResolver = resolver<CtxWithComments>()(Post, (f) => ({
+			id: f.expose("id"),
+			title: f.expose("title"),
+			comments: f
+				.many(Comment)
+				.args(z.object({ limit: z.number().optional() }))
+				.resolve(({ parent, args, ctx }) => {
+					let comments = ctx.db.comments.filter((c) => c.postId === parent.id);
+					if (args.limit !== undefined) {
+						comments = comments.slice(0, args.limit);
+					}
+					return comments;
+				}),
+		}));
+
+		const authorResolver = resolver<CtxWithComments>()(Author, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			posts: f
+				.many(Post)
+				.args(z.object({ limit: z.number().optional() }))
+				.resolve(({ parent, args, ctx }) => {
+					let posts = ctx.db.posts.filter((p) => p.authorId === parent.id);
+					if (args.limit !== undefined) {
+						posts = posts.slice(0, args.limit);
+					}
+					return posts;
+				}),
+		}));
+
+		const getAuthor = query<CtxWithComments>()
+			.input(z.object({ id: z.string() }))
+			.returns(Author)
+			.resolve(({ input, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === input.id);
+				if (!author) throw new Error("Author not found");
+				return author;
+			});
+
+		const server = createApp({
+			entities: { Author, Post, Comment },
+			queries: { getAuthor },
+			resolvers: [authorResolver, postResolver],
+			context: () => ({ db: mockDbWithComments }),
+		});
+
+		// Nested input at multiple levels:
+		// Author.posts(limit: 1) -> Post.comments(limit: 1)
+		const result = await firstValueFrom(
+			server.execute({
+				path: "getAuthor",
+				input: {
+					id: "a1",
+					$select: {
+						id: true,
+						posts: {
+							input: { limit: 1 },
+							select: {
+								id: true,
+								title: true,
+								comments: {
+									input: { limit: 1 },
+									select: { id: true, body: true },
+								},
+							},
+						},
+					},
+				},
+			}),
+		);
+
+		expect(result.error).toBeUndefined();
+		const data = result.data as any;
+		expect(data.posts).toHaveLength(1);
+		expect(data.posts[0].comments).toHaveLength(1);
+	});
+
+	it("works without nested input (default args)", async () => {
+		const authorResolver = resolver<TestContext>()(Author, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			posts: f
+				.many(Post)
+				.args(z.object({ limit: z.number().default(10) }))
+				.resolve(({ parent, args, ctx }) => {
+					return ctx.db.posts.filter((p) => p.authorId === parent.id).slice(0, args.limit);
+				}),
+		}));
+
+		const getAuthor = query<TestContext>()
+			.input(z.object({ id: z.string() }))
+			.returns(Author)
+			.resolve(({ input, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === input.id);
+				if (!author) throw new Error("Author not found");
+				return author;
+			});
+
+		const server = createApp({
+			entities: { Author, Post },
+			queries: { getAuthor },
+			resolvers: [authorResolver],
+			context: () => ({ db: mockDb }),
+		});
+
+		// Without nested input - should use default args
+		const result = await firstValueFrom(
+			server.execute({
+				path: "getAuthor",
+				input: {
+					id: "a1",
+					$select: {
+						id: true,
+						posts: { select: { id: true } },
+					},
+				},
+			}),
+		);
+
+		expect(result.error).toBeUndefined();
+		const data = result.data as any;
+		expect(data.posts).toHaveLength(3); // All of Alice's posts (default limit 10)
+	});
+
+	it("emit() goes through field resolvers", async () => {
+		// Track how many times posts resolver is called
+		let postsResolverCallCount = 0;
+
+		const Author = entity("Author", {
+			id: t.id(),
+			name: t.string(),
+		});
+
+		const Post = entity("Post", {
+			id: t.id(),
+			title: t.string(),
+			authorId: t.string(),
+		});
+
+		const mockDb = {
+			authors: [{ id: "a1", name: "Alice" }],
+			posts: [
+				{ id: "p1", title: "Post 1", authorId: "a1" },
+				{ id: "p2", title: "Post 2", authorId: "a1" },
+			],
+		};
+
+		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			posts: f.many(Post).resolve(({ parent, ctx }) => {
+				postsResolverCallCount++;
+				return ctx.db.posts.filter((p) => p.authorId === parent.id);
+			}),
+		}));
+
+		type EmitFn = ((data: unknown) => void) & { merge: (partial: unknown) => void };
+		let capturedEmit: EmitFn | null = null;
+
+		const getAuthor = query<{ db: typeof mockDb; emit: EmitFn }>()
+			.input(z.object({ id: z.string() }))
+			.returns(Author)
+			.resolve(({ input, ctx }) => {
+				capturedEmit = ctx.emit as EmitFn;
+				const author = ctx.db.authors.find((a) => a.id === input.id);
+				if (!author) throw new Error("Author not found");
+				return author;
+			});
+
+		const server = createApp({
+			entities: { Author, Post },
+			queries: { getAuthor },
+			resolvers: [authorResolver],
+			context: () => ({ db: mockDb }),
+		});
+
+		// Subscribe to query with nested posts
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "getAuthor",
+				input: {
+					id: "a1",
+					$select: {
+						id: true,
+						name: true,
+						posts: { select: { id: true, title: true } },
+					},
+				},
+			})
+			.subscribe({
+				next: (result) => {
+					results.push(result);
+				},
+			});
+
+		// Wait for initial result
+		await new Promise((resolve) => setTimeout(resolve, 50));
+
+		expect(results.length).toBe(1);
+		expect(postsResolverCallCount).toBe(1); // Called once for initial query
+
+		// Add a new post to the mock DB
+		mockDb.posts.push({ id: "p3", title: "Post 3", authorId: "a1" });
+
+		// Emit updated author (this should trigger field resolvers)
+		capturedEmit!({ id: "a1", name: "Alice Updated" });
+
+		// Wait for emit to process
+		await new Promise((resolve) => setTimeout(resolve, 50));
+
+		expect(results.length).toBe(2);
+		expect(postsResolverCallCount).toBe(2); // Called again after emit!
+
+		// Verify the emitted result includes the new post (from re-running posts resolver)
+		const latestResult = results[1] as { data: { posts: { id: string }[] } };
+		expect(latestResult.data.posts).toHaveLength(3); // Should have 3 posts now
+
+		subscription.unsubscribe();
+	});
+
+	it("field resolvers receive onCleanup for cleanup registration", async () => {
+		let cleanupCalled = false;
+		let resolverReceivedOnCleanup = false;
+
+		const Author = entity("Author", {
+			id: t.id(),
+			name: t.string(),
+		});
+
+		const Post = entity("Post", {
+			id: t.id(),
+			title: t.string(),
+			authorId: t.string(),
+		});
+
+		const mockDb = {
+			authors: [{ id: "a1", name: "Alice" }],
+			posts: [{ id: "p1", title: "Post 1", authorId: "a1" }],
+		};
+
+		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			posts: f.many(Post).resolve(({ parent, ctx }) => {
+				// Track if onCleanup was received (via ctx)
+				resolverReceivedOnCleanup = ctx.onCleanup !== undefined;
+
+				// Register a cleanup if available
+				if (ctx.onCleanup) {
+					ctx.onCleanup(() => {
+						cleanupCalled = true;
+					});
+				}
+
+				return ctx.db.posts.filter((p) => p.authorId === parent.id);
+			}),
+		}));
+
+		const getAuthor = query<{ db: typeof mockDb }>()
+			.input(z.object({ id: z.string() }))
+			.returns(Author)
+			.resolve(({ input, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === input.id);
+				if (!author) throw new Error("Author not found");
+				return author;
+			});
+
+		const server = createApp({
+			entities: { Author, Post },
+			queries: { getAuthor },
+			resolvers: [authorResolver],
+			context: () => ({ db: mockDb }),
+		});
+
+		const subscription = server
+			.execute({
+				path: "getAuthor",
+				input: {
+					id: "a1",
+					$select: {
+						id: true,
+						posts: { select: { id: true } },
+					},
+				},
+			})
+			.subscribe({});
+
+		// Wait for query to execute
+		await new Promise((resolve) => setTimeout(resolve, 50));
+
+		// Verify field resolver received onCleanup
+		expect(resolverReceivedOnCleanup).toBe(true);
+		expect(cleanupCalled).toBe(false); // Not called yet
+
+		// Unsubscribe should trigger cleanup
+		subscription.unsubscribe();
+
+		// Cleanup should be called
+		expect(cleanupCalled).toBe(true);
+	});
+
+	it("field-level emit updates specific field and notifies observer", async () => {
+		const Author = entity("Author", {
+			id: t.id(),
+			name: t.string(),
+		});
+
+		const Post = entity("Post", {
+			id: t.id(),
+			title: t.string(),
+			authorId: t.string(),
+		});
+
+		const mockDb = {
+			authors: [{ id: "a1", name: "Alice" }],
+			posts: [
+				{ id: "p1", title: "Post 1", authorId: "a1" },
+				{ id: "p2", title: "Post 2", authorId: "a1" },
+			],
+		};
+
+		// Track field emit
+		let capturedFieldEmit: ((value: unknown) => void) | undefined;
+
+		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			posts: f.many(Post).resolve(({ parent, ctx }) => {
+				// Capture the field emit for later use
+				capturedFieldEmit = ctx.emit;
+
+				// Set up a mock subscription that will use field emit
+				if (ctx.emit && ctx.onCleanup) {
+					// Simulate subscription setup
+					ctx.onCleanup(() => {
+						capturedFieldEmit = undefined;
+					});
+				}
+
+				return ctx.db.posts.filter((p) => p.authorId === parent.id);
+			}),
+		}));
+
+		const getAuthor = query<{ db: typeof mockDb }>()
+			.input(z.object({ id: z.string() }))
+			.returns(Author)
+			.resolve(({ input, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === input.id);
+				if (!author) throw new Error("Author not found");
+				return author;
+			});
+
+		const server = createApp({
+			entities: { Author, Post },
+			queries: { getAuthor },
+			resolvers: [authorResolver],
+			context: () => ({ db: mockDb }),
+		});
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "getAuthor",
+				input: {
+					id: "a1",
+					$select: {
+						id: true,
+						name: true,
+						posts: { select: { id: true, title: true } },
+					},
+				},
+			})
+			.subscribe({
+				next: (result) => {
+					results.push(result);
+				},
+			});
+
+		// Wait for initial result
+		await new Promise((resolve) => setTimeout(resolve, 50));
+
+		expect(results.length).toBe(1);
+		expect(capturedFieldEmit).toBeDefined();
+
+		const initialResult = results[0] as { data: { posts: { id: string }[] } };
+		expect(initialResult.data.posts).toHaveLength(2);
+
+		// Use field-level emit to update just the posts field
+		const newPosts = [
+			{ id: "p1", title: "Updated Post 1", authorId: "a1" },
+			{ id: "p2", title: "Updated Post 2", authorId: "a1" },
+			{ id: "p3", title: "New Post 3", authorId: "a1" },
+		];
+		capturedFieldEmit!(newPosts);
+
+		// Wait for field emit to process
+		await new Promise((resolve) => setTimeout(resolve, 50));
+
+		expect(results.length).toBe(2);
+		const updatedResult = results[1] as { data: { posts: { id: string; title: string }[] } };
+		expect(updatedResult.data.posts).toHaveLength(3);
+		expect(updatedResult.data.posts[2].title).toBe("New Post 3");
+
+		subscription.unsubscribe();
+	});
+
+	it("emit skips observer notification when value unchanged", async () => {
+		type EmitFn = (data: { id: string; name: string }) => void;
+		let capturedEmit: EmitFn | undefined;
+
+		// Query that captures emit for external use
+		const liveQuery = query()
+			.input(z.object({ id: z.string() }))
+			.returns(User)
+			.resolve(({ input, ctx }) => {
+				capturedEmit = ctx.emit as EmitFn;
+				return { id: input.id, name: "Initial" };
+			});
+
+		const testRouter = router({ liveQuery });
+		const app = createApp({ router: testRouter });
+
+		const results: unknown[] = [];
+		const observable = app.execute({
+			path: "liveQuery",
+			input: { id: "1" },
+		});
+
+		const subscription = observable.subscribe({
+			next: (value) => results.push(value),
+		});
+
+		// Wait for initial result
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		expect(results.length).toBe(1);
+		const firstResult = results[0] as { data: { id: string; name: string } };
+		expect(firstResult.data.name).toBe("Initial");
+
+		// Emit same value - should be skipped (equality check)
+		capturedEmit!({ id: "1", name: "Initial" });
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		expect(results.length).toBe(1); // Still 1, not 2
+
+		// Emit same value again - should be skipped
+		capturedEmit!({ id: "1", name: "Initial" });
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		expect(results.length).toBe(1); // Still 1
+
+		// Emit different value - should emit
+		capturedEmit!({ id: "1", name: "Changed" });
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		expect(results.length).toBe(2); // Now 2
+		expect((results[1] as { data: { name: string } }).data.name).toBe("Changed");
+
+		// Emit same "Changed" value again - should be skipped
+		capturedEmit!({ id: "1", name: "Changed" });
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		expect(results.length).toBe(2); // Still 2
+
+		subscription.unsubscribe();
+	});
+});