@dxos/functions 0.8.4-main.ef1bc66f44 → 0.8.4-main.f466a3d56e

package/dist/types/src/types/Trigger.d.ts

@@ -1,121 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Obj, QueryAST, Type } from '@dxos/echo';
-/**
- * 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 declare const Kinds: readonly ["email", "queue", "subscription", "timer", "webhook"];
-export type Kind = (typeof Kinds)[number];
-export declare const EmailSpec: Schema.Struct<{
-    kind: Schema.Literal<["email"]>;
-}>;
-export type EmailSpec = Schema.Schema.Type<typeof EmailSpec>;
-export declare const QueueSpec: Schema.Struct<{
-    kind: Schema.Literal<["queue"]>;
-    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
-}>;
-export type QueueSpec = Schema.Schema.Type<typeof QueueSpec>;
-/**
- * Subscription.
- */
-export declare const SubscriptionSpec: Schema.Struct<{
-    kind: Schema.Literal<["subscription"]>;
-    query: Schema.Struct<{
-        raw: Schema.optional<Schema.SchemaClass<string, string, never>>;
-        ast: Schema.Schema<QueryAST.QuerySelectClause | QueryAST.QueryFilterClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryUnionClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryOrderClause | QueryAST.QueryOptionsClause | QueryAST.QueryLimitClause, QueryAST.QuerySelectClause | QueryAST.QueryFilterClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryUnionClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryOrderClause | QueryAST.QueryOptionsClause | QueryAST.QueryLimitClause, never>;
-    }>;
-    options: Schema.optional<Schema.Struct<{
-        deep: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-        delay: Schema.optional<Schema.SchemaClass<number, number, never>>;
-    }>>;
-}>;
-export type SubscriptionSpec = Schema.Schema.Type<typeof SubscriptionSpec>;
-/**
- * Cron timer.
- */
-export declare const TimerSpec: Schema.Struct<{
-    kind: Schema.Literal<["timer"]>;
-    cron: Schema.SchemaClass<string, string, never>;
-}>;
-export type TimerSpec = Schema.Schema.Type<typeof TimerSpec>;
-/**
- * Webhook.
- */
-export declare const WebhookSpec: Schema.Struct<{
-    kind: Schema.Literal<["webhook"]>;
-    method: Schema.optional<Schema.SchemaClass<string, string, never>>;
-    port: Schema.optional<Schema.SchemaClass<number, number, never>>;
-}>;
-export type WebhookSpec = Schema.Schema.Type<typeof WebhookSpec>;
-/**
- * Trigger schema.
- */
-export declare const Spec: Schema.Union<[Schema.Struct<{
-    kind: Schema.Literal<["email"]>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["queue"]>;
-    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["subscription"]>;
-    query: Schema.Struct<{
-        raw: Schema.optional<Schema.SchemaClass<string, string, never>>;
-        ast: Schema.Schema<QueryAST.QuerySelectClause | QueryAST.QueryFilterClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryUnionClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryOrderClause | QueryAST.QueryOptionsClause | QueryAST.QueryLimitClause, QueryAST.QuerySelectClause | QueryAST.QueryFilterClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryUnionClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryOrderClause | QueryAST.QueryOptionsClause | QueryAST.QueryLimitClause, never>;
-    }>;
-    options: Schema.optional<Schema.Struct<{
-        deep: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-        delay: Schema.optional<Schema.SchemaClass<number, number, never>>;
-    }>>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["timer"]>;
-    cron: Schema.SchemaClass<string, string, never>;
-}>, Schema.Struct<{
-    kind: Schema.Literal<["webhook"]>;
-    method: Schema.optional<Schema.SchemaClass<string, string, never>>;
-    port: Schema.optional<Schema.SchemaClass<number, number, never>>;
-}>]>;
-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.
- */
-declare const TriggerSchema: Type.Obj<{
-    readonly function?: import("@dxos/echo/internal").Ref<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & {
-        readonly [x: string]: any;
-    }> | undefined;
-    readonly inputNodeId?: string | undefined;
-    readonly enabled?: boolean | undefined;
-    readonly spec?: {
-        readonly kind: "email";
-    } | {
-        readonly queue: string;
-        readonly kind: "queue";
-    } | {
-        readonly kind: "subscription";
-        readonly query: {
-            readonly raw?: string | undefined;
-            readonly ast: QueryAST.QuerySelectClause | QueryAST.QueryFilterClause | QueryAST.QueryReferenceTraversalClause | QueryAST.QueryIncomingReferencesClause | QueryAST.QueryRelationClause | QueryAST.QueryRelationTraversalClause | QueryAST.QueryHierarchyTraversalClause | QueryAST.QueryUnionClause | QueryAST.QuerySetDifferenceClause | QueryAST.QueryOrderClause | QueryAST.QueryOptionsClause | QueryAST.QueryLimitClause;
-        };
-        readonly options?: {
-            readonly deep?: boolean | undefined;
-            readonly delay?: number | undefined;
-        } | undefined;
-    } | {
-        readonly kind: "timer";
-        readonly cron: string;
-    } | {
-        readonly kind: "webhook";
-        readonly method?: string | undefined;
-        readonly port?: number | undefined;
-    } | undefined;
-    readonly input?: {
-        readonly [x: string]: any;
-    } | undefined;
-}, Schema.Struct.Fields>;
-export interface Trigger extends Schema.Schema.Type<typeof TriggerSchema> {
-}
-export declare const Trigger: Type.Obj<Trigger>;
-export declare const make: (props: Obj.MakeProps<typeof Trigger>) => Obj.Obj<import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Trigger>;
-export {};
-//# sourceMappingURL=Trigger.d.ts.map

