@dxos/functions 0.8.2-main.fbd8ed0 → 0.8.2-staging.42af850

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.2-main.fbd8ed0",
+  "version": "0.8.2-staging.42af850",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -42,7 +42,7 @@
     "src"
   ],
   "dependencies": {
-    "@preact/signals-core": "^1.6.0",
+    "@preact/signals-core": "^1.9.0",
     "cron": "^3.1.6",
     "cron-schedule": "^5.0.4",
     "effect": "3.14.21",
@@ -51,28 +51,28 @@
     "get-port-please": "^3.1.1",
     "iso-did": "^1.6.0",
     "ws": "^8.14.2",
-    "@dxos/assistant": "0.8.2-main.fbd8ed0",
-    "@dxos/client": "0.8.2-main.fbd8ed0",
-    "@dxos/async": "0.8.2-main.fbd8ed0",
-    "@dxos/crypto": "0.8.2-main.fbd8ed0",
-    "@dxos/context": "0.8.2-main.fbd8ed0",
-    "@dxos/echo-db": "0.8.2-main.fbd8ed0",
-    "@dxos/echo-protocol": "0.8.2-main.fbd8ed0",
-    "@dxos/echo-schema": "0.8.2-main.fbd8ed0",
-    "@dxos/edge-client": "0.8.2-main.fbd8ed0",
-    "@dxos/invariant": "0.8.2-main.fbd8ed0",
-    "@dxos/keys": "0.8.2-main.fbd8ed0",
-    "@dxos/log": "0.8.2-main.fbd8ed0",
-    "@dxos/node-std": "0.8.2-main.fbd8ed0",
-    "@dxos/schema": "0.8.2-main.fbd8ed0",
-    "@dxos/util": "0.8.2-main.fbd8ed0",
-    "@dxos/live-object": "0.8.2-main.fbd8ed0",
-    "@dxos/protocols": "0.8.2-main.fbd8ed0"
+    "@dxos/ai": "0.8.2-staging.42af850",
+    "@dxos/async": "0.8.2-staging.42af850",
+    "@dxos/client": "0.8.2-staging.42af850",
+    "@dxos/context": "0.8.2-staging.42af850",
+    "@dxos/echo-db": "0.8.2-staging.42af850",
+    "@dxos/echo-protocol": "0.8.2-staging.42af850",
+    "@dxos/echo-schema": "0.8.2-staging.42af850",
+    "@dxos/crypto": "0.8.2-staging.42af850",
+    "@dxos/invariant": "0.8.2-staging.42af850",
+    "@dxos/log": "0.8.2-staging.42af850",
+    "@dxos/edge-client": "0.8.2-staging.42af850",
+    "@dxos/live-object": "0.8.2-staging.42af850",
+    "@dxos/keys": "0.8.2-staging.42af850",
+    "@dxos/node-std": "0.8.2-staging.42af850",
+    "@dxos/schema": "0.8.2-staging.42af850",
+    "@dxos/util": "0.8.2-staging.42af850",
+    "@dxos/protocols": "0.8.2-staging.42af850"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.2-main.fbd8ed0"
+    "@dxos/agent": "0.8.2-staging.42af850"
   },
   "publishConfig": {
     "access": "public"

package/src/bundler/bundler.ts

@@ -171,7 +171,13 @@ export class Bundler {
     });
   }
 
