@sylphx/lens-server 2.12.0 → 2.13.0

package/dist/index.js

@@ -35,6 +35,7 @@ function extendContext(current, extension) {
 }
 // src/server/create.ts
 import {
+  applyUpdate,
   collectModelsFromOperations,
   collectModelsFromRouter,
   createEmit,
@@ -696,19 +697,26 @@ class LensServerImpl {
           return { ...state, ...command.data };
         }
         return command.data;
-      case "field":
+      case "field": {
+        if (command.field === "") {
+          return applyUpdate(state, command.update);
+        }
         if (state && typeof state === "object") {
+          const currentValue = state[command.field];
+          const newValue = applyUpdate(currentValue, command.update);
           return {
             ...state,
-            [command.field]: command.update.data
+            [command.field]: newValue
           };
         }
-        return { [command.field]: command.update.data };
+        return { [command.field]: applyUpdate(undefined, command.update) };
+      }
       case "batch":
         if (state && typeof state === "object") {
           const result = { ...state };
           for (const update of command.updates) {
-            result[update.field] = update.update.data;
+            const currentValue = result[update.field];
+            result[update.field] = applyUpdate(currentValue, update.update);
           }
           return result;
         }
@@ -739,18 +747,26 @@ class LensServerImpl {
     }
   }
   createFieldEmitFactory(getCurrentState, setCurrentState, notifyObserver, select, context, onCleanup) {
-    return (fieldPath) => {
+    return (fieldPath, resolvedValue) => {
       if (!fieldPath)
         return;
       const state = getCurrentState();
-      const currentFieldValue = state ? this.getFieldByPath(state, fieldPath) : undefined;
-      const isArray = Array.isArray(currentFieldValue);
+      const currentFieldValue = resolvedValue !== undefined ? resolvedValue : state ? this.getFieldByPath(state, fieldPath) : undefined;
+      let outputType = "object";
+      if (Array.isArray(currentFieldValue)) {
+        outputType = "array";
+      } else if (currentFieldValue === null || typeof currentFieldValue === "string" || typeof currentFieldValue === "number" || typeof currentFieldValue === "boolean") {
+        outputType = "scalar";
+      }
+      let localFieldValue = resolvedValue;
       const emitHandler = (command) => {
         const fullState = getCurrentState();
         if (!fullState || typeof fullState !== "object")
           return;
-        const fieldValue = this.getFieldByPath(fullState, fieldPath);
+        const stateFieldValue = this.getFieldByPath(fullState, fieldPath);
+        const fieldValue = stateFieldValue !== undefined ? stateFieldValue : localFieldValue;
         const newFieldValue = this.applyEmitCommand(command, fieldValue);
+        localFieldValue = newFieldValue;
         const updatedState = this.setFieldByPath(fullState, fieldPath, newFieldValue);
         setCurrentState(updatedState);
         (async () => {
@@ -764,7 +780,7 @@ class LensServerImpl {
           }
         })();
       };
-      return createEmit(emitHandler, isArray);
+      return createEmit(emitHandler, outputType);
     };
   }
   getFieldByPath(obj, path) {
@@ -845,7 +861,7 @@ class LensServerImpl {
           const publisher = resolverDef.subscribeField(field, obj, args, context ?? {});
           if (publisher && createFieldEmit && onCleanup) {
             try {
-              const fieldEmit = createFieldEmit(currentPath);
+              const fieldEmit = createFieldEmit(currentPath, result[field]);
               if (fieldEmit) {
                 publisher({
                   emit: fieldEmit,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "2.12.0",
+	"version": "2.13.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": "^2.10.0"
+		"@sylphx/lens-core": "^2.11.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.9.3",

package/src/server/create.test.ts

@@ -2101,3 +2101,135 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 		sub2.unsubscribe();
 	});
 });
+
+// =============================================================================
+// Scalar Field Subscription Tests (EmitScalar)
+// =============================================================================
+
+describe("scalar field subscription with emit.delta()", () => {
+	it("provides emit.delta() for string field subscriptions", async () => {
+		// UserWithBio - bio field is not provided by query, resolved by field resolver
+		const UserWithBio = entity("UserWithBio", {
+			id: t.id(),
+			name: t.string(),
+		});
+
+		let capturedEmit: {
+			(value: unknown): void;
+			delta?: (operations: { position: number; insert: string }[]) => void;
+		} | null = null;
+
+		const userResolver = resolver(UserWithBio, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			// bio is a computed field with resolve + subscribe
+			bio: f
+				.string()
+				.resolve(() => "Initial bio")
+				.subscribe((_params) => ({ emit, onCleanup }) => {
+					capturedEmit = emit as typeof capturedEmit;
+					onCleanup(() => {});
+				}),
+		}));
+
+		const server = createApp({
+			entities: { UserWithBio },
+			queries: {
+				getUserWithBio: query()
+					.input(z.object({ id: z.string() }))
+					.returns(UserWithBio)
+					.resolve(({ input }) => ({ id: input.id, name: "Alice" })),
+			},
+			resolvers: [userResolver],
+		});
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "getUserWithBio",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (result) => results.push(result),
+			});
+
+		// Wait for subscription setup
+		await new Promise((r) => setTimeout(r, 50));
+
+		// Initial result
+		expect(results.length).toBe(1);
+		expect((results[0] as { data: { bio: string } }).data.bio).toBe("Initial bio");
+
+		// Check that emit has delta method (EmitScalar)
+		expect(capturedEmit).toBeDefined();
+		expect(typeof capturedEmit?.delta).toBe("function");
+
+		subscription.unsubscribe();
+	});
+
+	it("emit.delta() appends text to string field", async () => {
+		// UserWithContent - content field resolved by field resolver
+		const UserWithContent = entity("UserWithContent", {
+			id: t.id(),
+			name: t.string(),
+		});
+
+		let capturedEmit: {
+			(value: unknown): void;
+			delta?: (operations: { position: number; insert: string }[]) => void;
+		} | null = null;
+
+		const userResolver = resolver(UserWithContent, (f) => ({
+			id: f.expose("id"),
+			name: f.expose("name"),
+			// content is a computed field with resolve + subscribe
+			content: f
+				.string()
+				.resolve(() => "Hello")
+				.subscribe((_params) => ({ emit, onCleanup }) => {
+					capturedEmit = emit as typeof capturedEmit;
+					onCleanup(() => {});
+				}),
+		}));
+
+		const server = createApp({
+			entities: { UserWithContent },
+			queries: {
+				getUserWithContent: query()
+					.input(z.object({ id: z.string() }))
+					.returns(UserWithContent)
+					.resolve(({ input }) => ({ id: input.id, name: "Alice" })),
+			},
+			resolvers: [userResolver],
+		});
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "getUserWithContent",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (result) => results.push(result),
+			});
+
+		// Wait for subscription setup
+		await new Promise((r) => setTimeout(r, 50));
+
+		// Initial result
+		expect(results.length).toBe(1);
+		expect((results[0] as { data: { content: string } }).data.content).toBe("Hello");
+
+		// Use emit.delta() to append text
+		capturedEmit?.delta?.([{ position: Infinity, insert: " World" }]);
+
+		// Wait for update
+		await new Promise((r) => setTimeout(r, 50));
+
+		// Should have received update with delta applied
+		expect(results.length).toBe(2);
+		expect((results[1] as { data: { content: string } }).data.content).toBe("Hello World");
+
+		subscription.unsubscribe();
+	});
+});

