feat: schema extension (#65)

Author: tonyfromundefined

.changeset/some-tires-run.md

@@ -0,0 +1,5 @@
+---
+"ventyd": minor
+---
+
+feat: export event, state schema (schema.event, schema.state)

src/arktype.ts

@@ -8,7 +8,19 @@ import { type Type, type } from "arktype";
 import { standard } from "./standard";
 import type { BaseEventType, SchemaInput, ValueOf } from "./types";
 
-type ArktypeObjectType = Type<object, object>;
+type ArktypeEmptyObject = Type<object, object>;
+
+type ArktypeEventObject<
+  $$EventName extends string,
+  $$Body extends ArktypeEmptyObject,
+> = Type<{
+  eventId: string;
+  eventCreatedAt: string;
+  entityName: string;
+  entityId: string;
+  eventName: $$EventName;
+  body: $$Body["infer"];
+}>;
 
 /**
  * Creates an ArkType schema provider for Ventyd.
@@ -93,15 +105,25 @@ type ArktypeObjectType = Type<object, object>;
 export function arktype<
   $$EntityName extends string,
   $$EventBodyArktypeDefinition extends {
-    [eventName: string]: ArktypeObjectType;
+    [eventName: string]: ArktypeEmptyObject;
   },
-  $$StateArktypeDefinition extends ArktypeObjectType,
+  $$StateArktypeDefinition extends ArktypeEmptyObject,
   $$NamespaceSeparator extends string = ":",
 >(args: {
   event: $$EventBodyArktypeDefinition;
   state: $$StateArktypeDefinition;
   namespaceSeparator?: $$NamespaceSeparator;
 }) {
+  type $$EventArktypeDefinition = {
+    [key in Extract<
+      keyof $$EventBodyArktypeDefinition,
+      string
+    >]: ArktypeEventObject<
+      `${$$EntityName}${$$NamespaceSeparator}${key}`,
+      $$EventBodyArktypeDefinition[key]
+    >;
+  };
+
   type $$EventStandardDefinition = {
     [key in Extract<
       keyof $$EventBodyArktypeDefinition,
@@ -124,46 +146,56 @@ export function arktype<
   >;
   type $$StateType = StandardSchemaV1.InferOutput<$$StateStandardDefinition>;
 
-  type $$SchemaInput = SchemaInput<$$EntityName, $$EventType, $$StateType>;
+  type $$SchemaInput = SchemaInput<
+    $$EntityName,
+    $$EventType,
+    $$StateType,
+    {
+      event: $$EventArktypeDefinition;
+      state: $$StateArktypeDefinition;
+    }
+  >;
 
   const input: $$SchemaInput = (context) => {
     const namespaceSeparator = args.namespaceSeparator ?? ":";
 
-    const event = Object.entries(args.event).reduce((acc, [key, body]) => {
-      const eventName = `${context.entityName}${namespaceSeparator}${key}`;
-
-      // ArkType's intersection to combine base event and body
-      const arktypeSchema = type({
-        eventId: "string",
-        eventCreatedAt: "string",
-        entityName: "string",
-        entityId: "string",
-        eventName: `'${eventName}'`,
-        body,
-      });
-
-      // ArkType natively implements Standard Schema V1
-      // We can use it directly as a StandardSchemaV1
-      const standardSchema = arktypeSchema as unknown as StandardSchemaV1;
+    const eventSchema = Object.entries(args.event).reduce(
+      (acc, [key, body]) => {
+        const eventName = `${context.entityName}${namespaceSeparator}${key}`;
 
-      return {
-        // biome-ignore lint/performance/noAccumulatingSpread: readonly acc
-        ...acc,
-        [eventName]: standardSchema,
-      };
-    }, {} as $$EventStandardDefinition);
+        // ArkType's intersection to combine base event and body
+        const arktypeSchema = type({
+          eventId: "string",
+          eventCreatedAt: "string",
+          entityName: "string",
+          entityId: "string",
+          eventName: `'${eventName}'`,
+          body,
+        });
 
-    // ArkType state schema is already a Standard Schema V1
-    const state = args.state as unknown as $$StateStandardDefinition;
+        return {
+          // biome-ignore lint/performance/noAccumulatingSpread: readonly acc
+          ...acc,
+          [eventName]: arktypeSchema,
+        };
+      },
+      {} as $$EventArktypeDefinition,
+    );
+    const stateSchema = args.state;
 
-    return standard<
-      $$EntityName,
-      $$EventStandardDefinition,
-      $$StateStandardDefinition
-    >({
-      event,
-      state,
-    })(context);
+    return {
+      event: eventSchema,
+      state: stateSchema,
+      ...standard<
+        $$EntityName,
+        $$EventStandardDefinition,
+        $$StateStandardDefinition
+      >({
+        // ArkType natively implements Standard Schema V1
+        event: eventSchema as unknown as $$EventStandardDefinition,
+        state: stateSchema as unknown as $$StateStandardDefinition,
+      })(context),
+    };
   };
 
   return input;

src/defineSchema.ts

@@ -91,24 +91,29 @@ export function defineSchema<
   $$EventType extends BaseEventType,
   $$StateType,
   $$InitialEventName extends $$EventType["eventName"],
+  $$Extension = {},
 >(
   entityName: $$EntityName,
   options: {
-    schema: SchemaInput<$$EntityName, $$EventType, $$StateType>;
+    schema: SchemaInput<$$EntityName, $$EventType, $$StateType, $$Extension>;
     initialEventName: $$InitialEventName;
     generateId?: (type: "eventId" | "entityId") => string;
   },
-): Schema<$$EntityName, $$EventType, $$StateType, $$InitialEventName> {
+): Schema<
+  $$EntityName,
+  $$EventType,
+  $$StateType,
+  $$InitialEventName,
+  $$Extension
+> {
   const generateId = options.generateId ?? defaultGenerateId;
 
-  const { parseEvent, parseEventByName, parseState } = options.schema({
+  const schemaInput = options.schema({
     entityName,
   });
 
   return {
-    parseEvent,
-    parseEventByName,
-    parseState,
+    ...schemaInput,
     " $$entityName": entityName,
     " $$initialEventName": options.initialEventName,
     " $$generateId": generateId,

src/typebox.ts

@@ -4,13 +4,25 @@
  */
 
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import { Type } from "typebox";
+import { type TLiteral, type TObject, type TString, Type } from "typebox";
 import { standard } from "./standard";
 import { typeboxToStandardSchema } from "./typeboxToStandardSchema";
 import type { BaseEventType, SchemaInput, ValueOf } from "./types";
 
 type TypeboxEmptyObject = Type.TObject<{}>;
 
+type TypeboxEventObject<
+  $$EventName extends string,
+  $$Body extends TypeboxEmptyObject,
+> = TObject<{
+  eventId: TString;
+  eventCreatedAt: TString;
+  entityName: TString;
+  entityId: TString;
+  eventName: TLiteral<$$EventName>;
+  body: $$Body;
+}>;
+
 /**
  * Creates a TypeBox schema provider for Ventyd.
  *
@@ -103,6 +115,16 @@ export function typebox<
   state: $$StateTypeboxDefinition;
   namespaceSeparator?: $$NamespaceSeparator;
 }) {
+  type $$EventTypeboxDefinition = {
+    [key in Extract<
+      keyof $$EventBodyTypeboxDefinition,
+      string
+    >]: TypeboxEventObject<
+      `${$$EntityName}${$$NamespaceSeparator}${key}`,
+      $$EventBodyTypeboxDefinition[key]
+    >;
+  };
+
   type $$EventStandardDefinition = {
     [key in Extract<
       keyof $$EventBodyTypeboxDefinition,
@@ -125,41 +147,61 @@ export function typebox<
   >;
   type $$StateType = StandardSchemaV1.InferOutput<$$StateStandardDefinition>;
 
-  type $$SchemaInput = SchemaInput<$$EntityName, $$EventType, $$StateType>;
+  type $$SchemaInput = SchemaInput<
+    $$EntityName,
+    $$EventType,
+    $$StateType,
+    {
+      event: $$EventTypeboxDefinition;
+      state: $$StateTypeboxDefinition;
+    }
+  >;
 
   const input: $$SchemaInput = (context) => {
     const namespaceSeparator = args.namespaceSeparator ?? ":";
 
-    const event = Object.entries(args.event).reduce((acc, [key, body]) => {
-      const eventName = `${context.entityName}${namespaceSeparator}${key}`;
-      const schema = typeboxToStandardSchema(
-        Type.Object({
+    const eventSchema = Object.entries(args.event).reduce(
+      (acc, [key, body]) => {
+        const eventName = `${context.entityName}${namespaceSeparator}${key}`;
+        const schema = Type.Object({
           eventId: Type.String(),
           eventCreatedAt: Type.String(),
           entityName: Type.String(),
           entityId: Type.String(),
           eventName: Type.Literal(eventName),
           body,
-        }),
-      );
-
-      return {
-        // biome-ignore lint/performance/noAccumulatingSpread: readonly acc
-        ...acc,
-        [eventName]: schema,
-      };
-    }, {} as $$EventStandardDefinition);
-
-    const state = typeboxToStandardSchema(args.state);
+        });
+        return {
+          // biome-ignore lint/performance/noAccumulatingSpread: readonly acc
+          ...acc,
+          [eventName]: schema,
+        };
+      },
+      {} as $$EventTypeboxDefinition,
+    );
+    const stateSchema = args.state;
 
-    return standard<
-      $$EntityName,
-      $$EventStandardDefinition,
-      $$StateStandardDefinition
-    >({
-      event,
-      state,
-    })(context);
+    return {
+      event: eventSchema,
+      state: stateSchema,
+      ...standard<
+        $$EntityName,
+        $$EventStandardDefinition,
+        $$StateStandardDefinition
+      >({
+        event: Object.entries(eventSchema).reduce(
+          (acc, [eventName, schema]) => {
+            return {
+              // biome-ignore lint/performance/noAccumulatingSpread: readonly acc
+              ...acc,
+              [eventName]: typeboxToStandardSchema(schema),
+            };
+          },
+          {} as $$EventStandardDefinition,
+        ),
+        state: typeboxToStandardSchema(args.state),
+      })(context),
+    };
   };
 
   return input;