@typeonce/effect-machine 0.8.0 → 0.9.0

package/src/internal/machine/protocol.ts

@@ -9,6 +9,7 @@ import * as Effect from "effect/Effect"
 import { hasProperty } from "effect/Predicate"
 import * as Result from "effect/Result"
 import * as Schema from "effect/Schema"
+import * as SchemaAST from "effect/SchemaAST"
 import type { Machine } from "../../Machine.js"
 import { MachineSchemaDecodeError } from "./errors.js"
 import { getStateNodeSchema, isStateInput } from "./topology.js"
@@ -26,6 +27,15 @@ interface MachineProtocolSchemas {
   readonly trustedEvents: WeakSet<object>
 }
 
+export const EventConstructionTypeId: unique symbol = Symbol("effect/Machine/EventConstruction")
+
+interface EventConstruction {
+  readonly [EventConstructionTypeId]: typeof EventConstructionTypeId
+  readonly _tag: PropertyKey
+  readonly schema: Machine.TaggedSchema
+  readonly input: unknown
+}
+
 type BoundaryDecoder = (value: unknown) => Effect.Effect<unknown, Schema.SchemaError, unknown>
 
 type BoundaryResultDecoder = (value: unknown) => Result.Result<unknown, Schema.SchemaError>
@@ -111,6 +121,88 @@ export const copyProtocol = (source: Machine.Any, target: Machine.Any): void =>
 export const getEventName = (event: unknown): string | undefined =>
   hasProperty(event, "_tag") ? String(event._tag) : undefined
 
+const makeEventConstruction = (
+  schema: Machine.TaggedSchema,
+  tag: PropertyKey,
+  input: unknown
+): EventConstruction => ({
+  [EventConstructionTypeId]: EventConstructionTypeId,
+  _tag: tag,
+  schema,
+  input
+})
+
+const isEventConstruction = (value: unknown): value is EventConstruction => hasProperty(value, EventConstructionTypeId)
+
+export const eventConstructors = (
+  schemas: ReadonlyArray<Machine.TaggedSchema>
+): Readonly<Record<PropertyKey, (...args: ReadonlyArray<unknown>) => EventConstruction>> => {
+  const leaves: Array<Machine.TaggedSchema> = []
+  const collect = (schema: Machine.TaggedSchema): void => {
+    if (hasProperty(schema, "cases") && typeof schema.cases === "object" && schema.cases !== null) {
+      for (const candidate of Reflect.ownKeys(schema.cases)) {
+        collect(Reflect.get(schema.cases, candidate) as Machine.TaggedSchema)
+      }
+      return
+    }
+    if (hasProperty(schema, "members") && Array.isArray(schema.members)) {
+      for (const member of schema.members) collect(member as Machine.TaggedSchema)
+      return
+    }
+    leaves.push(schema)
+  }
+  for (const schema of schemas) collect(schema)
+  const constructors = Object.create(null) as Record<
+    PropertyKey,
+    (...args: ReadonlyArray<unknown>) => EventConstruction
+  >
+  const tags = (ast: SchemaAST.AST): ReadonlyArray<PropertyKey> => {
+    if (SchemaAST.isLiteral(ast)) {
+      return typeof ast.literal === "string" || typeof ast.literal === "number" ? [ast.literal] : []
+    }
+    if (SchemaAST.isUniqueSymbol(ast)) return [ast.symbol]
+    if (SchemaAST.isEnum(ast)) return ast.enums.map(([, value]) => value)
+    if (SchemaAST.isUnion(ast)) return ast.types.flatMap(tags)
+    if (SchemaAST.isSuspend(ast)) return tags(ast.thunk())
+    return []
+  }
+  const schemaTags = (schema: Machine.TaggedSchema): ReadonlyArray<PropertyKey> => {
+    const ast = SchemaAST.toType(schema.ast)
+    if (SchemaAST.isObjects(ast)) {
+      const tag = ast.propertySignatures.find(({ name }) => name === "_tag")
+      const discriminants = tag === undefined ? [] : tags(tag.type)
+      if (discriminants.length > 0) return discriminants
+    }
+    try {
+      return Schema.Union([schema]).pipe(Schema.toTaggedUnion("_tag")).discriminants
+    } catch {
+      return []
+    }
+  }
+  for (const schema of leaves) {
+    const discriminants = schemaTags(schema)
+    if (discriminants.length === 0) {
+      throw new Error("Machine event constructors require finite literal or unique symbol event tags")
+    }
+    for (const tag of discriminants) {
+      if (hasProperty(constructors, tag)) {
+        throw new Error(`Duplicate machine event constructor tag: ${String(tag)}`)
+      }
+      Object.defineProperty(constructors, tag, {
+        value: (...args: ReadonlyArray<unknown>) => {
+          const fields = args.length === 0 ? {} : args[0]
+          const input = typeof fields === "object" && fields !== null
+            ? { ...fields, _tag: tag }
+            : { _tag: tag }
+          return makeEventConstruction(schema, tag, input)
+        },
+        enumerable: true
+      })
+    }
+  }
+  return constructors
+}
+
 export const decodeBoundary = <A>(
   machine: Machine.Any,
   schema: Schema.Top,
@@ -195,6 +287,54 @@ export const makeEvent = <Schema extends Machine.TaggedSchema>(
   return event
 }
 
+const eventConstructionProtocolError = (
+  machine: Machine.Any,
+  construction: EventConstruction
+): MachineSchemaDecodeError =>
+  new MachineSchemaDecodeError({
+    machineId: machine.id,
+    boundary: "event",
+    event: String(construction._tag),
+    cause: Cause.die(new Error("Constructed event schema does not belong to the machine event protocol"))
+  })
+
+const decodeEventConstruction = (
+  machine: Machine.Any,
+  protocol: MachineProtocolSchemas,
+  construction: EventConstruction
+): Effect.Effect<unknown, MachineSchemaDecodeError> => {
+  if (!protocol.eventConstructors.has(construction.schema as object)) {
+    return Effect.fail(eventConstructionProtocolError(machine, construction))
+  }
+  return construction.schema.makeEffect(construction.input as never).pipe(
+    Effect.mapError((cause) =>
+      new MachineSchemaDecodeError({
+        machineId: machine.id,
+        boundary: "event",
+        event: String(construction._tag),
+        cause: new Schema.SchemaError(cause)
+      })
+    ),
+    Effect.tap((event) => Effect.sync(() => protocol.trustedEvents.add(event as object)))
+  )
+}
+
+const decodeEventConstructionSync = (
+  machine: Machine.Any,
+  protocol: MachineProtocolSchemas,
+  construction: EventConstruction
+): unknown => {
+  if (!protocol.eventConstructors.has(construction.schema as object)) {
+    throw eventConstructionProtocolError(machine, construction)
+  }
+  const event = makeBoundarySync(machine, construction.schema, construction.input, {
+    boundary: "event",
+    event: String(construction._tag)
+  })
+  protocol.trustedEvents.add(event as object)
+  return event
+}
+
 const isTrustedEvent = (protocol: MachineProtocolSchemas, event: unknown): boolean =>
   typeof event === "object" && event !== null && protocol.trustedEvents.has(event)
 
@@ -210,6 +350,12 @@ export const decodeEvent = <const Events extends ReadonlyArray<Machine.TaggedSch
   event: unknown
 ): Effect.Effect<Machine.EventOf<Events>, MachineSchemaDecodeError> => {
   const protocol = getProtocolSchemas(machine)
+  if (isEventConstruction(event)) {
+    return decodeEventConstruction(machine, protocol, event) as Effect.Effect<
+      Machine.EventOf<Events>,
+      MachineSchemaDecodeError
+    >
+  }
   if (isTrustedEvent(protocol, event)) {
     return Effect.succeed(event as Machine.EventOf<Events>)
   }
@@ -227,6 +373,9 @@ export const decodeEventSync = <const Events extends ReadonlyArray<Machine.Tagge
   event: unknown
 ): Machine.EventOf<Events> => {
   const protocol = getProtocolSchemas(machine)
+  if (isEventConstruction(event)) {
+    return decodeEventConstructionSync(machine, protocol, event) as Machine.EventOf<Events>
+  }
   if (isTrustedEvent(protocol, event)) {
     return event as Machine.EventOf<Events>
   }

package/src/internal/machine/symbols.ts

@@ -1,2 +1,5 @@
 /** @internal */
 export const InitialEventTypeId: unique symbol = Symbol("effect/Machine/InitialEvent")
+
+/** @internal Returns process logic for a child descriptor and optional input. */
+export const ChildMachineLogicTypeId: unique symbol = Symbol("effect/Machine/ChildMachineLogic")

package/src/internal/machine/topology.ts

@@ -392,6 +392,29 @@ export const transitionDefinitions = (
         targets: transitionTargets(config.onDone)
       })
     }
