@dxos/functions 0.8.4-main.c85a9c8dae → 0.8.4-main.cb12b3f963

package/src/operation-compatibility.test.ts

@@ -1,185 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-import { describe, expect, test } from 'vitest';
-
-import { FunctionDefinition, defineFunction } from './sdk';
-
-describe('Function/Operation Compatibility', () => {
-  test('can convert FunctionDefinition to OperationDefinition', () => {
-    const func = defineFunction({
-      key: 'test.function',
-      name: 'Test Function',
-      description: 'A test function',
-      inputSchema: Schema.Struct({ value: Schema.Number }),
-      outputSchema: Schema.Struct({ result: Schema.String }),
-      handler: async ({ data }) => {
-        return { result: data.value.toString() };
-      },
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    expect(op.meta.key).toBe('test.function');
-    expect(op.meta.name).toBe('Test Function');
-    expect(op.meta.description).toBe('A test function');
-    expect(Schema.isSchema(op.schema.input)).toBe(true);
-    expect(Schema.isSchema(op.schema.output)).toBe(true);
-  });
-
-  test('converted operation has matching schemas', () => {
-    const inputSchema = Schema.Struct({
-      name: Schema.String,
-      age: Schema.Number,
-    });
-    const outputSchema = Schema.Struct({
-      greeting: Schema.String,
-    });
-
-    const func = defineFunction({
-      key: 'test.greet',
-      name: 'Greet',
-      inputSchema,
-      outputSchema,
-      handler: async ({ data }) => {
-        return { greeting: `Hello, ${data.name}!` };
-      },
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    // Verify schemas match
-    const testInput = { name: 'Alice', age: 30 };
-    const validatedInput = Schema.decodeSync(op.schema.input)(testInput);
-    expect(validatedInput).toEqual(testInput);
-
-    const testOutput = { greeting: 'Hello, Alice!' };
-    const validatedOutput = Schema.decodeSync(op.schema.output)(testOutput);
-    expect(validatedOutput).toEqual(testOutput);
-  });
-
-  test('converted operation preserves metadata', () => {
-    const func = defineFunction({
-      key: 'test.meta',
-      name: 'Meta Test',
-      description: 'Tests metadata preservation',
-      inputSchema: Schema.Void,
-      outputSchema: Schema.Void,
-      handler: async () => {},
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    expect(op.meta.key).toBe('test.meta');
-    expect(op.meta.name).toBe('Meta Test');
-    expect(op.meta.description).toBe('Tests metadata preservation');
-  });
-
-  test('converted operation is pipeable', () => {
-    const func = defineFunction({
-      key: 'test.pipe',
-      name: 'Pipe Test',
-      inputSchema: Schema.Void,
-      outputSchema: Schema.Void,
-      handler: async () => {},
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    expect(typeof op.pipe).toBe('function');
-  });
-
-  test('handles functions without output schema', () => {
-    const func = defineFunction({
-      key: 'test.no-output',
-      name: 'No Output',
-      inputSchema: Schema.Struct({ value: Schema.Number }),
-      handler: async ({ data }) => {
-        return data.value * 2;
-      },
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    expect(op.meta.key).toBe('test.no-output');
-    expect(Schema.isSchema(op.schema.output)).toBe(true);
-  });
-
-  test('converted operation includes handler', () => {
-    const func = defineFunction({
-      key: 'test.handler',
-      name: 'Handler Test',
-      inputSchema: Schema.Struct({ value: Schema.Number }),
-      outputSchema: Schema.Struct({ doubled: Schema.Number }),
-      handler: async ({ data }) => {
-        return { doubled: data.value * 2 };
-      },
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    expect(op.handler).toBeDefined();
-    expect(typeof op.handler).toBe('function');
-  });
-
-  test('converted operation has handler function', () => {
-    const func = defineFunction({
-      key: 'test.execute',
-      name: 'Execute Test',
-      inputSchema: Schema.Struct({ value: Schema.Number }),
-      outputSchema: Schema.Struct({ result: Schema.Number }),
-      handler: async ({ data }) => {
-        return { result: data.value * 3 };
-      },
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    // Handler is present and is a function that returns an Effect
-    expect(op.handler).toBeDefined();
-    const effect = op.handler({ value: 5 });
-    // Verify it returns an Effect-like object
-    expect(effect).toHaveProperty('pipe');
-  });
-
-  test('converted operation works with Effect-based handlers', () => {
-    const func = defineFunction({
-      key: 'test.effect',
-      name: 'Effect Test',
-      inputSchema: Schema.Struct({ value: Schema.Number }),
-      outputSchema: Schema.Struct({ result: Schema.Number }),
-      handler: Effect.fn(function* ({ data }) {
-        return { result: data.value * 4 };
-      }),
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    // Handler is present and produces an Effect
-    expect(op.handler).toBeDefined();
-    const effect = op.handler({ value: 3 });
-    expect(effect).toHaveProperty('pipe');
-  });
-
-  test('converted operation works with synchronous handlers', () => {
-    const func = defineFunction({
-      key: 'test.sync',
-      name: 'Sync Test',
-      inputSchema: Schema.Struct({ value: Schema.Number }),
-      outputSchema: Schema.Struct({ result: Schema.Number }),
-      handler: ({ data }) => {
-        return { result: data.value * 5 };
-      },
-    });
-
-    const op = FunctionDefinition.toOperation(func);
-
-    // Handler is present and produces an Effect
-    expect(op.handler).toBeDefined();
-    const effect = op.handler({ value: 2 });
-    expect(effect).toHaveProperty('pipe');
-  });
-});

package/src/services/event-logger.ts

@@ -1,127 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Schema from 'effect/Schema';
-
-import { Obj, Type } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { LogLevel, log } from '@dxos/log';
-
-import { TracingService } from './tracing';
-
-export const ComputeEventPayload = Schema.Union(
-  Schema.Struct({
-    type: Schema.Literal('begin-compute'),
-    nodeId: Schema.String,
-    /**
-     * Names of the inputs begin computed.
-     */
-    inputs: Schema.Array(Schema.String),
-  }),
-  Schema.Struct({
-    type: Schema.Literal('end-compute'),
-    nodeId: Schema.String,
-    /**
-     * Names of the outputs computed.
-     */
-    outputs: Schema.Array(Schema.String),
-  }),
-  Schema.Struct({
-    type: Schema.Literal('compute-input'),
-    nodeId: Schema.String,
-    property: Schema.String,
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('compute-output'),
-    nodeId: Schema.String,
-    property: Schema.String,
-    value: Schema.Any,
-  }),
-  Schema.Struct({
-    type: Schema.Literal('custom'),
-    nodeId: Schema.String,
-    event: Schema.Any,
-  }),
-);
-export type ComputeEventPayload = Schema.Schema.Type<typeof ComputeEventPayload>;
-
-export const ComputeEvent = Schema.Struct({
-  payload: ComputeEventPayload,
-}).pipe(Type.object({ typename: 'dxos.org/type/ComputeEvent', version: '0.1.0' }));
-
-/**
- * Logs event for the compute workflows.
- */
-export class ComputeEventLogger extends Context.Tag('@dxos/functions/ComputeEventLogger')<
-  ComputeEventLogger,
-  { readonly log: (event: ComputeEventPayload) => void; readonly nodeId: string | undefined }
->() {
-  static noop: Context.Tag.Service<ComputeEventLogger> = {
-    log: () => {},
-    nodeId: undefined,
-  };
-
-  /**
-   * Implements ComputeEventLogger using TracingService.
-   */
-  static layerFromTracing = Layer.effect(
-    ComputeEventLogger,
-    Effect.gen(function* () {
-      const tracing = yield* TracingService;
-      return {
-        log: (event: ComputeEventPayload) => {
-          tracing.write(Obj.make(ComputeEvent, { payload: event }), tracing.getTraceContext());
-        },
-        nodeId: undefined,
-      };
-    }),
-  );
-}
-
-export const logCustomEvent = (data: any) =>
-  Effect.gen(function* () {
-    const logger = yield* ComputeEventLogger;
-    if (!logger.nodeId) {
-      throw new Error('logCustomEvent must be called within a node compute function');
-    }
-    logger.log({
-      type: 'custom',
-      nodeId: logger.nodeId,
-      event: data,
-    });
-  });
-
-export const createDefectLogger = <A, E, R>(): ((self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>) =>
-  Effect.catchAll((error) =>
-    Effect.gen(function* () {
-      log.error('unhandled effect error', { error });
-      throw error;
-    }),
-  );
-
-export const createEventLogger = (
-  level: LogLevel,
-  message: string = 'event',
-): Context.Tag.Service<ComputeEventLogger> => {
-  const logFunction = (
-    {
-      [LogLevel.WARN]: log.warn,
-      [LogLevel.VERBOSE]: log.verbose,
-      [LogLevel.DEBUG]: log.debug,
-      [LogLevel.INFO]: log.info,
-      [LogLevel.ERROR]: log.error,
-    } as any
-  )[level];
-  invariant(logFunction);
-  return {
-    log: (event: ComputeEventPayload) => {
-      logFunction(message, event);
-    },
-    nodeId: undefined,
-  };
-};

package/src/types/Function.ts

@@ -1,83 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { Annotation, JsonSchema, Obj, Ref, Type } from '@dxos/echo';
-import { SystemTypeAnnotation } from '@dxos/echo/internal';
-
-import { Script } from './Script';
-
-/**
- * Function deployment.
- */
-export const Function = Schema.Struct({
-  /**
-   * Global registry ID.
-   * NOTE: The `key` property refers to the original registry entry.
-   */
-  // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.
-  // TODO(dmaretskyi): Consider making it part of ECHO meta.
-  // TODO(dmaretskyi): Make required.
-  key: Schema.optional(Schema.String).annotations({
-    description: 'Unique registration key for the blueprint',
-  }),
-
-  name: Schema.NonEmptyString,
-  version: Schema.String,
-
-  description: Schema.optional(Schema.String),
-
-  /**
-   * ISO date string of the last deployment.
-   */
-  updated: Schema.optional(Schema.String),
-
-  // Reference to a source script if it exists within ECHO.
-  // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema.optional(Ref.Ref(Script)),
-
-  inputSchema: Schema.optional(JsonSchema.JsonSchema),
-  outputSchema: Schema.optional(JsonSchema.JsonSchema),
-
-  /**
-   * List of required services.
-   * Match the Context.Tag keys of the FunctionServices variants.
-   */
-  services: Schema.optional(Schema.Array(Schema.String)),
-
-  // Local binding to a function name.
-  binding: Schema.optional(Schema.String),
-}).pipe(
-  Type.object({
-    typename: 'dxos.org/type/Function',
-    version: '0.1.0',
-  }),
-  Annotation.LabelAnnotation.set(['name']),
-  Annotation.IconAnnotation.set({ icon: 'ph--function--regular', hue: 'blue' }),
-  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) => {
-  Obj.change(target, (t) => {
-    t.key = source.key ?? target.key;
-    t.name = source.name ?? target.name;
-    t.version = source.version;
-    t.description = source.description;
-    t.updated = source.updated;
-    // TODO(dmaretskyi): A workaround for an ECHO bug.
-    t.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : undefined;
-    t.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : undefined;
-    Obj.getMeta(t).keys = JSON.parse(JSON.stringify(Obj.getMeta(source).keys));
-  });
-};

package/src/types/Script.ts

@@ -1,34 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { Annotation, Obj, Ref, Type } from '@dxos/echo';
-import { FormInputAnnotation } from '@dxos/echo/internal';
-import { Text } from '@dxos/schema';
-
-/**
- * Source script.
- */
-export const 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(FormInputAnnotation.set(false), Schema.optional),
-  source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
-}).pipe(
-  Type.object({
-    typename: 'dxos.org/type/Script',
-    version: '0.1.0',
-  }),
-  Annotation.LabelAnnotation.set(['name']),
-);
-
-export interface Script extends Schema.Schema.Type<typeof Script> {}
-
-type Props = Omit<Obj.MakeProps<typeof Script>, 'source'> & { source?: string };
-
-export const make = ({ source = '', ...props }: Props = {}): Script =>
-  Obj.make(Script, { ...props, source: Ref.make(Text.make(source)) });

package/src/types/Trigger.ts

@@ -1,153 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-import { Annotation, Obj, QueryAST, Ref, Type } from '@dxos/echo';
-import { OptionsAnnotationId, SystemTypeAnnotation } from '@dxos/echo/internal';
-import { DXN } from '@dxos/keys';
-import { Expando } from '@dxos/schema';
-
-/**
- * Type discriminator for TriggerType.
- * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
- * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
- */
-export const Kinds = ['email', 'queue', 'subscription', 'timer', 'webhook'] as const;
-export type Kind = (typeof Kinds)[number];
-
-const kindLiteralAnnotations = { title: 'Kind' };
-
-export const EmailSpec = Schema.Struct({
-  kind: Schema.Literal('email').annotations(kindLiteralAnnotations),
-});
-export type EmailSpec = Schema.Schema.Type<typeof EmailSpec>;
-
-export const QueueSpec = Schema.Struct({
-  kind: Schema.Literal('queue').annotations(kindLiteralAnnotations),
-
-  // TODO(dmaretskyi): Change to a reference.
-  queue: DXN.Schema,
-});
-export type QueueSpec = Schema.Schema.Type<typeof QueueSpec>;
-
-/**
- * Subscription.
- */
-export const SubscriptionSpec = Schema.Struct({
-  kind: Schema.Literal('subscription').annotations(kindLiteralAnnotations),
-  query: Schema.Struct({
-    raw: Schema.optional(Schema.String.annotations({ title: 'Query' })),
-    ast: QueryAST.Query,
-  }),
-  options: Schema.optional(
-    Schema.Struct({
-      // Watch changes to object (not just creation).
-      deep: Schema.optional(Schema.Boolean.annotations({ title: 'Nested' })),
-      // Debounce changes (delay in ms).
-      delay: Schema.optional(Schema.Number.annotations({ title: 'Delay' })),
-    }).annotations({ title: 'Options' }),
-  ),
-});
-export type SubscriptionSpec = Schema.Schema.Type<typeof SubscriptionSpec>;
-
-/**
- * Cron timer.
- */
-export const TimerSpec = Schema.Struct({
-  kind: Schema.Literal('timer').annotations(kindLiteralAnnotations),
-  cron: Schema.String.annotations({
-    title: 'Cron',
-    [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
-  }),
-});
-export type TimerSpec = Schema.Schema.Type<typeof TimerSpec>;
-
-/**
- * Webhook.
- */
-export const WebhookSpec = Schema.Struct({
-  kind: Schema.Literal('webhook').annotations(kindLiteralAnnotations),
-  method: Schema.optional(
-    Schema.String.annotations({
-      title: 'Method',
-      [OptionsAnnotationId]: ['GET', 'POST'],
-    }),
-  ),
-  port: Schema.optional(
-    Schema.Number.annotations({
-      title: 'Port',
-    }),
-  ),
-});
-export type WebhookSpec = Schema.Schema.Type<typeof WebhookSpec>;
-
-/**
- * Trigger schema.
- */
-export const Spec = Schema.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: 'Trigger',
-});
-export type Spec = Schema.Schema.Type<typeof Spec>;
-
-/**
- * Function trigger.
- * Function is invoked with the `payload` passed as input data.
- * The event that triggers the function is available in the function context.
- */
-const TriggerSchema = Schema.Struct({
-  /**
-   * Function or workflow to invoke.
-   */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema.optional(Ref.Ref(Expando.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({ title: 'Input Node ID' })),
-
-  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
-  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
-  enabled: Schema.optional(Schema.Boolean.annotations({ title: 'Enabled' })),
-
-  spec: Schema.optional(Spec),
-
-  concurrency: Schema.optional(
-    Schema.Number.annotations({
-      title: 'Concurrency',
-      default: 1,
-      description:
-        'Maximum number of concurrent invocations of the trigger. For queue triggers, this will process queue items in parallel.',
-    }),
-  ),
-
-  /**
-   * Passed as the input data to the function.
-   * Must match the function's input schema.
-   *
-   * @example
-   * {
-   *   item: '{{$.trigger.event}}',
-   *   instructions: 'Summarize and perform entity-extraction'
-   *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
-   * }
-   */
-  input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-}).pipe(
-  Type.object({
-    typename: 'dxos.org/type/Trigger',
-    version: '0.1.0',
-  }),
-  Annotation.IconAnnotation.set({ icon: 'ph--lightning--regular', hue: 'yellow' }),
-  SystemTypeAnnotation.set(true),
-);
-
-export interface Trigger extends Schema.Schema.Type<typeof TriggerSchema> {}
-export const Trigger: Type.Obj<Trigger> = TriggerSchema as any;
-
-export const make = (props: Obj.MakeProps<typeof Trigger>) => Obj.make(Trigger, props);

package/src/types/TriggerEvent.ts

@@ -1,62 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Schema from 'effect/Schema';
-
-import { DXN, Obj, Ref } from '@dxos/echo';
-
-// TODO(wittjosiah): Review this type.
-//   - Should be discriminated union.
-//   - Should be more consistent (e.g. subject vs item).
-//   - Should re-use schemas if possible.
-
-// TODO(burdon): Reuse trigger schema from @dxos/functions (TriggerType).
-export const EmailEvent = Schema.Struct({
-  from: Schema.String,
-  to: Schema.String,
-  subject: Schema.String,
-  created: Schema.String,
-  body: Schema.String,
-});
-export type EmailEvent = Schema.Schema.Type<typeof EmailEvent>;
-
-export const QueueEvent = Schema.Struct({
-  queue: DXN.Schema,
-  item: Schema.Any,
-  cursor: Schema.String,
-});
-export type QueueEvent = Schema.Schema.Type<typeof QueueEvent>;
-
-export const SubscriptionEvent = Schema.Struct({
-  /**
-   * Type of the mutation.
-   */
-  // TODO(dmaretskyi): Specify enum.
-  type: Schema.String,
-
-  /**
-   * Reference to the object that was changed or created.
-   */
-  subject: Ref.Ref(Obj.Unknown),
-
-  /**
-   * @deprecated
-   */
-  changedObjectId: Schema.optional(Schema.String),
-});
-export type SubscriptionEvent = Schema.Schema.Type<typeof SubscriptionEvent>;
-
-export const TimerEvent = Schema.Struct({ tick: Schema.Number });
-export type TimerEvent = Schema.Schema.Type<typeof TimerEvent>;
-
-export const WebhookEvent = Schema.Struct({
-  url: Schema.String,
-  method: Schema.Literal('GET', 'POST'),
-  headers: Schema.Record({ key: Schema.String, value: Schema.String }),
-  bodyText: Schema.String,
-});
-export type WebhookEvent = Schema.Schema.Type<typeof WebhookEvent>;
-
-export const TriggerEvent = Schema.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
-export type TriggerEvent = Schema.Schema.Type<typeof TriggerEvent>;