@4players/odin-plugin-web 1.0.0-alpha.12 → 1.0.0-alpha.13

package/lib/plugin/roomConnection.d.ts

@@ -1,5 +1,4 @@
-import { Backend, RoomCommands, Result } from '@4players/odin-common';
-import { z } from 'zod';
+import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
 import { Token } from './token';
@@ -14,6 +13,8 @@ export declare class RoomConnection {
     private _Token;
     private _UserData;
     private _Position;
+    private _ConnectionFailures;
+    private _FailureLimit;
     private _LastTokenRenew;
     private readonly _Closed;
     get token(): Token;
@@ -23,7 +24,7 @@ export declare class RoomConnection {
     get mainConnection(): MainConnection | undefined;
     constructor(connectionPool: ConnectionPool, onEvent: Backend.OnEvent, gateway: URL | undefined, token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]);
     request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
-    typedRequest<Name extends Extract<keyof RoomCommands, string>>(name: Name, properties: z.infer<RoomCommands[Name]['request']>): Promise<Result<z.infer<RoomCommands[Name]['response']>> | 'closed'>;
+    typedRequest<Name extends Extract<keyof RoomCommands, string>>(name: Name, properties: Infer<RoomCommands[Name]['request']>): Promise<Result<Infer<RoomCommands[Name]['response']>> | 'closed'>;
     close(): void;
     get renewTokenIn(): number;
     private _Main;

package/lib/plugin/roomConnection.js

@@ -8,7 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Selector, failure, sleep, success, RoomCommandsRpc, } from '@4players/odin-common';
-import { z } from 'zod';
 import { RpcConnection } from './rpcConnection';
 import { Token } from './token';
 import { ConnectTimeout, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
@@ -34,6 +33,8 @@ export class RoomConnection {
         this.gateway = gateway;
         this.roomId = roomId;
         this._Close = new AbortController();
+        this._ConnectionFailures = 0;
+        this._FailureLimit = 5;
         this._LastTokenRenew = performance.now();
         this._Closed = new Promise((accept) => this._Close.signal.addEventListener('abort', () => accept('closed'), {
             once: true,
@@ -144,6 +145,10 @@ export class RoomConnection {
                 if (mainConnection === 'closed')
                     return failure('connection pool closed'); // connection pool is closed
                 if (mainConnection.type === 'Failure') {
+                    if (this._ConnectionFailures < this._FailureLimit) {
+                        this._ConnectionFailures++;
+                        return failure(`Connection failed; ${mainConnection.reason}`);
+                    }
                     this._ChangeStatus('Joining', `connection failed; ${mainConnection.reason}`);
                     return success('continue');
                 }
@@ -180,13 +185,11 @@ export class RoomConnection {
         });
     }
     _ChangeStatus(status, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const properties = {
-                status,
-                message,
-            };
-            this.onEvent('RoomStatusChanged', properties);
-        });
+        const properties = {
+            status,
+            message,
+        };
+        this.onEvent('RoomStatusChanged', properties);
     }
     _HandleConnection(main, webSocket) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -264,6 +267,7 @@ export class RoomConnection {
     }
 }
 function contactGateway(gateway, token, signal) {
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const response = yield fetch(gateway, {
@@ -275,24 +279,13 @@ function contactGateway(gateway, token, signal) {
                 },
                 signal,
             });
-            const schema = z.union([
-                z.object({
-                    result: z.object({
-                        token: z.string(),
-                    }),
-                }),
-                z.object({
-                    error: z.object({
-                        message: z.string(),
-                    }),
-                }),
-            ]);
-            const body = schema.parse(yield response.json());
+            // TODO: re-add validation once schemas are available in common
+            const body = yield response.json();
             if ('result' in body) {
                 return Token.parse(body.result.token);
             }
             else {
-                console.error(`gateway rejected token; ${body.error.message}`);
+                console.error(`gateway rejected token; ${(_b = (_a = body.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'malformed response'}`);
                 return success('rejected');
             }
         }

package/lib/plugin/rpcConnection.d.ts

@@ -1,5 +1,4 @@
-import * as z from 'zod';
-import { Result, Accept, MessagePackRpc, Notifications } from '@4players/odin-common';
+import { Result, Accept, MessagePackRpc, Notifications, Infer, Commands } from '@4players/odin-common';
 export interface RpcMessage {
     name: string;
     properties: unknown;
@@ -31,25 +30,20 @@ export declare class RpcConnection {
     private _OnEvent;
     private _Cleanup;
 }
-export type Commands = Record<string, {
-    request: z.ZodTypeAny;
-    response: z.ZodTypeAny;
-}>;
-export type Events = Record<string, z.ZodTypeAny>;
 export interface TypedRpcMessage<Name extends string, Properties> extends RpcMessage {
     name: Name;
     properties: Properties;
 }
-export type RealizedEvents<E extends Events> = {
-    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, z.infer<E[Name]>>;
+export type RealizedEvents<E extends Notifications> = {
+    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, Infer<E[Name]>>;
 }[Extract<keyof E, string>];
-export declare class TypedRpcConnection<C extends Commands, E extends Events> extends RpcConnection {
+export declare class TypedRpcConnection<C extends Commands, E extends Notifications> extends RpcConnection {
     readonly _Commands: C;
     readonly _Events: E;
     constructor(webSocket: WebSocket, _Commands: C, _Events: E);
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): Promise<Result<z.infer<C[Name]['response']>> | 'closed'>;
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>, timeout: number): Promise<Result<z.infer<C[Name]['response']>> | 'closed' | 'timeout'>;
-    notify<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): void;
+    request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): Promise<Result<Infer<C[Name]['response']>> | 'closed'>;
+    request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>, timeout: number): Promise<Result<Infer<C[Name]['response']>> | 'closed' | 'timeout'>;
+    notify<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): void;
     recv(): Promise<RealizedEvents<E> | 'closed'>;
 }
 export declare function parseRpc(buffer: ArrayBuffer): Result<MessagePackRpc>;

package/lib/plugin/token.d.ts

@@ -1,5 +1,4 @@
-import { z } from 'zod';
-import { TokenAudienceSchema, TokenClaims, Result } from '@4players/odin-common';
+import { TokenAudienceSchema, TokenClaims, Result, Infer } from '@4players/odin-common';
 export declare class Token {
     readonly text: string;
     readonly claims: TokenClaims;
@@ -11,6 +10,6 @@ export declare class Token {
     get address(): URL | undefined;
     get upstream(): Token | undefined;
     get defaultRoomId(): string | undefined;
-    hasAudience(audience: z.infer<typeof TokenAudienceSchema>): boolean;
+    hasAudience(audience: Infer<typeof TokenAudienceSchema>): boolean;
     toString(): string;
 }