@covenant-rpc/server 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @covenant-rpc/server
+
+## 0.1.3
+
+### Patch Changes
+
+- 8061179: Initial publish
+- Updated dependencies [8061179]
+  - @covenant-rpc/request-serializer@1.0.3
+  - @covenant-rpc/core@0.1.3
+  - @covenant-rpc/ion@1.0.3
+
+## 0.1.2
+
+### Patch Changes
+
+- Fix all packages

package/lib/adapters/vanilla.ts

@@ -0,0 +1,9 @@
+import type { CovenantServer } from "../server";
+
+export function vanillaAdapter(server: CovenantServer<any, any, any, any>) {
+  return async (request: Request) => {
+    const res = await server.handle(request);
+    return res;
+  }
+}
+

package/lib/index.ts

@@ -0,0 +1,11 @@
+export { CovenantServer } from "./server";
+export { Logger } from "./logger";
+export { vanillaAdapter } from "./adapters/vanilla";
+export { Sidekick, type SidekickClient } from "./sidekick";
+export { httpServerToSidekick, httpSidekickToServer } from "./interfaces/http";
+export { emptyServerToSidekick } from "./interfaces/empty";
+export { directClientToServer } from "./interfaces/direct";
+export { mockClientToSidekick } from "./interfaces/mock";
+
+// Re-export types from core for convenience
+export type { LoggerLevel, Prefix } from "@covenant-rpc/core/logger";

package/lib/interfaces/direct.ts

@@ -0,0 +1,116 @@
+import type { ClientToServerConnection, ServerToSidekickConnection, ClientToSidekickConnection } from "@covenant-rpc/core/interfaces";
+import type { ProcedureRequestBody, ProcedureResponse } from "@covenant-rpc/core/procedure";
+import type { CovenantServer } from "../server";
+import { v } from "@covenant-rpc/core/validation";
+import { procedureResponseSchema } from "@covenant-rpc/core/procedure";
+import { channelConnectionRequestSchema, channelConnectionResponseSchema, type ChannelConnectionRequest, type ChannelConnectionResponse } from "@covenant-rpc/core/channel";
+import ION from "@covenant-rpc/ion";
+
+
+export function directClientToServer(
+  server: CovenantServer<any, any, any, any>,
+  extraHeaders: Record<string, string>
+): ClientToServerConnection {
+  const getHeaders = () => {
+    const h = new Headers();
+    h.set("Content-Type", "application/json");
+
+    for (const k in extraHeaders) {
+      h.set(k, extraHeaders[k]!);
+    }
+    return h;
+  }
+
+  const getUrl = (type: string) => {
+    const url = new URL("localhost:3000");
+    url.searchParams.set("type", type);
+    return url.toString();
+  }
+
+  return {
+    async sendConnectionRequest(body: ChannelConnectionRequest): Promise<ChannelConnectionResponse> {
+      try {
+        const request = new Request(getUrl("connect"), {
+          body: ION.stringify(body),
+          method: "POST",
+          headers: getHeaders(),
+        });
+
+        const response = await server.handle(request);
+        const responseText = await response.text();
+        const responseBody = ION.parse(responseText);
+        const connectionResponse = v.parseSafe(responseBody, channelConnectionResponseSchema);
+
+        if (connectionResponse === null) {
+          return {
+            channel: body.channel,
+            params: body.params,
+            result: {
+              type: "ERROR",
+              error: {
+                channel: body.channel,
+                params: body.params,
+                fault: "server",
+                message: `Bad response from server: ${JSON.stringify(responseBody)}`,
+              },
+            },
+          };
+        }
+
+        return connectionResponse;
+      } catch (e) {
+        return {
+          channel: body.channel,
+          params: body.params,
+          result: {
+            type: "ERROR",
+            error: {
+              channel: body.channel,
+              params: body.params,
+              fault: "server",
+              message: `Unknown error connecting to channel: ${e}`,
+            },
+          },
+        };
+      }
+    },
+    async runProcedure(body: ProcedureRequestBody) {
+      try {
+        const request = new Request(getUrl("procedure"), {
+          body: ION.stringify(body),
+          method: "POST",
+          headers: getHeaders(),
+        });
+
+        const response = await server.handle(request);
+        const responseText = await response.text();
+        const responseBody = ION.parse(responseText);
+        const procedureResponse = v.parseSafe(responseBody, procedureResponseSchema)
+
+        if (procedureResponse === null) {
+          return {
+            status: "ERR",
+            error: {
+              code: 500,
+              message: `Bad response from server: ${responseBody}`,
+            }
+          }
+        }
+
+        return procedureResponse;
+      } catch (e) {
+        return {
+          status: "ERR",
+          error: {
+            code: 400,
+            message: `Unknown error fetching from the server: ${e}`,
+          }
+        }
+      }
+    }
+
+  }
+
+}
+
+

