@dxos/react-ui-canvas-compute 0.8.2-staging.7ac8446 → 0.8.2

package/src/shapes/Trigger.tsx

@@ -2,17 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
+import { Schema } from 'effect';
 import React, { useEffect } from 'react';
 
-import {
-  EmailTriggerOutput,
-  QueueTriggerOutput,
-  SubscriptionTriggerOutput,
-  TimerTriggerOutput,
-  VoidInput,
-  WebhookTriggerOutput,
-} from '@dxos/conductor';
-import { ObjectId, Ref, S } from '@dxos/echo-schema';
+import { VoidInput } from '@dxos/conductor';
+import { ObjectId, Ref } from '@dxos/echo-schema';
 import {
   type EmailTrigger,
   FunctionTrigger,
@@ -22,23 +16,28 @@ import {
   TriggerKind,
   type TriggerType,
   type WebhookTrigger,
-} from '@dxos/functions/types';
+  EmailTriggerOutput,
+  QueueTriggerOutput,
+  SubscriptionTriggerOutput,
+  TimerTriggerOutput,
+  WebhookTriggerOutput,
+} from '@dxos/functions';
 import { DXN, SpaceId } from '@dxos/keys';
-import { create, makeRef, useSpace } from '@dxos/react-client/echo';
+import { live, makeRef, useSpace } from '@dxos/react-client/echo';
 import { Select, type SelectRootProps } from '@dxos/react-ui';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 
 import { createFunctionAnchors, FunctionBody, getHeight } from './common';
 import { ComputeShape, createShape, type CreateShapeProps } from './defs';
 
