@dxos/functions 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/dist/types/src/testing/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/testing/util.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAU,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAOvD,eAAO,MAAM,cAAc,UAAiB,KAAK,OAAO,MAAM,kBAM7D,CAAC;AAEF,eAAO,MAAM,YAAY,SAAgB,KAAK,SAAS,MAAM,kBAK5D,CAAC"}

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

@@ -1,7 +1,6 @@
-import { ScriptType } from './schema';
 declare const _default: {
     'en-US': {
-        [ScriptType.typename]: {
+        [x: string]: {
             'typename label': string;
         };
     };

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

@@ -1 +1 @@
-{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;;;QAKhC,CAAC,UAAU,CAAC,QAAQ,CAAC;;UAEpB;;;AALP,wBAQE"}
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../src/translations.ts"],"names":[],"mappings":";;;;;;;AAMA,wBAQE"}

package/dist/types/src/trigger/index.d.ts

@@ -0,0 +1,3 @@
+export * from './trigger-registry';
+export * from './type';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/trigger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/trigger/index.ts"],"names":[],"mappings":"AAIA,cAAc,oBAAoB,CAAC;AACnC,cAAc,QAAQ,CAAC"}

package/dist/types/src/trigger/trigger-registry.d.ts

@@ -0,0 +1,38 @@
+import { Event } from '@dxos/async';
+import { type Client } from '@dxos/client';
+import { type Space } from '@dxos/client/echo';
+import { Context, Resource } from '@dxos/context';
+import { type FunctionManifest, FunctionTrigger, type TriggerKind, type TriggerType } from '../types';
+type ResponseCode = number;
+export type TriggerCallback = (args: object) => Promise<ResponseCode>;
+export type TriggerFactory<Spec extends TriggerType, Options = any> = (ctx: Context, space: Space, spec: Spec, callback: TriggerCallback, options?: Options) => Promise<void>;
+export type TriggerFactoryMap = Partial<Record<TriggerKind, TriggerFactory<any>>>;
+export type TriggerEvent = {
+    space: Space;
+    triggers: FunctionTrigger[];
+};
+export declare class TriggerRegistry extends Resource {
+    private readonly _client;
+    private readonly _options?;
+    private readonly _triggersBySpaceKey;
+    readonly registered: Event<TriggerEvent>;
+    readonly removed: Event<TriggerEvent>;
+    constructor(_client: Client, _options?: TriggerFactoryMap | undefined);
+    getActiveTriggers(space: Space): FunctionTrigger[];
+    getInactiveTriggers(space: Space): FunctionTrigger[];
+    /**
+     * Set callback for trigger.
+     */
+    activate(space: Space, trigger: FunctionTrigger, callback: TriggerCallback): Promise<void>;
+    /**
+     * Loads triggers from the manifest into the space.
+     */
+    register(space: Space, manifest: FunctionManifest): Promise<void>;
+    protected _open(): Promise<void>;
+    protected _close(_: Context): Promise<void>;
+    private _handleNewTriggers;
+    private _handleRemovedTriggers;
+    private _getTriggers;
+}
+export {};
+//# sourceMappingURL=trigger-registry.d.ts.map

package/dist/types/src/trigger/trigger-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-registry.d.ts","sourceRoot":"","sources":["../../../../src/trigger/trigger-registry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAA2B,KAAK,KAAK,EAAsB,MAAM,mBAAmB,CAAC;AAC5F,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAQlD,OAAO,EAAE,KAAK,gBAAgB,EAAE,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAEtG,KAAK,YAAY,GAAG,MAAM,CAAC;AAE3B,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAGtE,MAAM,MAAM,cAAc,CAAC,IAAI,SAAS,WAAW,EAAE,OAAO,GAAG,GAAG,IAAI,CACpE,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,eAAe,EACzB,OAAO,CAAC,EAAE,OAAO,KACd,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AASlF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAOF,qBAAa,eAAgB,SAAQ,QAAQ;IAOzC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAP5B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkE;IAEtG,SAAgB,UAAU,sBAA6B;IACvD,SAAgB,OAAO,sBAA6B;gBAGjC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,iBAAiB,YAAA;IAKxC,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,EAAE;IAIlD,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,EAAE;IAI3D;;OAEG;IACU,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBvG;;OAEG;IACU,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;cAoCrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;cA8BtB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1D,OAAO,CAAC,kBAAkB;YAiBZ,sBAAsB;IA0BpC,OAAO,CAAC,YAAY;CAIrB"}

package/dist/types/src/trigger/trigger-registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trigger-registry.test.d.ts.map

package/dist/types/src/trigger/trigger-registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-registry.test.d.ts","sourceRoot":"","sources":["../../../../src/trigger/trigger-registry.test.ts"],"names":[],"mappings":""}

package/dist/types/src/trigger/type/index.d.ts

@@ -0,0 +1,3 @@
+export * from './subscription-trigger';
+export * from './timer-trigger';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/trigger/type/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/index.ts"],"names":[],"mappings":"AAIA,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC"}

package/dist/types/src/trigger/type/subscription-trigger.d.ts

@@ -0,0 +1,4 @@
+import type { SubscriptionTrigger } from '../../types';
+import { type TriggerFactory } from '../trigger-registry';
+export declare const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger>;
+//# sourceMappingURL=subscription-trigger.d.ts.map

package/dist/types/src/trigger/type/subscription-trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/subscription-trigger.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhF,eAAO,MAAM,yBAAyB,EAAE,cAAc,CAAC,mBAAmB,CAsEzE,CAAC"}

package/dist/types/src/trigger/type/timer-trigger.d.ts

@@ -0,0 +1,4 @@
+import type { TimerTrigger } from '../../types';
+import { type TriggerFactory } from '../trigger-registry';
+export declare const createTimerTrigger: TriggerFactory<TimerTrigger>;
+//# sourceMappingURL=timer-trigger.d.ts.map

package/dist/types/src/trigger/type/timer-trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/timer-trigger.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhF,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,YAAY,CAiC3D,CAAC"}

package/dist/types/src/trigger/type/webhook-trigger.d.ts

@@ -0,0 +1,4 @@
+import type { WebhookTrigger } from '../../types';
+import { type TriggerFactory } from '../trigger-registry';
+export declare const createWebhookTrigger: TriggerFactory<WebhookTrigger>;
+//# sourceMappingURL=webhook-trigger.d.ts.map

package/dist/types/src/trigger/type/webhook-trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/webhook-trigger.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhF,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,cAAc,CAiC/D,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from './schema';
+export * from './types';
+export * from './trace';
+export * from './url';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/index.ts"],"names":[],"mappings":"AAIA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}

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

@@ -0,0 +1,53 @@
+import { JsonSchemaType, Ref, S } from '@dxos/echo-schema';
+/**
+ * Source script.
+ */
+export declare const ScriptType: import("@dxos/echo-schema").EchoObjectSchema<S.Struct<{
+    name: S.optional<typeof S.String>;
+    description: S.optional<typeof S.String>;
+    changed: S.optional<typeof S.Boolean>;
+    source: import("@dxos/echo-schema").Ref$<import("@dxos/echo-schema").TypedObjectFields<{
+        content: typeof S.String;
+    }, import("@dxos/echo-schema").TypedObjectOptions>>;
+}>>;
+export type ScriptType = S.Schema.Type<typeof ScriptType>;
+declare const FunctionType_base: import("@dxos/echo-schema").TypedObjectPrototype<import("@dxos/echo-schema").TypedObjectFields<{
+    name: typeof S.NonEmptyString;
+    version: typeof S.String;
+    description: S.optional<typeof S.String>;
+    source: S.optional<import("@dxos/echo-schema").Ref$<{
+        readonly id: string;
+        source: Ref<import("@dxos/echo-schema").TypedObjectFields<{
+            content: typeof S.String;
+        }, import("@dxos/echo-schema").TypedObjectOptions>>;
+        name?: string | undefined;
+        description?: string | undefined;
+        changed?: boolean | undefined;
+    }>>;
+    inputSchema: S.optional<S.Schema<JsonSchemaType, JsonSchemaType, never>>;
+    outputSchema: S.optional<S.Schema<JsonSchemaType, JsonSchemaType, never>>;
+    binding: S.optional<typeof S.String>;
+}, import("@dxos/echo-schema").TypedObjectOptions>, S.Struct.Encoded<{
+    name: typeof S.NonEmptyString;
+    version: typeof S.String;
+    description: S.optional<typeof S.String>;
+    source: S.optional<import("@dxos/echo-schema").Ref$<{
+        readonly id: string;
+        source: Ref<import("@dxos/echo-schema").TypedObjectFields<{
+            content: typeof S.String;
+        }, import("@dxos/echo-schema").TypedObjectOptions>>;
+        name?: string | undefined;
+        description?: string | undefined;
+        changed?: boolean | undefined;
+    }>>;
+    inputSchema: S.optional<S.Schema<JsonSchemaType, JsonSchemaType, never>>;
+    outputSchema: S.optional<S.Schema<JsonSchemaType, JsonSchemaType, never>>;
+    binding: S.optional<typeof S.String>;
+}>>;
+/**
+ * Function deployment.
+ */
+export declare class FunctionType extends FunctionType_base {
+}
+export {};
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/types/schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,cAAc,EAAqB,GAAG,EAAE,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAGvG;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;wBAFtB,EAAE,MAAM;;GAWkE,CAAC;AAE5E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;;;;;;;;4BAbzD,EAAE,MAAM;;;;;;;;;;;;;;;;4BAAR,EAAE,MAAM;;;;;;;;;;AAeT;;GAEG;AACH,qBAAa,YAAa,SAAQ,iBAmBhC;CAAG"}

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

@@ -0,0 +1,146 @@
+import { Expando, Ref, S } from '@dxos/echo-schema';
+import { type FunctionTriggerType } from './types';
+export declare enum InvocationOutcome {
+    SUCCESS = "success",
+    FAILURE = "failure",
+    PENDING = "pending"
+}
+export declare enum InvocationTraceEventType {
+    START = "start",
+    END = "end"
+}
+export declare const TraceEventException: S.Struct<{
+    timestampMs: typeof S.Number;
+    message: typeof S.String;
+    name: typeof S.String;
+    stack: S.optional<typeof S.String>;
+}>;
+export type TraceEventException = S.Schema.Type<typeof TraceEventException>;
+export declare const InvocationTraceStartEvent: import("@dxos/echo-schema").EchoObjectSchema<S.Struct<{
+    /**
+     * Queue message id.
+     */
+    id: import("@dxos/echo-schema").ObjectIdClass;
+    type: S.Literal<[InvocationTraceEventType.START]>;
+    /**
+     * Invocation id, the same for invocation start and end events.
+     */
+    invocationId: import("@dxos/echo-schema").ObjectIdClass;
+    /**
+     * Event generation time.
+     */
+    timestampMs: typeof S.Number;
+    /**
+     * Data passed to function / workflow as an argument.
+     */
+    input: typeof S.Object;
+    /**
+     * Queue DXN for function/workflow invocation events.
+     */
+    invocationTraceQueue: import("@dxos/echo-schema").Ref$<Expando>;
+    /**
+     * DXN of the invoked function/workflow.
+     */
+    invocationTarget: import("@dxos/echo-schema").Ref$<Expando>;
+    /**
+     * Present for automatic invocations.
+     */
+    trigger: S.optional<import("@dxos/echo-schema").Ref$<import("@dxos/echo-schema").TypedObjectFields<{
+        readonly function: S.optional<S.SchemaClass<string, string, never>>;
+        readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
+            type: S.Literal<[import("./types").TriggerKind.Timer]>;
+            cron: S.SchemaClass<string, string, never>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[import("./types").TriggerKind.Webhook]>;
+            method: S.optional<S.SchemaClass<string, string, never>>;
+            port: S.optional<S.SchemaClass<number, number, never>>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[import("./types").TriggerKind.Subscription]>;
+            filter: S.Struct<{
+                type: S.optional<S.SchemaClass<string, string, never>>;
+                props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+            }>;
+            options: S.optional<S.Struct<{
+                deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+                delay: S.optional<S.SchemaClass<number, number, never>>;
+            }>>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[import("./types").TriggerKind.Email]>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[import("./types").TriggerKind.Queue]>;
+            queue: S.refine<string, typeof S.NonEmptyString>;
+        }>>]>>;
+        readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
+    }, import("@dxos/echo-schema").TypedObjectOptions>>>;
+}>>;
+export type InvocationTraceStartEvent = S.Schema.Type<typeof InvocationTraceStartEvent>;
+export declare const InvocationTraceEndEvent: import("@dxos/echo-schema").EchoObjectSchema<S.Struct<{
+    /**
+     * Trace event id.
+     */
+    id: import("@dxos/echo-schema").ObjectIdClass;
+    type: S.Literal<[InvocationTraceEventType.END]>;
+    /**
+     * Invocation id, will be the same for invocation start and end.
+     */
+    invocationId: import("@dxos/echo-schema").ObjectIdClass;
+    /**
+     * Event generation time.
+     */
+    timestampMs: typeof S.Number;
+    outcome: S.Enums<typeof InvocationOutcome>;
+    exception: S.optional<S.Struct<{
+        timestampMs: typeof S.Number;
+        message: typeof S.String;
+        name: typeof S.String;
+        stack: S.optional<typeof S.String>;
+    }>>;
+}>>;
+export type InvocationTraceEndEvent = S.Schema.Type<typeof InvocationTraceEndEvent>;
+export type InvocationTraceEvent = InvocationTraceStartEvent | InvocationTraceEndEvent;
+export declare const TraceEventLog: S.Struct<{
+    timestampMs: typeof S.Number;
+    level: typeof S.String;
+    message: typeof S.String;
+    context: S.optional<typeof S.Object>;
+}>;
+export declare const TraceEvent: import("@dxos/echo-schema").EchoObjectSchema<S.Struct<{
+    id: import("@dxos/echo-schema").ObjectIdClass;
+    outcome: typeof S.String;
+    truncated: typeof S.Boolean;
+    /**
+     * Time when the event was persisted.
+     */
+    ingestionTimestampMs: typeof S.Number;
+    logs: S.Array$<S.Struct<{
+        timestampMs: typeof S.Number;
+        level: typeof S.String;
+        message: typeof S.String;
+        context: S.optional<typeof S.Object>;
+    }>>;
+    exceptions: S.Array$<S.Struct<{
+        timestampMs: typeof S.Number;
+        message: typeof S.String;
+        name: typeof S.String;
+        stack: S.optional<typeof S.String>;
+    }>>;
+}>>;
+export type TraceEvent = S.Schema.Type<typeof TraceEvent>;
+/**
+ * Deprecated InvocationTrace event format.
+ * @deprecated
+ */
+export type InvocationSpan = {
+    id: string;
+    timestampMs: number;
+    outcome: InvocationOutcome;
+    input: object;
+    durationMs: number;
+    invocationTraceQueue: Ref<Expando>;
+    invocationTarget: Ref<Expando>;
+    trigger?: Ref<FunctionTriggerType>;
+    exception?: TraceEventException;
+};
+export declare const createInvocationSpans: (items?: InvocationTraceEvent[]) => InvocationSpan[];
+//# sourceMappingURL=trace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../../../src/types/trace.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,OAAO,EAAY,GAAG,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,EAAmB,KAAK,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEpE,oBAAY,iBAAiB;IAC3B,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAGD,oBAAY,wBAAwB;IAClC,KAAK,UAAU;IACf,GAAG,QAAQ;CACZ;AAED,eAAO,MAAM,mBAAmB;;;;;EAK9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE5E,eAAO,MAAM,yBAAyB;IACpC;;OAEG;;;IAGH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEoF,CAAC;AAE1F,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAExF,eAAO,MAAM,uBAAuB;IAClC;;OAEG;;;IAGH;;OAEG;;IAEH;;OAEG;;;;;;;;;GAKkF,CAAC;AAExF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEpF,MAAM,MAAM,oBAAoB,GAAG,yBAAyB,GAAG,uBAAuB,CAAC;AAEvF,eAAO,MAAM,aAAa;;;;;EAKxB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;IAKrB;;OAEG;;;;;;;;;;;;;;GAI0E,CAAC;AAEhF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE1D;;;GAGG;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IACnC,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,GAAG,CAAC,mBAAmB,CAAC,CAAC;IACnC,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,WAAY,oBAAoB,EAAE,KAAG,cAAc,EAkDpF,CAAC"}

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

