@nkzw/fate 0.1.2 → 1.0.0-rc.0

package/lib/sourceRouter-Bwpkr062.mjs

@@ -0,0 +1,972 @@
+import { t as isRecord } from "./record-AeZJC9fd.mjs";
+import { z } from "zod";
+//#region src/server/queryArgs.ts
+const toPrismaArgs = (args) => {
+	const prismaArgs = {};
+	const isBackward = args.before !== void 0 || typeof args.last === "number";
+	if (typeof args.first === "number") prismaArgs.take = args.first + 1;
+	if (typeof args.last === "number") prismaArgs.take = -(args.last + 1);
+	const cursor = isBackward ? args.before : args.after;
+	if (cursor !== void 0) {
+		prismaArgs.cursor = { id: cursor };
+		prismaArgs.skip = 1;
+	}
+	return prismaArgs;
+};
+/**
+* Narrows nested args to the slice relevant for a particular selection path.
+*/
+function getScopedArgs(args, path) {
+	if (!args) return;
+	const segments = path.split(".");
+	let current = args;
+	for (const segment of segments) {
+		if (!isRecord(current)) return;
+		current = current[segment];
+	}
+	return isRecord(current) ? current : void 0;
+}
+//#endregion
+//#region src/server/connection.ts
+const isConnectionResult = (value) => isRecord(value) && Array.isArray(value.items) && isRecord(value.pagination) && typeof value.pagination.hasNext === "boolean" && typeof value.pagination.hasPrevious === "boolean";
+const args = z.object({}).catchall(z.union([z.unknown(), z.lazy(() => args)]));
+/**
+* Zod schema for connection args (`after`, `before`, `first`, `last`, etc.).
+*/
+const connectionArgs = args.optional();
+const connectionInput = z.strictObject({
+	args: connectionArgs,
+	select: z.array(z.string())
+});
+const paginationArgKeys = new Set([
+	"after",
+	"before",
+	"first",
+	"last"
+]);
+const paginationArgsSchema = z.strictObject({
+	after: z.string().optional(),
+	before: z.string().optional(),
+	first: z.number().int().positive().optional(),
+	last: z.number().int().positive().optional()
+}).partial().refine(({ after, before }) => !(after && before), "Connection args can't include both 'after' and 'before'.").refine(({ first, last }) => !(first && last), "Connection args can't include both 'first' and 'last'.");
+const extractPaginationArgs = (args) => args ? Object.fromEntries(Object.entries(args).filter(([key]) => paginationArgKeys.has(key))) : {};
+async function resolveConnection({ ctx, defaultSize = 20, getCursor = (node) => node.id, input, map, query }) {
+	const paginationArgs = paginationArgsSchema.parse(extractPaginationArgs(input.args));
+	const isBackward = paginationArgs.before !== void 0 || paginationArgs.last !== void 0;
+	const cursor = isBackward ? paginationArgs.before : paginationArgs.after;
+	const direction = isBackward ? "backward" : "forward";
+	const pageSize = paginationArgs.first ?? paginationArgs.last ?? defaultSize;
+	const rawItems = await query({
+		ctx,
+		cursor,
+		direction,
+		input,
+		skip: cursor ? 1 : void 0,
+		take: pageSize + 1
+	});
+	const hasMore = rawItems.length > pageSize;
+	const limitedItems = isBackward ? rawItems.slice(Math.max(0, rawItems.length - pageSize)) : rawItems.slice(0, pageSize);
+	const items = (map ? await map({
+		ctx,
+		input,
+		items: limitedItems
+	}) : limitedItems).map((node) => ({
+		cursor: getCursor(node),
+		node
+	}));
+	const firstItem = items[0];
+	const lastItem = items.at(-1);
+	return {
+		items,
+		pagination: {
+			hasNext: isBackward ? Boolean(cursor) : hasMore,
+			hasPrevious: isBackward ? hasMore : Boolean(cursor),
+			nextCursor: lastItem?.cursor,
+			previousCursor: (isBackward ? hasMore : Boolean(cursor)) ? firstItem?.cursor : void 0
+		}
+	};
+}
+/**
+* Converts an array of nodes into a list view connection result the client
+* can normalize.
+*/
+function arrayToConnection(nodes, { args, getCursor = (node) => String(node.id) } = {}) {
+	if (!nodes) return;
+	const paginationArgs = paginationArgsSchema.parse(extractPaginationArgs(args));
+	if (Object.keys(paginationArgs).length === 0) return {
+		items: nodes.map((node) => ({
+			cursor: getCursor(node),
+			node
+		})),
+		pagination: {
+			hasNext: false,
+			hasPrevious: false,
+			nextCursor: void 0,
+			previousCursor: void 0
+		}
+	};
+	const isBackward = paginationArgs.before !== void 0 || paginationArgs.last !== void 0;
+	const cursor = isBackward ? paginationArgs.before : paginationArgs.after;
+	const pageSize = paginationArgs.first ?? paginationArgs.last ?? nodes.length;
+	const cursorIndex = cursor === void 0 ? -1 : nodes.findIndex((node) => getCursor(node) === cursor);
+	const selectedNodes = cursorIndex < 0 ? nodes : isBackward ? nodes.slice(0, cursorIndex) : nodes.slice(cursorIndex + 1);
+	const hasNext = selectedNodes.length > pageSize;
+	const hasPrevious = nodes.length > selectedNodes.length;
+	const items = (isBackward ? selectedNodes.slice(Math.max(0, selectedNodes.length - pageSize)) : selectedNodes.slice(0, pageSize)).map((node) => ({
+		cursor: getCursor(node),
+		node
+	}));
+	const firstItem = items[0];
+	const lastItem = items.at(-1);
+	return {
+		items,
+		pagination: {
+			hasNext: isBackward ? hasPrevious : hasNext,
+			hasPrevious: isBackward ? hasNext : hasPrevious,
+			nextCursor: lastItem?.cursor,
+			previousCursor: (isBackward ? hasNext : hasPrevious) && firstItem ? firstItem.cursor : void 0
+		}
+	};
+}
+const isDataViewField$1 = (field) => Boolean(field) && typeof field === "object" && "fields" in field;
+const assignIfChanged = (current, key, next, existing) => {
+	if (next === existing) return current;
+	if (!current) return { [key]: next };
+	current[key] = next;
+	return current;
+};
+function toConnectionResult({ args, item, path, view }) {
+	if (!isRecord(item)) return item;
+	let result = null;
+	const base = () => result ? {
+		...item,
+		...result
+	} : item;
+	for (const [field, config] of Object.entries(view.fields)) {
+		if (!isDataViewField$1(config)) continue;
+		const current = base()[field];
+		const nextPath = path ? `${path}.${field}` : field;
+		if (config.kind === "list") {
+			if (isConnectionResult(current)) {
+				const wrappedItems = current.items.map((entry) => ({
+					...entry,
+					node: toConnectionResult({
+						args,
+						item: entry.node,
+						path: nextPath,
+						view: config
+					})
+				}));
+				const connection = wrappedItems.some((entry, index) => entry.node !== current.items[index]?.node) || wrappedItems.length !== current.items.length ? {
+					...current,
+					items: wrappedItems
+				} : current;
+				result = assignIfChanged(result, field, connection, current);
+				continue;
+			}
+			if (!Array.isArray(current)) continue;
+			const connection = arrayToConnection(current.map((item) => toConnectionResult({
+				args,
+				item,
+				path: nextPath,
+				view: config
+			})), { args: getScopedArgs(args, nextPath) });
+			result = assignIfChanged(result, field, connection, current);
+			continue;
+		}
+		if (Array.isArray(current)) {
+			const wrapped = current.map((entry) => toConnectionResult({
+				args,
+				item: entry,
+				path: nextPath,
+				view: config
+			}));
+			result = assignIfChanged(result, field, wrapped, current);
+			continue;
+		}
+		if (isRecord(current)) {
+			const wrapped = toConnectionResult({
+				args,
+				item: current,
+				path: nextPath,
+				view: config
+			});
+			result = assignIfChanged(result, field, wrapped, current);
+		}
+	}
+	return result ? {
+		...item,
+		...result
+	} : item;
+}
+function withConnection(procedure) {
+	return ({ defaultSize = 20, getCursor = (node) => node.id, input: additionalInput, map, query }) => {
+		const inputSchema = additionalInput ? connectionInput.extend({ args: connectionArgs.and(additionalInput) }) : connectionInput;
+		return procedure.input(inputSchema).query(async (resolverOptions) => {
+			const { ctx, input } = resolverOptions;
+			return resolveConnection({
+				ctx,
+				defaultSize,
+				getCursor,
+				input,
+				map,
+				query
+			});
+		});
+	};
+}
+//#endregion
+//#region src/server/prismaSelect.ts
+const toPrismaOrderBy = (orderBy) => orderBy.map((entry) => ({ [entry.field]: entry.direction }));
+const mergeObject = (target, source) => {
+	for (const [key, value] of Object.entries(source)) {
+		const existing = target[key];
+		if (existing && value && typeof existing === "object" && typeof value === "object" && !Array.isArray(existing) && !Array.isArray(value)) {
+			mergeObject(existing, value);
+			continue;
+		}
+		target[key] = value;
+	}
+};
+const stableStringify = (value) => {
+	if (Array.isArray(value)) return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
+	return JSON.stringify(value);
+};
+const getConflictingCountRelations = (node) => {
+	const signaturesByRelation = /* @__PURE__ */ new Map();
+	for (const computed of node.computeds.values()) {
+		if (!computed.select) continue;
+		for (const selection of Object.values(computed.select)) {
+			if (selection.kind !== "count") continue;
+			const signatures = signaturesByRelation.get(selection.relation) ?? /* @__PURE__ */ new Set();
+			signatures.add(stableStringify(selection.where ?? null));
+			signaturesByRelation.set(selection.relation, signatures);
+		}
+	}
+	return new Set([...signaturesByRelation.entries()].filter(([, signatures]) => signatures.size > 1).map(([relation]) => relation));
+};
+const ensureRelationSelect = (select, path) => {
+	if (!path) return select;
+	const segments = path.split(".");
+	let current = select;
+	for (const segment of segments) {
+		const existing = current[segment];
+		if (existing && typeof existing === "object" && "select" in existing) {
+			const relation = existing;
+			if (!relation.select || typeof relation.select !== "object" || Array.isArray(relation.select)) relation.select = {};
+			current = relation.select;
+			continue;
+		}
+		const relation = { select: {} };
+		current[segment] = relation;
+		current = relation.select;
+	}
+	return current;
+};
+const assignDependencyPath = (select, path) => {
+	const segments = path.split(".");
+	let current = select;
+	for (const [index, segment] of segments.entries()) {
+		if (index === segments.length - 1) {
+			current[segment] = true;
+			continue;
+		}
+		current = ensureRelationSelect(current, segment);
+	}
+};
+const applyComputedSelections = (node, select) => {
+	const conflictingCountRelations = getConflictingCountRelations(node);
+	for (const computed of node.computeds.values()) {
+		if (!computed.select) continue;
+		for (const selection of Object.values(computed.select)) {
+			if (selection.kind === "count") {
+				if (conflictingCountRelations.has(selection.relation)) continue;
+				const target = ensureRelationSelect(select, node.path);
+				const existing = target._count ?? { select: {} };
+				target._count = existing;
+				const countSelect = existing.select ?? {};
+				existing.select = countSelect;
+				countSelect[selection.relation] = selection.where ? { where: selection.where } : true;
+				continue;
+			}
+			assignDependencyPath(ensureRelationSelect(select, node.path), selection.path);
+		}
+	}
+	for (const relation of node.relations.values()) applyComputedSelections(relation, select);
+};
+const collectResolverSelections = (node, select, args, context) => {
+	for (const resolver of node.resolvers.values()) {
+		if (!resolver.select) continue;
+		const addition = typeof resolver.select === "function" ? resolver.select({
+			args,
+			context
+		}) : resolver.select;
+		if (addition && typeof addition === "object" && !Array.isArray(addition)) mergeObject(ensureRelationSelect(select, node.path), addition);
+	}
+	for (const relation of node.relations.values()) collectResolverSelections(relation, select, args, context);
+};
+const buildNodeSelect = (node) => {
+	const select = {};
+	for (const field of node.selectedFields) {
+		if (field === "cursor") continue;
+		select[field] = true;
+	}
+	for (const [field, relation] of node.relations) {
+		const relationSelect = buildNodeSelect(relation);
+		const scopedArgs = relation.args;
+		const relationConfig = "source" in node ? node.source?.relations?.[field] : void 0;
+		const orderBy = (relationConfig ? relationConfig.kind === "many" || relationConfig.kind === "manyToMany" : false) && "orderBy" in relation ? toPrismaOrderBy(relation.orderBy ?? []) : [];
+		select[field] = scopedArgs && Object.keys(scopedArgs).length ? {
+			...toPrismaArgs(scopedArgs),
+			...orderBy.length ? { orderBy } : null,
+			select: relationSelect
+		} : {
+			...orderBy.length ? { orderBy } : null,
+			select: relationSelect
+		};
+	}
+	return select;
+};
+function toPrismaSelect(plan) {
+	const select = buildNodeSelect(plan.root);
+	applyComputedSelections(plan.root, select);
+	collectResolverSelections(plan.root, select, plan.args, plan.ctx);
+	return select;
+}
+//#endregion
+//#region src/server/dataView.ts
+const dataViewFieldsKey = Symbol("__fate__DataViewFields");
+const dataViewBaseKey = Symbol("__fate__DataViewBase");
+const dataViewListOptionsKey = Symbol("__fate__DataViewListOptions");
+const computedStateKey = Symbol("__fate__ComputedState");
+const isDataView = (value) => isRecord(value) && isRecord(value.fields) && typeof value.typeName === "string";
+const getBaseDataView = (view) => view[dataViewBaseKey] ?? view;
+const getDataViewListOptions = (view) => view[dataViewListOptionsKey];
+/**
+* Declares a server data view that exposes an object's available fields to the client.
+*
+* @example
+* const Post = dataView<PostItem>('Post')({
+*   id: true,
+*   title: true,
+* });
+*/
+function dataView(typeName) {
+	return (fields) => {
+		return {
+			[dataViewFieldsKey]: fields,
+			fields,
+			typeName
+		};
+	};
+}
+/**
+* Marks a data view as a list resolver so the server can respond with
+* connection information.
+*/
+const list = (view, options) => {
+	return {
+		...view,
+		[dataViewBaseKey]: getBaseDataView(view),
+		...options ? { [dataViewListOptionsKey]: options } : null,
+		kind: "list"
+	};
+};
+/**
+* Declares a resolver field inside a data view, optionally providing a
+* selection for any data dependencies.
+*/
+function resolver(config) {
+	return {
+		kind: "resolver",
+		...config
+	};
+}
+const field = (path) => ({
+	kind: "field",
+	path
+});
+const count = (relation, options) => ({
+	kind: "count",
+	relation,
+	where: options?.where
+});
+function computed(config) {
+	return {
+		kind: "computed",
+		...config
+	};
+}
+const isResolverField = (field) => Boolean(field) && typeof field === "object" && "kind" in field && field.kind === "resolver";
+const isComputedField = (field) => Boolean(field) && typeof field === "object" && "kind" in field && field.kind === "computed";
+const isDataViewField = (field) => Boolean(field) && typeof field === "object" && "fields" in field;
+const getValueAtPath = (item, path) => {
+	let current = item;
+	for (const segment of path.split(".")) {
+		if (!isRecord(current)) return;
+		current = current[segment];
+	}
+	return current;
+};
+const getComputedState = (item) => item[computedStateKey];
+const attachComputedState = (item, field, deps) => {
+	const state = getComputedState(item) ?? {};
+	state[field] = {
+		...state[field] ?? {},
+		...deps
+	};
+	Object.defineProperty(item, computedStateKey, {
+		configurable: true,
+		enumerable: false,
+		value: state,
+		writable: true
+	});
+	return item;
+};
+const getComputedDeps = (item, field, select) => {
+	const deps = { ...getComputedState(item)?.[field] ?? {} };
+	if (!select) return deps;
+	for (const [name, selection] of Object.entries(select)) {
+		if (deps[name] !== void 0) continue;
+		if (selection.kind === "count") {
+			deps[name] = getValueAtPath(item, `_count.${selection.relation}`) ?? 0;
+			continue;
+		}
+		deps[name] = getValueAtPath(item, selection.path);
+	}
+	return deps;
+};
+const filterToViewFields = (item, view, selectedPaths, prefix = null) => {
+	if (!isRecord(item)) return item;
+	const filtered = {};
+	for (const [field, config] of Object.entries(view.fields)) {
+		const path = prefix ? `${prefix}.${field}` : field;
+		let hasSelection = selectedPaths.has(path);
+		if (!hasSelection) {
+			for (const selected of selectedPaths) if (selected.startsWith(`${path}.`)) {
+				hasSelection = true;
+				break;
+			}
+		}
+		if (!hasSelection) continue;
+		if (!(field in item)) continue;
+		const value = item[field];
+		if (isDataViewField(config)) {
+			if (isConnectionResult(value)) {
+				filtered[field] = {
+					...value,
+					items: value.items.map((entry) => ({
+						...entry,
+						node: isRecord(entry.node) ? filterToViewFields(entry.node, config, selectedPaths, path) : entry.node
+					}))
+				};
+				continue;
+			}
+			if (Array.isArray(value)) {
+				filtered[field] = value.map((entry) => isRecord(entry) ? filterToViewFields(entry, config, selectedPaths, path) : entry);
+				continue;
+			}
+			if (isRecord(value)) {
+				filtered[field] = filterToViewFields(value, config, selectedPaths, path);
+				continue;
+			}
+		}
+		filtered[field] = value;
+	}
+	return filtered;
+};
+const createSelectedNode = (view, path, args) => ({
+	args: path ? getScopedArgs(args, path) : args,
+	computeds: /* @__PURE__ */ new Map(),
+	path,
+	relations: /* @__PURE__ */ new Map(),
+	resolvers: /* @__PURE__ */ new Map(),
+	selectedFields: /* @__PURE__ */ new Set(),
+	view
+});
+const assignPath = (node, segments, path, args, selectedPaths, view) => {
+	if (segments.length === 0) return;
+	const [segment, ...rest] = segments;
+	const field = view.fields[segment];
+	if (!field) return;
+	const nextPath = path ? `${path}.${segment}` : segment;
+	if (isResolverField(field)) {
+		if (rest.length === 0) {
+			node.resolvers.set(segment, field);
+			selectedPaths.add(nextPath);
+		}
+		return;
+	}
+	if (isComputedField(field)) {
+		if (rest.length === 0) {
+			node.computeds.set(segment, field);
+			selectedPaths.add(nextPath);
+		}
+		return;
+	}
+	if (isDataViewField(field)) {
+		let relationNode = node.relations.get(segment);
+		if (!relationNode) {
+			relationNode = createSelectedNode(field, nextPath, args);
+			node.relations.set(segment, relationNode);
+		}
+		if (field.fields.id === true) {
+			relationNode.selectedFields.add("id");
+			selectedPaths.add(`${nextPath}.id`);
+		}
+		if (rest.length === 0) {
+			selectedPaths.add(nextPath);
+			return;
+		}
+		assignPath(relationNode, rest, nextPath, args, selectedPaths, field);
+		return;
+	}
+	if (rest.length === 0) {
+		node.selectedFields.add(segment);
+		selectedPaths.add(nextPath);
+	}
+};
+const resolveNode = async ({ item, node, options: resolverOptions }) => {
+	if (!isRecord(item)) return item;
+	let result = null;
+	const assign = (key, value) => {
+		if (!result) {
+			result = { ...item };
+			const state = getComputedState(item);
+			if (state) Object.defineProperty(result, computedStateKey, {
+				configurable: true,
+				enumerable: false,
+				value: state,
+				writable: true
+			});
+		}
+		result[key] = value;
+	};
+	const getItem = () => result ?? item;
+	for (const [field, resolver] of node.resolvers) {
+		if (resolver.authorize) {
+			if (!await resolver.authorize(getItem(), resolverOptions.context, resolverOptions.args)) {
+				assign(field, null);
+				continue;
+			}
+		}
+		const value = await resolver.resolve(getItem(), resolverOptions.context, resolverOptions.args);
+		if (value !== void 0) assign(field, value);
+	}
+	for (const [field, computedField] of node.computeds) {
+		if (computedField.authorize) {
+			if (!await computedField.authorize(getItem(), resolverOptions.context, resolverOptions.args)) {
+				assign(field, null);
+				continue;
+			}
+		}
+		const value = await computedField.resolve(getItem(), getComputedDeps(getItem(), field, computedField.select), resolverOptions.context, resolverOptions.args);
+		if (value !== void 0) assign(field, value);
+	}
+	for (const [field, relationNode] of node.relations) {
+		const current = getItem()[field];
+		if (isConnectionResult(current)) {
+			const resolvedItems = await Promise.all(current.items.map(async (entry) => ({
+				...entry,
+				node: await resolveNode({
+					item: entry.node,
+					node: relationNode,
+					options: resolverOptions
+				})
+			})));
+			if (resolvedItems.some((value, index) => value.node !== current.items[index]?.node)) assign(field, {
+				...current,
+				items: resolvedItems
+			});
+			continue;
+		}
+		if (Array.isArray(current)) {
+			const resolved = await Promise.all(current.map((entry) => resolveNode({
+				item: entry,
+				node: relationNode,
+				options: resolverOptions
+			})));
+			if (resolved.some((value, index) => value !== current[index])) assign(field, resolved);
+			continue;
+		}
+		if (current && typeof current === "object") {
+			const resolved = await resolveNode({
+				item: current,
+				node: relationNode,
+				options: resolverOptions
+			});
+			if (resolved !== current) assign(field, resolved);
+		}
+	}
+	return result ?? item;
+};
+/**
+* Builds a generic execution plan for a client's selection against a server
+* data view.
+*/
+function createViewPlan({ args, ctx, select: initialSelect, view }) {
+	const selectedPaths = /* @__PURE__ */ new Set();
+	selectedPaths.add("id");
+	const root = createSelectedNode(view, null, args);
+	root.selectedFields.add("id");
+	for (const path of initialSelect) {
+		if (!path) continue;
+		assignPath(root, path.split("."), null, args, selectedPaths, view);
+	}
+	const resolve = async (item) => toConnectionResult({
+		args,
+		item: filterToViewFields(await resolveNode({
+			item,
+			node: root,
+			options: {
+				args,
+				context: ctx
+			}
+		}), root.view, selectedPaths),
+		view: root.view
+	});
+	return {
+		args,
+		ctx,
+		resolve,
+		resolveMany: (items) => Promise.all(items.map((item) => resolve(item))),
+		root,
+		selectedPaths,
+		view
+	};
+}
+/**
+* Builds a resolver that applies a client's selection to a server data view,
+* filtering fields, running nested resolvers, and shaping Prisma selects.
+*/
+function createResolver({ args, ctx, select, view }) {
+	const plan = createViewPlan({
+		args,
+		ctx,
+		select,
+		view
+	});
+	return {
+		resolve: plan.resolve,
+		resolveMany: plan.resolveMany,
+		select: toPrismaSelect(plan)
+	};
+}
+//#endregion
+//#region src/server/source.ts
+const ascending = (field) => ({
+	direction: "asc",
+	field
+});
+const toSourceOrder = (orderBy) => {
+	if (!orderBy) return;
+	const sourceOrder = (Array.isArray(orderBy) ? orderBy : [orderBy]).flatMap((entry) => Object.entries(entry).map(([field, direction]) => ({
+		direction,
+		field
+	})));
+	return sourceOrder.length ? sourceOrder : void 0;
+};
+const getDataViewSourceConfig = (input) => {
+	const view = getBaseDataView(input);
+	const orderBy = toSourceOrder(getDataViewListOptions(input)?.orderBy);
+	return {
+		...orderBy ? { orderBy } : null,
+		view
+	};
+};
+const collectDataViewConfigs = (input) => {
+	const configsByFields = /* @__PURE__ */ new Map();
+	const seenValues = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (!value || typeof value !== "object" || seenValues.has(value)) return;
+		seenValues.add(value);
+		if (isDataView(value)) {
+			const config = getDataViewSourceConfig(value);
+			const existingConfig = configsByFields.get(config.view.fields);
+			if (existingConfig) {
+				if (config.orderBy) existingConfig.orderBy = config.orderBy;
+			} else configsByFields.set(config.view.fields, config);
+			for (const field of Object.values(config.view.fields)) visit(field);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const entry of value) visit(entry);
+			return;
+		}
+		for (const [key, entry] of Object.entries(value)) {
+			if (key === "Root") continue;
+			visit(entry);
+		}
+	};
+	visit(input);
+	return [...configsByFields.values()];
+};
+function createSourceDefinition(view, config) {
+	return {
+		...config,
+		relations: void 0,
+		view
+	};
+}
+const getRelationView = (view, field) => {
+	const config = view.fields[field];
+	if (!isDataView(config)) return null;
+	const orderBy = toSourceOrder(getDataViewListOptions(config)?.orderBy);
+	return {
+		kind: config.kind === "list" ? "many" : "one",
+		...orderBy ? { orderBy } : null,
+		view: config
+	};
+};
+function createSourceDefinitions(configs, options) {
+	const sources = configs.map((config) => createSourceDefinition(config.view, {
+		adapter: config.adapter,
+		id: config.id ?? "id",
+		orderBy: config.orderBy
+	}));
+	const sourcesByView = /* @__PURE__ */ new Map();
+	const sourcesByFields = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		sourcesByView.set(source.view, source);
+		sourcesByFields.set(source.view.fields, source);
+	}
+	for (const [index, config] of configs.entries()) {
+		const source = sources[index];
+		const relations = {};
+		const relationFields = new Set([...Object.keys(config.relations ?? {}), ...Object.keys(config.view.fields).filter((field) => getRelationView(config.view, field))]);
+		for (const field of relationFields) {
+			const relationView = getRelationView(config.view, field);
+			if (!relationView) throw new Error(`Source ${config.view.typeName}.${field} must reference a data view relation.`);
+			const relationSource = sourcesByView.get(relationView.view) ?? sourcesByFields.get(relationView.view.fields);
+			if (!relationSource) throw new Error(`Source ${config.view.typeName}.${field} references an unregistered data view.`);
+			const relationConfig = {
+				...options?.resolveRelation?.({
+					config,
+					field,
+					kind: relationView.kind,
+					source,
+					target: relationSource
+				}),
+				...relationView.orderBy ? { orderBy: relationView.orderBy } : null,
+				...config.relations?.[field] ?? {}
+			};
+			if (!relationConfig.foreignKey || !relationConfig.localKey) throw new Error(`Source ${config.view.typeName}.${field} requires foreignKey and localKey relation metadata.`);
+			relations[field] = {
+				...relationConfig,
+				kind: relationConfig.through ? "manyToMany" : relationView.kind,
+				source: relationSource
+			};
+		}
+		if (Object.keys(relations).length > 0) source.relations = relations;
+	}
+	return sources;
+}
+const hasNestedSelection = (select, field) => {
+	for (const path of select) if (path === field || path.startsWith(`${field}.`)) return true;
+	return false;
+};
+const getNestedSelection = (select, field) => {
+	const nested = [];
+	for (const path of select) if (path.startsWith(`${field}.`)) nested.push(path.slice(field.length + 1));
+	return nested;
+};
+const getNestedSourceInput = (input, field) => ({
+	args: getScopedArgs(input.args, field),
+	select: getNestedSelection(input.select, field)
+});
+const resolveSourceReference = (source) => typeof source === "function" ? source() : source;
+const getSourceOrder = (source, override) => {
+	const base = [...override ?? source.orderBy ?? []];
+	if (!base.some((entry) => entry.field === source.id)) base.push(ascending(source.id));
+	return base.length ? base : [ascending(source.id)];
+};
+const attachSourceNode = (node, source, overrideOrder) => {
+	const relations = /* @__PURE__ */ new Map();
+	for (const [field, relationNode] of node.relations) {
+		const relation = source.relations?.[field];
+		if (!relation) continue;
+		const relationSource = resolveSourceReference(relation.source);
+		relations.set(field, attachSourceNode(relationNode, relationSource, relation.orderBy));
+	}
+	return {
+		...node,
+		orderBy: getSourceOrder(source, overrideOrder),
+		relations,
+		source
+	};
+};
+function createSourcePlan({ args, ctx, select, source }) {
+	const plan = createViewPlan({
+		args,
+		ctx,
+		select,
+		view: source.view
+	});
+	return {
+		...plan,
+		root: attachSourceNode(plan.root, source),
+		source
+	};
+}
+function createNestedSourcePlan({ ctx, field, input, source }) {
+	return createSourcePlan({
+		...getNestedSourceInput(input, field),
+		ctx,
+		source
+	});
+}
+//#endregion
+//#region src/server/executor.ts
+const createSourceRegistry = (entries) => new Map(entries);
+const getSourceExecutor = ({ plan, registry }) => {
+	const executor = registry.get(plan.source);
+	if (!executor) throw new Error(`No executor registered for source ${plan.source.view.typeName}.`);
+	return executor;
+};
+const createPlan = ({ ctx, input, source }) => createSourcePlan({
+	...input,
+	ctx,
+	source
+});
+const resolveSourceByIds = async ({ ctx, extra, ids, input, registry, source }) => {
+	const plan = createPlan({
+		ctx,
+		input,
+		source
+	});
+	const executor = getSourceExecutor({
+		plan,
+		registry
+	});
+	const planRecord = plan;
+	if (executor.byIds) return plan.resolveMany(await executor.byIds({
+		ctx,
+		extra,
+		ids,
+		plan: planRecord
+	}));
+	if (!executor.byId) throw new Error(`Source ${plan.source.view.typeName} does not support byIds execution.`);
+	const items = await Promise.all(ids.map((id) => executor.byId?.({
+		ctx,
+		extra,
+		id,
+		plan: planRecord
+	})));
+	return plan.resolveMany(items.flatMap((item) => item ? [item] : []));
+};
+const resolveSourceById = async ({ ctx, extra, id, input, registry, source }) => {
+	const plan = createPlan({
+		ctx,
+		input,
+		source
+	});
+	const executor = getSourceExecutor({
+		plan,
+		registry
+	});
+	const planRecord = plan;
+	if (executor.byId) {
+		const item = await executor.byId({
+			ctx,
+			extra,
+			id,
+			plan: planRecord
+		});
+		return item ? plan.resolve(item) : null;
+	}
+	if (!executor.byIds) throw new Error(`Source ${plan.source.view.typeName} does not support byId execution.`);
+	const items = await executor.byIds({
+		ctx,
+		extra,
+		ids: [id],
+		plan: planRecord
+	});
+	return items[0] ? plan.resolve(items[0]) : null;
+};
+const resolveSourceConnection = async ({ ctx, cursor, direction, extra, input, registry, skip, source, take }) => {
+	const plan = createPlan({
+		ctx,
+		input,
+		source
+	});
+	const executor = getSourceExecutor({
+		plan,
+		registry
+	});
+	const planRecord = plan;
+	if (!executor.connection) throw new Error(`Source ${plan.source.view.typeName} does not support connection execution.`);
+	return plan.resolveMany(await executor.connection({
+		ctx,
+		cursor,
+		direction,
+		extra,
+		plan: planRecord,
+		skip,
+		take
+	}));
+};
+const refetchSourceById = async ({ ctx, extra, id, input, registry, source }) => resolveSourceById({
+	ctx,
+	extra,
+	id,
+	input,
+	registry,
+	source
+});
+//#endregion
+//#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
+//#region src/server/sourceRouter.ts
+const normalizeSourceOptions = (input) => "source" in input ? input : { source: input };
+/**
+* Creates standard `byId` and `list` procedures for a Fate source.
+*
+* Use this when a router also has custom mutations or custom queries and you
+* want to spread the generated source procedures into that router.
+*/
+function createSourceProcedures({ byId, createConnectionProcedure, list, procedure, registry, source }) {
+	const procedures = {};
+	if (byId !== false) procedures.byId = procedure.input(byIdInput).query(async ({ ctx, input }) => resolveSourceByIds({
+		ctx,
+		ids: input.ids,
+		input,
+		registry,
+		source
+	}));
+	if (list !== false) {
+		if (!createConnectionProcedure) throw new Error(`Source ${source.view.typeName} requires createConnectionProcedure to build a list procedure.`);
+		procedures.list = createConnectionProcedure({
+			defaultSize: (typeof list === "object" ? list : void 0)?.defaultSize,
+			query: async ({ ctx, cursor, direction, input, skip, take }) => resolveSourceConnection({
+				ctx,
+				cursor,
+				direction,
+				input,
+				registry,
+				skip,
+				source,
+				take
+			})
+		});
+	}
+	return procedures;
+}
+/**
+* Binds the app-specific tRPC pieces once and returns a compact helper for
+* source procedures.
+*/
+function bindSourceProcedures(defaults) {
+	return (input) => createSourceProcedures({
+		...defaults,
+		...normalizeSourceOptions(input)
+	});
+}
+//#endregion
+export { list as C, resolveConnection as D, connectionArgs as E, withConnection as O, isDataView as S, toPrismaSelect as T, computed as _, refetchSourceById as a, dataView as b, resolveSourceConnection as c, createSourceDefinitions as d, createSourcePlan as f, attachComputedState as g, hasNestedSelection as h, createSourceRegistry as i, getScopedArgs as k, collectDataViewConfigs as l, getNestedSelection as m, createSourceProcedures as n, resolveSourceById as o, getDataViewSourceConfig as p, byIdInput as r, resolveSourceByIds as s, bindSourceProcedures as t, createNestedSourcePlan as u, count as v, resolver as w, field as x, createResolver as y };