@dxos/functions 0.8.4-main.e098934 → 0.8.4-main.ead640a

package/src/services/local-function-execution.ts

@@ -2,40 +2,67 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer, Schema } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schema from 'effect/Schema';
 
+import { AiService } from '@dxos/ai';
 import { todo } from '@dxos/debug';
+import { log } from '@dxos/log';
 
 import { FunctionError, FunctionNotFoundError } from '../errors';
 import type { FunctionContext, FunctionDefinition } from '../handler';
 
-import type { Services } from './service-container';
+import { CredentialsService } from './credentials';
+import { DatabaseService } from './database';
+import { type ComputeEventLogger } from './event-logger';
+import { QueueService } from './queues';
+import { RemoteFunctionExecutionService } from './remote-function-execution-service';
+import { type Services } from './service-container';
+import { type TracingService } from './tracing';
+
+/**
+ * Services that are provided at the function call site.
+ */
+export type InvocationServices = TracingService | ComputeEventLogger;
 
 export class LocalFunctionExecutionService extends Context.Tag('@dxos/functions/LocalFunctionExecutionService')<
   LocalFunctionExecutionService,
   {
     // TODO(dmaretskyi): This should take function id instead of the definition object.
     // TODO(dmaretskyi): Services should be satisfied from environment rather then bubbled up.
-    invokeFunction(functionDef: FunctionDefinition<any, any>, input: unknown): Effect.Effect<unknown, never, Services>;
+    invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
   }
 >() {
-  /**
-   * @deprecated Use layerLive instead.
-   */
-  static layer = Layer.succeed(LocalFunctionExecutionService, {
-    invokeFunction: (functionDef, input) => invokeFunction(functionDef, input),
-  });
-
   static layerLive = Layer.effect(
     LocalFunctionExecutionService,
     Effect.gen(function* () {
+      // TODO(dmaretskyi): Use `yield* Effect.context()`;
       const resolver = yield* FunctionImplementationResolver;
+      const ai = yield* AiService.AiService;
+      const credentials = yield* CredentialsService;
+      const database = yield* DatabaseService;
+      const queues = yield* QueueService;
+      // TODO(mykola): Delete, should not be required for local execution.
+      const functionCallService = yield* RemoteFunctionExecutionService;
       return {
-        invokeFunction: Effect.fn('invokeFunction')(function* (functionDef, input) {
-          // TODO(dmaretskyi): Better error types
-          const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect.orDie);
-          return yield* invokeFunction(resolved, input);
-        }),
+        // TODO(dmaretskyi): Better error types.
+        invokeFunction: <I, O>(
+          functionDef: FunctionDefinition<I, O>,
+          input: I,
+        ): Effect.Effect<O, never, InvocationServices> =>
+          Effect.gen(function* () {
+            const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect.orDie);
+            const output = yield* invokeFunction(resolved, input);
+            return output as O;
+          }).pipe(
+            Effect.provideService(AiService.AiService, ai),
+            Effect.provideService(CredentialsService, credentials),
+            Effect.provideService(DatabaseService, database),
+            Effect.provideService(QueueService, queues),
+            Effect.provideService(RemoteFunctionExecutionService, functionCallService),
+          ),
       };
     }),
   );
@@ -52,9 +79,13 @@ const invokeFunction = (
   input: any,
 ): Effect.Effect<unknown, never, Services> =>
   Effect.gen(function* () {
-    // Assert input matches schema
-    const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
-    (assertInput as any)(input);
+    // Assert input matches schema.
+    try {
+      const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
+      (assertInput as any)(input);
+    } catch (e) {
+      throw new FunctionError({ message: 'Invalid function input', context: { name: functionDef.name }, cause: e });
+    }
 
     const context: FunctionContext = {
       space: undefined,
@@ -64,6 +95,8 @@ const invokeFunction = (
       },
     };
 
+    log.info('invoking function', { name: functionDef.name, input });
+
     // TODO(dmaretskyi): This should be delegated to a function invoker service.
     const data = yield* Effect.gen(function* () {
       const result = functionDef.handler({ context, data: input });
@@ -86,9 +119,15 @@ const invokeFunction = (
       ),
     );
 
-    // Assert output matches schema
-    const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(data);
+    log.info('completed', { function: functionDef.name, input, data });
+
+    // Assert output matches schema.
+    try {
+      const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
+      (assertOutput as any)(data);
+    } catch (e) {
+      throw new FunctionError({ message: 'Invalid function output', context: { name: functionDef.name }, cause: e });
+    }
 
     return data;
   }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: functionDef.name } }));
