@dxos/functions 0.7.0 → 0.7.1-staging.7f6f91c

package/dist/types/src/types.d.ts

@@ -1,67 +1,113 @@
 import { S } from '@dxos/echo-schema';
 /**
- * Type discriminator for TriggerSpec.
- * Every spec has a type field of type FunctionTriggerType that we can use to understand which
- * type we're working with.
+ * Type discriminator for TriggerType.
+ * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
  * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
  */
-export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
+export type TriggerKind = 'timer' | 'webhook' | 'websocket' | 'subscription';
+/**
+ * Cron timer.
+ */
 declare const TimerTriggerSchema: S.mutable<S.Struct<{
     type: S.Literal<["timer"]>;
-    cron: typeof S.String;
+    cron: S.refine<string, S.Schema<string, string, never>>;
 }>>;
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
+/**
+ * Webhook.
+ */
 declare const WebhookTriggerSchema: S.mutable<S.Struct<{
     type: S.Literal<["webhook"]>;
     method: typeof S.String;
     port: S.optional<typeof S.Number>;
 }>>;
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
+/**
+ * Websocket.
+ * @deprecated
+ */
 declare const WebsocketTriggerSchema: S.mutable<S.Struct<{
     type: S.Literal<["websocket"]>;
     url: typeof S.String;
     init: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
 }>>;
 export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
+/**
+ * Subscription.
+ */
 declare const SubscriptionTriggerSchema: S.mutable<S.Struct<{
     type: S.Literal<["subscription"]>;
-    filter: S.Array$<S.Struct<{
-        type: typeof S.String;
+    filter: S.Struct<{
+        type: S.optional<S.SchemaClass<string, string, never>>;
         props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
-    }>>;
+    }>;
     options: S.optional<S.Struct<{
-        deep: S.optional<typeof S.Boolean>;
-        delay: S.optional<typeof S.Number>;
+        deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        delay: S.optional<S.SchemaClass<number, number, never>>;
     }>>;
 }>>;
 export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
-export type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;
-declare const FunctionDef_base: import("@dxos/echo-schema").AbstractTypedObject<{
-    handler: string;
-    uri: string;
-    description?: string | undefined;
-    route: string;
-} & {
-    id: string;
-}, S.Struct.Encoded<{
-    uri: typeof S.String;
-    description: S.optional<typeof S.String>;
-    route: typeof S.String;
-    handler: typeof S.String;
-}>>;
 /**
- * Function definition.
+ * Trigger schema (discriminated union).
  */
