@sylphx/lens-server 2.6.1 → 2.7.0

package/dist/index.js

@@ -36,12 +36,13 @@ function extendContext(current, extension) {
 // src/server/create.ts
 import {
   createEmit,
+  createResolverFromEntity,
   flattenRouter,
   hashValue,
+  hasInlineResolvers,
   isEntityDef,
   isMutationDef,
   isQueryDef,
-  toResolverMap,
   valuesEqual
 } from "@sylphx/lens-core";
 
@@ -353,7 +354,6 @@ class LensServerImpl {
     }
     this.queries = queries;
     this.mutations = mutations;
-    this.resolverMap = config.resolvers ? toResolverMap(config.resolvers) : undefined;
     const entities = { ...config.entities ?? {} };
     if (config.resolvers) {
       for (const resolver of config.resolvers) {
@@ -364,6 +364,7 @@ class LensServerImpl {
       }
     }
     this.entities = entities;
+    this.resolverMap = this.buildResolverMap(config.resolvers, entities);
     this.contextFactory = config.context ?? (() => ({}));
     this.version = config.version ?? "1.0.0";
     this.logger = config.logger ?? noopLogger;
@@ -403,6 +404,28 @@ class LensServerImpl {
       }
     }
   }
+  buildResolverMap(explicitResolvers, entities) {
+    const resolverMap = new Map;
+    if (explicitResolvers) {
+      for (const resolver of explicitResolvers) {
+        const entityName = resolver.entity._name;
+        if (entityName) {
+          resolverMap.set(entityName, resolver);
+        }
+      }
+    }
+    for (const [name, entity] of Object.entries(entities)) {
+      if (!isEntityDef(entity))
+        continue;
+      if (resolverMap.has(name))
+        continue;
+      if (hasInlineResolvers(entity)) {
+        const resolver = createResolverFromEntity(entity);
+        resolverMap.set(name, resolver);
+      }
+    }
+    return resolverMap.size > 0 ? resolverMap : undefined;
+  }
   hasAnySubscription(entityName, select, visited = new Set) {
     if (visited.has(entityName))
       return false;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "2.6.1",
+	"version": "2.7.0",
 	"description": "Server runtime for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",

package/src/server/create.test.ts

@@ -1477,3 +1477,125 @@ describe("Subscription detection", () => {
 		});
 	});
 });
+
+// =============================================================================
+// Unified Entity Definition (ADR-001) - Auto Resolver Conversion
+// =============================================================================
+
+describe("Unified Entity Definition", () => {
+	describe("auto-converts entities with inline resolvers", () => {
+		it("creates resolver from entity with inline .resolve()", async () => {
+			// Entity with inline resolver - no separate resolver() needed
+			const Product = entity("Product", (t) => ({
+				id: t.id(),
+				name: t.string(),
+				price: t.float(),
+				// Computed field with inline resolver
+				displayPrice: t.string().resolve(({ parent }) => `$${(parent as { price: number }).price.toFixed(2)}`),
+			}));
+
+			const getProduct = query()
+				.input(z.object({ id: z.string() }))
+				.returns(Product)
+				.resolve(({ input }) => ({
+					id: input.id,
+					name: "Test Product",
+					price: 19.99,
+				}));
+
+			// No resolvers array needed! Server auto-detects inline resolvers
+			const server = createApp({
+				entities: { Product },
+				queries: { getProduct },
+			});
+
+			const result = await firstValueFrom(
+				server.execute({
+					path: "getProduct",
+					input: { id: "prod-1", $select: { id: true, name: true, displayPrice: true } },
+				}),
+			);
+
+			expect(result.data).toEqual({
+				id: "prod-1",
+				name: "Test Product",
+				displayPrice: "$19.99",
+			});
+		});
+
+		it("explicit resolver takes priority over inline resolver", async () => {
+			// Entity with inline resolver
+			const Item = entity("Item", (t) => ({
+				id: t.id(),
+				label: t.string().resolve(() => "inline-label"),
+			}));
+
+			// Explicit resolver overrides inline
+			const itemResolver = resolver(Item, (f) => ({
+				id: f.expose("id"),
+				label: f.string().resolve(() => "explicit-label"),
+			}));
+
+			const getItem = query()
+				.input(z.object({ id: z.string() }))
+				.returns(Item)
+				.resolve(({ input }) => ({ id: input.id }));
+
+			const server = createApp({
+				entities: { Item },
+				queries: { getItem },
+				resolvers: [itemResolver], // Explicit resolver takes priority
+			});
+
+			const result = await firstValueFrom(
+				server.execute({
+					path: "getItem",
+					input: { id: "item-1", $select: { id: true, label: true } },
+				}),
+			);
+
+			expect(result.data).toEqual({
+				id: "item-1",
+				label: "explicit-label", // From explicit resolver, not inline
+			});
+		});
+
+		it("includes inline resolver fields in metadata", () => {
+			const Task = entity("Task", (t) => ({
+				id: t.id(),
+				title: t.string(),
+				status: t.string().subscribe(({ ctx }) => {
+					ctx.emit("pending");
+				}),
+			}));
+
+			const server = createApp({
+				entities: { Task },
+				queries: {},
+			});
+
+			const metadata = server.getMetadata();
+			expect(metadata.entities.Task).toBeDefined();
+			expect(metadata.entities.Task.id).toBe("exposed");
+			expect(metadata.entities.Task.title).toBe("exposed");
+			expect(metadata.entities.Task.status).toBe("subscribe");
+		});
+
+		it("skips entities without inline resolvers", () => {
+			// Plain entity without inline resolvers
+			const SimpleUser = entity("SimpleUser", {
+				id: t.id(),
+				name: t.string(),
+			});
+
+			const server = createApp({
+				entities: { SimpleUser },
+				queries: {},
+			});
+
+			const metadata = server.getMetadata();
+			// No resolver created for entities without inline resolvers
+			expect(metadata.entities.SimpleUser).toBeUndefined();
+		});
+	});
+});