@@ -0,0 +1,265 @@
+import { S } from '@dxos/echo-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 declare enum TriggerKind {
+    Timer = "timer",
+    Webhook = "webhook",
+    Subscription = "subscription",
+    Email = "email",
+    Queue = "queue"
+}
+/**
+ * Cron timer.
+ */
+declare const TimerTriggerSchema: S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Timer]>;
+    cron: S.SchemaClass<string, string, never>;
+}>>;
+export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
+declare const EmailTriggerSchema: S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Email]>;
+}>>;
+export type EmailTrigger = S.Schema.Type<typeof EmailTriggerSchema>;
+declare const QueueTriggerSchema: S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Queue]>;
+    queue: S.refine<string, typeof S.NonEmptyString>;
+}>>;
+export type QueueTrigger = S.Schema.Type<typeof QueueTriggerSchema>;
+/**
+ * Webhook.
+ */
+declare const WebhookTriggerSchema: S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Webhook]>;
+    method: S.optional<S.SchemaClass<string, string, never>>;
+    port: S.optional<S.SchemaClass<number, number, never>>;
+}>>;
+export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
+/**
+ * Subscription.
+ */
+declare const SubscriptionTriggerSchema: S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Subscription]>;
+    filter: S.Struct<{
+        type: S.optional<S.SchemaClass<string, string, never>>;
+        props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+    }>;
+    options: S.optional<S.Struct<{
+        deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        delay: S.optional<S.SchemaClass<number, number, never>>;
+    }>>;
+}>>;
+export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
+/**
+ * Trigger schema (discriminated union).
+ */
+export declare const TriggerSchema: S.Union<[S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Timer]>;
+    cron: S.SchemaClass<string, string, never>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Webhook]>;
+    method: S.optional<S.SchemaClass<string, string, never>>;
+    port: S.optional<S.SchemaClass<number, number, never>>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Subscription]>;
+    filter: S.Struct<{
+        type: S.optional<S.SchemaClass<string, string, never>>;
+        props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+    }>;
+    options: S.optional<S.Struct<{
+        deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        delay: S.optional<S.SchemaClass<number, number, never>>;
+    }>>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Email]>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Queue]>;
+    queue: S.refine<string, typeof S.NonEmptyString>;
+}>>]>;
+export type TriggerType = S.Schema.Type<typeof TriggerSchema>;
+/**
+ * Function trigger.
+ */
+export declare const FunctionTriggerSchema: S.Struct<{
+    function: S.optional<S.SchemaClass<string, string, never>>;
+    enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+    spec: S.optional<S.Union<[S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Timer]>;
+        cron: S.SchemaClass<string, string, never>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Webhook]>;
+        method: S.optional<S.SchemaClass<string, string, never>>;
+        port: S.optional<S.SchemaClass<number, number, never>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Subscription]>;
+        filter: S.Struct<{
+            type: S.optional<S.SchemaClass<string, string, never>>;
+            props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+        }>;
+        options: S.optional<S.Struct<{
+            deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+            delay: S.optional<S.SchemaClass<number, number, never>>;
+        }>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Email]>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Queue]>;
+        queue: S.refine<string, typeof S.NonEmptyString>;
+    }>>]>>;
+    meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
+}>;
+export type FunctionTriggerType = S.Schema.Type<typeof FunctionTriggerSchema>;
+declare const FunctionTrigger_base: import("@dxos/echo-schema").TypedObjectPrototype<import("@dxos/echo-schema").TypedObjectFields<{
+    readonly function: S.optional<S.SchemaClass<string, string, never>>;
+    readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+    readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Timer]>;
+        cron: S.SchemaClass<string, string, never>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Webhook]>;
+        method: S.optional<S.SchemaClass<string, string, never>>;
+        port: S.optional<S.SchemaClass<number, number, never>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Subscription]>;
+        filter: S.Struct<{
+            type: S.optional<S.SchemaClass<string, string, never>>;
+            props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+        }>;
+        options: S.optional<S.Struct<{
+            deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+            delay: S.optional<S.SchemaClass<number, number, never>>;
+        }>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Email]>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Queue]>;
+        queue: S.refine<string, typeof S.NonEmptyString>;
+    }>>]>>;
+    readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
+}, import("@dxos/echo-schema").TypedObjectOptions>, S.Struct.Encoded<{
+    readonly function: S.optional<S.SchemaClass<string, string, never>>;
+    readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+    readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Timer]>;
+        cron: S.SchemaClass<string, string, never>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Webhook]>;
+        method: S.optional<S.SchemaClass<string, string, never>>;
+        port: S.optional<S.SchemaClass<number, number, never>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Subscription]>;
+        filter: S.Struct<{
+            type: S.optional<S.SchemaClass<string, string, never>>;
+            props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+        }>;
+        options: S.optional<S.Struct<{
+            deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+            delay: S.optional<S.SchemaClass<number, number, never>>;
+        }>>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Email]>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Queue]>;
+        queue: S.refine<string, typeof S.NonEmptyString>;
+    }>>]>>;
+    readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
+}>>;
+/**
+ * Function trigger.
+ */
+export declare class FunctionTrigger extends FunctionTrigger_base {
+}
+declare const FunctionDef_base: import("@dxos/echo-schema").TypedObjectPrototype<import("@dxos/echo-schema").TypedObjectFields<{
+    uri: typeof S.String;
+    description: S.optional<typeof S.String>;
+    route: typeof S.String;
+    handler: typeof S.String;
+}, import("@dxos/echo-schema").TypedObjectOptions>, S.Struct.Encoded<{
+    uri: typeof S.String;
+    description: S.optional<typeof S.String>;
+    route: typeof S.String;
+    handler: typeof S.String;
+}>>;
+/**
+ * Function definition.
+ * @deprecated (Use dxos.org/type/Function)
+ */
+export declare class FunctionDef extends FunctionDef_base {
+}
+/**
+ * Function manifest file.
+ */
+export declare const FunctionManifestSchema: S.Struct<{
+    functions: S.optional<S.mutable<S.Array$<S.Schema<import("@dxos/echo-schema").ExcludeId<import("@dxos/echo-schema").TypedObjectFields<{
+        uri: typeof S.String;
+        description: S.optional<typeof S.String>;
+        route: typeof S.String;
+        handler: typeof S.String;
+    }, import("@dxos/echo-schema").TypedObjectOptions>> & import("@dxos/echo-schema").WithMeta, S.Struct.Encoded<{
+        uri: typeof S.String;
+        description: S.optional<typeof S.String>;
+        route: typeof S.String;
+        handler: typeof S.String;
+    }>, never>>>>;
+    triggers: S.optional<S.mutable<S.Array$<S.Schema<import("@dxos/echo-schema").ExcludeId<import("@dxos/echo-schema").TypedObjectFields<{
+        readonly function: S.optional<S.SchemaClass<string, string, never>>;
+        readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Timer]>;
+            cron: S.SchemaClass<string, string, never>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Webhook]>;
+            method: S.optional<S.SchemaClass<string, string, never>>;
+            port: S.optional<S.SchemaClass<number, number, never>>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Subscription]>;
+            filter: S.Struct<{
+                type: S.optional<S.SchemaClass<string, string, never>>;
+                props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+            }>;
+            options: S.optional<S.Struct<{
+                deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+                delay: S.optional<S.SchemaClass<number, number, never>>;
+            }>>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Email]>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Queue]>;
+            queue: S.refine<string, typeof S.NonEmptyString>;
+        }>>]>>;
+        readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
+    }, import("@dxos/echo-schema").TypedObjectOptions>> & import("@dxos/echo-schema").WithMeta, S.Struct.Encoded<{
+        readonly function: S.optional<S.SchemaClass<string, string, never>>;
+        readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
+        readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Timer]>;
+            cron: S.SchemaClass<string, string, never>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Webhook]>;
+            method: S.optional<S.SchemaClass<string, string, never>>;
+            port: S.optional<S.SchemaClass<number, number, never>>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Subscription]>;
+            filter: S.Struct<{
+                type: S.optional<S.SchemaClass<string, string, never>>;
+                props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+            }>;
+            options: S.optional<S.Struct<{
+                deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
+                delay: S.optional<S.SchemaClass<number, number, never>>;
+            }>>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Email]>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Queue]>;
+            queue: S.refine<string, typeof S.NonEmptyString>;
+        }>>]>>;
+        readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
+    }>, never>>>>;
+}>;
+export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;
+export declare const FUNCTION_TYPES: (typeof FunctionTrigger | typeof FunctionDef)[];
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/types/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuC,CAAC,EAAoB,MAAM,mBAAmB,CAAC;AAE7F;;;;GAIG;AACH,oBAAY,WAAW;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAKD;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;GAMN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,kBAAkB;;GAEN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,kBAAkB;;;GAGN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;GAaR,CAAC;AAEnB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAQxE;;GAEG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;GAYb,CAAC;AAEnB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;KAQxB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAchC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAGL;CAAG;;;;;;;;;;;;AAEnC;;;GAGG;AAEH,qBAAa,WAAY,SAAQ,gBAQ/B;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,cAAc,iDAAiC,CAAC"}

