@nkzw/fate 0.1.2 → 1.0.0-rc.0

package/lib/cli.mjs

@@ -1,259 +1,26 @@
 #!/usr/bin/env node
-import { writeFileSync } from "node:fs";
 import path from "node:path";
+import process from "node:process";
 import { styleText } from "node:util";
-
-//#region src/codegen/schema.ts
-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
-* root resolver configs.
-*/
-const createSchema = (dataViews, roots) => {
-	const canonicalViews = /* @__PURE__ */ new Map();
-	const rootSchema = {};
-	const fateTypes = /* @__PURE__ */ new Map();
-	const processing = /* @__PURE__ */ new Set();
-	const ensureType = (view) => {
-		const typeName = view.typeName;
-		const canonicalView = canonicalViews.get(typeName) ?? view;
-		const existing = fateTypes.get(typeName);
-		if (existing && !processing.has(typeName)) return typeName;
-		if (processing.has(typeName)) return typeName;
-		processing.add(typeName);
-		const fields = existing?.fields ?? {};
-		for (const [field, child] of Object.entries(canonicalView.fields)) if (isDataViewField(child)) {
-			const relationType = ensureType(child);
-			fields[field] = child.kind === "list" ? { listOf: relationType } : { type: relationType };
-		}
-		const descriptor = { type: typeName };
-		if (Object.keys(fields).length) descriptor.fields = fields;
-		fateTypes.set(typeName, descriptor);
-		processing.delete(typeName);
-		return typeName;
-	};
-	for (const view of dataViews) {
-		const typeName = view.typeName;
-		if (!typeName) throw new Error("Data view is missing a type name.");
-		if (!canonicalViews.has(typeName)) canonicalViews.set(typeName, view);
-	}
-	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 {
-		roots: rootSchema,
-		types: Array.from(fateTypes.values())
-	};
-};
-
-//#endregion
+import { resolveConfig } from "vite";
 //#region src/cli.ts
-const root = process.cwd();
-const [, , command, moduleName, targetFile] = process.argv;
-if (command !== "generate" || !moduleName || !targetFile) {
-	console.error(`${styleText("bold", "Usage:")} ${styleText("blue", `pnpm fate generate <moduleName> <targetFile>`)}
+const clientModuleId = "\0@nkzw/fate/client.ts";
+const usage = (message) => {
+	if (message) process.stderr.write(`${styleText("red", message)}\n\n`);
+	process.stderr.write(`${styleText("bold", "Usage:")} ${styleText("blue", "fate generate")}
 
-Generates the fate client from the server's tRPC router.
-
-  ${styleText("dim", "<moduleName>")}  The module name to import the tRPC router from.
-  ${styleText("dim", "<targetFile>")}  The file path to write the generated client to.
-  
-  ${styleText("bold", "Example:")} ${styleText("blue", `pnpm fate generate @org/server/trpc/router.ts client/lib/fate.ts`)}
+Generates fate client files from the fate plugin in ./vite.config.ts.
 `);
 	process.exit(1);
-}
-const formatRelation = (value) => "listOf" in value ? `{ listOf: '${value.listOf}' }` : `{ type: '${value.type}' }`;
-const formatTypes = (types) => {
-	if (!types.length) return "[]";
-	const lines = ["["];
-	for (const typeConfig of types) {
-		lines.push("  {");
-		if (typeConfig.fields) {
-			lines.push("    fields: {");
-			for (const [field, relation] of Object.entries(typeConfig.fields)) lines.push(`      ${field}: ${formatRelation(relation)},`);
-			lines.push("    },");
-		}
-		lines.push(`    type: '${typeConfig.type}',`, "  },");
-	}
-	lines.push("]");
-	return lines.join("\n");
-};
-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, 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 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,
-					name: `${router}.${procedureName}`,
-					procedure: procedureName,
-					router
-				});
-				continue;
-			}
-			if (procedureName === "byId" && type === "query") {
-				byIdEntries.push({
-					entityType,
-					router
-				});
-				continue;
-			}
-			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<
-  ${entityType},
-  RouterInputs['${router}']['${procedure}'],
-  RouterOutputs['${router}']['${procedure}']
->('${entityType}'),`);
-	const byIdLines = byIdEntries.map(({ entityType, router }) => `${entityType}: (client: TRPCClientType) => ({
-  args,
-  ids,
-  select,
-}: { args?: Record<string, unknown>; ids: Array<string | number>; select: Array<string> }) =>
-  client.${router}.byId.query({
-    args,
-    ids: ids.map(String),
-    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 { clientRoot, createClient, createTRPCTransport, mutation } from 'react-fate';
-
-type TRPCClientType = ReturnType<typeof createTRPCProxyClient<AppRouter>>;
-type RouterInputs = inferRouterInputs<AppRouter>;
-type RouterOutputs = inferRouterOutputs<AppRouter>;
-
-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: {
-  links: Parameters<typeof createTRPCProxyClient>[0]['links'];
-}) => {
-  const trpcClient = createTRPCProxyClient<AppRouter>(options);
-
-  const trpcMutations = {
-${mutationResolverBlock}
-  } as const;
-
-  return createClient<[GeneratedClientRoots, GeneratedClientMutations]>({
-    mutations,
-    roots,
-    transport: createTRPCTransport<AppRouter, typeof trpcMutations>({
-      byId: {
-${byIdBlock}
-      },
-      client: trpcClient,
-${queryLines.length ? `      queries: {\n${indentBlock(queriesBlockContent, 8)}\n      },\n` : ""}${listsBlock}      mutations: trpcMutations,
-    }),
-    types: ${typesBlock.trimStart()},
-  });
 };
-`;
-	const outputPath = path.join(root, targetFile);
-	writeFileSync(outputPath, source);
-	console.log(styleText("green", `  \u2713 fate client generated at '${path.relative(root, outputPath)}'.`));
-};
-await generate();
-
+const [command, ...args] = process.argv.slice(2);
+if (command !== "generate" || args.length > 0) usage();
+const configFile = path.join(process.cwd(), "vite.config.ts");
+const plugin = (await resolveConfig({ configFile }, "serve")).plugins.find((candidate) => candidate.name === "@nkzw/fate");
+const load = plugin?.load;
+const loadContext = {};
+const result = typeof load === "function" ? await load.call(loadContext, clientModuleId) : typeof load?.handler === "function" ? await load.handler.call(loadContext, clientModuleId) : null;
+if (!plugin || result == null) usage(`No fate plugin found in '${path.relative(process.cwd(), configFile)}'.`);
+process.stdout.write(styleText("green", `  fate client generated.\n`));
 //#endregion
-export {  };
+export {};

package/lib/clientStub.d.mts

@@ -0,0 +1,6 @@
+//#region src/clientStub.d.ts
+declare function createFateClient(..._args: Array<never>): never;
+interface ClientMutations {}
+interface ClientRoots {}
+//#endregion
+export { ClientMutations, ClientRoots, createFateClient };

package/lib/clientStub.mjs

@@ -0,0 +1,6 @@
+//#region src/clientStub.ts
+function createFateClient(..._args) {
+	throw new Error(`@nkzw/fate/client is generated by the fate Vite plugin. Add fate({ module: '...' }) to your Vite config.`);
+}
+//#endregion
+export { createFateClient };