fix: event bus type inference on vars

Author: ping-maxwell

packages/experimental/src/event.test.ts

@@ -211,4 +211,75 @@ describe("event extension + modules", () => {
 		await expect(f()).resolves.toEqual({ n: 7 });
 		expect(seen).toEqual([7]);
 	});
+
+	it("mounted var extensions widen a kind whose payload is that var", async () => {
+		const account = v.var("evt_var_account", {
+			schema: v.object({ id: v.string() }),
+		});
+		const withTag = v.extend(account, { tag: v.string() });
+		const bus = v.event("evt_var_payload", {
+			created: account,
+		});
+
+		const seen: unknown[] = [];
+		bus.subscribe(async (e, next) => {
+			if (e.type === "created") seen.push(e.data);
+			await next();
+		});
+
+		const f = v.fn({ use: [{ bus, account, withTag }] }, async (c) => {
+			const result = c.bus.publish("created", { id: "1", tag: "vip" });
+			expectTypeOf(result).toEqualTypeOf<
+				{ id: string; tag: string } | Promise<{ id: string; tag: string }>
+			>();
+			return result;
+		});
+		await expect(f()).resolves.toEqual({ id: "1", tag: "vip" });
+		expect(seen).toEqual([{ id: "1", tag: "vip" }]);
+
+		expect(() =>
+			v.fn({ use: [{ bus, account, withTag }] }, (c) =>
+				// @ts-expect-error tag required once withTag is mounted
+				c.bus.publish("created", { id: "1" }),
+			)(),
+		).toThrow(/evt_var_account|tag/);
+	});
+
+	it("unmounted, a var-payload kind stays the base shape", async () => {
+		const account = v.var("evt_var_bare", {
+			schema: v.object({ id: v.string() }),
+		});
+		const bus = v.event("evt_var_bare_bus", { created: account });
+		const f = v.fn({ use: [{ bus, account }] }, async (c) => {
+			const result = c.bus.publish("created", { id: "1" });
+			expectTypeOf(result).toEqualTypeOf<
+				{ id: string } | Promise<{ id: string }>
+			>();
+			return result;
+		});
+		await expect(f()).resolves.toEqual({ id: "1" });
+	});
+
+	it("a var field on an event kind widens the same way", async () => {
+		const account = v.var("evt_var_field_account", {
+			schema: v.object({ id: v.string() }),
+		});
+		const withTag = v.extend(account, { tag: v.string() });
+		const bus = v.event("evt_var_field", {
+			created: { account },
+		});
+		const f = v.fn({ use: [{ bus, account, withTag }] }, async (c) => {
+			return c.bus.publish("created", {
+				account: { id: "2", tag: "gold" },
+			});
+		});
+		await expect(f()).resolves.toEqual({
+			account: { id: "2", tag: "gold" },
+		});
+		expect(() =>
+			v.fn({ use: [{ bus, account, withTag }] }, (c) =>
+				c.bus.publish("created", { account: { id: "2" } } as never),
+			)(),
+		).toThrow(/tag/);
+	});
 });

packages/experimental/src/event.ts

@@ -1,5 +1,5 @@
 import { ValidationError } from "./error";