package/src/server/create.ts

@@ -16,6 +16,7 @@
  */
 
 import {
+	applyUpdate,
 	type ContextValue,
 	collectModelsFromOperations,
 	collectModelsFromRouter,
@@ -763,20 +764,29 @@ class LensServerImpl<
 				}
 				return command.data;
 
-			case "field":
+			case "field": {
+				// Empty field = scalar root value (e.g., emit.delta on a string field)
+				if (command.field === "") {
+					return applyUpdate(state, command.update);
+				}
+				// Named field - apply update to that field
 				if (state && typeof state === "object") {
+					const currentValue = (state as Record<string, unknown>)[command.field];
+					const newValue = applyUpdate(currentValue, command.update);
 					return {
 						...(state as Record<string, unknown>),
-						[command.field]: command.update.data,
+						[command.field]: newValue,
 					};
 				}
-				return { [command.field]: command.update.data };
+				return { [command.field]: applyUpdate(undefined, command.update) };
+			}
 
 			case "batch":
 				if (state && typeof state === "object") {
 					const result = { ...(state as Record<string, unknown>) };
 					for (const update of command.updates) {
-						result[update.field] = update.update.data;
+						const currentValue = result[update.field];
+						result[update.field] = applyUpdate(currentValue, update.update);
 					}
 					return result;
 				}
