sdn-flow 0.2.0

package/src/host/appHost.js

@@ -0,0 +1,105 @@
+import { createInstalledFlowApp } from "./workspace.js";
+import {
+  HostedRuntimeBindingDirection,
+  HostedRuntimeTransport,
+} from "./constants.js";
+import { normalizeHostedRuntimePlan } from "./normalize.js";
+
+function normalizeString(value, fallback = null) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : fallback;
+}
+
+export function listInstalledFlowHttpBindings(options = {}) {
+  const workspace = options.workspace ?? null;
+  const rawHostPlan = options.hostPlan ?? workspace?.hostPlan ?? null;
+  const hostPlan = rawHostPlan ? normalizeHostedRuntimePlan(rawHostPlan) : null;
+  const programId =
+    normalizeString(options.programId, null) ??
+    normalizeString(workspace?.program?.programId, null);
+  const runtimeBindings = [];
+
+  for (const runtime of hostPlan?.runtimes ?? []) {
+    if (programId && runtime.programId && runtime.programId !== programId) {
+      continue;
+    }
+    for (const binding of runtime.bindings ?? []) {
+      if (binding.direction !== HostedRuntimeBindingDirection.LISTEN) {
+        continue;
+      }
+      if (binding.transport !== HostedRuntimeTransport.HTTP) {
+        continue;
+      }
+      runtimeBindings.push({
+        runtimeId: runtime.runtimeId,
+        programId: runtime.programId ?? null,
+        adapter: runtime.adapter ?? hostPlan?.adapter ?? null,
+        engine: runtime.engine ?? hostPlan?.engine ?? null,
+        binding,
+      });
+    }
+  }
+
+  return runtimeBindings;
+}
+
+function toListenerRecord(bindingContext, handle) {
+  const close =
+    typeof handle === "function"
+      ? handle
+      : typeof handle?.close === "function"
+        ? handle.close.bind(handle)
+        : async () => {};
+  return {
+    ...bindingContext,
+    handle: handle ?? null,
+    async close() {
+      await close();
+    },
+  };
+}
+
+export async function startInstalledFlowAppHost(options = {}) {
+  const app = options.app ?? (await createInstalledFlowApp(options));
+  const startup = await app.start();
+  const serveHttp = options.serveHttp ?? null;
+  const bindingContexts = listInstalledFlowHttpBindings({
+    workspace: app.getWorkspace(),
+  });
+  const listeners = [];
+
+  if (typeof serveHttp === "function") {
+    for (const bindingContext of bindingContexts) {
+      const handle = await serveHttp({
+        ...bindingContext,
+        app,
+        workspace: app.getWorkspace(),
+        handler: app.fetchHandler,
+      });
+      listeners.push(toListenerRecord(bindingContext, handle));
+    }
+  }
+
+  return {
+    app,
+    startup,
+    listeners,
+    listBindings() {
+      return bindingContexts;
+    },
+    async stop() {
+      for (const listener of listeners) {
+        await listener.close();
+      }
+      app.stop();
+    },
+  };
+}
+
+export default {
+  listInstalledFlowHttpBindings,
+  startInstalledFlowAppHost,
+};

package/src/host/autoHost.js

@@ -0,0 +1,113 @@
+import { HostedRuntimeEngine } from "./constants.js";
+import {
+  startInstalledFlowBrowserFetchHost,
+} from "./browserHostAdapters.js";
+import {
+  startInstalledFlowBunHttpHost,
+  startInstalledFlowDenoHttpHost,
+  startInstalledFlowNodeHttpHost,
+} from "./httpHostAdapters.js";
+import { normalizeHostedRuntimeEngine } from "./profile.js";
+import {
+  readInstalledFlowWorkspace,
+  resolveInstalledFlowWorkspace,
+} from "./workspace.js";
+
+function resolveGlobalEngineFallback(options = {}) {
+  if (typeof globalThis.Bun?.serve === "function") {
+    return HostedRuntimeEngine.BUN;
+  }
+  if (typeof globalThis.Deno?.serve === "function") {
+    return HostedRuntimeEngine.DENO;
+  }
+  if (
+    typeof options.addEventListener === "function" ||
+    typeof globalThis.addEventListener === "function"
+  ) {
+    return HostedRuntimeEngine.BROWSER;
+  }
+  return HostedRuntimeEngine.NODE;
+}
+
+function resolveWorkspaceEngine(workspace = null) {
+  return normalizeHostedRuntimeEngine(
+    workspace?.engine ?? workspace?.hostPlan?.engine,
+    null,
+  );
+}
+
+export async function resolveInstalledFlowAutoHostEngine(options = {}) {
+  const explicitEngine = normalizeHostedRuntimeEngine(options.engine, null);
+  if (explicitEngine) {
+    return explicitEngine;
+  }
+
+  if (typeof options.app?.getWorkspace === "function") {
+    const appEngine = resolveWorkspaceEngine(options.app.getWorkspace());
+    if (appEngine) {
+      return appEngine;
+    }
+  }
+
+  if (options.workspace !== undefined) {
+    const workspace = await resolveInstalledFlowWorkspace(
+      options.workspace,
+      options,
+    );
+    const workspaceEngine = resolveWorkspaceEngine(workspace);
+    if (workspaceEngine) {
+      return workspaceEngine;
+    }
+  }
+
+  if (typeof options.workspacePath === "string" && options.workspacePath.trim()) {
+    const workspace = await readInstalledFlowWorkspace(options.workspacePath, options);
+    const workspaceEngine = resolveWorkspaceEngine(workspace);
+    if (workspaceEngine) {
+      return workspaceEngine;
+    }
+  }
+
+  return resolveGlobalEngineFallback(options);
+}
+
+export async function startInstalledFlowAutoHost(options = {}) {
+  const engine = await resolveInstalledFlowAutoHostEngine(options);
+  const startBrowserHost =
+    options.startBrowserHost ?? startInstalledFlowBrowserFetchHost;
+  const startDenoHost =
+    options.startDenoHost ?? startInstalledFlowDenoHttpHost;
+  const startBunHost =
+    options.startBunHost ?? startInstalledFlowBunHttpHost;
+  const startNodeHost =
+    options.startNodeHost ?? startInstalledFlowNodeHttpHost;
+
+  switch (engine) {
+    case HostedRuntimeEngine.BROWSER:
+      return startBrowserHost({
+        ...options,
+        engine,
+      });
+    case HostedRuntimeEngine.DENO:
+      return startDenoHost({
+        ...options,
+        engine,
+      });
+    case HostedRuntimeEngine.BUN:
+      return startBunHost({
+        ...options,
+        engine,
+      });
+    case HostedRuntimeEngine.NODE:
+    default:
+      return startNodeHost({
+        ...options,
+        engine,
+      });
+  }
+}
+
+export default {
+  resolveInstalledFlowAutoHostEngine,
+  startInstalledFlowAutoHost,
+};