-import { asType, type InferInput, validate } from "./schema";
+import { asType, type InferInput, isVar, validate } from "./schema";
 import type {
 	LiteralString,
 	Members,
@@ -238,23 +238,89 @@ const runHandlers = (
 	return thenMaybe(run(0), () => current);
 };
 
+/** A var extension's extra fields, applied to event payloads that infer
+ * from that var when publishing inside a mounted scope. */
+export type EventVarExt = { name: string; schema: unknown };
+
+/** Fold mounted `v.extend` / same-name customize schemas onto a payload
+ * schema that references those vars - whole-var kinds and var fields. */
+const applyVarExtsToSchema = (
+	schema: unknown,
+	exts: readonly EventVarExt[],
+): unknown => {
+	if (exts.length === 0) return schema;
+	if (isVar(schema)) {
+		const name = (schema as { name: string }).name;
+		const inner = (schema as { schema?: unknown }).schema ?? {};
+		return mergeVarExtShapes(applyVarExtsToSchema(inner, exts), name, exts);
+	}
+	const def = asType(schema);
+	if (def.name !== "object" || def.shape === undefined) return schema;
+	const shape = def.shape as Record<string, unknown>;
+	const next: Record<string, unknown> = {};
+	let changed = false;
+	for (const [key, field] of Object.entries(shape)) {
+		const rewritten = applyVarExtsToSchema(field, exts);
+		next[key] = rewritten;
+		if (rewritten !== field) changed = true;
+	}
+	return changed ? { ...def, shape: next } : schema;
+};
+
+const mergeVarExtShapes = (
+	schema: unknown,
+	varName: string,
+	exts: readonly EventVarExt[],
+) => {
+	const matches = exts.filter((ext) => ext.name === varName);
+	if (matches.length === 0) return schema;
+	const def = asType(schema);
+	const shape: Record<string, unknown> =
+		def.name === "object" && def.shape !== undefined
+			? { ...(def.shape as Record<string, unknown>) }
+			: {};
+	for (const ext of matches) {
+		const extra = asType(ext.schema);
+		if (extra.name === "object" && extra.shape !== undefined) {
+			Object.assign(shape, extra.shape);
+		}
+	}
+	return {
+		...(def.name === "object" ? def : { name: "object" as const }),
+		shape,
+	};
+};
+
 const publishOn = (
 	name: string,
 	type: string,
 	data: unknown,
+	varExts: readonly EventVarExt[] = [],
 ): unknown | Promise<unknown> => {
 	const bus = getBus(name);
 	const schema = bus.types[type];
 	const path = `event.${name}.${type}`;
 	if (schema === undefined) {
 		throw new Error(`${path}: unknown event kind "${type}"`);
 	}
+	const effective = applyVarExtsToSchema(schema, varExts);
 	const handlers = [...bus.mounted, ...bus.direct];
-	return thenMaybe(validate(asType(schema), data, path), (parsed) =>
-		runHandlers(handlers, type, parsed, schema, path),
+	return thenMaybe(validate(asType(effective), data, path), (parsed) =>
+		runHandlers(handlers, type, parsed, effective, path),
 	);
 };
 
+/** Publish against a named bus, folding mounted var extensions into
+ * kinds whose payload infers from those vars. Used by a fn context so
+ * `c.bus.publish` matches the same `v.extend` / customize the handler
+ * already sees on `c.input`. */
+export const publishEvent = (
+	name: string,
+	type: string,
+	data: unknown,
+	varExts: readonly EventVarExt[] = [],
+): unknown | Promise<unknown> => publishOn(name, type, data, varExts);
+
 /** Register a module-mounted event listener (no-op if already present). */
 export const mountEventOn = (entry: EventOnEntry<string>) => {
 	getBus(entry.name).mounted.add(entry.handler);

packages/experimental/src/fn.ts

@@ -16,6 +16,7 @@ import {
 	mountEvent,
 	mountEventExtension,
 	mountEventOn,
+	publishEvent,
 } from "./event";
 import {
 	type ApplyOns,
@@ -1169,7 +1170,15 @@ const defineFn = (
 						continue;
 					}
 					if (isEvent(used)) {
-						target[name] = used;
+						const event = used as {
+							name: string;
+							types: Record<string, unknown>;
+						};
+						target[name] = {
+							...used,
+							publish: (type: string, data: unknown) =>
+								publishEvent(event.name, type, data, exts),
+						};
 						continue;
 					}
 					// Storage mounts whole - do not walk `$models` as a namespace.

packages/experimental/src/module.ts

@@ -8,7 +8,13 @@ import {
 	onEvent,
 } from "./event";
 import type { FnDefination } from "./fn";
-import { type InferArgs, type InferInput, isVar, type vTypes } from "./schema";
+import {
+	type InferArgs,
+	type InferInput,
+	isVar,
+	type TypeDefination,
+	type vTypes,
+} from "./schema";
 import type { WidenSchemaFns } from "./scope";
 import type {
 	LiteralString,
@@ -814,7 +820,9 @@ export type ExtendedArgs<PL, K extends string> = UnionToIntersection<
  * inputs also pick up `v.extend` / same-name `customize` via
  * {@link InputVarExtra}. Storage members get the same scope rewrite as a
  * db var's value ({@link WidenSchemaFns}): collections re-resolve
- * row/`Where` types against mounted `v.extend` / customize.
+ * row/`Where` types against mounted `v.extend` / customize. Event kinds
+ * whose payload is (or contains) a var pick up those same extras on
+ * `publish` / `subscribe`.
  *
  * Walks nested module GROUPS and merge-var helper intersections
  * (`{ db: { createUser } }` / `VarDef & { createUser }`) so
@@ -840,6 +848,32 @@ type ApplyOnVarHelpers<V, PL> = [Exclude<keyof V, VarSurfaceKey>] extends [
 			[K in Exclude<keyof V, VarSurfaceKey>]: ApplyOn<V[K], PL>;
 		};
 
+/**
+ * Kinds whose payload references a var `PL` mutates. `never` when none -
+ * {@link ApplyOn} then leaves the event as written.
+ */
+type EventVarExtraKeys<PL, T> = {
+	[K in keyof T]: unknown extends InputVarExtraOut<PL, T[K]> ? never : K;
+}[keyof T];
+
+/**
+ * Rewrite one event kind so {@link EventPayloads} sees mounted
+ * `v.extend` / customize fields. Unchanged kinds keep their schema;
+ * widened kinds wrap the merged payload as a type def so `InferInput`
+ * (and Date / class leaves) do not get remapped as object shapes.
+ */
+type WidenEventKind<S, PL> =
+	unknown extends InputVarExtraOut<PL, S>
+		? S
+		: TypeDefination<
+				Prettify<InferInput<S> & InputVarExtraOut<PL, S>>,
+				Prettify<InferInput<S> & InputVarExtraOut<PL, S>>
+			>;
+
+type WidenEventTypes<T, PL> = {
+	[K in keyof T]: WidenEventKind<T[K], PL>;
+};
+
 export type ApplyOn<F, PL> = F extends StorageLike
 	? WidenSchemaFns<F, PL>
 	: F extends FnDefination<
@@ -868,11 +902,15 @@ export type ApplyOn<F, PL> = F extends StorageLike
 					W,
 					O
 				>
-		: F extends { $var: true }
-			? ApplyOnVarHelpers<F, PL>
-			: [GroupMember<F>] extends [never]
+		: F extends EventDefination<infer N, infer T>
+			? [EventVarExtraKeys<PL, T>] extends [never]
 				? F
-				: { [P in keyof F]: ApplyOn<F[P], PL> };
+				: EventDefination<N, WidenEventTypes<T, PL>>
+			: F extends { $var: true }
+				? ApplyOnVarHelpers<F, PL>
+				: [GroupMember<F>] extends [never]
+					? F
+					: { [P in keyof F]: ApplyOn<F[P], PL> };
 
 export type ApplyOns<Fns, PL> = { [P in keyof Fns]: ApplyOn<Fns[P], PL> };