@sigil-dev/grimoire 0.7.5 → 0.7.7

package/src/server/build.ts

@@ -1,6 +1,8 @@
 import { sigil } from "@sigil-dev/compiler/bun";
 import { mkdir } from "fs/promises";
 import { isAbsolute, join } from "path";
+import { cwd } from "process";
+import { normalizePath } from "../dev/paths";
 import { generateManifest } from "../routing/manifest-gen";
 import type { RouteTree } from "../routing/scanner";
 import { scanRoutes } from "../routing/scanner";
@@ -9,82 +11,229 @@ import { generateTypes } from "../typegen";
 import type { BuildResult, GrimoireConfig, GrimoirePlugin } from "../types";
 import { runHook } from "./plugins";
 
+export async function rebuildForChange(
+	changedFilePath: string,
+	config: GrimoireConfig,
+	plugins: GrimoirePlugin[] = [],
+): Promise<{ result: BuildResult }> {
+	const { routes = "src/routes" } = config;
+	const routesDir = isAbsolute(routes) ? routes : join(process.cwd(), routes);
+
+	// only retransform the changed file, not all routes
+	const tree = await scanRoutes(routesDir, process.cwd());
+	const changedRoute = [
+		...tree.routes.filter((r) => r.type === "page" || r.type === "simple"),
+		...tree.layouts.filter((r) => r.type === "layout"),
+	].find((r) => normalizePath(r.filePath) === normalizePath(changedFilePath));
+
+	const compiledDir = join(process.cwd(), ".grimoire/compiled");
+
+	if (changedRoute) {
+		// retransform only the changed file
+		await Promise.all([
+			transformRoutes([changedRoute], compiledDir, "hydrate", plugins),
+			transformRoutes([changedRoute], compiledDir, "dom", plugins),
+		]);
+		// update manifests with full route list but new compiled paths
+		// (other routes already have compiled files from initial build)
+		const allClientRoutes = [
+			...tree.routes.filter((r) => r.type === "page" || r.type === "simple"),
+			...tree.layouts.filter((r) => r.type === "layout"),
+		];
+		// rebuild full manifests - cheap
+		const hydrateManifest = join(process.cwd(), ".grimoire/_routes.hydrate.js");
+		const domManifest = join(process.cwd(), ".grimoire/_routes.dom.js");
+		const [allHFiles, allDFiles] = await Promise.all([
+			transformRoutes(allClientRoutes, compiledDir, "hydrate", plugins),
+			transformRoutes(allClientRoutes, compiledDir, "dom", plugins),
+		]);
+		await Promise.all([
+			Bun.write(hydrateManifest, generateManifest(allClientRoutes, allHFiles)),
+			Bun.write(domManifest, generateManifest(allClientRoutes, allDFiles)),
+		]);
+	}
+
+	// still need Bun.build — this is the slow part, Step 3 kills it
+	const publicDir = join(process.cwd(), "public/__grimoire__");
+	const hydrateManifest = join(process.cwd(), ".grimoire/_routes.hydrate.js");
+	const domManifest = join(process.cwd(), ".grimoire/_routes.dom.js");
+	const resolvedAlias: Record<string, string> = {
+		...Object.fromEntries(
+			Object.entries(config.alias ?? {}).map(([k, v]) => [k, join(cwd(), v)]),
+		),
+		"$env/static/public": join(import.meta.dir, "../env/public.ts"),
+		"$env/static/private": join(import.meta.dir, "../env/private.ts"),
+	};
+
+	const makeRoutesPlugin = (manifestPath: string) => ({
+		name: "grimoire-routes",
+		setup(build: any) {
+			build.onResolve({ filter: /^#grimoire-routes$/ }, () => ({
+				path: manifestPath,
+			}));
+		},
+	});
+
+	const [hydrateResult, domResult] = await Promise.all([
+		Bun.build({
+			entrypoints: [join(import.meta.dir, "../rendering/hydrate.ts")],
+			outdir: publicDir,
+			plugins: [sigil({ mode: "hydrate" }), makeRoutesPlugin(hydrateManifest)],
+			// @ts-expect-error
+			alias: resolvedAlias,
+		}),
+		Bun.build({
+			entrypoints: [join(import.meta.dir, "../client/index.ts")],
+			outdir: publicDir,
+			plugins: [sigil({ mode: "dom" }), makeRoutesPlugin(domManifest)],
+			// @ts-expect-error
+			alias: resolvedAlias,
+		}),
+	]);
+
+	return {
+		result: {
+			success: hydrateResult.success && domResult.success,
+			outputs: [...hydrateResult.outputs, ...domResult.outputs].map(
+				(o) => o.path,
+			),
+			errors: [...hydrateResult.logs, ...domResult.logs].map(String),
+		},
+	};
+}
+
 export async function buildProject(
-    config: GrimoireConfig,
-    plugins: GrimoirePlugin[] = [],
+	config: GrimoireConfig,
+	plugins: GrimoirePlugin[] = [],
 ): Promise<{ result: BuildResult; tree: RouteTree }> {
-    await runHook(plugins, "onBuildStart");
-
-    const { routes = "src/routes" } = config;
-
-    const routesDir = isAbsolute(routes)
-        ? routes.replace(/\0/g, "")
-        : join(process.cwd(), routes).replace(/\0/g, "");
-    const tree = await scanRoutes(routesDir, process.cwd());
-
-    await mkdir(join(process.cwd(), ".grimoire"), { recursive: true });
-
-    await generateTypes(tree, {
-        projectRoot: process.cwd(),
-        routesDir,
-        outDir: join(process.cwd(), ".grimoire/types"),
-    });
-
-    const compiledDir = join(process.cwd(), ".grimoire/compiled");
-    await mkdir(compiledDir, { recursive: true });
-
-    const pageRoutes = tree.routes.filter(
-        (r) => r.type === "page" || r.type === "simple",
-    );
-    const [hydrateFiles, domFiles] = await Promise.all([
-        transformRoutes(pageRoutes, compiledDir, "hydrate", plugins),
-        transformRoutes(pageRoutes, compiledDir, "dom", plugins),
-    ]);
-
-    const hydrateManifest = join(process.cwd(), ".grimoire/_routes.hydrate.js");
-    const domManifest = join(process.cwd(), ".grimoire/_routes.dom.js");
-    await Promise.all([
-        Bun.write(hydrateManifest, generateManifest(pageRoutes, hydrateFiles)),
-        Bun.write(domManifest, generateManifest(pageRoutes, domFiles)),
-    ]);
-
-    const makeRoutesPlugin = (manifestPath: string) => ({
-        name: "grimoire-routes",
-        setup(build: any) {
-            build.onResolve({ filter: /^#grimoire-routes$/ }, () => ({
-                path: manifestPath,
-            }));
-        },
-    });
-
-    const [hydrateResult, domResult] = await Promise.all([
-        Bun.build({
-            entrypoints: [join(import.meta.dir, "../rendering/hydrate.ts")],
-            outdir: join(process.cwd(), "public/__grimoire__"),
-            plugins: [sigil({ mode: "hydrate" }), makeRoutesPlugin(hydrateManifest)],
-        }),
-        Bun.build({
-            entrypoints: [join(import.meta.dir, "../client/index.ts")],
-            outdir: join(process.cwd(), "public/__grimoire__"),
-            plugins: [sigil({ mode: "dom" }), makeRoutesPlugin(domManifest)],
-        }),
-    ]);
-
-    if (!hydrateResult.success) {
-        for (const log of hydrateResult.logs) console.error(log);
-    }
-    if (!domResult.success) {
-        for (const log of domResult.logs) console.error(log);
-    }
-
-    const result: BuildResult = {
-        success: hydrateResult.success && domResult.success,
-        outputs: [...hydrateResult.outputs, ...domResult.outputs].map(
-            (o) => o.path,
-        ),
-        errors: [...hydrateResult.logs, ...domResult.logs].map(String),
-    };
-
-    await runHook(plugins, "onBuildEnd", result);
-    return { result, tree };
+	await runHook(plugins, "onBuildStart");
+
+	const { routes = "src/routes" } = config;
+
+	const routesDir = isAbsolute(routes)
+		? routes.replace(/\0/g, "")
+		: join(process.cwd(), routes).replace(/\0/g, "");
+	const tree = await scanRoutes(routesDir, process.cwd());
+
+	const outDir = join(process.cwd(), ".grimoire");
+	await mkdir(outDir, { recursive: true });
+
+	await generateTypes(tree, {
+		projectRoot: process.cwd(),
+		routesDir,
+		outDir: join(outDir, "types"),
+	});
+
+	// Generate $env type declarations from .env
+	const { generateEnvTypes } = await import("../env/typegen");
+	const envTypeDir = join(outDir, "types");
+	await mkdir(envTypeDir, { recursive: true });
+	await generateEnvTypes(process.cwd(), envTypeDir);
+
+	const compiledDir = join(outDir, "compiled");
+	await mkdir(compiledDir, { recursive: true });
+
+	const clientRoutes = [
+		...tree.routes.filter((r) => r.type === "page" || r.type === "simple"),
+		...tree.layouts.filter((r) => r.type === "layout"),
+	];
+
+	const [hydrateFiles, domFiles] = await Promise.all([
+		transformRoutes(clientRoutes, compiledDir, "hydrate", plugins),
+		transformRoutes(clientRoutes, compiledDir, "dom", plugins),
+	]);
+
+	const hydrateManifest = join(process.cwd(), ".grimoire/_routes.hydrate.js");
+	const domManifest = join(process.cwd(), ".grimoire/_routes.dom.js");
+	await Promise.all([
+		Bun.write(hydrateManifest, generateManifest(clientRoutes, hydrateFiles)),
+		Bun.write(domManifest, generateManifest(clientRoutes, domFiles)),
+	]);
+
+	const makeRoutesPlugin = (manifestPath: string) => ({
+		name: "grimoire-routes",
+		setup(build: any) {
+			build.onResolve({ filter: /^#grimoire-routes$/ }, () => ({
+				path: manifestPath,
+			}));
+		},
+	});
+
+	const resolvedAlias: Record<string, string> = {
+		...Object.fromEntries(
+			Object.entries(config.alias ?? {}).map(([k, v]) => [k, join(cwd(), v)]),
+		),
+		"$env/static/public": join(import.meta.dir, "../env/public.ts"),
+		"$env/static/private": join(import.meta.dir, "../env/private.ts"),
+	};
+
+	const bundleStrategy = config.bundleStrategy ?? "split";
+	const publicDir = join(process.cwd(), "public/__grimoire__");
+
+	if (bundleStrategy === "single") {
+		// Single bundle: combine hydrate + dom in one output
+		const singleResult = await Bun.build({
+			entrypoints: [
+				join(import.meta.dir, "../rendering/hydrate.ts"),
+				join(import.meta.dir, "../client/index.ts"),
+			],
+			outdir: publicDir,
+			plugins: [
+				sigil({ mode: "hydrate" }),
+				sigil({ mode: "dom" }),
+				makeRoutesPlugin(hydrateManifest),
+				makeRoutesPlugin(domManifest),
+			],
+			// @ts-expect-error alias is a valid Bun.build option not yet in types
+			alias: resolvedAlias,
+		});
+
+		if (!singleResult.success) {
+			for (const log of singleResult.logs) console.error(log);
+		}
+
+		const result: BuildResult = {
+			success: singleResult.success,
+			outputs: singleResult.outputs.map((o) => o.path),
+			errors: singleResult.logs.map(String),
+		};
+
+		await runHook(plugins, "onBuildEnd", result);
+		return { result, tree };
+	}
+
+	const [hydrateResult, domResult] = await Promise.all([
+		Bun.build({
+			entrypoints: [join(import.meta.dir, "../rendering/hydrate.ts")],
+			outdir: publicDir,
+			plugins: [sigil({ mode: "hydrate" }), makeRoutesPlugin(hydrateManifest)],
+			// @ts-expect-error alias is a valid Bun.build option not yet in types
+			alias: resolvedAlias,
+		}),
+		Bun.build({
+			entrypoints: [join(import.meta.dir, "../client/index.ts")],
+			outdir: publicDir,
+			plugins: [sigil({ mode: "dom" }), makeRoutesPlugin(domManifest)],
+			// @ts-expect-error alias is a valid Bun.build option not yet in types
+			alias: resolvedAlias,
+		}),
+	]);
+
+	if (!hydrateResult.success) {
+		for (const log of hydrateResult.logs) console.error(log);
+	}
+	if (!domResult.success) {
+		for (const log of domResult.logs) console.error(log);
+	}
+
+	const result: BuildResult = {
+		success: hydrateResult.success && domResult.success,
+		outputs: [...hydrateResult.outputs, ...domResult.outputs].map(
+			(o) => o.path,
+		),
+		errors: [...hydrateResult.logs, ...domResult.logs].map(String),
+	};
+
+	await runHook(plugins, "onBuildEnd", result);
+	return { result, tree };
 }

