@statewalker/webrun-http-browser 0.3.3 → 0.4.2

package/src/relay/index-sw.js

@@ -1,216 +0,0 @@
-import { newRegistry } from "@statewalker/utils";
-import { get, set } from "idb-keyval";
-import { callChannel, handleChannelCalls } from "../core/data-calls.js";
-import { sendHttpRequest } from "../http/http-send-recieve.js";
-import { splitServiceUrl } from "./splitServiceUrl.js";
-import { HttpError } from "../http/HttpError.js";
-
-export function startRelayServiceWorker(self) {
-  const [register, clear] = newRegistry();
-
-  if (typeof self.skipWaiting === "function") {
-    console.log("self.skipWaiting() is supported.");
-    self.addEventListener("install", (e) => {
-      // See https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#service-worker-global-scope-skipwaiting
-      e.waitUntil(self.skipWaiting());
-    });
-  } else {
-    console.log("self.skipWaiting() is not supported.");
-  }
-
-  if (self.clients && (typeof self.clients.claim === "function")) {
-    console.log("self.clients.claim() is supported.");
-    self.addEventListener("activate", (e) => {
-      // See https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#clients-claim-method
-      e.waitUntil(self.clients.claim());
-    });
-  } else {
-    console.log("self.clients.claim() is not supported.");
-  }
-
-  const clientsRegistry = newClientsRegistry({
-    self,
-    get,
-    set,
-  });
-
-  // This listener handles the following message types:
-  // * registration: registers new clients as service providers
-  // * handles service calls rounting:
-  //   - it gets the clientKey defined in the call
-  //   - it uses the serviceKey to get the service-specifc channel
-  //   - it creates a new message channel and sent its ports to peers
-
-  register(handleChannelCalls(self, "REGISTER", async (event, data) => {
-    return await clientsRegistry.addClient(data.key, event.source);
-  }));
-  register(handleChannelCalls(self, "UNREGISTER", async (event, data) => {
-    return await clientsRegistry.removeClient(data.key);
-  }));
-
-  // Transfers all parameters (and ports) to the target client.
-  register(handleChannelCalls(self, "CONNECT", async (event, data, port) => {
-    const { key } = data;
-    const client = await clientsRegistry.getClient(key);
-    if (!client) {
-      throw new Error(`Target client was not found. Target key: "${key}".`);
-    }
-    return await callChannel(client, "CONNECT", data, port);
-  }));
-
-  const fetchListener = (event) => {
-    const request = event.request;
-    const params = splitServiceUrl(request.url);
-    const { key } = params;
-    if (key) {
-      const handler = async () => {
-        try {
-          const channel = new MessageChannel();
-          const client = await clientsRegistry.getClient(key);
-          if (!client) {
-            throw HttpError.errorResourceGone(params);
-          }
-          const data = {
-            type: "http",
-            key,
-          };
-          if (!await callChannel(client, "CONNECT", data, channel.port2)) {
-            throw HttpError.errorForbidden(params);
-          }
-          return await sendHttpRequest(channel.port1, request);
-        } catch (error) {
-          error = HttpError.fromError(error);
-          const options = error.getResponseOptions(params);
-          return new Response(JSON.stringify(options), {
-            ...options,
-            headers: {
-              "Content-Type": "text/javascript",
-            },
-          });
-        }
-      };
-      event.respondWith(handler());
-    }
-  };
-  self.addEventListener("fetch", fetchListener);
-  register(() => self.removeEventListener("fetch", fetchListener));
-
-  return clear;
-}
-
-// --------------------------------------------
-// errors.js
-
-// --------------------------------------------
-
-function newClientsRegistry({
-  self,
-  key = "clientsIds",
-  get,
-  set,
-}) {
-  let _index;
-  async function loadClientsIndex() {
-    if (!_index) {
-      const entries = (await get(key)) || [];
-      _index = Object.fromEntries(entries);
-    }
-    return _index;
-  }
-  async function storeClientsIndex() {
-    const index = await loadClientsIndex();
-    const entries = Object.entries(index);
-    await set(key, entries);
-    return index;
-  }
-
-  async function addClient(clientKey, client) {
-    const index = await loadClientsIndex();
-    const clientId = client.id;
-    let result = false;
-    if (!(clientId in index)) {
-      index[clientKey] = clientId;
-      await storeClientsIndex();
-      result = true;
-    }
-    return result;
-  }
-
-  async function removeClient(clientKey) {
-    const index = await loadClientsIndex();
-    let result = false;
-    if (clientKey in index) {
-      delete index[clientKey];
-      await storeClientsIndex();
-      result = true;
-    }
-    return result;
-  }
-
-  async function getClient(clientKey) {
-    const index = await loadClientsIndex();
-    const clientId = index[clientKey];
-    const client = await self.clients.get(clientId);
-    if (!client) {
-      delete index[clientKey];
-      await storeClientsIndex();
-    }
-    return client;
-  }
-
-  return {
-    getClient,
-    addClient,
-    removeClient,
-  };
-}
-// ----------------------------------------------------
-// Content of the "idb-keyval" package
-// import { get, set } from "idb-keyval";
-
-// function promisifyRequest(request) {
-//   return new Promise((resolve, reject) => {
-//     // @ts-ignore - file size hacks
-//     request.oncomplete = request.onsuccess = () => resolve(request.result);
-//     // @ts-ignore - file size hacks
-//     request.onabort = request.onerror = () => reject(request.error);
-//   });
-// }
-// function createStore(dbName, storeName) {
-//   const request = indexedDB.open(dbName);
-//   request.onupgradeneeded = () => request.result.createObjectStore(storeName);
-//   const dbp = promisifyRequest(request);
-//   return (txMode, callback) =>
-//     dbp.then((db) =>
-//       callback(db.transaction(storeName, txMode).objectStore(storeName))
-//     );
-// }
-// let defaultGetStoreFunc;
-// function defaultGetStore() {
-//   if (!defaultGetStoreFunc) {
-//     defaultGetStoreFunc = createStore("keyval-store", "keyval");
-//   }
-//   return defaultGetStoreFunc;
-// }
-// /**
-//  * Get a value by its key.
-//  *
-//  * @param key
-//  * @param customStore Method to get a custom store. Use with caution (see the docs).
-//  */
-// function get(key, customStore = defaultGetStore()) {
-//   return customStore("readonly", (store) => promisifyRequest(store.get(key)));
-// }
-// /**
-//  * Set a value with a key.
-//  *
-//  * @param key
-//  * @param value
-//  * @param customStore Method to get a custom store. Use with caution (see the docs).
-//  */
-// function set(key, value, customStore = defaultGetStore()) {
-//   return customStore("readwrite", (store) => {
-//     store.put(value, key);
-//     return promisifyRequest(store.transaction);
-//   });
-// }

