@dxos/functions 0.3.9-main.ee9a520 → 0.3.9-main.ef334cd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.3.9-main.ee9a520",
+  "version": "0.3.9-main.ef334cd",
   "description": "Functions SDK and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -19,17 +19,19 @@
     "src"
   ],
   "dependencies": {
+    "@preact/signals-core": "^1.5.0",
     "cron": "^3.1.6",
+    "deepsignal": "1.4.0-shallow.0",
     "express": "^4.17.1",
     "get-port-please": "^3.1.1",
-    "@dxos/client": "0.3.9-main.ee9a520",
-    "@dxos/async": "0.3.9-main.ee9a520",
-    "@dxos/echo-schema": "0.3.9-main.ee9a520",
-    "@dxos/invariant": "0.3.9-main.ee9a520",
-    "@dxos/node-std": "0.3.9-main.ee9a520",
-    "@dxos/context": "0.3.9-main.ee9a520",
-    "@dxos/log": "0.3.9-main.ee9a520",
-    "@dxos/util": "0.3.9-main.ee9a520"
+    "@dxos/async": "0.3.9-main.ef334cd",
+    "@dxos/context": "0.3.9-main.ef334cd",
+    "@dxos/client": "0.3.9-main.ef334cd",
+    "@dxos/echo-schema": "0.3.9-main.ef334cd",
+    "@dxos/log": "0.3.9-main.ef334cd",
+    "@dxos/invariant": "0.3.9-main.ef334cd",
+    "@dxos/node-std": "0.3.9-main.ef334cd",
+    "@dxos/util": "0.3.9-main.ef334cd"
   },
   "devDependencies": {
     "@types/express": "^4.17.17"

package/src/handler.ts

@@ -2,7 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Client } from '@dxos/client';
+import { type Client, PublicKey } from '@dxos/client';
+import { type Space } from '@dxos/client/echo';
+import { isTypedObject, type TypedObject } from '@dxos/echo-schema';
+import { nonNullable } from '@dxos/util';
 
 // TODO(burdon): No response?
 export interface Response {
@@ -12,6 +15,7 @@ export interface Response {
 // TODO(burdon): Limit access to individual space?
 export interface FunctionContext {
   client: Client;
+  dataDir?: string;
 }
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
@@ -23,6 +27,28 @@ export type FunctionHandler<T extends {}> = (params: {
 }) => Promise<Response | void>;
 
 export type FunctionSubscriptionEvent = {
-  space: string; // TODO(burdon): Convert to PublicKey.
-  objects: string[];
+  space?: string; // TODO(burdon): Convert to PublicKey.
+  objects?: string[];
+};
+
+export type FunctionSubscriptionEvent2 = {
+  space?: Space;
+  objects?: TypedObject[];
+};
+
+export const subscriptionHandler = (
+  handler: FunctionHandler<FunctionSubscriptionEvent2>,
+): FunctionHandler<FunctionSubscriptionEvent> => {
+  return ({ event, context, ...rest }) => {
+    const { client } = context;
+    const space = event.space ? client.spaces.get(PublicKey.from(event.space)) : undefined;
+    const objects =
+      space &&
+      event.objects
+        ?.map<TypedObject | undefined>((id) => space!.db.getObjectById(id))
+        .filter(nonNullable)
+        .filter(isTypedObject);
+
+    return handler({ event: { space, objects }, context, ...rest });
+  };
 };

package/src/manifest.ts

@@ -15,11 +15,13 @@ export type FunctionDef = {
   description?: string;
 };
 
+// TODO(burdon): Query DSL.
 export type TriggerSubscription = {
   type: string;
   spaceKey: string;
   props?: Record<string, any>;
-  nested?: string[];
+  deep?: boolean; // Watch changes to object (not just creation).
+  delay?: number;
 };
 
 // TODO(burdon): Generalize binding.
@@ -28,7 +30,7 @@ export type TriggerSubscription = {
 export type FunctionTrigger = {
   function: string;
   schedule?: string;
-  subscription?: TriggerSubscription;
+  subscriptions?: TriggerSubscription[];
 };
 
 /**

package/src/runtime/dev-server.ts

@@ -20,6 +20,7 @@ export type DevServerOptions = {
   directory: string;
   manifest: FunctionManifest;
   reload?: boolean;
+  dataDir?: string;
 };
 
 /**
@@ -79,13 +80,13 @@ export class DevServer {
         res.statusCode = await this._invoke(name, req.body);
         res.end();
       } catch (err: any) {
-        log.error(err);
+        log.catch(err);
         res.statusCode = 500;
         res.end();
       }
     });
 
-    this._port = await getPort({ port: 7200, portRange: [7200, 7299] });
+    this._port = await getPort({ host: 'localhost', port: 7200, portRange: [7200, 7299] });
     this._server = app.listen(this._port);
 
     try {
@@ -161,6 +162,7 @@ export class DevServer {
 
     const context: FunctionContext = {
       client: this._client,
+      dataDir: this._options.dataDir,
     };
 
     let statusCode = 200;

package/src/runtime/scheduler.test.ts

@@ -0,0 +1,57 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { Trigger } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { TestBuilder } from '@dxos/client/testing';
+import { describe, test } from '@dxos/test';
+
+import { Scheduler } from './scheduler';
+import { type FunctionManifest } from '../manifest';
+
+describe('scheduler', () => {
+  test('basic', async () => {
+    const testBuilder = new TestBuilder();
+    const client = new Client({ services: testBuilder.createLocal() });
+    await client.initialize();
+    await client.halo.createIdentity();
+
+    const manifest: FunctionManifest = {
+      functions: [
+        {
+          id: 'example.com/function/test',
+          name: 'test',
+          handler: 'test',
+        },
+      ],
+      triggers: [
+        {
+          function: 'example.com/function/test',
+          schedule: '* * * * * *', // Every second.
+        },
+      ],
+    };
+
+    let count = 0;
+    const done = new Trigger();
+    const scheduler = new Scheduler(client, manifest, {
+      callback: async () => {
+        if (++count === 3) {
+          done.wake();
+        }
+
+        return 200;
+      },
+    });
+
+    await scheduler.start();
+    await done.wait();
+    expect(count).to.equal(3);
+
+    await scheduler.stop();
+    await client.destroy();
+  });
+});

package/src/runtime/scheduler.ts

@@ -4,19 +4,23 @@
 
 import { CronJob } from 'cron';
 
-import { DeferredTask } from '@dxos/async';
+import { debounce, DeferredTask } from '@dxos/async';
 import { type Client, type PublicKey } from '@dxos/client';
-import { type Space } from '@dxos/client/echo';
+import { type Space, TextObject } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
-import { Filter, createSubscription } from '@dxos/echo-schema';
+import { Filter, createSubscription, type Query, subscribe } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { ComplexMap } from '@dxos/util';
 
-import { type FunctionDef, type FunctionManifest, type FunctionTrigger } from '../manifest';
+import { type FunctionSubscriptionEvent } from '../handler';
+import { type FunctionDef, type FunctionManifest, type FunctionTrigger, type TriggerSubscription } from '../manifest';
+
+type Callback = (data: FunctionSubscriptionEvent) => Promise<number>;
 
 type SchedulerOptions = {
-  endpoint: string;
+  endpoint?: string;
+  callback?: Callback;
 };
 
 /**
@@ -33,7 +37,7 @@ export class Scheduler {
   constructor(
     private readonly _client: Client,
     private readonly _manifest: FunctionManifest,
-    private readonly _options: SchedulerOptions,
+    private readonly _options: SchedulerOptions = {},
   ) {}
 
   async start() {
@@ -58,6 +62,7 @@ export class Scheduler {
     const def = this._manifest.functions.find((config) => config.id === trigger.function);
     invariant(def, `Function not found: ${trigger.function}`);
 
+    // Currently supports only one trigger declaration per function.
     const exists = this._mounts.get(key);
     if (!exists) {
       this._mounts.set(key, { ctx, trigger });
@@ -66,52 +71,14 @@ export class Scheduler {
         return;
       }
 
-      // Cron schedule.
+      // Timer.
       if (trigger.schedule) {
-        const task = new DeferredTask(ctx, async () => {
-          await this.execFunction(def, {
-            space: space.key,
-          });
-        });
-
-        // TODO(burdon): Check greater than 30s min (use cron-parser).
-        const job = new CronJob(trigger.schedule, () => task.schedule());
-
-        job.start();
-        ctx.onDispose(() => job.stop());
+        this._createTimer(ctx, space, def, trigger);
       }
 
-      // ECHO subscription.
-      if (trigger.subscription) {
-        const objectIds = new Set<string>();
-        const task = new DeferredTask(ctx, async () => {
-          await this.execFunction(def, {
-            space: space.key,
-            objects: Array.from(objectIds),
-          });
-        });
-
-        const subscription = createSubscription(({ added, updated }) => {
-          for (const object of added) {
-            objectIds.add(object.id);
-          }
-          for (const object of updated) {
-            objectIds.add(object.id);
-          }
-
-          task.schedule();
-        });
-
-        const { type, props } = trigger.subscription;
-        const query = space.db.query(Filter.typename(type, props));
-        const unsubscribe = query.subscribe(({ objects }) => {
-          subscription.update(objects);
-        }, true);
-
-        ctx.onDispose(() => {
-          subscription.unsubscribe();
-          unsubscribe();
-        });
+      // Subscription.
+      for (const triggerSubscription of trigger.subscriptions ?? []) {
+        this._createSubscription(ctx, space, def, triggerSubscription);
       }
     }
   }
@@ -125,19 +92,92 @@ export class Scheduler {
     }
   }
 
-  private async execFunction(def: FunctionDef, data: any) {
+  private _createTimer(ctx: Context, space: Space, def: FunctionDef, trigger: FunctionTrigger) {
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, {
+        space: space.key,
+      });
+    });
+
+    // TODO(burdon): Check greater than 30s min (use cron-parser).
+    invariant(trigger.schedule);
+    const job = new CronJob(trigger.schedule, () => task.schedule());
+
+    job.start();
+    ctx.onDispose(() => job.stop());
+  }
+
+  private _createSubscription(ctx: Context, space: Space, def: FunctionDef, triggerSubscription: TriggerSubscription) {
+    const objectIds = new Set<string>();
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, {
+        space: space.key,
+        objects: Array.from(objectIds),
+      });
+    });
+
+    // TODO(burdon): Standardize subscription handles.
+    const subscriptions: (() => void)[] = [];
+    const subscription = createSubscription(({ added, updated }) => {
+      for (const object of added) {
+        objectIds.add(object.id);
+      }
+      for (const object of updated) {
+        objectIds.add(object.id);
+      }
+
+      task.schedule();
+    });
+    subscriptions.push(() => subscription.unsubscribe());
+
+    const { type, props, deep, delay } = triggerSubscription;
+    const update = ({ objects }: Query) => {
+      subscription.update(objects);
+
+      // TODO(burdon): Hack to monitor changes to Document's text object.
+      if (deep) {
+        log.info('update', { type, deep, objects: objects.length });
+        for (const object of objects) {
+          const content = object.content;
+          if (content instanceof TextObject) {
+            subscriptions.push(content[subscribe](debounce(() => subscription.update([object]), 1_000)));
+          }
+        }
+      }
+    };
+
+    // TODO(burdon): [Bug]: all callbacks are fired on the first mutation.
+    // TODO(burdon): [Bug]: not updated when document is deleted (either top or hierarchically).
+    const query = space.db.query(Filter.typename(type, props));
+    subscriptions.push(query.subscribe(delay ? debounce(update, delay * 1_000) : update));
+
+    ctx.onDispose(() => {
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+    });
+  }
+
+  private async _execFunction(def: FunctionDef, data: any) {
     try {
       log('request', { function: def.id });
-      const response = await fetch(`${this._options.endpoint}/${def.name}`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(data),
-      });
+      const { endpoint, callback } = this._options;
+      let status = 0;
+      if (endpoint) {
+        // TODO(burdon): Move out of scheduler (generalize as callback).
+        const response = await fetch(`${this._options.endpoint}/${def.name}`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(data),
+        });
+
+        status = response.status;
+      } else if (callback) {
+        status = await callback(data);
+      }
 
       // const result = await response.json();
-      log('result', { function: def.id, result: response.status });
+      log('result', { function: def.id, result: status });
     } catch (err: any) {
       log.error('error', { function: def.id, error: err.message });
     }

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=function.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"function.test.d.ts","sourceRoot":"","sources":["../../../src/function.test.ts"],"names":[],"mappings":""}

package/src/function.test.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { test } from '@dxos/test';
-
-test('works', () => {});