@dxos/functions-runtime-cloudflare 0.8.4-main.3c1ae3b

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,754 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/functions-client.ts
+import { Resource as Resource2 } from "@dxos/context";
+import { EchoClient } from "@dxos/echo-db";
+import { invariant as invariant5 } from "@dxos/invariant";
+
+// src/internal/data-service-impl.ts
+import { Stream } from "@dxos/codec-protobuf/stream";
+import { raise } from "@dxos/debug";
+import { NotImplementedError, RuntimeServiceError } from "@dxos/errors";
+import { invariant } from "@dxos/invariant";
+import { SpaceId } from "@dxos/keys";
+import { log } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/internal/data-service-impl.ts";
+var DataServiceImpl = class {
+  _executionContext;
+  _dataService;
+  dataSubscriptions = /* @__PURE__ */ new Map();
+  constructor(_executionContext, _dataService) {
+    this._executionContext = _executionContext;
+    this._dataService = _dataService;
+  }
+  subscribe({ subscriptionId, spaceId }) {
+    return new Stream(({ next }) => {
+      invariant(SpaceId.isValid(spaceId), void 0, {
+        F: __dxlog_file,
+        L: 35,
+        S: this,
+        A: [
+          "SpaceId.isValid(spaceId)",
+          ""
+        ]
+      });
+      this.dataSubscriptions.set(subscriptionId, {
+        spaceId,
+        next
+      });
+      return () => {
+        this.dataSubscriptions.delete(subscriptionId);
+      };
+    });
+  }
+  async updateSubscription({ subscriptionId, addIds, removeIds }) {
+    const sub = this.dataSubscriptions.get(subscriptionId) ?? raise(new RuntimeServiceError({
+      message: "Subscription not found.",
+      context: {
+        subscriptionId
+      }
+    }));
+    if (addIds) {
+      log.info("request documents", {
+        count: addIds.length
+      }, {
+        F: __dxlog_file,
+        L: 55,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      for (const documentId of addIds) {
+        const document = await this._dataService.getDocument(this._executionContext, sub.spaceId, documentId);
+        log.info("document loaded", {
+          documentId,
+          spaceId: sub.spaceId,
+          found: !!document
+        }, {
+          F: __dxlog_file,
+          L: 59,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (!document) {
+          log.warn("not found", {
+            documentId
+          }, {
+            F: __dxlog_file,
+            L: 61,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          continue;
+        }
+        sub.next({
+          updates: [
+            {
+              documentId,
+              mutation: document.data
+            }
+          ]
+        });
+      }
+    }
+  }
+  async update({ updates, subscriptionId }) {
+    const sub = this.dataSubscriptions.get(subscriptionId) ?? raise(new RuntimeServiceError({
+      message: "Subscription not found.",
+      context: {
+        subscriptionId
+      }
+    }));
+    try {
+      for (const update of updates ?? []) {
+        await this._dataService.changeDocument(this._executionContext, sub.spaceId, update.documentId, update.mutation);
+      }
+    } catch (error) {
+      throw RuntimeServiceError.wrap({
+        message: "Failed to apply document updates.",
+        context: {
+          subscriptionId
+        },
+        ifTypeDiffers: true
+      })(error);
+    }
+  }
+  async flush() {
+  }
+  subscribeSpaceSyncState(request, options) {
+    throw new NotImplementedError({
+      message: "subscribeSpaceSyncState is not implemented."
+    });
+  }
+  async getDocumentHeads({ documentIds }) {
+    throw new NotImplementedError({
+      message: "getDocumentHeads is not implemented."
+    });
+  }
+  async reIndexHeads({ documentIds }) {
+    throw new NotImplementedError({
+      message: "reIndexHeads is not implemented."
+    });
+  }
+  async updateIndexes() {
+    throw new NotImplementedError({
+      message: "updateIndexes is not implemented."
+    });
+  }
+  async waitUntilHeadsReplicated({ heads }) {
+    throw new NotImplementedError({
+      message: "waitUntilHeadsReplicated is not implemented."
+    });
+  }
+};
+
+// src/internal/query-service-impl.ts
+import * as Schema from "effect/Schema";
+import { Stream as Stream2 } from "@dxos/codec-protobuf/stream";
+import { QueryAST } from "@dxos/echo-protocol";
+import { NotImplementedError as NotImplementedError2, RuntimeServiceError as RuntimeServiceError2 } from "@dxos/errors";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { PublicKey } from "@dxos/keys";
+import { SpaceId as SpaceId3 } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+
+// src/internal/adapter.ts
+import { failUndefined } from "@dxos/debug";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { SpaceId as SpaceId2 } from "@dxos/keys";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/internal/adapter.ts";
+var queryToDataServiceRequest = (query) => {
+  const { filter, options } = isSimpleSelectionQuery(query) ?? failUndefined();
+  invariant2(options?.spaceIds?.length === 1, "Only one space is supported", {
+    F: __dxlog_file2,
+    L: 13,
+    S: void 0,
+    A: [
+      "options?.spaceIds?.length === 1",
+      "'Only one space is supported'"
+    ]
+  });
+  invariant2(filter.type === "object", "Only object filters are supported", {
+    F: __dxlog_file2,
+    L: 14,
+    S: void 0,
+    A: [
+      "filter.type === 'object'",
+      "'Only object filters are supported'"
+    ]
+  });
+  const spaceId = options.spaceIds[0];
+  invariant2(SpaceId2.isValid(spaceId), void 0, {
+    F: __dxlog_file2,
+    L: 17,
+    S: void 0,
+    A: [
+      "SpaceId.isValid(spaceId)",
+      ""
+    ]
+  });
+  return {
+    spaceId,
+    type: filter.typename ?? void 0,
+    objectIds: [
+      ...filter.id ?? []
+    ]
+  };
+};
+var isSimpleSelectionQuery = (query) => {
+  switch (query.type) {
+    case "options": {
+      const maybeFilter = isSimpleSelectionQuery(query.query);
+      if (!maybeFilter) {
+        return null;
+      }
+      return {
+        filter: maybeFilter.filter,
+        options: query.options
+      };
+    }
+    case "select": {
+      return {
+        filter: query.filter,
+        options: void 0
+      };
+    }
+    default: {
+      return null;
+    }
+  }
+};
+
+// src/internal/query-service-impl.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/internal/query-service-impl.ts";
+var QueryServiceImpl = class {
+  _executionContext;
+  _dataService;
+  _queryCount = 0;
+  constructor(_executionContext, _dataService) {
+    this._executionContext = _executionContext;
+    this._dataService = _dataService;
+  }
+  execQuery(request) {
+    log2.info("execQuery", {
+      request
+    }, {
+      F: __dxlog_file3,
+      L: 33,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const query = QueryAST.Query.pipe(Schema.decodeUnknownSync)(JSON.parse(request.query));
+    const requestedSpaceIds = getTargetSpacesForQuery(query);
+    invariant3(requestedSpaceIds.length === 1, "Only one space is supported", {
+      F: __dxlog_file3,
+      L: 36,
+      S: this,
+      A: [
+        "requestedSpaceIds.length === 1",
+        "'Only one space is supported'"
+      ]
+    });
+    const spaceId = requestedSpaceIds[0];
+    return Stream2.fromPromise((async () => {
+      try {
+        this._queryCount++;
+        log2.info("begin query", {
+          spaceId
+        }, {
+          F: __dxlog_file3,
+          L: 43,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const queryResponse = await this._dataService.queryDocuments(this._executionContext, queryToDataServiceRequest(query));
+        log2.info("query response", {
+          spaceId,
+          filter: request.filter,
+          resultCount: queryResponse.results.length
+        }, {
+          F: __dxlog_file3,
+          L: 48,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return {
+          results: queryResponse.results.map((object) => ({
+            id: object.objectId,
+            spaceId,
+            spaceKey: PublicKey.ZERO,
+            documentId: object.document.documentId,
+            rank: 0,
+            documentAutomerge: object.document.data
+          }))
+        };
+      } catch (error) {
+        log2.error("query failed", {
+          err: error
+        }, {
+          F: __dxlog_file3,
+          L: 62,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        throw new RuntimeServiceError2({
+          message: `Query execution failed (queryCount=${this._queryCount})`,
+          context: {
+            spaceId,
+            filter: request.filter,
+            queryCount: this._queryCount
+          },
+          cause: error
+        });
+      }
+    })());
+  }
+  async reindex() {
+    throw new NotImplementedError2({
+      message: "Reindex is not implemented."
+    });
+  }
+  async setConfig() {
+    throw new NotImplementedError2({
+      message: "SetConfig is not implemented."
+    });
+  }
+};
+var getTargetSpacesForQuery = (query) => {
+  const spaces = /* @__PURE__ */ new Set();
+  const visitor = (node) => {
+    if (node.type === "options") {
+      if (node.options.spaceIds) {
+        for (const spaceId of node.options.spaceIds) {
+          spaces.add(SpaceId3.make(spaceId));
+        }
+      }
+    }
+  };
+  QueryAST.visit(query, visitor);
+  return [
+    ...spaces
+  ];
+};
+
+// src/internal/queue-service-impl.ts
+import { NotImplementedError as NotImplementedError3, RuntimeServiceError as RuntimeServiceError3 } from "@dxos/errors";
+var QueueServiceImpl = class {
+  _ctx;
+  _queueService;
+  constructor(_ctx, _queueService) {
+    this._ctx = _ctx;
+    this._queueService = _queueService;
+  }
+  async queryQueue(subspaceTag, spaceId, { queueId, ...query }) {
+    try {
+      const result = await this._queueService.query(this._ctx, `dxn:queue:${subspaceTag}:${spaceId}:${queueId}`, query);
+      return result;
+    } catch (error) {
+      throw RuntimeServiceError3.wrap({
+        message: "Queue query failed.",
+        context: {
+          subspaceTag,
+          spaceId,
+          queueId
+        },
+        ifTypeDiffers: true
+      })(error);
+    }
+  }
+  async insertIntoQueue(subspaceTag, spaceId, queueId, objects) {
+    try {
+      const result = await this._queueService.append(this._ctx, `dxn:queue:${subspaceTag}:${spaceId}:${queueId}`, objects);
+      return result;
+    } catch (error) {
+      throw RuntimeServiceError3.wrap({
+        message: "Queue append failed.",
+        context: {
+          subspaceTag,
+          spaceId,
+          queueId
+        },
+        ifTypeDiffers: true
+      })(error);
+    }
+  }
+  deleteFromQueue(subspaceTag, spaceId, queueId, _objectIds) {
+    throw new NotImplementedError3({
+      message: "Deleting from queue is not supported.",
+      context: {
+        subspaceTag,
+        spaceId,
+        queueId
+      }
+    });
+  }
+};
+
+// src/internal/service-container.ts
+var ServiceContainer = class {
+  _executionContext;
+  _dataService;
+  _queueService;
+  constructor(_executionContext, _dataService, _queueService) {
+    this._executionContext = _executionContext;
+    this._dataService = _dataService;
+    this._queueService = _queueService;
+  }
+  async getSpaceMeta(spaceId) {
+    return this._dataService.getSpaceMeta(this._executionContext, spaceId);
+  }
+  async createServices() {
+    const dataService = new DataServiceImpl(this._executionContext, this._dataService);
+    const queryService = new QueryServiceImpl(this._executionContext, this._dataService);
+    const queueService = new QueueServiceImpl(this._executionContext, this._queueService);
+    return {
+      dataService,
+      queryService,
+      queueService
+    };
+  }
+  queryQueue(queue) {
+    return this._queueService.query({}, queue.toString(), {});
+  }
+  insertIntoQueue(queue, objects) {
+    return this._queueService.append({}, queue.toString(), objects);
+  }
+};
+
+// src/space-proxy.ts
+import { Resource } from "@dxos/context";
+import { invariant as invariant4 } from "@dxos/invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+
+// src/queues-api.ts
+var QueuesAPIImpl = class {
+  _serviceContainer;
+  _spaceId;
+  constructor(_serviceContainer, _spaceId) {
+    this._serviceContainer = _serviceContainer;
+    this._spaceId = _spaceId;
+  }
+  queryQueue(queue, options) {
+    return this._serviceContainer.queryQueue(queue);
+  }
+  insertIntoQueue(queue, objects) {
+    return this._serviceContainer.insertIntoQueue(queue, JSON.parse(JSON.stringify(objects)));
+  }
+};
+
+// src/space-proxy.ts
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/space-proxy.ts";
+var SpaceProxy = class extends Resource {
+  _serviceContainer;
+  _echoClient;
+  _id;
+  _db = void 0;
+  _queuesApi;
+  constructor(_serviceContainer, _echoClient, _id) {
+    super(), this._serviceContainer = _serviceContainer, this._echoClient = _echoClient, this._id = _id;
+    this._queuesApi = new QueuesAPIImpl(this._serviceContainer, this._id);
+  }
+  get id() {
+    return this._id;
+  }
+  get db() {
+    invariant4(this._db, void 0, {
+      F: __dxlog_file4,
+      L: 34,
+      S: this,
+      A: [
+        "this._db",
+        ""
+      ]
+    });
+    return this._db;
+  }
+  /**
+  * @deprecated Use db API.
+  */
+  get crud() {
+    invariant4(this._db, void 0, {
+      F: __dxlog_file4,
+      L: 42,
+      S: this,
+      A: [
+        "this._db",
+        ""
+      ]
+    });
+    return this._db.coreDatabase;
+  }
+  get queues() {
+    return this._queuesApi;
+  }
+  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: PublicKey2.from(meta.spaceKey),
+      reactiveSchemaQuery: false,
+      owningObject: this
+    });
+    await this._db.coreDatabase.open({
+      rootUrl: meta.rootDocumentId
+    });
+  }
+};
+
+// src/functions-client.ts
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/functions-client.ts";
+var FunctionsClient = class extends Resource2 {
+  _serviceContainer;
+  _echoClient;
+  _executionContext = {};
+  _spaces = /* @__PURE__ */ new Map();
+  constructor(services) {
+    super();
+    invariant5(typeof services.dataService !== "undefined", "DataService is required", {
+      F: __dxlog_file5,
+      L: 32,
+      S: this,
+      A: [
+        "typeof services.dataService !== 'undefined'",
+        "'DataService is required'"
+      ]
+    });
+    invariant5(typeof services.queueService !== "undefined", "QueueService is required", {
+      F: __dxlog_file5,
+      L: 33,
+      S: this,
+      A: [
+        "typeof services.queueService !== 'undefined'",
+        "'QueueService is required'"
+      ]
+    });
+    this._serviceContainer = new ServiceContainer(this._executionContext, services.dataService, services.queueService);
+    this._echoClient = new EchoClient({});
+  }
+  get echo() {
+    return this._echoClient;
+  }
+  async _open() {
+    const { dataService, queryService } = await this._serviceContainer.createServices();
+    this._echoClient.connectToService({
+      dataService,
+      queryService
+    });
+    await this._echoClient.open();
+  }
+  async _close() {
+    for (const space of this._spaces.values()) {
+      await space.close();
+    }
+    this._spaces.clear();
+    await this._echoClient.close();
+  }
+  async getSpace(spaceId) {
+    if (!this._spaces.has(spaceId)) {
+      const space2 = new SpaceProxy(this._serviceContainer, this._echoClient, spaceId);
+      this._spaces.set(spaceId, space2);
+    }
+    const space = this._spaces.get(spaceId);
+    await space.open();
+    return space;
+  }
+};
+var createClientFromEnv = async (env) => {
+  const client = new FunctionsClient({
+    dataService: env.DATA_SERVICE,
+    queueService: env.QUEUE_SERVICE
+  });
+  await client.open();
+  return client;
+};
+
+// src/types.ts
+var FUNCTION_ROUTE_HEADER = "X-DXOS-Function-Route";
+var FunctionRouteValue = /* @__PURE__ */ (function(FunctionRouteValue2) {
+  FunctionRouteValue2["Meta"] = "meta";
+  return FunctionRouteValue2;
+})({});
+
+// src/wrap-handler-for-cloudflare.ts
+import { invariant as invariant6 } from "@dxos/invariant";
+import { SpaceId as SpaceId4 } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
+import { EdgeResponse } from "@dxos/protocols";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/wrap-handler-for-cloudflare.ts";
+var wrapHandlerForCloudflare = (func) => {
+  return async (request, env) => {
+    if (request.headers.get(FUNCTION_ROUTE_HEADER) === FunctionRouteValue.Meta) {
+      log3.info(">>> meta", {
+        func
+      }, {
+        F: __dxlog_file6,
+        L: 25,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return handleFunctionMetaCall(func, request);
+    }
+    try {
+      const spaceId = new URL(request.url).searchParams.get("spaceId");
+      if (spaceId) {
+        if (!SpaceId4.isValid(spaceId)) {
+          return new Response("Invalid spaceId", {
+            status: 400
+          });
+        }
+      }
+      const serviceContainer = new ServiceContainer({}, env.DATA_SERVICE, env.QUEUE_SERVICE);
+      const context = await createFunctionContext({
+        serviceContainer,
+        contextSpaceId: spaceId
+      });
+      return EdgeResponse.success(await invokeFunction(func, context, request));
+    } catch (error) {
+      log3.error("error invoking function", {
+        error,
+        stack: error.stack
+      }, {
+        F: __dxlog_file6,
+        L: 45,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      return EdgeResponse.failure({
+        message: error?.message ?? "Internal error",
+        error
+      });
+    }
+  };
+};
+var invokeFunction = async (func, context, request) => {
+  const { data } = await decodeRequest(request);
+  return func.handler({
+    context,
+    data
+  });
+};
+var decodeRequest = async (request) => {
+  const { data: { bodyText, ...rest }, trigger } = await request.json();
+  if (!bodyText) {
+    return {
+      data: rest,
+      trigger
+    };
+  }
+  try {
+    const data = JSON.parse(bodyText);
+    return {
+      data,
+      trigger: {
+        ...trigger,
+        ...rest
+      }
+    };
+  } catch (err) {
+    log3.catch(err, void 0, {
+      F: __dxlog_file6,
+      L: 80,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    return {
+      data: {
+        bodyText,
+        ...rest
+      }
+    };
+  }
+};
+var handleFunctionMetaCall = (functionDefinition, request) => {
+  const response = {
+    key: functionDefinition.meta.key,
+    name: functionDefinition.meta.name,
+    description: functionDefinition.meta.description,
+    inputSchema: functionDefinition.meta.inputSchema,
+    outputSchema: functionDefinition.meta.outputSchema
+  };
+  return new Response(JSON.stringify(response), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+var createFunctionContext = async ({ serviceContainer, contextSpaceId }) => {
+  const { dataService, queryService, queueService } = await serviceContainer.createServices();
+  let spaceKey;
+  let rootUrl;
+  if (contextSpaceId) {
+    const meta = await serviceContainer.getSpaceMeta(contextSpaceId);
+    if (!meta) {
+      throw new Error(`Space not found: ${contextSpaceId}`);
+    }
+    spaceKey = meta.spaceKey;
+    invariant6(!meta.rootDocumentId.startsWith("automerge:"), void 0, {
+      F: __dxlog_file6,
+      L: 118,
+      S: void 0,
+      A: [
+        "!meta.rootDocumentId.startsWith('automerge:')",
+        ""
+      ]
+    });
+    rootUrl = `automerge:${meta.rootDocumentId}`;
+  }
+  return {
+    services: {
+      dataService,
+      queryService,
+      queueService
+    },
+    spaceId: contextSpaceId,
+    spaceKey,
+    spaceRootUrl: rootUrl
+  };
+};
+
+// src/logger.ts
+import { LogLevel, log as log4, shouldLog } from "@dxos/log";
+var setupFunctionsLogger = () => {
+  log4.runtimeConfig.processors.length = 0;
+  log4.runtimeConfig.processors.push(functionLogProcessor);
+};
+var functionLogProcessor = (config, entry) => {
+  if (!shouldLog(entry, config.filters)) {
+    return;
+  }
+  switch (entry.level) {
+    case LogLevel.DEBUG:
+      console.debug(entry.message, entry.context);
+      break;
+    case LogLevel.TRACE:
+      console.debug(entry.message, entry.context);
+      break;
+    case LogLevel.VERBOSE:
+      console.log(entry.message, entry.context);
+      break;
+    case LogLevel.INFO:
+      console.info(entry.message, entry.context);
+      break;
+    case LogLevel.WARN:
+      console.warn(entry.message, entry.context);
+      break;
+    case LogLevel.ERROR:
+      console.error(entry.message, entry.context);
+      break;
+    default:
+      console.log(entry.message, entry.context);
+      break;
+  }
+};
+export {
+  FUNCTION_ROUTE_HEADER,
+  FunctionRouteValue,
+  FunctionsClient,
+  ServiceContainer,
+  createClientFromEnv,
+  setupFunctionsLogger,
+  wrapHandlerForCloudflare
+};
+//# sourceMappingURL=index.mjs.map