@octanejs/tanstack-start 0.1.0

package/src/internal/start-plugin-core/vite/plugin.js

@@ -0,0 +1,208 @@
+import { START_ENVIRONMENT_NAMES } from '../constants.js';
+import {
+	createServerFnBasePath,
+	normalizePublicBase,
+	shouldRewriteDevBasepath,
+} from '../planning.js';
+import {
+	applyResolvedBaseAndOutput,
+	applyResolvedRouterBasepath,
+	createStartConfigContext,
+} from '../config-context.js';
+import { importProtectionPlugin } from './import-protection-plugin/plugin.js';
+import { startCompilerPlugin } from './start-compiler-plugin/plugin.js';
+import { loadEnvPlugin } from './load-env-plugin/plugin.js';
+import {
+	buildStartViteEnvironments,
+	createViteConfigPlan,
+	createViteDefineConfig,
+	createViteResolvedEntryAliases,
+} from './planning.js';
+import { devServerPlugin } from './dev-server-plugin/plugin.js';
+import { getClientOutputDirectory, getServerOutputDirectory } from './output-directory.js';
+import { previewServerPlugin } from './preview-server-plugin/plugin.js';
+import {
+	createDevBaseRewritePlugin,
+	createDevClientEntryPlugin,
+	createPostBuildPlugin,
+} from './plugins.js';
+import { parseStartConfig } from './schema.js';
+import { startManifestPlugin } from './start-manifest-plugin/plugin.js';
+import { tanStackStartRouter } from './start-router-plugin/plugin.js';
+import { postServerBuild } from './post-server-build.js';
+import { serializationAdaptersPlugin } from './serialization-adapters-plugin.js';
+import { crawlFrameworkPkgs } from 'vitefu';
+import { getStartPackage } from '#tanstack-start/package-names';
+//#region src/vite/plugin.ts
+function tanStackStartVite(corePluginOpts, startPluginOpts) {
+	const normalizedStartPluginOpts = startPluginOpts ?? {};
+	const configContext = createStartConfigContext({
+		corePluginOpts,
+		startPluginOpts: normalizedStartPluginOpts,
+		parseConfig: parseStartConfig,
+	});
+	const { getConfig, resolvedStartConfig } = configContext;
+	const serverFnProviderEnv = corePluginOpts.providerEnvironmentName;
+	const ssrIsProvider = corePluginOpts.ssrIsProvider;
+	let needsDevBaseRewrite = false;
+	const environments = [
+		{
+			name: START_ENVIRONMENT_NAMES.client,
+			type: 'client',
+		},
+		{
+			name: START_ENVIRONMENT_NAMES.server,
+			type: 'server',
+			getServerFnById:
+				corePluginOpts.ssrResolverStrategy.type === 'vite-rsc-forward'
+					? createViteRscForwarder(corePluginOpts.ssrResolverStrategy)
+					: void 0,
+		},
+	];
+	if (
+		serverFnProviderEnv !== START_ENVIRONMENT_NAMES.server &&
+		!environments.find((e) => e.name === serverFnProviderEnv)
+	)
+		environments.push({
+			name: serverFnProviderEnv,
+			type: 'server',
+		});
+	return [
+		{
+			name: 'tanstack-start-core:config',
+			enforce: 'pre',
+			async config(viteConfig, { command }) {
+				const publicBase = normalizePublicBase(viteConfig.base);
+				applyResolvedBaseAndOutput({
+					resolvedStartConfig,
+					root: viteConfig.root || process.cwd(),
+					publicBase,
+					clientOutputDirectory: getClientOutputDirectory(viteConfig),
+					serverOutputDirectory: getServerOutputDirectory(viteConfig),
+				});
+				const { startConfig } = getConfig();
+				const routerBasepath = applyResolvedRouterBasepath({
+					resolvedStartConfig,
+					startConfig,
+				});
+				if (
+					shouldRewriteDevBasepath({
+						command,
+						middlewareMode: Boolean(viteConfig.server?.middlewareMode),
+						routerBasepath,
+						publicBase: resolvedStartConfig.basePaths.publicBase,
+					})
+				)
+					needsDevBaseRewrite = true;
+				const TSS_SERVER_FN_BASE = createServerFnBasePath({
+					routerBasepath,
+					serverFnBase: startConfig.serverFns.base,
+				});
+				const entryAliases = createViteResolvedEntryAliases({
+					entryPaths: configContext.resolveEntries().entryPaths,
+				});
+				const startPackageName = getStartPackage(corePluginOpts.framework);
+				const crawlFrameworkPkgsResult = await crawlFrameworkPkgs({
+					root: process.cwd(),
+					isBuild: command === 'build',
+					isFrameworkPkgByJson(pkgJson) {
+						const peerDependencies = pkgJson['peerDependencies'];
+						if (peerDependencies) {
+							if (
+								startPackageName in peerDependencies ||
+								'@tanstack/start-client-core' in peerDependencies
+							)
+								return true;
+						}
+						return false;
+					},
+				});
+				const viteConfigPlan = createViteConfigPlan({
+					viteConfig,
+					command,
+					framework: corePluginOpts.framework,
+					entryAliases,
+					clientOutputDirectory: resolvedStartConfig.outputDirectories.client,
+					serverOutputDirectory: resolvedStartConfig.outputDirectories.server,
+					serverFnProviderEnv,
+					optimizeDepsExclude: crawlFrameworkPkgsResult.optimizeDeps.exclude,
+					noExternal: crawlFrameworkPkgsResult.ssr.noExternal.sort(),
+				});
+				return {
+					appType: viteConfig.appType ?? 'custom',
+					environments: viteConfigPlan.environments,
+					resolve: viteConfigPlan.resolve,
+					define: createViteDefineConfig({
+						command,
+						mode: viteConfig.mode,
+						serverFnBase: TSS_SERVER_FN_BASE,
+						routerBasepath,
+						spaEnabled: startConfig.spa?.enabled,
+						devSsrStylesEnabled: startConfig.dev.ssrStyles.enabled,
+						devSsrStylesBasepath:
+							startConfig.dev.ssrStyles.basepath ?? resolvedStartConfig.basePaths.publicBase,
+						inlineCssEnabled: command === 'build' && startConfig.server.build.inlineCss.enabled,
+						staticNodeEnv: startConfig.server.build.staticNodeEnv,
+						disableCsrfMiddlewareWarning: startConfig.serverFns.disableCsrfMiddlewareWarning,
+					}),
+					builder: {
+						sharedPlugins: true,
+						async buildApp(builder) {
+							await buildStartViteEnvironments({
+								builder,
+								providerEnvironmentName: serverFnProviderEnv,
+								ssrIsProvider,
+							});
+						},
+					},
+				};
+			},
+		},
+		createPostBuildPlugin({
+			getConfig,
+			postServerBuild,
+		}),
+		startCompilerPlugin({
+			framework: corePluginOpts.framework,
+			environments,
+			generateFunctionId: normalizedStartPluginOpts.serverFns?.generateFunctionId,
+			compilerTransforms: corePluginOpts.compilerTransforms,
+			serverFnProviderModuleDirectives: corePluginOpts.serverFnProviderModuleDirectives,
+			providerEnvName: serverFnProviderEnv,
+		}),
+		importProtectionPlugin({
+			getConfig,
+			framework: corePluginOpts.framework,
+			environments,
+			providerEnvName: serverFnProviderEnv,
+		}),
+		tanStackStartRouter(normalizedStartPluginOpts, getConfig, corePluginOpts),
+		loadEnvPlugin(),
+		createDevClientEntryPlugin({
+			framework: corePluginOpts.framework,
+			getClientEntry: () => configContext.resolveEntries().entryPaths.client,
+		}),
+		startManifestPlugin({ getConfig }),
+		createDevBaseRewritePlugin({
+			shouldRewriteDevBase: () => needsDevBaseRewrite,
+			resolvedStartConfig,
+		}),
+		devServerPlugin({
+			getConfig,
+			devSsrStylesEnabled: normalizedStartPluginOpts.dev?.ssrStyles?.enabled ?? true,
+			installDevServerMiddleware: normalizedStartPluginOpts.vite?.installDevServerMiddleware,
+		}),
+		previewServerPlugin(),
+		...(corePluginOpts.serializationAdapters?.length
+			? [serializationAdaptersPlugin({ adapters: corePluginOpts.serializationAdapters })]
+			: []),
+	];
+}
+function createViteRscForwarder(strategy) {
+	return `export async function getServerFnById(id, access) {
+  const m = await import.meta.viteRsc.loadModule(${JSON.stringify(strategy.sourceEnvironmentName)}, ${JSON.stringify(strategy.sourceEntry)})
+  return m[${JSON.stringify(strategy.exportName)}](id, access)
+}`;
+}
+//#endregion
+export { tanStackStartVite };

