feat(expermental): infer .input & .output of vars in events

Author: ping-maxwell

packages/experimental/src/event.test.ts

@@ -309,4 +309,47 @@ describe("event extension + modules", () => {
 			)(),
 		).toThrow(/tag/);
 	});
+
+	it("publish expects .input; complete resolves .output", async () => {
+		const user = v.var("evt_io_user", {
+			schema: v.object({
+				id: v.noInput(v.string({ default: "minted" })),
+				email: v.string(),
+				passwordHash: v.noOutput(v.string()),
+			}),
+		});
+		const bus = v.event("evt_io", { created: user });
+
+		bus.subscribe(async (e, next) => {
+			if (e.type === "created") {
+				await next({
+					id: "srv-1",
+					passwordHash: "hashed",
+				});
+				return;
+			}
+			await next();
+		});
+
+		expect(() =>
+			bus.publish("created", {
+				email: "a@b.c",
+				id: "smuggle",
+			} as never),
+		).toThrow(/noInput field/);
+
+		const [result, complete] = await bus.publish("created", {
+			email: "a@b.c",
+			passwordHash: "plain",
+		});
+		expectTypeOf(result).toEqualTypeOf<{
+			email: string;
+			passwordHash: string;
+		}>();
+		expect(result).toEqual({ email: "a@b.c", passwordHash: "plain" });
+
+		const out = await complete();
+		expectTypeOf(out).toEqualTypeOf<{ id: string; email: string }>();
+		expect(out).toEqual({ id: "srv-1", email: "a@b.c" });
+	});
 });

packages/experimental/src/event.ts

@@ -1,17 +1,45 @@
 import { ValidationError } from "./error";
-import { asType, type InferInput, isVar, validate } from "./schema";
+import {
+	asType,
+	type InferArgs,
+	type InferInput,
+	isNoInput,
+	isNoOutput,
+	isVar,
+	projectValue,
+	rejectFields,
+	type SchemaInputOf,
+	type SchemaOutputOf,
+	toInputSchema,
+	validate,
+} from "./schema";
 import type {
 	LiteralString,
 	Members,
 	Prettify,
 	UnionToIntersection,
 } from "./types";
 
-/** Payload for each kind in an event-type map. */
+/** Handler-visible payload (full schema, including noInput / noOutput). */
 export type EventPayloads<T> = {
 	[K in keyof T]: InferInput<T[K]>;
 };
 
+/** What {@link EventDefination.publish} accepts - the `.input` view. */
+export type EventPublishArgs<T> = {
+	[K in keyof T]: InferArgs<SchemaInputOf<T[K]>>;
+};
+
+/** Validated publish-time payload - parsed `.input` view. */
+export type EventPublishResult<T> = {
+	[K in keyof T]: InferInput<SchemaInputOf<T[K]>>;
+};
+
+/** What `complete()` resolves to - the `.output` view. */
+export type EventCompleteResult<T> = {
+	[K in keyof T]: InferInput<SchemaOutputOf<T[K]>>;
+};
+
 /** Discriminated message handed to subscribers. */
 export type EventMessage<T> = Prettify<
 	{
@@ -47,18 +75,21 @@ export interface EventDefination<
 	 */
 	subscribe: (handler: EventHandler<T>) => () => void;
 	/**
-	 * Validate `data` against the kind's schema, run subscribers (direct +
-	 * any mounted via `v.on` / modules), merge `next` mutations, and return:
-	 * - `result`: the validated payload at publish-time
-	 * - `complete`: a promise function resolving to the final payload after
-	 *   the full subscriber chain finishes
+	 * Validate `data` against the kind's `.input` view, run subscribers
+	 * (direct + any mounted via `v.on` / modules), merge `next` mutations,
+	 * and return:
+	 * - `result`: the validated `.input` payload at publish-time
+	 * - `complete`: a promise function resolving to the `.output` payload
+	 *   after the full subscriber chain finishes
 	 */
 	publish: <K extends keyof T & string>(
 		type: K,
-		data: EventPayloads<T>[K],
+		data: EventPublishArgs<T>[K],
 	) =>
-		| [EventPayloads<T>[K], () => Promise<EventPayloads<T>[K]>]
-		| Promise<[EventPayloads<T>[K], () => Promise<EventPayloads<T>[K]>]>;
+		| [EventPublishResult<T>[K], () => Promise<EventCompleteResult<T>[K]>]
+		| Promise<
+				[EventPublishResult<T>[K], () => Promise<EventCompleteResult<T>[K]>]
+		  >;
 	/**
 	 * Mint a NEW event def under the same name with more kinds - the
 	 * re-export pattern (`customize` for vars). Shared bus; widened types.
@@ -307,12 +338,30 @@ const publishOn = (
 	}
 	const effective = applyVarExtsToSchema(schema, varExts);
 	const handlers = [...bus.mounted, ...bus.direct];
-	return thenMaybe(validate(asType(effective), data, path), (parsed) => {
+	// Publish door matches v.fn input: reject smuggled noInput keys, then
+	// validate the `.input` view. Handlers still patch against the full
+	// schema so they can fill noInput fields via `next`.
+	const parseInput = () =>
+		thenMaybe(
+			rejectFields(
+				effective,
+				data,
+				isNoInput,
+				path,
+				"noInput field is not allowed",
+			),
+			() => validate(asType(toInputSchema(effective)), data, path),
+		);
+	return thenMaybe(parseInput(), (parsed) => {
 		const done = runHandlers(handlers, type, parsed, effective, path);
 		return [
 			parsed,
 			() =>
-				isThenable(done) ? (done as Promise<unknown>) : Promise.resolve(done),
+				Promise.resolve(
+					thenMaybe(done, (final) =>
+						projectValue(effective, final, isNoOutput),
+					),
+				),
 		] as [unknown, () => Promise<unknown>];
 	});
 };

packages/experimental/src/index.ts

@@ -148,13 +148,16 @@ export {
 	ValidationError,
 } from "./error";
 export type {
+	EventCompleteResult,
 	EventDefination,
 	EventExtension,
 	EventHandler,
 	EventMessage,
 	EventNext,
 	EventOnEntry,
 	EventPayloads,
+	EventPublishArgs,
+	EventPublishResult,
 	EventsFrom,
 	ModuleEvents,
 } from "./event";

packages/experimental/src/schema.ts

@@ -691,9 +691,10 @@ export const omitFields = <S>(schema: S, drop: FieldPred): S => {
 /**
  * Strip keys from an already-validated value where `drop` matches the
  * field schema. Used after union arm selection so defaults/transforms
- * from the probe validate are not run a second time.
+ * from the probe validate are not run a second time, and by event
+ * `complete()` to project the `.output` view without re-transforming.
  */
-const omitValue = (
+export const projectValue = (
 	schema: unknown,
 	value: unknown,
 	drop: FieldPred,
@@ -711,16 +712,19 @@ const omitValue = (
 			def.shape as Record<string, unknown>,
 		)) {
 			if (drop(child) || !Object.hasOwn(record, key)) continue;
-			out[key] = omitValue(child, record[key], drop);
+			out[key] = projectValue(child, record[key], drop);
 		}
 		return out;
 	}
 	if (def.name === "array" && def.shape !== undefined && Array.isArray(value)) {
-		return value.map((item) => omitValue(def.shape, item, drop));
+		return value.map((item) => projectValue(def.shape, item, drop));
 	}
 	return value;
 };
 
+/** @deprecated Use {@link projectValue}. */
+const omitValue = projectValue;
+
 /**
  * Throw if any field matching `match` is present on `value` (own key).
  * Object validation otherwise strips unknown keys, so this is what stops