package/dist/types/src/types/Trigger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Trigger.d.ts","sourceRoot":"","sources":["../../../../src/types/Trigger.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAKjD;;;;GAIG;AACH,eAAO,MAAM,KAAK,iEAAkE,CAAC;AACrF,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;AAI1C,eAAO,MAAM,SAAS;;EAEpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D,eAAO,MAAM,SAAS;;;EAKpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;EAc3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,SAAS;;;EAMpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,WAAW;;;;EAatB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,WAAW,CAAC,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;IAEf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnD;;;;GAIG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAsClB,CAAC;AAEF,MAAM,WAAW,OAAQ,SAAQ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC;CAAG;AAC5E,eAAO,MAAM,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAwB,CAAC;AAE/D,eAAO,MAAM,IAAI,GAAI,OAAO,GAAG,CAAC,SAAS,CAAC,OAAO,OAAO,CAAC,2GAA6B,CAAC"}

package/dist/types/src/types/TriggerEvent.d.ts

@@ -1,74 +0,0 @@
-import * as Schema from 'effect/Schema';
-export declare const EmailEvent: Schema.Struct<{
-    from: typeof Schema.String;
-    to: typeof Schema.String;
-    subject: typeof Schema.String;
-    created: typeof Schema.String;
-    body: typeof Schema.String;
-}>;
-export type EmailEvent = Schema.Schema.Type<typeof EmailEvent>;
-export declare const QueueEvent: Schema.Struct<{
-    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
-    item: typeof Schema.Any;
-    cursor: typeof Schema.String;
-}>;
-export type QueueEvent = Schema.Schema.Type<typeof QueueEvent>;
-export declare const SubscriptionEvent: Schema.Struct<{
-    /**
-     * Type of the mutation.
-     */
-    type: typeof Schema.String;
-    /**
-     * Reference to the object that was changed or created.
-     */
-    subject: import("@dxos/echo/internal").RefSchema<any>;
-    /**
-     * @deprecated
-     */
-    changedObjectId: Schema.optional<typeof Schema.String>;
-}>;
-export type SubscriptionEvent = Schema.Schema.Type<typeof SubscriptionEvent>;
-export declare const TimerEvent: Schema.Struct<{
-    tick: typeof Schema.Number;
-}>;
-export type TimerEvent = Schema.Schema.Type<typeof TimerEvent>;
-export declare const WebhookEvent: Schema.Struct<{
-    url: typeof Schema.String;
-    method: Schema.Literal<["GET", "POST"]>;
-    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
-    bodyText: typeof Schema.String;
-}>;
-export type WebhookEvent = Schema.Schema.Type<typeof WebhookEvent>;
-export declare const TriggerEvent: Schema.Union<[Schema.Struct<{
-    from: typeof Schema.String;
-    to: typeof Schema.String;
-    subject: typeof Schema.String;
-    created: typeof Schema.String;
-    body: typeof Schema.String;
-}>, Schema.Struct<{
-    queue: Schema.refine<string, typeof Schema.NonEmptyString>;
-    item: typeof Schema.Any;
-    cursor: typeof Schema.String;
-}>, Schema.Struct<{
-    /**
-     * Type of the mutation.
-     */
-    type: typeof Schema.String;
-    /**
-     * Reference to the object that was changed or created.
-     */
-    subject: import("@dxos/echo/internal").RefSchema<any>;
-    /**
-     * @deprecated
-     */
-    changedObjectId: Schema.optional<typeof Schema.String>;
-}>, Schema.Struct<{
-    tick: typeof Schema.Number;
-}>, Schema.Struct<{
-    url: typeof Schema.String;
-    method: Schema.Literal<["GET", "POST"]>;
-    headers: Schema.Record$<typeof Schema.String, typeof Schema.String>;
-    bodyText: typeof Schema.String;
-}>]>;
-export type TriggerEvent = Schema.Schema.Type<typeof TriggerEvent>;
-//# sourceMappingURL=TriggerEvent.d.ts.map