package/src/server/coordinator.ts

@@ -168,10 +168,19 @@ export async function startCoordinator(options: CoordinatorOptions) {
 			const workerEntry = join(import.meta.dir, "./worker.ts");
 			if (workerEnv.name) descriptor.name = workerEnv.name;
 
+			// Inject env vars prefixed with PUBLIC_ so they're available to client bundles
+			const publicEnvVars: Record<string, string> = {};
+			for (const [key, value] of Object.entries(process.env)) {
+				if (key.startsWith("PUBLIC_") && value !== undefined) {
+					publicEnvVars[key] = value;
+				}
+			}
+
 			const proc = spawn(["bun", "run", workerEntry], {
 				env: {
 					...process.env,
 					...workerEnv.env,
+					...publicEnvVars,
 					GRIMOIRE_MODE: mode,
 					GRIMOIRE_WORKER_INDEX: String(i),
 					GRIMOIRE_WORKER_PORT: String(workerPort),

package/src/server/hooks.ts

@@ -1,7 +1,7 @@
 /**
  * SvelteKit-style server hooks.
  *
- * Create a hooks.index.ts in your project root:
+ * Create a hooks.server.ts in your project root:
  *
  *   import type { Handle } from "@sigil-dev/grimoire/hooks";
  *
@@ -12,6 +12,10 @@
  *     return response;
  *   };
  *
+ *   export const handleError: HandleError = ({ error, status, message }) => {
+ *     console.error(`[${status}] ${message}`, error);
+ *   };
+ *
  *   // optional: runs once at server start
  *   export const init = () => {
  *     console.log("Server started");
@@ -32,8 +36,10 @@ export interface RequestEvent {
 	request: Request;
 	url: URL;
 	params: Record<string, string>;
-	locals: Record<string, any>;
+	locals: App.Locals;
 	cookies: Cookies;
+	route: { id: string };
+	fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 	setHeaders: (headers: Record<string, string>) => void;
 }
 
@@ -60,6 +66,21 @@ export type Handle = (input: {
 	resolve: ResolveFunction;
 }) => MaybePromise<Response>;
 
+export interface HandleErrorInput {
+	error: unknown;
+	event: RequestEvent;
+	status: number;
+	message: string;
+}
+export type HandleError = (input: HandleErrorInput) => void | Promise<void>;
+
+export interface HandleFetchInput {
+	request: Request;
+	fetch: typeof globalThis.fetch;
+	event: RequestEvent;
+}
+export type HandleFetch = (input: HandleFetchInput) => MaybePromise<Response>;
+
 export type InitFunction = () => void | Promise<void>;
 
 /**
@@ -73,7 +94,7 @@ export function sequence(...handlers: Handle[]): Handle {
 		const next: ResolveFunction = async (evt) => {
 			if (i < handlers.length) {
 				const handler = handlers[i++];
-				return handler({ event: evt, resolve: next });
+				return handler!({ event: evt, resolve: next });
 			}
 			return resolve(evt);
 		};