-export declare class FunctionDef extends FunctionDef_base {
-}
+export declare const TriggerSchema: S.Union<[S.mutable<S.Struct<{
+    type: S.Literal<["timer"]>;
+    cron: S.refine<string, S.Schema<string, string, never>>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<["webhook"]>;
+    method: typeof S.String;
+    port: S.optional<typeof S.Number>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<["websocket"]>;
+    url: typeof S.String;
+    init: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<["subscription"]>;
+    filter: S.Struct<{
+        type: S.optional<S.SchemaClass<string, string, never>>;
+        props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+    }>;
+    options: S.optional<S.Struct<{
+        deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        delay: S.optional<S.SchemaClass<number, number, never>>;
+    }>>;
+}>>]>;
+export type TriggerType = S.Schema.Type<typeof TriggerSchema>;
+/**
+ * Function trigger.
+ */
+export declare const FunctionTriggerSchema: S.Struct<{
+    function: S.optional<S.SchemaClass<string, string, never>>;
+    enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+    spec: S.optional<S.Union<[S.mutable<S.Struct<{
+        type: S.Literal<["timer"]>;
+        cron: S.refine<string, S.Schema<string, string, never>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<["webhook"]>;
+        method: typeof S.String;
+        port: S.optional<typeof S.Number>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<["websocket"]>;
+        url: typeof S.String;
+        init: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<["subscription"]>;
+        filter: S.Struct<{
+            type: S.optional<S.SchemaClass<string, string, never>>;
+            props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+        }>;
+        options: S.optional<S.Struct<{
+            deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+            delay: S.optional<S.SchemaClass<number, number, never>>;
+        }>>;
+    }>>]>>;
+    meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
+}>;
+export type FunctionTriggerType = S.Schema.Type<typeof FunctionTriggerSchema>;
 declare const FunctionTrigger_base: import("@dxos/echo-schema").AbstractTypedObject<{
-    function: string;
-    name?: string | undefined;
+    function?: string | undefined;
     enabled?: boolean | undefined;
-    meta?: {
-        [x: string]: any;
-    } | undefined;
-    spec: {
+    spec?: {
         type: "timer";
         cron: string;
     } | {
@@ -75,28 +121,29 @@ declare const FunctionTrigger_base: import("@dxos/echo-schema").AbstractTypedObj
             readonly [x: string]: any;
         } | undefined;
     } | {
-        filter: readonly {
-            readonly type: string;
+        filter: {
+            readonly type?: string | undefined;
             readonly props?: {
                 readonly [x: string]: any;
             } | undefined;
-        }[];
+        };
         type: "subscription";
         options?: {
             readonly deep?: boolean | undefined;
             readonly delay?: number | undefined;
         } | undefined;
-    };
+    } | undefined;
+    meta?: {
+        [x: string]: any;
+    } | undefined;
 } & {
     id: string;
 }, S.Struct.Encoded<{
-    name: S.optional<typeof S.String>;
-    enabled: S.optional<typeof S.Boolean>;
-    function: S.SchemaClass<string, string, never>;
-    meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
-    spec: S.Union<[S.mutable<S.Struct<{
+    readonly function: S.optional<S.SchemaClass<string, string, never>>;
+    readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+    readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
         type: S.Literal<["timer"]>;
-        cron: typeof S.String;
+        cron: S.refine<string, S.Schema<string, string, never>>;
     }>>, S.mutable<S.Struct<{
         type: S.Literal<["webhook"]>;
         method: typeof S.String;
@@ -107,21 +154,41 @@ declare const FunctionTrigger_base: import("@dxos/echo-schema").AbstractTypedObj
         init: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
     }>>, S.mutable<S.Struct<{
         type: S.Literal<["subscription"]>;
-        filter: S.Array$<S.Struct<{
-            type: typeof S.String;
+        filter: S.Struct<{
+            type: S.optional<S.SchemaClass<string, string, never>>;
             props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
-        }>>;
+        }>;
         options: S.optional<S.Struct<{
-            deep: S.optional<typeof S.Boolean>;
-            delay: S.optional<typeof S.Number>;
+            deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+            delay: S.optional<S.SchemaClass<number, number, never>>;
         }>>;
-    }>>]>;
+    }>>]>>;
+    readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
 }>>;
 /**
  * Function trigger.
  */
 export declare class FunctionTrigger extends FunctionTrigger_base {
 }
+declare const FunctionDef_base: import("@dxos/echo-schema").AbstractTypedObject<{
+    handler: string;
+    uri: string;
+    description?: string | undefined;
+    route: string;
+} & {
+    id: string;
+}, S.Struct.Encoded<{
+    uri: typeof S.String;
+    description: S.optional<typeof S.String>;
+    route: typeof S.String;
+    handler: typeof S.String;
+}>>;
+/**
+ * Function definition.
+ * @deprecated (Use dxos.org/type/Function)
+ */
+export declare class FunctionDef extends FunctionDef_base {
+}
 /**
  * Function manifest file.
  */
