[core] Fix Actor<T> not assignable to ActorRef<T> problem (#5011)

* Add failing test * Add stricter `ActorRefFromLogic`, improve `ActorRefFrom` * Changeset * Remove test
statelyai · Aug 9, 2024 · a275d27 · a275d27
1 parent 437738d
commit a275d27
Show file tree

Hide file tree

Showing 9 changed files with 67 additions and 66 deletions.
diff --git a/.changeset/tasty-kangaroos-lay.md b/.changeset/tasty-kangaroos-lay.md
@@ -0,0 +1,5 @@
+---
+'xstate': patch
+---
+
+There is a new type helper: `ActorRefFromLogic<TLogic>`. This type is a stricter form of `ActorRefFrom<TLogic>` that only accepts actor logic types. See https://github.com/statelyai/xstate/issues/4997 for more details.
diff --git a/packages/core/src/actors/callback.ts b/packages/core/src/actors/callback.ts
@@ -2,7 +2,7 @@ import { XSTATE_STOP } from '../constants.ts';
 import { AnyActorSystem } from '../system.ts';
 import {
   ActorLogic,
-  ActorRefFrom,
+  ActorRefFromLogic,
   AnyActorRef,
   AnyEventObject,
   EventObject,
@@ -73,7 +73,7 @@ export type CallbackActorLogic<
 export type CallbackActorRef<
   TEvent extends EventObject,
   TInput = NonReducibleUnknown
-> = ActorRefFrom<CallbackActorLogic<TEvent, TInput>>;
+> = ActorRefFromLogic<CallbackActorLogic<TEvent, TInput>>;
 
 type Receiver<TEvent extends EventObject> = (
   listener: {

diff --git a/packages/core/src/actors/observable.ts b/packages/core/src/actors/observable.ts
@@ -2,7 +2,7 @@ import { XSTATE_STOP } from '../constants';
 import { AnyActorSystem } from '../system.ts';
 import {
   ActorLogic,
-  ActorRefFrom,
+  ActorRefFromLogic,
   EventObject,
   NonReducibleUnknown,
   Snapshot,
@@ -67,7 +67,7 @@ export type ObservableActorLogic<
  * @see {@link fromObservable}
  * @see {@link fromEventObservable}
  */
-export type ObservableActorRef<TContext> = ActorRefFrom<
+export type ObservableActorRef<TContext> = ActorRefFromLogic<
   ObservableActorLogic<TContext, any>
 >;
 

diff --git a/packages/core/src/actors/promise.ts b/packages/core/src/actors/promise.ts
@@ -2,7 +2,7 @@ import { XSTATE_STOP } from '../constants.ts';
 import { AnyActorSystem } from '../system.ts';
 import {
   ActorLogic,
-  ActorRefFrom,
+  ActorRefFromLogic,
   AnyActorRef,
   EventObject,
   NonReducibleUnknown,
@@ -61,7 +61,7 @@ export type PromiseActorLogic<
  *
  * @see {@link fromPromise}
  */
-export type PromiseActorRef<TOutput> = ActorRefFrom<
+export type PromiseActorRef<TOutput> = ActorRefFromLogic<
   PromiseActorLogic<TOutput, unknown>
 >;
 

diff --git a/packages/core/src/actors/transition.ts b/packages/core/src/actors/transition.ts
@@ -1,7 +1,7 @@
 import { AnyActorSystem } from '../system.ts';
 import {
   ActorLogic,
-  ActorRefFrom,
+  ActorRefFromLogic,
   ActorScope,
   EventObject,
   NonReducibleUnknown,
@@ -86,7 +86,7 @@ export type TransitionActorLogic<
 export type TransitionActorRef<
   TContext,
   TEvent extends EventObject
-> = ActorRefFrom<
+> = ActorRefFromLogic<
   TransitionActorLogic<TransitionSnapshot<TContext>, TEvent, unknown>
 >;
 

diff --git a/packages/core/src/spawn.ts b/packages/core/src/spawn.ts
@@ -1,6 +1,6 @@
 import { ProcessingStatus, createActor } from './createActor.ts';
 import {
-  ActorRefFrom,
+  ActorRefFromLogic,
   AnyActorLogic,
   AnyActorRef,
   AnyActorScope,
@@ -43,7 +43,7 @@ export type Spawner<TActor extends ProvidedActor> = IsLiteralString<
       <TSrc extends TActor['src']>(
         logic: TSrc,
         ...[options]: SpawnOptions<TActor, TSrc>
-      ): ActorRefFrom<GetConcreteByKey<TActor, 'src', TSrc>['logic']>;
+      ): ActorRefFromLogic<GetConcreteByKey<TActor, 'src', TSrc>['logic']>;
       <TLogic extends AnyActorLogic>(
         src: TLogic,
         options?: {
@@ -52,7 +52,7 @@ export type Spawner<TActor extends ProvidedActor> = IsLiteralString<
           input?: InputFrom<TLogic>;
           syncSnapshot?: boolean;
         }
-      ): ActorRefFrom<TLogic>;
+      ): ActorRefFromLogic<TLogic>;
     }
   : <TLogic extends AnyActorLogic | string>(
       src: TLogic,
@@ -62,7 +62,7 @@ export type Spawner<TActor extends ProvidedActor> = IsLiteralString<
         input?: TLogic extends string ? unknown : InputFrom<TLogic>;
         syncSnapshot?: boolean;
       }
-    ) => TLogic extends string ? AnyActorRef : ActorRefFrom<TLogic>;
+    ) => TLogic extends AnyActorLogic ? ActorRefFromLogic<TLogic> : AnyActorRef;
 
 export function createSpawner(
   actorScope: AnyActorScope,

diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
@@ -2006,50 +2006,19 @@ export type ActorLogicFrom<T> = ReturnTypeOrValue<T> extends infer R
       : never
   : never;
 
+// TODO: in v6, this should only accept AnyActorLogic, like ActorRefFromLogic
 export type ActorRefFrom<T> = ReturnTypeOrValue<T> extends infer R
-  ? R extends StateMachine<
-      infer TContext,
-      infer TEvent,
-      infer TChildren,
-      infer _TActor,
-      infer _TAction,
-      infer _TGuard,
-      infer _TDelay,
-      infer TStateValue,
-      infer TTag,
-      infer _TInput,
-      infer TOutput,
-      infer TEmitted,
-      infer TMeta,
-      infer TStateSchema
-    >
-    ? ActorRef<
-        MachineSnapshot<
-          TContext,
-          TEvent,
-          TChildren,
-          TStateValue,
-          TTag,
-          TOutput,
-          TMeta,
-          TStateSchema
-        >,
-        TEvent,
-        TEmitted
-      >
-    : R extends Promise<infer U>
-      ? ActorRefFrom<PromiseActorLogic<U>>
-      : R extends ActorLogic<
-            infer TSnapshot,
-            infer TEvent,
-            infer _TInput,
-            infer _TSystem,
-            infer TEmitted
-          >
-        ? ActorRef<TSnapshot, TEvent, TEmitted>
-        : never
+  ? R extends AnyActorLogic
+    ? ActorRefFromLogic<R>
+    : never
   : never;
 
+export type ActorRefFromLogic<T extends AnyActorLogic> = ActorRef<
+  SnapshotFrom<T>,
+  EventFromLogic<T>,
+  EmittedFrom<T>
+>;
+
 export type DevToolsAdapter = (service: AnyActor) => void;
 
 /** @deprecated Use `Actor<T>` instead. */
@@ -2259,7 +2228,7 @@ export type AnyActorLogic = ActorLogic<
 export type UnknownActorLogic = ActorLogic<
   any, // snapshot
   any, // event
-  never, // input
+  any, // input
   AnyActorSystem,
   any // emitted
 >;
@@ -2429,7 +2398,9 @@ type ExtractLiteralString<T extends string | undefined> = T extends string
   : never;
 
 type ToConcreteChildren<TActor extends ProvidedActor> = {
-  [A in TActor as ExtractLiteralString<A['id']>]?: ActorRefFrom<A['logic']>;
+  [A in TActor as ExtractLiteralString<A['id']>]?: ActorRefFromLogic<
+    A['logic']
+  >;
 };
 
 export type ToChildren<TActor extends ProvidedActor> =
@@ -2444,7 +2415,7 @@ export type ToChildren<TActor extends ProvidedActor> =
           {
             include: {
               [id: string]: TActor extends any
-                ? ActorRefFrom<TActor['logic']> | undefined
+                ? ActorRefFromLogic<TActor['logic']> | undefined
                 : never;
             };
             exclude: {};

diff --git a/packages/core/test/actions.test.ts b/packages/core/test/actions.test.ts
@@ -7,13 +7,12 @@ import {
   raise,
   sendParent,
   sendTo,
-  spawnChild,
   stopChild
 } from '../src/actions.ts';
 import { CallbackActorRef, fromCallback } from '../src/actors/callback.ts';
 import {
   ActorRef,
-  ActorRefFrom,
+  ActorRefFromLogic,
   AnyActorRef,
   EventObject,
   Snapshot,
@@ -1551,7 +1550,7 @@ describe('entry/exit actions', () => {
       const parent = createMachine({
         types: {} as {
           context: {
-            child: ActorRefFrom<typeof child>;
+            child: ActorRefFromLogic<typeof child>;
           };
         },
         id: 'parent',
@@ -1596,7 +1595,7 @@ describe('entry/exit actions', () => {
       const parent = createMachine({
         types: {} as {
           context: {
-            child: ActorRefFrom<typeof child>;
+            child: ActorRefFromLogic<typeof child>;
           };
         },
         id: 'parent',
@@ -2976,7 +2975,7 @@ describe('sendTo', () => {
     const parentMachine = createMachine({
       types: {} as {
         context: {
-          child: ActorRefFrom<typeof childMachine>;
+          child: ActorRefFromLogic<typeof childMachine>;
         };
       },
       context: ({ spawn }) => ({
@@ -3008,7 +3007,7 @@ describe('sendTo', () => {
     const parentMachine = createMachine({
       types: {} as {
         context: {
-          child: ActorRefFrom<typeof childMachine>;
+          child: ActorRefFromLogic<typeof childMachine>;
           count: number;
         };
       },
@@ -3045,7 +3044,7 @@ describe('sendTo', () => {
     createMachine({
       types: {} as {
         context: {
-          child: ActorRefFrom<typeof childMachine>;
+          child: ActorRefFromLogic<typeof childMachine>;
         };
       },
       context: ({ spawn }) => ({
@@ -3076,7 +3075,9 @@ describe('sendTo', () => {
     });
 
     const parentMachine = createMachine({
-      types: {} as { context: { child: ActorRefFrom<typeof childMachine> } },
+      types: {} as {
+        context: { child: ActorRefFromLogic<typeof childMachine> };
+      },
       context: ({ spawn }) => ({
         child: spawn(childMachine, { id: 'child' })
       }),
@@ -3105,7 +3106,9 @@ describe('sendTo', () => {
     });
 
     const parentMachine = createMachine({
-      types: {} as { context: { child: ActorRefFrom<typeof childMachine> } },
+      types: {} as {
+        context: { child: ActorRefFromLogic<typeof childMachine> };
+      },
       context: ({ spawn }) => ({
         child: spawn(childMachine)
       }),

diff --git a/packages/core/test/types.test.ts b/packages/core/test/types.test.ts
@@ -25,7 +25,13 @@ import {
   stateIn,
   setup,
   toPromise,
-  UnknownActorRef
+  UnknownActorRef,
+  AnyActorLogic,
+  ActorRef,
+  SnapshotFrom,
+  EmittedFrom,
+  EventFrom,
+  ActorRefFromLogic
 } from '../src/index';
 
 function noop(_x: unknown) {
@@ -4582,3 +4588,19 @@ it('UnknownActorRef should return a Snapshot-typed value from getSnapshot()', ()
   // @ts-expect-error
   actor.getSnapshot().status === 'FOO';
 });
+
+it('Actor<T> should be assignable to ActorRefFromLogic<T>', () => {
+  const logic = createMachine({});
+
+  class ActorThing<T extends AnyActorLogic> {
+    actorRef: ActorRefFromLogic<T>;
+    constructor(actorLogic: T) {
+      const actor = createActor(actorLogic);
+
+      actor satisfies ActorRefFromLogic<typeof actorLogic>;
+      this.actorRef = actor;
+    }
+  }
+
+  new ActorThing(logic);
+});