@dxos/functions 0.5.3-main.495a683 → 0.5.3-main.4e877aa

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,yBAAyB;;;;;;;;;;;;;;;;;EAiB7B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,QAAA,MAAM,kBAAkB;;;EAGtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,oBAAoB;;;;GAOzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,QAAA,MAAM,sBAAsB;;;;;;;;EAI1B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAS5E,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;;;;;;;;;AAEjG;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAS/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAQnC;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAO,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAKxD;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAErF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;EAiB7B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,QAAA,MAAM,kBAAkB;;;EAGtB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,oBAAoB;;;;GAOzB,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,QAAA,MAAM,sBAAsB;;;;;;;;EAI1B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAQ5E,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;;;;;;;;;AAEjG;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAS/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAQnC;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxos/functions",
-  "version": "0.5.3-main.495a683",
-  "description": "Functions API and runtime.",
+  "version": "0.5.3-main.4e877aa",
+  "description": "Functions SDK and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
@@ -10,24 +10,10 @@
     ".": {
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node/index.cjs",
-      "default": "./dist/lib/node/index.cjs",
-      "types": "./dist/types/src/index.d.ts"
-    },
-    "./types": {
-      "browser": "./dist/lib/browser/types.mjs",
-      "node": "./dist/lib/node/types.cjs",
-      "default": "./dist/lib/node/types.cjs",
-      "types": "./dist/types/src/types.d.ts"
+      "default": "./dist/lib/node/index.cjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "types": [
-        "dist/types/src/types.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "schema",
@@ -40,28 +26,29 @@
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "ws": "^8.14.2",
-    "@braneframe/types": "0.5.3-main.495a683",
-    "@dxos/client": "0.5.3-main.495a683",
-    "@dxos/async": "0.5.3-main.495a683",
-    "@dxos/context": "0.5.3-main.495a683",
-    "@dxos/echo-schema": "0.5.3-main.495a683",
-    "@dxos/echo-db": "0.5.3-main.495a683",
-    "@dxos/keys": "0.5.3-main.495a683",
-    "@dxos/invariant": "0.5.3-main.495a683",
-    "@dxos/node-std": "0.5.3-main.495a683",
-    "@dxos/protocols": "0.5.3-main.495a683",
-    "@dxos/log": "0.5.3-main.495a683",
-    "@dxos/util": "0.5.3-main.495a683"
+    "@braneframe/types": "0.5.3-main.4e877aa",
+    "@dxos/async": "0.5.3-main.4e877aa",
+    "@dxos/client": "0.5.3-main.4e877aa",
+    "@dxos/echo-db": "0.5.3-main.4e877aa",
+    "@dxos/context": "0.5.3-main.4e877aa",
+    "@dxos/invariant": "0.5.3-main.4e877aa",
+    "@dxos/echo-schema": "0.5.3-main.4e877aa",
+    "@dxos/keys": "0.5.3-main.4e877aa",
+    "@dxos/log": "0.5.3-main.4e877aa",
+    "@dxos/node-std": "0.5.3-main.4e877aa",
+    "@dxos/protocols": "0.5.3-main.4e877aa",
+    "@dxos/util": "0.5.3-main.4e877aa"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.5.3-main.495a683"
+    "@dxos/agent": "0.5.3-main.4e877aa"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "gen-schema": "ts-node ./tools/schema.ts"
+    "gen-schema": "ts-node ./tools/schema.ts",
+    "prebuild": "pnpm gen-schema"
   }
 }

package/schema/functions.json

@@ -48,11 +48,17 @@
         "properties": {
           "function": {
             "type": "string",
-            "description": "Function URI.",
+            "description": "Function ID/URI.",
             "title": "string"
           },
           "meta": {
-            "$ref": "#/$defs/object"
+            "type": "object",
+            "required": [],
+            "properties": {},
+            "additionalProperties": {
+              "$id": "/schemas/any",
+              "title": "any"
+            }
           },
           "spec": {
             "anyOf": [
@@ -187,20 +193,5 @@
       }
     }
   },
-  "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"
-    }
-  }
+  "additionalProperties": false
 }

package/src/index.ts

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

package/src/{function → registry}/function-registry.test.ts

@@ -44,7 +44,7 @@ describe('function registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const registry = createRegistry(client);
       const space = await client.spaces.create();
-      await registry.register(space, testManifest.functions);
+      await registry.register(space, testManifest);
       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);
@@ -54,8 +54,8 @@ describe('function registry', () => {
       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 existing = space.db.add(create(FunctionDef, { ...testManifest.functions![0] }));
+      await registry.register(space, testManifest);
       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);
@@ -67,12 +67,12 @@ describe('function registry', () => {
       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]));