package/src/internal/start-plugin-core/vite/plugins.d.ts

@@ -0,0 +1,17 @@
+import { CompileStartFrameworkOptions, GetConfigFn, ResolvedStartConfig } from '../types.js';
+import { PluginOption, ViteBuilder } from 'vite';
+export declare function createDevClientEntryPlugin(opts: {
+	framework: CompileStartFrameworkOptions;
+	getClientEntry: () => string;
+}): PluginOption;
+export declare function createPostBuildPlugin(opts: {
+	getConfig: GetConfigFn;
+	postServerBuild: (opts: {
+		startConfig: ReturnType<GetConfigFn>['startConfig'];
+		builder: ViteBuilder;
+	}) => Promise<void>;
+}): PluginOption;
+export declare function createDevBaseRewritePlugin(opts: {
+	shouldRewriteDevBase: () => boolean;
+	resolvedStartConfig: ResolvedStartConfig;
+}): PluginOption;

package/src/internal/start-plugin-core/vite/plugins.js

@@ -0,0 +1,72 @@
+import { DEV_CLIENT_ENTRY } from '../constants.js';
+import { createVirtualModule } from './createVirtualModule.js';
+import { normalizePath } from 'vite';
+//#region src/vite/plugins.ts
+function createDevClientEntryPlugin(opts) {
+	return createVirtualModule({
+		name: 'tanstack-start-core:dev-client-entry',
+		moduleId: DEV_CLIENT_ENTRY,
+		enforce: 'pre',
+		async load() {
+			const clientEntry = JSON.stringify(
+				normalizePath(opts.getClientEntry()).replaceAll('\\', '/'),
+			);
+			if (shouldInjectReactRefreshPreamble(this.environment, opts.framework)) {
+				const reactRefresh = await this.resolve?.('/@react-refresh');
+				if (!reactRefresh)
+					throw new Error(
+						'TanStack Start React dev mode requires the React Refresh runtime, but /@react-refresh could not be resolved. Add @vitejs/plugin-react or another compatible React Refresh Vite plugin to your Vite config.',
+					);
+				return getReactRefreshPreambleCode(reactRefresh.id) + `\nawait import(${clientEntry})`;
+			}
+			return `import ${clientEntry}`;
+		},
+	});
+}
+function shouldInjectReactRefreshPreamble(environment, framework) {
+	const config = environment?.config;
+	return (
+		framework === 'react' &&
+		config?.command === 'serve' &&
+		config.consumer === 'client' &&
+		config.server?.hmr !== false
+	);
+}
+function getReactRefreshPreambleCode(reactRefreshId) {
+	return `import { injectIntoGlobalHook } from ${JSON.stringify(reactRefreshId)};
+injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;`;
+}
+function createPostBuildPlugin(opts) {
+	return {
+		name: 'tanstack-start-core:post-build',
+		enforce: 'post',
+		buildApp: {
+			order: 'post',
+			async handler(builder) {
+				const { startConfig } = opts.getConfig();
+				await opts.postServerBuild({
+					builder,
+					startConfig,
+				});
+			},
+		},
+	};
+}
+function createDevBaseRewritePlugin(opts) {
+	return {
+		name: 'tanstack-start-core:dev-base-rewrite',
+		configureServer(server) {
+			if (!opts.shouldRewriteDevBase()) return;
+			const basePrefix = opts.resolvedStartConfig.basePaths.publicBase.replace(/\/$/, '');
+			server.middlewares.use((req, _res, next) => {
+				if (req.url && !req.url.startsWith(basePrefix)) req.url = basePrefix + req.url;
+				next();
+			});
+		},
+	};
+}
+//#endregion
+export { createDevBaseRewritePlugin, createDevClientEntryPlugin, createPostBuildPlugin };

