mindoodb-app-sdk 0.0.4

package/dist/testing/index.js

@@ -0,0 +1,801 @@
+// src/testing/index.ts
+var PROTOCOL = "mindoodb-app-bridge";
+function createBridgeErrorPayload(error, fallbackCode = "bridge-error") {
+  if (error && typeof error === "object" && "message" in error) {
+    const namedError = error;
+    const code = typeof namedError.name === "string" && namedError.name ? namedError.name : fallbackCode;
+    const message = typeof namedError.message === "string" ? namedError.message : String(error);
+    return { code, message };
+  }
+  return { code: fallbackCode, message: String(error) };
+}
+function cloneBytes(chunk) {
+  return new Uint8Array(chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
+}
+function mergeLaunchContext(current, patch) {
+  if (!patch) {
+    return {
+      ...current,
+      theme: { ...current.theme },
+      viewport: current.viewport ? { ...current.viewport } : null,
+      user: { ...current.user },
+      launchParameters: { ...current.launchParameters },
+      views: current.views.map((view) => ({
+        ...view,
+        sources: view.sources.map((source) => ({ ...source })),
+        columns: view.columns.map((column) => ({
+          ...column,
+          expression: column.expression.mode === "field" ? { ...column.expression } : { mode: "formula", expression: structuredClone(column.expression.expression) }
+        })),
+        filter: view.filter.mode === "rules" ? {
+          mode: "rules",
+          match: view.filter.match,
+          rules: view.filter.rules.map((rule) => ({ ...rule }))
+        } : {
+          mode: "formula",
+          expression: structuredClone(view.filter.expression)
+        }
+      }))
+    };
+  }
+  return {
+    ...current,
+    ...patch,
+    theme: patch.theme ? { ...current.theme, ...patch.theme } : { ...current.theme },
+    viewport: patch.viewport === void 0 ? current.viewport ? { ...current.viewport } : null : patch.viewport ? { ...patch.viewport } : null,
+    user: patch.user ? { ...current.user, ...patch.user } : { ...current.user },
+    launchParameters: patch.launchParameters ? { ...current.launchParameters, ...patch.launchParameters } : { ...current.launchParameters },
+    views: patch.views ? patch.views.map((view) => ({
+      ...view,
+      sources: view.sources.map((source) => ({ ...source })),
+      columns: view.columns.map((column) => ({
+        ...column,
+        expression: column.expression.mode === "field" ? { ...column.expression } : { mode: "formula", expression: structuredClone(column.expression.expression) }
+      })),
+      filter: view.filter.mode === "rules" ? {
+        mode: "rules",
+        match: view.filter.match,
+        rules: view.filter.rules.map((rule) => ({ ...rule }))
+      } : {
+        mode: "formula",
+        expression: structuredClone(view.filter.expression)
+      }
+    })) : current.views.map((view) => ({
+      ...view,
+      sources: view.sources.map((source) => ({ ...source })),
+      columns: view.columns.map((column) => ({
+        ...column,
+        expression: column.expression.mode === "field" ? { ...column.expression } : { mode: "formula", expression: structuredClone(column.expression.expression) }
+      })),
+      filter: view.filter.mode === "rules" ? {
+        mode: "rules",
+        match: view.filter.match,
+        rules: view.filter.rules.map((rule) => ({ ...rule }))
+      } : {
+        mode: "formula",
+        expression: structuredClone(view.filter.expression)
+      }
+    }))
+  };
+}
+function createDefaultLaunchContext(patch) {
+  const base = {
+    appId: "sample-app",
+    appInstanceId: "sample-app-instance",
+    appVersion: "1.0.0",
+    launchId: "test-launch",
+    runtime: "iframe",
+    theme: {
+      mode: "dark",
+      preset: "mindoo"
+    },
+    viewport: {
+      width: 1024,
+      height: 768
+    },
+    user: {
+      id: "user-1",
+      username: "Test User"
+    },
+    launchParameters: {},
+    views: []
+  };
+  return mergeLaunchContext(base, patch);
+}
+function createDefaultReadableAttachmentStream(chunks = []) {
+  const queue = chunks.map((chunk) => cloneBytes(chunk));
+  let closed = false;
+  return {
+    async read() {
+      if (closed) {
+        return null;
+      }
+      const next = queue.shift();
+      if (!next) {
+        closed = true;
+        return null;
+      }
+      return next;
+    },
+    async close() {
+      closed = true;
+      queue.splice(0);
+    }
+  };
+}
+function createDefaultWritableAttachmentStream() {
+  let closed = false;
+  return {
+    async write() {
+      if (closed) {
+        throw new Error("The attachment write stream is already closed.");
+      }
+    },
+    async close() {
+      closed = true;
+    },
+    async abort() {
+      closed = true;
+    }
+  };
+}
+function createDefaultViewHandle() {
+  const definition = {
+    title: "Mock View",
+    columns: []
+  };
+  const expansion = {
+    mode: "collapsed",
+    ids: []
+  };
+  const emptyPage = {
+    rows: [],
+    nextPosition: null,
+    hasMore: false
+  };
+  return {
+    async getDefinition() {
+      return definition;
+    },
+    async refresh() {
+    },
+    async page(_input) {
+      return emptyPage;
+    },
+    async getExpansionState() {
+      return expansion;
+    },
+    async setExpansionState(state) {
+      return state;
+    },
+    async expand(rowKey) {
+      return {
+        mode: "collapsed",
+        ids: [rowKey]
+      };
+    },
+    async collapse(_rowKey) {
+      return expansion;
+    },
+    async expandAll() {
+      return {
+        mode: "expanded",
+        ids: []
+      };
+    },
+    async collapseAll() {
+      return expansion;
+    },
+    async getRow(_rowKey) {
+      return null;
+    },
+    async getCategory(_input) {
+      return null;
+    },
+    async pageCategory(_categoryKey, _input) {
+      return emptyPage;
+    },
+    async listCategoryDocumentIds(_categoryKey) {
+      return [];
+    },
+    async dispose() {
+    }
+  };
+}
+function createDatabaseHandle(definition) {
+  let createCounter = 0;
+  const defaultViewFactory = async () => createDefaultViewHandle();
+  const defaultDocuments = {
+    async list(_query) {
+      return {
+        items: [],
+        nextCursor: null
+      };
+    },
+    async get(_docId) {
+      return null;
+    },
+    async create(input) {
+      createCounter += 1;
+      return {
+        id: `doc-${createCounter}`,
+        data: { ...input.data },
+        attachments: []
+      };
+    },
+    async update(docId, patch) {
+      return {
+        id: docId,
+        data: { ...patch.data },
+        attachments: []
+      };
+    },
+    async delete(_docId) {
+      return { ok: true };
+    },
+    async listHistory(_docId) {
+      return [];
+    },
+    async getAtTimestamp(docId, timestamp) {
+      return {
+        id: docId,
+        timestamp,
+        state: "missing",
+        data: null
+      };
+    }
+  };
+  const defaultViews = {
+    async create(_definition) {
+      return await defaultViewFactory();
+    },
+    async open(_viewId) {
+      return await defaultViewFactory();
+    }
+  };
+  const defaultAttachments = {
+    async list(_docId) {
+      return [];
+    },
+    async remove(_docId, _attachmentName) {
+      return { ok: true };
+    },
+    async openReadStream(_docId, _attachmentName) {
+      return createDefaultReadableAttachmentStream();
+    },
+    async openWriteStream(_docId, _attachmentName, _contentType) {
+      return createDefaultWritableAttachmentStream();
+    }
+  };
+  const methods = definition.methods ?? {};
+  return {
+    async info() {
+      return { ...definition.info, capabilities: [...definition.info.capabilities] };
+    },
+    documents: {
+      ...defaultDocuments,
+      ...methods.documents
+    },
+    views: {
+      ...defaultViews,
+      ...methods.views
+    },
+    attachments: {
+      ...defaultAttachments,
+      ...methods.attachments
+    }
+  };
+}
+function createMockSessionState(options = {}) {
+  let launchContext = createDefaultLaunchContext(options.launchContext);
+  const themeListeners = /* @__PURE__ */ new Set();
+  const viewportListeners = /* @__PURE__ */ new Set();
+  const databaseHandles = /* @__PURE__ */ new Map();
+  let databaseInfos = [];
+  const setDatabases = (definitions) => {
+    databaseHandles.clear();
+    databaseInfos = definitions.map((definition) => ({
+      ...definition.info,
+      capabilities: [...definition.info.capabilities]
+    }));
+    for (const definition of definitions) {
+      databaseHandles.set(definition.info.id, createDatabaseHandle(definition));
+    }
+  };
+  setDatabases(options.databases ?? []);
+  const session = {
+    async getLaunchContext() {
+      return mergeLaunchContext(launchContext);
+    },
+    async listDatabases() {
+      return databaseInfos.map((entry) => ({
+        ...entry,
+        capabilities: [...entry.capabilities]
+      }));
+    },
+    async openDatabase(databaseId) {
+      const database = databaseHandles.get(databaseId);
+      if (!database) {
+        throw new Error(`Unknown test database: ${databaseId}`);
+      }
+      return database;
+    },
+    onThemeChange(listener) {
+      themeListeners.add(listener);
+      return () => {
+        themeListeners.delete(listener);
+      };
+    },
+    onViewportChange(listener) {
+      viewportListeners.add(listener);
+      return () => {
+        viewportListeners.delete(listener);
+      };
+    },
+    async disconnect() {
+      await options.onDisconnect?.();
+    }
+  };
+  const bridge = {
+    async connect() {
+      return session;
+    }
+  };
+  return {
+    getLaunchContext() {
+      return mergeLaunchContext(launchContext);
+    },
+    setLaunchContext(patch) {
+      launchContext = mergeLaunchContext(launchContext, patch);
+      return mergeLaunchContext(launchContext);
+    },
+    listDatabaseInfos() {
+      return databaseInfos.map((entry) => ({
+        ...entry,
+        capabilities: [...entry.capabilities]
+      }));
+    },
+    setDatabases,
+    getDatabase(databaseId) {
+      const database = databaseHandles.get(databaseId);
+      if (!database) {
+        throw new Error(`Unknown test database: ${databaseId}`);
+      }
+      return database;
+    },
+    bridge,
+    session,
+    emitThemeChange(theme) {
+      launchContext = mergeLaunchContext(launchContext, { theme });
+      themeListeners.forEach((listener) => listener({ ...launchContext.theme }));
+    },
+    emitViewportChange(viewport) {
+      launchContext = mergeLaunchContext(launchContext, { viewport });
+      viewportListeners.forEach((listener) => listener({ ...viewport }));
+    }
+  };
+}
+function createMockMindooDBAppSession(options = {}) {
+  const state = createMockSessionState(options);
+  return {
+    bridge: state.bridge,
+    session: state.session,
+    getLaunchContext: state.getLaunchContext,
+    setLaunchContext: state.setLaunchContext,
+    listDatabases: state.listDatabaseInfos,
+    setDatabases: state.setDatabases,
+    emitThemeChange: state.emitThemeChange,
+    emitViewportChange: state.emitViewportChange
+  };
+}
+function createMockMindooDBAppBridge(options = {}) {
+  return createMockMindooDBAppSession(options);
+}
+function createFakeBridgeHost(options = {}) {
+  const state = createMockSessionState(options);
+  const customRequestHandlers = new Map(Object.entries(options.requestHandlers ?? {}));
+  const requests = [];
+  const connectedPorts = /* @__PURE__ */ new Set();
+  const viewSessions = /* @__PURE__ */ new Map();
+  const readStreams = /* @__PURE__ */ new Map();
+  const writeStreams = /* @__PURE__ */ new Map();
+  let viewCounter = 0;
+  let streamCounter = 0;
+  let previousWindowDescriptor = Object.getOwnPropertyDescriptor(globalThis, "window");
+  let previousWindowValue = typeof window === "undefined" ? void 0 : window;
+  let installed = false;
+  const hostWindow = {
+    postMessage(message, _targetOrigin, transfer) {
+      const payload = message;
+      if (!payload || payload.protocol !== PROTOCOL || payload.type !== "mindoodb-app:connect") {
+        return;
+      }
+      if (payload.launchId !== state.getLaunchContext().launchId) {
+        return;
+      }
+      const port = transfer?.[0];
+      if (!port) {
+        throw new Error("Expected the bridge connection to transfer a MessagePort.");
+      }
+      connectedPorts.add(port);
+      port.addEventListener("message", (event) => {
+        void handlePortMessage(port, event.data);
+      });
+      port.start();
+      const connected = {
+        protocol: PROTOCOL,
+        type: "mindoodb-app:connected"
+      };
+      port.postMessage(connected);
+    }
+  };
+  function getWindowSearch() {
+    return `?mindoodbAppLaunchId=${encodeURIComponent(state.getLaunchContext().launchId)}`;
+  }
+  function restoreWindow() {
+    if (!installed) {
+      return;
+    }
+    connectedPorts.forEach((port) => {
+      port.close();
+    });
+    connectedPorts.clear();
+    if (previousWindowDescriptor) {
+      Object.defineProperty(globalThis, "window", previousWindowDescriptor);
+    } else if (previousWindowValue !== void 0) {
+      Object.defineProperty(globalThis, "window", {
+        value: previousWindowValue,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      Reflect.deleteProperty(globalThis, "window");
+    }
+    installed = false;
+  }
+  function install() {
+    if (installed) {
+      return;
+    }
+    previousWindowDescriptor = Object.getOwnPropertyDescriptor(globalThis, "window");
+    previousWindowValue = typeof window === "undefined" ? void 0 : window;
+    const baseWindow = typeof window === "undefined" ? {} : window;
+    const nextWindow = Object.create(baseWindow);
+    Object.defineProperties(nextWindow, {
+      parent: {
+        value: options.windowMode === "opener" ? baseWindow : hostWindow,
+        configurable: true
+      },
+      opener: {
+        value: options.windowMode === "opener" ? hostWindow : null,
+        configurable: true
+      },
+      location: {
+        value: {
+          search: getWindowSearch()
+        },
+        configurable: true
+      },
+      setTimeout: {
+        value: typeof window !== "undefined" && typeof window.setTimeout === "function" ? window.setTimeout.bind(window) : setTimeout,
+        configurable: true
+      },
+      clearTimeout: {
+        value: typeof window !== "undefined" && typeof window.clearTimeout === "function" ? window.clearTimeout.bind(window) : clearTimeout,
+        configurable: true
+      }
+    });
+    Object.defineProperty(globalThis, "window", {
+      value: nextWindow,
+      configurable: true,
+      writable: true
+    });
+    installed = true;
+  }
+  async function resolveViewHandle(databaseId, viewId) {
+    const key = `${databaseId}::${viewId}`;
+    const existing = viewSessions.get(key);
+    if (existing) {
+      return existing;
+    }
+    const database = state.getDatabase(databaseId);
+    const handle = await database.views.open(viewId);
+    viewSessions.set(key, handle);
+    return handle;
+  }
+  function postRpcSuccess(port, requestId, result) {
+    port.postMessage({
+      protocol: PROTOCOL,
+      kind: "success",
+      id: requestId,
+      result
+    });
+  }
+  function postRpcError(port, requestId, error) {
+    port.postMessage({
+      protocol: PROTOCOL,
+      kind: "error",
+      id: requestId,
+      error
+    });
+  }
+  function postStreamAck(port, streamId) {
+    port.postMessage({
+      protocol: PROTOCOL,
+      kind: "stream-ack",
+      streamId
+    });
+  }
+  function postStreamError(port, streamId, error) {
+    port.postMessage({
+      protocol: PROTOCOL,
+      kind: "stream-error",
+      streamId,
+      error
+    });
+  }
+  async function handleBuiltinRequest(request) {
+    const params = request.params;
+    switch (request.method) {
+      case "session.getLaunchContext":
+        return state.getLaunchContext();
+      case "session.listDatabases":
+        return state.listDatabaseInfos();
+      case "session.openDatabase":
+        state.getDatabase(String(params.databaseId));
+        return { ok: true };
+      case "session.disconnect":
+        await state.session.disconnect();
+        return { ok: true };
+      case "documents.list":
+        return await state.getDatabase(String(params.databaseId)).documents.list(params.query);
+      case "documents.get":
+        return await state.getDatabase(String(params.databaseId)).documents.get(String(params.docId));
+      case "documents.create":
+        return await state.getDatabase(String(params.databaseId)).documents.create(params.input);
+      case "documents.update":
+        return await state.getDatabase(String(params.databaseId)).documents.update(
+          String(params.docId),
+          params.patch
+        );
+      case "documents.delete":
+        return await state.getDatabase(String(params.databaseId)).documents.delete(String(params.docId));
+      case "documents.history.list":
+        return await state.getDatabase(String(params.databaseId)).documents.listHistory(String(params.docId));
+      case "documents.history.getAtTimestamp":
+        return await state.getDatabase(String(params.databaseId)).documents.getAtTimestamp(
+          String(params.docId),
+          Number(params.timestamp)
+        );
+      case "attachments.list":
+        return await state.getDatabase(String(params.databaseId)).attachments.list(String(params.docId));
+      case "attachments.remove":
+        return await state.getDatabase(String(params.databaseId)).attachments.remove(
+          String(params.docId),
+          String(params.attachmentName)
+        );
+      case "attachments.openReadStream": {
+        const stream = await state.getDatabase(String(params.databaseId)).attachments.openReadStream(
+          String(params.docId),
+          String(params.attachmentName)
+        );
+        const streamId = `read-${streamCounter += 1}`;
+        readStreams.set(streamId, stream);
+        return { streamId };
+      }
+      case "attachments.openWriteStream": {
+        const stream = await state.getDatabase(String(params.databaseId)).attachments.openWriteStream(
+          String(params.docId),
+          String(params.attachmentName),
+          typeof params.contentType === "string" ? params.contentType : void 0
+        );
+        const streamId = `write-${streamCounter += 1}`;
+        writeStreams.set(streamId, stream);
+        return { streamId };
+      }
+      case "views.create": {
+        const handle = await state.getDatabase(String(params.databaseId)).views.create(params.definition);
+        const viewId = `view-${viewCounter += 1}`;
+        viewSessions.set(`${String(params.databaseId)}::${viewId}`, handle);
+        return { viewId };
+      }
+      case "views.getDefinition":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).getDefinition();
+      case "views.refresh":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).refresh();
+      case "views.page":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).page(
+          params.request
+        );
+      case "views.expansion.get":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).getExpansionState();
+      case "views.expansion.set":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).setExpansionState(
+          params.expansion
+        );
+      case "views.expansion.expand":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).expand(String(params.rowKey));
+      case "views.expansion.collapse":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).collapse(String(params.rowKey));
+      case "views.expansion.expandAll":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).expandAll();
+      case "views.expansion.collapseAll":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).collapseAll();
+      case "views.row.get":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).getRow(String(params.rowKey));
+      case "views.category.get":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).getCategory(
+          params.lookup
+        );
+      case "views.category.page":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).pageCategory(
+          String(params.categoryKey),
+          params.request
+        );
+      case "views.category.documentIds":
+        return await (await resolveViewHandle(String(params.databaseId), String(params.viewId))).listCategoryDocumentIds(
+          String(params.categoryKey)
+        );
+      case "views.dispose": {
+        const key = `${String(params.databaseId)}::${String(params.viewId)}`;
+        const handle = await resolveViewHandle(String(params.databaseId), String(params.viewId));
+        await handle.dispose();
+        viewSessions.delete(key);
+        return void 0;
+      }
+      default:
+        return void 0;
+    }
+  }
+  async function handleStreamMessage(port, message) {
+    if (message.kind === "stream-read") {
+      const stream = readStreams.get(message.streamId);
+      if (!stream) {
+        throw Object.assign(new Error(`Unknown read stream: ${message.streamId}`), { name: "stream-not-found" });
+      }
+      const chunk = await stream.read();
+      port.postMessage({
+        protocol: PROTOCOL,
+        kind: "stream-chunk",
+        streamId: message.streamId,
+        chunk: chunk ? cloneBytes(chunk).buffer : void 0,
+        done: !chunk
+      });
+      if (!chunk) {
+        readStreams.delete(message.streamId);
+      }
+      return true;
+    }
+    if (message.kind === "stream-write") {
+      const stream = writeStreams.get(message.streamId);
+      if (!stream) {
+        throw Object.assign(new Error(`Unknown write stream: ${message.streamId}`), { name: "stream-not-found" });
+      }
+      await stream.write(new Uint8Array(message.chunk));
+      postStreamAck(port, message.streamId);
+      return true;
+    }
+    if (message.kind === "stream-close") {
+      const readStream = readStreams.get(message.streamId);
+      if (readStream) {
+        await readStream.close();
+        readStreams.delete(message.streamId);
+        postStreamAck(port, message.streamId);
+        return true;
+      }
+      const writeStream = writeStreams.get(message.streamId);
+      if (writeStream) {
+        await writeStream.close();
+        writeStreams.delete(message.streamId);
+        postStreamAck(port, message.streamId);
+        return true;
+      }
+      throw Object.assign(new Error(`Unknown stream: ${message.streamId}`), { name: "stream-not-found" });
+    }
+    if (message.kind === "stream-abort") {
+      const stream = writeStreams.get(message.streamId);
+      if (!stream) {
+        throw Object.assign(new Error(`Unknown write stream: ${message.streamId}`), { name: "stream-not-found" });
+      }
+      await stream.abort();
+      writeStreams.delete(message.streamId);
+      postStreamAck(port, message.streamId);
+      return true;
+    }
+    return false;
+  }
+  async function handlePortMessage(port, rawMessage) {
+    const message = rawMessage;
+    if (!message || message.protocol !== PROTOCOL) {
+      return;
+    }
+    if (message.kind === "request") {
+      requests.push(message);
+      try {
+        const customHandler = customRequestHandlers.get(message.method);
+        if (customHandler) {
+          const result = await customHandler(message.params, { host: controller, request: message, port });
+          postRpcSuccess(port, message.id, result);
+          return;
+        }
+        const builtinResult = await handleBuiltinRequest(message);
+        if (builtinResult === void 0 && message.method !== "views.dispose") {
+          postRpcError(port, message.id, {
+            code: "unsupported-method",
+            message: `No fake bridge handler is configured for ${message.method}.`
+          });
+          return;
+        }
+        postRpcSuccess(port, message.id, builtinResult);
+      } catch (error) {
+        postRpcError(port, message.id, createBridgeErrorPayload(error));
+      }
+      return;
+    }
+    try {
+      const handledByCustom = await options.onPortMessage?.(message, { host: controller, port });
+      if (handledByCustom) {
+        return;
+      }
+      const handled = await handleStreamMessage(port, message);
+      if (!handled) {
+        throw Object.assign(new Error(`No fake bridge port handler is configured for ${message.kind}.`), {
+          name: "unsupported-message"
+        });
+      }
+    } catch (error) {
+      const streamId = "streamId" in message ? String(message.streamId) : "unknown";
+      postStreamError(port, streamId, createBridgeErrorPayload(error));
+    }
+  }
+  const controller = {
+    bridge: state.bridge,
+    session: state.session,
+    get launchId() {
+      return state.getLaunchContext().launchId;
+    },
+    get requests() {
+      return requests;
+    },
+    install,
+    dispose() {
+      restoreWindow();
+      viewSessions.clear();
+      readStreams.clear();
+      writeStreams.clear();
+    },
+    emitThemeChange(theme) {
+      state.emitThemeChange(theme);
+      const payload = {
+        protocol: PROTOCOL,
+        kind: "theme-changed",
+        theme
+      };
+      connectedPorts.forEach((port) => port.postMessage(payload));
+    },
+    emitViewportChange(viewport) {
+      state.emitViewportChange(viewport);
+      const payload = {
+        protocol: PROTOCOL,
+        kind: "viewport-changed",
+        viewport
+      };
+      connectedPorts.forEach((port) => port.postMessage(payload));
+    },
+    postPortMessage(message, transfer = []) {
+      connectedPorts.forEach((port) => port.postMessage(message, transfer));
+    },
+    setRequestHandler(method, handler) {
+      customRequestHandlers.set(method, handler);
+    },
+    clearRequestHandler(method) {
+      customRequestHandlers.delete(method);
+    }
+  };
+  return controller;
+}
+export {
+  createFakeBridgeHost,
+  createMockMindooDBAppBridge,
+  createMockMindooDBAppSession
+};