@dxos/app-framework 0.7.5-main.9d26e3a → 0.7.5-main.e9bb01b

package/src/plugin-intent/errors.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// TODO(wittjosiah): Reconcile with @dxos/protocols. Factor out errors.
+
+/**
+ * NOTE: Messages should be sentences (Start with a capital letter and end with a period).
+ * Errors can optionally include a JSON context object.
+ */
+export class BaseError extends Error {
+  constructor(
+    readonly code: string,
+    message?: string,
+    readonly context?: Record<string, any>,
+  ) {
+    // TODO(dmaretskyi): Error.cause.
+    super(message ?? code);
+    this.name = code;
+    // NOTE: Restores prototype chain (https://stackoverflow.com/a/48342359).
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class NoResolversError extends BaseError {
+  constructor(action: string) {
+    super('NO_RESOLVERS', 'No resolvers were found for the action', { action });
+  }
+}
+
+export class CycleDetectedError extends BaseError {
+  constructor(context?: Record<string, any>) {
+    super(
+      'CYCLE_DETECTED',
+      'Intent execution limit exceeded. This is likely due to an infinite loop within intent resolvers.',
+      context,
+    );
+  }
+}

package/src/plugin-intent/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './actions';
+export * from './intent';
+export * from './intent-dispatcher';
+export * from './IntentPlugin';

package/src/{plugins/plugin-intent → plugin-intent}/intent-dispatcher.test.ts

@@ -2,17 +2,16 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Schema as S } from '@effect/schema';
 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';
+import { type AnyIntentResolver, createDispatcher, createResolver } from './intent-dispatcher';
 
 describe('Intent dispatcher', () => {
   test('throws error if no resolver found', async () => {
-    const { dispatchPromise } = createDispatcher({});
+    const { dispatchPromise } = createDispatcher(() => []);
     const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(data).toBe(undefined);
@@ -20,7 +19,7 @@ describe('Intent dispatcher', () => {
   });
 
   test('matches intent to resolver and executes', async () => {
-    const { dispatchPromise } = createDispatcher({ test: [toStringResolver] });
+    const { dispatchPromise } = createDispatcher(() => [toStringResolver]);
     const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(error).toBe(undefined);
@@ -28,18 +27,19 @@ describe('Intent dispatcher', () => {
   });
 
   test('update resolvers', async () => {
-    const { dispatchPromise, registerResolver } = createDispatcher({ test: [] });
+    const resolvers: AnyIntentResolver[] = [];
+    const { dispatchPromise } = createDispatcher(() => resolvers);
     const { error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(error).toBeInstanceOf(Error);
 
-    const removeResolver = registerResolver('test', toStringResolver);
+    resolvers.push(toStringResolver);
 
     const { data } = await dispatchPromise(createIntent(ToString, { value: 1 }));
 
     expect(data?.string).toBe('1');
 
-    removeResolver();
+    resolvers.splice(resolvers.indexOf(toStringResolver), 1);
 
     {
       const { data, error } = await dispatchPromise(createIntent(ToString, { value: 1 }));
@@ -50,34 +50,34 @@ describe('Intent dispatcher', () => {
   });
 
   test('compose intent effects', async () => {
-    const { dispatch } = createDispatcher({ test: [computeResolver] });
+    const { dispatch } = createDispatcher(() => [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;
+      return b.value - a.value;
     });
 
     expect(await Effect.runPromise(program)).toBe(2);
   });
 
   test('concurrent intent effects', async () => {
-    const { dispatch } = createDispatcher({ test: [computeResolver] });
+    const { dispatch } = createDispatcher(() => [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;
+      return b.value - a.value;
     });
 
     expect(await Effect.runPromise(program)).toBe(-6);
   });
 
   test('mix & match intent effects with promises', async () => {
-    const { dispatch, dispatchPromise } = createDispatcher({ test: [toStringResolver, computeResolver] });
+    const { dispatch, dispatchPromise } = createDispatcher(() => [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;
+      const b = yield* dispatch(createIntent(ToString, { value: a.value }));
+      return b.string;
     });
 
     expect(await Effect.runPromise(program)).toBe('4');
@@ -89,124 +89,135 @@ describe('Intent dispatcher', () => {
   });
 
   test('undo intent', async () => {
-    const { dispatch, undo } = createDispatcher({ test: [computeResolver] });
+    const { dispatch, undo } = createDispatcher(() => [computeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 2 }));
 
-      expect(a.data?.value).toBe(4);
+      expect(a.value).toBe(4);
 
       const b = yield* undo();
 
-      expect(b?.data?.value).toBe(2);
+      expect(b.value).toBe(2);
     });
 
     await Effect.runPromise(program);
   });
 
   test('chain intents', async () => {
-    const { dispatch } = createDispatcher({ test: [computeResolver, toStringResolver, concatResolver] });
+    const { dispatch } = createDispatcher(() => [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.first.id).toBe(Compute._tag);
+    expect(intent.last.id).toBe(Concat._tag);
     expect(intent.all.length).toBe(3);
 
     const program = Effect.gen(function* () {
-      const { data } = yield* dispatch(intent);
-      return data?.string;
+      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 { dispatch, undo } = createDispatcher(() => [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);
+      expect(a.value).toBe(8);
 
       const b = yield* undo();
 
-      expect(b?.data?.value).toBe(1);
+      expect(b.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 otherComputeResolver = createResolver({
+      intent: Compute,
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
+    });
+    const { dispatch } = createDispatcher((module) => (module === 'test' ? [computeResolver] : [otherComputeResolver]));
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
-      expect(a.data?.value).toBe(2);
+      expect(a.value).toBe(3);
 
-      const b = yield* dispatch(createIntent(Compute, { value: 1 }, { plugin: 'other' }));
+      const b = yield* dispatch(createIntent(Compute, { value: 1 }, { module: 'test' }));
 
-      expect(b.data?.value).toBe(3);
+      expect(b.value).toBe(2);
     });
 
     await Effect.runPromise(program);
   });
 
   test('filter resolvers by predicate', async () => {
-    const conditionalComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
+    const conditionalComputeResolver = createResolver({
+      intent: Compute,
       filter: (data): data is { value: number } => data?.value > 1,
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
     });
-    const { dispatch } = createDispatcher({ test: [conditionalComputeResolver, computeResolver] });
+    const { dispatch } = createDispatcher(() => [conditionalComputeResolver, computeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
-      expect(a.data?.value).toBe(2);
+      expect(a.value).toBe(2);
 
       const b = yield* dispatch(createIntent(Compute, { value: 2 }));
 
-      expect(b.data?.value).toBe(6);
+      expect(b.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 hoistedComputeResolver = createResolver({
+      intent: Compute,
+      position: 'hoist',
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
     });
-    const { dispatchPromise } = createDispatcher({ test: [computeResolver, hoistedComputeResolver] });
+    const { dispatchPromise } = createDispatcher(() => [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 } }), {
+    const conditionalComputeResolver = createResolver({
+      intent: Compute,
       filter: (data): data is { value: number } => data?.value === 1,
+      resolve: async (data) => ({ data: { value: data?.value * 2 } }),
     });
-    const fallbackComputeResolver = createResolver(Compute, async (data) => ({ data: { value: data?.value * 3 } }), {
-      disposition: 'fallback',
+    const fallbackComputeResolver = createResolver({
+      intent: Compute,
+      position: 'fallback',
+      resolve: async (data) => ({ data: { value: data?.value * 3 } }),
     });
-    const { dispatch } = createDispatcher({ test: [fallbackComputeResolver, conditionalComputeResolver] });
+    const { dispatch } = createDispatcher(() => [conditionalComputeResolver, fallbackComputeResolver]);
     const program = Effect.gen(function* () {
       const a = yield* dispatch(createIntent(Compute, { value: 1 }));
 
-      expect(a.data?.value).toBe(2);
+      expect(a.value).toBe(2);
 
       const b = yield* dispatch(createIntent(Compute, { value: 2 }));
 
-      expect(b.data?.value).toBe(6);
+      expect(b.value).toBe(6);
     });
 
     await Effect.runPromise(program);
   });
 
   test('non-struct inputs & outputs', async () => {
-    const { dispatchPromise } = createDispatcher({ test: [addResolver] });
+    const { dispatchPromise } = createDispatcher(() => [addResolver]);
     const { data } = await dispatchPromise(createIntent(Add, [1, 1]));
     expect(data).toBe(2);
   });
 
   test('empty inputs & outputs', async () => {
-    const { dispatchPromise } = createDispatcher({ test: [sideEffectResolver] });
+    const { dispatchPromise } = createDispatcher(() => [sideEffectResolver]);
     const { data } = await dispatchPromise(createIntent(SideEffect));
     expect(data).toBe(undefined);
   });
@@ -223,8 +234,9 @@ class ToString extends S.TaggedClass<ToString>()('ToString', {
   }),
 }) {}
 
-const toStringResolver = createResolver(ToString, async (data) => {
-  return { data: { string: data.value.toString() } };
+const toStringResolver = createResolver({
+  intent: ToString,
+  resolve: async (data) => ({ data: { string: data.value.toString() } }),
 });
 
 class Compute extends S.TaggedClass<Compute>()('Compute', {
@@ -236,16 +248,19 @@ class Compute extends S.TaggedClass<Compute>()('Compute', {
   }),
 }) {}
 
-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 } } };
-  });
+const computeResolver = createResolver({
+  intent: Compute,
+  resolve: (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', {
@@ -258,8 +273,9 @@ class Concat extends S.TaggedClass<Concat>()('Concat', {
   }),
 }) {}
 
-const concatResolver = createResolver(Concat, async (data) => {
-  return { data: { string: data.string + data.plus } };
+const concatResolver = createResolver({
+  intent: Concat,
+  resolve: async (data) => ({ data: { string: data.string + data.plus } }),
 });
 
 class Add extends S.TaggedClass<Add>()('Add', {
@@ -267,8 +283,9 @@ class Add extends S.TaggedClass<Add>()('Add', {
   output: S.Number,
 }) {}
 
-const addResolver = createResolver(Add, async (data) => {
-  return { data: data[0] + data[1] };
+const addResolver = createResolver({
+  intent: Add,
+  resolve: async (data) => ({ data: data[0] + data[1] }),
 });
 
 class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
@@ -276,4 +293,7 @@ class SideEffect extends S.TaggedClass<SideEffect>()('SideEffect', {
   output: S.Void,
 }) {}
 
-const sideEffectResolver = createResolver(SideEffect, async () => {});
+const sideEffectResolver = createResolver({
+  intent: SideEffect,
+  resolve: async () => {},
+});