+      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);
+      registry.onFunctionsRegistered.on((fn) => {
+        functionRegistered.wake(fn.newFunctions);
       });
       void registry.open(ctx);
       const functions = await functionRegistered.wait();
@@ -86,12 +86,12 @@ describe('function registry', () => {
       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]);
+      registry.onFunctionsRegistered.on((fn) => {
+        expect(fn.newFunctions.length).to.eq(1);
+        functionRegistered.wake(fn.newFunctions[0]);
       });
       await registry.open(ctx);
-      await registry.register(space, testManifest.functions);
+      await registry.register(space, testManifest);
       const registered = await functionRegistered.wait();
       expect(registered.uri).to.eq(testManifest.functions![0].uri);
     });

package/src/registry/function-registry.ts

@@ -0,0 +1,84 @@
+//
+// 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 { ComplexMap } from '@dxos/util';
+
+import { FunctionDef, type FunctionManifest } from '../types';
+
+export type FunctionsRegisteredEvent = {
+  space: Space;
+  newFunctions: FunctionDef[];
+};
+
+export class FunctionRegistry extends Resource {
+  private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
+
+  public readonly onFunctionsRegistered = new Event<FunctionsRegisteredEvent>();
+
+  constructor(private readonly _client: Client) {
+    super();
+  }
+
+  public getFunctions(space: Space): FunctionDef[] {
+    return this._functionBySpaceKey.get(space.key) ?? [];
+  }
+
+  /**
+   * The method loads function definitions from the manifest into the space.
+   * We first load all the definitions from the space to deduplicate by functionId.
+   */
+  // TODO(burdon): This should not be space specific (they are static for the agent).
+  public async register(space: Space, manifest: FunctionManifest): Promise<void> {
+    if (!manifest.functions?.length) {
+      return;
+    }
+    if (!space.db.graph.runtimeSchemaRegistry.isSchemaRegistered(FunctionDef)) {
+      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionDef);
+    }
+
+    const { objects: existingDefinitions } = await space.db.query(Filter.schema(FunctionDef)).run();
+    const newDefinitions = getNewDefinitions(manifest.functions, existingDefinitions);
+    const reactiveObjects = newDefinitions.map((template) => create(FunctionDef, { ...template }));
+    reactiveObjects.forEach((obj) => space.db.add(obj));
+  }
+
+  protected override async _open(): Promise<void> {
+    const spaceListSubscription = 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;
+        }
+
+        const functionsSubscription = space.db.query(Filter.schema(FunctionDef)).subscribe((definitions) => {
+          const newFunctions = getNewDefinitions(definitions.objects, registered);
+          if (newFunctions.length > 0) {
+            registered.push(...newFunctions);
+            this.onFunctionsRegistered.emit({ space, newFunctions });
+          }
+        });
+        this._ctx.onDispose(functionsSubscription);
+      }
+    });
+    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
+  }
+
+  protected override async _close(_: Context): Promise<void> {
+    this._functionBySpaceKey.clear();
+  }
+}
+
+const getNewDefinitions = <T extends { uri: string }>(candidateList: T[], existing: FunctionDef[]): T[] => {
+  return candidateList.filter((candidate) => existing.find((def) => def.uri === candidate.uri) == null);
+};

package/src/runtime/dev-server.test.ts

@@ -11,7 +11,7 @@ import { TestBuilder } from '@dxos/client/testing';
 import { describe, test } from '@dxos/test';
 
 import { DevServer } from './dev-server';
-import { FunctionRegistry } from '../function';
+import { FunctionRegistry } from '../registry';
 import { createFunctionRuntime } from '../testing';
 import { type FunctionManifest } from '../types';
 
@@ -44,7 +44,7 @@ describe('dev server', () => {
       baseDir: path.join(__dirname, '../testing'),
     });
     const space = await client.spaces.create();
-    await registry.register(space, manifest.functions);
+    await registry.register(space, manifest);
     await server.start();
 
     // TODO(burdon): Doesn't shut down cleanly.

package/src/runtime/dev-server.ts

@@ -13,8 +13,8 @@ import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
-import { type FunctionRegistry } from '../function';
 import { type FunctionContext, type FunctionEvent, type FunctionHandler, type FunctionResponse } from '../handler';