+    const invokes = config.invoke === undefined
+      ? []
+      : Array.isArray(config.invoke)
+      ? config.invoke
+      : [config.invoke]
+    for (const invoke of invokes) {
+      const id = "child" in invoke ? String(invoke.child.id) : String(invoke.id)
+      for (const outcome of ["done", "failure", "snapshot"] as const) {
+        const handler = outcome === "done"
+          ? invoke.onDone
+          : outcome === "failure"
+          ? invoke.onFailure
+          : invoke.onSnapshot
+        if (handler !== undefined) {
+          definitions.push({
+            source: node.path,
+            trigger: { type: "invoke", id, outcome },
+            reenter: typeof handler === "object" && handler !== null && handler.reenter === true,
+            targets: transitionTargets(handler)
+          })
+        }
+      }
+    }
   }
   return definitions
 }

package/src/unstable/reactivity/AtomMachine.ts

@@ -537,7 +537,7 @@ type MachineInputArgsOf<M extends Machine.Machine.Any> = [
 
 type MachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<
   Machine.Machine.Snapshot<Machine.Machine.States<M>>,
-  Machine.Machine.InputEvent<M>,
+  Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
   MachineRuntimeError<Machine.Machine.Error<M>, Machine.Machine.Services<M>>,
   Machine.Machine.Output<M>,
   MachineStartError<
@@ -551,7 +551,7 @@ type MachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<
 
 type ResumedMachineAtomOf<M extends Machine.Machine.Any, RuntimeError> = MachineAtom<
   Machine.Machine.Snapshot<Machine.Machine.States<M>>,
-  Machine.Machine.InputEvent<M>,
+  Machine.Machine.EventInput<Machine.Machine.InputEvent<M>>,
   MachineRuntimeError<Machine.Machine.Error<M>, Machine.Machine.Services<M>>,
   Machine.Machine.Output<M>,
   Machine.MachineSchemaDecodeError | RuntimeError
@@ -661,7 +661,7 @@ export const make: {
     ...args: [...Machine.Machine.InputArgs<Input>]
   ): MachineAtom<
     Machine.Machine.Snapshot<States>,
-    Machine.Machine.EventOf<InputEvents>,
+    Machine.Machine.EventInputOf<InputEvents>,
     MachineRuntimeError<E, R>,
     Output,
     MachineStartError<InitialE, E, InitialR, R>