@@ -140,13 +207,9 @@ export declare const FunctionManifestSchema: S.Struct<{
         handler: typeof S.String;
     }>, never>>>>;
     triggers: S.optional<S.mutable<S.Array$<S.Schema<{
-        function: string;
-        name?: string | undefined;
+        function?: string | undefined;
         enabled?: boolean | undefined;
-        meta?: {
-            [x: string]: any;
-        } | undefined;
-        spec: {
+        spec?: {
             type: "timer";
             cron: string;
         } | {
@@ -160,28 +223,29 @@ export declare const FunctionManifestSchema: S.Struct<{
                 readonly [x: string]: any;
             } | undefined;
         } | {
-            filter: readonly {
-                readonly type: string;
+            filter: {
+                readonly type?: string | undefined;
                 readonly props?: {
                     readonly [x: string]: any;
                 } | undefined;
-            }[];
+            };
             type: "subscription";
             options?: {
                 readonly deep?: boolean | undefined;
                 readonly delay?: number | undefined;
             } | undefined;
-        };
+        } | undefined;
+        meta?: {
+            [x: string]: any;
+        } | undefined;
     } & {
         "@meta"?: import("@dxos/echo-schema").ObjectMeta;
     }, S.Struct.Encoded<{
-        name: S.optional<typeof S.String>;
-        enabled: S.optional<typeof S.Boolean>;
-        function: S.SchemaClass<string, string, never>;
-        meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
-        spec: S.Union<[S.mutable<S.Struct<{
+        readonly function: S.optional<S.SchemaClass<string, string, never>>;
+        readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
             type: S.Literal<["timer"]>;
-            cron: typeof S.String;
+            cron: S.refine<string, S.Schema<string, string, never>>;
         }>>, S.mutable<S.Struct<{
             type: S.Literal<["webhook"]>;
             method: typeof S.String;
@@ -192,18 +256,19 @@ export declare const FunctionManifestSchema: S.Struct<{
             init: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
         }>>, S.mutable<S.Struct<{
             type: S.Literal<["subscription"]>;
-            filter: S.Array$<S.Struct<{
-                type: typeof S.String;
+            filter: S.Struct<{
+                type: S.optional<S.SchemaClass<string, string, never>>;
                 props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
-            }>>;
+            }>;
             options: S.optional<S.Struct<{
-                deep: S.optional<typeof S.Boolean>;
-                delay: S.optional<typeof S.Number>;
+                deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+                delay: S.optional<S.SchemaClass<number, number, never>>;
             }>>;
-        }>>]>;
+        }>>]>>;
+        readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
     }>, never>>>>;
 }>;
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;
-export declare const FUNCTION_SCHEMA: (typeof FunctionDef | typeof FunctionTrigger)[];
+export declare const FUNCTION_TYPES: (typeof FunctionTrigger | typeof FunctionDef)[];
 export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/types/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAa,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAErF,QAAA,MAAM,kBAAkB;;;GAGN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,oBAAoB;;;;GAKR,CAAC;AAEnB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,QAAA,MAAM,sBAAsB;;;;GAIV,CAAC;AAEnB,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAO5E,QAAA,MAAM,yBAAyB;;;;;;;;;;GAYb,CAAC;AAEnB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AASlF,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;;;;;;;;;;;;;;AAEjG;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAQ/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAUnC;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAG5E,eAAO,MAAM,eAAe,iDAAiC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,CAAC;AAK7E;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;GAMN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;GAKR,CAAC;AAEnB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE;;;GAGG;AACH,QAAA,MAAM,sBAAsB;;;;GAIV,CAAC;AAEnB,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAQ5E;;GAEG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;GAYb,CAAC;AAEnB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;KAK2B,CAAC;AAEtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;EAWhC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAGL;CAAG;;;;;;;;;;;;;;AAEnC;;;GAGG;AAEH,qBAAa,WAAY,SAAQ,gBAQ/B;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,cAAc,iDAAiC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.7.0",
