Further login process

* APIUtils addition: query validation
* Coach and Server accounts are now properly created if they do not exist
* Profiles now cannot be IDs 1 or 2 (reservedIds)
* Fixed profile username exists bug
* Added relationship manager
* Started relationship management
* DeviceClass and VRMovementMode enum defaults for reserved profiles
* Presence update simplification
* Progression fixes
* Relationship query and object fixes
* Base configuration is now rate limited
* Progression route no longer requires authentication, instead is rate limited
* Base relationships with reserved profiles (Coach and Server)
* DeviceClass required for login
* Get presence route
* Socket route no longer logs
* Socket target base finished

src/socket/socket.ts

@@ -1,6 +1,18 @@
 import { Profile } from "../data/profiles.ts";
 import Logging from "@proxnet/undead-logging";
-import { Message, MessageKind, SignalMessageType, SignalRMessage, SignalRMessageSchema, TargetResult, TargetResultFailure, TargetResultSuccess, TargetResultType } from "./types.ts";
+import {
+    CompletionMessage,
+    Message,
+    MessageKind,
+    SignalMessageType,
+    SignalRMessage,
+    SignalRMessageSchema,
+    TargetResult,
+    TargetResultFailure,
+    TargetResultNotATarget,
+    TargetResultSuccess,
+    TargetResultType
+} from "./types.ts";
 import { SocketTarget } from "./targets/targetbase.ts";
 import { PlayerSocketSubscriptionTarget } from "./targets/SubscribeToPlayers.ts";
 
@@ -26,22 +38,55 @@ export class SignalRSocketHandler {
 
     }
 
-    async #dispatchTarget<T = unknown>(target: string, args: object[]): Promise<TargetResult> {
+    async #dispatchTarget<T = unknown>(target: string, args: unknown): Promise<TargetResult> {
         const targetExec = this.#Targets.get(target);
-        if (!targetExec) return { type: TargetResultType.Failure } as TargetResultFailure;
-        else return { type: TargetResultType.Success, data: await targetExec.exec(args) } as TargetResultSuccess<T>;
+        if (!targetExec) return { type: TargetResultType.NotATarget } as TargetResultNotATarget;
+        else {
+            try {
+                return { type: TargetResultType.Success, data: await targetExec.exec(args) } as TargetResultSuccess<T>;
+            } catch (err) {
+                this.#log.w(`Target '${target}' function error: ${err}`);
+                if (err instanceof Error) return { type: TargetResultType.Failure, err: err } as TargetResultFailure;
+                else return { type: TargetResultType.Failure, err: `${err}` } as TargetResultFailure;
+            }
+        }
     }
 
-    #onMessage(message: Message) {
+    async #onMessage(message: Message) {
         if (message.kind == MessageKind.Protocol) {
             this.sendRaw({});
             return;
         } else {
             this.#log.d(`CLIENT MESSAGE\n   Type: ${message.data.type} (${SignalMessageType[message.data.type]})\n   ${JSON.stringify(message.data)}`);
+            if (message.data.type == SignalMessageType.Invocation && message.data.invocationId) { // don't send completion messages for nonblocking invocations
+                const res = await this.#dispatchTarget(message.data.target, message.data.arguments[0]); // rec room only uses the first index
+                if (res.type == TargetResultType.Success) {
+                    const signalRes: CompletionMessage = {
+                        type: SignalMessageType.Completion,
+                        invocationId: message.data.invocationId,
+                        result: JSON.stringify(res.data)
+                    }
+                    this.sendRaw(signalRes);
+                } else if (res.type == TargetResultType.Failure) {
+                    const signalRes: CompletionMessage = {
+                        type: SignalMessageType.Completion,
+                        invocationId: message.data.invocationId,
+                        error: res.err instanceof Error ? res.err.message : res.err
+                    }
+                    this.sendRaw(signalRes);
+                } else {
+                    const signalRes: CompletionMessage = {
+                        type: SignalMessageType.Completion,
+                        invocationId: message.data.invocationId,
+                        error: "Target not found"
+                    }
+                    this.sendRaw(signalRes);
+                }
+            }
         }
     }
 
-    async #init() {
+    #init() {
         this.#log.source += this.#profile.getId().toString();
 
         this.#log.i(`Created hub socket`);
@@ -82,6 +127,9 @@ export class SignalRSocketHandler {
 
     sendRaw(data: object) {
         this.#socket.send(`${JSON.stringify(data)}\u001e`);
+        // todo sometime: make this less confusing
+        const type = `Type: ${JSON.stringify(data) == '{}' ? 'Protocol Message' : `${(data as SignalRMessage).type} (${SignalMessageType[(data as SignalRMessage).type]})`}`;
+        this.#log.d(`SERVER MESSAGE\n   ${type}\n   ${JSON.stringify(data as SignalRMessage)}`);
     }
 
 }