Add generic function invocation event to all event schemas

.changeset/violet-phones-provide.md

@@ -0,0 +1,5 @@
+---
+"inngest": patch
+---
+
+Add generic function invocation event to all event schemas

packages/inngest/src/components/EventSchemas.test.ts

@@ -18,7 +18,8 @@ describe("EventSchemas", () => {
 
     type Expected =
       | `${internalEvents.FunctionFailed}`
-      | `${internalEvents.FunctionFinished}`;
+      | `${internalEvents.FunctionFinished}`
+      | `${internalEvents.FunctionInvoked}`;
 
     type Actual = Schemas<typeof schemas>[keyof Schemas<
       typeof schemas

packages/inngest/src/components/EventSchemas.ts

@@ -1,14 +1,12 @@
 import { type Simplify } from "type-fest";
-import {
-  type FnFailedEventName,
-  type FnFinishedEventName,
-} from "../helpers/consts";
+import { type internalEvents } from "../helpers/consts";
 import { type IsEmptyObject, type IsStringLiteral } from "../helpers/types";
 import type * as z from "../helpers/validators/zod";
 import {
   type EventPayload,
   type FailureEventPayload,
   type FinishedEventPayload,
+  type InvokedEventPayload,
 } from "../types";
 
 /**
@@ -33,6 +31,26 @@ export type StandardEventSchema = {
  */
 export type StandardEventSchemas = Record<string, StandardEventSchema>;
 
+/**
+ * Asserts that the given type `T` contains a mapping for all internal events.
+ *
+ * Usage of this ensures that we never forget about an internal event in schemas
+ * when adding new ones.
+ *
+ * It also ensures that the mapped name is not the enum type, as this would
+ * require a user to use the enum type to access the event schema to declare
+ * triggers, where we want to allow them to use the string literal.
+ *
+ * @public
+ */
+export type AssertInternalEventPayloads<
+  T extends Record<internalEvents, EventPayload>,
+> = {
+  [K in keyof T as `${K & string}`]: Simplify<
+    Omit<T[K], "name"> & { name: `${K & string}` }
+  >;
+};
+
 /**
  * A string error used to highlight to a user that they have a clashing name
  * between the event name and the key of the event schema.
@@ -219,10 +237,11 @@ export type Combine<
  * @public
  */
 export class EventSchemas<
-  S extends Record<string, EventPayload> = {
-    [FnFailedEventName]: FailureEventPayload;
-    [FnFinishedEventName]: FinishedEventPayload;
-  },
+  S extends Record<string, EventPayload> = AssertInternalEventPayloads<{
+    [internalEvents.FunctionFailed]: FailureEventPayload;
+    [internalEvents.FunctionFinished]: FinishedEventPayload;
+    [internalEvents.FunctionInvoked]: InvokedEventPayload;
+  }>,
 > {
   /**
    * Use generated Inngest types to type events.

packages/inngest/src/helpers/consts.ts

@@ -145,14 +145,6 @@ export enum internalEvents {
   FunctionFinished = "inngest/function.finished",
 }
 
-/**
- * Accessing enum values as literals in some TypeScript types can be difficult,
- * so we also manually create the string values here.
- */
-export const FnFailedEventName = `${internalEvents.FunctionFailed}`;
-export const FnInvokedEventName = `${internalEvents.FunctionInvoked}`;
-export const FnFinishedEventName = `${internalEvents.FunctionFinished}`;
-
 export const logPrefix = chalk.magenta.bold("[Inngest]");
 
 export const debugPrefix = "inngest";

packages/inngest/src/index.ts

@@ -1,5 +1,6 @@
 export {
   EventSchemas,
+  type AssertInternalEventPayloads,
   type Combine,
   type LiteralZodEventSchema,
   type StandardEventSchemaToPayload,

packages/inngest/src/types.ts

@@ -97,6 +97,18 @@ export type FinishedEventPayload = {
   );
 };
 
+/**
+ * The payload for any generic function invocation event. In practice, the event
+ * data will be more specific to the function being invoked.
+ *
+ * @public
+ */
+export type InvokedEventPayload = Simplify<
+  Omit<EventPayload, "name"> & {
+    name: `${internalEvents.FunctionInvoked}`;
+  }
+>;
+
 /**
  * Unique codes for the different types of operation that can be sent to Inngest
  * from SDK step functions.