@dxos/functions-runtime-cloudflare 0.8.4-main.1068cf700f

package/src/space-proxy.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { Resource } from '@dxos/context';
+import { type Database } from '@dxos/echo';
+import { type CoreDatabase, type EchoClient, type EchoDatabaseImpl } from '@dxos/echo-db';
+import { invariant } from '@dxos/invariant';
+import { PublicKey, type SpaceId } from '@dxos/keys';
+
+import type { ServiceContainer } from './internal';
+import { type QueuesAPI, QueuesAPIImpl } from './queues-api';
+
+/**
+ * @deprecated
+ */
+export class SpaceProxy extends Resource {
+  private _db?: EchoDatabaseImpl = undefined;
+  private _queuesApi: QueuesAPIImpl;
+
+  constructor(
+    private readonly _serviceContainer: ServiceContainer,
+    private readonly _echoClient: EchoClient,
+    private readonly _id: SpaceId,
+  ) {
+    super();
+    this._queuesApi = new QueuesAPIImpl(this._serviceContainer, this._id);
+  }
+
+  get id(): SpaceId {
+    return this._id;
+  }
+
+  get db(): Database.Database {
+    invariant(this._db);
+    return this._db;
+  }
+
+  /**
+   * @deprecated Use db API.
+   */
+  get crud(): CoreDatabase {
+    invariant(this._db);
+    return this._db.coreDatabase;
+  }
+
+  get queues(): QueuesAPI {
+    return this._queuesApi;
+  }
+
+  protected override async _open() {
+    const meta = await this._serviceContainer.getSpaceMeta(this._id);
+    if (!meta) {
+      throw new Error(`Space not found: ${this._id}`);
+    }
+
+    this._db = this._echoClient.constructDatabase({
+      spaceId: this._id,
+      spaceKey: PublicKey.from(meta.spaceKey),
+      reactiveSchemaQuery: false,
+      owningObject: this,
+    });
+
+    await this._db.coreDatabase.open({ rootUrl: meta.rootDocumentId });
+  }
+}

package/src/types.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type { JsonSchemaType } from '@dxos/echo/internal';
+
+/**
+ * Is used for to route the request to the metadata handler instead of the main handler.
+ */
+export const FUNCTION_ROUTE_HEADER = 'X-DXOS-Function-Route';
+
+export enum FunctionRouteValue {
+  Meta = 'meta',
+}
+
+export type FunctionMetadata = {
+  /**
+   * FQN.
+   */
+  key: string;
+  /**
+   * Human-readable name.
+   */
+  name?: string;
+
+  /**
+   * Description.
+   */
+  description?: string;
+
+  /**
+   * Input schema.
+   */
+  inputSchema?: JsonSchemaType;
+
+  /**
+   * Output schema.
+   */
+  outputSchema?: JsonSchemaType;
+};

package/src/wrap-handler-for-cloudflare.ts

@@ -0,0 +1,132 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import type { JsonSchemaType } from '@dxos/echo/internal';
+import { invariant } from '@dxos/invariant';
+import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { EdgeResponse } from '@dxos/protocols';
+import type { EdgeFunctionEnv, FunctionProtocol } from '@dxos/protocols';
+
+import { ServiceContainer } from './internal';
+import { FUNCTION_ROUTE_HEADER, type FunctionMetadata, FunctionRouteValue } from './types';
+
+/**
+ * Wraps a user function in a Cloudflare-compatible handler.
+ */
+export const wrapHandlerForCloudflare = (func: FunctionProtocol.Func): ExportedHandlerFetchHandler<any> => {
+  return async (request: Request, env: EdgeFunctionEnv.Env): Promise<Response> => {
+    // TODO(dmaretskyi): Should theÓ scope name reflect the function name?
+    // TODO(mykola): Wrap in withCleanAutomergeWasmState;
+    // TODO(mykola): Wrap in withNewExecutionContext;
+    // Meta route is used to get the input schema of the function by the functions service.
+    if (request.headers.get(FUNCTION_ROUTE_HEADER) === FunctionRouteValue.Meta) {
+      return handleFunctionMetaCall(func, request);
+    }
+
+    try {
+      const spaceId = new URL(request.url).searchParams.get('spaceId');
+      if (spaceId) {
+        if (!SpaceId.isValid(spaceId)) {
+          return new Response('Invalid spaceId', { status: 400 });
+        }
+      }
+
+      const serviceContainer = new ServiceContainer({}, env.DATA_SERVICE, env.QUEUE_SERVICE, env.FUNCTIONS_AI_SERVICE);
+      const context = await createFunctionContext({
+        serviceContainer,
+        contextSpaceId: spaceId as SpaceId | undefined,
+      });
+
+      return EdgeResponse.success(await invokeFunction(func, context, request));
+    } catch (error: any) {
+      log.error('error invoking function', { error, stack: error.stack });
+      return EdgeResponse.failure({
+        message: error?.message ?? 'Internal error',
+        error,
+      });
+    }
+  };
+};
+
+const invokeFunction = async (func: FunctionProtocol.Func, context: FunctionProtocol.Context, request: Request) => {
+  // TODO(dmaretskyi): For some reason requests get wrapped like this.
+  const { data } = await decodeRequest(request);
+
+  return func.handler({
+    context,
+    data,
+  });
+};
+
+const decodeRequest = async (request: Request) => {
+  const {
+    data: { bodyText, ...rest },
+    trigger,
+  } = (await request.json()) as any;
+
+  if (!bodyText) {
+    return { data: rest, trigger };
+  }
+
+  // Webhook passed body as bodyText. Use it as function input if a well-formatted JSON
+  // TODO: better trigger input mapping
+  try {
+    const data = JSON.parse(bodyText);
+    return { data, trigger: { ...trigger, ...rest } };
+  } catch (err) {
+    log.catch(err);
+    return { data: { bodyText, ...rest } };
+  }
+};
+
+const handleFunctionMetaCall = (functionDefinition: FunctionProtocol.Func, request: Request): Response => {
+  const response: FunctionMetadata = {
+    key: functionDefinition.meta.key,
+    name: functionDefinition.meta.name,
+    description: functionDefinition.meta.description,
+    inputSchema: functionDefinition.meta.inputSchema as JsonSchemaType | undefined,
+    outputSchema: functionDefinition.meta.outputSchema as JsonSchemaType | undefined,
+  };
+
+  return new Response(JSON.stringify(response), {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+};
+
+const createFunctionContext = async ({
+  serviceContainer,
+  contextSpaceId,
+}: {
+  serviceContainer: ServiceContainer;
+  contextSpaceId: SpaceId | undefined;
+}): Promise<FunctionProtocol.Context> => {
+  const { dataService, queryService, queueService, functionsAiService } = await serviceContainer.createServices();
+
+  let spaceKey: string | undefined;
+  let rootUrl: string | undefined;
+  if (contextSpaceId) {
+    const meta = await serviceContainer.getSpaceMeta(contextSpaceId);
+    if (!meta) {
+      throw new Error(`Space not found: ${contextSpaceId}`);
+    }
+    spaceKey = meta.spaceKey;
+    invariant(!meta.rootDocumentId.startsWith('automerge:'));
+    rootUrl = `automerge:${meta.rootDocumentId}`;
+  }
+
+  return {
+    services: {
+      dataService,
+      queryService,
+      queueService,
+      functionsAiService,
+    },
+    spaceId: contextSpaceId,
+    spaceKey,
+    spaceRootUrl: rootUrl,
+  } as any; // TODO(dmaretskyi): Link and fix before merging
+};