@nkzw/fate 0.0.7 → 0.1.0

package/lib/cli.mjs

@@ -7,11 +7,11 @@ import { styleText } from "node:util";
 const isDataViewField = (field) => Boolean(field) && typeof field === "object" && "fields" in field;
 /**
 * Builds the schema object used by the CLI generator from your data views and
-* list resolver configs.
+* root resolver configs.
 */
-const createSchema = (dataViews, lists) => {
+const createSchema = (dataViews, roots) => {
 	const canonicalViews = /* @__PURE__ */ new Map();
-	const entities = {};
+	const rootSchema = {};
 	const fateTypes = /* @__PURE__ */ new Map();
 	const processing = /* @__PURE__ */ new Set();
 	const ensureType = (view) => {
@@ -36,20 +36,25 @@ const createSchema = (dataViews, lists) => {
 		const typeName = view.typeName;
 		if (!typeName) throw new Error("Data view is missing a type name.");
 		if (!canonicalViews.has(typeName)) canonicalViews.set(typeName, view);
-		entities[typeName.toLowerCase()] = { type: typeName };
 	}
-	for (const [name, list] of Object.entries(lists)) {
-		const config = "fields" in list ? { view: list } : list;
-		const typeName = ensureType(config.view);
-		entities[typeName.toLowerCase()] = {
-			list: name,
-			listProcedure: config.procedure,
-			type: typeName
+	for (const view of dataViews) ensureType(view);
+	for (const [name, root$1] of Object.entries(roots)) {
+		const config = "fields" in root$1 ? { view: root$1 } : root$1;
+		const view = config.view;
+		const type = ensureType(view);
+		if (!view.typeName) throw new Error(`Root "${name}" is missing a data view.`);
+		const router = config.router ?? view.typeName[0]?.toLowerCase() + view.typeName.slice(1);
+		if (!router) throw new Error(`Root "${name}" is missing a router name.`);
+		rootSchema[name] = {
+			kind: view.kind === "list" ? "list" : "query",
+			procedure: config.procedure ?? (view.kind === "list" ? "list" : name),
+			router,
+			type
 		};
 	}
 	for (const view of dataViews) ensureType(view);
 	return {
-		entities,
+		roots: rootSchema,
 		types: Array.from(fateTypes.values())
 	};
 };
@@ -89,21 +94,29 @@ const formatTypes = (types) => {
 const indentBlock = (value, spaces) => value.split("\n").map((line) => line.length ? `${" ".repeat(spaces)}${line}` : line).join("\n");
 const generate = async () => {
 	console.log(styleText("bold", `Generating fate client…\n`));
-	const { appRouter, Lists, ...dataViews } = await import(moduleName);
-	const { entities, types } = createSchema(Object.values(dataViews), Lists);
+	const { appRouter, Root, ...dataViews } = await import(moduleName);
+	const { roots, types } = createSchema(Object.values(dataViews), Root ?? {});
 	const routerRecord = appRouter._def?.record ?? {};
 	const mutationEntries = [];
 	const byIdEntries = [];
 	const listEntries = [];
+	const queryEntries = [];
+	const rootsByRouter = /* @__PURE__ */ new Map();
+	for (const entry of Object.entries(roots)) {
+		const list = rootsByRouter.get(entry[1].router) ?? [];
+		list.push(entry);
+		rootsByRouter.set(entry[1].router, list);
+	}
 	for (const [router, procedures] of Object.entries(routerRecord)) {
-		const entity = entities[router];
-		if (!entity) continue;
+		const routerRoots = rootsByRouter.get(router);
+		if (!routerRoots?.length) continue;
+		const entityType = routerRoots[0][1].type;
 		for (const [procedureName, procedure] of Object.entries(procedures)) {
 			const type = procedure?._def?.type;
 			if (!type) continue;
 			if (type === "mutation") {
 				mutationEntries.push({
-					entityType: entity.type,
+					entityType,
 					name: `${router}.${procedureName}`,
 					procedure: procedureName,
 					router
@@ -112,22 +125,53 @@ const generate = async () => {
 			}
 			if (procedureName === "byId" && type === "query") {
 				byIdEntries.push({
-					entityType: entity.type,
+					entityType,
 					router
 				});
 				continue;
 			}
-			const listProcedure = entity.listProcedure ?? "list";
-			if (procedureName === listProcedure && type === "query" && entity.list) listEntries.push({
-				list: entity.list,
-				procedure: listProcedure,
-				router
-			});
+			for (const [queryName, root$1] of routerRoots) {
+				if (root$1.kind !== "query") continue;
+				if (procedureName === root$1.procedure && type === "query") queryEntries.push({
+					name: queryName,
+					procedure: root$1.procedure,
+					router,
+					type: root$1.type
+				});
+			}
+			for (const [listName, root$1] of routerRoots) {
+				if (root$1.kind !== "list") continue;
+				if (procedureName === root$1.procedure && type === "query") listEntries.push({
+					list: listName,
+					procedure: root$1.procedure,
+					router,
+					type: root$1.type
+				});
+			}
 		}
 	}
 	mutationEntries.sort((a, b) => a.name.localeCompare(b.name));
 	byIdEntries.sort((a, b) => a.entityType.localeCompare(b.entityType));
+	queryEntries.sort((a, b) => a.name.localeCompare(b.name));
 	listEntries.sort((a, b) => a.list.localeCompare(b.list));
+	const rootEntries = [
+		...byIdEntries.map(({ entityType, router }) => ({
+			name: router,
+			type: entityType,
+			value: `'${router}': clientRoot<RouterOutputs['${router}']['byId'], '${entityType}'>('${entityType}'),`
+		})),
+		...queryEntries.map(({ name, procedure, router, type }) => ({
+			name,
+			type,
+			value: `'${name}': clientRoot<RouterOutputs['${router}']['${procedure}'], '${type}'>('${type}'),`
+		})),
+		...listEntries.map(({ list, procedure, router, type }) => ({
+			name: list,
+			type,
+			value: `'${list}': clientRoot<RouterOutputs['${router}']['${procedure}'], '${type}'>('${type}'),`
+		}))
+	];
+	rootEntries.sort((a, b) => a.name.localeCompare(b.name));
 	const viewTypes = Array.from(["AppRouter", ...new Set(mutationEntries.map((entry) => entry.entityType))]).sort();
 	const mutationResolverLines = mutationEntries.map(({ name, procedure, router }) => `'${name}': (client: TRPCClientType) => client.${router}.${procedure}.mutate,`);
 	const mutationConfigLines = mutationEntries.map(({ entityType, name, procedure, router }) => `'${name}': mutation<
@@ -146,17 +190,21 @@ const generate = async () => {
     select,
   }),`);
 	const listLines = listEntries.map(({ list, procedure, router }) => `${list}: (client: TRPCClientType) => client.${router}.${procedure}.query,`);
+	const queryLines = queryEntries.map(({ name, procedure, router }) => `${name}: (client: TRPCClientType) => client.${router}.${procedure}.query,`);
 	const typeImports = `import type { ${viewTypes.join(", ")} } from '${moduleName}';`;
 	const typesBlock = indentBlock(formatTypes(types), 6);
 	const mutationResolverBlock = indentBlock(mutationResolverLines.join("\n"), 4);
 	const mutationConfigBlock = indentBlock(mutationConfigLines.join("\n"), 2);
 	const byIdBlock = indentBlock(byIdLines.join("\n"), 8);
+	const rootsBlock = indentBlock(rootEntries.map((entry) => entry.value).join("\n"), 2);
 	const listsBlockContent = listLines.join("\n");
+	const listsBlock = listLines.length ? `      lists: {\n${indentBlock(listsBlockContent, 8)}\n      },\n` : "";
+	const queriesBlockContent = queryLines.join("\n");
 	const source = `// @generated by \`pnpm fate generate\`
 ${typeImports}
 import { createTRPCProxyClient } from '@trpc/client';
 import { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import { createClient, createTRPCTransport, mutation } from 'react-fate';
+import { clientRoot, createClient, createTRPCTransport, mutation } from 'react-fate';
 
 type TRPCClientType = ReturnType<typeof createTRPCProxyClient<AppRouter>>;
 type RouterInputs = inferRouterInputs<AppRouter>;
@@ -166,10 +214,16 @@ const mutations = {
 ${mutationConfigBlock}
 } as const;
 
+const roots = {
+${rootsBlock}
+} as const;
+
 type GeneratedClientMutations = typeof mutations;
+type GeneratedClientRoots = typeof roots;
 
 declare module 'react-fate' {
   interface ClientMutations extends GeneratedClientMutations {}
+  interface ClientRoots extends GeneratedClientRoots {}
 }
 
 export const createFateClient = (options: {
@@ -181,14 +235,15 @@ export const createFateClient = (options: {
 ${mutationResolverBlock}
   } as const;
 
-  return createClient({
+  return createClient<[GeneratedClientRoots, GeneratedClientMutations]>({
     mutations,
+    roots,
     transport: createTRPCTransport<AppRouter, typeof trpcMutations>({
       byId: {
 ${byIdBlock}
       },
       client: trpcClient,
-${listLines.length ? `      lists: {\n${indentBlock(listsBlockContent, 8)}\n      },\n` : ""}      mutations: trpcMutations,
+${queryLines.length ? `      queries: {\n${indentBlock(queriesBlockContent, 8)}\n      },\n` : ""}${listsBlock}      mutations: trpcMutations,
     }),
     types: ${typesBlock.trimStart()},
   });