@seedcord/http 0.7.0 → 0.8.1

package/dist/{edge.index-CWUU_d_X.mjs → edge.index-CdX0NeZA.mjs}

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { GatedMetadataKey, PublishDefault, RegisterDefaults, RegisterSubscriber, accessorStore, asError, clearStore, decodeComponentRoute, deferFlags, guardedAccessor, isEmojiTuple, outcomeFor, queuedMsFor, reportDispatch, reportedWrite, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
+import { GatedMetadataKey, MiddlewareRegistry, PublishDefault, RegisterDefaults, RegisterSubscriber, accessorStore, asError, clearStore, decodeComponentRoute, deferFlags, guardedAccessor, interactionMiddleware, isEmojiTuple, outcomeFor, queuedMsFor, reportDispatch, reportedWrite, resultFor, runAfter, runHandlerGates, sendFlags, slowGateMonitor } from "@seedcord/core/internal";
 import { SeedcordError, SeedcordTypeError, applicationIdFromToken, validateDiscordToken } from "@seedcord/errors/internal";
 import { Logger } from "@seedcord/logger";
 import { Converters, Envapter } from "envapt";
@@ -46,9 +46,10 @@ function callbackData(reply, flags) {
 var ReplySender = class extends BaseReplySender {
 	ref;
 	rest;
-	constructor(ref, rest, routeId, bus) {
-		super(routeId, {
+	constructor(ref, rest, dispatch, bus) {
+		super({
 			bus,
+			dispatch,
 			interactionId: ref.id
 		});
 		this.ref = ref;
@@ -150,13 +151,13 @@ var RepliableHandler$1 = class extends RepliableHandler {
 	getEvent() {
 		return this.event;
 	}
-	buildSender(event, core, routeId) {
+	buildSender(event, core, dispatch) {
 		const ref = {
 			application_id: event.application_id,
 			id: event.id,
 			token: event.token
 		};
-		return new ReplySender(ref, core.rest, routeId, core.bus);
+		return new ReplySender(ref, core.rest, dispatch, core.bus);
 	}
 	/**
 	* Typed Discord REST API (`@discordjs/core/http-only`) over `core.rest`, one instance per core.
@@ -170,12 +171,13 @@ var RepliableHandler$1 = class extends RepliableHandler {
 
 //#endregion
 //#region src/gates/context.ts
-function interactionGateContext(payload, core, routeId) {
+function interactionGateContext(payload, core, dispatch) {
 	const member = payload.member ?? null;
 	const resolved = member?.user ?? payload.user;
 	return {
 		kind: "interaction",
 		core,
+		dispatch,
 		interaction: payload,
 		user: resolved,
 		member,
@@ -185,7 +187,7 @@ function interactionGateContext(payload, core, routeId) {
 		memberRoleIds: member?.roles ?? [],
 		memberPermissions: member ? BigInt(member.permissions) : null,
 		appPermissions: BigInt(payload.app_permissions),
-		routeId
+		declaredRoute: null
 	};
 }
 
@@ -200,18 +202,21 @@ function slashRouteOf(data) {
 
 //#endregion
 //#region src/dispatch/reportFault.ts
-function reportFault(error, uuid, routeId, payload, core) {
+function reportFault(error, uuid, dispatch, payload, core) {
 	const source = interactionSource(payload);
+	const from = {
+		uuid,
+		dispatchId: dispatch.id,
+		origin: dispatch.routeId
+	};
 	if (error instanceof Notice && source) core.bus[PublishDefault]("handledException", {
 		denial: error,
-		uuid,
-		routeId,
+		...from,
 		source
 	});
 	else core.bus[PublishDefault]("unknownException", {
-		uuid,
+		...from,
 		error,
-		routeId,
 		...actors(payload),
 		metadata: payload
 	});
@@ -313,44 +318,50 @@ async function sendGuarded(routeId, send) {
 async function respondEmptyChoices(scope) {
 	const telemetry = {
 		bus: scope.core.bus,
+		dispatch: scope.dispatch,
 		interactionId: scope.payload.id
 	};
-	await reportedWrite(telemetry, scope.routeId, "respond", () => scope.core.rest.post(Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
+	await reportedWrite(telemetry, "respond", () => scope.core.rest.post(Routes.interactionCallback(scope.payload.id, scope.payload.token), { body: {
 		type: InteractionResponseType.ApplicationCommandAutocompleteResult,
 		data: { choices: [] }
 	} }));
 }
-function renderContext(core, uuid) {
-	const developerUsername = core.config.notifications?.developerUsername;
-	return developerUsername === void 0 ? { uuid } : {
+function renderContext(scope, uuid) {
+	const { dispatch } = scope;
+	const developerUsername = scope.core.config.notifications?.developerUsername;
+	return developerUsername === void 0 ? {
+		uuid,
+		dispatch
+	} : {
 		uuid,
-		developerUsername
+		developerUsername,
+		dispatch
 	};
 }
 async function handleNotice(notice, uuid, scope) {
 	if (notice.report) {
 		logger().error(`${notice.name}: ${paint.mute(uuid)}`, notice);
-		reportFault(notice, uuid, scope.routeId, scope.payload, scope.core);
+		reportFault(notice, uuid, scope.dispatch, scope.payload, scope.core);
 	}
 	const { sender } = scope;
 	if (!sender) {
 		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
 		return;
 	}
-	const response = notice.render(renderContext(scope.core, uuid));
+	const response = notice.render(renderContext(scope, uuid));
 	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: notice.ephemeral }));
 }
 async function handleRawFault(error, uuid, scope) {
 	const { core, sender } = scope;
 	if (core.config.errors?.errorStack ?? false) logger().error(paint.mute(uuid), error);
 	else logger().error(`${paint.mute(uuid)} | ${error.message}`);
-	reportFault(error, uuid, scope.routeId, scope.payload, core);
+	reportFault(error, uuid, scope.dispatch, scope.payload, core);
 	if (!sender) {
 		await sendGuarded(scope.routeId, () => respondEmptyChoices(scope));
 		return;
 	}
 	const Override = core.config.errors?.defaultError;
-	const response = (Override ? new Override(uuid) : new Fault()).render(renderContext(core, uuid));
+	const response = (Override ? new Override(uuid) : new Fault()).render(renderContext(scope, uuid));
 	await sendGuarded(scope.routeId, () => sender.send(response, { ephemeral: true }));
 }
 async function handleFault(caught, scope) {
@@ -376,30 +387,33 @@ function unhandledRouteId(match) {
 	const key = match.attemptedKey ?? "";
 	return `${match.kind}:${key.length > 0 ? key : "unrouted"}`;
 }
-function freshScope(match, payload, core) {
+function freshScope(match, payload, core, dispatch) {
 	const ref = {
 		application_id: payload.application_id,
 		id: payload.id,
 		token: payload.token
 	};
-	const routeId = unhandledRouteId(match);
 	return {
 		core,
 		payload,
-		routeId,
-		sender: match.kind === "autocomplete" ? null : new ReplySender(ref, core.rest, routeId, core.bus)
+		routeId: unhandledRouteId(match),
+		dispatch,
+		sender: match.kind === InteractionKind.Autocomplete ? null : new ReplySender(ref, core.rest, dispatch, core.bus)
 	};
 }
-function dispatchReporter(match, payload, core) {
+function dispatchReporter(match, payload, core, dispatchId) {
 	const startedAt = performance.now();
 	const queuedMs = queuedMsFor(payload.id);
 	return (outcome) => {
 		reportDispatch(core.bus, {
+			dispatchId,
 			routeId: unhandledRouteId(match),
 			interactionId: payload.id,
 			kind: match.kind,
 			outcome,
 			fallback: match.routeId === null,
+			userId: (payload.member?.user ?? payload.user)?.id ?? null,
+			guildId: payload.guild_id ?? null,
 			startedAt,
 			queuedMs
 		});
@@ -412,61 +426,98 @@ async function answer(caught, scope, report, outcome = outcomeFor(caught)) {
 		report(outcome);
 	}
 }
-async function loadHandlerCtor(match, payload, core, report) {
+async function loadHandlerCtor(match, payload, core, dispatch, report) {
 	const routeId = unhandledRouteId(match);
 	let exported;
 	try {
 		exported = await match.load();
 	} catch (caught) {
 		logger().error(`Route ${paint.sky.bold(routeId)} failed to load its handler.`, caught);
-		await answer(caught, freshScope(match, payload, core), report, "failed");
+		await answer(caught, freshScope(match, payload, core, dispatch), report, "failed");
 		return null;
 	}
 	if (isHandlerCtor(exported)) return exported;
 	logger().error(`Route ${paint.sky.bold(routeId)} loaded an export that is not a handler class.`);
-	await answer(/* @__PURE__ */ new Error(`route ${routeId} loaded an export that is not a handler class`), freshScope(match, payload, core), report, "failed");
+	await answer(/* @__PURE__ */ new Error(`route ${routeId} loaded an export that is not a handler class`), freshScope(match, payload, core, dispatch), report, "failed");
 	return null;
 }
+async function runMiddlewares(step, kind, sender) {
+	const { args, dispatch, ran } = step;
+	for (const Middleware of args.middlewares.chainFor(kind)) {
+		const event = args.payload;
+		const instance = new Middleware(event, args.core, dispatch, sender);
+		ran.push(instance);
+		await instance.execute();
+	}
+}
+async function refusalBeforeHandler(step) {
+	const { args, scope } = step;
+	const { kind } = args.match;
+	if (kind !== InteractionKind.Autocomplete && scope.sender) try {
+		await runMiddlewares(step, kind, scope.sender);
+	} catch (caught) {
+		return { caught };
+	}
+	return gateRefusal(step);
+}
 async function dispatchInteraction(args) {
 	const { match, payload, core } = args;
-	const report = dispatchReporter(match, payload, core);
-	const Handler = await loadHandlerCtor(match, payload, core, report);
-	if (!Handler) return null;
 	const routeId = unhandledRouteId(match);
-	logger().debug(`Processing ${paint.sky.bold(routeId)} with ${paint.mute(Handler.name)}`);
 	const dispatch = new DispatchContext(routeId);
+	const report = dispatchReporter(match, payload, core, dispatch.id);
+	const Handler = await loadHandlerCtor(match, payload, core, dispatch, report);
+	if (!Handler) return null;
+	logger().debug(`Processing ${paint.sky.bold(routeId)} with ${paint.mute(Handler.name)}`);
 	let handler;
 	try {
 		handler = new Handler(payload, core, dispatch);
 	} catch (caught) {
-		await answer(caught, freshScope(match, payload, core), report);
+		await answer(caught, freshScope(match, payload, core, dispatch), report);
 		return null;
 	}
 	const scope = {
 		core,
 		payload,
 		routeId,
+		dispatch,
 		sender: handler instanceof RepliableHandler$1 ? handler.sender : null
 	};
-	const refusal = await gateRefusal(Handler, match, payload, core);
+	const ran = [];
+	const refusal = await refusalBeforeHandler({
+		args,
+		Handler,
+		dispatch,
+		scope,
+		ran
+	});
 	if (refusal) {
-		await answer(refusal.caught, scope, report);
+		try {
+			await answer(refusal.caught, scope, report);
+		} finally {
+			await runAfter(ran, resultFor(refusal.caught), logger());
+		}
 		return null;
 	}
 	return async () => {
+		let result = { outcome: "handled" };
 		try {
 			await handler.execute();
 			report("handled");
 		} catch (caught) {
+			result = resultFor(caught);
 			await answer(caught, scope, report);
+		} finally {
+			await runAfter(ran, result, logger());
 		}
 	};
 }
-async function gateRefusal(ctor, match, payload, core) {
-	if (match.kind === "autocomplete" || payload.type === InteractionType.ApplicationCommandAutocomplete) return null;
+async function gateRefusal(step) {
+	const { Handler, dispatch } = step;
+	const { match, payload, core } = step.args;
+	if (match.kind === InteractionKind.Autocomplete || payload.type === InteractionType.ApplicationCommandAutocomplete) return null;
 	const monitor = slowGateMonitor();
 	try {
-		await runHandlerGates(ctor, interactionGateContext(payload, core, match.routeId), match.routeId ?? void 0, monitor?.observe);
+		await runHandlerGates(Handler, interactionGateContext(payload, core, dispatch), match.routeId ?? void 0, monitor?.observe);
 		return null;
 	} catch (caught) {
 		return { caught };
@@ -637,11 +688,11 @@ var AutocompleteHandler = class extends BaseHandler {
 	}
 	/** Send autocomplete suggestions, callback type 8. Prefer {@link match}, which restricts each field's choices to its declared type. */
 	async respond(choices) {
-		const routeId = this.dispatch?.routeId ?? "autocomplete";
 		await reportedWrite({
 			bus: this.core.bus,
+			dispatch: this.dispatch,
 			interactionId: this.event.id
-		}, routeId, "respond", () => this.core.rest.post(Routes.interactionCallback(this.event.id, this.event.token), { body: {
+		}, "respond", () => this.core.rest.post(Routes.interactionCallback(this.event.id, this.event.token), { body: {
 			type: InteractionResponseType.ApplicationCommandAutocompleteResult,
 			data: { choices }
 		} }));
@@ -899,7 +950,7 @@ const decoder = new TextDecoder();
 function hasInteractionType(payload) {
 	return typeof payload === "object" && payload !== null && "type" in payload && typeof payload.type === "number";
 }
-function buildEngine(core, maps) {
+function buildEngine(core, maps, middlewares) {
 	if (!Envapter.has("DISCORD_PUBLIC_KEY")) throw new SeedcordError(SeedcordErrorCode.ConfigMissingEnv, ["DISCORD_PUBLIC_KEY"]);
 	const publicKey = Envapter.getRequired("DISCORD_PUBLIC_KEY", Converters.String);
 	const verifier = new Ed25519Verifier(publicKey);
@@ -910,7 +961,8 @@ function buildEngine(core, maps) {
 		const start = await dispatchInteraction({
 			match,
 			payload,
-			core
+			core,
+			middlewares
 		});
 		if (!start) return;
 		const work = start().catch(rootFault);
@@ -990,7 +1042,7 @@ function createSeedcord(config, manifest) {
 	const core = createCore(config, token);
 	core.bus[RegisterDefaults]();
 	registerSubscribers(core.bus, manifest);
-	return buildEngine(core, buildRouteMaps(manifest)).handle;
+	return buildEngine(core, buildRouteMaps(manifest), new MiddlewareRegistry(interactionMiddleware)).handle;
 }
 
 //#endregion
@@ -1238,6 +1290,34 @@ var EmojiInjector = class {
 	}
 };
 
+//#endregion
+//#region src/handlers/interaction/InteractionMiddleware.ts
+/**
+* Base class for interaction middleware on the HTTP transport.
+*
+* Middleware runs after the dispatcher builds the handler and before the gates, over the handler's own
+* reply surface. Name the kinds in the generic and list the same ones in `{ kinds }`. Several kinds give
+* `this.event` a union. Narrow it on `type` and `data.component_type`. A catchall reads every repliable
+* kind.
+*
+* @typeParam Kind - One or more {@link InteractionKind} members. Defaults to every repliable kind.
+*
+* @example
+* ```ts
+* \@RegisterInteractionMiddleware({ kinds: [InteractionKind.Button] })
+* class Audit extends InteractionMiddleware<InteractionKind.Button> {
+*     async execute() {
+*         this.logger.info(this.event.data.custom_id);
+*     }
+* }
+* ```
+*/
+var InteractionMiddleware = class extends RepliableHandler$1 {
+	constructor(event, core, dispatch, sender) {
+		super(event, core, dispatch, sender);
+	}
+};
+
 //#endregion
 //#region src/handlers/interaction/SlashHandler.ts
 /**
@@ -1813,8 +1893,8 @@ function Gated(...gates) {
 
 //#endregion
 //#region src/version.ts
-const version = "0.7.0";
+const version = "0.8.1";
 
 //#endregion
-export { createSeedcord as C, AutocompleteHandler as D, InteractionHandler as E, RepliableHandler$1 as O, ModalFields as S, buildRouteMaps as T, MessageContextMenuHandler as _, Paginator as a, EmojiInjector as b, ChannelMenuHandler as c, SelectMenuHandler as d, StringMenuHandler as f, ComponentHandler as g, ButtonHandler as h, CursorSource as i, ReplySender as k, MentionableMenuHandler as l, ModalHandler as m, Gated as n, Subscriber$1 as o, UserMenuHandler as p, ArraySource as r, WebhookLog$1 as s, version as t, RoleMenuHandler as u, UserContextMenuHandler as v, buildEngine as w, Emojis as x, SlashHandler as y };
-//# sourceMappingURL=edge.index-CWUU_d_X.mjs.map
+export { ReplySender as A, ModalFields as C, InteractionHandler as D, buildRouteMaps as E, AutocompleteHandler as O, Emojis as S, buildEngine as T, MessageContextMenuHandler as _, Paginator as a, InteractionMiddleware as b, ChannelMenuHandler as c, SelectMenuHandler as d, StringMenuHandler as f, ComponentHandler as g, ButtonHandler as h, CursorSource as i, RepliableHandler$1 as k, MentionableMenuHandler as l, ModalHandler as m, Gated as n, Subscriber$1 as o, UserMenuHandler as p, ArraySource as r, WebhookLog$1 as s, version as t, RoleMenuHandler as u, UserContextMenuHandler as v, createSeedcord as w, EmojiInjector as x, SlashHandler as y };
+//# sourceMappingURL=edge.index-CdX0NeZA.mjs.map