package/src/server/create.ts

@@ -18,10 +18,12 @@
 import {
 	type ContextValue,
 	createEmit,
+	createResolverFromEntity,
 	type EmitCommand,
 	type EntityDef,
 	flattenRouter,
 	hashValue,
+	hasInlineResolvers,
 	type InferRouterContext,
 	isEntityDef,
 	isMutationDef,
@@ -29,7 +31,6 @@ import {
 	type Observable,
 	type ResolverDef,
 	type RouterDef,
-	toResolverMap,
 	valuesEqual,
 } from "@sylphx/lens-core";
 import { createContext, runWithContext, tryUseContext } from "../context/index.js";
@@ -189,7 +190,6 @@ class LensServerImpl<
 
 		this.queries = queries as Q;
 		this.mutations = mutations as M;
-		this.resolverMap = config.resolvers ? toResolverMap(config.resolvers) : undefined;
 
 		// Build entities map: explicit config + auto-extracted from resolvers
 		const entities: EntitiesMap = { ...(config.entities ?? {}) };
@@ -202,6 +202,11 @@ class LensServerImpl<
 			}
 		}
 		this.entities = entities;
+
+		// Build resolver map: explicit resolvers + auto-converted from entities with inline resolvers
+		// Unified Entity Definition (ADR-001): entities can have inline .resolve()/.subscribe() methods
+		// These are automatically converted to resolvers, no need to call createResolverFromEntity() manually
+		this.resolverMap = this.buildResolverMap(config.resolvers, entities);
 		this.contextFactory = config.context ?? (() => ({}) as TContext);
 		this.version = config.version ?? "1.0.0";
 		this.logger = config.logger ?? noopLogger;
@@ -248,6 +253,45 @@ class LensServerImpl<
 		}
 	}
 
+	/**
+	 * Build resolver map from explicit resolvers and entities with inline resolvers.
+	 *
+	 * Unified Entity Definition (ADR-001): Entities can have inline .resolve()/.subscribe() methods.
+	 * These are automatically converted to resolvers - no manual createResolverFromEntity() needed.
+	 *
+	 * Priority: explicit resolvers > auto-converted from entities
+	 */
+	private buildResolverMap(
+		explicitResolvers: import("@sylphx/lens-core").Resolvers | undefined,
+		entities: EntitiesMap,
+	): ResolverMap | undefined {
+		const resolverMap: ResolverMap = new Map();
+
+		// 1. Add explicit resolvers first (takes priority)
+		if (explicitResolvers) {
+			for (const resolver of explicitResolvers) {
+				const entityName = resolver.entity._name;
+				if (entityName) {
+					resolverMap.set(entityName, resolver);
+				}
+			}
+		}
+
+		// 2. Auto-convert entities with inline resolvers (if not already in map)
+		for (const [name, entity] of Object.entries(entities)) {
+			if (!isEntityDef(entity)) continue;
+			if (resolverMap.has(name)) continue; // Explicit resolver takes priority
+
+			// Check if entity has inline resolvers
+			if (hasInlineResolvers(entity)) {
+				const resolver = createResolverFromEntity(entity);
+				resolverMap.set(name, resolver);
+			}
+		}
+
+		return resolverMap.size > 0 ? resolverMap : undefined;
+	}
+
 	// =========================================================================
 	// Subscription Detection (Deprecated - Use client-side with entities metadata)
 	// =========================================================================