@dxos/functions 0.5.3-main.d7fe7b5 → 0.5.3-main.e38fceb

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 '../registry';
+import { FunctionRegistry } from '../function';
 import { createInitializedClients, TestType, triggerWebhook } from '../testing';
 import { TriggerRegistry } from '../trigger';
 import { type FunctionManifest } from '../types';
@@ -29,6 +29,15 @@ describe('scheduler', () => {
     await testBuilder.destroy();
   });
 
+  const createScheduler = (callback: SchedulerOptions['callback']) => {
+    const scheduler = new Scheduler(new FunctionRegistry(client), new TriggerRegistry(client), { callback });
+    after(async () => {
+      await scheduler.stop();
+    });
+
+    return scheduler;
+  };
+
   test('timer', async () => {
     const manifest: FunctionManifest = {
       functions: [
@@ -41,6 +50,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'timer',
             cron: '0/1 * * * * *', // Every 1s.
@@ -75,6 +85,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'webhook',
             method: 'GET',
@@ -108,6 +119,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'websocket',
             // url: 'https://hub.dxos.network/api/mailbox/test',
@@ -154,6 +166,7 @@ describe('scheduler', () => {
       triggers: [
         {
           function: 'example.com/function/test',
+          enabled: true,
           spec: {
             type: 'subscription',
             filter: [{ type: TestType.typename }],
@@ -165,7 +178,7 @@ describe('scheduler', () => {
     let count = 0;
     const done = new Trigger();
     const scheduler = createScheduler(async () => {
-      if (++count === 2) {
+      if (++count === 1) {
         done.wake();
       }
     });
@@ -180,12 +193,4 @@ describe('scheduler', () => {
 
     await done.wait();
   });
-
-  const createScheduler = (callback: SchedulerOptions['callback']) => {
-    const scheduler = new Scheduler(new FunctionRegistry(client), new TriggerRegistry(client), { callback });
-    after(async () => {
-      await scheduler.stop();
-    });
-    return scheduler;
-  };
 });

package/src/runtime/scheduler.ts

@@ -4,12 +4,13 @@
 
 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';
 
@@ -26,13 +27,15 @@ export type SchedulerOptions = {
 export class Scheduler {
   private _ctx = createContext();
 
+  private readonly _functionUriToCallMutex = new Map<string, Mutex>();
+
   constructor(
     public readonly functions: FunctionRegistry,
     public readonly triggers: TriggerRegistry,
     private readonly _options: SchedulerOptions = {},
   ) {
-    this.functions.onFunctionsRegistered.on(async ({ space, newFunctions }) => {
-      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), newFunctions);
+    this.functions.registered.on(async ({ space, added }) => {
+      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
     });
     this.triggers.registered.on(async ({ space, triggers }) => {
       await this._safeActivateTriggers(space, triggers, this.functions.getFunctions(space));
@@ -52,8 +55,9 @@ 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);
+    await this.functions.register(space, manifest.functions);
     await this.triggers.register(space, manifest);
   }
 
@@ -68,24 +72,33 @@ export class Scheduler {
     await Promise.all(mountTasks).catch(log.catch);
   }
 
-  private async activate(space: Space, functions: FunctionDef[], fnTrigger: FunctionTrigger) {
-    const definition = functions.find((def) => def.uri === fnTrigger.function);
+  private async activate(space: Space, functions: FunctionDef[], trigger: FunctionTrigger) {
+    const definition = functions.find((def) => def.uri === trigger.function);
     if (!definition) {
-      log.info('function is not found for trigger', { fnTrigger });
+      log.info('function is not found for trigger', { trigger });
       return;
     }
 
-    await this.triggers.activate({ space }, fnTrigger, async (args) => {
-      return this._execFunction(definition, {
-        meta: fnTrigger.meta,
-        data: { ...args, spaceKey: space.key },
+    await this.triggers.activate(space, trigger, async (args) => {
+      const mutex = this._functionUriToCallMutex.get(definition.uri) ?? new Mutex();
+      this._functionUriToCallMutex.set(definition.uri, mutex);
+
+      log.info('function triggered, waiting for mutex', { uri: definition.uri });
+      return mutex.executeSynchronized(() => {
+        log.info('mutex acquired', { uri: definition.uri });
+        return this._execFunction(definition, trigger, {
+          meta: trigger.meta ?? {},
+          data: { ...args, spaceKey: space.key },
+        });
       });
     });
-    log('activated trigger', { space: space.key, trigger: fnTrigger });
+
+    log('activated trigger', { space: space.key, trigger });
   }
 
   private async _execFunction<TData, TMeta>(
     def: FunctionDef,
+    trigger: FunctionTrigger,
     { data, meta }: { data: TData; meta?: TMeta },
   ): Promise<number> {
     let status = 0;
@@ -97,7 +110,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 });
+        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

@@ -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 '../registry';
+import { FunctionRegistry } from '../function';
 import { DevServer, Scheduler } from '../runtime';
 import { createFunctionRuntime, createInitializedClients, TestType } from '../testing';
 import { TriggerRegistry } from '../trigger';
@@ -44,6 +44,7 @@ describe('functions e2e', () => {
     space.db.add(
       create(FunctionTrigger, {
         function: uri,
+        enabled: true,
         meta: triggerMeta,
         spec: {
           type: 'subscription',

package/src/testing/setup.ts

@@ -10,16 +10,16 @@ import { range } from '@dxos/util';
 import { TestType } from './types';
 import { FunctionDef, FunctionTrigger } from '../types';
 
-// TODO(burdon): Create TestBuilder.
+// TODO(burdon): Extend/wrap TestBuilder.
 
 export const createInitializedClients = async (testBuilder: TestBuilder, count: number = 1, config?: Config) => {
   const clients = range(count).map(() => new Client({ config, services: testBuilder.createLocalClientServices() }));
-  testBuilder.ctx.onDispose(() => Promise.all(clients.map((c) => c.destroy())));
+  testBuilder.ctx.onDispose(() => Promise.all(clients.map((client) => client.destroy())));
   return Promise.all(
     clients.map(async (client, index) => {
       await client.initialize();
       await client.halo.createIdentity({ displayName: `Peer ${index}` });
-      client.addSchema(TestType, FunctionDef, FunctionTrigger);
+      client.addSchema(FunctionDef, FunctionTrigger, TestType);
       return client;
     }),
   );
@@ -34,12 +34,10 @@ export const createFunctionRuntime = async (testBuilder: TestBuilder): Promise<C
     },
   });
 
-  const client = (await createInitializedClients(testBuilder, 1, config))[0];
-
-  // TODO(burdon): Better way to configure plugin? (Rationalize chess.test).
-  const functionsPlugin = new FunctionsPlugin();
-  await functionsPlugin.initialize({ client, clientServices: client.services });
-  await functionsPlugin.open();
-  testBuilder.ctx.onDispose(() => functionsPlugin.close());
+  const [client] = await createInitializedClients(testBuilder, 1, config);
+  const plugin = new FunctionsPlugin();
+  await plugin.initialize({ client, clientServices: client.services });
+  await plugin.open();
+  testBuilder.ctx.onDispose(() => plugin.close());
   return client;
 };

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

@@ -11,7 +11,7 @@ import { type Space } from '@dxos/client/echo';
 import { TestBuilder } from '@dxos/client/testing';
 import { Context } from '@dxos/context';
 import { Filter } from '@dxos/echo-db';
-import { create } from '@dxos/echo-schema';
+import { create, splitMeta } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
@@ -19,20 +19,42 @@ import { TriggerRegistry } from './trigger-registry';
 import { createInitializedClients, TestType, triggerWebhook } from '../testing';
 import { type FunctionManifest, FunctionTrigger } from '../types';
 
-const testManifest: FunctionManifest = {
+const manifest: FunctionManifest = {
   triggers: [
     {
+      '@meta': {
+        keys: [
+          {
+            source: 'example.com',
+            id: 'trigger-1',
+          },
+        ],
+      },
       function: 'example.com/function/webhook-test',
+      enabled: true,
       spec: {
         type: 'webhook',
         method: 'GET',
       },
     },
     {
+      '@meta': {
+        keys: [
+          {
+            source: 'example.com',
+            id: 'trigger-2',
+          },
+        ],
+      },
       function: 'example.com/function/subscription-test',
+      enabled: true,
       spec: {
         type: 'subscription',
-        filter: [{ type: TestType.typename }],
+        filter: [
+          {
+            type: TestType.typename,
+          },
+        ],
       },
     },
   ],
@@ -54,30 +76,44 @@ describe('trigger registry', () => {
 
   describe('register', () => {
     test('creates new triggers', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
       const space = await client.spaces.create();
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       const { objects } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      expect(objects.length).to.eq(testManifest.triggers?.length);
-      const expected = testManifest.triggers?.map((t) => t.function).sort();
-      expect(objects.map((o: FunctionTrigger) => o.function).sort()).to.deep.eq(expected);
+      expect(objects.length).to.eq(manifest.triggers?.length);
+
+      const expected = manifest.triggers?.map((trigger) => trigger.function).sort();
+      expect(objects.map((object: FunctionTrigger) => object.function).sort()).to.deep.eq(expected);
+    });
+
+    test('set meta', () => {
+      const trigger = create(FunctionTrigger, {
+        function: 'example.com/function/webhook-test',
+        spec: {
+          type: 'webhook',
+          method: 'GET',
+        },
+      });
+
+      (trigger.meta ??= {}).test = 100;
+      expect(trigger.meta.test).to.eq(100);
     });
   });
 
   describe('activate', () => {
     test('invokes the provided callback', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const callbackInvoked = new Trigger();
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const webhookTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'webhook')!;
-      await registry.activate({ space }, webhookTrigger, async () => {
+      const webhookTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'webhook')!;
+      await registry.activate(space, webhookTrigger, async () => {
         callbackInvoked.wake();
         return 200;
       });
@@ -87,34 +123,37 @@ describe('trigger registry', () => {
     });
 
     test('removes from inactive list', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const inactiveTrigger = registry.getInactiveTriggers(space)[0];
-      await registry.activate({ space }, inactiveTrigger, async () => 200);
+      await registry.activate(space, inactiveTrigger, async () => 200);
 
       const updatedInactiveList = registry.getInactiveTriggers(space);
-      expect(updatedInactiveList.find((t: FunctionTrigger) => t.function === inactiveTrigger.function)).to.be.undefined;
+      expect(updatedInactiveList.find((trigger: FunctionTrigger) => trigger.function === inactiveTrigger.function)).to
+        .be.undefined;
     });
+
+    // TODO(burdon): Test enable/disable trigger.
   });
 
   describe('deactivate', () => {
     test('trigger object deletion deactivates a trigger', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'subscription')!;
+      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
       let count = 0;
-      await registry.activate({ space }, echoTrigger, async () => {
+      await registry.activate(space, echoTrigger, async () => {
         count++;
         return 200;
       });
@@ -124,24 +163,23 @@ describe('trigger registry', () => {
       expect(count).to.eq(1);
 
       space.db.remove(echoTrigger);
-
       space.db.add(create(TestType, { title: '2' }));
       await sleep(20);
       expect(count).to.eq(1);
     });
 
     test('registry closing deactivates a trigger', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'subscription')!;
+      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
       let count = 0;
-      await registry.activate({ space }, echoTrigger, async () => {
+      await registry.activate(space, echoTrigger, async () => {
         count++;
         return 200;
       });
@@ -156,23 +194,24 @@ describe('trigger registry', () => {
 
   describe('trigger events', () => {
     test('event fired when all registered when opened', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
-      const triggers = createTriggersInSpace(client.spaces.default, 3);
+      const triggers = createTriggers(client.spaces.default, 3);
 
       const triggersRegistered = new Trigger<FunctionTrigger[]>();
       registry.registered.on((fn) => {
         expect(fn.space.key.toHex()).to.eq(client.spaces.default.key.toHex());
         triggersRegistered.wake(fn.triggers);
       });
+
       void registry.open(ctx);
       const functions = await triggersRegistered.wait();
-      const expected = triggers.map((obj) => obj.id).sort();
+      const expected = triggers.map((object) => object.id).sort();
       expect(functions.map((fn) => fn.id).sort()).to.deep.eq(expected);
     });
 
     test('event fired when a new trigger is added', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
       const space = await client.spaces.create();
 
@@ -182,16 +221,16 @@ describe('trigger registry', () => {
         triggerRegistered.wake(fn.triggers[0]);
       });
       await registry.open(ctx);
-      await registry.register(space, { triggers: testManifest?.triggers?.slice(0, 1) });
+      await registry.register(space, { triggers: manifest?.triggers?.slice(0, 1) });
       const registered = await triggerRegistered.wait();
-      expect(registered.function).to.eq(testManifest.triggers![0].function);
+      expect(registered.function).to.eq(manifest.triggers![0].function);
     });
 
     test('event fired when a new trigger is removed', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
+      const [client] = await createInitializedClients(testBuilder);
       const registry = createRegistry(client);
       const space = await client.spaces.create();
-      const triggers = createTriggersInSpace(space, 3);
+      const triggers = createTriggers(space, 3);
 
       const triggerLoaded = new Trigger();
       registry.registered.on((fn) => triggerLoaded.wake());
@@ -201,7 +240,7 @@ describe('trigger registry', () => {
         expect(fn.triggers.length).to.eq(1);
         triggerRemoved.wake(fn.triggers[0]);
       });
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
       await triggerLoaded.wait();
 
@@ -211,19 +250,23 @@ describe('trigger registry', () => {
     });
   });
 
-  const waitHasInactiveTriggers = async (registry: TriggerRegistry, space: Space) => {
-    await waitForCondition({ condition: () => registry.getInactiveTriggers(space).length > 0 });
-  };
-
   const createRegistry = (client: Client) => {
     const registry = new TriggerRegistry(client);
     ctx.onDispose(() => registry.close());
     return registry;
   };
 
-  const createTriggersInSpace = (space: Space, count: number) => {
-    const triggers = range(count, () => create(FunctionTrigger, { ...testManifest.triggers![0] }));
-    triggers.forEach((def) => space.db.add(def));
+  const createTriggers = (space: Space, count: number) => {
+    const triggers = range(count, () => {
+      const { meta, object } = splitMeta(manifest.triggers![0]);
+      return create(FunctionTrigger, object, meta);
+    });
+
+    triggers.forEach((trigger) => space.db.add(trigger));
     return triggers;
   };
+
+  const waitForInactiveTriggers = async (registry: TriggerRegistry, space: Space) => {
+    await waitForCondition({ condition: () => registry.getInactiveTriggers(space).length > 0 });
+  };
 });