+  "version": "0.7.1-staging.7f6f91c",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -41,30 +41,31 @@
     "src"
   ],
   "dependencies": {
-    "@effect/schema": "^0.75.1",
+    "@effect/schema": "^0.75.5",
     "@preact/signals-core": "^1.6.0",
     "cron": "^3.1.6",
-    "effect": "^3.9.1",
+    "effect": "^3.9.2",
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "ws": "^8.14.2",
-    "@dxos/async": "0.7.0",
-    "@dxos/context": "0.7.0",
-    "@dxos/client": "0.7.0",
-    "@dxos/echo-db": "0.7.0",
-    "@dxos/echo-protocol": "0.7.0",
-    "@dxos/echo-schema": "0.7.0",
-    "@dxos/invariant": "0.7.0",
-    "@dxos/keys": "0.7.0",
-    "@dxos/log": "0.7.0",
-    "@dxos/node-std": "0.7.0",
-    "@dxos/util": "0.7.0",
-    "@dxos/protocols": "0.7.0"
+    "@dxos/async": "0.7.1-staging.7f6f91c",
+    "@dxos/client": "0.7.1-staging.7f6f91c",
+    "@dxos/context": "0.7.1-staging.7f6f91c",
+    "@dxos/echo-protocol": "0.7.1-staging.7f6f91c",
+    "@dxos/echo-schema": "0.7.1-staging.7f6f91c",
+    "@dxos/echo-db": "0.7.1-staging.7f6f91c",
+    "@dxos/keys": "0.7.1-staging.7f6f91c",
+    "@dxos/invariant": "0.7.1-staging.7f6f91c",
+    "@dxos/log": "0.7.1-staging.7f6f91c",
+    "@dxos/protocols": "0.7.1-staging.7f6f91c",
+    "@dxos/node-std": "0.7.1-staging.7f6f91c",
+    "@dxos/schema": "0.7.1-staging.7f6f91c",
+    "@dxos/util": "0.7.1-staging.7f6f91c"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.7.0"
+    "@dxos/agent": "0.7.1-staging.7f6f91c"
   },
   "publishConfig": {
     "access": "public"

package/schema/functions.json

@@ -48,7 +48,7 @@
         "properties": {
           "function": {
             "type": "string",
-            "description": "Function URI.",
+            "description": "Function",
             "title": "string"
           },
           "enabled": {
@@ -208,4 +208,4 @@
       "title": "object"
     }
   }
-}
+}

package/src/runtime/scheduler.test.ts

@@ -175,7 +175,7 @@ describe('scheduler', () => {
           enabled: true,
           spec: {
             type: 'subscription',
-            filter: [{ type: TestType.typename }],
+            filter: { type: TestType.typename },
           },
         },
       ],

package/src/runtime/scheduler.ts

