@sylphx/lens-server 1.3.2 → 1.5.0

package/README.md

@@ -0,0 +1,35 @@
+# @sylphx/lens-server
+
+Server runtime for the Lens API framework with WebSocket support.
+
+## Installation
+
+```bash
+bun add @sylphx/lens-server
+```
+
+## Usage
+
+```typescript
+import { createServer } from "@sylphx/lens-server";
+import { appRouter } from "./router";
+
+const server = createServer({ router: appRouter });
+
+// Handle WebSocket connections
+Bun.serve({
+  port: 3000,
+  fetch: server.fetch,
+  websocket: server.websocket,
+});
+```
+
+## License
+
+MIT
+
+---
+
+Built with [@sylphx/lens-core](https://github.com/SylphxAI/Lens).
+
+✨ Powered by Sylphx

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { query, mutation, router, QueryBuilder, MutationBuilder, QueryDef as QueryDef2, MutationDef as MutationDef2, RouterDef as RouterDef2, RouterRoutes, ResolverFn, ResolverContext, InferRouterContext as InferRouterContext2 } from "@sylphx/lens-core";
-import { ContextValue, EntityDef, EntityDefinition, EntityResolvers, EntityResolversDefinition, InferRouterContext, MutationDef, QueryDef, RelationDef, RelationTypeWithForeignKey, RouterDef } from "@sylphx/lens-core";
+import { InferRouterContext as InferRouterContext2, MutationDef as MutationDef2, mutation, QueryDef as QueryDef2, query, ResolverContext, ResolverFn, RouterDef as RouterDef2, RouterRoutes, router } from "@sylphx/lens-core";
+import { ContextValue, EntityDef, InferRouterContext, MutationDef, QueryDef, Resolvers, RouterDef } from "@sylphx/lens-core";
 import { ArrayOperation, EmitCommand, EntityKey, InternalFieldUpdate, Update } from "@sylphx/lens-core";
 /** Client connection interface */
 interface StateClient {
@@ -217,17 +217,21 @@ type EntitiesMap = Record<string, EntityDef<string, any>>;
 type QueriesMap = Record<string, QueryDef<unknown, unknown>>;
 /** Mutations map type */
 type MutationsMap = Record<string, MutationDef<unknown, unknown>>;
-/** Relations array type */
-type RelationsArray = RelationDef<EntityDef<string, EntityDefinition>, Record<string, RelationTypeWithForeignKey>>[];
 /** Operation metadata for handshake */
 interface OperationMeta {
-	type: "query" | "mutation";
+	type: "query" | "mutation" | "subscription";
 	optimistic?: unknown;
 }
 /** Nested operations structure for handshake */
 type OperationsMap = {
 	[key: string]: OperationMeta | OperationsMap;
 };
+/** Logger interface for server */
+interface LensLogger {
+	info?: (message: string, ...args: unknown[]) => void;
+	warn?: (message: string, ...args: unknown[]) => void;
+	error?: (message: string, ...args: unknown[]) => void;
+}
 /** Server configuration */
 interface LensServerConfig<
 	TContext extends ContextValue = ContextValue,
@@ -235,16 +239,16 @@ interface LensServerConfig<
 > {
 	/** Entity definitions */
 	entities?: EntitiesMap;
-	/** Relation definitions */
-	relations?: RelationsArray;
 	/** Router definition (namespaced operations) - context type is inferred */
 	router?: TRouter;
 	/** Query definitions (flat, legacy) */
 	queries?: QueriesMap;
 	/** Mutation definitions (flat, legacy) */
 	mutations?: MutationsMap;
-	/** Entity resolvers */
-	resolvers?: EntityResolvers<EntityResolversDefinition>;
+	/** Field resolvers array (use lens() factory to create) */
+	resolvers?: Resolvers;
+	/** Logger for server messages (default: silent) */
+	logger?: LensLogger;
 	/** Context factory - must return the context type expected by the router */
 	context?: (req?: unknown) => TContext | Promise<TContext>;
 	/** Server version */
@@ -308,96 +312,6 @@ interface WebSocketLike {
 	onclose?: (() => void) | null;
 	onerror?: ((error: unknown) => void) | null;
 }
-declare class LensServerImpl<
-	Q extends QueriesMap = QueriesMap,
-	M extends MutationsMap = MutationsMap,
-	TContext extends ContextValue = ContextValue
-> implements LensServer {
-	private queries;
-	private mutations;
-	private entities;
-	private resolvers?;
-	private contextFactory;
-	private version;
-	private ctx;
-	/** GraphStateManager for per-client state tracking */
-	private stateManager;
-	/** DataLoaders for N+1 batching (per-request) */
-	private loaders;
-	/** Client connections */
-	private connections;
-	private connectionCounter;
-	/** Server instance */
-	private server;
-	constructor(config: LensServerConfig<TContext> & {
-		queries?: Q;
-		mutations?: M;
-	});
-	getStateManager(): GraphStateManager;
-	/**
-	* Get server metadata for transport handshake.
-	* Used by inProcess transport for direct access.
-	*/
-	getMetadata(): ServerMetadata;
-	/**
-	* Execute operation - auto-detects query vs mutation from registered operations.
-	* Used by inProcess transport for direct server calls.
-	*/
-	execute(op: LensOperation): Promise<LensResult>;
-	/**
-	* Build nested operations map for handshake response
-	* Converts flat "user.get", "user.create" into nested { user: { get: {...}, create: {...} } }
-	*/
-	private buildOperationsMap;
-	handleWebSocket(ws: WebSocketLike): void;
-	private handleMessage;
-	private handleHandshake;
-	private handleSubscribe;
-	private executeSubscription;
-	private handleUpdateFields;
-	private handleUnsubscribe;
-	private handleQuery;
-	private handleMutation;
-	private handleDisconnect;
-	executeQuery<
-		TInput,
-		TOutput
-	>(name: string, input?: TInput): Promise<TOutput>;
-	executeMutation<
-		TInput,
-		TOutput
-	>(name: string, input: TInput): Promise<TOutput>;
-	handleRequest(req: Request): Promise<Response>;
-	listen(port: number): Promise<void>;
-	close(): Promise<void>;
-	private findConnectionByWs;
-	private getEntityNameFromOutput;
-	private getEntityNameFromMutation;
-	private extractEntities;
-	private applySelection;
-	private applySelectionToObject;
-	/**
-	* Execute entity resolvers for nested data.
-	* Processes the selection object and resolves relation fields.
-	*/
-	private executeEntityResolvers;
-	/**
-	* Get target entity name for a relation field.
-	*/
-	private getRelationTargetEntity;
-	/**
-	* Serialize entity data for transport.
-	* Auto-calls serialize() on field types (Date → ISO string, etc.)
-	*/
-	private serializeEntity;
-	/**
-	* Process query result: execute entity resolvers, apply selection, serialize
-	*/
-	private processQueryResult;
-	private computeUpdates;
-	private deepEqual;
-	private clearLoaders;
-}
 /**
 * Infer input type from a query/mutation definition
 */
@@ -421,10 +335,9 @@ type InferOutput<T> = T extends QueryDef<unknown, infer O> ? O : T extends Mutat
 * const client = createClient<Api>({ links: [...] });
 * ```
 */
-type InferApi<T extends LensServer> = T extends LensServerImpl<infer Q, infer M> ? {
-	queries: Q;
-	mutations: M;
-} : never;
+type InferApi<T> = T extends {
+	_types: infer Types;
+} ? Types : never;
 /**
 * Config helper type that infers context from router
 */
@@ -434,11 +347,11 @@ type ServerConfigWithInferredContext<
 	M extends MutationsMap = MutationsMap
 > = {
 	entities?: EntitiesMap;
-	relations?: RelationsArray;
 	router: TRouter;
 	queries?: Q;
 	mutations?: M;
-	resolvers?: EntityResolvers<EntityResolversDefinition>;
+	/** Field resolvers array */
+	resolvers?: Resolvers;
 	/** Context factory - type is inferred from router's procedures */
 	context?: (req?: unknown) => InferRouterContext<TRouter> | Promise<InferRouterContext<TRouter>>;
 	version?: string;
@@ -452,11 +365,11 @@ type ServerConfigLegacy<
 	M extends MutationsMap = MutationsMap
 > = {
 	entities?: EntitiesMap;
-	relations?: RelationsArray;
 	router?: undefined;
 	queries?: Q;
 	mutations?: M;
-	resolvers?: EntityResolvers<EntityResolversDefinition>;
+	/** Field resolvers array */
+	resolvers?: Resolvers;
 	context?: (req?: unknown) => TContext | Promise<TContext>;
 	version?: string;
 };
@@ -484,6 +397,7 @@ declare function createServer<
 	M extends MutationsMap = MutationsMap
 >(config: ServerConfigWithInferredContext<TRouter, Q, M>): LensServer & {
 	_types: {
+		router: TRouter;
 		queries: Q;
 		mutations: M;
 		context: InferRouterContext<TRouter>;
@@ -544,7 +458,7 @@ declare class SSEHandler {
 	* Handle new SSE connection
 	* Returns a Response with SSE stream
 	*/
-	handleConnection(req?: Request): Response;
+	handleConnection(_req?: Request): Response;
 	/**
 	* Remove client and cleanup
 	*/
@@ -570,4 +484,4 @@ declare class SSEHandler {
 * Create SSE handler (transport adapter)
 */
 declare function createSSEHandler(config: SSEHandlerConfig): SSEHandler;
-export { router, query, mutation, createServer, createSSEHandler, createGraphStateManager, WebSocketLike, Subscription, StateUpdateMessage, StateFullMessage, StateClient, ServerMetadata, LensServerConfig as ServerConfig, SelectionObject, SSEHandlerConfig, SSEHandler, SSEClientInfo, RouterRoutes, RouterDef2 as RouterDef, ResolverFn, ResolverContext, RelationsArray, QueryDef2 as QueryDef, QueryBuilder, QueriesMap, OperationsMap, OperationMeta, MutationsMap, MutationDef2 as MutationDef, MutationBuilder, LensServer, LensResult, LensOperation, InferRouterContext2 as InferRouterContext, InferOutput, InferInput, InferApi, GraphStateManagerConfig, GraphStateManager, EntityKey, EntitiesMap };
+export { router, query, mutation, createServer, createSSEHandler, createGraphStateManager, WebSocketLike, Subscription, StateUpdateMessage, StateFullMessage, StateClient, ServerMetadata, LensServerConfig as ServerConfig, SelectionObject, SSEHandlerConfig, SSEHandler, SSEClientInfo, RouterRoutes, RouterDef2 as RouterDef, ResolverFn, ResolverContext, QueryDef2 as QueryDef, QueriesMap, OperationsMap, OperationMeta, MutationsMap, MutationDef2 as MutationDef, LensServer, LensResult, LensOperation, InferRouterContext2 as InferRouterContext, InferOutput, InferInput, InferApi, GraphStateManagerConfig, GraphStateManager, EntityKey, EntitiesMap };

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
 import {
-  query,
   mutation,
+  query,
   router
 } from "@sylphx/lens-core";
 
@@ -11,15 +11,16 @@ import {
   createEmit,
   createUpdate as createUpdate2,
   flattenRouter,
-  isBatchResolver,
   isMutationDef,
   isQueryDef,
-  runWithContext
+  runWithContext,
+  toResolverMap
 } from "@sylphx/lens-core";
 
 // src/state/graph-state-manager.ts
 import {
   applyUpdate,
+  computeArrayDiff,
   createUpdate,
   makeEntityKey
 } from "@sylphx/lens-core";
@@ -241,14 +242,35 @@ class GraphStateManager {
     if (JSON.stringify(lastState) === JSON.stringify(newArray)) {
       return;
     }
-    client.send({
-      type: "update",
-      entity,
-      id,
-      updates: {
-        _items: { strategy: "value", data: newArray }
-      }
-    });
+    const diff = computeArrayDiff(lastState, newArray);
+    if (diff === null || diff.length === 0) {
+      client.send({
+        type: "update",
+        entity,
+        id,
+        updates: {
+          _items: { strategy: "value", data: newArray }
+        }
+      });
+    } else if (diff.length === 1 && diff[0].op === "replace") {
+      client.send({
+        type: "update",
+        entity,
+        id,
+        updates: {
+          _items: { strategy: "value", data: newArray }
+        }
+      });
+    } else {
+      client.send({
+        type: "update",
+        entity,
+        id,
+        updates: {
+          _items: { strategy: "array", data: diff }
+        }
+      });
+    }
     clientArrayState.lastState = [...newArray];
   }
   getArrayState(entity, id) {
@@ -471,11 +493,13 @@ class DataLoader {
       keys.forEach((key, index) => {
         const callbacks = batch.get(key);
         const result = results[index] ?? null;
-        callbacks.forEach(({ resolve }) => resolve(result));
+        for (const { resolve } of callbacks)
+          resolve(result);
       });
     } catch (error) {
       for (const callbacks of batch.values()) {
-        callbacks.forEach(({ reject }) => reject(error));
+        for (const { reject } of callbacks)
+          reject(error);
       }
     }
   }
@@ -483,14 +507,16 @@ class DataLoader {
     this.batch.clear();
   }
 }
+var noopLogger = {};
 
 class LensServerImpl {
   queries;
   mutations;
   entities;
-  resolvers;
+  resolverMap;
   contextFactory;
   version;
+  logger;
   ctx = createContext();
   stateManager;
   loaders = new Map;
@@ -513,9 +539,10 @@ class LensServerImpl {
     this.queries = queries;
     this.mutations = mutations;
     this.entities = config.entities ?? {};
-    this.resolvers = config.resolvers;
+    this.resolverMap = config.resolvers ? toResolverMap(config.resolvers) : undefined;
     this.contextFactory = config.context ?? (() => ({}));
     this.version = config.version ?? "1.0.0";
+    this.logger = config.logger ?? noopLogger;
     for (const [name, def] of Object.entries(this.entities)) {
       if (def && typeof def === "object" && !def._name) {
         def._name = name;
@@ -594,7 +621,7 @@ class LensServerImpl {
       }
       current[parts[parts.length - 1]] = meta;
     };
-    for (const [name, def] of Object.entries(this.queries)) {
+    for (const [name, _def] of Object.entries(this.queries)) {
       setNested(name, { type: "query" });
     }
     for (const [name, def] of Object.entries(this.mutations)) {
@@ -820,7 +847,7 @@ class LensServerImpl {
       try {
         cleanup();
       } catch (e) {
-        console.error("Cleanup error:", e);
+        this.logger.error?.("Cleanup error:", e);
       }
     }
     for (const entityKey of sub.entityKeys) {
@@ -877,7 +904,7 @@ class LensServerImpl {
         try {
           cleanup();
         } catch (e) {
-          console.error("Cleanup error:", e);
+          this.logger.error?.("Cleanup error:", e);
         }
       }
     }
@@ -1031,7 +1058,7 @@ class LensServerImpl {
         }
       }
     });
-    console.log(`Lens server listening on port ${port}`);
+    this.logger.info?.(`Lens server listening on port ${port}`);
   }
   async close() {
     if (this.server && typeof this.server.stop === "function") {
@@ -1144,27 +1171,20 @@ class LensServerImpl {
     return result;
   }
   async executeEntityResolvers(entityName, data, select) {
-    if (!data || !select || !this.resolvers)
+    if (!data || !select || !this.resolverMap)
+      return data;
+    const resolverDef = this.resolverMap.get(entityName);
+    if (!resolverDef)
       return data;
     const result = { ...data };
+    const context = await this.contextFactory();
     for (const [fieldName, fieldSelect] of Object.entries(select)) {
       if (fieldSelect === false || fieldSelect === true)
         continue;
-      const resolver = this.resolvers.getResolver(entityName, fieldName);
-      if (!resolver)
+      if (!resolverDef.hasField(fieldName))
         continue;
-      if (isBatchResolver(resolver)) {
-        const loaderKey = `${entityName}.${fieldName}`;
-        if (!this.loaders.has(loaderKey)) {
-          this.loaders.set(loaderKey, new DataLoader(async (parents) => {
-            return resolver.batch(parents);
-          }));
-        }
-        const loader = this.loaders.get(loaderKey);
-        result[fieldName] = await loader.load(data);
-      } else {
-        result[fieldName] = await resolver(data);
-      }
+      const fieldArgs = typeof fieldSelect === "object" && fieldSelect !== null && "args" in fieldSelect ? fieldSelect.args ?? {} : {};
+      result[fieldName] = await resolverDef.resolveField(fieldName, data, fieldArgs, context);
       const nestedSelect = fieldSelect.select;
       if (nestedSelect && result[fieldName]) {
         const relationData = result[fieldName];
@@ -1228,7 +1248,7 @@ class LensServerImpl {
         try {
           result[fieldName] = fieldType.serialize(value);
         } catch (error) {
-          console.warn(`Failed to serialize field ${entityName}.${fieldName}:`, error);
+          this.logger.warn?.(`Failed to serialize field ${entityName}.${fieldName}:`, error);
           result[fieldName] = value;
         }
       } else {
@@ -1245,7 +1265,7 @@ class LensServerImpl {
     if (Array.isArray(data)) {
       const processedItems = await Promise.all(data.map(async (item) => {
         let result2 = item;
-        if (select && this.resolvers) {
+        if (select && this.resolverMap) {
           result2 = await this.executeEntityResolvers(entityName, item, select);
         }
         if (select) {
@@ -1259,7 +1279,7 @@ class LensServerImpl {
       return processedItems;
     }
     let result = data;
-    if (select && this.resolvers) {
+    if (select && this.resolverMap) {
       result = await this.executeEntityResolvers(entityName, data, select);
     }
     if (select) {
@@ -1330,7 +1350,7 @@ class SSEHandler {
     this.stateManager = config.stateManager;
     this.heartbeatInterval = config.heartbeatInterval ?? 30000;
   }
-  handleConnection(req) {
+  handleConnection(_req) {
     const clientId = `sse_${++this.clientCounter}_${Date.now()}`;
     const encoder = new TextEncoder;
     const stream = new ReadableStream({

package/package.json

@@ -1,38 +1,39 @@
 {
-  "name": "@sylphx/lens-server",
-  "version": "1.3.2",
-  "description": "Server runtime for Lens API framework",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "scripts": {
-    "build": "bunup",
-    "typecheck": "tsc --noEmit",
-    "test": "bun test"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "keywords": [
-    "lens",
-    "server",
-    "resolvers",
-    "graphql"
-  ],
-  "author": "SylphxAI",
-  "license": "MIT",
-  "dependencies": {
-    "@sylphx/lens-core": "^1.3.2"
-  },
-  "devDependencies": {
-    "typescript": "^5.9.3",
-    "zod": "^4.1.13"
-  }
+	"name": "@sylphx/lens-server",
+	"version": "1.5.0",
+	"description": "Server runtime for Lens API framework",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"scripts": {
+		"build": "bunup",
+		"typecheck": "tsc --noEmit",
+		"test": "bun test",
+		"prepack": "bun run build"
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"keywords": [
+		"lens",
+		"server",
+		"resolvers",
+		"graphql"
+	],
+	"author": "SylphxAI",
+	"license": "MIT",
+	"dependencies": {
+		"@sylphx/lens-core": "^1.9.0"
+	},
+	"devDependencies": {
+		"typescript": "^5.9.3",
+		"zod": "^4.1.13"
+	}
 }