@@ -96,15 +135,15 @@ const invokeFunction = (
 export class FunctionImplementationResolver extends Context.Tag('@dxos/functions/FunctionImplementationResolver')<
   FunctionImplementationResolver,
   {
-    resolveFunctionImplementation(
-      functionDef: FunctionDefinition<any, any>,
-    ): Effect.Effect<FunctionDefinition<any, any>, FunctionNotFoundError>;
+    resolveFunctionImplementation<I, O>(
+      functionDef: FunctionDefinition<I, O>,
+    ): Effect.Effect<FunctionDefinition<I, O>, FunctionNotFoundError>;
   }
 >() {
   static layerTest = ({ functions }: { functions: FunctionDefinition<any, any>[] }) =>
     Layer.succeed(FunctionImplementationResolver, {
-      resolveFunctionImplementation: (functionDef) => {
-        const resolved = functions.find((f) => f.name === functionDef.name);
+      resolveFunctionImplementation: <I, O>(functionDef: FunctionDefinition<I, O>) => {
+        const resolved = functions.find((f) => f.key === functionDef.key);
         if (!resolved) {
           return Effect.fail(new FunctionNotFoundError(functionDef.name));
         }

package/src/services/queues.ts

@@ -2,7 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import type { Obj, Relation } from '@dxos/echo';
 import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';

package/src/services/remote-function-execution-service.ts

@@ -2,10 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import type { SpaceId } from '@dxos/keys';
 
+import { FunctionError } from '../errors';
 import { getInvocationUrl } from '../url';
 
 /**
@@ -14,33 +17,47 @@ import { getInvocationUrl } from '../url';
 export class RemoteFunctionExecutionService extends Context.Tag('@dxos/functions/RemoteFunctionExecutionService')<
   RemoteFunctionExecutionService,
   {
-    callFunction(deployedFunctionId: string, input: any, spaceId?: SpaceId): Promise<any>;
+    callFunction<I, O>(deployedFunctionId: string, input: I): Effect.Effect<O>;
   }
 >() {
-  static fromClient(baseUrl: string, spaceId: SpaceId): Context.Tag.Service<RemoteFunctionExecutionService> {
-    return {
-      callFunction: async (deployedFunctionId: string, input: any) => {
-        const url = getInvocationUrl(deployedFunctionId, baseUrl, { spaceId });
-        const result = await fetch(url, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(input),
-        });
-        if (result.status >= 300 || result.status < 200) {
-          throw new Error('Failed to invoke function', { cause: new Error(`HTTP error: ${await result.text()}`) });
-        }
-        return await result.json();
-      },
-    };
+  /**
+   * @param baseUrl URL of the EDGE server.
+   * @param spaceId - The space ID to invoke the function in. If not provided, the function will be without space context.
+   * @returns
+   */
+  static fromClient(baseUrl: string, spaceId?: SpaceId): Layer.Layer<RemoteFunctionExecutionService> {
+    return Layer.succeed(RemoteFunctionExecutionService, {
+      callFunction: <I, O>(deployedFunctionId: string, input: I): Effect.Effect<O> =>
+        Effect.gen(function* () {
+          const url = getInvocationUrl(deployedFunctionId, baseUrl, { spaceId });
+          const result = yield* Effect.promise(() =>
+            fetch(url, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify(input),
+            }),
+          );
+          if (result.status >= 300 || result.status < 200) {
+            const text = yield* Effect.promise(() => result.text());
+            return yield* Effect.die(
+              new FunctionError({
+                message: 'Failed to invoke function',
+                cause: new Error(`HTTP error: ${text}`),
+              }),
+            );
+          }
+          const data = (yield* Effect.promise(() => result.json())) as O;
+          return data;
+        }),
+    });
   }
 
   static mock = (): Context.Tag.Service<RemoteFunctionExecutionService> => {
     return {
-      callFunction: async (deployedFunctionId: string, input: any) => {
-        return input;
-      },
+      callFunction: <I, O>(deployedFunctionId: string, input: I): Effect.Effect<O> =>
+        Effect.succeed(input as unknown as O),
     };
   };
 
-  static mockLayer = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
+  static layerMock = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
 }

package/src/services/service-container.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Context, Layer } from 'effect';
+import type * as Context from 'effect/Context';
+import * as Layer from 'effect/Layer';
 
 import { AiService } from '@dxos/ai';
 import { entries } from '@dxos/util';

package/src/services/service-registry.test.ts

@@ -3,7 +3,10 @@
 //
 
 import { describe, it } from '@effect/vitest';
-import { Context, Effect, Layer, Option } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
 
 import { ServiceRegistry } from './service-registry';
 

package/src/services/service-registry.ts

@@ -2,7 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, type Option, flow } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import type * as Option from 'effect/Option';
 
 import { ServiceNotAvailableError } from '../errors';
 
@@ -40,7 +43,8 @@ export class ServiceRegistry extends Context.Tag('@dxos/functions/ServiceRegistr
       E | ServiceNotAvailableError,
       Exclude<R, { [K in keyof Tags]: Context.Tag.Identifier<Tags[K]> }[number]> | ServiceRegistry
     >;
-  } = (...tags) => (flow as any)(...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag))));
+  } = (...tags) =>
+    (Function.flow as any)(...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag))));
 
   static provideOrDie: {
     <Tags extends [Context.Tag<any, any>, ...Context.Tag<any, any>[]]>(
@@ -53,7 +57,7 @@ export class ServiceRegistry extends Context.Tag('@dxos/functions/ServiceRegistr
       Exclude<R, { [K in keyof Tags]: Context.Tag.Identifier<Tags[K]> }[number]> | ServiceRegistry
     >;
   } = (...tags) =>
-    (flow as any)(
+    (Function.flow as any)(
       ...tags.map((tag) => Effect.provideServiceEffect(tag, ServiceRegistry.resolve(tag).pipe(Effect.orDie))),
     );
 }

package/src/services/tracing.ts

@@ -2,12 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import { AgentStatus } from '@dxos/ai';
 import { Obj } from '@dxos/echo';
+import type { ObjectId } from '@dxos/echo/internal';
 import type { Queue } from '@dxos/echo-db';
-import type { ObjectId } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 import { DataType } from '@dxos/schema';
 
@@ -36,7 +38,6 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
 
   static console: Context.Tag.Service<TracingService> = {
     write: (event) => {
-      // eslint-disable-next-line no-console
       console.log(event);
     },
     getTraceContext: () => ({}),
@@ -89,17 +90,19 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
   /**
    * Emit the current human-readable execution status.
    */
-  static emitStatus: (data: Obj.MakeProps<typeof AgentStatus>) => Effect.Effect<void, never, TracingService> =
-    Effect.fnUntraced(function* (data) {
-      const tracing = yield* TracingService;
-      tracing.write(
-        Obj.make(AgentStatus, {
-          parentMessage: tracing.getTraceContext().parentMessage,
-          toolCallId: tracing.getTraceContext().toolCallId,
-          ...data,
-        }),
-      );
-    });
+  static emitStatus: (
+    data: Omit<Obj.MakeProps<typeof AgentStatus>, 'created'>,
+  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
+    const tracing = yield* TracingService;
+    tracing.write(
+      Obj.make(AgentStatus, {
+        parentMessage: tracing.getTraceContext().parentMessage,
+        toolCallId: tracing.getTraceContext().toolCallId,
+        created: new Date().toISOString(),
+        ...data,
+      }),
+    );
+  });
 
   static emitConverationMessage: (
     data: Obj.MakeProps<typeof DataType.Message>,

package/src/testing/layer.ts

@@ -2,13 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { Schema } from 'effect';
-import { Context, Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import type * as Schema from 'effect/Schema';
 
 import type { EchoDatabaseImpl, QueueFactory } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
 import type { EchoHostIndexingConfig } from '@dxos/echo-pipeline';
-import { accuireReleaseResource } from '@dxos/effect';
+import { acquireReleaseResource } from '@dxos/effect';
 import { PublicKey } from '@dxos/keys';
 import type { LevelDB } from '@dxos/kv-store';
 import { createTestLevel } from '@dxos/kv-store/testing';
@@ -16,7 +18,7 @@ import { log } from '@dxos/log';
 
 import { DatabaseService, QueueService } from '../services';
 
-const testBuilder = accuireReleaseResource(() => new EchoTestBuilder());
+const testBuilder = acquireReleaseResource(() => new EchoTestBuilder());
 
 export const testStoragePath = ({ name = PublicKey.random().toHex() }: { name?: string }) => {
   return `/tmp/dxos-${name}`;
@@ -25,11 +27,12 @@ export const testStoragePath = ({ name = PublicKey.random().toHex() }: { name?:
 export type TestDatabaseOptions = {
   indexing?: Partial<EchoHostIndexingConfig>;
   types?: Schema.Schema.AnyNoContext[];
+  spaceKey?: PublicKey;
   storagePath?: string;
   onInit?: () => Effect.Effect<void, never, DatabaseService | QueueService>;
 };
 
-export const TestDatabaseLayer = ({ indexing, types, storagePath, onInit }: TestDatabaseOptions = {}) =>
+export const TestDatabaseLayer = ({ indexing, types, spaceKey, storagePath, onInit }: TestDatabaseOptions = {}) =>
   Layer.scopedContext(
     Effect.gen(function* () {
       const builder = yield* testBuilder;
@@ -59,7 +62,7 @@ export const TestDatabaseLayer = ({ indexing, types, storagePath, onInit }: Test
         });
         log('starting persistant test db', { storagePath, testMetadata });
         if (!testMetadata) {
-          const key = PublicKey.random();
+          const key = spaceKey ?? PublicKey.random();
           db = yield* Effect.promise(() => peer.createDatabase(key));
           queues = peer.client.constructQueueFactory(db.spaceId);
 
@@ -80,7 +83,7 @@ export const TestDatabaseLayer = ({ indexing, types, storagePath, onInit }: Test
           queues = peer.client.constructQueueFactory(db.spaceId);
         }
       } else {
-        db = yield* Effect.promise(() => peer.createDatabase());
+        db = yield* Effect.promise(() => peer.createDatabase(spaceKey));
         queues = peer.client.constructQueueFactory(db.spaceId);
         if (onInit) {
           yield* onInit().pipe(

package/src/testing/logger.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Context, Effect } from 'effect';
+import type * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
 
 import { LogLevel } from '@dxos/log';
 

package/src/testing/persist-database.test.ts

@@ -3,7 +3,7 @@
 //
 
 import { describe, expect, it } from '@effect/vitest';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
 import { Filter, Obj, Query, Type } from '@dxos/echo';
 import { DataType } from '@dxos/schema';
@@ -15,7 +15,7 @@ import { TestDatabaseLayer, testStoragePath } from './layer';
 describe('TestDatabaseLayer', { timeout: 600_000 }, () => {
   it.effect(
     'persist database to disk',
-    Effect.fnUntraced(function* ({ expect: _ }) {
+    Effect.fnUntraced(function* (_) {
       const DbLayer = TestDatabaseLayer({
         storagePath: testStoragePath({ name: `feed-test-${Date.now()}` }),
       });
@@ -34,7 +34,7 @@ describe('TestDatabaseLayer', { timeout: 600_000 }, () => {
 
   it.effect(
     'reload database -- save index before restart',
-    Effect.fnUntraced(function* ({ expect: _ }) {
+    Effect.fnUntraced(function* (_) {
       const NUM_OBJECTS = 500;
       const DbLayer = TestDatabaseLayer({
         types: [DataType.Person],
@@ -58,7 +58,7 @@ describe('TestDatabaseLayer', { timeout: 600_000 }, () => {
   it.effect.skip(
     'reload database -- save index before restart [manual]',
     Effect.fnUntraced(
-      function* ({ expect: _ }) {
+      function* (_) {
         const NUM_OBJECTS = 500;
 
         {

package/src/testing/services.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Context } from 'effect';
+import type * as Context from 'effect/Context';
 
 import type { Space } from '@dxos/client/echo';
 import type { EchoDatabase, QueueFactory } from '@dxos/echo-db';

package/src/trace.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { type Ref, Type } from '@dxos/echo';
+import { ObjectId } from '@dxos/echo/internal';
 import { Queue } from '@dxos/echo-db';
-import { ObjectId } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
 import { FunctionTrigger } from './types';

package/src/triggers/invocation-tracer.ts

@@ -2,7 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import { Obj, Ref } from '@dxos/echo';
 import { type Queue } from '@dxos/echo-db';

package/src/triggers/trigger-dispatcher.test.ts

@@ -2,9 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { FetchHttpClient } from '@effect/platform';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
 import { describe, it } from '@effect/vitest';
-import { Duration, Effect, Exit, Layer, pipe } from 'effect';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Function from 'effect/Function';
+import * as Layer from 'effect/Layer';
 
 import { AiService } from '@dxos/ai';
 import { Filter, Obj, Query, Ref } from '@dxos/echo';
@@ -18,11 +22,10 @@ import {
   ComputeEventLogger,
   CredentialsService,
   DatabaseService,
+  FunctionInvocationService,
   QueueService,
-  RemoteFunctionExecutionService,
   TracingService,
 } from '../services';
-import { FunctionImplementationResolver, LocalFunctionExecutionService } from '../services/local-function-execution';
 import { TestDatabaseLayer } from '../testing';
 import { FunctionTrigger } from '../types';
 
@@ -30,22 +33,22 @@ import { InvocationTracer } from './invocation-tracer';
 import { TriggerDispatcher } from './trigger-dispatcher';
 import { TriggerStateStore } from './trigger-state-store';
 
-const TestLayer = pipe(
+const TestLayer = Function.pipe(
   Layer.mergeAll(ComputeEventLogger.layerFromTracing, InvocationTracer.layerTest, TriggerStateStore.layerMemory),
   Layer.provideMerge(
     Layer.mergeAll(
       AiService.notAvailable,
+      CredentialsService.layerConfig([]),
+      FunctionInvocationService.layerTestMocked({ functions: [reply] }).pipe(
+        Layer.provideMerge(ComputeEventLogger.layerFromTracing),
+        Layer.provideMerge(TracingService.layerLogInfo()),
+      ),
+      FetchHttpClient.layer,
       TestDatabaseLayer({
         types: [FunctionType, FunctionTrigger, DataType.Person, DataType.Task],
       }),
-      CredentialsService.layerConfig([]),
-      LocalFunctionExecutionService.layerLive,
-      RemoteFunctionExecutionService.mockLayer,
-      TracingService.layerLogInfo(),
-      FetchHttpClient.layer,
     ),
   ),
-  Layer.provideMerge(FunctionImplementationResolver.layerTest({ functions: [reply] })),
 );
 
 const TestTriggerDispatcherLayer = Layer.provideMerge(
@@ -452,7 +455,9 @@ describe('TriggerDispatcher', () => {
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -494,7 +499,9 @@ describe('TriggerDispatcher', () => {
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -530,7 +537,9 @@ describe('TriggerDispatcher', () => {
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -578,7 +587,9 @@ describe('TriggerDispatcher', () => {
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Task)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Task)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -625,7 +636,9 @@ describe('TriggerDispatcher', () => {
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
           input: {
             objectId: '{{event.changedObjectId}}',