-  analyzeSourceFileImports(code: string) {
+  analyzeSourceFileImports(code: string): {
+    defaultImportName: string;
+    namedImports: string[];
+    wildcardImportName: string;
+    moduleIdentifier: string;
+    quotes: string;
+  }[] {
     // TODO(dmaretskyi): Support import aliases and wildcard imports.
     const parsedImports = allMatches(IMPORT_REGEX, code);
     return parsedImports.map((capture) => {

package/src/executor/executor.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import type { SpaceId } from '@dxos/client/echo';
+
+import type { FunctionContext, FunctionDefinition } from '../handler';
+import type { ServiceContainer } 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,
+    input: F extends FunctionDefinition<infer I, infer _O> ? I : never,
+  ): Promise<F extends FunctionDefinition<infer _I, infer O> ? O : never> {
+    // Assert input matches schema
+    const assertInput = fnDef.inputSchema.pipe(Schema.asserts);
+    (assertInput as any)(input);
+
+    const context: FunctionContext = {
+      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);
+
+    if (Effect.isEffect(result)) {
+      return Effect.runPromise(result as any);
+    }
+
+    return result as any;
+  }
+}

package/src/executor/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './executor';

package/src/handler.ts

@@ -2,10 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
-import { type Effect } from 'effect';
+import { Schema, type Context, type Effect } from 'effect';
 
-import { type AIServiceClient } from '@dxos/assistant';
+import { type AIServiceClient } from '@dxos/ai';
 // import { type Space } from '@dxos/client/echo';
 import type { CoreDatabase, EchoDatabase } from '@dxos/echo-db';
 import { type HasId } from '@dxos/echo-schema';
@@ -38,6 +37,12 @@ export type FunctionHandler<TData = {}, TOutput = any> = (params: {
  * Function context.
  */
 export interface FunctionContext {
+  /**
+   * Resolves a service available to the function.
+   * @throws if the service is not available.
+   */
+  getService: <T extends Context.Tag<any, any>>(tag: T) => Context.Tag.Service<T>;
+
   getSpace: (spaceId: SpaceId) => Promise<SpaceAPI>;
 
   /**

package/src/index.ts

@@ -7,3 +7,7 @@ export * from './schema';
 export * from './trace';
 export * from './types';
 export * from './url';
+export * from './services';
+export * from './executor';
+
+// Blow up cache

package/src/schema.ts

@@ -4,7 +4,7 @@
 
 import { Schema } from 'effect';
 
-import { EchoObject, JsonSchemaType, LabelAnnotationId, Ref, TypedObject } from '@dxos/echo-schema';
+import { EchoObject, JsonSchemaType, LabelAnnotation, Ref, TypedObject } from '@dxos/echo-schema';
 import { DataType } from '@dxos/schema';
 
 /**
@@ -17,14 +17,13 @@ export const ScriptType = Schema.Struct({
   // Whether source has changed since last deploy.
   changed: Schema.optional(Schema.Boolean),
   source: Ref(DataType.Text),
-})
-  .annotations({ [LabelAnnotationId]: 'name' })
-  .pipe(
-    EchoObject({
-      typename: 'dxos.org/type/Script',
-      version: '0.1.0',
-    }),
-  );
+}).pipe(
+  EchoObject({
+    typename: 'dxos.org/type/Script',
+    version: '0.1.0',
+  }),
+  LabelAnnotation.set(['name']),
+);
 
 export type ScriptType = Schema.Schema.Type<typeof ScriptType>;
 

package/src/services/ai.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+import type { AIServiceClient } from '@dxos/ai';
+
+// TODO(burdon): Move to @dxos/ai.
+export class AiService extends Context.Tag('AiService')<
+  AiService,
+  {
+    readonly client: AIServiceClient;
+  }
+>() {}

package/src/services/credentials.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+type CredentialQuery = {
+  service?: string;
+};
+
+// TODO(dmaretskyi): Unify with other apis.
+// packages/sdk/schema/src/common/access-token.ts
+type ServiceCredential = {
+  service: string;
+
+  // TODO(dmaretskyi): Build out.
+  apiKey?: string;
+};
+
+export class CredentialsService extends Context.Tag('CredentialsService')<
+  CredentialsService,
+  {
+    /**
+     * Query all.
+     */
+    queryCredentials: (query: CredentialQuery) => Promise<ServiceCredential[]>;
+
+    /**
+     * Get a single credential.
+     * @throws {Error} If no credential is found.
+     */
+    getCredential: (query: CredentialQuery) => Promise<ServiceCredential>;
+  }
+>() {}
+
+export class ConfiguredCredentialsService implements Context.Tag.Service<CredentialsService> {
+  constructor(private readonly credentials: ServiceCredential[] = []) {}
+
+  addCredentials(credentials: ServiceCredential[]): ConfiguredCredentialsService {
+    this.credentials.push(...credentials);
+    return this;
+  }
+
+  async queryCredentials(query: CredentialQuery): Promise<ServiceCredential[]> {
+    return this.credentials.filter((credential) => credential.service === query.service);
+  }
+
+  async getCredential(query: CredentialQuery): Promise<ServiceCredential> {
+    const credential = this.credentials.find((credential) => credential.service === query.service);
+    if (!credential) {
+      throw new Error(`Credential not found for service: ${query.service}`);
+    }
+    return credential;
+  }
+}

package/src/services/database.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+import type { EchoDatabase } from '@dxos/echo-db';
+
+export class DatabaseService extends Context.Tag('DatabaseService')<
+  DatabaseService,
+  {
+    readonly db: EchoDatabase;
+  }
+>() {}

package/src/services/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './ai';
+export * from './database';
+export * from './queues';
+export * from './service-container';
+export * from './credentials';
+export * from './tracing';

package/src/services/queues.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+import type { Queue, QueueFactory } from '@dxos/echo-db';
+
+export class QueuesService extends Context.Tag('QueuesService')<
+  QueuesService,
+  {
+    readonly contextQueue: Queue | undefined;
+
+    readonly queues: QueueFactory;
+  }
+>() {}

package/src/services/service-container.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Context } from 'effect';
+
+import { AiService } from './ai';
+import { CredentialsService } from './credentials';
+import { DatabaseService } from './database';
+import { QueuesService } from './queues';
+import { TracingService } from './tracing';
+
+export interface Services {
+  database: Context.Tag.Service<DatabaseService>;
+  ai: Context.Tag.Service<AiService>;
+  queues: Context.Tag.Service<QueuesService>;
+  credentials: Context.Tag.Service<CredentialsService>;
+  tracing: Context.Tag.Service<TracingService>;
+}
+
+const SERVICE_MAPPING: Record<string, keyof Services> = {
+  [DatabaseService.key]: 'database',
+  [AiService.key]: 'ai',
+  [QueuesService.key]: 'queues',
+  [CredentialsService.key]: 'credentials',
+  [TracingService.key]: 'tracing',
+};
+
+const DEFAULT_SERVICES: Partial<Services> = {
+  tracing: TracingService.noop,
+};
+
+export class ServiceContainer {
+  private _services: Partial<Services> = { ...DEFAULT_SERVICES };
+
+  /**
+   * Set services.
+   * @param services - Services to set.
+   * @returns The container instance.
+   */
+  setServices(services: Partial<Services>): this {
+    this._services = { ...this._services, ...services };
+    return this;
+  }
+
+  getService<T extends Context.Tag<any, any>>(tag: T): Context.Tag.Service<T> {
+    const serviceKey = SERVICE_MAPPING[tag.key];
+    const service = serviceKey != null ? this._services[serviceKey] : undefined;
+    if (!service) {
+      throw new Error(`Service not available: ${tag.key}`);
+    }
+    return service as Context.Tag.Service<T>;
+  }
+
+  clone(): ServiceContainer {
+    return new ServiceContainer().setServices({ ...this._services });
+  }
+}

package/src/services/tracing.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Context } from 'effect';
+
+import type { AnyEchoObject } from '@dxos/echo-schema';
+
+export class TracingService extends Context.Tag('TracingService')<
+  TracingService,
+  {
+    /**
+     * Write an event to the tracing queue.
+     * @param event - The event to write. Must be an a typed object.
+     */
+    write(event: AnyEchoObject): void;
+  }
+>() {
+  static noop: Context.Tag.Service<TracingService> = { write: () => {} };
+
+  static console: Context.Tag.Service<TracingService> = {
+    write: (event) => {
+      // eslint-disable-next-line no-console
+      console.log(event);
+    },
+  };
+}

package/src/trace.ts

@@ -4,6 +4,7 @@
 
 import { Schema } from 'effect';
 
+import { Queue } from '@dxos/echo-db';
 import { EchoObject, Expando, ObjectId, Ref } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
@@ -49,10 +50,9 @@ export const InvocationTraceStartEvent = Schema.Struct({
   // TODO(burdon): Input schema?
   input: Schema.Object,
   /**
-   * Queue DXN for function/workflow invocation events.
+   * Queue  for function/workflow invocation events.
    */
-  // TODO(burdon): Need reference type for queue. vs. string?
-  invocationTraceQueue: Ref(Expando),
+  invocationTraceQueue: Ref(Queue),
   /**
    * DXN of the invoked function/workflow.
    */
@@ -121,7 +121,7 @@ export type InvocationSpan = {
   outcome: InvocationOutcome;
   input: object;
   durationMs: number;
-  invocationTraceQueue: Ref<Expando>;
+  invocationTraceQueue: Ref<Queue>;
   invocationTarget: Ref<Expando>;
   trigger?: Ref<FunctionTriggerType>;
   exception?: TraceEventException;

package/src/types.ts

@@ -4,7 +4,8 @@
 
 import { Schema, SchemaAST } from 'effect';
 
-import { Expando, OptionsAnnotationId, TypedObject, DXN, Ref, RawObject } from '@dxos/echo-schema';
+import { Expando, OptionsAnnotationId, TypedObject, Ref, RawObject } from '@dxos/echo-schema';
+import { DXN } from '@dxos/keys';
 
 import { FunctionType } from './schema';
 
@@ -21,7 +22,7 @@ export enum TriggerKind {
   Queue = 'queue',
 }
 
-const kindLiteralAnnotations = { [SchemaAST.TitleAnnotationId]: 'Kind' };
+const kindLiteralAnnotations = { title: 'Kind' };
 
 /**
  * Cron timer.
@@ -29,7 +30,7 @@ const kindLiteralAnnotations = { [SchemaAST.TitleAnnotationId]: 'Kind' };
 const TimerTriggerSchema = Schema.Struct({
   kind: Schema.Literal(TriggerKind.Timer).annotations(kindLiteralAnnotations),
   cron: Schema.String.annotations({
-    [SchemaAST.TitleAnnotationId]: 'Cron',
+    title: 'Cron',
     [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
   }),
 }).pipe(Schema.mutable);
@@ -42,7 +43,7 @@ export type EmailTrigger = Schema.Schema.Type<typeof EmailTriggerSchema>;
 
 const QueueTriggerSchema = Schema.Struct({
   kind: Schema.Literal(TriggerKind.Queue).annotations(kindLiteralAnnotations),
-  queue: DXN,
+  queue: DXN.Schema,
 }).pipe(Schema.mutable);
 export type QueueTrigger = Schema.Schema.Type<typeof QueueTriggerSchema>;
 
@@ -53,13 +54,13 @@ const WebhookTriggerSchema = Schema.Struct({
   kind: Schema.Literal(TriggerKind.Webhook).annotations(kindLiteralAnnotations),
   method: Schema.optional(
     Schema.String.annotations({
-      [SchemaAST.TitleAnnotationId]: 'Method',
+      title: 'Method',
       [OptionsAnnotationId]: ['GET', 'POST'],
     }),
   ),
   port: Schema.optional(
     Schema.Number.annotations({
-      [SchemaAST.TitleAnnotationId]: 'Port',
+      title: 'Port',
     }),
   ),
 }).pipe(Schema.mutable);
@@ -67,9 +68,9 @@ export type WebhookTrigger = Schema.Schema.Type<typeof WebhookTriggerSchema>;
 
 // TODO(burdon): Use ECHO definition (from https://github.com/dxos/dxos/pull/8233).
 const QuerySchema = Schema.Struct({
-  type: Schema.optional(Schema.String.annotations({ [SchemaAST.TitleAnnotationId]: 'Type' })),
+  type: Schema.optional(Schema.String.annotations({ title: 'Type' })),
   props: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-}).annotations({ [SchemaAST.TitleAnnotationId]: 'Query' });
+}).annotations({ title: 'Query' });
 
 /**
  * Subscription.
@@ -81,10 +82,10 @@ const SubscriptionTriggerSchema = Schema.Struct({
   options: Schema.optional(
     Schema.Struct({
       // Watch changes to object (not just creation).
-      deep: Schema.optional(Schema.Boolean.annotations({ [SchemaAST.TitleAnnotationId]: 'Nested' })),
+      deep: Schema.optional(Schema.Boolean.annotations({ title: 'Nested' })),
       // Debounce changes (delay in ms).
-      delay: Schema.optional(Schema.Number.annotations({ [SchemaAST.TitleAnnotationId]: 'Delay' })),
-    }).annotations({ [SchemaAST.TitleAnnotationId]: 'Options' }),
+      delay: Schema.optional(Schema.Number.annotations({ title: 'Delay' })),
+    }).annotations({ title: 'Options' }),
   ),
 }).pipe(Schema.mutable);
 export type SubscriptionTrigger = Schema.Schema.Type<typeof SubscriptionTriggerSchema>;
@@ -99,7 +100,7 @@ export const TriggerSchema = Schema.Union(
   EmailTriggerSchema,
   QueueTriggerSchema,
 ).annotations({
-  [SchemaAST.TitleAnnotationId]: 'Trigger',
+  title: 'Trigger',
 });
 export type TriggerType = Schema.Schema.Type<typeof TriggerSchema>;
 
@@ -134,7 +135,7 @@ export type WebhookTriggerOutput = Schema.Schema.Type<typeof WebhookTriggerOutpu
 
 export const QueueTriggerOutput = Schema.mutable(
   Schema.Struct({
-    queue: DXN,
+    queue: DXN.Schema,
     item: Schema.Any,
     cursor: Schema.String,
   }),
@@ -159,16 +160,16 @@ export const FunctionTriggerSchema = Schema.Struct({
    * Function or workflow to invoke.
    */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema.optional(Ref(Expando).annotations({ [SchemaAST.TitleAnnotationId]: 'Function' })),
+  function: Schema.optional(Ref(Expando).annotations({ title: 'Function' })),
 
   /**
    * Only used for workflowSchema.
    * Specifies the input node in the circuit.
    * @deprecated Remove and enforce a single input node in all compute graphSchema.
    */
-  inputNodeId: Schema.optional(Schema.String.annotations({ [SchemaAST.TitleAnnotationId]: 'Input Node ID' })),
+  inputNodeId: Schema.optional(Schema.String.annotations({ title: 'Input Node ID' })),
 
-  enabled: Schema.optional(Schema.Boolean.annotations({ [SchemaAST.TitleAnnotationId]: 'Enabled' })),
+  enabled: Schema.optional(Schema.Boolean.annotations({ title: 'Enabled' })),
 
   spec: Schema.optional(TriggerSchema),