chore: Adding mainFn helpers

lib/mainFn/AddressReceipt.ts

@@ -0,0 +1,4 @@
+declare const AddressProof: unique symbol;
+export type AddressReceipt = {
+  [AddressProof]: never;
+};

lib/mainFn/LocalBinding.ts

@@ -0,0 +1,11 @@
+import { Origin } from "./Origin";
+
+export class LocalBinding {
+  constructor(readonly localAddress: string, readonly ipAddress: string) {}
+  createOrigins(protocol: string) {
+    return {
+      local: new Origin(protocol, this.localAddress),
+      ip: new Origin(protocol, this.ipAddress),
+    };
+  }
+}

lib/mainFn/LocalPort.ts

@@ -0,0 +1,13 @@
+import { Effects } from "../types";
+import { LocalBinding } from "./LocalBinding";
+
+export class LocalPort {
+  constructor(readonly id: string, readonly effects: Effects) {}
+  async bindLan(internalPort: number) {
+    const [localAddress, ipAddress] = await this.effects.bindLan({
+      internalPort,
+      name: this.id,
+    });
+    return new LocalBinding(localAddress, ipAddress);
+  }
+}

lib/mainFn/NetworkBuilder.ts

@@ -0,0 +1,17 @@
+import { Effects } from "../types";
+import { LocalPort } from "./LocalPort";
+import { TorHostname } from "./TorHostname";
+
+export class NetworkBuilder {
+  static of(effects: Effects) {
+    return new NetworkBuilder(effects);
+  }
+  private constructor(private effects: Effects) {}
+
+  getTorHostName(id: string) {
+    return new TorHostname(id, this.effects);
+  }
+  getPort(id: string) {
+    return new LocalPort(id, this.effects);
+  }
+}

lib/mainFn/NetworkInterfaceBuilder.ts

@@ -0,0 +1,38 @@
+import { Effects } from "../types";
+import { AddressReceipt } from "./AddressReceipt";
+import { Origin } from "./Origin";
+
+export class NetworkInterfaceBuilder {
+  constructor(
+    readonly options: {
+      effects: Effects;
+      name: string;
+      id: string;
+      description: string;
+      ui: boolean;
+      basic?: null | { password: string; username: string };
+      path?: string;
+      search?: Record<string, string>;
+    }
+  ) {}
+
+  async exportAddresses(addresses: Iterable<Origin>) {
+    const { name, description, id, ui, path, search } = this.options;
+    // prettier-ignore
+    const urlAuth = !!(this.options?.basic) ? `${this.options.basic.username}:${this.options.basic.password}@` :
+            '';
+    for (const origin of addresses) {
+      const address = `${origin.protocol}://${urlAuth}${origin.address}`;
+      await this.options.effects.exportAddress({
+        name,
+        description,
+        address,
+        id,
+        ui,
+        path,
+        search,
+      });
+    }
+    return {} as AddressReceipt;
+  }
+}

lib/mainFn/Origin.ts

@@ -0,0 +1,3 @@
+export class Origin {
+  constructor(readonly protocol: string, readonly address: string) {}
+}

lib/mainFn/RunningMainRet.ts

@@ -0,0 +1,7 @@
+import { Daemon } from "../types";
+import { ReadyProof } from "../health/ReadyProof";
+
+export type RunningMainRet = {
+  [ReadyProof]: never;
+  daemon: Daemon;
+};

lib/mainFn/TorBinding.ts

@@ -0,0 +1,8 @@
+import { Origin } from "./Origin";
+
+export class TorBinding {
+  constructor(readonly address: string) {}
+  createOrigin(protocol: string) {
+    return new Origin(protocol, this.address);
+  }
+}

lib/mainFn/TorHostname.ts

@@ -0,0 +1,14 @@
+import { Effects } from "../types";
+import { TorBinding } from "./TorBinding";
+
+export class TorHostname {
+  constructor(readonly id: string, readonly effects: Effects) {}
+  async bindTor(internalPort: number, externalPort: number) {
+    const address = await this.effects.bindTor({
+      internalPort,
+      name: this.id,
+      externalPort,
+    });
+    return new TorBinding(address);
+  }
+}

lib/mainFn/exportInterfaces.ts

@@ -0,0 +1,8 @@
+import { AddressReceipt } from "./AddressReceipt";
+import { InterfaceReceipt } from "./interfaceReceipt";
+
+export const exportInterfaces = (
+  _firstProof: AddressReceipt,
+  ..._rest: AddressReceipt[]
+) => ({} as InterfaceReceipt);
+export default exportInterfaces;

lib/mainFn/index.ts

@@ -0,0 +1,22 @@
+import { RunningMainRet } from "./RunningMainRet";
+import { Effects, ExpectedExports } from "../types";
+export * as network from "./exportInterfaces";
+export { LocalBinding } from "./LocalBinding";
+export { LocalPort } from "./LocalPort";
+export { NetworkBuilder } from "./NetworkBuilder";
+export { NetworkInterfaceBuilder } from "./NetworkInterfaceBuilder";
+export { Origin } from "./Origin";
+export { TorBinding } from "./TorBinding";
+export { TorHostname } from "./TorHostname";
+
+export const runningMain: (
+  fn: (o: {
+    effects: Effects;
+    started(onTerm: () => void): null;
+  }) => Promise<RunningMainRet>
+) => ExpectedExports.main = (fn) => {
+  return async (options) => {
+    const { daemon } = await fn(options);
+    daemon.wait();
+  };
+};

lib/mainFn/interfaceReceipt.ts

@@ -0,0 +1,4 @@
+declare const InterfaceProof: unique symbol;
+export type InterfaceReceipt = {
+  [InterfaceProof]: never;
+};