@nkzw/fate 0.1.2 → 1.0.0-rc.0

package/lib/server/drizzle.mjs

@@ -0,0 +1,688 @@
+import { t as isRecord } from "../record-AeZJC9fd.mjs";
+import { O as withConnection, S as isDataView, c as resolveSourceConnection, d as createSourceDefinitions, f as createSourcePlan, g as attachComputedState, i as createSourceRegistry, l as collectDataViewConfigs, o as resolveSourceById, p as getDataViewSourceConfig, s as resolveSourceByIds, t as bindSourceProcedures } from "../sourceRouter-Bwpkr062.mjs";
+import { and, asc, createTableRelationsHelpers, desc, eq, extractTablesRelationalConfig, getTableColumns, gt, inArray, isTable, lt, normalizeRelation, or, sql } from "drizzle-orm";
+//#region src/server/drizzle.ts
+/**
+* Fate's Drizzle integration.
+*
+* @example
+* import { createDrizzleFate } from '@nkzw/fate/server/drizzle';
+*
+* @module @nkzw/fate/server/drizzle
+*/
+const resolveSource = (source) => typeof source === "function" ? source() : source;
+const isSourceDefinition = (target) => "view" in target && "id" in target;
+const getColumn = (columns, field) => {
+	const column = columns[field];
+	if (!column) throw new Error(`No Drizzle column registered for field ${field}.`);
+	return column;
+};
+const paginationArgs = (args) => ({
+	after: typeof args?.after === "string" ? args.after : void 0,
+	before: typeof args?.before === "string" ? args.before : void 0,
+	first: typeof args?.first === "number" ? args.first : void 0,
+	last: typeof args?.last === "number" ? args.last : void 0
+});
+const hasPagination = (args) => {
+	const value = paginationArgs(args);
+	return value.after !== void 0 || value.before !== void 0 || value.first !== void 0 || value.last !== void 0;
+};
+const getConnectionDirection = (args) => args?.before !== void 0 || typeof args?.last === "number" ? "backward" : "forward";
+const getConnectionSize = (fallback, args) => (typeof args?.first === "number" ? args.first : void 0) ?? (typeof args?.last === "number" ? args.last : void 0) ?? fallback;
+const buildConnection = ({ cursor, direction, items, pageSize }) => {
+	const hasMore = items.length > pageSize;
+	const connectionItems = (direction === "forward" ? items.slice(0, pageSize) : items.slice(-pageSize)).map((node) => ({
+		cursor: node.id,
+		node
+	}));
+	const firstItem = connectionItems[0];
+	const lastItem = connectionItems.at(-1);
+	return {
+		items: connectionItems,
+		pagination: {
+			hasNext: direction === "backward" ? Boolean(cursor) : hasMore,
+			hasPrevious: direction === "backward" ? hasMore : Boolean(cursor),
+			nextCursor: lastItem?.cursor,
+			previousCursor: (direction === "backward" ? hasMore : Boolean(cursor)) ? firstItem?.cursor : void 0
+		}
+	};
+};
+const mapByField = (items, field) => new Map(items.map((item) => [item[field], item]));
+const compactKeys = (values) => [...new Set(values.filter((value) => value !== null && value !== void 0))];
+const reorderByIds = (ids, items) => {
+	const itemsById = mapByField(items, "id");
+	return ids.flatMap((id) => {
+		const item = itemsById.get(id);
+		return item ? [item] : [];
+	});
+};
+const addColumnField = (fields, field) => {
+	if (!field || field === "cursor") return;
+	fields.add(field);
+};
+const addComputedSelectionColumns = (fields, select) => {
+	if (!select) return;
+	for (const selection of Object.values(select)) if (selection.kind === "field") {
+		const [field] = selection.path.split(".");
+		addColumnField(fields, field);
+	}
+};
+const getRequiredFields = (node, extraFields = []) => {
+	const fields = new Set(extraFields);
+	addColumnField(fields, node.source.id);
+	for (const field of node.selectedFields) addColumnField(fields, field);
+	for (const order of node.orderBy) addColumnField(fields, order.field);
+	for (const computed of node.computeds.values()) addComputedSelectionColumns(fields, computed.select);
+	for (const [field] of node.relations) {
+		const sourceRelation = node.source.relations?.[field];
+		if (sourceRelation) addColumnField(fields, sourceRelation.localKey);
+	}
+	return fields;
+};
+const compareColumn = (direction, naturalDirection, column, value) => {
+	const forward = naturalDirection === "asc" ? gt(column, value) : lt(column, value);
+	const backward = naturalDirection === "asc" ? lt(column, value) : gt(column, value);
+	return direction === "forward" ? forward : backward;
+};
+const buildCursorWhere = ({ columns, cursorValues, direction, node }) => {
+	const branches = node.orderBy.map((entry, index) => {
+		const column = getColumn(columns, entry.field);
+		const compare = compareColumn(direction, entry.direction, column, cursorValues[entry.field]);
+		const equalities = node.orderBy.slice(0, index).map((previous) => eq(getColumn(columns, previous.field), cursorValues[previous.field]));
+		return equalities.length ? and(...equalities, compare) : compare;
+	});
+	return branches.length === 1 ? branches[0] : or(...branches);
+};
+const getQueryOrder = (direction, node, columns) => node.orderBy.map((entry) => {
+	const column = getColumn(columns, entry.field);
+	return direction === "forward" ? entry.direction === "asc" ? asc(column) : desc(column) : entry.direction === "asc" ? desc(column) : asc(column);
+});
+const isSQLWrapper = (value) => isRecord(value) && typeof value.getSQL === "function";
+const whereFromCountSelection = (columns, where) => {
+	if (!where) return;
+	if (typeof where === "function") return where(columns);
+	if (isSQLWrapper(where)) return where;
+	if (Object.keys(where).length === 0) return;
+	const conditions = Object.entries(where).map(([field, value]) => eq(getColumn(columns, field), value));
+	return conditions.length === 1 ? conditions[0] : and(...conditions);
+};
+const toRegisteredConfig = (config) => ({
+	...config,
+	columns: config.columns ?? getTableColumns(config.table)
+});
+const lowerFirst = (value) => `${value.slice(0, 1).toLowerCase()}${value.slice(1)}`;
+const getColumnKey = (columns, column) => {
+	const entry = Object.entries(columns).find(([, candidate]) => candidate === column);
+	if (!entry) throw new Error(`Unable to resolve Drizzle column ${column.name}.`);
+	return entry[0];
+};
+const includesColumn = (columns, column) => Object.values(columns).includes(column);
+const getDrizzleSchemaMetadata = ({ db, schema }) => {
+	if (schema) {
+		const extracted = extractTablesRelationalConfig(schema, createTableRelationsHelpers);
+		return {
+			fullSchema: schema,
+			schema: extracted.tables,
+			tableNamesMap: extracted.tableNamesMap
+		};
+	}
+	if (typeof db === "function") return;
+	const metadata = db._;
+	return metadata?.schema && metadata.fullSchema && metadata.tableNamesMap ? {
+		fullSchema: metadata.fullSchema,
+		schema: metadata.schema,
+		tableNamesMap: metadata.tableNamesMap
+	} : void 0;
+};
+const getTableConfig = ({ config, metadata }) => {
+	const entry = Object.entries(metadata.fullSchema).find(([, table]) => table === config.table);
+	if (!entry) throw new Error(`No Drizzle schema metadata found for ${config.view.typeName}.`);
+	const tableConfig = metadata.schema[entry[0]];
+	if (!tableConfig) throw new Error(`No Drizzle relational config found for ${config.view.typeName}.`);
+	return tableConfig;
+};
+const getTableForView = (view, metadata) => {
+	const directTable = metadata.fullSchema[lowerFirst(view.typeName)];
+	if (isTable(directTable)) return directTable;
+	const tableConfig = Object.values(metadata.schema).find((config) => config.tsName === lowerFirst(view.typeName) || config.dbName === view.typeName || lowerFirst(config.dbName) === lowerFirst(view.typeName));
+	if (tableConfig) {
+		const table = metadata.fullSchema[tableConfig.tsName];
+		if (isTable(table)) return table;
+	}
+	throw new Error(`No Drizzle table found for view ${view.typeName}.`);
+};
+const isDrizzleViewConfig = (value) => isRecord(value) && isDataView(value.view) && isTable(value.table);
+const createDrizzleViewConfigs = ({ metadata, views }) => {
+	if (Array.isArray(views)) return views.map((view) => {
+		if (isDrizzleViewConfig(view)) return view;
+		if (!isDataView(view)) throw new Error(`Expected a data view or Drizzle view config.`);
+		if (!metadata) throw new Error(`Drizzle table for ${view.typeName} could not be inferred. Pass 'schema' to createDrizzleFate or use an explicit view config.`);
+		const config = getDataViewSourceConfig(view);
+		return {
+			...config,
+			table: getTableForView(config.view, metadata)
+		};
+	});
+	if (!metadata) throw new Error(`Drizzle tables could not be inferred. Pass 'schema' to createDrizzleFate or use explicit view configs.`);
+	return collectDataViewConfigs(views).map((config) => ({
+		...config,
+		table: getTableForView(config.view, metadata)
+	}));
+};
+const inferDirectRelation = ({ field, metadata, sourceConfig, targetConfig }) => {
+	const sourceTableConfig = getTableConfig({
+		config: sourceConfig,
+		metadata
+	});
+	const targetTableConfig = getTableConfig({
+		config: targetConfig,
+		metadata
+	});
+	const relation = sourceTableConfig.relations[field];
+	if (!relation) return null;
+	const normalized = normalizeRelation(metadata.schema, metadata.tableNamesMap, relation);
+	return {
+		foreignKey: getColumnKey(targetTableConfig.columns, normalized.references[0]),
+		localKey: getColumnKey(sourceTableConfig.columns, normalized.fields[0])
+	};
+};
+const inferManyToManyRelation = ({ field, metadata, sourceConfig, targetConfig }) => {
+	const sourceTableConfig = getTableConfig({
+		config: sourceConfig,
+		metadata
+	});
+	const targetTableConfig = getTableConfig({
+		config: targetConfig,
+		metadata
+	});
+	for (const joinTableConfig of Object.values(metadata.schema)) {
+		if (joinTableConfig === sourceTableConfig || joinTableConfig === targetTableConfig) continue;
+		let sourceJoin = null;
+		let targetJoin = null;
+		for (const relation of Object.values(joinTableConfig.relations)) {
+			let normalized;
+			try {
+				normalized = normalizeRelation(metadata.schema, metadata.tableNamesMap, relation);
+			} catch {
+				continue;
+			}
+			const fieldColumn = normalized.fields[0];
+			const referenceColumn = normalized.references[0];
+			if (!fieldColumn || !referenceColumn) continue;
+			if (includesColumn(sourceTableConfig.columns, referenceColumn)) sourceJoin = {
+				field: fieldColumn,
+				reference: referenceColumn
+			};
+			else if (includesColumn(targetTableConfig.columns, referenceColumn)) targetJoin = {
+				field: fieldColumn,
+				reference: referenceColumn
+			};
+		}
+		if (!sourceJoin || !targetJoin) continue;
+		const joinTable = metadata.fullSchema[joinTableConfig.tsName];
+		if (!isTable(joinTable)) continue;
+		sourceConfig.manyToMany = {
+			...sourceConfig.manyToMany,
+			[field]: sourceConfig.manyToMany?.[field] ?? joinTable
+		};
+		return {
+			foreignKey: getColumnKey(targetTableConfig.columns, targetJoin.reference),
+			localKey: getColumnKey(sourceTableConfig.columns, sourceJoin.reference),
+			through: {
+				foreignKey: getColumnKey(joinTableConfig.columns, targetJoin.field),
+				localKey: getColumnKey(joinTableConfig.columns, sourceJoin.field)
+			}
+		};
+	}
+	return null;
+};
+const resolveManyToManyConfig = ({ field, source, sourceRelation, through: throughInput }) => {
+	const through = isTable(throughInput) ? { table: throughInput } : throughInput;
+	if (through.localColumn && through.foreignColumn) return {
+		foreignColumn: through.foreignColumn,
+		localColumn: through.localColumn,
+		table: through.table
+	};
+	if (!sourceRelation.through) throw new Error(`Drizzle many-to-many relation ${source.view.typeName}.${field} requires source relation 'through' keys or explicit join columns.`);
+	const throughColumns = through.columns ?? getTableColumns(through.table);
+	return {
+		foreignColumn: getColumn(throughColumns, sourceRelation.through.foreignKey),
+		localColumn: getColumn(throughColumns, sourceRelation.through.localKey),
+		table: through.table
+	};
+};
+function createDrizzleSourceAdapter({ db, schema, views }) {
+	const metadata = getDrizzleSchemaMetadata({
+		db,
+		schema
+	});
+	const viewConfigs = createDrizzleViewConfigs({
+		metadata,
+		views
+	}).map((config) => ({
+		...config,
+		manyToMany: config.manyToMany ? { ...config.manyToMany } : void 0,
+		relations: config.relations ? { ...config.relations } : void 0
+	}));
+	const configsByView = new Map(viewConfigs.map((config) => [config.view, config]));
+	const configsByFields = new Map(viewConfigs.map((config) => [config.view.fields, config]));
+	const sourceDefinitions = createSourceDefinitions(viewConfigs, { resolveRelation: ({ config, field, kind, target }) => {
+		if (!metadata) return;
+		const targetConfig = configsByView.get(target.view) ?? configsByFields.get(target.view.fields);
+		if (!targetConfig) return;
+		return inferDirectRelation({
+			field,
+			metadata,
+			sourceConfig: config,
+			targetConfig
+		}) ?? (kind === "many" ? inferManyToManyRelation({
+			field,
+			metadata,
+			sourceConfig: config,
+			targetConfig
+		}) : void 0) ?? void 0;
+	} });
+	const sourcesByView = new Map(sourceDefinitions.map((source) => [source.view, source]));
+	const sourcesByFields = new Map(sourceDefinitions.map((source) => [source.view.fields, source]));
+	const sourceConfigs = new Map(viewConfigs.map((config, index) => [sourceDefinitions[index], {
+		...toRegisteredConfig(config),
+		source: sourceDefinitions[index]
+	}]));
+	const getSource = (target) => {
+		if (isSourceDefinition(target)) return target;
+		const source = sourcesByView.get(target) ?? sourcesByFields.get(target.fields);
+		if (!source) throw new Error(`No source registered for view ${target.typeName}.`);
+		return source;
+	};
+	const getSourceConfig = (source) => {
+		const config = sourceConfigs.get(source);
+		if (!config) throw new Error(`No Drizzle table registered for source ${source.view.typeName}.`);
+		return config;
+	};
+	const getDb = (ctx) => {
+		if (typeof db === "function") return db(ctx);
+		return db;
+	};
+	const buildSelection = (node, extraFields = []) => {
+		const config = getSourceConfig(node.source);
+		const selection = {};
+		for (const field of getRequiredFields(node, extraFields)) selection[field] = getColumn(config.columns, field);
+		return selection;
+	};
+	const queryRows = async ({ ctx, extraFields, node, where }) => {
+		const config = getSourceConfig(node.source);
+		return await getDb(ctx).select(buildSelection(node, extraFields)).from(config.table).where(where).orderBy(...getQueryOrder("forward", node, config.columns));
+	};
+	const queryNodePage = async ({ baseWhere, ctx, cursor, direction, node, take }) => {
+		const config = getSourceConfig(node.source);
+		const currentDb = getDb(ctx);
+		let whereClause = baseWhere;
+		if (cursor) {
+			const cursorSelection = Object.fromEntries(node.orderBy.map((entry) => [entry.field, getColumn(config.columns, entry.field)]));
+			const [cursorRow] = await currentDb.select(cursorSelection).from(config.table).where(baseWhere ? and(baseWhere, eq(getColumn(config.columns, node.source.id), cursor)) : eq(getColumn(config.columns, node.source.id), cursor)).limit(1);
+			if (cursorRow) {
+				const cursorWhere = buildCursorWhere({
+					columns: config.columns,
+					cursorValues: cursorRow,
+					direction,
+					node
+				});
+				whereClause = whereClause ? and(whereClause, cursorWhere) : cursorWhere;
+			}
+		}
+		const rows = await currentDb.select(buildSelection(node)).from(config.table).where(whereClause).orderBy(...getQueryOrder(direction, node, config.columns)).limit(take);
+		return direction === "backward" ? rows.reverse() : rows;
+	};
+	const attachComputedCounts = async (items, node, ctx) => {
+		if (items.length === 0) return;
+		for (const [field, computed] of node.computeds) {
+			if (!computed.select) continue;
+			for (const [selectionName, selection] of Object.entries(computed.select)) {
+				if (selection.kind !== "count") continue;
+				const sourceRelation = node.source.relations?.[selection.relation];
+				if (!sourceRelation || sourceRelation.kind !== "many" && sourceRelation.kind !== "manyToMany") throw new Error(`Computed count ${node.source.view.typeName}.${field} requires a collection relation named ${selection.relation}.`);
+				const parentKeys = compactKeys(items.map((item) => item[sourceRelation.localKey]));
+				if (parentKeys.length === 0) continue;
+				const childConfig = getSourceConfig(resolveSource(sourceRelation.source));
+				let rows;
+				if (sourceRelation.kind === "manyToMany") {
+					const throughConfig = getSourceConfig(node.source).manyToMany?.[selection.relation];
+					if (!throughConfig) throw new Error(`No Drizzle many-to-many table registered for ${node.source.view.typeName}.${selection.relation}.`);
+					const through = resolveManyToManyConfig({
+						field: selection.relation,
+						source: node.source,
+						sourceRelation,
+						through: throughConfig
+					});
+					rows = await getDb(ctx).select({
+						count: sql`count(*)`.mapWith(Number),
+						parentKey: through.localColumn
+					}).from(through.table).innerJoin(childConfig.table, eq(through.foreignColumn, getColumn(childConfig.columns, sourceRelation.foreignKey))).where(and(inArray(through.localColumn, parentKeys), whereFromCountSelection(childConfig.columns, selection.where))).groupBy(through.localColumn);
+				} else {
+					const parentKeyColumn = getColumn(childConfig.columns, sourceRelation.foreignKey);
+					rows = await getDb(ctx).select({
+						count: sql`count(*)`.mapWith(Number),
+						parentKey: parentKeyColumn
+					}).from(childConfig.table).where(and(inArray(parentKeyColumn, parentKeys), whereFromCountSelection(childConfig.columns, selection.where))).groupBy(parentKeyColumn);
+				}
+				const counts = new Map(rows.map((row) => [row.parentKey, row.count]));
+				for (const item of items) attachComputedState(item, field, { [selectionName]: counts.get(item[sourceRelation.localKey]) ?? 0 });
+			}
+		}
+	};
+	const fetchManyRelation = async ({ ctx, items, relationNode, sourceRelation }) => {
+		const childConfig = getSourceConfig(resolveSource(sourceRelation.source));
+		const parentKeys = compactKeys(items.map((item) => item[sourceRelation.localKey]));
+		if (parentKeys.length === 0) return /* @__PURE__ */ new Map();
+		const hydrated = await hydrateRows(await queryRows({
+			ctx,
+			extraFields: [sourceRelation.foreignKey],
+			node: relationNode,
+			where: inArray(getColumn(childConfig.columns, sourceRelation.foreignKey), parentKeys)
+		}), relationNode, ctx);
+		const byParentKey = /* @__PURE__ */ new Map();
+		for (const item of hydrated) {
+			const key = item[sourceRelation.foreignKey];
+			const entries = byParentKey.get(key) ?? [];
+			entries.push(item);
+			byParentKey.set(key, entries);
+		}
+		return byParentKey;
+	};
+	const fetchManyConnection = async (parentKey, relationNode, sourceRelation, ctx) => {
+		const childConfig = getSourceConfig(resolveSource(sourceRelation.source));
+		const args = paginationArgs(relationNode.args);
+		const direction = getConnectionDirection(args);
+		const pageSize = getConnectionSize(20, args);
+		const cursor = direction === "forward" ? args.after : args.before;
+		if (parentKey === null || parentKey === void 0) return buildConnection({
+			cursor,
+			direction,
+			items: [],
+			pageSize
+		});
+		return buildConnection({
+			cursor,
+			direction,
+			items: await hydrateRows(await queryNodePage({
+				baseWhere: eq(getColumn(childConfig.columns, sourceRelation.foreignKey), parentKey),
+				ctx,
+				cursor,
+				direction,
+				node: relationNode,
+				take: pageSize + 1
+			}), relationNode, ctx),
+			pageSize
+		});
+	};
+	const queryManyToManyPage = async ({ ctx, cursor, direction, node, parentKey, sourceRelation, take, through }) => {
+		const childConfig = getSourceConfig(resolveSource(sourceRelation.source));
+		const currentDb = getDb(ctx);
+		let whereClause = eq(through.localColumn, parentKey);
+		if (cursor) {
+			const cursorSelection = Object.fromEntries(node.orderBy.map((entry) => [entry.field, getColumn(childConfig.columns, entry.field)]));
+			const [cursorRow] = await currentDb.select(cursorSelection).from(through.table).innerJoin(childConfig.table, eq(through.foreignColumn, getColumn(childConfig.columns, sourceRelation.foreignKey))).where(and(eq(through.localColumn, parentKey), eq(getColumn(childConfig.columns, node.source.id), cursor))).limit(1);
+			if (cursorRow) whereClause = and(whereClause, buildCursorWhere({
+				columns: childConfig.columns,
+				cursorValues: cursorRow,
+				direction,
+				node
+			}));
+		}
+		const rows = await currentDb.select({
+			...buildSelection(node),
+			parentKey: through.localColumn
+		}).from(through.table).innerJoin(childConfig.table, eq(through.foreignColumn, getColumn(childConfig.columns, sourceRelation.foreignKey))).where(whereClause).orderBy(...getQueryOrder(direction, node, childConfig.columns)).limit(take);
+		return direction === "backward" ? rows.reverse() : rows;
+	};
+	const fetchManyToManyConnection = async (parentKey, relationNode, sourceRelation, through, ctx) => {
+		const args = paginationArgs(relationNode.args);
+		const direction = getConnectionDirection(args);
+		const pageSize = getConnectionSize(20, args);
+		const cursor = direction === "forward" ? args.after : args.before;
+		if (parentKey === null || parentKey === void 0) return buildConnection({
+			cursor,
+			direction,
+			items: [],
+			pageSize
+		});
+		return buildConnection({
+			cursor,
+			direction,
+			items: await hydrateRows(await queryManyToManyPage({
+				ctx,
+				cursor,
+				direction,
+				node: relationNode,
+				parentKey,
+				sourceRelation,
+				take: pageSize + 1,
+				through
+			}), relationNode, ctx),
+			pageSize
+		});
+	};
+	const fetchManyToManyRelation = async ({ ctx, items, node, relationField, relationNode, sourceRelation }) => {
+		const parentConfig = getSourceConfig(node.source);
+		const childConfig = getSourceConfig(resolveSource(sourceRelation.source));
+		const throughConfig = parentConfig.manyToMany?.[relationField];
+		if (!throughConfig) throw new Error(`No Drizzle many-to-many table registered for ${node.source.view.typeName}.${relationField}.`);
+		const through = resolveManyToManyConfig({
+			field: relationField,
+			source: node.source,
+			sourceRelation,
+			through: throughConfig
+		});
+		const parentKeys = compactKeys(items.map((item) => item[sourceRelation.localKey]));
+		if (parentKeys.length === 0) return /* @__PURE__ */ new Map();
+		const hydrated = await hydrateRows(await getDb(ctx).select({
+			...buildSelection(relationNode),
+			parentKey: through.localColumn
+		}).from(through.table).innerJoin(childConfig.table, eq(through.foreignColumn, getColumn(childConfig.columns, sourceRelation.foreignKey))).where(inArray(through.localColumn, parentKeys)).orderBy(...getQueryOrder("forward", relationNode, childConfig.columns)), relationNode, ctx);
+		const byParentKey = /* @__PURE__ */ new Map();
+		for (const item of hydrated) {
+			const entries = byParentKey.get(item.parentKey) ?? [];
+			entries.push(item);
+			byParentKey.set(item.parentKey, entries);
+		}
+		return byParentKey;
+	};
+	const hydrateRows = async (rows, node, ctx) => {
+		const items = rows.map((row) => ({ ...row }));
+		await attachComputedCounts(items, node, ctx);
+		for (const [field, relationNode] of node.relations) {
+			const sourceRelation = node.source.relations?.[field];
+			if (!sourceRelation) continue;
+			if (sourceRelation.kind === "one") {
+				const childConfig = getSourceConfig(resolveSource(sourceRelation.source));
+				const childKeys = compactKeys(items.map((item) => item[sourceRelation.localKey]));
+				const childByKey = mapByField(await hydrateRows(childKeys.length ? await queryRows({
+					ctx,
+					node: relationNode,
+					where: inArray(getColumn(childConfig.columns, sourceRelation.foreignKey), childKeys)
+				}) : [], relationNode, ctx), sourceRelation.foreignKey);
+				for (const item of items) {
+					const localKey = item[sourceRelation.localKey];
+					item[field] = localKey !== null && localKey !== void 0 ? childByKey.get(localKey) ?? null : null;
+				}
+				continue;
+			}
+			if (sourceRelation.kind === "manyToMany") {
+				const throughConfig = getSourceConfig(node.source).manyToMany?.[field];
+				if (!throughConfig) throw new Error(`No Drizzle many-to-many table registered for ${node.source.view.typeName}.${field}.`);
+				const through = resolveManyToManyConfig({
+					field,
+					source: node.source,
+					sourceRelation,
+					through: throughConfig
+				});
+				if (hasPagination(relationNode.args)) {
+					const connections = await Promise.all(items.map(async (item) => [item[sourceRelation.localKey], await fetchManyToManyConnection(item[sourceRelation.localKey], relationNode, sourceRelation, through, ctx)]));
+					const connectionByParentKey = new Map(connections);
+					for (const item of items) item[field] = connectionByParentKey.get(item[sourceRelation.localKey]);
+					continue;
+				}
+				const byParentKey = await fetchManyToManyRelation({
+					ctx,
+					items,
+					node,
+					relationField: field,
+					relationNode,
+					sourceRelation
+				});
+				for (const item of items) item[field] = byParentKey.get(item[sourceRelation.localKey]) ?? [];
+				continue;
+			}
+			if (hasPagination(relationNode.args)) {
+				const connections = await Promise.all(items.map(async (item) => [item[sourceRelation.localKey], await fetchManyConnection(item[sourceRelation.localKey], relationNode, sourceRelation, ctx)]));
+				const connectionByParentKey = new Map(connections);
+				for (const item of items) item[field] = connectionByParentKey.get(item[sourceRelation.localKey]);
+				continue;
+			}
+			const byParentKey = await fetchManyRelation({
+				ctx,
+				items,
+				relationNode,
+				sourceRelation
+			});
+			for (const item of items) item[field] = byParentKey.get(item[sourceRelation.localKey]) ?? [];
+		}
+		return items;
+	};
+	const fetchByIds = async ({ ctx, extra, ids, plan }) => {
+		if (!ids.length) return [];
+		const config = getSourceConfig(plan.source);
+		return reorderByIds(ids, await hydrateRows(await queryRows({
+			ctx,
+			extraFields: extra?.extraFields,
+			node: plan.root,
+			where: inArray(getColumn(config.columns, plan.source.id), [...new Set(ids)])
+		}), plan.root, ctx));
+	};
+	const fetchById = async ({ ctx, extra, id, plan }) => (await fetchByIds({
+		ctx,
+		extra,
+		ids: [id],
+		plan
+	}))[0] ?? null;
+	const fetchConnection = async ({ ctx, cursor, direction, extra, plan, take }) => hydrateRows(await queryNodePage({
+		baseWhere: extra?.where,
+		ctx,
+		cursor,
+		direction,
+		node: plan.root,
+		take
+	}), plan.root, ctx);
+	const registry = createSourceRegistry(sourceDefinitions.map((source) => [source, {
+		byId: ({ ctx, extra, id, plan }) => fetchById({
+			ctx,
+			extra,
+			id,
+			plan
+		}),
+		byIds: ({ ctx, extra, ids, plan }) => fetchByIds({
+			ctx,
+			extra,
+			ids,
+			plan
+		}),
+		connection: ({ ctx, cursor, direction, extra, plan, take }) => fetchConnection({
+			ctx,
+			cursor,
+			direction,
+			extra,
+			plan,
+			take
+		})
+	}]));
+	return {
+		fetchById,
+		fetchByIds,
+		fetchConnection,
+		getSource,
+		registry,
+		resolveById: ({ ctx, extra, id, input, view }) => resolveSourceById({
+			ctx,
+			extra,
+			id,
+			input,
+			registry,
+			source: getSource(view)
+		}),
+		resolveByIds: ({ ctx, extra, ids, input, view }) => resolveSourceByIds({
+			ctx,
+			extra,
+			ids,
+			input,
+			registry,
+			source: getSource(view)
+		}),
+		resolveConnection: ({ ctx, cursor, direction, extra, input, skip, take, view }) => resolveSourceConnection({
+			ctx,
+			cursor,
+			direction,
+			extra,
+			input,
+			registry,
+			skip,
+			source: getSource(view),
+			take
+		})
+	};
+}
+const createDrizzleSourceRegistry = (options) => createDrizzleSourceAdapter(options).registry;
+function createDrizzleFate({ procedure, ...options }) {
+	const adapter = createDrizzleSourceAdapter(options);
+	const connection = withConnection(procedure);
+	const procedures = bindSourceProcedures({
+		createConnectionProcedure: connection,
+		procedure,
+		registry: adapter.registry
+	});
+	return {
+		...adapter,
+		connection,
+		createPlan: ({ args, ctx, select, view }) => createSourcePlan({
+			args,
+			ctx,
+			select,
+			source: adapter.getSource(view)
+		}),
+		procedures: (input) => {
+			const procedureInput = input;
+			return procedures(procedureInput && typeof procedureInput === "object" && "view" in procedureInput ? {
+				...procedureInput,
+				source: adapter.getSource(procedureInput.view)
+			} : adapter.getSource(input));
+		},
+		resolveById: ({ ctx, extra, id, input, view }) => resolveSourceById({
+			ctx,
+			extra,
+			id,
+			input,
+			registry: adapter.registry,
+			source: adapter.getSource(view)
+		}),
+		resolveByIds: ({ ctx, extra, ids, input, view }) => resolveSourceByIds({
+			ctx,
+			extra,
+			ids,
+			input,
+			registry: adapter.registry,
+			source: adapter.getSource(view)
+		}),
+		resolveConnection: ({ ctx, cursor, direction, extra, input, skip, take, view }) => resolveSourceConnection({
+			ctx,
+			cursor,
+			direction,
+			extra,
+			input,
+			registry: adapter.registry,
+			skip,
+			source: adapter.getSource(view),
+			take
+		})
+	};
+}
+//#endregion
+export { createDrizzleFate, createDrizzleSourceAdapter, createDrizzleSourceRegistry };