package/dist/types/src/{url.d.ts → types/url.d.ts}

@@ -3,12 +3,6 @@ import { type SpaceId } from '@dxos/keys';
 export declare const FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
 export declare const getUserFunctionUrlInMetadata: (meta: ObjectMeta) => string | undefined;
 export declare const setUserFunctionUrlInMetadata: (meta: ObjectMeta, functionUrl: string) => void;
-/**
- * NOTE: functionId is backend ID, not ECHO object id.
- */
-export declare const makeFunctionUrl: (fn: {
-    functionId: string;
-}) => string;
 export declare const getInvocationUrl: (functionUrl: string, edgeUrl: string, options?: InvocationOptions) => string;
 export type InvocationOptions = {
     spaceId?: SpaceId;

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

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../../src/types/url.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAK1C,eAAO,MAAM,yBAAyB,qCAAqC,CAAC;AAM5E,eAAO,MAAM,4BAA4B,SAAU,UAAU,uBAE5D,CAAC;AAEF,eAAO,MAAM,4BAA4B,SAAU,UAAU,eAAe,MAAM,SASjF,CAAC;AAEF,eAAO,MAAM,gBAAgB,gBAAiB,MAAM,WAAW,MAAM,YAAW,iBAAiB,WAUhG,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/types/tools/schema.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/types/tools/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../tools/schema.ts"],"names":[],"mappings":""}

package/dist/types/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"version":"5.8.3"}
+{"version":"5.7.3"}