@dxos/app-framework 0.7.4 → 0.7.5-main.9cb18ac

package/src/plugins/plugin-intent/IntentPlugin.tsx

@@ -2,26 +2,20 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Effect } from 'effect';
 import React from 'react';
 
 import { create } from '@dxos/live-object';
-import { log } from '@dxos/log';
 
-import { type IntentContext, type IntentExecution, IntentProvider } from './IntentContext';
-import { isUndoable } from './helpers';
-import type { Intent, IntentResolver } from './intent';
+import { IntentProvider } from './IntentContext';
+import { createDispatcher, type AnyIntentResolver, type IntentContext } from './intent-dispatcher';
 import IntentMeta from './meta';
-import {
-  IntentAction,
-  type IntentPluginProvides,
-  type IntentResolverProvides,
-  parseIntentResolverPlugin,
-} from './provides';
-import { filterPlugins, findPlugin } from '../helpers';
+import { type IntentPluginProvides, type ResolverDefinitions, parseIntentResolverPlugin } from './provides';
+import { filterPlugins } from '../helpers';
 import { type PluginDefinition } from '../plugin-host';
 
-const EXECUTION_LIMIT = 1000;
-const HISTORY_LIMIT = 100;
+const defaultEffect = () => Effect.fail(new Error('Intent runtime not ready'));
+const defaultPromise = () => Effect.runPromise(defaultEffect());
 
 /**
  * Allows plugins to register intent handlers and routes sent intents to the appropriate plugin.
@@ -29,119 +23,38 @@ const HISTORY_LIMIT = 100;
  */
 export const IntentPlugin = (): PluginDefinition<IntentPluginProvides> => {
   const state = create<IntentContext>({
-    dispatch: async () => ({}),
-    undo: async () => ({}),
-    history: [],
+    dispatch: defaultEffect,
+    dispatchPromise: defaultPromise,
+    undo: defaultEffect,
+    undoPromise: defaultPromise,
     registerResolver: () => () => {},
   });
 
-  const dynamicResolvers = new Set<{ plugin: string; resolver: IntentResolver }>();
-
   return {
     meta: IntentMeta,
-    ready: async (plugins) => {
-      // Dispatch intent to associated plugin.
-      const dispatch = async (intent: Intent) => {
-        log('dispatch', { action: intent.action, intent });
-        if (intent.plugin) {
-          for (const entry of dynamicResolvers) {
-            if (entry.plugin === intent.plugin) {
-              const result = await entry.resolver(intent, plugins);
-              if (result) {
-                return result;
-              }
-            }
-          }
-
-          const plugin = findPlugin<IntentResolverProvides>(plugins, intent.plugin);
-          return plugin?.provides.intent.resolver(intent, plugins);
-        }
-
-        for (const entry of dynamicResolvers) {
-          const result = await entry.resolver(intent, plugins);
-          if (result) {
-            return result;
-          }
-        }
-
-        // Return resolved value from first plugin that handles the intent.
-        for (const plugin of filterPlugins(plugins, parseIntentResolverPlugin)) {
-          const result = await plugin.provides.intent.resolver(intent, plugins);
-          if (result) {
-            return result;
-          }
-        }
-
-        // https://vitejs.dev/guide/env-and-mode#env-variables
-        // TODO(wittjosiah): How to handle this more generically?
-        if (import.meta?.env?.DEV) {
-          log.warn('No plugin found to handle intent', intent);
-        }
-      };
-
-      // Sequentially dispatch array of invents.
-      const dispatchChain = async (intentOrArray: Intent | Intent[], depth = 0) => {
-        if (depth > EXECUTION_LIMIT) {
-          return {
-            error: new Error(
-              `Intent execution limit exceeded (${EXECUTION_LIMIT} iterations). This is likely due to an infinite loop within intent resolvers.`,
-            ),
-          };
-        }
-
-        const executionResults: IntentExecution[] = [];
-        const chain = Array.isArray(intentOrArray) ? intentOrArray : [intentOrArray];
-        for (const intent of chain) {
-          const { result: prevResult } = executionResults.at(-1) ?? {};
-          const data = intent.data ? { result: prevResult?.data, ...intent.data } : prevResult?.data;
-          const result = await dispatch({ ...intent, data });
-
-          if (!result || result?.error) {
-            break;
-          }
-
-          executionResults.push({ intent, result });
-
-          // TODO(wittjosiah): How does undo work with returned intents?
-          result?.intents?.forEach((intents) => {
-            void dispatchChain(intents, depth + 1);
-          });
-        }
-
-        state.history.push(executionResults);
-        if (state.history.length > HISTORY_LIMIT) {
-          state.history.splice(0, state.history.length - HISTORY_LIMIT);
-        }
-
-        if (isUndoable(executionResults)) {
-          void dispatch({ action: IntentAction.SHOW_UNDO, data: { results: executionResults } });
-        }
-
-        return executionResults.at(-1)?.result;
-      };
-
-      const undo = async () => {
-        const last = state.history.findLastIndex(isUndoable);
-        const chain =
-          last !== -1 &&
-          state.history[last]?.map(({ intent, result }): Intent => {
-            const data = result.undoable?.data ? { ...intent.data, ...result.undoable.data } : intent.data;
-            return { ...intent, data, undo: true };
-          });
-        if (chain) {
-          const result = await dispatchChain(chain);
-          state.history = state.history.filter((_, index) => index !== last);
-          return result;
-        }
-      };
-
-      state.dispatch = dispatchChain;
+    ready: async ({ plugins }) => {
+      const resolvers = Object.fromEntries(
+        filterPlugins(plugins, parseIntentResolverPlugin).map((plugin): [string, AnyIntentResolver[]] => {
+          const resolvers = reduceResolvers(
+            plugin.provides.intent.resolvers({
+              plugins,
+              dispatch: (intent) => state.dispatch(intent),
+              dispatchPromise: (intent) => state.dispatchPromise(intent),
+              undo: () => state.undo(),
+              undoPromise: () => state.undoPromise(),
+              registerResolver: (id, resolver) => state.registerResolver(id, resolver),
+            }),
+          );
+          return [plugin.meta.id, resolvers];
+        }),
+      );
+      const { dispatch, dispatchPromise, undo, undoPromise, registerResolver } = createDispatcher(resolvers);
+
+      state.dispatch = dispatch;
+      state.dispatchPromise = dispatchPromise;
       state.undo = undo;
-      state.registerResolver = (plugin, resolver) => {
-        const entry = { plugin, resolver };
-        dynamicResolvers.add(entry);
-        return () => dynamicResolvers.delete(entry);
-      };
+      state.undoPromise = undoPromise;
+      state.registerResolver = registerResolver;
     },
     provides: {
       intent: state,
@@ -149,3 +62,14 @@ export const IntentPlugin = (): PluginDefinition<IntentPluginProvides> => {
     },
   };
 };
+
+const reduceResolvers = (
+  definitions: ResolverDefinitions,
+  resolvers: AnyIntentResolver[] = [],
+): AnyIntentResolver[] => {
+  if (Array.isArray(definitions)) {
+    return definitions.reduce((acc: AnyIntentResolver[], definition) => reduceResolvers(definition, acc), resolvers);
+  }
+
+  return [...resolvers, definitions];
+};

package/src/plugins/plugin-intent/index.ts

@@ -5,6 +5,7 @@
 import { IntentPlugin } from './IntentPlugin';
 
 export * from './intent';
+export * from './intent-dispatcher';
 export * from './provides';
 
 export * from './IntentContext';

package/src/plugins/plugin-intent/intent-dispatcher.test.ts

@@ -0,0 +1,279 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Effect, Fiber, pipe } from 'effect';
+import { describe, expect, test } from 'vitest';
+
+import { S } from '@dxos/echo-schema';
+
+import { chain, createIntent } from './intent';
+import { createDispatcher, createResolver } from './intent-dispatcher';
+
+describe('Intent dispatcher', () => {
+  test('throws error if no resolver found', async () => {
+    const { dispatchPromise } = createDispatcher({});
+    const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
+
+    expect(data).toBe(undefined);
+    expect(error).toBeInstanceOf(Error);
+  });
+
+  test('matches intent to resolver and executes', async () => {
+    const { dispatchPromise } = createDispatcher({ test: [toStringResolver] });
+    const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
+
+    expect(error).toBe(undefined);
+    expect(data?.string).toBe('1');
+  });
+
+  test('update resolvers', async () => {
+    const { dispatchPromise, registerResolver } = createDispatcher({ test: [] });
+    const { error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
+
+    expect(error).toBeInstanceOf(Error);
+
+    const removeResolver = registerResolver('test', toStringResolver);
+
+    const { data } = await dispatchPromise(createIntent(ToString, { value: 1 }));
+
+    expect(data?.string).toBe('1');
+
+    removeResolver();
+
+    {
+      const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
+
+      expect(data).toBe(undefined);
+      expect(error).toBeInstanceOf(Error);
+    }
+  });
+
+  test('compose intent effects', async () => {
+    const { dispatch } = createDispatcher({ test: [computeResolver] });
+    const program = Effect.gen(function* () {
+      const a = yield* dispatch(createIntent(Compute, { value: 1 }));
+      const b = yield* dispatch(createIntent(Compute, { value: 2 }));
+      return b.data!.value - a.data!.value;
+    });
+
+    expect(await Effect.runPromise(program)).toBe(2);
+  });
+
+  test('concurrent intent effects', async () => {
+    const { dispatch } = createDispatcher({ test: [computeResolver] });
+    const program = Effect.gen(function* () {
+      const fiberA = yield* Effect.fork(dispatch(createIntent(Compute, { value: 5 })));
+      const fiberB = yield* Effect.fork(dispatch(createIntent(Compute, { value: 2 })));
+      const [a, b] = yield* Fiber.join(Fiber.zip(fiberA, fiberB));
+      return b.data!.value - a.data!.value;
+    });
+
+    expect(await Effect.runPromise(program)).toBe(-6);
+  });
+
+  test('mix & match intent effects with promises', async () => {
+    const { dispatch, dispatchPromise } = createDispatcher({ test: [toStringResolver, computeResolver] });
+    const program = Effect.gen(function* () {
+      const a = yield* dispatch(createIntent(Compute, { value: 2 }));
+      const b = yield* dispatch(createIntent(ToString, { value: a.data!.value }));
+      return b.data?.string;
+    });
+
+    expect(await Effect.runPromise(program)).toBe('4');
+
+    const a = await dispatchPromise(createIntent(Compute, { value: 2 }));
+    const b = await dispatchPromise(createIntent(ToString, { value: a.data!.value }));
+
+    expect(b.data?.string).toBe('4');
+  });
+
+  test('undo intent', async () => {
+    const { dispatch, undo } = createDispatcher({ test: [computeResolver] });
+    const program = Effect.gen(function* () {
+      const a = yield* dispatch(createIntent(Compute, { value: 2 }));
+
+      expect(a.data?.value).toBe(4);
+
+      const b = yield* undo();
+
+      expect(b?.data?.value).toBe(2);
+    });
+
+    await Effect.runPromise(program);
+  });
+
+  test('chain intents', async () => {
+    const { dispatch } = createDispatcher({ test: [computeResolver, toStringResolver, concatResolver] });
+    const intent = pipe(createIntent(Compute, { value: 1 }), chain(ToString, {}), chain(Concat, { plus: '!' }));
+
+    expect(intent.first.action).toBe(Compute._tag);
+    expect(intent.last.action).toBe(Concat._tag);
+    expect(intent.all.length).toBe(3);
+
+    const program = Effect.gen(function* () {
+      const { data } = yield* dispatch(intent);
+      return data?.string;
+    });
+
+    expect(await Effect.runPromise(program)).toBe('2!');
+  });
+
+  test('undo chained intent', async () => {
+    const { dispatch, undo } = createDispatcher({ test: [computeResolver, toStringResolver, concatResolver] });
+    const intent = pipe(createIntent(Compute, { value: 1 }), chain(Compute, {}), chain(Compute, {}));
+    const program = Effect.gen(function* () {
+      const a = yield* dispatch(intent);
+
+      expect(a.data?.value).toBe(8);
+
+      const b = yield* undo();
+
+      expect(b?.data?.value).toBe(1);
+    });
+
+    await Effect.runPromise(program);
+  });
+
+  test('filter resolvers by plugin', async () => {
+    const otherComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }));
+    const { dispatch } = createDispatcher({ test: [computeResolver], other: [otherComputeResolver] });
+    const program = Effect.gen(function* () {
+      const a = yield* dispatch(createIntent(Compute, { value: 1 }));
+
+      expect(a.data?.value).toBe(2);
+
+      const b = yield* dispatch(createIntent(Compute, { value: 1 }, { plugin: 'other' }));
+
+      expect(b.data?.value).toBe(3);
+    });
+
+    await Effect.runPromise(program);
+  });
+
+  test('filter resolvers by predicate', async () => {
+    const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
+      filter: (data): data is { value: number } => data?.value > 1,
+    });
+    const { dispatch } = createDispatcher({ test: [conditionalComputeResolver, computeResolver] });
+    const program = Effect.gen(function* () {
+      const a = yield* dispatch(createIntent(Compute, { value: 1 }));
+
+      expect(a.data?.value).toBe(2);
+
+      const b = yield* dispatch(createIntent(Compute, { value: 2 }));
+
+      expect(b.data?.value).toBe(6);
+    });
+
+    await Effect.runPromise(program);
+  });
+
+  test('hoist resolvers', async () => {
+    const hoistedComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
+      disposition: 'hoist',
+    });
+    const { dispatchPromise } = createDispatcher({ test: [computeResolver, hoistedComputeResolver] });
+    const { data } = await dispatchPromise(createIntent(Compute, { value: 1 }));
+    expect(data?.value).toBe(3);
+  });
+
+  test('fallback resolvers', async () => {
+    const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 2 } }), {
+      filter: (data): data is { value: number } => data?.value === 1,
+    });
+    const fallbackComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
+      disposition: 'fallback',
+    });
+    const { dispatch } = createDispatcher({ test: [fallbackComputeResolver, conditionalComputeResolver] });
+    const program = Effect.gen(function* () {
+      const a = yield* dispatch(createIntent(Compute, { value: 1 }));
+
+      expect(a.data?.value).toBe(2);
+
+      const b = yield* dispatch(createIntent(Compute, { value: 2 }));
+
+      expect(b.data?.value).toBe(6);
+    });
+
+    await Effect.runPromise(program);
+  });
+
+  test('non-struct inputs & outputs', async () => {
+    const { dispatchPromise } = createDispatcher({ test: [addResolver] });
+    const { data } = await dispatchPromise(createIntent(Add, [1, 1]));
+    expect(data).toBe(2);
+  });
+
+  test('empty inputs & outputs', async () => {
+    const { dispatchPromise } = createDispatcher({ test: [sideEffectResolver] });
+    const { data } = await dispatchPromise(createIntent(SideEffect));
+    expect(data).toBe(undefined);
+  });
+
+  test.todo('follow up intents');
+});
+
+class ToString extends S.TaggedClass<ToString>()('ToString', {
+  input: S.Struct({
+    value: S.Number,
+  }),
+  output: S.Struct({
+    string: S.String,
+  }),
+}) {}
+
+const toStringResolver = createResolver(ToString, async (data) => {
+  return { data: { string: data.value.toString() } };
+});
+
+class Compute extends S.TaggedClass<Compute>()('Compute', {
+  input: S.Struct({
+    value: S.Number,
+  }),
+  output: S.Struct({
+    value: S.Number,
+  }),
+}) {}
+
+const computeResolver = createResolver(Compute, (data, undo) => {
+  return Effect.gen(function* () {
+    if (undo) {
+      return { data: { value: data.value / 2 } };
+    }
+
+    yield* Effect.sleep(data.value * 10);
+    const value = data.value * 2;
+    return { data: { value }, undoable: { message: 'test', data: { value } } };
+  });
+});
+
+class Concat extends S.TaggedClass<Concat>()('Concat', {
+  input: S.Struct({
+    string: S.String,
+    plus: S.String,
+  }),
+  output: S.Struct({
+    string: S.String,
+  }),
+}) {}
+
+const concatResolver = createResolver(Concat, async (data) => {
+  return { data: { string: data.string + data.plus } };
+});
+
+class Add extends S.TaggedClass<Add>()('Add', {
+  input: S.Tuple(S.Number, S.Number),
+  output: S.Number,
+}) {}
+
+const addResolver = createResolver(Add, async (data) => {
+  return { data: data[0] + data[1] };
+});
+
+class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
+  input: S.Void,
+  output: S.Void,
+}) {}
+
+const sideEffectResolver = createResolver(SideEffect, async () => {});