@dxos/functions 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.72ec0f3",
+  "version": "0.8.4-main.7ace549",
   "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -25,18 +25,19 @@
   "dependencies": {
     "@effect/platform": "0.92.1",
     "effect": "3.18.3",
-    "@dxos/echo": "0.8.4-main.72ec0f3",
-    "@dxos/echo-db": "0.8.4-main.72ec0f3",
-    "@dxos/effect": "0.8.4-main.72ec0f3",
-    "@dxos/ai": "0.8.4-main.72ec0f3",
-    "@dxos/errors": "0.8.4-main.72ec0f3",
-    "@dxos/invariant": "0.8.4-main.72ec0f3",
-    "@dxos/keys": "0.8.4-main.72ec0f3",
-    "@dxos/node-std": "0.8.4-main.72ec0f3",
-    "@dxos/protocols": "0.8.4-main.72ec0f3",
-    "@dxos/schema": "0.8.4-main.72ec0f3",
-    "@dxos/types": "0.8.4-main.72ec0f3",
-    "@dxos/log": "0.8.4-main.72ec0f3"
+    "@dxos/ai": "0.8.4-main.7ace549",
+    "@dxos/context": "0.8.4-main.7ace549",
+    "@dxos/effect": "0.8.4-main.7ace549",
+    "@dxos/errors": "0.8.4-main.7ace549",
+    "@dxos/echo": "0.8.4-main.7ace549",
+    "@dxos/invariant": "0.8.4-main.7ace549",
+    "@dxos/echo-db": "0.8.4-main.7ace549",
+    "@dxos/log": "0.8.4-main.7ace549",
+    "@dxos/node-std": "0.8.4-main.7ace549",
+    "@dxos/protocols": "0.8.4-main.7ace549",
+    "@dxos/schema": "0.8.4-main.7ace549",
+    "@dxos/types": "0.8.4-main.7ace549",
+    "@dxos/keys": "0.8.4-main.7ace549"
   },
   "publishConfig": {
     "access": "public"

package/src/protocol/protocol.ts

@@ -8,10 +8,10 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
 import { AiService } from '@dxos/ai';
+import { LifecycleState, Resource } from '@dxos/context';
 import { Type } from '@dxos/echo';
-import { EchoClient } from '@dxos/echo-db';
-import { acquireReleaseResource } from '@dxos/effect';
-import { failedInvariant, invariant } from '@dxos/invariant';
+import { EchoClient, type EchoDatabaseImpl, type QueueFactory } from '@dxos/echo-db';
+import { assertState, failedInvariant, invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { type FunctionProtocol } from '@dxos/protocols';
 
@@ -47,9 +47,21 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
         });
       }
 
+      // eslint-disable-next-line no-useless-catch
       try {
         if (!SchemaAST.isAnyKeyword(func.inputSchema.ast)) {
-          Schema.validateSync(func.inputSchema)(data);
+          try {
+            Schema.validateSync(func.inputSchema)(data);
+          } catch (error) {
+            throw new FunctionError({ message: 'Invalid input schema', cause: error });
+          }
+        }
+
+        await using funcContext = await new FunctionContext(context).open();
+
+        if (func.types.length > 0) {
+          invariant(funcContext.db, 'Database is required for functions with types');
+          funcContext.db.graph.schemaRegistry.addSchema(func.types);
         }
 
         let result = await func.handler({
@@ -62,7 +74,7 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
           result = await Effect.runPromise(
             (result as Effect.Effect<unknown, unknown, FunctionServices>).pipe(
               Effect.orDie,
-              Effect.provide(createServiceLayer(context)),
+              Effect.provide(funcContext.createLayer()),
             ),
           );
         }
@@ -73,72 +85,71 @@ export const wrapFunctionHandler = (func: FunctionDefinition): FunctionProtocol.
 
         return result;
       } catch (error) {
-        if (FunctionError.is(error)) {
-          throw error;
-        } else {
-          throw new FunctionError({
-            cause: error,
-            context: { func: func.key },
-          });
-        }
+        // TODO(dmaretskyi): We might do error wrapping here and add extra context.
+        throw error;
       }
     },
   };
 };
 
 /**
- * Creates a layer of services for the function.
+ * Container for services and context for a function.
  */
