@dxos/functions 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/src/types/Trigger.ts

@@ -5,8 +5,8 @@
 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 { Annotation, Obj, QueryAST, Ref, Type } from '@dxos/echo';
+import { OptionsAnnotationId, SystemTypeAnnotation } from '@dxos/echo/internal';
 import { DXN } from '@dxos/keys';
 
 /**
@@ -21,15 +21,17 @@ 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>;
 
+// TODO(burdon): Change to Feed.
+// TODO(wittjosiah): Remove. Migrate to Subscription triggers once EDGE supports them for feed queries.
 export const QueueSpec = Schema.Struct({
   kind: Schema.Literal('queue').annotations(kindLiteralAnnotations),
 
-  // TODO(dmaretskyi): Change to a reference.
+  // TODO(dmaretskyi): Rename to `feed` and change to a reference.
   queue: DXN.Schema,
-}).pipe(Schema.mutable);
+});
 export type QueueSpec = Schema.Schema.Type<typeof QueueSpec>;
 
 /**
@@ -40,7 +42,7 @@ export const SubscriptionSpec = Schema.Struct({
   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).
@@ -49,7 +51,7 @@ export const SubscriptionSpec = Schema.Struct({
       delay: Schema.optional(Schema.Number.annotations({ title: 'Delay' })),
     }).annotations({ title: 'Options' }),
   ),
-}).pipe(Schema.mutable);
+});
 export type SubscriptionSpec = Schema.Schema.Type<typeof SubscriptionSpec>;
 
 /**
@@ -61,7 +63,7 @@ export const TimerSpec = Schema.Struct({
     title: 'Cron',
     [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
   }),
-}).pipe(Schema.mutable);
+});
 export type TimerSpec = Schema.Schema.Type<typeof TimerSpec>;
 
 /**
@@ -80,7 +82,7 @@ export const WebhookSpec = Schema.Struct({
       title: 'Port',
     }),
   ),
-}).pipe(Schema.mutable);
+});
 export type WebhookSpec = Schema.Schema.Type<typeof WebhookSpec>;
 
 /**
@@ -96,12 +98,12 @@ export type Spec = Schema.Schema.Type<typeof Spec>;
  * 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({
+const TriggerSchema = 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' })),
+  function: Schema.optional(Ref.Ref(Obj.Unknown).annotations({ title: 'Function' })),
 
   /**
    * Only used for workflowSchema.
@@ -110,30 +112,43 @@ const Trigger_ = Schema.Struct({
    */
   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 Feed triggers, this will process Feed items in parallel.',
+    }),
+  ),
+
   /**
    * Passed as the input data to the function.
    * Must match the function's input schema.
    *
    * @example
    * {
-   *   item: '{{$.trigger.event}}',
+   *   item: '{{event.item}}',
    *   instructions: 'Summarize and perform entity-extraction'
    *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
    * }
    */
-  input: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
+  input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
 }).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Trigger',
+  Type.object({
+    typename: 'org.dxos.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 Trigger_> {}
-export interface TriggerEncoded extends Schema.Schema.Encoded<typeof Trigger_> {}
-export const Trigger: Schema.Schema<Trigger, TriggerEncoded> = Trigger_;
+
+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

@@ -4,29 +4,28 @@
 
 import * as Schema from 'effect/Schema';
 
-import { DXN, Obj, Type } from '@dxos/echo';
+import { DXN, Obj, Ref } from '@dxos/echo';
 
-export type TriggerEvent = EmailEvent | QueueEvent | SubscriptionEvent | TimerEvent | WebhookEvent;
+// 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.mutable(
-  Schema.Struct({
-    from: Schema.String,
-    to: Schema.String,
-    subject: Schema.String,
-    created: Schema.String,
-    body: Schema.String,
-  }),
-);
+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.mutable(
-  Schema.Struct({
-    queue: DXN.Schema,
-    item: Schema.Any,
-    cursor: Schema.String,
-  }),
-);
+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({
@@ -39,24 +38,25 @@ export const SubscriptionEvent = Schema.Struct({
   /**
    * Reference to the object that was changed or created.
    */
-  subject: Type.Ref(Obj.Any),
+  subject: Ref.Ref(Obj.Unknown),
 
   /**
    * @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 const TimerEvent = 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 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>;

package/src/types/index.ts

@@ -2,7 +2,6 @@
 // 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/types/url.ts

@@ -2,24 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ObjectMeta } from '@dxos/echo/internal';
+import { type Obj } from '@dxos/echo';
 
 // TODO: use URL scheme for source?
-export const FUNCTIONS_META_KEY = 'dxos.org/service/function';
+export const FUNCTIONS_META_KEY = 'org.dxos.service.function';
 
-export const FUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
+export const FUNCTIONS_PRESET_META_KEY = 'org.dxos.service.function-preset';
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
  */
-export const getUserFunctionIdInMetadata = (meta: ObjectMeta) => {
+export const getUserFunctionIdInMetadata = (meta: Obj.ReadonlyMeta) => {
   return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
+ * Must be called inside Obj.changeMeta() since it mutates the meta.
  */
-export const setUserFunctionIdInMetadata = (meta: ObjectMeta, functionId: string) => {
+export const setUserFunctionIdInMetadata = (meta: Obj.Meta, functionId: string) => {
   const key = meta.keys.find((key) => key.source === FUNCTIONS_META_KEY);
   if (key) {
     if (key.id !== functionId) {