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

package/dist/lib/browser/index.mjs

@@ -45,11 +45,12 @@ import { assertArgument, failedInvariant } from "@dxos/invariant";
 var Function_exports = {};
 __export(Function_exports, {
   Function: () => Function,
-  make: () => make2
+  make: () => make2,
+  setFrom: () => setFrom
 });
 import * as Schema2 from "effect/Schema";
-import { Obj as Obj2, Type as Type2 } from "@dxos/echo";
-import { JsonSchemaType, LabelAnnotation as LabelAnnotation2, Ref as Ref2 } from "@dxos/echo/internal";
+import { Annotation as Annotation2, JsonSchema, Obj as Obj2, Type as Type2 } from "@dxos/echo";
+import { SystemTypeAnnotation } from "@dxos/echo/internal";
 
 // src/types/Script.ts
 var Script_exports = {};
@@ -58,20 +59,20 @@ __export(Script_exports, {
   make: () => make
 });
 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";
 var Script = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
   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([
+}), Annotation.LabelAnnotation.set([
   "name"
 ]));
 var make = ({ source = "", ...props } = {}) => Obj.make(Script, {
@@ -91,7 +92,6 @@ var Function = Schema2.Struct({
   key: Schema2.optional(Schema2.String).annotations({
     description: "Unique registration key for the blueprint"
   }),
-  // TODO(burdon): Rename to id/uri?
   name: Schema2.NonEmptyString,
   version: Schema2.String,
   description: Schema2.optional(Schema2.String),
@@ -101,9 +101,9 @@ var Function = Schema2.Struct({
   updated: Schema2.optional(Schema2.String),
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema2.optional(Ref2(Script)),
-  inputSchema: Schema2.optional(JsonSchemaType),
-  outputSchema: Schema2.optional(JsonSchemaType),
+  source: Schema2.optional(Type2.Ref(Script)),
+  inputSchema: Schema2.optional(JsonSchema.JsonSchema),
+  outputSchema: Schema2.optional(JsonSchema.JsonSchema),
   /**
   * List of required services.
   * Match the Context.Tag keys of the FunctionServices variants.
@@ -114,10 +114,20 @@ var Function = Schema2.Struct({
 }).pipe(Type2.Obj({
   typename: "dxos.org/type/Function",
   version: "0.1.0"
-}), LabelAnnotation2.set([
+}), Annotation2.LabelAnnotation.set([
   "name"
-]));
+]), SystemTypeAnnotation.set(true));
 var make2 = (props) => Obj2.make(Function, props);
+var setFrom = (target, source) => {
+  target.key = source.key ?? target.key;
+  target.name = source.name ?? target.name;
+  target.version = source.version;
+  target.description = source.description;
+  target.updated = source.updated;
+  target.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : void 0;
+  target.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : void 0;
+  Obj2.getMeta(target).keys = JSON.parse(JSON.stringify(Obj2.getMeta(source).keys));
+};
 
 // src/types/Trigger.ts
 var Trigger_exports = {};
@@ -135,7 +145,7 @@ __export(Trigger_exports, {
 import * as Schema3 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 import { Obj as Obj3, QueryAST, Type as Type3 } from "@dxos/echo";
-import { Expando, OptionsAnnotationId, Ref as Ref3 } from "@dxos/echo/internal";
+import { OptionsAnnotationId, SystemTypeAnnotation as SystemTypeAnnotation2 } from "@dxos/echo/internal";
 import { DXN } from "@dxos/keys";
 var Kinds = [
   "email",
@@ -206,7 +216,7 @@ var Trigger_ = Schema3.Struct({
   * Function or workflow to invoke.
   */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Ref3(Expando).annotations({
+  function: Schema3.optional(Type3.Ref(Type3.Expando).annotations({
     title: "Function"
   })),
   /**
@@ -239,7 +249,7 @@ var Trigger_ = Schema3.Struct({
 }).pipe(Type3.Obj({
   typename: "dxos.org/type/Trigger",
   version: "0.1.0"
-}));
+}), SystemTypeAnnotation2.set(true));
 var Trigger = Trigger_;
 var make3 = (props) => Obj3.make(Trigger, props);
 
@@ -316,7 +326,7 @@ var setUserFunctionIdInMetadata = (meta, functionId) => {
 
 // src/sdk.ts
 var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
-var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler, services }) => {
+var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler, types, services }) => {
   if (!Schema5.isSchema(inputSchema)) {
     throw new Error("Input schema must be a valid schema");
   }
@@ -357,6 +367,7 @@ var defineFunction = ({ key, name, description, inputSchema, outputSchema = Sche
     inputSchema,
     outputSchema,
     handler: handlerWithSpan,
+    types: types ?? [],
     services: !services ? [] : getServiceKeys(services)
   };
 };
@@ -411,6 +422,7 @@ var deserializeFunction = (functionObj) => {
     handler: () => {
     },
     services: functionObj.services ?? [],
+    types: [],
     meta: {
       deployedFunctionId: getUserFunctionIdInMetadata(Obj5.getMeta(functionObj))
     }
@@ -790,11 +802,76 @@ import * as Layer5 from "effect/Layer";
 import * as Schema10 from "effect/Schema";
 import * as SchemaAST2 from "effect/SchemaAST";
 import { AiService } from "@dxos/ai";
+import { LifecycleState, Resource } from "@dxos/context";
 import { Type as Type7 } from "@dxos/echo";
 import { EchoClient } from "@dxos/echo-db";
-import { acquireReleaseResource } from "@dxos/effect";
-import { failedInvariant as failedInvariant2, invariant as invariant2 } from "@dxos/invariant";
+import { assertState, failedInvariant as failedInvariant2, invariant as invariant2 } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
+function _ts_add_disposable_resource(env, value2, async) {
+  if (value2 !== null && value2 !== void 0) {
+    if (typeof value2 !== "object" && typeof value2 !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value2[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value2[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value: value2,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value2;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    return next();
+  })(env);
+}
 var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
 var wrapFunctionHandler = (func) => {
   if (!FunctionDefinition.isFunction(func)) {
@@ -816,75 +893,101 @@ var wrapFunctionHandler = (func) => {
         });
       }
       try {
-        if (!SchemaAST2.isAnyKeyword(func.inputSchema.ast)) {
-          Schema10.validateSync(func.inputSchema)(data);
-        }
-        let result = await func.handler({
-          // TODO(dmaretskyi): Fix the types.
-          context,
-          data
-        });
-        if (Effect10.isEffect(result)) {
-          result = await Effect10.runPromise(result.pipe(Effect10.orDie, Effect10.provide(createServiceLayer(context))));
-        }
-        if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
-          Schema10.validateSync(func.outputSchema)(result);
-        }
-        return result;
-      } catch (error) {
-        if (FunctionError.is(error)) {
-          throw error;
-        } else {
-          throw new FunctionError({
-            cause: error,
-            context: {
-              func: func.key
+        const env = {
+          stack: [],
+          error: void 0,
+          hasError: false
+        };
+        try {
+          if (!SchemaAST2.isAnyKeyword(func.inputSchema.ast)) {
+            try {
+              Schema10.validateSync(func.inputSchema)(data);
+            } catch (error) {
+              throw new FunctionError({
+                message: "Invalid input schema",
+                cause: error
+              });
             }
+          }
+          const funcContext = _ts_add_disposable_resource(env, await new FunctionContext(context).open(), true);
+          if (func.types.length > 0) {
+            invariant2(funcContext.db, "Database is required for functions with types", {
+              F: __dxlog_file2,
+              L: 63,
+              S: void 0,
+              A: [
+                "funcContext.db",
+                "'Database is required for functions with types'"
+              ]
+            });
+            funcContext.db.graph.schemaRegistry.addSchema(func.types);
+          }
+          let result = await func.handler({
+            // TODO(dmaretskyi): Fix the types.
+            context,
+            data
           });
+          if (Effect10.isEffect(result)) {
+            result = await Effect10.runPromise(result.pipe(Effect10.orDie, Effect10.provide(funcContext.createLayer())));
+          }
+          if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
+            Schema10.validateSync(func.outputSchema)(result);
+          }
+          return result;
+        } catch (e) {
+          env.error = e;
+          env.hasError = true;
+        } finally {
+          const result = _ts_dispose_resources(env);
+          if (result) await result;
         }
+      } catch (error) {
+        throw error;
       }
     }
   };
 };
-var createServiceLayer = (context) => {
-  return Layer5.unwrapScoped(Effect10.gen(function* () {
-    let client;
+var FunctionContext = class extends Resource {
+  context;
+  client;
+  db;
+  queues;
+  constructor(context) {
+    super();
+    this.context = context;
     if (context.services.dataService && context.services.queryService) {
-      client = yield* acquireReleaseResource(() => {
-        invariant2(context.services.dataService && context.services.queryService, void 0, {
-          F: __dxlog_file2,
-          L: 99,
-          S: this,
-          A: [
-            "context.services.dataService && context.services.queryService",
-            ""
-          ]
-        });
-        return new EchoClient().connectToService({
-          dataService: context.services.dataService,
-          queryService: context.services.queryService,
-          queueService: context.services.queueService
-        });
+      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 ?? failedInvariant2(),
-      spaceKey: PublicKey.fromHex(context.spaceKey ?? failedInvariant2("spaceKey missing in context")),
+  }
+  async _open() {
+    await this.client?.open();
+    this.db = this.client && this.context.spaceId ? this.client.constructDatabase({
+      spaceId: this.context.spaceId ?? failedInvariant2(),
+      spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant2("spaceKey missing in context")),
       reactiveSchemaQuery: false
-    })) : void 0;
-    if (db) {
-      console.log("Setting space root", context.spaceRootUrl);
-      yield* Effect10.promise(() => db.setSpaceRoot(context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context")));
-    }
-    const queues = client && context.spaceId ? client.constructQueueFactory(context.spaceId) : void 0;
-    const dbLayer = db ? DatabaseService2.layer(db) : DatabaseService2.notAvailable;
-    const queuesLayer = queues ? QueueService.layer(queues) : QueueService.notAvailable;
+    }) : void 0;
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context"));
+    await this.db?.open();
+    this.queues = this.client && this.context.spaceId ? this.client.constructQueueFactory(this.context.spaceId) : void 0;
+  }
+  async _close() {
+    await this.db?.close();
+    await this.client?.close();
+  }
+  createLayer() {
+    assertState(this._lifecycleState === LifecycleState.OPEN, "FunctionContext is not open");
+    const dbLayer = this.db ? DatabaseService2.layer(this.db) : DatabaseService2.notAvailable;
+    const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
     const credentials = dbLayer ? CredentialsService.layerFromDatabase().pipe(Layer5.provide(dbLayer)) : CredentialsService.configuredLayer([]);
     const functionInvocationService = MockedFunctionInvocationService;
     const aiService = AiService.notAvailable;
     const tracing = TracingService.layerNoop;
     return Layer5.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
-  }));
+  }
 };
 var MockedFunctionInvocationService = Layer5.succeed(FunctionInvocationService, {
   invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet.")