-export const TriggerShape = S.extend(
+export const TriggerShape = Schema.extend(
   ComputeShape,
-  S.Struct({
-    type: S.Literal('trigger'),
-    functionTrigger: S.optional(Ref(FunctionTrigger)),
+  Schema.Struct({
+    type: Schema.Literal('trigger'),
+    functionTrigger: Schema.optional(Ref(FunctionTrigger)),
   }),
 );
-export type TriggerShape = S.Schema.Type<typeof TriggerShape>;
+export type TriggerShape = Schema.Schema.Type<typeof TriggerShape>;
 
 export type CreateTriggerProps = CreateShapeProps<Omit<TriggerShape, 'functionTrigger'>> & {
   spaceId?: SpaceId;
@@ -46,7 +45,7 @@ export type CreateTriggerProps = CreateShapeProps<Omit<TriggerShape, 'functionTr
 };
 
 export const createTrigger = (props: CreateTriggerProps): TriggerShape => {
-  const functionTrigger = create(FunctionTrigger, {
+  const functionTrigger = live(FunctionTrigger, {
     enabled: true,
     spec: createTriggerSpec(props),
   });
@@ -71,12 +70,12 @@ export const TriggerComponent = ({ shape }: TriggerComponentProps) => {
   }, [functionTrigger, functionTrigger?.spec]);
 
   useEffect(() => {
-    shape.size.height = getHeight(getOutputSchema(functionTrigger?.spec?.type ?? TriggerKind.Email));
-  }, [functionTrigger?.spec?.type]);
+    shape.size.height = getHeight(getOutputSchema(functionTrigger?.spec?.kind ?? TriggerKind.Email));
+  }, [functionTrigger?.spec?.kind]);
 
   const setKind = (kind: TriggerKind) => {
-    if (functionTrigger?.spec?.type !== kind) {
-      functionTrigger!.spec = createTriggerSpec({ triggerKind: TriggerKind.Email, spaceId: space?.id });
+    if (functionTrigger?.spec?.kind !== kind) {
+      functionTrigger!.spec = createTriggerSpec({ triggerKind: kind, spaceId: space?.id });
     }
   };
 
@@ -88,10 +87,10 @@ export const TriggerComponent = ({ shape }: TriggerComponentProps) => {
     <FunctionBody
       shape={shape}
       status={
-        <TriggerKindSelect value={functionTrigger.spec?.type} onValueChange={(kind) => setKind(kind as TriggerKind)} />
+        <TriggerKindSelect value={functionTrigger.spec?.kind} onValueChange={(kind) => setKind(kind as TriggerKind)} />
       }
       inputSchema={VoidInput}
-      outputSchema={getOutputSchema(functionTrigger.spec!.type!)}
+      outputSchema={getOutputSchema(functionTrigger.spec!.kind!)}
     />
   );
 };
@@ -105,9 +104,9 @@ const TriggerKindSelect = ({ value, onValueChange }: Pick<SelectRootProps, 'valu
         <Select.Content>
           <Select.ScrollUpButton />
           <Select.Viewport>
-            {Object.values(TriggerKind).map((type) => (
-              <Select.Option key={type} value={type}>
-                {type}
+            {Object.values(TriggerKind).map((kind) => (
+              <Select.Option key={kind} value={kind}>
+                {kind}
               </Select.Option>
             ))}
           </Select.Viewport>
@@ -123,22 +122,22 @@ const createTriggerSpec = (props: { triggerKind?: TriggerKind; spaceId?: SpaceId
   const kind = props.triggerKind ?? TriggerKind.Email;
   switch (kind) {
     case TriggerKind.Timer:
-      return { type: TriggerKind.Timer, cron: '*/10 * * * * *' } satisfies TimerTrigger;
+      return { kind: TriggerKind.Timer, cron: '*/10 * * * * *' } satisfies TimerTrigger;
     case TriggerKind.Webhook:
-      return { type: TriggerKind.Webhook, method: 'POST' } satisfies WebhookTrigger;
+      return { kind: TriggerKind.Webhook, method: 'POST' } satisfies WebhookTrigger;
     case TriggerKind.Subscription:
-      return { type: TriggerKind.Subscription, filter: {} } satisfies SubscriptionTrigger;
+      return { kind: TriggerKind.Subscription, filter: {} } satisfies SubscriptionTrigger;
     case TriggerKind.Email:
-      return { type: TriggerKind.Email } satisfies EmailTrigger;
+      return { kind: TriggerKind.Email } satisfies EmailTrigger;
     case TriggerKind.Queue: {
       const dxn = new DXN(DXN.kind.QUEUE, ['data', props.spaceId ?? SpaceId.random(), ObjectId.random()]).toString();
-      return { type: TriggerKind.Queue, queue: dxn } satisfies QueueTrigger;
+      return { kind: TriggerKind.Queue, queue: dxn } satisfies QueueTrigger;
     }
   }
 };
 
 const getOutputSchema = (kind: TriggerKind) => {
-  const kindToSchema: Record<TriggerKind, S.Schema<any>> = {
+  const kindToSchema: Record<TriggerKind, Schema.Schema<any>> = {
     [TriggerKind.Email]: EmailTriggerOutput,
     [TriggerKind.Subscription]: SubscriptionTriggerOutput,
     [TriggerKind.Timer]: TimerTriggerOutput,
@@ -158,6 +157,6 @@ export const triggerShape: ShapeDef<TriggerShape> = {
     createFunctionAnchors(
       shape,
       VoidInput,
-      getOutputSchema(shape.functionTrigger?.target?.spec?.type ?? TriggerKind.Email),
+      getOutputSchema(shape.functionTrigger?.target?.spec?.kind ?? TriggerKind.Email),
     ),
 };

package/src/shapes/common/FunctionBody.tsx

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import { type Schema, SchemaAST } from 'effect';
 import React, { type JSX, useRef, useState } from 'react';
 
 import { VoidInput, VoidOutput } from '@dxos/conductor';
-import { AST, type S } from '@dxos/echo-schema';
 import { useCanvasContext } from '@dxos/react-ui-canvas';
 import { type Polygon, type Shape } from '@dxos/react-ui-canvas-editor';
 import { getParentShapeElement, createAnchors, rowHeight } from '@dxos/react-ui-canvas-editor';
@@ -20,8 +20,8 @@ export type FunctionBodyProps = {
   shape: Shape;
   name?: string;
   content?: JSX.Element;
-  inputSchema?: S.Schema.Any;
-  outputSchema?: S.Schema.Any;
+  inputSchema?: Schema.Schema.Any;
+  outputSchema?: Schema.Schema.Any;
 } & Pick<BoxProps, 'status'>;
 
 // TODO(wittjosiah): Rename, not used for functions.
@@ -106,18 +106,20 @@ export const FunctionBody = ({
   );
 };
 
-export const getHeight = (input: S.Schema<any>) => {
-  const properties = AST.getPropertySignatures(input.ast);
+export const getHeight = (input: Schema.Schema<any>) => {
+  const properties = SchemaAST.getPropertySignatures(input.ast);
   return headerHeight + footerHeight + bodyPadding * 2 + properties.length * rowHeight + 2; // Incl. borders.
 };
 
 export const createFunctionAnchors = (
   shape: Polygon,
-  input: S.Schema<any> = VoidInput,
-  output: S.Schema<any> = VoidOutput,
+  input: Schema.Schema<any> = VoidInput,
+  output: Schema.Schema<any> = VoidOutput,
 ) => {
   // TODO(burdon): Set type.
-  const inputs = AST.getPropertySignatures(input.ast).map(({ name }) => createAnchorId('input', name.toString()));
-  const outputs = AST.getPropertySignatures(output.ast).map(({ name }) => createAnchorId('output', name.toString()));
+  const inputs = SchemaAST.getPropertySignatures(input.ast).map(({ name }) => createAnchorId('input', name.toString()));
+  const outputs = SchemaAST.getPropertySignatures(output.ast).map(({ name }) =>
+    createAnchorId('output', name.toString()),
+  );
   return createAnchors({ shape, inputs, outputs, center: { x: 0, y: (headerHeight - footerHeight) / 2 + 1 } });
 };

package/src/shapes/defs.ts

@@ -2,10 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { SchemaAST as AST } from 'effect';
+import { Schema, SchemaAST } from 'effect';
 
 import { DEFAULT_INPUT, DEFAULT_OUTPUT } from '@dxos/conductor';
-import { ObjectId, S } from '@dxos/echo-schema';
+import { ObjectId } from '@dxos/echo-schema';
 import { Polygon } from '@dxos/react-ui-canvas-editor';
 import { type MakeOptional } from '@dxos/util';
 
@@ -15,8 +15,8 @@ import { type MakeOptional } from '@dxos/util';
 
 export type PropertyKind = 'input' | 'output';
 
-export const getProperties = (ast: AST.AST) =>
-  AST.getPropertySignatures(ast).map(({ name }) => ({ name: name.toString() }));
+export const getProperties = (ast: SchemaAST.AST) =>
+  SchemaAST.getPropertySignatures(ast).map(({ name }) => ({ name: name.toString() }));
 
 export const createAnchorId = (kind: PropertyKind, property = kind === 'input' ? DEFAULT_INPUT : DEFAULT_OUTPUT) =>
   [kind, property].join('.');
@@ -32,15 +32,15 @@ export const parseAnchorId = (id: string): [PropertyKind | undefined, string] =>
 
 export type CreateShapeProps<S extends Polygon> = Omit<MakeOptional<S, 'id' | 'size'>, 'type' | 'node'>;
 
-export const ComputeShape = S.extend(
+export const ComputeShape = Schema.extend(
   Polygon,
-  S.Struct({
+  Schema.Struct({
     // TODO(burdon): Rename computeNode?
-    node: S.optional(ObjectId.annotations({ [AST.DescriptionAnnotationId]: 'Compute node id' })),
-  }).pipe(S.mutable),
+    node: Schema.optional(ObjectId.annotations({ description: 'Compute node id' })),
+  }).pipe(Schema.mutable),
 );
 
-export type ComputeShape = S.Schema.Type<typeof ComputeShape>;
+export type ComputeShape = Schema.Schema.Type<typeof ComputeShape>;
 
 export const createShape = <S extends ComputeShape>({ id, ...rest }: CreateShapeProps<S> & { type: string }): S => {
   return {