package/lib/interfaces/empty.ts

@@ -0,0 +1,9 @@
+import type { ServerToSidekickConnection } from "@covenant-rpc/core/interfaces";
+
+export function emptyServerToSidekick(): ServerToSidekickConnection {
+  return {
+    addConnection: async () => null,
+    update: async () => null,
+    postMessage: async () => null,
+  }
+}

package/lib/interfaces/http.ts

@@ -0,0 +1,111 @@
+import type { ServerToSidekickConnection, SidekickToServerConnection } from "@covenant-rpc/core/interfaces";
+import type { ChannelConnectionPayload, ServerMessage } from "@covenant-rpc/core/channel";
+import ION from "@covenant-rpc/ion";
+
+export function httpSidekickToServer(baseUrl: string, key: string): SidekickToServerConnection {
+  const getUrl = (type: string) => {
+    const url = new URL(baseUrl);
+    url.searchParams.set("type", type);
+    return url.toString();
+  };
+
+  return {
+    async sendMessage(message) {
+      const json = ION.stringify(message);
+
+      const res = await fetch(getUrl("channel"), {
+        headers: {
+          "Authorization": `Bearer ${key}`,
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+        body: json,
+      });
+
+      if (res.ok) {
+        return null;
+      }
+
+      return {
+        channel: message.channel,
+        params: message.params,
+        fault: "server",
+        message: `Failed to send message to server. Received: ${res.status} - ${res.statusText}`,
+      }
+    },
+  }
+}
+
+
+class HttpServerToSidekick implements ServerToSidekickConnection {
+  private url: URL;
+  private key: string;
+
+  constructor(url: string, key: string) {
+    this.url = new URL(url);
+    this.key = key;
+  }
+
+  async addConnection(payload: ChannelConnectionPayload): Promise<Error | null> {
+    const url = new URL(this.url.toString());
+    url.pathname = "/connection";
+
+    const res = await fetch(url.toString(), {
+      body: ION.stringify(payload),
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.key}`,
+      },
+      method: "POST",
+    });
+
+    if (!res.ok) {
+      return new Error(`Error posting connection from sidekick: ${res.status} - ${res.statusText}`);
+    }
+    return null;
+  }
+
+  async update(resources: string[]): Promise<Error | null> {
+    const url = new URL(this.url.toString());
+    url.pathname = "/resources";
+
+    const res = await fetch(url.toString(), {
+      body: ION.stringify({
+        resources: resources,
+      }),
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.key}`,
+      },
+      method: "POST",
+    });
+
+    if (!res.ok) {
+      return new Error(`Error posting resources from sidekick: ${res.status} - ${res.statusText}`);
+    }
+    return null;
+  }
+
+  async postMessage(message: ServerMessage): Promise<Error | null> {
+    const url = new URL(this.url.toString());
+    url.pathname = "/message";
+
+    const res = await fetch(url.toString(), {
+      body: ION.stringify(message),
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.key}`,
+      },
+      method: "POST",
+    });
+
+    if (!res.ok) {
+      return new Error(`Error posting message from sidekick: ${res.status} - ${res.statusText}`);
+    }
+    return null;
+  }
+}
+
+export function httpServerToSidekick(url: string, key: string): ServerToSidekickConnection {
+  return new HttpServerToSidekick(url, key);
+}

package/lib/interfaces/mock.ts

@@ -0,0 +1,32 @@
+import type { ClientToSidekickConnection, ServerToSidekickConnection } from "@covenant-rpc/core/interfaces";
+import type { Sidekick, SidekickClient } from "../sidekick";
+import type { SidekickIncomingMessage, SidekickOutgoingMessage } from "@covenant-rpc/core/sidekick/protocol";
+
+
+export function mockServerToSidekick(sidekick: Sidekick): ServerToSidekickConnection {
+  return {
+    async addConnection(p) {
+      sidekick.addConnection(p);
+      return null;
+    },
+    async update(resources: string[]) {
+      await sidekick.updateResources(resources);
+      return null;
+    },
+    async postMessage(m) {
+      await sidekick.postServerMessage(m);
+      return null;
+    }
+  }
+}
+
+export function mockClientToSidekick(sidekick: Sidekick, client: SidekickClient): ClientToSidekickConnection {
+  return {
+    sendMessage(message: SidekickIncomingMessage) {
+      sidekick.handleClientMessage(client, message);
+    },
+    onMessage(v) {
+
+    }
+  }
+}

package/lib/logger.ts

@@ -0,0 +1,79 @@
+import type { Logger as ILogger, LoggerLevel, Prefix } from "@covenant-rpc/core/logger";
+
+const loggerLevels: Record<LoggerLevel, number> = { "slient": 0, "error": 1, "warn": 2, "info": 3, "debug": 4 };
+
+function levelSatisfies(currentLevel: LoggerLevel, maxLevel: LoggerLevel): boolean {
+  return loggerLevels[currentLevel] <= loggerLevels[maxLevel];
+}
+
+export class Logger implements ILogger {
+  prefixes: Prefix[];
+  level: LoggerLevel
+
+  constructor(level: LoggerLevel, prefixes: Prefix[] = []) {
+    this.prefixes = prefixes;
+    this.level = level;
+  }
+
+  sublogger(prefix: Prefix): Logger {
+    return new Logger(this.level, [...this.prefixes, prefix]);
+  }
+
+  pushPrefix(prefix: Prefix): Logger {
+    this.prefixes.push(prefix);
+    return this
+  }
+
+  clone(): Logger {
+    return new Logger(this.level, [...this.prefixes]);
+  }
+
+  debug(text: string): void {
+    if (!levelSatisfies("debug", this.level)) {
+      return;
+    }
+
+    console.log(`${this.getPrefix()}DEBUG: ${text}`);
+  }
+
+  info(text: string): void {
+    if (!levelSatisfies("info", this.level)) {
+      return;
+    }
+
+    console.log(`${this.getPrefix()}INFO: ${text}`);
+  }
+
+  error(text: string): void {
+    if (!levelSatisfies("error", this.level)) {
+      return;
+    }
+
+    console.log(`${this.getPrefix()}ERROR: ${text}`);
+  }
+
+  warn(text: string): void {
+    if (!levelSatisfies("error", this.level)) {
+      return;
+    }
+
+    console.log(`${this.getPrefix()}WARNING: ${text}`);
+  }
+
+  fatal(text: string): never {
+    console.log("---------------------------------");
+    console.log(`${this.getPrefix()}FATAL: ${text}`);
+    console.log("---------------------------------");
+    throw new Error(`FATAL: ${text}`);
+  }
+
+  private getPrefix(): string {
+    if (this.prefixes.length === 0) {
+      return "";
+    }
+    const strs = this.prefixes.map(p => typeof p === "string" ? p : p());
+    return `[${strs.join(" |> ")}] `;
+
+  }
+}
+