@dxos/functions 0.7.5-main.499c70c → 0.7.5-main.5ae2ba8

package/src/bundler/bundler.test.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+// @ts-ignore
+import wasmUrl from 'esbuild-wasm/esbuild.wasm?url';
+import { beforeAll, describe, expect, test } from 'vitest';
+
+import { isNode } from '@dxos/util';
+
+import { Bundler, initializeBundler } from './bundler';
+
+describe('Bundler', () => {
+  beforeAll(async () => {
+    if (!isNode()) {
+      await initializeBundler({ wasmUrl });
+    }
+  });
+
+  test('Basic', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({ source: 'const x = 100' }); // TODO(burdon): Test import.
+    expect(result.bundle).to.exist;
+    expect(result.error).to.not.exist;
+  });
+
+  test('Import', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({
+      source: `
+      import { Filter } from './runtime.js';
+
+      const query = Filter.typename('dxos.org/type/Example');
+    `,
+    });
+    expect(result.bundle).to.exist;
+    expect(result.error).to.not.exist;
+  });
+
+  // TODO(dmaretskyi): Flaky on CI: https://cloud.nx.app/runs/Hjcifa8Ccq/task/plugin-script%3Atest
+  test.skip('HTTPS Import', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({
+      source: `
+      import { invariant } from 'https://esm.sh/@dxos/invariant';
+      invariant(true);
+    `,
+    });
+    expect(result.bundle).to.exist;
+    expect(result.error).to.not.exist;
+  });
+
+  test('Error', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({ source: "import missing from './module'; missing();" });
+    expect(result.bundle).to.not.exist;
+    expect(result.error).to.exist;
+  });
+});

package/src/bundler/bundler.ts

