@dxos/functions 0.8.3 → 0.8.4-main.28f8d3d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.3",
+  "version": "0.8.4-main.28f8d3d",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -9,22 +9,26 @@
   "sideEffects": true,
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
-    },
     "./bundler": {
+      "source": "./src/bundler/index.ts",
       "types": "./dist/types/src/bundler/index.d.ts",
       "browser": "./dist/lib/browser/bundler/index.mjs",
       "node": "./dist/lib/node-esm/bundler/index.mjs"
     },
     "./edge": {
+      "source": "./src/edge/index.ts",
       "types": "./dist/types/src/edge/index.d.ts",
       "browser": "./dist/lib/browser/edge/index.mjs",
       "node": "./dist/lib/node-esm/edge/index.mjs"
     },
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/types/src/index.d.ts",
+      "browser": "./dist/lib/browser/index.mjs",
+      "node": "./dist/lib/node-esm/index.mjs"
+    },
     "./testing": {
+      "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
       "browser": "./dist/lib/browser/testing/index.mjs",
       "node": "./dist/lib/node-esm/testing/index.mjs"
@@ -47,38 +51,44 @@
     "src"
   ],
   "dependencies": {
+    "@effect/platform": "0.90.2",
     "@preact/signals-core": "^1.9.0",
     "cron": "^3.1.6",
     "cron-schedule": "^5.0.4",
-    "effect": "3.14.21",
+    "effect": "3.17.7",
     "esbuild-wasm": "^0.16.14",
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
+    "i18next": "^24.2.1",
     "iso-did": "^1.6.0",
     "ws": "^8.14.2",
-    "@dxos/ai": "0.8.3",
-    "@dxos/client": "0.8.3",
-    "@dxos/async": "0.8.3",
-    "@dxos/crypto": "0.8.3",
-    "@dxos/echo": "0.8.3",
-    "@dxos/context": "0.8.3",
-    "@dxos/echo-protocol": "0.8.3",
-    "@dxos/echo-db": "0.8.3",
-    "@dxos/echo-schema": "0.8.3",
-    "@dxos/edge-client": "0.8.3",
-    "@dxos/invariant": "0.8.3",
-    "@dxos/keys": "0.8.3",
-    "@dxos/live-object": "0.8.3",
-    "@dxos/log": "0.8.3",
-    "@dxos/node-std": "0.8.3",
-    "@dxos/protocols": "0.8.3",
-    "@dxos/schema": "0.8.3",
-    "@dxos/util": "0.8.3"
+    "@dxos/ai": "0.8.4-main.28f8d3d",
+    "@dxos/async": "0.8.4-main.28f8d3d",
+    "@dxos/client": "0.8.4-main.28f8d3d",
+    "@dxos/context": "0.8.4-main.28f8d3d",
+    "@dxos/crypto": "0.8.4-main.28f8d3d",
+    "@dxos/echo": "0.8.4-main.28f8d3d",
+    "@dxos/debug": "0.8.4-main.28f8d3d",
+    "@dxos/echo-db": "0.8.4-main.28f8d3d",
+    "@dxos/echo-pipeline": "0.8.4-main.28f8d3d",
+    "@dxos/echo-protocol": "0.8.4-main.28f8d3d",
+    "@dxos/echo-schema": "0.8.4-main.28f8d3d",
+    "@dxos/edge-client": "0.8.4-main.28f8d3d",
+    "@dxos/errors": "0.8.4-main.28f8d3d",
+    "@dxos/effect": "0.8.4-main.28f8d3d",
+    "@dxos/invariant": "0.8.4-main.28f8d3d",
+    "@dxos/keys": "0.8.4-main.28f8d3d",
+    "@dxos/live-object": "0.8.4-main.28f8d3d",
+    "@dxos/log": "0.8.4-main.28f8d3d",
+    "@dxos/node-std": "0.8.4-main.28f8d3d",
+    "@dxos/protocols": "0.8.4-main.28f8d3d",
+    "@dxos/schema": "0.8.4-main.28f8d3d",
+    "@dxos/util": "0.8.4-main.28f8d3d"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.3"
+    "@dxos/agent": "0.8.4-main.28f8d3d"
   },
   "publishConfig": {
     "access": "public"

package/src/bundler/bundler.test.ts

@@ -37,7 +37,7 @@ describe('Bundler', () => {
     expect(result.error).to.not.exist;
   });
 
-  // TODO(dmaretskyi): Flaky on CI: https://cloud.nx.app/runs/Hjcifa8Ccq/task/plugin-script%3Atest
+  // TODO(dmaretskyi): Flaky on CI.
   test.skip('HTTPS Import', async () => {
     const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
     const result = await bundler.bundle({

package/src/bundler/bundler.ts

@@ -2,10 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type BuildOptions } from 'esbuild';
-import { build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
+import { FetchHttpClient, HttpClient } from '@effect/platform';
+import { Duration, Effect, Schedule, pipe } from 'effect';
+import { type BuildOptions, type BuildResult, type Loader, type Plugin, build, initialize } from 'esbuild-wasm';
 
 import { subtleCrypto } from '@dxos/crypto';
+import { runAndForwardErrors } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
@@ -242,6 +244,9 @@ const analyzeSourceFileImports = (code: string): ParsedImport[] => {
   });
 };
 
+const MAX_RETRIES = 5;
+const INITIAL_DELAY = 1_000;
+
 const httpPlugin: Plugin = {
   name: 'http',
   setup: (build) => {
@@ -263,8 +268,25 @@ const httpPlugin: Plugin = {
     // When a URL is loaded, we want to actually download the content from the internet.
     // This has just enough logic to be able to handle the example import from unpkg.com but in reality this would probably need to be more complex.
     build.onLoad({ filter: /.*/, namespace: 'http-url' }, async (args) => {
-      const response = await fetch(args.path);
-      return { contents: await response.text(), loader: 'jsx' };
+      return Effect.gen(function* () {
+        const response = yield* HttpClient.get(args.path);
+        if (response.status !== 200) {
+          throw new Error(`failed to fetch: ${response.status}`);
+        }
+
+        const text = yield* response.text;
+        return { contents: text, loader: 'jsx' as Loader };
+      }).pipe(
+        Effect.retry(
+          pipe(
+            Schedule.exponential(Duration.millis(INITIAL_DELAY)),
+            Schedule.jittered,
+            Schedule.intersect(Schedule.recurs(MAX_RETRIES - 1)),
+          ),
+        ),
+        Effect.provide(FetchHttpClient.layer),
+        runAndForwardErrors,
+      );
     });
   },
 };

package/src/edge/functions.ts

@@ -8,7 +8,7 @@ import { type Client } from '@dxos/client';
 import { createEdgeIdentity } from '@dxos/client/edge';
 import { EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
-import type { PublicKey } from '@dxos/keys';
+import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type UploadFunctionResponseBody } from '@dxos/protocols';
 

package/src/errors.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+
+export class ServiceNotAvailableError extends BaseError.extend('SERVICE_NOT_AVAILABLE') {
+  constructor(serviceName: string) {
+    super(`Service not available: ${serviceName}`);
+  }
+}
+
+export class FunctionError extends BaseError.extend('FUNCTION_ERROR') {}

package/src/executor/executor.ts

@@ -4,14 +4,18 @@
 
 import { Effect, Schema } from 'effect';
 
-import type { SpaceId } from '@dxos/client/echo';
+import { type SpaceId } from '@dxos/client/echo';
+import { runAndForwardErrors } from '@dxos/effect';
 
 import type { FunctionContext, FunctionDefinition } from '../handler';
-import type { ServiceContainer } from '../services';
+import type { ServiceContainer, Services } from '../services';
 
 export class FunctionExecutor {
   constructor(private readonly _services: ServiceContainer) {}
 
+  /**
+   *
+   */
   // TODO(dmaretskyi): Invocation context: queue, space, etc...
   async invoke<F extends FunctionDefinition<any, any>>(
     fnDef: F,
@@ -22,26 +26,29 @@ export class FunctionExecutor {
     (assertInput as any)(input);
 
     const context: FunctionContext = {
+      space: undefined,
       getService: this._services.getService.bind(this._services),
       getSpace: async (_spaceId: SpaceId) => {
         throw new Error('Not available. Use the database service instead.');
       },
-      space: undefined,
-      get ai(): never {
-        throw new Error('Not available. Use the ai service instead.');
-      },
     };
 
-    const result = await fnDef.handler({ context, data: input });
-
-    // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(result);
+    const result = fnDef.handler({ context, data: input });
 
+    let data: unknown;
     if (Effect.isEffect(result)) {
-      return Effect.runPromise(result as any);
+      data = await (result as Effect.Effect<unknown, unknown, Services>).pipe(
+        Effect.provide(this._services.createLayer()),
+        runAndForwardErrors,
+      );
+    } else {
+      data = await result;
     }
 
-    return result as any;
+    // Assert output matches schema
+    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
+    (assertOutput as any)(data);
+
+    return data as any;
   }
 }

package/src/handler.ts

@@ -2,15 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema, type Context, type Effect } from 'effect';
+import { type Context, type Effect, Schema } from 'effect';
 
-import { type AiServiceClient } from '@dxos/ai';
-// import { type Space } from '@dxos/client/echo';
-import type { CoreDatabase, EchoDatabase } from '@dxos/echo-db';
+import { type EchoDatabase } from '@dxos/echo-db';
 import { type HasId } from '@dxos/echo-schema';
-import { type SpaceId, type DXN } from '@dxos/keys';
+import { type DXN, type SpaceId } from '@dxos/keys';
 import { type QueryResult } from '@dxos/protocols';
 
+import type { Services } from './services';
+
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
 // https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
@@ -31,12 +31,17 @@ export type FunctionHandler<TData = {}, TOutput = any> = (params: {
    * This will be the payload from the trigger or other data passed into the function in a workflow.
    */
   data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any>;
+}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, Services>;
 
 /**
  * Function context.
  */
 export interface FunctionContext {
+  /**
+   * Space from which the function was invoked.
+   */
+  space: SpaceAPI | undefined;
+
   /**
    * Resolves a service available to the function.
    * @throws if the service is not available.
@@ -44,13 +49,6 @@ export interface FunctionContext {
   getService: <T extends Context.Tag<any, any>>(tag: T) => Context.Tag.Service<T>;
 
   getSpace: (spaceId: SpaceId) => Promise<SpaceAPI>;
-
-  /**
-   * Space from which the function was invoked.
-   */
-  space: SpaceAPI | undefined;
-
-  ai: AiServiceClient;
 }
 
 export interface FunctionContextAi {
@@ -74,12 +72,9 @@ export interface QueuesAPI {
  */
 export interface SpaceAPI {
   get id(): SpaceId;
-  /**
-   * @deprecated
-   */
-  get crud(): CoreDatabase;
   get db(): EchoDatabase;
-  // TODO(dmaretskyi): Align with echo api --- queues.get(id).append(items);
+
+  // TODO(dmaretskyi): Align with echo api: queues.get(id).append(items);
   get queues(): QueuesAPI;
 }
 
@@ -89,6 +84,7 @@ const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
 };
 
 export type FunctionDefinition<T = {}, O = any> = {
+  name: string;
   description?: string;
   inputSchema: Schema.Schema<T, any>;
   outputSchema?: Schema.Schema<O, any>;
@@ -96,18 +92,31 @@ export type FunctionDefinition<T = {}, O = any> = {
 };
 
 // TODO(dmaretskyi): Bind input type to function handler.
-export const defineFunction = <T, O>(params: FunctionDefinition<T, O>): FunctionDefinition<T, O> => {
-  if (!Schema.isSchema(params.inputSchema)) {
+export const defineFunction = <T, O>({
+  name,
+  description,
+  inputSchema,
+  outputSchema = Schema.Any,
+  handler,
+}: FunctionDefinition<T, O>): FunctionDefinition<T, O> => {
+  if (!Schema.isSchema(inputSchema)) {
     throw new Error('Input schema must be a valid schema');
   }
-  if (typeof params.handler !== 'function') {
+  if (typeof handler !== 'function') {
     throw new Error('Handler must be a function');
   }
 
   return {
-    description: params.description,
-    inputSchema: params.inputSchema,
-    outputSchema: params.outputSchema ?? Schema.Any,
-    handler: params.handler,
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    handler,
   };
 };
+
+export namespace FunctionDefinition {
+  export type Any = FunctionDefinition<any, any>;
+  export type Input<T extends FunctionDefinition> = T extends FunctionDefinition<infer I, any> ? I : never;
+  export type Output<T extends FunctionDefinition> = T extends FunctionDefinition<any, infer O> ? O : never;
+}

package/src/index.ts

@@ -9,5 +9,6 @@ export * from './types';
 export * from './url';
 export * from './services';
 export * from './executor';
+export * from './errors';
 
 // Blow up cache

package/src/services/credentials.ts

@@ -2,7 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context } from 'effect';
+import { Context, Effect, Layer } from 'effect';
+
+import { Query } from '@dxos/echo';
+import { DataType } from '@dxos/schema';
+
+import { DatabaseService } from './database';
 
 type CredentialQuery = {
   service?: string;
@@ -10,14 +15,14 @@ type CredentialQuery = {
 
 // TODO(dmaretskyi): Unify with other apis.
 // packages/sdk/schema/src/common/access-token.ts
-type ServiceCredential = {
+export type ServiceCredential = {
   service: string;
 
   // TODO(dmaretskyi): Build out.
   apiKey?: string;
 };
 
-export class CredentialsService extends Context.Tag('CredentialsService')<
+export class CredentialsService extends Context.Tag('@dxos/functions/CredentialsService')<
   CredentialsService,
   {
     /**
@@ -31,7 +36,45 @@ export class CredentialsService extends Context.Tag('CredentialsService')<
      */
     getCredential: (query: CredentialQuery) => Promise<ServiceCredential>;
   }
->() {}
+>() {
+  static getCredential = (query: CredentialQuery): Effect.Effect<ServiceCredential, never, CredentialsService> =>
+    Effect.gen(function* () {
+      const credentials = yield* CredentialsService;
+      return yield* Effect.promise(() => credentials.getCredential(query));
+    });
+
+  static configuredLayer = (credentials: ServiceCredential[]) =>
+    Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
+
+  static layerFromDatabase = () =>
+    Layer.effect(
+      CredentialsService,
+      Effect.gen(function* () {
+        const dbService = yield* DatabaseService;
+        const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
+          const { objects: accessTokens } = await dbService.db.query(Query.type(DataType.AccessToken)).run();
+          return accessTokens
+            .filter((accessToken) => accessToken.source === query.service)
+            .map((accessToken) => ({
+              service: accessToken.source,
+              apiKey: accessToken.token,
+            }));
+        };
+        return {
+          getCredential: async (query) => {
+            const credentials = await queryCredentials(query);
+            if (credentials.length === 0) {
+              throw new Error(`Credential not found for service: ${query.service}`);
+            }
+            return credentials[0];
+          },
+          queryCredentials: async (query) => {
+            return queryCredentials(query);
+          },
+        };
+      }),
+    );
+}
 
 export class ConfiguredCredentialsService implements Context.Tag.Service<CredentialsService> {
   constructor(private readonly credentials: ServiceCredential[] = []) {}

package/src/services/database.ts

@@ -2,11 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Layer } from 'effect';
+import { Context, Effect, Layer, type Schema } from 'effect';
 
-import type { EchoDatabase } from '@dxos/echo-db';
+import { type Filter, type Live, Obj, type Query, type Ref, type Relation, type Type } from '@dxos/echo';
+import type { EchoDatabase, FlushOptions, OneShotQueryResult, QueryResult } from '@dxos/echo-db';
+import { BaseError } from '@dxos/errors';
+import { invariant } from '@dxos/invariant';
+import type { DXN } from '@dxos/keys';
 
-export class DatabaseService extends Context.Tag('DatabaseService')<
+export class DatabaseService extends Context.Tag('@dxos/functions/DatabaseService')<
   DatabaseService,
   {
     readonly db: EchoDatabase;
@@ -25,4 +29,88 @@ export class DatabaseService extends Context.Tag('DatabaseService')<
       },
     };
   };
+
+  static layer = (db: EchoDatabase): Layer.Layer<DatabaseService> => {
+    return Layer.succeed(DatabaseService, DatabaseService.make(db));
+  };
+
+  /**
+   * Resolves an object by its DXN.
+   */
+  static resolve: {
+    // No type check.
+    (dxn: DXN): Effect.Effect<Obj.Any | Relation.Any, never, DatabaseService>;
+    // Check matches schema.
+    <S extends Type.Obj.Any | Type.Relation.Any>(
+      dxn: DXN,
+      schema: S,
+    ): Effect.Effect<Schema.Schema.Type<S>, ObjectNotFoundError, DatabaseService>;
+  } = (<S extends Type.Obj.Any | Type.Relation.Any>(
+    dxn: DXN,
+    schema?: S,
+  ): Effect.Effect<Schema.Schema.Type<S>, ObjectNotFoundError, DatabaseService> =>
+    Effect.gen(function* () {
+      const { db } = yield* DatabaseService;
+      const object = yield* Effect.promise(() =>
+        db.graph
+          .createRefResolver({
+            context: {
+              space: db.spaceId,
+            },
+          })
+          .resolve(dxn),
+      );
+
+      if (!object) {
+        return yield* Effect.fail(new ObjectNotFoundError({ dxn }));
+      }
+      invariant(!schema || Obj.instanceOf(schema, object), 'Object type mismatch.');
+      return object as any;
+    })) as any;
+
+  /**
+   * Loads an object reference.
+   */
+  static load: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, never, never> = Effect.fn(function* (ref) {
+    return yield* Effect.promise(() => ref.load());
+  });
+
+  /**
+   * Creates a `QueryResult` object that can be subscribed to.
+   */
+  static query: {
+    <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult<Live<Query.Type<Q>>>, never, DatabaseService>;
+    <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult<Live<Filter.Type<F>>>, never, DatabaseService>;
+  } = (queryOrFilter: Query.Any | Filter.Any) =>
+    DatabaseService.pipe(
+      Effect.map(({ db }) => db.query(queryOrFilter as any)),
+      Effect.withSpan('DatabaseService.query'),
+    );
+
+  /**
+   * Executes the query once and returns the results.
+   */
+  static runQuery: {
+    <Q extends Query.Any>(query: Q): Effect.Effect<OneShotQueryResult<Live<Query.Type<Q>>>, never, DatabaseService>;
+    <F extends Filter.Any>(filter: F): Effect.Effect<OneShotQueryResult<Live<Filter.Type<F>>>, never, DatabaseService>;
+  } = (queryOrFilter: Query.Any | Filter.Any) =>
+    DatabaseService.query(queryOrFilter as any).pipe(
+      Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())),
+    );
+
+  /**
+   * Adds an object to the database.
+   */
+  static add = <T extends Obj.Any | Relation.Any>(obj: T): Effect.Effect<T, never, DatabaseService> =>
+    DatabaseService.pipe(Effect.map(({ db }) => db.add(obj)));
+
+  static flush = (opts?: FlushOptions) =>
+    DatabaseService.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.flush(opts))));
+}
+
+// TODO(burdon): Move to echo/errors.
+class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND') {
+  constructor(context?: Record<string, unknown>) {
+    super('Object not found', { context });
+  }
 }