package/src/relay/index.js

@@ -1,263 +0,0 @@
-import { newRegistry } from "@statewalker/utils";
-import { callChannel, handleChannelCalls } from "../core/data-calls.js";
-import {
-  handleHttpRequests,
-  sendHttpRequest,
-} from "../http/http-send-recieve.js";
-export * from "./splitServiceUrl.js";
-
-export function newServiceWorkerPort() {
-  // Bind the service worker to
-  const channel = new MessageChannel();
-  channel.port1.onmessage = (event) => {
-    navigator.serviceWorker.controller.postMessage(event.data, event.ports);
-  };
-  navigator.serviceWorker.addEventListener("message", (event) => {
-    channel.port1.postMessage(event.data, event.ports);
-  });
-  return channel.port2;
-}
-
-export async function initServiceWorker1({ swUrl, scopeUrl, type }) {
-  const {
-    installing,
-    waiting,
-    active,
-  } = await navigator.serviceWorker.register(swUrl, {
-    // type: "module",
-    scope: scopeUrl,
-  });
-  (installing || waiting || active).addEventListener("statechange", (e) => {
-    console.log("state", e.target.state);
-  });
-
-  const serviceWorker = navigator.serviceWorker;
-  await new Promise((resolve) => {
-    // Resolve right away if this page is already controlled.
-    if (serviceWorker.controller) {
-      resolve();
-    } else {
-      const onChange = () => {
-        resolve();
-        serviceWorker.removeEventListener("controllerchange", onChange);
-        serviceWorker.oncontrollerchange = null;
-      };
-      serviceWorker.addEventListener("controllerchange", onChange);
-      serviceWorker.oncontrollerchange = onChange;
-    }
-  });
-  const worker = serviceWorker.controller;
-  const isActivated = () => worker.state === "activated";
-  return await new Promise(async (resolve) => {
-    if (isActivated()) resolve(worker);
-    else {
-      worker.onstatechange = () => {
-        if (!isActivated()) return;
-        worker.onstatechange = null;
-        resolve(worker);
-      };
-    }
-  });
-}
-
-export async function initServiceWorker({ swUrl, scopeUrl, type }) {
-  await navigator.serviceWorker.register(swUrl, {
-    type,
-    scope: scopeUrl,
-  });
-  const worker = await getServiceWorkerController();
-  await awaitServiceWorkerActivation(worker);
-  return worker;
-
-  async function getServiceWorkerController() {
-    return await new Promise((resolve) => {
-      // Resolve right away if this page is already controlled.
-      const serviceWorker = navigator.serviceWorker;
-      if (serviceWorker.controller) {
-        resolve(serviceWorker.controller);
-      } else {
-        const onChange = () => {
-          resolve(serviceWorker.controller);
-          serviceWorker.removeEventListener("controllerchange", onChange);
-          serviceWorker.oncontrollerchange = null;
-        };
-        serviceWorker.addEventListener("controllerchange", onChange);
-        serviceWorker.oncontrollerchange = onChange;
-      }
-    });
-  }
-
-  // ------------------------------
-  // Await until the service is ready
-  async function awaitServiceWorkerActivation(worker) {
-    const isActivated = () => worker.state === "activated";
-    await new Promise(async (resolve) => {
-      if (isActivated()) resolve();
-      else {
-        worker.onstatechange = () => {
-          if (!isActivated()) return;
-          worker.onstatechange = null;
-          resolve();
-        };
-      }
-    });
-  }
-}
-
-export async function initHttpService(handler, {
-  key,
-  port,
-}) {
-  return await registerConnectionsHandler({
-    key,
-    communicationPort: port,
-    handler: async (event, data, callPort) => {
-      handleHttpRequests(callPort, handler);
-      return true;
-    },
-  });
-}
-
-export async function callHttpService(request, {
-  key,
-  port,
-}) {
-  const callPort = await initializeConnection({
-    key,
-    communicationPort: port,
-  });
-  const result = await sendHttpRequest(callPort, request);
-  return result;
-}
-
-export function getRelayWindowMessageHandler({
-  swUrl = new URL("./index-sw.js", import.meta.url) + "",
-  scopeUrl = new URL("../", import.meta.url) + "",
-} = {}) {
-  let externalPort;
-  return async (ev) => {
-    if (ev.data.type === "CONNECT") {
-      const newExternalPort = (ev.ports || [])[0];
-      if (externalPort) {
-        newExternalPort.close();
-        return;
-      }
-      externalPort = newExternalPort;
-      await initServiceWorker({
-        swUrl,
-        scopeUrl,
-      });
-      const serviceWorkerPort = newServiceWorkerPort();
-      serviceWorkerPort.onmessage = (event) => {
-        externalPort.postMessage(event.data, event.ports);
-      };
-
-      externalPort.onmessage = (event) => {
-        serviceWorkerPort.postMessage(event.data, event.ports);
-      };
-    }
-  };
-}
-
-export async function newRemoteRelayChannel({
-  baseUrl = new URL("../public-relay/", import.meta.url),
-  url = new URL("relay.html", baseUrl),
-  container = document.body,
-} = {}) {
-  const messageChannel = new MessageChannel();
-  const { iframe, promise } = await newIFrame(url);
-  Object.assign(iframe.style, {
-    // height: "100px"
-    position: "fixed",
-    width: "1px",
-    height: "1px",
-    top: "-1000",
-    left: "-1000",
-    display: "block",
-    opacity: "0",
-    border: "none",
-    outline: "none",
-  });
-  container.appendChild(iframe);
-  promise.then(() => {
-    iframe.contentWindow.postMessage(
-      {
-        type: "CONNECT",
-      },
-      "*",
-      [messageChannel.port1],
-    );
-  });
-  return {
-    baseUrl,
-    port: messageChannel.port2,
-    close: () => {
-      iframe.parentElement && iframe.parentElement.removeChild(iframe);
-      messageChannel.port1.close();
-      messageChannel.port2.close();
-    },
-  };
-
-  async function newIFrame(url) {
-    const iframe = document.createElement("iframe");
-    iframe.src = url;
-    Object.assign(iframe.style, {
-      padding: 0,
-      margin: 0,
-      border: "none",
-      outline: "none",
-      width: "100%",
-      height: "100%",
-    });
-    return {
-      iframe,
-      promise: new Promise((resolve, reject) => {
-        try {
-          iframe.onerror = reject;
-          iframe.onload = () => resolve(iframe);
-        } catch (error) {
-          reject(error);
-        }
-      }),
-    };
-  }
-}
-// -------------------------------------------------------
-
-export async function initializeConnection({
-  key,
-  communicationPort,
-  ...options
-}) {
-  const channel = new MessageChannel();
-  const accepted = await callChannel(
-    communicationPort,
-    "CONNECT",
-    { key, ...options },
-    channel.port2,
-  );
-  if (!accepted) {
-    channel.port1.close();
-    channel.port2.close();
-    return null;
-  }
-  return channel.port1;
-}
-
-export async function registerConnectionsHandler({
-  key,
-  handler,
-  communicationPort,
-}) {
-  const [register, cleanup] = newRegistry();
-  await callChannel(communicationPort, "REGISTER", { key });
-  register(() => callChannel(communicationPort, "UNREGISTER", { key }));
-  register(
-    handleChannelCalls(
-      communicationPort,
-      "CONNECT",
-      handler,
-    ),
-  );
-  return cleanup;
-}