package/src/host/browserHostAdapters.js

@@ -0,0 +1,108 @@
+import { listInstalledFlowHttpBindings } from "./appHost.js";
+import { createInstalledFlowApp } from "./workspace.js";
+
+function normalizeString(value, fallback = null) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : fallback;
+}
+
+function resolveRequestUrl(request) {
+  if (request instanceof Request) {
+    return new URL(request.url);
+  }
+  const requestUrl = normalizeString(request?.url, null);
+  if (!requestUrl) {
+    throw new Error("Browser fetch host requires a Request or request-like object with url.");
+  }
+  return new URL(requestUrl);
+}
+
+export function matchesInstalledFlowHttpBindingRequest(bindingContext, request) {
+  const requestUrl = resolveRequestUrl(request);
+  const bindingUrl = new URL(bindingContext.binding.url);
+  return requestUrl.pathname === bindingUrl.pathname;
+}
+
+export function createInstalledFlowBrowserFetchEventListener(options = {}) {
+  const app = options.app;
+  if (!app) {
+    throw new Error(
+      "createInstalledFlowBrowserFetchEventListener requires an installed flow app.",
+    );
+  }
+  const bindingContexts =
+    options.bindingContexts ??
+    listInstalledFlowHttpBindings({
+      workspace: app.getWorkspace(),
+    });
+  const handler = options.handler ?? app.fetchHandler;
+
+  return function onFetch(event) {
+    const request = event?.request ?? event;
+    const bindingContext = bindingContexts.find((candidate) =>
+      matchesInstalledFlowHttpBindingRequest(candidate, request),
+    );
+    if (!bindingContext) {
+      return false;
+    }
+    const responsePromise = Promise.resolve(
+      handler(request, {
+        event,
+        bindingContext,
+      }),
+    );
+    if (typeof event?.respondWith === "function") {
+      event.respondWith(responsePromise);
+      return true;
+    }
+    return responsePromise;
+  };
+}
+
+export async function startInstalledFlowBrowserFetchHost(options = {}) {
+  const app = options.app ?? (await createInstalledFlowApp(options));
+  const startup = await app.start();
+  const bindingContexts = listInstalledFlowHttpBindings({
+    workspace: app.getWorkspace(),
+  });
+  const listener = createInstalledFlowBrowserFetchEventListener({
+    app,
+    bindingContexts,
+    handler: options.handler,
+  });
+  const addEventListenerFn =
+    options.addEventListener ??
+    globalThis.addEventListener?.bind(globalThis) ??
+    null;
+  const removeEventListenerFn =
+    options.removeEventListener ??
+    globalThis.removeEventListener?.bind(globalThis) ??
+    null;
+
+  if (typeof addEventListenerFn === "function") {
+    addEventListenerFn("fetch", listener);
+  }
+
+  return {
+    app,
+    startup,
+    bindingContexts,
+    handler: app.fetchHandler,
+    listener,
+    stop() {
+      if (typeof removeEventListenerFn === "function") {
+        removeEventListenerFn("fetch", listener);
+      }
+      app.stop();
+    },
+  };
+}
+
+export default {
+  createInstalledFlowBrowserFetchEventListener,
+  matchesInstalledFlowHttpBindingRequest,
+  startInstalledFlowBrowserFetchHost,
+};