package/src/internal/start-plugin-core/vite/post-server-build.d.ts

@@ -0,0 +1,9 @@
+import { TanStackStartOutputConfig } from '../schema.js';
+import { ViteBuilder } from 'vite';
+export declare function postServerBuild({
+	builder,
+	startConfig,
+}: {
+	builder: ViteBuilder;
+	startConfig: TanStackStartOutputConfig;
+}): Promise<void>;

package/src/internal/start-plugin-core/vite/post-server-build.js

@@ -0,0 +1,22 @@
+import { getClientOutputDirectory } from './output-directory.js';
+import { postBuild } from '../post-build.js';
+import { prerenderWithVite } from './prerender.js';
+//#region src/vite/post-server-build.ts
+async function postServerBuild({ builder, startConfig }) {
+	await postBuild({
+		startConfig,
+		adapter: {
+			getClientOutputDirectory() {
+				return getClientOutputDirectory(builder.config);
+			},
+			prerender(startConfig) {
+				return prerenderWithVite({
+					startConfig,
+					builder,
+				});
+			},
+		},
+	});
+}
+//#endregion
+export { postServerBuild };

package/src/internal/start-plugin-core/vite/prerender.d.ts

@@ -0,0 +1,9 @@
+import { TanStackStartOutputConfig } from '../schema.js';
+import { ViteBuilder } from 'vite';
+export declare function prerenderWithVite({
+	startConfig,
+	builder,
+}: {
+	startConfig: TanStackStartOutputConfig;
+	builder: ViteBuilder;
+}): Promise<void>;