@@ -825,24 +835,48 @@ class LensServerImpl<
 		select: SelectionObject | undefined,
 		context: TContext | undefined,
 		onCleanup: ((fn: () => void) => void) | undefined,
-	): (fieldPath: string) => Emit<unknown> | undefined {
-		return (fieldPath: string) => {
+	): (fieldPath: string, resolvedValue?: unknown) => Emit<unknown> | undefined {
+		return (fieldPath: string, resolvedValue?: unknown) => {
 			if (!fieldPath) return undefined;
 
-			// Determine if field value is an array (check current state)
+			// Determine output type from resolved value (if provided) or current field value
 			const state = getCurrentState();
-			const currentFieldValue = state ? this.getFieldByPath(state, fieldPath) : undefined;
-			const isArray = Array.isArray(currentFieldValue);
+			const currentFieldValue =
+				resolvedValue !== undefined
+					? resolvedValue
+					: state
+						? this.getFieldByPath(state, fieldPath)
+						: undefined;
+
+			// Determine emit type: array, scalar, or object
+			let outputType: "array" | "object" | "scalar" = "object";
+			if (Array.isArray(currentFieldValue)) {
+				outputType = "array";
+			} else if (
+				currentFieldValue === null ||
+				typeof currentFieldValue === "string" ||
+				typeof currentFieldValue === "number" ||
+				typeof currentFieldValue === "boolean"
+			) {
+				outputType = "scalar";
+			}
+
+			// Track field value locally (for fields not yet in fullState)
+			let localFieldValue = resolvedValue;
 
 			// Create emit handler that applies commands to the field's value
 			const emitHandler = (command: EmitCommand) => {
 				const fullState = getCurrentState();
 				if (!fullState || typeof fullState !== "object") return;
 
-				// Get current field value and apply command to it
-				const fieldValue = this.getFieldByPath(fullState, fieldPath);
+				// Get current field value from state, or use local value if not in state yet
+				const stateFieldValue = this.getFieldByPath(fullState, fieldPath);
+				const fieldValue = stateFieldValue !== undefined ? stateFieldValue : localFieldValue;
 				const newFieldValue = this.applyEmitCommand(command, fieldValue);
 
+				// Update local tracking
+				localFieldValue = newFieldValue;
+
 				// Update state with new field value
 				const updatedState = this.setFieldByPath(
 					fullState as Record<string, unknown>,
@@ -879,7 +913,7 @@ class LensServerImpl<
 				})();
 			};
 
-			return createEmit<unknown>(emitHandler, isArray);
+			return createEmit<unknown>(emitHandler, outputType);
 		};
 	}
 
@@ -928,7 +962,7 @@ class LensServerImpl<
 		select?: SelectionObject,
 		context?: TContext,
 		onCleanup?: (fn: () => void) => void,
-		createFieldEmit?: (fieldPath: string) => Emit<unknown> | undefined,
+		createFieldEmit?: (fieldPath: string, resolvedValue?: unknown) => Emit<unknown> | undefined,
 	): Promise<T> {
 		if (!data) return data;
 
@@ -966,7 +1000,7 @@ class LensServerImpl<
 		context?: TContext,
 		fieldPath = "",
 		onCleanup?: (fn: () => void) => void,
-		createFieldEmit?: (fieldPath: string) => Emit<unknown> | undefined,
+		createFieldEmit?: (fieldPath: string, resolvedValue?: unknown) => Emit<unknown> | undefined,
 	): Promise<T> {
 		if (!data || !this.resolverMap) return data;
 
@@ -1053,7 +1087,8 @@ class LensServerImpl<
 					const publisher = resolverDef.subscribeField(field, obj, args, context ?? {});
 					if (publisher && createFieldEmit && onCleanup) {
 						try {
-							const fieldEmit = createFieldEmit(currentPath);
+							// Pass resolved value to determine correct emit type (array/object/scalar)
+							const fieldEmit = createFieldEmit(currentPath, result[field]);
 							if (fieldEmit) {
 								publisher({
 									emit: fieldEmit,