@nkzw/fate 0.0.1

package/lib/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/lib/cli.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+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
+* list resolver configs.
+*/
+const createFateSchema = (dataViews, lists) => {
+	const canonicalViews = /* @__PURE__ */ new Map();
+	const entities = {};
+	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);
+		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
+		};
+	}
+	return {
+		entities,
+		types: Array.from(fateTypes.values())
+	};
+};
+
+//#endregion
+//#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>`)}
+
+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.generated.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, Lists, ...dataViews }] = await Promise.all([import(moduleName)]);
+	const { entities, types } = createFateSchema(Object.values(dataViews), Lists);
+	const routerRecord = appRouter._def?.record ?? {};
+	const mutationEntries = [];
+	const byIdEntries = [];
+	const listEntries = [];
+	for (const [router, procedures] of Object.entries(routerRecord)) {
+		const entity = entities[router];
+		if (!entity) continue;
+		for (const [procedureName, procedure] of Object.entries(procedures)) {
+			const type = procedure?._def?.type;
+			if (!type) continue;
+			if (type === "mutation") {
+				mutationEntries.push({
+					entityType: entity.type,
+					name: `${router}.${procedureName}`,
+					procedure: procedureName,
+					router
+				});
+				continue;
+			}
+			if (procedureName === "byId" && type === "query") {
+				byIdEntries.push({
+					entityType: entity.type,
+					router
+				});
+				continue;
+			}
+			const listProcedure = entity.listProcedure ?? "list";
+			if (procedureName === listProcedure && type === "query" && entity.list) listEntries.push({
+				list: entity.list,
+				procedure: listProcedure,
+				router
+			});
+		}
+	}
+	mutationEntries.sort((a, b) => a.name.localeCompare(b.name));
+	byIdEntries.sort((a, b) => a.entityType.localeCompare(b.entityType));
+	listEntries.sort((a, b) => a.list.localeCompare(b.list));
+	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 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"), 6);
+	const byIdBlock = indentBlock(byIdLines.join("\n"), 8);
+	const listsBlockContent = listLines.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';
+
+type TRPCClientType = ReturnType<typeof createTRPCProxyClient<AppRouter>>;
+type RouterInputs = inferRouterInputs<AppRouter>;
+type RouterOutputs = inferRouterOutputs<AppRouter>;
+
+export const createFateClient = (options: {
+  links: Parameters<typeof createTRPCProxyClient>[0]['links'];
+}) => {
+  const trpcClient = createTRPCProxyClient<AppRouter>(options);
+
+  const mutations = {
+${mutationResolverBlock}
+  } as const;
+
+  return createClient({
+    mutations: {
+${mutationConfigBlock}
+    },
+    transport: createTRPCTransport<AppRouter, typeof mutations>({
+      byId: {
+${byIdBlock}
+      },
+      client: trpcClient,
+${listLines.length ? `      lists: {\n${indentBlock(listsBlockContent, 8)}\n      },\n` : ""}      mutations,
+    }),
+    types: ${typesBlock},
+  });
+};
+`;
+	const outputPath = path.join(root, targetFile);
+	writeFileSync(outputPath, source);
+	console.log(styleText("green", `  \u2713 fate client generated at '${path.relative(root, outputPath)}'.`));
+};
+await generate();
+
+//#endregion
+export {  };