+import { type FunctionRegistry } from '../registry';
 import { type FunctionDef } from '../types';
 
 export type DevServerOptions = {
@@ -41,15 +41,16 @@ export class DevServer {
 
   public readonly update = new Event<number>();
 
+  // prettier-ignore
   constructor(
     private readonly _client: Client,
     private readonly _functionsRegistry: FunctionRegistry,
     private readonly _options: DevServerOptions,
   ) {
-    this._functionsRegistry.registered.on(async ({ added }) => {
-      added.forEach((def) => this._load(def));
+    this._functionsRegistry.onFunctionsRegistered.on(async ({ newFunctions }) => {
+      newFunctions.forEach((def) => this._load(def));
       await this._safeUpdateRegistration();
-      log('new functions loaded', { added });
+      log('new functions loaded', { newFunctions });
     });
   }
 
@@ -157,7 +158,7 @@ export class DevServer {
   /**
    * Load function.
    */
-  private async _load(def: FunctionDef, force?: boolean | undefined) {
+  private async _load(def: FunctionDef, force = false) {
     const { uri, route, handler } = def;
     const filePath = join(this._options.baseDir, handler);
     log.info('loading', { uri, force });

package/src/runtime/scheduler.test.ts

@@ -12,7 +12,7 @@ import { create } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 
 import { Scheduler, type SchedulerOptions } from './scheduler';
-import { FunctionRegistry } from '../function';
+import { FunctionRegistry } from '../registry';
 import { createInitializedClients, TestType, triggerWebhook } from '../testing';
 import { TriggerRegistry } from '../trigger';
 import { type FunctionManifest } from '../types';

package/src/runtime/scheduler.ts

@@ -4,13 +4,12 @@
 
 import path from 'node:path';
 
-import { Mutex } from '@dxos/async';
 import { type Space } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
 import { log } from '@dxos/log';
 
-import { type FunctionRegistry } from '../function';
 import { type FunctionEventMeta } from '../handler';
+import { type FunctionRegistry } from '../registry';
 import { type TriggerRegistry } from '../trigger';
 import { type FunctionDef, type FunctionManifest, type FunctionTrigger } from '../types';
 
@@ -27,15 +26,13 @@ export type SchedulerOptions = {
 export class Scheduler {
   private _ctx = createContext();
 
-  private readonly _callMutex = new Mutex();
-
   constructor(
     public readonly functions: FunctionRegistry,
     public readonly triggers: TriggerRegistry,
     private readonly _options: SchedulerOptions = {},
   ) {
-    this.functions.registered.on(async ({ space, added }) => {
-      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
+    this.functions.onFunctionsRegistered.on(async ({ space, newFunctions }) => {
+      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), newFunctions);
     });
     this.triggers.registered.on(async ({ space, triggers }) => {
       await this._safeActivateTriggers(space, triggers, this.functions.getFunctions(space));
@@ -55,9 +52,8 @@ export class Scheduler {
     await this.triggers.close();
   }
 
-  // TODO(burdon): Remove and update registries directly.
   public async register(space: Space, manifest: FunctionManifest) {
-    await this.functions.register(space, manifest.functions);
+    await this.functions.register(space, manifest);
     await this.triggers.register(space, manifest);
   }
 
@@ -80,20 +76,16 @@ export class Scheduler {
     }
 
     await this.triggers.activate({ space }, fnTrigger, async (args) => {
-      return this._callMutex.executeSynchronized(() => {
-        return this._execFunction(definition, fnTrigger, {
-          meta: fnTrigger.meta,
-          data: { ...args, spaceKey: space.key },
-        });
+      return this._execFunction(definition, {
+        meta: fnTrigger.meta,
+        data: { ...args, spaceKey: space.key },
       });
     });
-
     log('activated trigger', { space: space.key, trigger: fnTrigger });
   }
 
   private async _execFunction<TData, TMeta>(
     def: FunctionDef,
-    trigger: FunctionTrigger,
     { data, meta }: { data: TData; meta?: TMeta },
   ): Promise<number> {
     let status = 0;
@@ -105,7 +97,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 });
         const response = await fetch(url, {
           method: 'POST',
           headers: {

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

@@ -13,7 +13,7 @@ import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test } from '@dxos/test';
 
 import { setTestCallHandler } from './test/handler';
-import { FunctionRegistry } from '../function';
+import { FunctionRegistry } from '../registry';
 import { DevServer, Scheduler } from '../runtime';
 import { createFunctionRuntime, createInitializedClients, TestType } from '../testing';
 import { TriggerRegistry } from '../trigger';

package/src/testing/setup.ts

@@ -10,7 +10,7 @@ import { range } from '@dxos/util';
 import { TestType } from './types';
 import { FunctionDef, FunctionTrigger } from '../types';
 
-// TODO(burdon): Create new or extend existing TestBuilder.
+// TODO(burdon): Create TestBuilder.
 
 export const createInitializedClients = async (testBuilder: TestBuilder, count: number = 1, config?: Config) => {
   const clients = range(count).map(() => new Client({ config, services: testBuilder.createLocalClientServices() }));