@dxos/functions 0.8.4-main.a4bbb77 → 0.8.4-main.ae835ea

package/src/{schema.ts → types/Function.ts}

@@ -2,36 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { Type } from '@dxos/echo';
-import { JsonSchemaType, LabelAnnotation, Ref } from '@dxos/echo-schema';
-import { DataType } from '@dxos/schema';
+import { Obj, Type } from '@dxos/echo';
+import { JsonSchemaType, LabelAnnotation, Ref } from '@dxos/echo/internal';
 
-/**
- * Source script.
- */
-export const ScriptType = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema.optional(Schema.Boolean),
-  source: Ref(DataType.Text),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Script',
-    version: '0.1.0',
-  }),
-  LabelAnnotation.set(['name']),
-);
-
-export interface ScriptType extends Schema.Schema.Type<typeof ScriptType> {}
+import { Script } from './Script';
 
 /**
  * Function deployment.
  */
-export const FunctionType = Schema.Struct({
+export const Function = Schema.Struct({
   /**
    * Global registry ID.
    * NOTE: The `key` property refers to the original registry entry.
@@ -51,7 +32,7 @@ export const FunctionType = Schema.Struct({
 
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema.optional(Ref(ScriptType)),
+  source: Schema.optional(Ref(Script)),
 
   inputSchema: Schema.optional(JsonSchemaType),
   outputSchema: Schema.optional(JsonSchemaType),
@@ -65,4 +46,6 @@ export const FunctionType = Schema.Struct({
   }),
   LabelAnnotation.set(['name']),
 );
-export interface FunctionType extends Schema.Schema.Type<typeof FunctionType> {}
+export interface Function extends Schema.Schema.Type<typeof Function> {}
+
+export const make = (props: Obj.MakeProps<typeof Function>) => Obj.make(Function, props);

package/src/types/Script.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Obj, Ref, Type } from '@dxos/echo';
+import { FormAnnotation, LabelAnnotation } from '@dxos/echo/internal';
+import { DataType } 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(FormAnnotation.set(false), Schema.optional),
+  source: Type.Ref(DataType.Text).pipe(FormAnnotation.set(false)),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Script',
+    version: '0.1.0',
+  }),
+  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 = {}) =>
+  Obj.make(Script, { ...props, source: Ref.make(DataType.makeText(source)) });

package/src/types/Trigger.ts

@@ -0,0 +1,139 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { Obj, QueryAST, Type } from '@dxos/echo';
+import { Expando, OptionsAnnotationId, Ref } from '@dxos/echo/internal';
+import { DXN } from '@dxos/keys';
+
+/**
+ * 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),
+}).pipe(Schema.mutable);
+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,
+}).pipe(Schema.mutable);
+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,
+  }).pipe(Schema.mutable),
+  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' }),
+  ),
+}).pipe(Schema.mutable);
+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 * * *'],
+  }),
+}).pipe(Schema.mutable);
+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',
+    }),
+  ),
+}).pipe(Schema.mutable);
+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 Trigger_ = Schema.Struct({
+  /**
+   * Function or workflow to invoke.
+   */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  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({ title: 'Input Node ID' })),
+
+  enabled: Schema.optional(Schema.Boolean.annotations({ title: 'Enabled' })),
+
+  spec: Schema.optional(Spec),
+
+  /**
+   * 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.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Trigger',
+    version: '0.1.0',
+  }),
+);
+export interface Trigger extends Schema.Schema.Type<typeof Trigger_> {}
+export interface TriggerEncoded extends Schema.Schema.Encoded<typeof Trigger_> {}
+export const Trigger: Schema.Schema<Trigger, TriggerEncoded> = Trigger_;
+
+export const make = (props: Obj.MakeProps<typeof Trigger>) => Obj.make(Trigger, props);

package/src/types/TriggerEvent.ts

@@ -0,0 +1,62 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { DXN, Obj, Type } from '@dxos/echo';
+
+export type TriggerEvent = EmailEvent | QueueEvent | SubscriptionEvent | TimerEvent | WebhookEvent;
+
+// TODO(burdon): Reuse trigger schema from @dxos/functions (TriggerType).
+export const EmailEvent = Schema.mutable(
+  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.mutable(
+  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: Type.Ref(Obj.Any),
+
+  /**
+   * @deprecated
+   */
+  changedObjectId: Schema.optional(Schema.String),
+}).pipe(Schema.mutable);
+export type SubscriptionEvent = Schema.Schema.Type<typeof SubscriptionEvent>;
+
+export const TimerEvent = Schema.mutable(Schema.Struct({ tick: Schema.Number }));
+export type TimerEvent = Schema.Schema.Type<typeof TimerEvent>;
+
+export const WebhookEvent = Schema.mutable(
+  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>;

package/src/types/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * as Function from './Function';
+export * as Script from './Script';
+export * as Trigger from './Trigger';
+export * as TriggerEvent from './TriggerEvent';

package/src/url.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ObjectMeta } from '@dxos/echo-schema';
+import { type ObjectMeta } from '@dxos/echo/internal';
 import { type SpaceId } from '@dxos/keys';
 
 // TODO: use URL scheme for source?