@nkzw/fate 0.1.3 → 1.0.0

package/lib/vite.mjs

@@ -0,0 +1,593 @@
+import path from "node:path";
+import { runnerImport, transformWithOxc } from "vite";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+//#region src/codegen/schema.ts
+const isDataView = (value) => Boolean(value) && typeof value === "object" && typeof value.typeName === "string" && Boolean(value.fields) && typeof value.fields === "object";
+/**
+* Builds the schema object used by the Vite plugin from your data views and
+* root resolver configs.
+*/
+const createSchema = (dataViews, roots) => {
+	const rootSchema = {};
+	const fateTypes = /* @__PURE__ */ new Map();
+	const processing = /* @__PURE__ */ new Set();
+	const ensureType = (view) => {
+		const typeName = view.typeName;
+		const existing = fateTypes.get(typeName);
+		if (processing.has(typeName)) return typeName;
+		processing.add(typeName);
+		const fields = existing?.fields ?? {};
+		for (const [field, child] of Object.entries(view.fields)) if (isDataView(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) if (!view.typeName) throw new Error("Data view is missing a type name.");
+	for (const view of dataViews) ensureType(view);
+	for (const [name, root] of Object.entries(roots)) {
+		const config = "fields" in root ? { view: root } : root;
+		const view = config.view;
+		if (!view.typeName) throw new Error(`Root "${name}" is missing a data view.`);
+		const type = ensureType(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
+//#region src/codegen/client.ts
+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 createClientSource = ({ clientModule = "react-fate", moduleExports, moduleName, runtimeModuleName = moduleName, transport = "trpc" }) => {
+	if (transport === "native" || transport === "void") return createNativeClientSource({
+		clientModule,
+		moduleExports,
+		moduleName,
+		runtimeModuleName,
+		voidTransport: transport === "void"
+	});
+	const { appRouter, Root } = moduleExports;
+	const { roots, types } = createSchema(Object.values(moduleExports).filter(isDataView), 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] of routerRoots) {
+				if (root.kind !== "query") continue;
+				if (procedureName === root.procedure && type === "query") queryEntries.push({
+					name: queryName,
+					procedure: root.procedure,
+					router,
+					type: root.type
+				});
+			}
+			for (const [listName, root] of routerRoots) {
+				if (root.kind !== "list") continue;
+				if (procedureName === root.procedure && type === "query") listEntries.push({
+					list: listName,
+					procedure: root.procedure,
+					router,
+					type: root.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 queriesBlock = queryLines.length ? `      queries: {\n${indentBlock(queriesBlockContent, 8)}\n      },\n` : "";
+	const trpcFateServer = moduleExports.fateServer?.manifest ? moduleExports.fateServer : null;
+	const hasLive = Object.keys(trpcFateServer?.manifest.live ?? {}).length > 0;
+	const liveOptions = hasLive ? `fetch?: typeof fetch;
+headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+liveRetryMs?: number;
+liveUrl: string | URL;` : "";
+	const liveImport = hasLive ? ", createHTTPTransport" : "";
+	const liveTransportSetup = hasLive ? `
+  const liveTransport = createHTTPTransport({
+    fetch: options.fetch,
+    headers: options.headers,
+    liveRetryMs: options.liveRetryMs,
+    url: options.liveUrl,
+  });
+` : "";
+	const liveTransportAssignment = hasLive ? `
+  transport.subscribeById = liveTransport.subscribeById;
+  transport.subscribeConnection = liveTransport.subscribeConnection;
+` : "";
+	const generatedClientTypes = `
+declare module '${`${clientModule}/client`}' {
+  interface ClientMutations extends GeneratedClientMutations {}
+  interface ClientRoots extends GeneratedClientRoots {}
+
+  export function createFateClient(
+    ...args: Parameters<GeneratedCreateFateClient>
+  ): ReturnType<GeneratedCreateFateClient>;
+}
+`;
+	return `// @generated by @nkzw/fate/vite
+${typeImports}
+import { createTRPCProxyClient } from '@trpc/client';
+import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { clientRoot, createClient${liveImport}, createTRPCTransport, mutation } from '${clientModule}';
+
+type TRPCClientType = ReturnType<typeof createTRPCProxyClient<AppRouter>>;
+type RouterInputs = inferRouterInputs<AppRouter>;
+type RouterOutputs = inferRouterOutputs<AppRouter>;
+
+const mutations = {
+${mutationConfigBlock}
+} as const;
+
+const roots = {
+${rootsBlock}
+} as const;
+
+export type GeneratedClientMutations = typeof mutations;
+export type GeneratedClientRoots = typeof roots;
+
+export const createFateClient = (options: {
+  links: Parameters<typeof createTRPCProxyClient>[0]['links'];
+${indentBlock(liveOptions.trim(), 2)}
+  onLiveError?: (error: unknown) => void;
+}) => {
+  const trpcClient = createTRPCProxyClient<AppRouter>(options);
+${liveTransportSetup}
+
+  const trpcMutations = {
+${mutationResolverBlock}
+  } as const;
+
+  const transport = createTRPCTransport<AppRouter, typeof trpcMutations>({
+    byId: {
+${byIdBlock}
+    },
+    client: trpcClient,
+${queriesBlock}${listsBlock}    mutations: trpcMutations,
+  });
+${liveTransportAssignment}
+
+  return createClient<[GeneratedClientRoots, GeneratedClientMutations]>({
+    mutations,
+    onLiveError: options.onLiveError,
+    roots,
+    transport,
+    types: ${typesBlock.trimStart()},
+  });
+};
+
+type GeneratedCreateFateClient = typeof createFateClient;
+${generatedClientTypes}
+`;
+};
+const lowerTypeName = (type) => type[0]?.toLowerCase() + type.slice(1);
+const createNativeClientSource = ({ clientModule, moduleExports, moduleName, runtimeModuleName, voidTransport }) => {
+	const { Root } = moduleExports;
+	const fateExportName = moduleExports.fate?.manifest ? "fate" : moduleExports.fateServer?.manifest ? "fateServer" : null;
+	const fateServer = fateExportName ? moduleExports[fateExportName] : null;
+	if (!fateServer?.manifest) throw new Error(`Native fate client generation requires the server module to export a value named "fate" or "fateServer" created by createFateServer().`);
+	const { roots, types } = createSchema(Object.values(moduleExports).filter(isDataView), Root ?? {});
+	const manifest = fateServer.manifest;
+	const hasLive = Object.keys(manifest.live ?? {}).length > 0;
+	const byIdEntries = Object.keys(manifest.types ?? {}).map((type) => ({
+		name: lowerTypeName(type),
+		type
+	}));
+	const mutationEntries = Object.entries(manifest.mutations ?? {}).map(([name, config]) => ({
+		name,
+		type: config.type
+	}));
+	const rootEntries = [...byIdEntries.map(({ name, type }) => ({
+		name,
+		value: `'${name}': clientRoot<Array<${type}>, '${type}'>('${type}'),`
+	})), ...Object.entries(roots).map(([name, root]) => {
+		const apiKey = name;
+		return {
+			name,
+			value: `'${name}': clientRoot<FateAPI['${root.kind === "list" ? "lists" : "queries"}']['${apiKey}']['output'], '${root.type}'>('${root.type}'),`
+		};
+	})].sort((a, b) => a.name.localeCompare(b.name));
+	const importedTypes = Array.from(new Set([
+		fateExportName === "fate" ? "fate as fateServer" : "fateServer",
+		...types.map((type) => type.type),
+		...mutationEntries.map((entry) => entry.type)
+	])).sort((a, b) => a.localeCompare(b));
+	const mutationConfigLines = mutationEntries.map(({ name, type }) => `'${name}': mutation<
+  ${type},
+  FateAPI['mutations']['${name}']['input'],
+  FateAPI['mutations']['${name}']['output']
+>('${type}'),`);
+	const typesBlock = indentBlock(formatTypes(types), 6);
+	const rootBlock = indentBlock(rootEntries.map((entry) => entry.value).join("\n"), 2);
+	const mutationConfigBlock = indentBlock(mutationConfigLines.join("\n"), 2);
+	const clientDeclarationModule = `${clientModule}/client`;
+	const voidServerFetch = voidTransport ? `
+import type { FateServer } from '@nkzw/fate/server';
+
+const defaultVoidFateRpcPath = '/fate';
+const defaultVoidFateLivePath = '/fate-live';
+
+let serverFateFetchPromise: Promise<(request: Request) => Promise<Response>> | null = null;
+
+const isFateServer = (value: unknown): value is FateServer<unknown> =>
+  Boolean(value && typeof value === 'object' && 'manifest' in value);
+
+const getServerFateFetch = async () => {
+  serverFateFetchPromise ??= Promise.all([
+    import('@nkzw/fate/server'),
+    import('${runtimeModuleName}'),
+  ]).then(([{ createFateFetchHandler }, serverModule]) => {
+    const moduleRecord = serverModule as Record<string, unknown>;
+    const server = isFateServer(moduleRecord.fate)
+      ? moduleRecord.fate
+      : isFateServer(moduleRecord.fateServer)
+        ? moduleRecord.fateServer
+        : null;
+
+    if (!server) {
+      throw new Error('void-fate: Expected the server module to export a Fate server named "fate" or "fateServer".');
+    }
+
+    return createFateFetchHandler(server);
+  });
+
+  return serverFateFetchPromise;
+};
+
+const getDefaultOrigin = () =>
+  typeof window === 'undefined' ? 'http://localhost' : window.location.origin;
+
+const toEndpointUrl = (url: string | URL | undefined, path: string, origin: string | URL) =>
+  url ?? new URL(path, origin);
+
+const createVoidFetch = (options: {
+  fetch?: typeof fetch;
+  userId?: null | string;
+}): typeof fetch => {
+  if (options.fetch) {
+    return options.fetch;
+  }
+
+  if (import.meta.env.SSR) {
+    return async (input, init) => (await getServerFateFetch())(new Request(input, init));
+  }
+
+  return (input, init) =>
+    fetch(input, {
+      ...init,
+      credentials: options.userId ? 'include' : init?.credentials,
+    });
+};
+` : "";
+	const createClientOptions = voidTransport ? `options: {
+  fetch?: typeof fetch;
+  headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+  livePath?: string;
+  liveRetryMs?: number;
+  liveUrl?: string | URL;
+  onLiveError?: (error: unknown) => void;
+  origin?: string | URL;
+  rpcPath?: string;
+  url?: string | URL;
+  userId?: null | string;
+} = {}` : `options: {
+  fetch?: typeof fetch;
+  headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+  liveRetryMs?: number;
+  liveUrl?: string | URL;
+  onLiveError?: (error: unknown) => void;
+  url: string | URL;
+}`;
+	const clientSetup = voidTransport ? ` => {
+  const origin = options.origin ?? getDefaultOrigin();
+
+  return createClient<[GeneratedClientRoots, GeneratedClientMutations]>({
+    mutations,
+    onLiveError: options.onLiveError,
+    roots,
+    transport: createHTTPTransport<FateAPI>({
+      fetch: createVoidFetch(options),
+      headers: options.headers,
+      live: ${hasLive ? "connectLiveStream" : "false"},
+      liveRetryMs: options.liveRetryMs,
+      liveUrl: toEndpointUrl(
+        options.liveUrl,
+        options.livePath ?? defaultVoidFateLivePath,
+        origin,
+      ),
+      url: toEndpointUrl(options.url, options.rpcPath ?? defaultVoidFateRpcPath, origin),
+    }),
+    types: ${typesBlock.trimStart()},
+  });
+}` : ` =>
+  createClient<[GeneratedClientRoots, GeneratedClientMutations]>({
+    mutations,
+    onLiveError: options.onLiveError,
+    roots,
+    transport: createHTTPTransport<FateAPI>({
+      fetch: options.fetch,
+      headers: options.headers,
+      live: ${String(hasLive)},
+      liveRetryMs: options.liveRetryMs,
+      liveUrl: options.liveUrl,
+      url: options.url,
+    }),
+    types: ${typesBlock.trimStart()},
+  })`;
+	const generatedClientTypes = `
+declare module '${clientDeclarationModule}' {
+  interface ClientMutations extends GeneratedClientMutations {}
+  interface ClientRoots extends GeneratedClientRoots {}
+
+  export function createFateClient(
+    ...args: Parameters<GeneratedCreateFateClient>
+  ): ReturnType<GeneratedCreateFateClient>;
+}
+`;
+	return `// @generated by @nkzw/fate/vite
+import type { ${importedTypes.join(", ")} } from '${moduleName}';
+import { clientRoot, createClient, createHTTPTransport, mutation, type InferFateAPI } from '${clientModule}';
+${voidTransport && hasLive ? "import { connectLiveStream } from 'void/live/client';\n" : ""}${voidServerFetch}
+
+type FateAPI = InferFateAPI<typeof fateServer>;
+
+const mutations = {
+${mutationConfigBlock}
+} as const;
+
+const roots = {
+${rootBlock}
+} as const;
+
+export type GeneratedClientMutations = typeof mutations;
+export type GeneratedClientRoots = typeof roots;
+
+export const createFateClient = (${createClientOptions})${clientSetup};
+
+type GeneratedCreateFateClient = typeof createFateClient;
+${generatedClientTypes}
+`;
+};
+//#endregion
+//#region src/vite.ts
+const defaultClientRuntime = "@nkzw/fate";
+const defaultClientModule = `${defaultClientRuntime}/client`;
+const defaultGeneratedFile = ".fate/client.generated.ts";
+const legacyDeclarationFile = ".fate/client.d.ts";
+const defaultTsconfigFile = ".fate/tsconfig.json";
+const resolvedClientModule = `\0${defaultClientModule}.ts`;
+const toTsconfigPath = (fromFile, toFile) => {
+	const relativePath = path.relative(path.dirname(fromFile), toFile).replaceAll(path.sep, "/");
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+};
+const toGeneratedModuleName = ({ fromFile, moduleName, root }) => {
+	if (!moduleName.startsWith(".") && !path.isAbsolute(moduleName)) return moduleName;
+	return toTsconfigPath(fromFile, path.isAbsolute(moduleName) ? moduleName : path.resolve(root, moduleName));
+};
+const toVirtualRuntimeModuleName = ({ moduleName, root }) => {
+	if (!moduleName.startsWith(".") && !path.isAbsolute(moduleName)) return moduleName;
+	const resolvedModule = path.isAbsolute(moduleName) ? moduleName : path.resolve(root, moduleName);
+	const rootRelativeModule = path.relative(root, resolvedModule).replaceAll(path.sep, "/");
+	return rootRelativeModule.startsWith("..") || path.isAbsolute(rootRelativeModule) ? `/@fs/${resolvedModule.replaceAll(path.sep, "/")}` : `/${rootRelativeModule}`;
+};
+const writeIfChanged = async (file, contents) => {
+	try {
+		if (await readFile(file, "utf8") === contents) return;
+	} catch {}
+	await mkdir(path.dirname(file), { recursive: true });
+	await writeFile(file, contents);
+};
+const removeIfExists = async (file) => {
+	try {
+		await rm(file);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+};
+const fate = (options) => {
+	const clientModule = `${options.clientModule ?? defaultClientRuntime}/client`;
+	const clientModules = new Set([defaultClientModule, clientModule]);
+	let config;
+	let dependencies = /* @__PURE__ */ new Set();
+	let generatedSource = null;
+	let generationPromise = null;
+	let server = null;
+	const getGeneratedFile = () => options.generatedFile === false ? null : path.resolve(config.root, options.generatedFile ?? defaultGeneratedFile);
+	const getTsconfigFile = () => options.tsconfigFile === false ? null : path.resolve(config.root, options.tsconfigFile ?? defaultTsconfigFile);
+	const writeGeneratedFiles = async (moduleExports) => {
+		const generatedFile = getGeneratedFile();
+		if (!generatedFile) return;
+		await writeIfChanged(generatedFile, createClientSource({
+			clientModule: options.clientModule ?? defaultClientRuntime,
+			moduleExports,
+			moduleName: toGeneratedModuleName({
+				fromFile: generatedFile,
+				moduleName: options.module,
+				root: config.root
+			}),
+			transport: options.transport ?? "trpc"
+		}));
+		await removeIfExists(path.resolve(config.root, legacyDeclarationFile));
+		const tsconfigFile = getTsconfigFile();
+		if (!tsconfigFile) return;
+		await writeIfChanged(tsconfigFile, `${JSON.stringify({ files: [toTsconfigPath(tsconfigFile, generatedFile)] }, null, 2)}\n`);
+	};
+	const importServerModule = async () => {
+		const inlineConfig = {
+			configFile: false,
+			mode: config.mode,
+			resolve: {
+				alias: config.resolve.alias,
+				conditions: config.resolve.conditions
+			},
+			root: config.root
+		};
+		const result = await runnerImport(options.module, inlineConfig);
+		dependencies = new Set(result.dependencies.map((dependency) => path.normalize(dependency)));
+		return result.module;
+	};
+	const generate = async () => {
+		const moduleExports = await importServerModule();
+		const source = createClientSource({
+			clientModule: options.clientModule ?? defaultClientRuntime,
+			moduleExports,
+			moduleName: options.module,
+			runtimeModuleName: toVirtualRuntimeModuleName({
+				moduleName: options.module,
+				root: config.root
+			}),
+			transport: options.transport ?? "trpc"
+		});
+		generatedSource = source;
+		await writeGeneratedFiles(moduleExports);
+		server?.watcher.add([...dependencies]);
+		return source;
+	};
+	const ensureGenerated = () => {
+		generationPromise ??= generate().finally(() => {
+			generationPromise = null;
+		});
+		return generationPromise;
+	};
+	return {
+		buildStart: async function() {
+			await ensureGenerated();
+			const resolvedServerModule = await this.resolve(options.module);
+			if (resolvedServerModule) dependencies.add(path.normalize(resolvedServerModule.id));
+			for (const dependency of dependencies) this.addWatchFile(dependency);
+		},
+		config: () => ({ ssr: { noExternal: [...new Set([defaultClientRuntime, options.clientModule ?? defaultClientRuntime])] } }),
+		configResolved: (resolvedConfig) => {
+			config = resolvedConfig;
+		},
+		configureServer: (viteServer) => {
+			server = viteServer;
+		},
+		enforce: "pre",
+		handleHotUpdate: async ({ file, server: viteServer }) => {
+			if (!dependencies.has(path.normalize(file))) return;
+			generatedSource = null;
+			await ensureGenerated();
+			const clientModuleNode = viteServer.moduleGraph.getModuleById(resolvedClientModule);
+			if (clientModuleNode) {
+				viteServer.moduleGraph.invalidateModule(clientModuleNode);
+				return [clientModuleNode];
+			}
+		},
+		load: async (id) => {
+			if (id !== resolvedClientModule) return;
+			return transformWithOxc(generatedSource ?? await ensureGenerated(), id, { lang: "ts" });
+		},
+		name: "@nkzw/fate",
+		resolveId: (id) => clientModules.has(id) ? resolvedClientModule : void 0
+	};
+};
+//#endregion
+export { fate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkzw/fate",
-  "version": "0.1.3",
+  "version": "1.0.0",
   "description": "fate is a modern data client for React.",
   "homepage": "https://github.com/nkzw-tech/fate",
   "license": "MIT",
@@ -16,6 +16,7 @@
     "fate": "./lib/cli.mjs"
   },
   "files": [
+    "docs",
     "lib"
   ],
   "type": "module",
@@ -27,6 +28,16 @@
       "@nkzw/source": "./src/index.ts",
       "default": "./lib/index.mjs"
     },
+    "./client": {
+      "types": "./lib/clientStub.d.mts",
+      "@nkzw/source": "./src/clientStub.ts",
+      "default": "./lib/clientStub.mjs"
+    },
+    "./list": {
+      "types": "./src/list.ts",
+      "@nkzw/source": "./src/list.ts",
+      "default": "./lib/list.mjs"
+    },
     "./cli": {
       "types": "./lib/cli.d.mts",
       "@nkzw/source": "./src/cli.ts",
@@ -36,20 +47,47 @@
       "types": "./lib/server.d.mts",
       "@nkzw/source": "./src/server.ts",
       "default": "./lib/server.mjs"
+    },
+    "./server/drizzle": {
+      "types": "./lib/server/drizzle.d.mts",
+      "@nkzw/source": "./src/server/drizzle.ts",
+      "default": "./lib/server/drizzle.mjs"
+    },
+    "./server/prisma": {
+      "types": "./lib/server/prisma.d.mts",
+      "@nkzw/source": "./src/server/prisma.ts",
+      "default": "./lib/server/prisma.mjs"
+    },
+    "./vite": {
+      "types": "./lib/vite.d.mts",
+      "@nkzw/source": "./src/vite.ts",
+      "default": "./lib/vite.mjs"
     }
   },
   "dependencies": {
     "superjson": "^2.2.6",
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@trpc/client": "^11.8.1",
-    "@trpc/server": "^11.8.1"
+    "@trpc/client": "^11.17.0",
+    "@trpc/server": "^11.17.0",
+    "drizzle-orm": "^0.45.2",
+    "vite": "^8.0.12"
   },
   "peerDependencies": {
-    "@trpc/client": "^11.6.0"
+    "@trpc/client": "^11.6.0",
+    "drizzle-orm": "^0.45.0",
+    "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
   },
   "scripts": {
-    "build": "vite lib -d lib --target=node24 src/index.ts src/server.ts src/cli.ts"
+    "build": "vp pack -d lib --target=node24 src/index.ts src/clientStub.ts src/list.ts src/cli.ts src/server.ts src/server/drizzle.ts src/server/prisma.ts src/vite.ts"
   }
 }