package/src/relay/splitServiceUrl.js

@@ -1,24 +0,0 @@
-export function splitServiceUrl(url, separator = "~") {
-  let key = "";
-  let path = "";
-  let str = url + "";
-  const idx = str.indexOf(separator);
-  let baseUrl = "";
-  if (idx >= 0) {
-    baseUrl = str.substring(0, idx + separator.length);
-    str.substring(idx + separator.length)
-      .replace(/^([^\/]+)/, (match, $1) => {
-        baseUrl += match;
-        if (baseUrl.length < str.length) baseUrl += "/";
-        key = $1;
-        path = str.substring(baseUrl.length);
-        return "";
-      });
-  }
-  return {
-    url,
-    key,
-    baseUrl,
-    path,
-  };
-}

package/src/sw/http-sw-dispatcher.js

@@ -1,128 +0,0 @@
-import { handleHttpRequests, sendHttpRequest } from "../http/http-send-recieve.js";
-import { SwPortDispatcher, SwPortHandler } from "./sw-dispatcher.js";
-
-export class SwHttpAdapter extends SwPortHandler {
-  constructor(options) {
-    super(options);
-    this._handlers = new Map();
-  }
-
-  async _setCommunicationPort(port) {
-    if (this._cleanupRequestChannel) {
-      this._cleanupRequestChannel();
-    }
-    this._cleanupRequestChannel = handleHttpRequests(
-      port,
-      this._handleHttpRequest.bind(this),
-    );
-  }
-
-  async _handleHttpRequest(request) {
-    const requestUrl = request.url;
-    let handler;
-    for (let entry of this._handlers.entries()) {
-      const [urlPrefix] = entry;
-      if (requestUrl.indexOf(urlPrefix) === 0) {
-        handler = entry[1];
-        break;
-      }
-    }
-    return !handler
-      ? new Response(null, {
-        status: 404,
-        statusMessage: "Error 404: Not found",
-      })
-      : handler(request);
-  }
-
-  /**
-   * Registers the given request handler.
-   * @param {string} prefix unique base URL prefix used to register the specified handler
-   * @param {*} handler the request handler
-   * @return {string} full URL of the resulting endpoint
-   */
-  async register(prefix, handler) {
-    prefix = "./" + (prefix || "").replace(/^[\.\/]+/, "");
-    const rootUrl = this.rootUrl;
-    const baseUrl = new URL(prefix, rootUrl) + "";
-    this._handlers.set(baseUrl, handler);
-    return {
-      baseUrl,
-      prefix,
-      async remove() {
-        this._handlers.delete(baseUrl);
-      },
-    };
-  }
-}
-
-export class SwHttpDispatcher extends SwPortDispatcher {
-  constructor(options) {
-    super(options);
-  }
-
-  start() {
-    super.start();
-    this.self.addEventListener("fetch", this._handleFetchEvent.bind(this));
-  }
-
-  _handleFetchEvent(event) {
-    event.respondWith((async () => {
-      const request = event.request;
-      try {
-        const requestUrl = request.url;
-        const rootUrl = this.scope;
-        let channelInfo;
-        if (requestUrl.indexOf(rootUrl) === 0) {
-          const key = requestUrl
-            .substring(rootUrl.length)
-            .replace(/^\/?([^\/]+).*$/, "$1");
-          // console.log(`* rootUrl="${rootUrl}" requestUrl="${requestUrl}" key="${key}"`);
-          channelInfo = await this.loadChannelInfo(key);
-        }
-        if (channelInfo && channelInfo.port) {
-          return await sendHttpRequest(channelInfo.port, request);
-        } else {
-          const newRequest = new Request(requestUrl, {
-            method: request.method,
-            headers: request.headers,
-            body: request.body,
-            referrer: request.referrer,
-            referrerPolicy: request.referrerPolicy,
-            // mode: request.mode,
-            credentials: request.credentials,
-            cache: request.cache,
-            redirect: request.redirect,
-            integrity: request.integrity,
-          });
-          return await fetch(newRequest);
-        }
-
-        // const requestUrl = request.url;
-        // let url = requestUrl.replace(
-        //   /^.*\/[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}(.*)$/,
-        //   "$1",
-        // );
-        // if (url !== requestUrl) {
-        //   url = new URL(
-        //     "/packages/webrun-http-browser/src" + url,
-        //     self.location.href,
-        //   );
-        // }
-      } catch (error) {
-        console.error(error);
-        return new Response(null, {
-          status: 500,
-          statusText: "Error 500: Internal error",
-        });
-      }
-    })());
-  }
-}
-export function startHttpDispatcher({ self, log }) {
-  const dispatcher = new SwHttpDispatcher({ self, log });
-  dispatcher.start();
-  return () => {
-    dispatcher.stop();
-  };
-}