package/src/internal/start-plugin-core/vite/prerender.js

@@ -0,0 +1,52 @@
+import { VITE_ENVIRONMENT_NAMES } from '../constants.js';
+import { prerender } from '../prerender.js';
+//#region src/vite/prerender.ts
+async function prerenderWithVite({ startConfig, builder }) {
+	const serverEnv = builder.environments[VITE_ENVIRONMENT_NAMES.server];
+	if (!serverEnv)
+		throw new Error(`Vite's "${VITE_ENVIRONMENT_NAMES.server}" environment not found`);
+	const clientEnv = builder.environments[VITE_ENVIRONMENT_NAMES.client];
+	if (!clientEnv)
+		throw new Error(`Vite's "${VITE_ENVIRONMENT_NAMES.client}" environment not found`);
+	const outputDir = clientEnv.config.build.outDir;
+	process.env.TSS_PRERENDERING = 'true';
+	process.env.TSS_CLIENT_OUTPUT_DIR = outputDir;
+	const previewServer = await startPreviewServer(serverEnv.config);
+	const baseUrl = getResolvedUrl(previewServer);
+	return prerender({
+		startConfig,
+		handler: {
+			getClientOutputDirectory() {
+				return outputDir;
+			},
+			request(path, options) {
+				const url = new URL(path, baseUrl);
+				return fetch(new Request(url, options));
+			},
+			close() {
+				return previewServer.close();
+			},
+		},
+	});
+}
+async function startPreviewServer(viteConfig) {
+	const vite = await import('vite');
+	try {
+		return await vite.preview({
+			configFile: viteConfig.configFile,
+			preview: {
+				port: 0,
+				open: false,
+			},
+		});
+	} catch (error) {
+		throw new Error('Failed to start the Vite preview server for prerendering', { cause: error });
+	}
+}
+function getResolvedUrl(previewServer) {
+	const baseUrl = previewServer.resolvedUrls?.local[0];
+	if (!baseUrl) throw new Error('No resolved URL is available from the Vite preview server');
+	return new URL(baseUrl);
+}
+//#endregion
+export { prerenderWithVite };

package/src/internal/start-plugin-core/vite/preview-server-plugin/plugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'vite';
+export declare function previewServerPlugin(): Plugin;

package/src/internal/start-plugin-core/vite/preview-server-plugin/plugin.js

@@ -0,0 +1,54 @@
+import { VITE_ENVIRONMENT_NAMES } from '../../constants.js';
+import { getBundlerOptions } from '../../utils.js';
+import { getServerOutputDirectory } from '../output-directory.js';
+import { basename, extname, join } from 'pathe';
+import { NodeRequest, sendNodeResponse } from 'srvx/node';
+import { pathToFileURL } from 'node:url';
+import { joinURL } from 'ufo';
+//#region src/vite/preview-server-plugin/plugin.ts
+function previewServerPlugin() {
+	return {
+		name: 'tanstack-start-core:preview-server',
+		configurePreviewServer: {
+			order: 'post',
+			handler(server) {
+				return () => {
+					let serverBuild = null;
+					server.middlewares.use(async (req, res, next) => {
+						try {
+							if (!serverBuild) {
+								const serverEnv = server.config.environments[VITE_ENVIRONMENT_NAMES.server];
+								const serverInput = getBundlerOptions(serverEnv?.build)?.input ?? 'server';
+								if (typeof serverInput !== 'string')
+									throw new Error('Invalid server input. Expected a string.');
+								const outputFilename = `${basename(serverInput, extname(serverInput))}.js`;
+								serverBuild = (
+									await import(
+										pathToFileURL(
+											join(getServerOutputDirectory(server.config), outputFilename),
+										).toString()
+									)
+								).default;
+							}
+							req.url = joinURL(server.config.base, req.url ?? '/');
+							const webReq = new NodeRequest({
+								req,
+								res,
+							});
+							const webRes = await serverBuild.fetch(webReq);
+							if (webRes.headers.get('content-type')?.startsWith('text/html'))
+								res.setHeader('content-encoding', 'identity');
+							res.setHeaders(webRes.headers);
+							res.writeHead(webRes.status, webRes.statusText);
+							return sendNodeResponse(res, webRes);
+						} catch (error) {
+							next(error);
+						}
+					});
+				};
+			},
+		},
+	};
+}
+//#endregion
+export { previewServerPlugin };