@@ -0,0 +1,264 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type BuildOptions } from 'esbuild';
+import { build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
+
+import { subtleCrypto } from '@dxos/crypto';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+
+export type Import = {
+  moduleUrl: string;
+  defaultImport: boolean;
+  namedImports: string[];
+};
+
+export type BundleOptions = {
+  /**
+   * Path to the source file on the local file system.
+   * If provided, the path will be used instead of the `source` code.
+   */
+  path?: string;
+
+  /**
+   * Source code to bundle.
+   * Required if `path` is not provided.
+   */
+  source?: string;
+};
+
+export type BundleResult = {
+  timestamp: number;
+  sourceHash?: Buffer;
+  imports?: Import[];
+  bundle?: string;
+  error?: any;
+};
+
+export type BundlerOptions = {
+  platform: BuildOptions['platform'];
+  sandboxedModules: string[];
+  remoteModules: Record<string, string>;
+};
+
+let initialized: Promise<void>;
+export const initializeBundler = async (options: { wasmUrl: string }) => {
+  await (initialized ??= initialize({
+    wasmURL: options.wasmUrl,
+  }));
+};
+
+/**
+ * ESBuild bundler.
+ */
+export class Bundler {
+  constructor(private readonly _options: BundlerOptions) {}
+
+  async bundle({ path, source }: BundleOptions): Promise<BundleResult> {
+    const { sandboxedModules: providedModules, ...options } = this._options;
+
+    const createResult = async (result?: Partial<BundleResult>) => {
+      return {
+        timestamp: Date.now(),
+        sourceHash: source ? Buffer.from(await subtleCrypto.digest('SHA-256', Buffer.from(source))) : undefined,
+        ...result,
+      };
+    };
+
+    if (this._options.platform === 'browser') {
+      invariant(initialized, 'Compiler not initialized.');
+      await initialized;
+    }
+
+    const imports = source ? analyzeSourceFileImports(source) : [];
+
+    // https://esbuild.github.io/api/#build
+    try {
+      const result = await build({
+        platform: options.platform,
+        conditions: ['workerd', 'browser'],
+        metafile: true,
+        write: false,
+        entryPoints: [path ?? 'memory:main.tsx'],
+        bundle: true,
+        format: 'esm',
+        plugins: [
+          {
+            name: 'memory',
+            setup: (build) => {
+              build.onResolve({ filter: /^\.\/runtime\.js$/ }, ({ path }) => {
+                return { path, external: true };
+              });
+
+              build.onResolve({ filter: /^dxos:functions$/ }, ({ path }) => {
+                return { path: './runtime.js', external: true };
+              });
+
+              build.onResolve({ filter: /^memory:/ }, ({ path }) => {
+                return { path: path.split(':')[1], namespace: 'memory' };
+              });
+
+              build.onLoad({ filter: /.*/, namespace: 'memory' }, ({ path }) => {
+                if (path === 'main.tsx') {
+                  return {
+                    contents: source,
+                    loader: 'tsx',
+                  };
+                }
+              });
+
+              for (const module of providedModules) {
+                build.onResolve({ filter: new RegExp(`^${module}$`) }, ({ path }) => {
+                  return { path, namespace: 'injected-module' };
+                });
+              }
+
+              build.onLoad({ filter: /.*/, namespace: 'injected-module' }, ({ path }) => {
+                const namedImports = imports.find((entry) => entry.moduleIdentifier === path)?.namedImports ?? [];
+                return {
+                  contents: `
+                  const { ${namedImports.join(',')} } = window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}];
+                  export { ${namedImports.join(',')} };
+                  export default window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}].default;
+                `,
+                  loader: 'tsx',
+                };
+              });
+            },
+          },
+          httpPlugin,
+        ],
+      });
+
+      log('compile complete', result.metafile);
+
+      return await createResult({
+        imports: this.analyzeImports(result),
+        bundle: result.outputFiles![0].text,
+      });
+    } catch (err) {
+      return await createResult({ error: err });
+    }
+  }
+
+  // TODO(dmaretskyi): In the future we can replace the compiler with SWC with plugins running in WASM.
+  analyzeImports(result: BuildResult): Import[] {
+    invariant(result.outputFiles);
+
+    // TODO(dmaretskyi): Support import aliases and wildcard imports.
+    const parsedImports = allMatches(IMPORT_REGEX, result.outputFiles[0].text);
+    return Object.values(result.metafile!.outputs)[0].imports.map((entry): Import => {
+      const namedImports: string[] = [];
+
+      const parsedImport = parsedImports.find((capture) => capture?.[4] === entry.path);
+      if (parsedImport?.[2]) {
+        NAMED_IMPORTS_REGEX.lastIndex = 0;
+        const namedImportsMatch = NAMED_IMPORTS_REGEX.exec(parsedImport[2]);
+        if (namedImportsMatch) {
+          namedImportsMatch[1].split(',').forEach((importName) => {
+            namedImports.push(importName.trim());
+          });
+        }
+      }
+
+      return {
+        moduleUrl: entry.path,
+        defaultImport: !!parsedImport?.[1],
+        namedImports,
+      };
+    });
+  }
+
+  analyzeSourceFileImports(code: string) {
+    // TODO(dmaretskyi): Support import aliases and wildcard imports.
+    const parsedImports = allMatches(IMPORT_REGEX, code);
+    return parsedImports.map((capture) => {
+      return {
+        defaultImportName: capture[1],
+        namedImports: capture[2]?.split(',').map((importName) => importName.trim()),
+        wildcardImportName: capture[3],
+        moduleIdentifier: capture[4],
+        quotes: capture[5],
+      };
+    });
+  }
+}
+
+// https://regex101.com/r/FEN5ks/1
+// https://stackoverflow.com/a/73265022
+// $1 = default import name (can be non-existent)
+// $2 = destructured exports (can be non-existent)
+// $3 = wildcard import name (can be non-existent)
+// $4 = module identifier
+// $5 = quotes used (either ' or ")
+const IMPORT_REGEX =
+  /import(?:(?:(?:[ \n\t]+([^ *\n\t{},]+)[ \n\t]*(?:,|[ \n\t]+))?([ \n\t]*{(?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+})?[ \n\t]*)|[ \n\t]*\*[ \n\t]*as[ \n\t]+([^ \n\t{}]+)[ \n\t]+)from[ \n\t]*(?:['"])([^'"\n]+)(['"])/gm;
+
+const NAMED_IMPORTS_REGEX = /[ \n\t]*{((?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+)}[ \n\t]*/gm;
+
+const allMatches = (regex: RegExp, str: string) => {
+  regex.lastIndex = 0;
+
+  let match;
+  const matches = [];
+  while ((match = regex.exec(str))) {
+    matches.push(match);
+  }
+
+  return matches;
+};
+
+type ParsedImport = {
+  defaultImportName?: string;
+  namedImports: string[];
+  wildcardImportName?: string;
+  moduleIdentifier: string;
+  quotes: string;
+};
+
+const analyzeSourceFileImports = (code: string): ParsedImport[] => {
+  // TODO(dmaretskyi): Support import aliases and wildcard imports.
+  const parsedImports = allMatches(IMPORT_REGEX, code);
+  return parsedImports.map((capture) => {
+    return {
+      defaultImportName: capture[1],
+      namedImports: capture[2]
+        ?.trim()
+        .slice(1, -1)
+        .split(',')
+        .map((importName) => importName.trim()),
+      wildcardImportName: capture[3],
+      moduleIdentifier: capture[4],
+      quotes: capture[5],
+    };
+  });
+};
+
+const httpPlugin: Plugin = {
+  name: 'http',
+  setup: (build) => {
+    // Intercept import paths starting with "http:" and "https:" so esbuild doesn't attempt to map them to a file system location.
+    // Tag them with the "http-url" namespace to associate them with this plugin.
+    build.onResolve({ filter: /^https?:\/\// }, (args) => ({
+      path: args.path,
+      namespace: 'http-url',
+    }));
+
+    // We also want to intercept all import paths inside downloaded files and resolve them against the original URL.
+    // All of these files will be in the "http-url" namespace.
+    // Make sure to keep the newly resolved URL in the "http-url" namespace so imports inside it will also be resolved as URLs recursively.
+    build.onResolve({ filter: /.*/, namespace: 'http-url' }, (args) => ({
+      path: new URL(args.path, args.importer).toString(),
+      namespace: 'http-url',
+    }));
+
+    // When a URL is loaded, we want to actually download the content from the internet.
+    // This has just enough logic to be able to handle the example import from unpkg.com but in reality this would probably need to be more complex.
+    build.onLoad({ filter: /.*/, namespace: 'http-url' }, async (args) => {
+      const response = await fetch(args.path);
+      return { contents: await response.text(), loader: 'jsx' };
+    });
+  },
+};

package/src/bundler/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './bundler';

package/src/edge/functions.ts

@@ -75,10 +75,14 @@ export const getInvocationUrl = (functionUrl: string, edgeUrl: string, options:
   const url = new URL(`./${relativeUrl}`, baseUrl.toString());
   options.spaceId && url.searchParams.set('spaceId', options.spaceId);
   options.subjectId && url.searchParams.set('subjectId', options.subjectId);
-  url.protocol = 'https';
+  url.protocol = isSecure(url.protocol) ? 'https' : 'http';
   return url.toString();
 };
 
+const isSecure = (protocol: string) => {
+  return protocol === 'https:' || protocol === 'wss:';
+};
+
 const createEdgeIdentity = (client: Client): EdgeIdentity => {
   const identity = client.halo.identity.get();
   const device = client.halo.device;

package/src/handler.ts

@@ -2,13 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Schema as S } from '@effect/schema';
+import { Schema as S } from '@effect/schema';
+import { type Effect } from 'effect';
 
 import { type Client, PublicKey } from '@dxos/client';
 import { type Space, type SpaceId } from '@dxos/client/echo';
-import type { CoreDatabase, ReactiveEchoObject } from '@dxos/echo-db';
+import type { CoreDatabase, EchoDatabase, QueryResult, ReactiveEchoObject } from '@dxos/echo-db';
+import { type HasId } from '@dxos/echo-schema';
+import { type DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { nonNullable } from '@dxos/util';
+import { isNonNullable } from '@dxos/util';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
@@ -18,15 +21,14 @@ import { nonNullable } from '@dxos/util';
 /**
  * Function handler.
  */
-export type FunctionHandler<TData = {}, TMeta = {}> = (params: {
+export type FunctionHandler<TData = {}, TMeta = {}, TOutput = any> = (params: {
   context: FunctionContext;
   event: FunctionEvent<TData, TMeta>;
-
   /**
    * @deprecated
    */
   response: FunctionResponse;
-}) => Promise<Response | FunctionResponse | void>;
+}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any>;
 
 /**
  * Function context.
@@ -61,6 +63,7 @@ export interface FunctionContextAi {
 /**
  * Event payload.
  */
+// TODO(dmaretskyi): Update type definitions to match the actual payload.
 export type FunctionEvent<TData = {}, TMeta = {}> = {
   data: FunctionEventMeta<TMeta> & TData;
 };
@@ -83,17 +86,61 @@ export type FunctionResponse = {
 // API.
 //
 
+// TODO(dmaretskyi): Temporary API to get the queues working.
+// TODO(dmaretskyi): To be replaced with integrating queues into echo.
+export interface QueuesAPI {
+  queryQueue(queue: DXN, options?: {}): Promise<QueryResult>;
+  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void>;
+}
+
 /**
  * Space interface available to functions.
  */
 export interface SpaceAPI {
   get id(): SpaceId;
+  /**
+   * @deprecated
+   */
   get crud(): CoreDatabase;
+  get db(): EchoDatabase;
+  // TODO(dmaretskyi): Align with echo api --- queues.get(id).append(items);
+  get queues(): QueuesAPI;
 }
 
+// TODO(wittjosiah): Fix this.
 const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
-  // eslint-disable-next-line unused-imports/no-unused-vars
-  const y: SpaceAPI = {} as Space;
+  // const _: SpaceAPI = {} as Space;
+};
+
+export type FunctionDefinition = {
+  description?: string;
+  inputSchema: S.Schema.AnyNoContext;
+  outputSchema?: S.Schema.AnyNoContext;
+  handler: FunctionHandler<any>;
+};
+
+export type DefineFunctionParams<T, O = any> = {
+  description?: string;
+  inputSchema: S.Schema<T, any>;
+  outputSchema?: S.Schema<O, any>;
+  handler: FunctionHandler<T, any, O>;
+};
+
+// TODO(dmaretskyi): Bind input type to function handler.
+export const defineFunction = <T, O>(params: DefineFunctionParams<T, O>): FunctionDefinition => {
+  if (!S.isSchema(params.inputSchema)) {
+    throw new Error('Input schema must be a valid schema');
+  }
+  if (typeof params.handler !== 'function') {
+    throw new Error('Handler must be a function');
+  }
+
+  return {
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema ?? S.Any,
+    handler: params.handler,
+  };
 };
 
 //
@@ -135,7 +182,9 @@ export const subscriptionHandler = <TMeta>(
 
     registerTypes(space, types);
     const objects = space
-      ? data.objects?.map<ReactiveEchoObject<any> | undefined>((id) => space!.db.getObjectById(id)).filter(nonNullable)
+      ? data.objects
+          ?.map<ReactiveEchoObject<any> | undefined>((id) => space!.db.getObjectById(id))
+          .filter(isNonNullable)
       : [];
 
     if (!!data.spaceKey && !space) {

package/src/trigger/trigger-registry.test.ts

@@ -236,7 +236,9 @@ describe('trigger registry', () => {
       const triggers = createTriggers(space, 3);
 
       const triggerLoaded = new Trigger();
-      registry.registered.on((fn) => triggerLoaded.wake());
+      registry.registered.on(() => {
+        triggerLoaded.wake();
+      });
 
       const triggerRemoved = new Trigger<FunctionTrigger>();
       registry.removed.on((fn) => {

package/src/types/index.ts

@@ -4,3 +4,4 @@
 
 export * from './schema';
 export * from './types';
+export * from './trace';

package/src/types/schema.ts

@@ -3,11 +3,7 @@
 //
 
 import { JsonSchemaType, Ref, S, TypedObject } from '@dxos/echo-schema';
-
-// TODO(burdon): Reconcile with plugin-markdown.
-export class TextType extends TypedObject({ typename: 'dxos.org/type/Text', version: '0.1.0' })({
-  content: S.String,
-}) {}
+import { TextType } from '@dxos/schema';
 
 /**
  * Source script.
@@ -16,7 +12,6 @@ export class ScriptType extends TypedObject({
   typename: 'dxos.org/type/Script',
   version: '0.1.0',
 })({
-  // TODO(burdon): Change to URI?
   name: S.optional(S.String),
   description: S.optional(S.String),
   // TODO(burdon): Change to hash of deployed content.
@@ -37,11 +32,14 @@ export class FunctionType extends TypedObject({
   name: S.NonEmptyString,
   version: S.String,
 
+  description: S.optional(S.String),
+
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
   source: S.optional(Ref(ScriptType)),
 
   inputSchema: S.optional(JsonSchemaType),
+  outputSchema: S.optional(JsonSchemaType),
 
   // Local binding to a function name.
   binding: S.optional(S.String),

package/src/types/trace.ts

@@ -0,0 +1,49 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { EchoObject, Expando, ObjectId, Ref, S } from '@dxos/echo-schema';
+
+import { FunctionTrigger } from './types';
+
+const InvocationTrace = S.Struct({
+  id: ObjectId,
+  /**
+   * Queue DXN for function/workflow invocation events.
+   */
+  invocationTraceQueue: Ref(Expando),
+  /**
+   * DXN of the invoked function/workflow.
+   */
+  invocationTarget: Ref(Expando),
+  /**
+   * Present for automatic invocations.
+   */
+  trigger: S.optional(Ref(FunctionTrigger)),
+}).pipe(EchoObject('dxos.org/type/InvocationTrace', '0.1.0'));
+
+export type InvocationTraceEvent = S.Schema.Type<typeof InvocationTrace>;
+
+const TraceEventLog = S.Struct({
+  timestampMs: S.Number,
+  level: S.String,
+  message: S.String,
+  context: S.optional(S.Object),
+});
+
+const TraceEventException = S.Struct({
+  timestampMs: S.Number,
+  message: S.String,
+  name: S.String,
+  stack: S.optional(S.String),
+});
+
+const TraceEvent = S.Struct({
+  id: ObjectId,
+  outcome: S.String,
+  truncated: S.Boolean,
+  logs: S.Array(TraceEventLog),
+  exceptions: S.Array(TraceEventException),
+}).pipe(EchoObject('dxos.org/type/TraceEvent', '0.1.0'));
+
+export type TraceEvent = S.Schema.Type<typeof TraceEvent>;

package/src/types/types.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { AST, OptionsAnnotationId, RawObject, S, TypedObject } from '@dxos/echo-schema';
+import { AST, OptionsAnnotationId, RawObject, S, TypedObject, DXN } from '@dxos/echo-schema';
 
 /**
  * Type discriminator for TriggerType.
@@ -13,6 +13,8 @@ export enum TriggerKind {
   Timer = 'timer',
   Webhook = 'webhook',
   Subscription = 'subscription',
+  Email = 'email',
+  Queue = 'queue',
 }
 
 // TODO(burdon): Rename prop kind.
@@ -31,6 +33,19 @@ const TimerTriggerSchema = S.Struct({
 
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 
+const EmailTriggerSchema = S.Struct({
+  type: S.Literal(TriggerKind.Email).annotations(typeLiteralAnnotations),
+}).pipe(S.mutable);
+
+export type EmailTrigger = S.Schema.Type<typeof EmailTriggerSchema>;
+
+const QueueTriggerSchema = S.Struct({
+  type: S.Literal(TriggerKind.Queue).annotations(typeLiteralAnnotations),
+  queue: DXN,
+}).pipe(S.mutable);
+
+export type QueueTrigger = S.Schema.Type<typeof QueueTriggerSchema>;
+
 /**
  * Webhook.
  */
@@ -80,10 +95,11 @@ export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema
  * Trigger schema (discriminated union).
  */
 export const TriggerSchema = S.Union(
-  //
   TimerTriggerSchema,
   WebhookTriggerSchema,
   SubscriptionTriggerSchema,
+  EmailTriggerSchema,
+  QueueTriggerSchema,
 ).annotations({
   [AST.TitleAnnotationId]: 'Trigger',
 });
@@ -95,6 +111,7 @@ export type TriggerType = S.Schema.Type<typeof TriggerSchema>;
  */
 export const FunctionTriggerSchema = S.Struct({
   // TODO(burdon): What type does this reference.
+  // TODO(wittjosiah): This should probably be a Ref?
   function: S.optional(S.String.annotations({ [AST.TitleAnnotationId]: 'Function' })),
 
   enabled: S.optional(S.Boolean.annotations({ [AST.TitleAnnotationId]: 'Enabled' })),

package/dist/lib/browser/chunk-PKOLPTSC.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types/schema.ts", "../../../src/types/types.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { JsonSchemaType, Ref, S, TypedObject } from '@dxos/echo-schema';\n\n// TODO(burdon): Reconcile with plugin-markdown.\nexport class TextType extends TypedObject({ typename: 'dxos.org/type/Text', version: '0.1.0' })({\n  content: S.String,\n}) {}\n\n/**\n * Source script.\n */\nexport class ScriptType extends TypedObject({\n  typename: 'dxos.org/type/Script',\n  version: '0.1.0',\n})({\n  // TODO(burdon): Change to URI?\n  name: S.optional(S.String),\n  description: S.optional(S.String),\n  // TODO(burdon): Change to hash of deployed content.\n  // Whether source has changed since last deploy.\n  changed: S.optional(S.Boolean),\n  source: Ref(TextType),\n}) {}\n\n/**\n * Function deployment.\n */\n// TODO(burdon): Move to core/functions.\nexport class FunctionType extends TypedObject({\n  typename: 'dxos.org/type/Function',\n  version: '0.1.0',\n})({\n  // TODO(burdon): Rename to id/uri?\n  name: S.NonEmptyString,\n  version: S.String,\n\n  // Reference to a source script if it exists within ECHO.\n  // TODO(burdon): Don't ref ScriptType directly (core).\n  source: S.optional(Ref(ScriptType)),\n\n  inputSchema: S.optional(JsonSchemaType),\n\n  // Local binding to a function name.\n  binding: S.optional(S.String),\n}) {}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { AST, OptionsAnnotationId, RawObject, S, TypedObject } from '@dxos/echo-schema';\n\n/**\n * Type discriminator for TriggerType.\n * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.\n * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions\n */\nexport enum TriggerKind {\n  Timer = 'timer',\n  Webhook = 'webhook',\n  Subscription = 'subscription',\n}\n\n// TODO(burdon): Rename prop kind.\nconst typeLiteralAnnotations = { [AST.TitleAnnotationId]: 'Type' };\n\n/**\n * Cron timer.\n */\nconst TimerTriggerSchema = S.Struct({\n  type: S.Literal(TriggerKind.Timer).annotations(typeLiteralAnnotations),\n  cron: S.String.annotations({\n    [AST.TitleAnnotationId]: 'Cron',\n    [AST.ExamplesAnnotationId]: ['0 0 * * *'],\n  }),\n}).pipe(S.mutable);\n\nexport type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;\n\n/**\n * Webhook.\n */\nconst WebhookTriggerSchema = S.Struct({\n  type: S.Literal(TriggerKind.Webhook).annotations(typeLiteralAnnotations),\n  method: S.optional(\n    S.String.annotations({\n      [AST.TitleAnnotationId]: 'Method',\n      [OptionsAnnotationId]: ['GET', 'POST'],\n    }),\n  ),\n  port: S.optional(\n    S.Number.annotations({\n      [AST.TitleAnnotationId]: 'Port',\n    }),\n  ),\n}).pipe(S.mutable);\n\nexport type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;\n\n// TODO(burdon): Use ECHO definition (from https://github.com/dxos/dxos/pull/8233).\nconst QuerySchema = S.Struct({\n  type: S.optional(S.String.annotations({ [AST.TitleAnnotationId]: 'Type' })),\n  props: S.optional(S.Record({ key: S.String, value: S.Any })),\n}).annotations({ [AST.TitleAnnotationId]: 'Query' });\n\n/**\n * Subscription.\n */\nconst SubscriptionTriggerSchema = S.Struct({\n  type: S.Literal(TriggerKind.Subscription).annotations(typeLiteralAnnotations),\n  // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.\n  filter: QuerySchema,\n  options: S.optional(\n    S.Struct({\n      // Watch changes to object (not just creation).\n      deep: S.optional(S.Boolean.annotations({ [AST.TitleAnnotationId]: 'Nested' })),\n      // Debounce changes (delay in ms).\n      delay: S.optional(S.Number.annotations({ [AST.TitleAnnotationId]: 'Delay' })),\n    }).annotations({ [AST.TitleAnnotationId]: 'Options' }),\n  ),\n}).pipe(S.mutable);\n\nexport type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;\n\n/**\n * Trigger schema (discriminated union).\n */\nexport const TriggerSchema = S.Union(\n  //\n  TimerTriggerSchema,\n  WebhookTriggerSchema,\n  SubscriptionTriggerSchema,\n).annotations({\n  [AST.TitleAnnotationId]: 'Trigger',\n});\n\nexport type TriggerType = S.Schema.Type<typeof TriggerSchema>;\n\n/**\n * Function trigger.\n */\nexport const FunctionTriggerSchema = S.Struct({\n  // TODO(burdon): What type does this reference.\n  function: S.optional(S.String.annotations({ [AST.TitleAnnotationId]: 'Function' })),\n\n  enabled: S.optional(S.Boolean.annotations({ [AST.TitleAnnotationId]: 'Enabled' })),\n\n  // TODO(burdon): Flatten entire schema.\n  spec: S.optional(TriggerSchema),\n\n  // TODO(burdon): Get meta from function.\n  // The `meta` property is merged into the event data passed to the function.\n  meta: S.optional(S.mutable(S.Record({ key: S.String, value: S.Any }))),\n});\n\nexport type FunctionTriggerType = S.Schema.Type<typeof FunctionTriggerSchema>;\n\n/**\n * Function trigger.\n */\nexport class FunctionTrigger extends TypedObject({\n  typename: 'dxos.org/type/FunctionTrigger',\n  version: '0.1.0',\n})(FunctionTriggerSchema.fields) {}\n\n/**\n * Function definition.\n * @deprecated (Use dxos.org/type/Function)\n */\n// TODO(burdon): Reconcile with FunctionType.\nexport class FunctionDef extends TypedObject({\n  typename: 'dxos.org/type/FunctionDef',\n  version: '0.1.0',\n})({\n  uri: S.String,\n  description: S.optional(S.String),\n  route: S.String,\n  handler: S.String,\n}) {}\n\n/**\n * Function manifest file.\n */\nexport const FunctionManifestSchema = S.Struct({\n  functions: S.optional(S.mutable(S.Array(RawObject(FunctionDef)))),\n  triggers: S.optional(S.mutable(S.Array(RawObject(FunctionTrigger)))),\n});\n\nexport type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;\n\nexport const FUNCTION_TYPES = [FunctionDef, FunctionTrigger];\n"],
-  "mappings": "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",
-  "names": ["JsonSchemaType", "Ref", "S", "TypedObject", "TextType", "TypedObject", "typename", "version", "content", "S", "String", "ScriptType", "name", "optional", "description", "changed", "Boolean", "source", "Ref", "FunctionType", "NonEmptyString", "inputSchema", "JsonSchemaType", "binding", "AST", "OptionsAnnotationId", "RawObject", "S", "TypedObject", "TriggerKind", "typeLiteralAnnotations", "AST", "TitleAnnotationId", "TimerTriggerSchema", "S", "Struct", "type", "Literal", "annotations", "cron", "String", "ExamplesAnnotationId", "pipe", "mutable", "WebhookTriggerSchema", "method", "optional", "OptionsAnnotationId", "port", "Number", "QuerySchema", "props", "Record", "key", "value", "Any", "SubscriptionTriggerSchema", "filter", "options", "deep", "Boolean", "delay", "TriggerSchema", "Union", "FunctionTriggerSchema", "function", "enabled", "spec", "meta", "FunctionTrigger", "TypedObject", "typename", "version", "fields", "FunctionDef", "uri", "description", "route", "handler", "FunctionManifestSchema", "functions", "Array", "RawObject", "triggers", "FUNCTION_TYPES"]
-}