@dxos/functions 0.5.3-main.6f2dfea → 0.5.3-main.79e0565

package/schema/functions.json

@@ -1,26 +1,24 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
-  "required": [
-    "functions"
-  ],
+  "required": [],
   "properties": {
     "functions": {
       "type": "array",
       "items": {
         "type": "object",
         "required": [
-          "id",
-          "path",
+          "uri",
+          "route",
           "handler"
         ],
         "properties": {
-          "id": {
+          "uri": {
             "type": "string",
             "description": "a string",
             "title": "string"
           },
-          "path": {
+          "route": {
             "type": "string",
             "description": "a string",
             "title": "string"
@@ -44,135 +42,165 @@
       "items": {
         "type": "object",
         "required": [
-          "function"
+          "function",
+          "spec"
         ],
         "properties": {
           "function": {
             "type": "string",
-            "description": "Function ID/URI.",
+            "description": "Function URI.",
             "title": "string"
           },
-          "context": {
-            "type": "object",
-            "required": [],
-            "properties": {},
-            "additionalProperties": {
-              "$id": "/schemas/any",
-              "title": "any"
-            }
+          "meta": {
+            "$ref": "#/$defs/object"
           },
-          "timer": {
-            "type": "object",
-            "required": [
-              "cron"
-            ],
-            "properties": {
-              "cron": {
-                "type": "string",
-                "description": "a string",
-                "title": "string"
-              }
-            },
-            "additionalProperties": false
-          },
-          "webhook": {
-            "type": "object",
-            "required": [
-              "port"
-            ],
-            "properties": {
-              "port": {
-                "type": "number",
-                "description": "a number",
-                "title": "number"
-              }
-            },
-            "additionalProperties": false
-          },
-          "websocket": {
-            "type": "object",
-            "required": [
-              "url"
-            ],
-            "properties": {
-              "url": {
-                "type": "string",
-                "description": "a string",
-                "title": "string"
-              },
-              "init": {
+          "spec": {
+            "anyOf": [
+              {
                 "type": "object",
-                "required": [],
-                "properties": {},
-                "additionalProperties": {
-                  "$id": "/schemas/any",
-                  "title": "any"
-                }
-              }
-            },
-            "additionalProperties": false
-          },
-          "subscription": {
-            "type": "object",
-            "required": [
-              "filter"
-            ],
-            "properties": {
-              "spaceKey": {
-                "type": "string",
-                "description": "a string",
-                "title": "string"
-              },
-              "filter": {
-                "type": "array",
-                "items": {
-                  "type": "object",
-                  "required": [
-                    "type"
-                  ],
-                  "properties": {
-                    "type": {
-                      "type": "string",
-                      "description": "a string",
-                      "title": "string"
-                    },
-                    "props": {
-                      "type": "object",
-                      "required": [],
-                      "properties": {},
-                      "additionalProperties": {
-                        "$id": "/schemas/any",
-                        "title": "any"
-                      }
-                    }
+                "required": [
+                  "type",
+                  "cron"
+                ],
+                "properties": {
+                  "type": {
+                    "const": "timer"
                   },
-                  "additionalProperties": false
-                }
+                  "cron": {
+                    "type": "string",
+                    "description": "a string",
+                    "title": "string"
+                  }
+                },
+                "additionalProperties": false
               },
-              "options": {
+              {
                 "type": "object",
-                "required": [],
+                "required": [
+                  "type",
+                  "method"
+                ],
                 "properties": {
-                  "deep": {
-                    "type": "boolean",
-                    "description": "a boolean",
-                    "title": "boolean"
+                  "type": {
+                    "const": "webhook"
+                  },
+                  "method": {
+                    "type": "string",
+                    "description": "a string",
+                    "title": "string"
                   },
-                  "delay": {
+                  "port": {
                     "type": "number",
                     "description": "a number",
                     "title": "number"
                   }
                 },
                 "additionalProperties": false
+              },
+              {
+                "type": "object",
+                "required": [
+                  "type",
+                  "url"
+                ],
+                "properties": {
+                  "type": {
+                    "const": "websocket"
+                  },
+                  "url": {
+                    "type": "string",
+                    "description": "a string",
+                    "title": "string"
+                  },
+                  "init": {
+                    "type": "object",
+                    "required": [],
+                    "properties": {},
+                    "additionalProperties": {
+                      "$id": "/schemas/any",
+                      "title": "any"
+                    }
+                  }
+                },
+                "additionalProperties": false
+              },
+              {
+                "type": "object",
+                "required": [
+                  "type",
+                  "filter"
+                ],
+                "properties": {
+                  "type": {
+                    "const": "subscription"
+                  },
+                  "filter": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "required": [
+                        "type"
+                      ],
+                      "properties": {
+                        "type": {
+                          "type": "string",
+                          "description": "a string",
+                          "title": "string"
+                        },
+                        "props": {
+                          "type": "object",
+                          "required": [],
+                          "properties": {},
+                          "additionalProperties": {
+                            "$id": "/schemas/any",
+                            "title": "any"
+                          }
+                        }
+                      },
+                      "additionalProperties": false
+                    }
+                  },
+                  "options": {
+                    "type": "object",
+                    "required": [],
+                    "properties": {
+                      "deep": {
+                        "type": "boolean",
+                        "description": "a boolean",
+                        "title": "boolean"
+                      },
+                      "delay": {
+                        "type": "number",
+                        "description": "a number",
+                        "title": "number"
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "additionalProperties": false
               }
-            },
-            "additionalProperties": false
+            ]
           }
         },
         "additionalProperties": false
       }
     }
   },
-  "additionalProperties": false
+  "additionalProperties": false,
+  "$defs": {
+    "object": {
+      "$id": "/schemas/object",
+      "oneOf": [
+        {
+          "type": "object"
+        },
+        {
+          "type": "array"
+        }
+      ],
+      "description": "an object in the TypeScript meaning, i.e. the `object` type",
+      "title": "object"
+    }
+  }
 }

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

@@ -0,0 +1,105 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Trigger } from '@dxos/async';
+import { type Client } from '@dxos/client';
+import { TestBuilder } from '@dxos/client/testing';
+import { Context } from '@dxos/context';
+import { Filter } from '@dxos/echo-db';
+import { create } from '@dxos/echo-schema';
+import { describe, test } from '@dxos/test';
+import { range } from '@dxos/util';
+
+import { FunctionRegistry } from './function-registry';
+import { createInitializedClients } from '../testing';
+import { FunctionDef, type FunctionManifest } from '../types';
+
+const testManifest: FunctionManifest = {
+  functions: [
+    {
+      uri: 'dxos.functions.test/hello',
+      route: '/hello',
+      handler: 'test',
+    },
+  ],
+};
+
+describe('function registry', () => {
+  let ctx: Context;
+  let testBuilder: TestBuilder;
+  beforeEach(async () => {
+    ctx = new Context();
+    testBuilder = new TestBuilder();
+  });
+  afterEach(async () => {
+    await ctx.dispose();
+    await testBuilder.destroy();
+  });
+
+  describe('register', () => {
+    test('creates new functions', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const space = await client.spaces.create();
+      await registry.register(space, testManifest.functions);
+      const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
+      expect(definitions.length).to.eq(1);
+      expect(definitions[0].uri).to.eq(testManifest.functions?.[0]?.uri);
+    });
+
+    test('de-duplicates by function URI', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const space = await client.spaces.create();
+      const existing = space.db.add(create(FunctionDef, testManifest.functions![0]));
+      await registry.register(space, testManifest.functions);
+      const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
+      expect(definitions.length).to.eq(1);
+      expect(definitions[0].uri).to.eq(existing.uri);
+    });
+  });
+
+  describe('onFunctionsRegistered', () => {
+    test('called with all registered when opened', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const space = await client.spaces.create();
+      const definitions = range(3, () => create(FunctionDef, testManifest.functions![0]));
+      definitions.forEach((def) => space.db.add(def));
+
+      const functionRegistered = new Trigger<FunctionDef[]>();
+      registry.registered.on((fn) => {
+        functionRegistered.wake(fn.added);
+      });
+      void registry.open(ctx);
+      const functions = await functionRegistered.wait();
+      const expected = definitions.map((def) => def.uri).sort();
+      expect(functions.map((fn) => fn.uri).sort()).to.deep.eq(expected);
+    });
+
+    test('called when a new functions is added', async () => {
+      const client = (await createInitializedClients(testBuilder))[0];
+      const registry = createRegistry(client);
+      const space = await client.spaces.create();
+
+      const functionRegistered = new Trigger<FunctionDef>();
+      registry.registered.on((fn) => {
+        expect(fn.added.length).to.eq(1);
+        functionRegistered.wake(fn.added[0]);
+      });
+      await registry.open(ctx);
+      await registry.register(space, testManifest.functions);
+      const registered = await functionRegistered.wait();
+      expect(registered.uri).to.eq(testManifest.functions![0].uri);
+    });
+  });
+
+  const createRegistry = (client: Client) => {
+    const registry = new FunctionRegistry(client);
+    ctx.onDispose(() => registry.close());
+    return registry;
+  };
+});

package/src/function/function-registry.ts

@@ -0,0 +1,90 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { type Client } from '@dxos/client';
+import { create, Filter, type Space } from '@dxos/client/echo';
+import { type Context, Resource } from '@dxos/context';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { ComplexMap } from '@dxos/util';
+
+import { FunctionDef, type FunctionManifest } from '../types';
+import { diff } from '../util';
+
+export type FunctionsRegisteredEvent = {
+  space: Space;
+  added: FunctionDef[];
+};
+
+export class FunctionRegistry extends Resource {
+  private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
+
+  public readonly registered = new Event<FunctionsRegisteredEvent>();
+
+  constructor(private readonly _client: Client) {
+    super();
+  }
+
+  public getFunctions(space: Space): FunctionDef[] {
+    return this._functionBySpaceKey.get(space.key) ?? [];
+  }
+
+  /**
+   * Loads function definitions from the manifest into the space.
+   * We first load all the definitions from the space to deduplicate by functionId.
+   */
+  public async register(space: Space, functions: FunctionManifest['functions']): Promise<void> {
+    log('register', { space: space.key, functions: functions?.length ?? 0 });
+    if (!functions?.length) {
+      return;
+    }
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionDef)) {
+      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionDef);
+    }
+
+    // Sync definitions.
+    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
+    const { added, removed } = diff(existing, functions, (a, b) => a.uri === b.uri);
+    added.forEach((def) => space.db.add(create(FunctionDef, def)));
+    // TODO(burdon): Update existing templates.
+    removed.forEach((def) => space.db.remove(def));
+  }
+
+  protected override async _open(): Promise<void> {
+    const spacesSubscription = this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        if (this._functionBySpaceKey.has(space.key)) {
+          continue;
+        }
+
+        const registered: FunctionDef[] = [];
+        this._functionBySpaceKey.set(space.key, registered);
+        await space.waitUntilReady();
+        if (this._ctx.disposed) {
+          break;
+        }
+
+        // Subscribe to updates.
+        this._ctx.onDispose(
+          space.db.query(Filter.schema(FunctionDef)).subscribe(({ objects }) => {
+            const { added } = diff(registered, objects, (a, b) => a.uri === b.uri);
+            // TODO(burdon): Update and remove.
+            if (added.length > 0) {
+              registered.push(...added);
+              this.registered.emit({ space, added });
+            }
+          }),
+        );
+      }
+    });
+
+    // TODO(burdon): API: Normalize unsubscribe methods.
+    this._ctx.onDispose(() => spacesSubscription.unsubscribe());
+  }
+
+  protected override async _close(_: Context): Promise<void> {
+    this._functionBySpaceKey.clear();
+  }
+}

package/src/function/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './function-registry';

package/src/handler.ts

@@ -8,38 +8,61 @@ import { type EchoReactiveObject } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 import { nonNullable } from '@dxos/util';
 
-// Lambda-like function definitions.
+// TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
+// https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
 // https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
 // https://www.npmjs.com/package/aws-lambda
-// https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
 
-// TODO(burdon): No response?
-export interface Response {
-  status(code: number): Response;
-}
+/**
+ * Function handler.
+ */
+export type FunctionHandler<TData = {}, TMeta = {}> = (params: {
+  context: FunctionContext;
+  event: FunctionEvent<TData, TMeta>;
+  response: FunctionResponse;
+}) => Promise<FunctionResponse | void>;
 
+/**
+ * Function context.
+ */
 export interface FunctionContext {
   // TODO(burdon): Limit access to individual space.
   client: Client;
   // TODO(burdon): Replace with storage service abstraction.
   dataDir?: string;
-  // Data passed to function invocation.
-  data?: any;
 }
 
-// TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
-export type FunctionHandler<T extends {}> = (params: {
-  event: T;
-  context: FunctionContext;
-  response: Response;
-}) => Promise<Response | void>;
+/**
+ * Event payload.
+ */
+export type FunctionEvent<TData = {}, TMeta = {}> = {
+  data: FunctionEventMeta<TMeta> & TData;
+};
+
+/**
+ * Metadata from trigger.
+ */
+export type FunctionEventMeta<TMeta = {}> = {
+  meta: TMeta;
+};
+
+/**
+ * Function response.
+ */
+export interface FunctionResponse {
+  status(code: number): FunctionResponse;
+}
+
+//
+// Subscription utils.
+//
 
-export type RawSubscriptionEvent = {
+export type RawSubscriptionData = {
   spaceKey?: string;
   objects?: string[];
 };
 
-export type SubscriptionEvent = {
+export type SubscriptionData = {
   space?: Space;
   objects?: EchoReactiveObject<any>[];
 };
@@ -54,22 +77,22 @@ export type SubscriptionEvent = {
  *
  * NOTE: Get space key from devtools or `dx space list --json`
  */
-export const subscriptionHandler = (
-  handler: FunctionHandler<SubscriptionEvent>,
-): FunctionHandler<RawSubscriptionEvent> => {
-  return ({ event, context, ...rest }) => {
+export const subscriptionHandler = <TMeta>(
+  handler: FunctionHandler<SubscriptionData, TMeta>,
+): FunctionHandler<RawSubscriptionData, TMeta> => {
+  return ({ event: { data }, context, ...rest }) => {
     const { client } = context;
-    const space = event.spaceKey ? client.spaces.get(PublicKey.from(event.spaceKey)) : undefined;
-    const objects =
-      space &&
-      event.objects?.map<EchoReactiveObject<any> | undefined>((id) => space!.db.getObjectById(id)).filter(nonNullable);
+    const space = data.spaceKey ? client.spaces.get(PublicKey.from(data.spaceKey)) : undefined;
+    const objects = space
+      ? data.objects?.map<EchoReactiveObject<any> | undefined>((id) => space!.db.getObjectById(id)).filter(nonNullable)
+      : [];
 
-    if (!!event.spaceKey && !space) {
-      log.warn('invalid space', { event });
+    if (!!data.spaceKey && !space) {
+      log.warn('invalid space', { data });
     } else {
       log.info('handler', { space: space?.key.truncate(), objects: objects?.length });
     }
 
-    return handler({ event: { space, objects }, context, ...rest });
+    return handler({ event: { data: { ...data, space, objects } }, context, ...rest });
   };
 };

package/src/index.ts

@@ -2,6 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
+export * from './function';
 export * from './handler';
 export * from './runtime';
+export * from './trigger';
 export * from './types';