package/dist/types/src/types/TriggerEvent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TriggerEvent.d.ts","sourceRoot":"","sources":["../../../../src/types/TriggerEvent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAUxC,eAAO,MAAM,UAAU;;;;;;EAMrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;EAIrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;;IAIH;;OAEG;;IAGH;;OAEG;;EAEH,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE7E,eAAO,MAAM,UAAU;;EAAyC,CAAC;AACjE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/D,eAAO,MAAM,YAAY;;;;;EAKvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC;AAEnE,eAAO,MAAM,YAAY;;;;;;;;;;;IA7BvB;;OAEG;;IAIH;;OAEG;;IAGH;;OAEG;;;;;;;;;IAgBwG,CAAC;AAC9G,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/src/errors.ts

@@ -1,21 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { BaseError, type BaseErrorOptions } from '@dxos/errors';
-
-export class ServiceNotAvailableError extends BaseError.extend('ServiceNotAvailable', 'Service not available') {
-  constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>) {
-    super({ context: { service }, ...options });
-  }
-}
-
-export class FunctionNotFoundError extends BaseError.extend('FunctionNotFound', 'Function not found') {
-  constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>) {
-    super({ context: { function: functionKey }, ...options });
-  }
-}
-
-export class FunctionError extends BaseError.extend('FunctionError', 'Function invocation error') {}
-
-export class TriggerStateNotFoundError extends BaseError.extend('TriggerStateNotFound', 'Trigger state not found') {}

package/src/example/fib.ts

@@ -1,32 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { defineFunction } from '../sdk';
-
-export default defineFunction({
-  key: 'example.org/function/fib',
-  name: 'Fibonacci',
-  description: 'Function that calculates a Fibonacci number',
-  inputSchema: Schema.Struct({
-    iterations: Schema.optional(Schema.Number).annotations({
-      description: 'Number of iterations',
-      default: 100_000,
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    result: Schema.String,
-  }),
-  handler: Effect.fn(function* ({ data: { iterations = 100_000 } }) {
-    let a = 0n;
-    let b = 1n;
-    for (let i = 0; i < iterations; i++) {
-      a += b;
-      b = a - b;
-    }
-    return { result: a.toString() };
-  }),
-});

package/src/example/forex-effect.ts

@@ -1,40 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
-import {
-  FetchHttpClient,
-  HttpClient,
-  HttpClientRequest,
-  // @ts-ignore
-} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
-// @ts-ignore
-import { Effect, Schedule } from 'https://esm.sh/effect@3.17.0?bundle=false';
-
-export default defineFunction({
-  key: 'dxos.org/script/forex-effect',
-  name: 'Forex Effect',
-  description: 'Returns the exchange rate between two currencies.',
-
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
-  }),
-
-  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
-
-  handler: async ({ data: { from, to } }: any) =>
-    Effect.gen(function* () {
-      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
-        HttpClient.execute,
-        Effect.flatMap((res: any) => res.json),
-        Effect.timeout('1 second'),
-        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
-        Effect.scoped,
-      );
-
-      return res.data.rates[to].toString();
-    }).pipe(Effect.provide(FetchHttpClient.layer)),
-});

package/src/example/index.ts

@@ -1,13 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { default as fib$ } from './fib';
-import { default as reply$ } from './reply';
-import { default as sleep$ } from './sleep';
-
-export namespace Example {
-  export const fib = fib$;
-  export const reply = reply$;
-  export const sleep = sleep$;
-}

package/src/example/reply.ts

@@ -1,21 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Console from 'effect/Console';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { defineFunction } from '../sdk';
-
-export default defineFunction({
-  key: 'example.org/function/reply',
-  name: 'Reply',
-  description: 'Function that echoes the input',
-  inputSchema: Schema.Any,
-  outputSchema: Schema.Any,
-  handler: Effect.fn(function* ({ data }) {
-    yield* Console.log('reply', { data });
-    return data;
-  }),
-});

package/src/example/sleep.ts

@@ -1,24 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { defineFunction } from '../sdk';
-
-export default defineFunction({
-  key: 'example.org/function/sleep',
-  name: 'Sleep',
-  description: 'Function that sleeps for a given amount of time',
-  inputSchema: Schema.Struct({
-    duration: Schema.optional(Schema.Number).annotations({
-      description: 'Milliseconds to sleep',
-      default: 100_000,
-    }),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ data: { duration = 100_000 } }) {
-    yield* Effect.sleep(duration);
-  }),
-});

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,
-  };
-};