@skgo/sveltekit-adapter 0.18.0 → 0.22.0

package/skgo-adapter.js

@@ -17,8 +17,8 @@ import { pathToFileURL } from 'node:url';
 import {
 	createPrerenderOwner,
 	installPrerenderFailureBoundary,
-	joinFailedPrerenderOwner,
 	remoteFunction,
+ remoteEndpoint,
 	remoteLoad
 } from './skgo-adapter/prerender.js';
 import { gojaDevEnvironment, gojaDevUnchangedFiles, gojaEnvironment, goEnvironmentValues, nodeTable, SSR_TARGET } from './skgo-adapter/env.js';
@@ -59,10 +59,10 @@ const KIT_COMPONENTS = join(
  * serve a frontend that was built from a different set of Go functions than it
  * answers.
  *
- * @param {{ out?: string, precompress?: boolean }} [options]
+ * @param {{ out?: string, precompress?: boolean, prerenderPackage?: string }} [options]
  * @returns {import('@sveltejs/kit').Adapter}
  */
-export default function skgo({ out = 'build', precompress = true } = {}) {
+export default function skgo({ out = 'build', precompress = true, prerenderPackage } = {}) {
 	// The engine's bundle is a fourth environment of kit's own build. Kit reads
 	// `vite.plugins.post` while it assembles its config, long before `adapt`
 	// runs, so the plugin that declares the environment has to exist here; the
@@ -74,14 +74,23 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 		name: 'skgo-prerender-main-owner',
 		apply: 'build',
 		configResolved(config) {
-			prerenderOwner = createPrerenderOwner(process.cwd());
+			prerenderOwner = createPrerenderOwner(process.cwd(), prerenderPackage);
 			installPrerenderFailureBoundary(config, prerenderOwner);
 		},
+		// Kit captures its app environment in config/configResolved. Vite awaits
+		// all of those before this hook; publication here cannot enter that snapshot.
+		buildApp: {
+			order: 'pre',
+			async handler() {
+				await prerenderOwner?.prepare();
+				prerenderOwner?.publish();
+			}
+		},
 		buildEnd(error) {
 			if (error && prerenderOwner) return prerenderOwner.fail(error);
 		},
 		async closeBundle() {
-			await joinFailedPrerenderOwner(prerenderOwner);
+			if (prerenderOwner?.closing) await prerenderOwner.cleanup();
 		}
 	};
 
@@ -90,6 +99,7 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 		emulate() {
 			return {
 				platform: () => ({
+                    skgoPrerenderEndpoint(event) { return remoteEndpoint(event); },
 					async skgoPrerenderLoad(module, source, event) {
 						return remoteLoad(module, source, event);
 					},
@@ -107,6 +117,7 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 		// states its own `apply`, so only one of them is ever live.
 		vite: { plugins: { pre: [prerenderOwnerPlugin], post: [environment.plugin, goja.plugin, gojaDevEnvironment(), gojaDevUnchangedFiles({ out })] } },
 		async adapt(builder) {
+			let failure;
 			try {
 			rmSync(out, { force: true, recursive: true });
 
@@ -120,6 +131,9 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 			checkServerLoads(allServerIds, generated.loads, generated.actions);
 
 			const endpoints = checkEndpoints(builder, generated.endpoints);
+			const prerenderedEndpoints = Object.fromEntries(builder.routes
+				.filter((route) => route.prerender === true && endpoints.has(route.id))
+				.map((route) => [route.id, endpoints.get(route.id)]));
 
 			builder.writeClient(`${out}/client`);
 			checkRemoteIds(`${out}/client`, generated.remotes, hashes);
@@ -186,6 +200,7 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 						// records in the node module it builds.
 						nodes: serverIds,
 						loads: generated.loads,
+						prerenderedEndpoints,
 						actions: [...new Set(generated.actions)].sort(),
 						ssr: describeSSR(builder, kit, nodes),
 						routes: kit._.routes.map((/** @type {any} */ route) => ({
@@ -242,8 +257,15 @@ export default function skgo({ out = 'build', precompress = true } = {}) {
 			write(`${out}/.gitkeep`, '');
 
 			builder.log.minor(`skgo: wrote ${out}/`);
+			} catch (error) {
+				failure = error;
+				throw error;
 			} finally {
-				await prerenderOwner?.cleanup();
+				if (failure) await prerenderOwner?.fail(failure);
+				else {
+					await prerenderOwner?.cleanup();
+					if (prerenderOwner?.failed) throw prerenderOwner.failed;
+				}
 			}
 		}
 	};