@@ -136,7 +136,7 @@ export class Scheduler {
       if (endpoint) {
         // TODO(burdon): Move out of scheduler (generalize as callback).
         const url = path.join(endpoint, def.route);
-        log.info('exec', { function: def.uri, url, triggerType: trigger.spec.type });
+        log.info('exec', { function: def.uri, url, triggerType: trigger.spec?.type });
         const response = await fetch(url, {
           method: 'POST',
           headers: {

package/src/testing/functions-integration.test.ts

@@ -43,7 +43,7 @@ describe.skip('functions e2e', () => {
         meta: triggerMeta,
         spec: {
           type: 'subscription',
-          filter: [{ type: TestType.typename }],
+          filter: { type: TestType.typename },
         },
       }),
     );

package/src/testing/util.ts

@@ -12,9 +12,9 @@ import { FunctionTrigger } from '../types';
 
 export const triggerWebhook = async (space: Space, uri: string) => {
   const trigger = (
-    await space.db.query(Filter.schema(FunctionTrigger, (t: FunctionTrigger) => t.function === uri)).run()
+    await space.db.query(Filter.schema(FunctionTrigger, (trigger: FunctionTrigger) => trigger.function === uri)).run()
   ).objects[0];
-  invariant(trigger.spec.type === 'webhook');
+  invariant(trigger.spec?.type === 'webhook');
   void fetch(`http://localhost:${trigger.spec.port}`);
 };
 

package/src/trigger/trigger-registry.test.ts

@@ -48,11 +48,9 @@ const manifest: FunctionManifest = {
       enabled: true,
       spec: {
         type: 'subscription',
-        filter: [
-          {
-            type: TestType.typename,
-          },
-        ],
+        filter: {
+          type: TestType.typename,
+        },
       },
     },
   ],
@@ -111,13 +109,13 @@ describe('trigger registry', () => {
 
       const callbackInvoked = new Trigger();
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const webhookTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'webhook')!;
+      const webhookTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'webhook')!;
       await registry.activate(space, webhookTrigger, async () => {
         callbackInvoked.wake();
         return 200;
       });
 
-      setTimeout(() => triggerWebhook(space, webhookTrigger.function));
+      setTimeout(() => triggerWebhook(space, webhookTrigger.function!));
       await callbackInvoked.wait();
     });
 
@@ -150,7 +148,7 @@ describe('trigger registry', () => {
       await waitForInactiveTriggers(registry, space);
 
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
+      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'subscription')!;
       let count = 0;
       await registry.activate(space, echoTrigger, async () => {
         count++;
@@ -177,7 +175,7 @@ describe('trigger registry', () => {
       await waitForInactiveTriggers(registry, space);
 
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
+      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec?.type === 'subscription')!;
       let count = 0;
       await registry.activate(space, echoTrigger, async () => {
         count++;

package/src/trigger/trigger-registry.ts

@@ -12,15 +12,15 @@ import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { ComplexMap, diff } from '@dxos/util';
 
-import { createSubscriptionTrigger, createTimerTrigger, createWebsocketTrigger } from './type';
-import { type FunctionManifest, FunctionTrigger, type FunctionTriggerType, type TriggerSpec } from '../types';
+import { createSubscriptionTrigger, createTimerTrigger } from './type';
+import { type FunctionManifest, FunctionTrigger, type TriggerKind, type TriggerType } from '../types';
 
 type ResponseCode = number;
 
 export type TriggerCallback = (args: object) => Promise<ResponseCode>;
 
 // TODO(burdon): Make object?
-export type TriggerFactory<Spec extends TriggerSpec, Options = any> = (
+export type TriggerFactory<Spec extends TriggerType, Options = any> = (
   ctx: Context,
   space: Space,
   spec: Spec,
@@ -28,15 +28,13 @@ export type TriggerFactory<Spec extends TriggerSpec, Options = any> = (
   options?: Options,
 ) => Promise<void>;
 
-export type TriggerFactoryMap = Record<FunctionTriggerType, TriggerFactory<any>>;
+export type TriggerFactoryMap = Partial<Record<TriggerKind, TriggerFactory<any>>>;
 
 const triggerFactory: TriggerFactoryMap = {
-  subscription: createSubscriptionTrigger,
   timer: createTimerTrigger,
   // TODO(burdon): Cannot use in browser.
   // webhook: createWebhookTrigger,
-  webhook: null as any,
-  websocket: createWebsocketTrigger,
+  subscription: createSubscriptionTrigger,
 };
 
 export type TriggerEvent = {
@@ -84,6 +82,7 @@ export class TriggerRegistry extends Resource {
 
     try {
       // Create trigger.
+      invariant(trigger.spec);
       const options = this._options?.[trigger.spec.type];
       const createTrigger = triggerFactory[trigger.spec.type];
       invariant(createTrigger, `Trigger factory not found: ${trigger.spec.type}`);
@@ -112,7 +111,7 @@ export class TriggerRegistry extends Resource {
       let keys = trigger[ECHO_ATTR_META]?.keys;
       delete trigger[ECHO_ATTR_META];
       if (!keys?.length) {
-        keys = [foreignKey('manifest', [trigger.function, trigger.spec.type].join(':'))];
+        keys = [foreignKey('manifest', [trigger.function, trigger.spec?.type].join(':'))];
       }
 
       return create(FunctionTrigger, trigger, { keys });

package/src/trigger/type/subscription-trigger.ts

@@ -73,8 +73,8 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
   // TODO(burdon): [Bug]: not updated when document is deleted (either top or hierarchically).
   log.info('subscription', { filter });
   // const query = triggerCtx.space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
-  if (filter) {
-    const query = space.db.query(Filter.typename(filter[0].type, filter[0].props));
+  if (filter.type) {
+    const query = space.db.query(Filter.typename(filter.type, filter.props));
     subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
   }