@nkzw/fate 0.0.7 → 0.1.0

package/lib/index.mjs

@@ -418,6 +418,12 @@ function isNodeItem(item) {
 function isNodesItem(item) {
 	return "ids" in item;
 }
+/** Indicates whether a request item represents a root query. */
+function isQueryItem(item) {
+	return "view" in item && !("id" in item) && !("ids" in item);
+}
+/** Brand used on root definitions to mark their identity in the d.ts output. */
+const RootKind = "__fate__root";
 /** Brand used on mutation definitions to mark their identity in the d.ts output. */
 const MutationKind = "__fate__mutation";
 
@@ -663,7 +669,7 @@ const emptySet$1 = /* @__PURE__ */ new Set();
 */
 function wrapMutation(client, identifier) {
 	const config = client.getTypeConfig(identifier.entity);
-	return async ({ args, delete: deleteRecord, input, optimistic, view: view$1 }) => {
+	return async ({ args, delete: deleteRecord, input, insert = "after", optimistic, view: view$1 }) => {
 		const id$1 = maybeGetId(config.getId, input);
 		const plan = view$1 ? getSelectionPlan(view$1, null) : void 0;
 		const viewSelection = plan?.paths;
@@ -678,7 +684,7 @@ function wrapMutation(client, identifier) {
 		const optimisticSelection = optimisticRecord ? collectImplicitSelectedPaths(optimisticRecord) : void 0;
 		const selection = viewSelection || optimisticSelection ? new Set([...viewSelection ? [...viewSelection] : [], ...optimisticSelection ? [...optimisticSelection] : []]) : /* @__PURE__ */ new Set();
 		const optimisticToken = optimisticEntityId ? client.registerOptimisticUpdate(optimisticEntityId, optimisticSelection ?? emptySet$1) : null;
-		if (optimisticRecord && optimisticEntityId) client.write(identifier.entity, optimisticRecord, optimisticSelection ?? emptySet$1, snapshots, plan);
+		if (optimisticRecord && optimisticEntityId) client.write(identifier.entity, optimisticRecord, optimisticSelection ?? emptySet$1, snapshots, plan, null, null, insert);
 		if (deleteRecord) {
 			if (id$1 == null) throw new Error(`fate: Mutation '${identifier.key}' requires an 'id' to delete.`);
 			client.deleteRecord(identifier.entity, id$1, snapshots, listSnapshots);
@@ -692,7 +698,7 @@ function wrapMutation(client, identifier) {
 				const select = collectImplicitSelectedPaths(result);
 				const pendingMask = optimisticEntityId ? client.getPendingOptimisticMask(optimisticEntityId, { excludeToken: optimisticToken }) : null;
 				const filteredSelection = optimisticEntityId ? client.filterSelectionForPendingOptimistics(optimisticEntityId, select, { excludeToken: optimisticToken }) : select;
-				client.write(identifier.entity, result, filteredSelection, void 0, plan, null, pendingMask);
+				client.write(identifier.entity, result, filteredSelection, void 0, plan, null, pendingMask, insert);
 				if (deleteRecord && id$1 != null) client.deleteRecord(identifier.entity, id$1);
 				const resultId = maybeGetId(config.getId, result);
 				if (optimisticRecordId != null && resultId != null && optimisticRecordId !== resultId) client.deleteRecord(identifier.entity, optimisticRecordId);
@@ -1001,16 +1007,19 @@ const getRequestCacheKey = (request) => {
 	for (const name of names) {
 		const item = request[name];
 		if (!item) continue;
-		const viewSignature = getViewSignature(item.root);
 		if (isNodeItem(item)) {
-			parts.push(`node:${name}:${item.type}:${viewSignature}:${item.id}`);
+			parts.push(`node:${name}:${getViewSignature(item.view)}:${item.id}`);
 			continue;
 		}
 		if (isNodesItem(item)) {
-			parts.push(`node:${name}:${item.type}:${viewSignature}:${item.ids.map(serializeId).join(",")}`);
+			parts.push(`node:${name}:${getViewSignature(item.view)}:${item.ids.map(serializeId).join(",")}`);
+			continue;
+		}
+		if (isQueryItem(item)) {
+			parts.push(`query:${name}:${getViewSignature(item.view)}:${item.args ? hashArgs(item.args) : ""}`);
 			continue;
 		}
-		parts.push(`list:${name}:${item.type}:${viewSignature}:${item.args ? hashArgs(item.args) : ""}`);
+		parts.push(`list:${name}:${getViewSignature(item.list)}:${item.args ? hashArgs(item.args) : ""}`);
 	}
 	return parts.join("$");
 };
@@ -1038,22 +1047,25 @@ const groupSelectionByPrefix = (select) => {
 var FateClient = class {
 	constructor(options) {
 		this.parentLists = /* @__PURE__ */ new Map();
+		this.rootLists = /* @__PURE__ */ new Map();
 		this.pending = /* @__PURE__ */ new Map();
 		this.optimisticMasks = /* @__PURE__ */ new Map();
 		this.optimisticByEntity = /* @__PURE__ */ new Map();
 		this.optimisticTokenCounter = 0;
 		this.requests = /* @__PURE__ */ new Map();
+		this.rootRequests = /* @__PURE__ */ new Map();
 		this.stalledRequests = /* @__PURE__ */ new Set();
 		this.store = new Store();
 		this.viewDataCache = new ViewDataCache();
+		this.actions = Object.create(null);
+		this.mutationMap = Object.create(null);
+		this.mutations = Object.create(null);
+		this.roots = options.roots;
 		this.transport = options.transport;
 		this.types = new Map(options.types.map((entity) => [entity.type, {
 			getId,
 			...entity
 		}]));
-		this.mutationMap = Object.create(null);
-		this.mutations = Object.create(null);
-		this.actions = Object.create(null);
 		if (options.mutations) for (const [key, definition] of Object.entries(options.mutations)) {
 			const mutation$1 = wrapMutation(this, {
 				...definition,
@@ -1092,6 +1104,30 @@ var FateClient = class {
 			}
 		}
 	}
+	registerRootList(type, key) {
+		let lists = this.rootLists.get(type);
+		if (!lists) {
+			lists = /* @__PURE__ */ new Set();
+			this.rootLists.set(type, lists);
+		}
+		lists.add(key);
+	}
+	insertIntoRootLists(type, entityId, insert) {
+		if (insert === "none") return;
+		const listNames = this.rootLists.get(type);
+		if (!listNames) return;
+		for (const key of listNames) {
+			const listState = this.store.getListState(key);
+			if (!listState || listState.ids.includes(entityId)) continue;
+			const ids = insert === "before" ? [entityId, ...listState.ids] : [...listState.ids, entityId];
+			const cursors = listState.cursors ? insert === "before" ? [void 0, ...listState.cursors] : [...listState.cursors, void 0] : listState.cursors;
+			this.store.setList(key, {
+				cursors,
+				ids,
+				pagination: listState.pagination
+			});
+		}
+	}
 	getTypeConfig(type) {
 		const config = this.types.get(type);
 		if (!config) throw new Error(`fate: Unknown entity type '${type}'.`);
@@ -1108,8 +1144,8 @@ var FateClient = class {
 		} : argsPayload ? { args: argsPayload } : input;
 		return await this.transport.mutate(key, requestInput, select);
 	}
-	write(type, data, select, snapshots, plan, pathPrefix = null, blockedMask) {
-		return this.writeEntity(type, data, select, snapshots, plan, pathPrefix, blockedMask);
+	write(type, data, select, snapshots, plan, pathPrefix = null, blockedMask, insert) {
+		return this.writeEntity(type, data, select, snapshots, plan, pathPrefix, blockedMask, insert);
 	}
 	deleteRecord(type, id$1, snapshots, listSnapshots) {
 		const entityId = toEntityId(type, id$1);
@@ -1278,13 +1314,13 @@ var FateClient = class {
 				...connection.args,
 				...args
 			};
-			const { argsPayload: argsPayload$1, plan: plan$1 } = this.resolveListSelection(view$1, requestArgs$1);
+			const { argsPayload: argsPayload$1, plan: plan$1 } = this.resolveSelection(view$1, requestArgs$1);
 			const { items, pagination } = await this.transport.fetchList(connection.field, plan$1.paths, argsPayload$1);
 			if (!items) return this.store.getListState(connection.key);
 			const incomingIds$1 = [];
 			const incomingCursors$1 = [];
 			for (const entry of items) {
-				const id$1 = this.write(connection.type, entry.node, plan$1.paths, void 0, plan$1);
+				const id$1 = this.write(connection.type, entry.node, plan$1.paths, void 0, plan$1, null, null, "after");
 				incomingIds$1.push(id$1);
 				incomingCursors$1.push(entry.cursor);
 			}
@@ -1296,6 +1332,7 @@ var FateClient = class {
 				direction: isBackward ? "backward" : "forward",
 				hasCursorArg
 			});
+			this.registerRootList(connection.type, connection.key);
 			this.store.setList(connection.key, nextListState$1);
 			return nextListState$1;
 		}
@@ -1305,7 +1342,7 @@ var FateClient = class {
 			...args
 		};
 		if (requestArgs.id === void 0 && owner.id) requestArgs.id = owner.id;
-		const { argsPayload, plan } = this.resolveListSelection(view$1, requestArgs);
+		const { argsPayload, plan } = this.resolveSelection(view$1, requestArgs);
 		const nodeSelection = plan.paths;
 		const scopedArgsPayload = argsPayload ? scopeArgsPayload(argsPayload, connection.field) : void 0;
 		const parentSelection = /* @__PURE__ */ new Set();
@@ -1389,33 +1426,42 @@ var FateClient = class {
 		this.executeRequest(request, { fetchAll: true }).catch(() => {});
 		return result;
 	}
+	getRootType(name) {
+		const root = this.roots[name];
+		if (!root) throw new Error(`fate: Unknown root request '${name}'.`);
+		return root.type;
+	}
 	async executeRequest(request, options = {}) {
 		const fetchAll = options.fetchAll ?? false;
 		const groups = /* @__PURE__ */ new Map();
 		const promises = [];
 		for (const [name, item] of Object.entries(request)) {
+			const type = this.getRootType(name);
 			const isNode = isNodeItem(item);
 			if (isNode || isNodesItem(item)) {
-				const plan = getSelectionPlan(item.root, null);
+				const plan = getSelectionPlan(item.view, null);
 				const fields = plan.paths;
-				const fieldsSignature = [...fields].slice().sort().join(",");
-				const argsSignature = [...plan.args.entries()].map(([path, entry]) => `${path}:${entry.hash}`).sort().join(",");
-				const groupKey = `${item.type}#${fieldsSignature}|${argsSignature}`;
+				const groupKey = `${type}#${[...fields].slice().sort().join(",")}|${[...plan.args.entries()].map(([path, entry]) => `${path}:${entry.hash}`).sort().join(",")}`;
 				let group = groups.get(groupKey);
 				if (!group) {
 					group = {
 						fields,
 						ids: [],
 						plan,
-						type: item.type
+						type
 					};
 					groups.set(groupKey, group);
 				}
 				for (const raw of isNode ? [item.id] : item.ids) {
-					const entityId = toEntityId(item.type, raw);
+					const entityId = toEntityId(type, raw);
 					const missing = this.store.missingForSelection(entityId, fields);
 					if (fetchAll || missing.size > 0) group.ids.push(raw);
 				}
+			} else if (isQueryItem(item)) {
+				const { argsPayload, plan } = this.resolveSelection(item.view, item.args);
+				const entityId = this.rootRequests.get(name);
+				const missing = entityId ? this.store.missingForSelection(entityId, plan.paths) : plan.paths;
+				if (fetchAll || missing.size > 0) promises.push(this.fetchQueryAndNormalize(name, item, plan, argsPayload));
 			} else promises.push(this.fetchListAndNormalize(name, item));
 		}
 		await Promise.all([...promises, ...Array.from(groups.values()).map((group) => group.ids.length ? this.fetchByIdAndNormalize(group.type, group.ids, group.fields, group.plan) : Promise.resolve())]);
@@ -1423,14 +1469,21 @@ var FateClient = class {
 	hasRequestData(request) {
 		for (const [name, item] of Object.entries(request)) {
 			const isNode = isNodeItem(item);
+			const type = this.getRootType(name);
 			if (isNode || isNodesItem(item)) {
-				const fields = getSelectionPlan(item.root, null).paths;
+				const fields = getSelectionPlan(item.view, null).paths;
 				for (const raw of isNode ? [item.id] : item.ids) {
-					const entityId = toEntityId(item.type, raw);
+					const entityId = toEntityId(type, raw);
 					if (this.store.missingForSelection(entityId, fields).size > 0) return false;
 				}
 				continue;
 			}
+			if (isQueryItem(item)) {
+				const { plan } = this.resolveSelection(item.view, item.args);
+				const entityId = this.rootRequests.get(name);
+				if ((entityId ? this.store.missingForSelection(entityId, plan.paths) : plan.paths).size > 0) return false;
+				continue;
+			}
 			if (!this.store.getList(name)) return false;
 		}
 		return true;
@@ -1438,18 +1491,28 @@ var FateClient = class {
 	getRequestResult(request) {
 		const result = {};
 		for (const [name, item] of Object.entries(request)) {
+			const type = this.getRootType(name);
 			if (isNodeItem(item)) {
-				result[name] = this.ref(item.type, item.id, item.root);
+				result[name] = this.ref(type, item.id, item.view);
 				continue;
 			}
 			if (isNodesItem(item)) {
-				result[name] = item.ids.map((id$1) => this.ref(item.type, id$1, item.root));
+				result[name] = item.ids.map((id$1) => this.ref(type, id$1, item.view));
+				continue;
+			}
+			if (isQueryItem(item)) {
+				const entityId = this.rootRequests.get(name);
+				if (entityId) {
+					const { id: id$1 } = parseEntityId(entityId);
+					result[name] = createRef(type, id$1, item.view, { root: true });
+				} else result[name] = null;
 				continue;
 			}
 			const listState = this.store.getListState(name);
-			const nodeView = item.root && typeof item.root === "object" && "items" in item.root && item.root.items ? item.root.items.node ?? item.root : item.root;
+			const hasItems = item.list && typeof item.list === "object" && "items" in item.list;
+			const nodeView = hasItems && item.list.items ? item.list.items.node ?? item.list : item.list;
 			const nodes = (listState?.ids ?? []).map((id$1) => this.rootListRef(id$1, nodeView));
-			if (item.root && typeof item.root === "object" && "items" in item.root) {
+			if (hasItems) {
 				const connection = {
 					items: nodes.map((node, index) => ({
 						cursor: listState?.cursors?.[index],
@@ -1457,7 +1520,7 @@ var FateClient = class {
 					})),
 					pagination: listState?.pagination
 				};
-				const { argsPayload } = this.resolveListSelection(item.root, item.args);
+				const { argsPayload } = this.resolveSelection(item.list, item.args);
 				const metadata = {
 					args: argsPayload,
 					field: name,
@@ -1465,7 +1528,7 @@ var FateClient = class {
 					owner: name,
 					procedure: `request.${name}`,
 					root: true,
-					type: item.type
+					type
 				};
 				Object.defineProperty(connection, ConnectionTag, {
 					configurable: false,
@@ -1485,24 +1548,33 @@ var FateClient = class {
 		const records = await this.transport.fetchById(type, ids, select, resolvedArgs);
 		for (const record of records) this.writeEntity(type, record, select, void 0, plan, prefix);
 	}
+	async fetchQueryAndNormalize(name, item, plan, argsPayload) {
+		if (!this.transport.fetchQuery) throw new Error(`fate: transport does not support queries. Please add support for 'fetchQuery' in your transport for '${name}'.`);
+		const record = await this.transport.fetchQuery(name, plan.paths, argsPayload);
+		if (!record || typeof record !== "object") return;
+		const entityId = this.writeEntity(this.getRootType(name), record, plan.paths, void 0, plan);
+		this.rootRequests.set(name, entityId);
+	}
 	async fetchListAndNormalize(name, item) {
 		if (!this.transport.fetchList) throw new Error(`fate: 'transport.fetchList' is not configured but request includes a list for key '${name}'.`);
-		const { argsPayload, plan } = this.resolveListSelection(item.root, item.args);
+		const type = this.getRootType(name);
+		const { argsPayload, plan } = this.resolveSelection(item.list, item.args);
 		const { items, pagination } = await this.transport.fetchList(name, plan.paths, argsPayload);
 		const ids = [];
 		const cursors = [];
 		for (const entry of items) {
-			const id$1 = this.writeEntity(item.type, entry.node, plan.paths, void 0, plan);
+			const id$1 = this.writeEntity(type, entry.node, plan.paths, void 0, plan);
 			ids.push(id$1);
 			cursors.push(entry.cursor);
 		}
+		this.registerRootList(type, name);
 		this.store.setList(name, {
 			cursors,
 			ids,
 			pagination
 		});
 	}
-	resolveListSelection(view$1, args) {
+	resolveSelection(view$1, args) {
 		const plan = getSelectionPlan(view$1, null);
 		const argsPayload = combineArgsPayload(args, resolvedArgsFromPlan(plan));
 		if (argsPayload) applyArgsPayloadToPlan(plan, argsPayload);
@@ -1511,7 +1583,7 @@ var FateClient = class {
 			plan
 		};
 	}
-	writeEntity(type, record, select, snapshots, plan, pathPrefix = null, blockedMask) {
+	writeEntity(type, record, select, snapshots, plan, pathPrefix = null, blockedMask, insert) {
 		const config = this.types.get(type);
 		if (!config) throw new Error(`fate: Found unknown entity type '${type}' in normalization.`);
 		const entityId = toEntityId(type, config.getId(record));
@@ -1528,6 +1600,10 @@ var FateClient = class {
 			} else if (relationDescriptor && typeof relationDescriptor === "object" && "type" in relationDescriptor) {
 				if (isFieldBlocked) continue;
 				const childPaths = selectionTree.get(key) ?? emptySet;
+				if (value === null) {
+					result[key] = null;
+					continue;
+				}
 				if (value && typeof value === "object" && !isNodeRef(value)) {
 					const childType = relationDescriptor.type;
 					const childConfig = this.types.get(childType);
@@ -1538,6 +1614,10 @@ var FateClient = class {
 			} else if (relationDescriptor && typeof relationDescriptor === "object" && "listOf" in relationDescriptor) {
 				if (isFieldBlocked) continue;
 				const childPaths = selectionTree.get(key) ?? emptySet;
+				if (value === null) {
+					result[key] = null;
+					continue;
+				}
 				const childType = relationDescriptor.listOf;
 				const childConfig = this.types.get(childType);
 				if (!childConfig) throw new Error(`fate: Unknown related type '${childType}' (field '${type}.${key}').`);
@@ -1614,10 +1694,12 @@ var FateClient = class {
 		if (snapshots && !snapshots.has(entityId)) snapshots.set(entityId, this.store.snapshot(entityId));
 		this.viewDataCache.invalidate(entityId);
 		this.store.merge(entityId, result, select);
-		this.linkParentLists(type, entityId, result, snapshots);
+		this.linkParentLists(type, entityId, result, snapshots, insert ?? "after");
+		if (!pathPrefix && insert) this.insertIntoRootLists(type, entityId, insert);
 		return entityId;
 	}
-	linkParentLists(type, entityId, record, snapshots) {
+	linkParentLists(type, entityId, record, snapshots, insert) {
+		if (insert === "none") return;
 		const parents = this.parentLists.get(type);
 		if (!parents) return;
 		for (const parent of parents) {
@@ -1631,11 +1713,11 @@ var FateClient = class {
 			if (current.some((item) => isNodeRef(item) && getNodeRefId(item) === entityId)) continue;
 			if (snapshots && !snapshots.has(parentId)) snapshots.set(parentId, this.store.snapshot(parentId));
 			this.viewDataCache.invalidate(parentId);
-			const nextList = [...current, createNodeRef(entityId)];
+			const nextList = insert === "before" ? [createNodeRef(entityId), ...current] : [...current, createNodeRef(entityId)];
 			const ids = nextList.map((item) => isNodeRef(item) ? getNodeRefId(item) : null).filter((id$1) => id$1 != null);
 			const defaultListKey = getListKey(parentId, parent.field);
 			const defaultListState = this.store.getListState(defaultListKey);
-			const nextDefaultCursors = defaultListState?.cursors && ids.length > defaultListState.cursors.length ? [...defaultListState.cursors, ...new Array(ids.length - defaultListState.cursors.length).fill(void 0)] : defaultListState?.cursors;
+			const nextDefaultCursors = defaultListState?.cursors ? insert === "before" ? [void 0, ...defaultListState.cursors] : [...defaultListState.cursors, void 0] : defaultListState?.cursors;
 			this.store.setList(defaultListKey, {
 				cursors: nextDefaultCursors,
 				ids,
@@ -1644,8 +1726,8 @@ var FateClient = class {
 			const registeredLists = this.store.getListsForField(parentId, parent.field).filter(([key]) => key !== defaultListKey);
 			for (const [listKey, listState] of registeredLists) {
 				if (listState.ids.includes(entityId)) continue;
-				const listIds = [...listState.ids, entityId];
-				const listCursors = listState.cursors ? [...listState.cursors, void 0] : void 0;
+				const listIds = insert === "before" ? [entityId, ...listState.ids] : [...listState.ids, entityId];
+				const listCursors = listState.cursors ? insert === "before" ? [void 0, ...listState.cursors] : [...listState.cursors, void 0] : void 0;
 				this.store.setList(listKey, {
 					cursors: listCursors,
 					ids: listIds,
@@ -1681,6 +1763,10 @@ var FateClient = class {
 					if (!(key in target)) target[key] = {};
 					const nextSelection = Object.keys(selectionWithoutArgs).length ? selectionWithoutArgs : selectionValue;
 					const value = record$1[key];
+					if (value == null) {
+						target[key] = null;
+						continue;
+					}
 					if (Array.isArray(value)) if (nextSelection.items && typeof nextSelection.items === "object") {
 						const selection = nextSelection.items;
 						const fieldArgs = plan.args.get(fieldPath);
@@ -1806,7 +1892,7 @@ function createClient(options) {
 * Builds a `Transport` backed by a tRPC client using the configured resolvers
 * for by-id queries, lists, and mutations.
 */
-function createTRPCTransport({ byId, client, lists, mutations }) {
+function createTRPCTransport({ byId, client, lists, mutations, queries }) {
 	const transport = {
 		async fetchById(type, ids, select, args) {
 			const resolver = byId[type];
@@ -1825,6 +1911,15 @@ function createTRPCTransport({ byId, client, lists, mutations }) {
 				args,
 				select: [...select]
 			});
+		},
+		async fetchQuery(procedure, select, args) {
+			if (!queries) throw new Error(`fate(trpc): No query resolvers configured; cannot call "${procedure}".`);
+			const resolver = queries[procedure];
+			if (!resolver) throw new Error(`fate(trpc): Missing query resolver for procedure "${procedure}"`);
+			return resolver(client)({
+				args,
+				select: [...select]
+			});
 		}
 	};
 	transport.mutate = async (procedure, input, select) => {
@@ -1839,4 +1934,16 @@ function createTRPCTransport({ byId, client, lists, mutations }) {
 }
 
 //#endregion
-export { ConnectionTag, FateClient, createClient, createTRPCTransport, getSelectionPlan, isViewTag, mutation, toEntityId, view };
+//#region src/root.ts
+/**
+* Defines a root query for an entity type, capturing the response shape.
+*/
+function clientRoot(type) {
+	return Object.freeze({
+		[RootKind]: true,
+		type
+	});
+}
+
+//#endregion
+export { ConnectionTag, FateClient, clientRoot, createClient, createTRPCTransport, getSelectionPlan, isViewTag, mutation, toEntityId, view };

package/lib/server.d.mts

@@ -1,30 +1,28 @@
+import { t as AnyRecord } from "./types-CNKGKRtz.mjs";
 import { z } from "zod";
 import { TRPCProcedureBuilder } from "@trpc/server";
 
 //#region src/server/dataView.d.ts
 declare const dataViewFieldsKey: unique symbol;
-type AnyRecord = Record<string, unknown>;
 type ResolverSelect<Context> = AnyRecord | ((options: {
   args?: AnyRecord;
   context?: Context;
 }) => AnyRecord | void);
 type Bivariant<Fn extends (...args: Array<any>) => unknown> = {
-  bivarianceHack(...args: Parameters<Fn>): ReturnType<Fn>;
-}['bivarianceHack'];
-type ResolverResolve<Item$1 extends AnyRecord, Context> = Bivariant<(options: {
-  args?: AnyRecord;
-  context?: Context;
-  item: Item$1;
-}) => Promise<unknown> | unknown>;
+  bivariance(...args: Parameters<Fn>): ReturnType<Fn>;
+}['bivariance'];
+type ResolverResolve<Item$1 extends AnyRecord, Result, Context> = Bivariant<(item: Item$1, context?: Context, args?: AnyRecord) => Promise<Result> | Result>;
+type ResolverAuthorize<Item$1 extends AnyRecord, Context> = Bivariant<(item: Item$1, context?: Context, args?: AnyRecord) => Promise<boolean> | boolean>;
 /**
  * Field configuration for selecting and resolving a computed value on the backend.
  */
-type ResolverField<Item$1 extends AnyRecord, Context> = {
+type ResolverField<Item$1 extends AnyRecord, Result, Context> = {
+  authorize?: ResolverAuthorize<Item$1, Context>;
   kind: 'resolver';
-  resolve: ResolverResolve<Item$1, Context>;
+  resolve: ResolverResolve<Item$1, Result, Context>;
   select?: ResolverSelect<Context>;
 };
-type DataField<Item$1 extends AnyRecord, Context> = true | DataView<AnyRecord, Context> | ResolverField<Item$1, Context>;
+type DataField<Item$1 extends AnyRecord> = true | DataView<AnyRecord> | ResolverField<Item$1, any, any>;
 /**
  * Recursively serializes resolver results for transport across the network.
  */
@@ -33,15 +31,15 @@ type Serializable<T> = T extends Date ? string : T extends Array<infer U> ? Arra
  * Server-side mirror of a view definition describing how to select and resolve
  * fields when fulfilling a client request.
  */
-type DataView<Item$1 extends AnyRecord, Context = unknown> = {
-  fields: Record<string, DataField<Item$1, Context>>;
+type DataView<Item$1 extends AnyRecord> = {
+  fields: Record<string, DataField<Item$1>>;
   kind?: 'resolver' | 'list';
   typeName: string;
 };
 /**
  * Convenience type for declaring the fields of a server data view.
  */
-type DataViewConfig<Item$1 extends AnyRecord, Context> = Record<string, DataField<Item$1, Context>>;
+type DataViewConfig<Item$1 extends AnyRecord> = Record<string, DataField<Item$1>>;
 /**
  * Declares a server data view that exposes an object's available fields to the client.
  *
@@ -51,43 +49,44 @@ type DataViewConfig<Item$1 extends AnyRecord, Context> = Record<string, DataFiel
  *   title: true,
  * });
  */
-declare function dataView<Item$1 extends AnyRecord, Context = unknown>(typeName: string): <Fields extends DataViewConfig<Item$1, Context>>(fields: Fields) => DataView<Item$1, Context> & {
+declare function dataView<Item$1 extends AnyRecord>(typeName: string): <Fields extends DataViewConfig<Item$1>>(fields: Fields) => DataView<Item$1> & {
   readonly [dataViewFieldsKey]: Fields;
 };
 /**
  * Marks a data view as a list resolver so the server can respond with
  * connection information.
  */
-declare const list: <Item$1 extends AnyRecord, Context>(view: DataView<Item$1, Context>) => {
+declare const list: <Item$1 extends AnyRecord>(view: DataView<Item$1>) => {
   kind: "list";
-  fields: Record<string, DataField<Item$1, Context>>;
+  fields: Record<string, DataField<Item$1>>;
   typeName: string;
 };
 /**
  * Declares a resolver field inside a data view, optionally providing a
  * selection for any data dependencies.
  */
-declare function resolver<Item$1 extends AnyRecord, Context = unknown>(config: {
-  resolve: ResolverResolve<Item$1, Context>;
+declare function resolver<Item$1 extends AnyRecord, Result = unknown, Context = unknown>(config: {
+  authorize?: ResolverAuthorize<Item$1, Context>;
+  resolve: ResolverResolve<Item$1, Result, Context>;
   select?: ResolverSelect<Context>;
-}): ResolverField<Item$1, Context>;
+}): ResolverField<Item$1, Result, Context>;
 type NonNullish<T> = Exclude<T, null | undefined>;
 type WithNullish<Original, Value> = null extends Original ? undefined extends Original ? Value | null | undefined : Value | null : undefined extends Original ? Value | undefined : Value;
-type ResolverResult<Field> = Field extends ResolverField<AnyRecord, unknown> ? Awaited<ReturnType<Field['resolve']>> : never;
-type RelationResult<ItemField, V extends DataView<AnyRecord, unknown>> = NonNullish<ItemField> extends Array<unknown> ? WithNullish<ItemField, Array<RawDataViewResult<V>>> : WithNullish<ItemField, RawDataViewResult<V>>;
-type ViewFieldConfig<V extends DataView<AnyRecord, unknown>> = V extends {
+type ResolverResult<Field> = Field extends ResolverField<AnyRecord, any, any> ? Field['authorize'] extends ResolverAuthorize<any, any> ? Awaited<ReturnType<Field['resolve']>> | null : Awaited<ReturnType<Field['resolve']>> : never;
+type RelationResult<ItemField, V extends DataView<AnyRecord>> = NonNullish<ItemField> extends Array<unknown> ? WithNullish<ItemField, Array<RawDataViewResult<V>>> : WithNullish<ItemField, RawDataViewResult<V>>;
+type ViewFieldConfig<V extends DataView<AnyRecord>> = V extends {
   readonly [dataViewFieldsKey]: infer Fields;
 } ? Fields : V['fields'];
-type RawFieldResult<Item$1 extends AnyRecord, Key extends PropertyKey, Field extends DataField<Item$1, unknown>> = Field extends true ? Key extends keyof Item$1 ? Item$1[Key] : never : Field extends DataView<infer ChildItem, unknown> ? Key extends keyof Item$1 ? RelationResult<Item$1[Key], DataView<ChildItem, unknown>> : never : Field extends ResolverField<Item$1, unknown> ? ResolverResult<Field> : never;
-type RawDataViewResult<V extends DataView<AnyRecord, unknown>> = V extends DataView<infer Item, unknown> ? { [K in keyof ViewFieldConfig<V>]: RawFieldResult<Item, K, ViewFieldConfig<V>[K]> } : never;
-type DataViewResult<V extends DataView<AnyRecord, unknown>> = Serializable<RawDataViewResult<V>>;
+type RawFieldResult<Item$1 extends AnyRecord, Key extends PropertyKey, Field extends DataField<Item$1>> = Field extends true ? Key extends keyof Item$1 ? Item$1[Key] : never : Field extends DataView<infer ChildItem> ? Key extends keyof Item$1 ? RelationResult<Item$1[Key], DataView<ChildItem>> : never : Field extends ResolverField<Item$1, any, any> ? ResolverResult<Field> : never;
+type RawDataViewResult<V extends DataView<AnyRecord>> = V extends DataView<infer Item> ? { [K in keyof ViewFieldConfig<V>]: RawFieldResult<Item, K, ViewFieldConfig<V>[K]> } : never;
+type DataViewResult<V extends DataView<AnyRecord>> = Serializable<RawDataViewResult<V>>;
 type WithTypename<T, Name extends string> = T & {
   __typename: Name;
 };
 /**
  * Resolved entity type from a data view for client use.
  */
-type Entity<TView extends DataView<AnyRecord, unknown>, Name extends string, Replacements extends Record<string, unknown> = Record<string, never>> = WithTypename<Omit<DataViewResult<TView>, keyof Replacements> & Replacements, Name>;
+type Entity<TView extends DataView<AnyRecord>, Name extends string, Replacements extends Record<string, unknown> = Record<never, never>> = WithTypename<Omit<DataViewResult<TView>, keyof Replacements> & Replacements, Name>;
 /**
  * Builds a resolver that applies a client's selection to a server data view,
  * filtering fields, running nested resolvers, and shaping selects.
@@ -101,7 +100,7 @@ declare function createResolver<Item$1 extends AnyRecord, Context = unknown>({
   args?: AnyRecord;
   ctx?: Context;
   select: Iterable<string>;
-  view: DataView<Item$1, Context>;
+  view: DataView<Item$1>;
 }): {
   resolve: (item: Item$1) => Promise<AnyRecord>;
   resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
@@ -164,4 +163,11 @@ declare const withConnection: <TContext>(procedure: ProcedureLike<TContext>) =>
   query: QueryFn<TContext, TItem, ConnectionInputWithAdditional<TAdditionalInput>>;
 }) => ReturnType<ReturnType<ProcedureLike<TContext>["input"]>["query"]>;
 //#endregion
-export { type Entity, connectionArgs, createResolver, dataView, list, resolver, withConnection };
+//#region src/server/input.d.ts
+declare const byIdInput: z.ZodObject<{
+  args: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+  ids: z.ZodArray<z.ZodString>;
+  select: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+//#endregion
+export { type Entity, byIdInput, connectionArgs, createResolver, dataView, list, resolver, withConnection };

package/lib/server.mjs

@@ -374,24 +374,26 @@ const collectResolvers = (node, select, args$1, context) => {
 	}
 	for (const relation of node.relations.values()) collectResolvers(relation, select, args$1, context);
 };
-const resolveNode = async (options) => {
-	const { item, node, options: resolverOptions } = options;
+const resolveNode = async ({ item, node, options: resolverOptions }) => {
 	if (!isRecord(item)) return item;
 	let result = null;
 	const assign = (key, value) => {
 		if (!result) result = { ...item };
 		result[key] = value;
 	};
-	const base = () => result ?? item;
+	const getItem = () => result ?? item;
 	for (const [field, resolver$1] of node.resolvers) {
-		const value = await resolver$1.resolve({
-			...resolverOptions,
-			item: base()
-		});
+		if (resolver$1.authorize) {
+			if (!await resolver$1.authorize(getItem(), resolverOptions.context, resolverOptions.args)) {
+				assign(field, null);
+				continue;
+			}
+		}
+		const value = await resolver$1.resolve(getItem(), resolverOptions.context, resolverOptions.args);
 		if (value !== void 0) assign(field, value);
 	}
 	for (const [field, relationNode] of node.relations) {
-		const current = base()[field];
+		const current = getItem()[field];
 		if (Array.isArray(current)) {
 			const resolved = await Promise.all(current.map((entry) => resolveNode({
 				item: entry,
@@ -447,4 +449,12 @@ function createResolver({ args: args$1, ctx, select: initialSelect, view }) {
 }
 
 //#endregion
-export { connectionArgs, createResolver, dataView, list, resolver, withConnection };
+//#region src/server/input.ts
+const byIdInput = z.object({
+	args: connectionArgs,
+	ids: z.array(z.string().min(1)).nonempty(),
+	select: z.array(z.string())
+});
+
+//#endregion
+export { byIdInput, connectionArgs, createResolver, dataView, list, resolver, withConnection };