rpc

api/src/rpc.ts

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'node:events';
+import { setTimeout } from 'timers/promises';
+import assert from 'assert/strict';
+
+import type Log from 'bunyan';
+
+import type { Want, Offer, User } from '@prisma/client';
+
+import { Pg } from './pg';
+import { Status } from './offers';
+
+function checkMsgType(msgType: RpcMessageType): msgType is RpcMessageType {
+    if (RpcMessageType[msgType]) {
+        return true;
+    }
+    return false;
+}
+
+// rpc is created per connection from the api
+export default function createRpc(log: Log, pg: Pg, user: User, ws, discogs, offers) {
+    async function ping(): Promise<PongMessage> {
+        return [RpcMessageType.Pong, []];
+    }
+
+    async function offerStatusSet(params: OfferStatusSetParams): Promise<OffersMessage> {
+        log.info(params);
+        const { id, status } = params;
+        assert(id, 'no id supplied');
+        assert(Status[status], 'unknown status');
+
+        const offer = await offers.statusSet(user, id, status);
+        return [RpcMessageType.Offers, []]
+    }
+
+    async function receive(message: any): Promise<RpcMessage> {
+        const [msgType, params] = message;
+
+        if (msgType !== RpcMessageType.Ping) log.info({ msgType, params }, 'rpc message');
+
+        // // this sucks but can't figure out how to convince typescript to agree yet
+        if (checkMsgType(msgType)) {
+            switch (msgType) {
+            case RpcMessageType.Ping:
+                return ping();
+            case RpcMessageType.OfferStatusSet:
+                return offerStatusSet(params);
+            default:
+                throw new Error(`Message type ${msgType} is known but unhandled`);
+            }
+        } else {
+            throw new Error(`Unknown message type ${msgType}`);
+        }
+
+        throw new Error(`Invalid parameters for message type ${msgType}: ${JSON.stringify(message)}`);
+    }
+
+    function send(msg: RpcMessage) {
+        ws.send(JSON.stringify(msg, (key, value) =>
+            typeof value === 'bigint'
+                ? value.toString()
+                : value // return everything else unchanged
+        ))
+    }
+
+    return {
+        receive,
+        send,
+    }
+}
+
+export enum RpcMessageType {
+    Ping = 'Ping',
+    Pong = 'Pong',
+
+    Bundles = 'Bundles',
+    Offers = 'Offers',
+    List = 'List',
+    Error = 'Error',
+
+    OfferStatusSet = 'OfferStatusSet',
+}
+
+type ErrorMessage = [RpcMessageType.Error, string];
+type PongMessage = [RpcMessageType.Pong, []];
+type PingMessage = [RpcMessageType.Ping, []];
+type OffersMessage = [RpcMessageType.Offers, Offer[]];
+type OfferStatusSetMessage = [RpcMessageType.OfferStatusSet, Offer[]];
+
+export type RpcMessage =
+    PingMessage |
+    PongMessage |
+    OffersMessage |
+    OfferStatusSetMessage |
+    ErrorMessage;
+
+
+type OfferStatusSetParams = {
+    id: UUID,
+    status: Status,
+};