-const createServiceLayer = (context: FunctionProtocol.Context): Layer.Layer<FunctionServices> => {
-  return Layer.unwrapScoped(
-    Effect.gen(function* () {
-      let client: EchoClient | undefined;
-
-      if (context.services.dataService && context.services.queryService) {
-        client = yield* acquireReleaseResource(() => {
-          invariant(context.services.dataService && context.services.queryService);
-          // TODO(dmaretskyi): Queues service.
-          return new EchoClient().connectToService({
-            dataService: context.services.dataService,
-            queryService: context.services.queryService,
-            queueService: context.services.queueService,
-          });
-        });
-      }
+class FunctionContext extends Resource {
+  readonly context: FunctionProtocol.Context;
+  readonly client: EchoClient | undefined;
+  db: EchoDatabaseImpl | undefined;
+  queues: QueueFactory | undefined;
+
+  constructor(context: FunctionProtocol.Context) {
+    super();
+    this.context = context;
+    if (context.services.dataService && context.services.queryService) {
+      this.client = new EchoClient().connectToService({
+        dataService: context.services.dataService,
+        queryService: context.services.queryService,
+        queueService: context.services.queueService,
+      });
+    }
+  }
 
-      const db =
-        client && context.spaceId
-          ? yield* acquireReleaseResource(() =>
-              client.constructDatabase({
-                spaceId: context.spaceId ?? failedInvariant(),
-                spaceKey: PublicKey.fromHex(context.spaceKey ?? failedInvariant('spaceKey missing in context')),
-                reactiveSchemaQuery: false,
-              }),
-            )
-          : undefined;
-
-      if (db) {
-        console.log('Setting space root', context.spaceRootUrl);
-        yield* Effect.promise(() =>
-          db!.setSpaceRoot(context.spaceRootUrl ?? failedInvariant('spaceRootUrl missing in context')),
-        );
-      }
+  override async _open() {
+    await this.client?.open();
+    this.db =
+      this.client && this.context.spaceId
+        ? this.client.constructDatabase({
+            spaceId: this.context.spaceId ?? failedInvariant(),
+            spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant('spaceKey missing in context')),
+            reactiveSchemaQuery: false,
+          })
+        : undefined;
+
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant('spaceRootUrl missing in context'));
+    await this.db?.open();
+    this.queues =
+      this.client && this.context.spaceId ? this.client.constructQueueFactory(this.context.spaceId) : undefined;
+  }
+
+  override async _close() {
+    await this.db?.close();
+    await this.client?.close();
+  }
 
-      const queues = client && context.spaceId ? client.constructQueueFactory(context.spaceId) : undefined;
+  createLayer(): Layer.Layer<FunctionServices> {
+    assertState(this._lifecycleState === LifecycleState.OPEN, 'FunctionContext is not open');
 
-      const dbLayer = db ? DatabaseService.layer(db) : DatabaseService.notAvailable;
-      const queuesLayer = queues ? QueueService.layer(queues) : QueueService.notAvailable;
-      const credentials = dbLayer
-        ? CredentialsService.layerFromDatabase().pipe(Layer.provide(dbLayer))
-        : CredentialsService.configuredLayer([]);
-      const functionInvocationService = MockedFunctionInvocationService;
-      const aiService = AiService.notAvailable;
-      const tracing = TracingService.layerNoop;
+    const dbLayer = this.db ? DatabaseService.layer(this.db) : DatabaseService.notAvailable;
+    const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
+    const credentials = dbLayer
+      ? CredentialsService.layerFromDatabase().pipe(Layer.provide(dbLayer))
+      : CredentialsService.configuredLayer([]);
+    const functionInvocationService = MockedFunctionInvocationService;
+    const aiService = AiService.notAvailable;
+    const tracing = TracingService.layerNoop;
 
-      return Layer.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
-    }),
-  );
-};
+    return Layer.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
+  }
+}
 
 const MockedFunctionInvocationService = Layer.succeed(FunctionInvocationService, {
   invokeFunction: () => Effect.die('Calling functions from functions is not implemented yet.'),

package/src/sdk.ts

@@ -75,6 +75,12 @@ export type FunctionDefinition<T = any, O = any, S extends FunctionServices = Fu
   inputSchema: Schema.Schema<T, any>;
   outputSchema?: Schema.Schema<O, any>;
 
+  /**
+   * List of types the function uses.
+   * This is used to ensure that the types are available when the function is executed.
+   */
+  types: readonly Type.Obj.Any[];
+
   /**
    * Keys of the required services.
    */
@@ -108,6 +114,12 @@ export type FunctionProps<T, O> = {
   description?: string;
   inputSchema: Schema.Schema<T, any>;
   outputSchema?: Schema.Schema<O, any>;
+
+  /**
+   * List of types the function uses.
+   * This is used to ensure that the types are available when the function is executed.
+   */
+  types?: readonly Type.Obj.Any[];
   // TODO(dmaretskyi): This currently doesn't cause a compile-time error if the handler requests a service that is not specified
   services?: readonly Context.Tag<any, any>[];
 
@@ -117,7 +129,7 @@ export type FunctionProps<T, O> = {
 // TODO(dmaretskyi): Output type doesn't get typechecked.
 export const defineFunction: {
   <I, O>(params: FunctionProps<I, O>): FunctionDefinition<I, O, FunctionServices>;
-} = ({ key, name, description, inputSchema, outputSchema = Schema.Any, handler, services }) => {
+} = ({ key, name, description, inputSchema, outputSchema = Schema.Any, handler, types, services }) => {
   if (!Schema.isSchema(inputSchema)) {
     throw new Error('Input schema must be a valid schema');
   }
@@ -162,6 +174,7 @@ export const defineFunction: {
     inputSchema,
     outputSchema,
     handler: handlerWithSpan,
+    types: types ?? [],
     services: !services ? [] : getServiceKeys(services),
   } satisfies FunctionDefinition.Any;
 };
@@ -219,6 +232,7 @@ export const deserializeFunction = (functionObj: Function.Function): FunctionDef
     // TODO(dmaretskyi): This should throw error.
     handler: () => {},
     services: functionObj.services ?? [],
+    types: [],
     meta: {
       deployedFunctionId: getUserFunctionIdInMetadata(Obj.getMeta(functionObj)),
     },

package/src/services/queues.ts

@@ -6,7 +6,7 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import type { Obj, Relation } from '@dxos/echo';
+import type { Entity } from '@dxos/echo';
 import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
 import type { DXN, QueueSubspaceTag } from '@dxos/keys';
 
@@ -53,22 +53,20 @@ export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
   /**
    * Gets a queue by its DXN.
    */
-  static getQueue = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
+  static getQueue = <T extends Entity.Unknown = Entity.Unknown>(
     dxn: DXN,
   ): Effect.Effect<Queue<T>, never, QueueService> => QueueService.pipe(Effect.map(({ queues }) => queues.get<T>(dxn)));
 
   /**
    * Creates a new queue.
    */
-  static createQueue = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(options?: {
+  static createQueue = <T extends Entity.Unknown = Entity.Unknown>(options?: {
     subspaceTag?: QueueSubspaceTag;
   }): Effect.Effect<Queue<T>, never, QueueService> =>
     QueueService.pipe(Effect.map(({ queues }) => queues.create<T>(options)));
 
-  static append = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
-    queue: Queue<T>,
-    objects: T[],
-  ): Effect.Effect<void> => Effect.promise(() => queue.append(objects));
+  static append = <T extends Entity.Unknown = Entity.Unknown>(queue: Queue<T>, objects: T[]): Effect.Effect<void> =>
+    Effect.promise(() => queue.append(objects));
 }
 
 /**

package/src/services/tracing.ts

@@ -8,7 +8,7 @@ import * as Layer from 'effect/Layer';
 
 import { AgentStatus } from '@dxos/ai';
 import { Obj } from '@dxos/echo';
-import type { ObjectId } from '@dxos/echo/internal';
+import { type ObjectId } from '@dxos/keys';
 import { Message } from '@dxos/types';
 
 /**

package/src/types/Function.ts

@@ -4,8 +4,8 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Obj, Type } from '@dxos/echo';
-import { JsonSchemaType, LabelAnnotation, Ref } from '@dxos/echo/internal';
+import { Annotation, JsonSchema, Obj, Type } from '@dxos/echo';
+import { SystemTypeAnnotation } from '@dxos/echo/internal';
 
 import { Script } from './Script';
 
@@ -24,7 +24,6 @@ export const Function = Schema.Struct({
     description: 'Unique registration key for the blueprint',
   }),
 
-  // TODO(burdon): Rename to id/uri?
   name: Schema.NonEmptyString,
   version: Schema.String,
 
@@ -37,10 +36,10 @@ export const Function = Schema.Struct({
 
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema.optional(Ref(Script)),
+  source: Schema.optional(Type.Ref(Script)),
 
-  inputSchema: Schema.optional(JsonSchemaType),
-  outputSchema: Schema.optional(JsonSchemaType),
+  inputSchema: Schema.optional(JsonSchema.JsonSchema),
+  outputSchema: Schema.optional(JsonSchema.JsonSchema),
 
   /**
    * List of required services.
@@ -55,8 +54,27 @@ export const Function = Schema.Struct({
     typename: 'dxos.org/type/Function',
     version: '0.1.0',
   }),
-  LabelAnnotation.set(['name']),
+  Annotation.LabelAnnotation.set(['name']),
+  SystemTypeAnnotation.set(true),
 );
+
 export interface Function extends Schema.Schema.Type<typeof Function> {}
 
 export const make = (props: Obj.MakeProps<typeof Function>) => Obj.make(Function, props);
+
+/**
+ * Copies properties from source to target.
+ * @param target - Target object to copy properties to.
+ * @param source - Source object to copy properties from.
+ */
+export const setFrom = (target: Function, source: Function) => {
+  target.key = source.key ?? target.key;
+  target.name = source.name ?? target.name;
+  target.version = source.version;
+  target.description = source.description;
+  target.updated = source.updated;
+  // TODO(dmaretskyi): A workaround for an ECHO bug.
+  target.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : undefined;
+  target.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : undefined;
+  Obj.getMeta(target).keys = JSON.parse(JSON.stringify(Obj.getMeta(source).keys));
+};

package/src/types/Script.ts

@@ -4,8 +4,8 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Obj, Ref, Type } from '@dxos/echo';
-import { FormAnnotation, LabelAnnotation } from '@dxos/echo/internal';
+import { Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation } from '@dxos/echo/internal';
 import { Text } from '@dxos/schema';
 
 /**
@@ -16,14 +16,14 @@ export const Script = Schema.Struct({
   description: Schema.String.pipe(Schema.optional),
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
-  changed: Schema.Boolean.pipe(FormAnnotation.set(false), Schema.optional),
-  source: Type.Ref(Text.Text).pipe(FormAnnotation.set(false)),
+  changed: Schema.Boolean.pipe(FormInputAnnotation.set(false), Schema.optional),
+  source: Type.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
 }).pipe(
   Type.Obj({
     typename: 'dxos.org/type/Script',
     version: '0.1.0',
   }),
-  LabelAnnotation.set(['name']),
+  Annotation.LabelAnnotation.set(['name']),
 );
 export interface Script extends Schema.Schema.Type<typeof Script> {}
 

package/src/types/Trigger.ts

@@ -6,7 +6,7 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
 import { Obj, QueryAST, Type } from '@dxos/echo';
-import { Expando, OptionsAnnotationId, Ref } from '@dxos/echo/internal';
+import { OptionsAnnotationId, SystemTypeAnnotation } from '@dxos/echo/internal';
 import { DXN } from '@dxos/keys';
 
 /**
@@ -101,7 +101,7 @@ const Trigger_ = Schema.Struct({
    * Function or workflow to invoke.
    */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema.optional(Ref(Expando).annotations({ title: 'Function' })),
+  function: Schema.optional(Type.Ref(Type.Expando).annotations({ title: 'Function' })),
 
   /**
    * Only used for workflowSchema.
@@ -131,6 +131,7 @@ const Trigger_ = Schema.Struct({
     typename: 'dxos.org/type/Trigger',
     version: '0.1.0',
   }),
+  SystemTypeAnnotation.set(true),
 );
 export interface Trigger extends Schema.Schema.Type<typeof Trigger_> {}
 export interface TriggerEncoded extends Schema.Schema.Encoded<typeof Trigger_> {}