@casual-simulation/aux-common 3.3.11 → 3.3.13

package/partitions/RemoteYjsPartition.d.ts

@@ -1,59 +1,27 @@
-import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import { Observable } from 'rxjs';
 import { AuxPartitionRealtimeStrategy, YjsPartition } from './AuxPartition';
 import { BotAction, Bot, UpdatedBot, StateUpdatedEvent, BotsState } from '../bots';
 import { PartitionConfig, YjsClientPartitionConfig, RemoteYjsPartitionConfig } from './AuxPartitionConfig';
-import { Doc } from 'yjs';
-import { Action, RemoteActions, StatusUpdate, CurrentVersion } from '../common';
-import { InstRecordsClient } from '../websockets';
+import { RemoteActions } from '../common';
+import { ClientEvent, InstRecordsClient, MaxInstSizeReachedClientError, RateLimitExceededMessage } from '../websockets';
 import { PartitionAuthSource } from './PartitionAuthSource';
+import { RemoteYjsSharedDocument } from '../documents/RemoteYjsSharedDocument';
 /**
  * Attempts to create a YjsPartition from the given config.
  * @param config The config.
  * @param authSource The auth source.
  */
 export declare function createRemoteClientYjsPartition(config: PartitionConfig, authSource: PartitionAuthSource): YjsPartition;
-export declare class RemoteYjsPartitionImpl implements YjsPartition {
-    protected _onVersionUpdated: BehaviorSubject<CurrentVersion>;
-    private _onUpdates;
-    protected _onError: Subject<any>;
-    protected _onEvents: Subject<Action[]>;
-    protected _onStatusUpdated: Subject<StatusUpdate>;
-    protected _hasRegisteredSubs: boolean;
-    private _sub;
+export declare class RemoteYjsPartitionImpl extends RemoteYjsSharedDocument implements YjsPartition {
     private _emittedMaxSizeReached;
-    private _localId;
-    private _remoteId;
-    private _doc;
     private _bots;
     private _masks;
-    private _client;
-    private _currentVersion;
     private _internalPartition;
-    private _isLocalTransaction;
-    private _isRemoteUpdate;
-    private _static;
-    private _skipInitialLoad;
-    private _sendInitialUpdates;
-    private _watchingBranch;
-    private _synced;
-    private _authorized;
-    private _recordName;
-    private _inst;
-    private _branch;
-    private _temporary;
-    private _readOnly;
     private _remoteEvents;
-    private _authSource;
-    private _indexeddb;
-    private _persistence;
     get onBotsAdded(): Observable<Bot[]>;
     get onBotsRemoved(): Observable<string[]>;
     get onBotsUpdated(): Observable<UpdatedBot[]>;
     get onStateUpdated(): Observable<StateUpdatedEvent>;
-    get onVersionUpdated(): Observable<CurrentVersion>;
-    get onError(): Observable<any>;
-    get onEvents(): Observable<Action[]>;
-    get onStatusUpdated(): Observable<StatusUpdate>;
     unsubscribe(): void;
     get closed(): boolean;
     get state(): BotsState;
@@ -62,23 +30,13 @@ export declare class RemoteYjsPartitionImpl implements YjsPartition {
     get space(): string;
     set space(value: string);
     get realtimeStrategy(): AuxPartitionRealtimeStrategy;
-    get site(): string;
-    get onUpdates(): Observable<string[]>;
-    get doc(): Doc;
-    private get _remoteSite();
-    private get _currentSite();
     constructor(client: InstRecordsClient, authSource: PartitionAuthSource, config: YjsClientPartitionConfig | RemoteYjsPartitionConfig);
     applyEvents(events: BotAction[]): Promise<BotAction[]>;
-    init(): Promise<void>;
-    connect(): void;
     sendRemoteEvents(events: RemoteActions[]): Promise<void>;
-    enableCollaboration(): Promise<void>;
-    private _initializePartitionWithoutLoading;
-    private _requestBranch;
-    private _watchBranch;
-    private _updateSynced;
+    protected _handleClientEvent(event: ClientEvent): void;
+    protected _onMaxSizeReached(event: MaxInstSizeReachedClientError): void;
+    protected _onRateLimitExceeded(event: RateLimitExceededMessage): void;
     private _applyEvents;
-    private _applyUpdates;
     private _processTransaction;
     private _mapToBot;
     /**

package/partitions/RemoteYjsPartition.js

@@ -18,18 +18,17 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { isTagEdit, preserve, del, insert, edit, } from '../bots';
-import { Subscription, Subject, BehaviorSubject, firstValueFrom, } from 'rxjs';
-import { breakIntoIndividualEvents, botAdded, createBot, botRemoved, hasValue, botUpdated, action, ON_REMOTE_DATA_ACTION_NAME, ON_REMOTE_WHISPER_ACTION_NAME, asyncResult, asyncError, convertToString, ON_SPACE_MAX_SIZE_REACHED, ON_SPACE_RATE_LIMIT_EXCEEDED_ACTION_NAME, } from '../bots';
-import { Doc, Text, Map, applyUpdate, YMapEvent, createAbsolutePositionFromRelativePosition, YTextEvent, encodeStateAsUpdate, } from 'yjs';
+import { isTagEdit, preserve, del, insert, edit, ON_REMOTE_WHISPER_ACTION_NAME, ON_REMOTE_DATA_ACTION_NAME, } from '../bots';
+import { BehaviorSubject, } from 'rxjs';
+import { breakIntoIndividualEvents, botAdded, createBot, botRemoved, hasValue, botUpdated, action, asyncResult, asyncError, convertToString, ON_SPACE_MAX_SIZE_REACHED, ON_SPACE_RATE_LIMIT_EXCEEDED_ACTION_NAME, } from '../bots';
+import { Text, Map, applyUpdate, YMapEvent, createAbsolutePositionFromRelativePosition, YTextEvent, } from 'yjs';
 import { MemoryPartitionImpl } from './MemoryPartition';
 import { createRelativePositionFromStateVector, getClock, getStateVector, } from '../yjs/YjsHelpers';
 import { fromByteArray, toByteArray } from 'base64-js';
-import { filter, startWith } from 'rxjs/operators';
 import { YjsPartitionImpl } from './YjsPartition';
 import { ensureTagIsSerializable, supportsRemoteEvent } from './PartitionUtils';
-import { device, getConnectionId, } from '../common';
-import { YjsIndexedDBPersistence } from '../yjs/YjsIndexedDBPersistence';
+import { device, } from '../common';
+import { RemoteYjsSharedDocument } from '../documents/RemoteYjsSharedDocument';
 /**
  * Attempts to create a YjsPartition from the given config.
  * @param config The config.
@@ -41,8 +40,7 @@ export function createRemoteClientYjsPartition(config, authSource) {
     }
     return undefined;
 }
-const APPLY_UPDATES_TO_INST_TRANSACTION_ORIGIN = '__apply_updates_to_inst';
-export class RemoteYjsPartitionImpl {
+export class RemoteYjsPartitionImpl extends RemoteYjsSharedDocument {
     get onBotsAdded() {
         return this._internalPartition.onBotsAdded;
     }
@@ -55,18 +53,6 @@ export class RemoteYjsPartitionImpl {
     get onStateUpdated() {
         return this._internalPartition.onStateUpdated;
     }
-    get onVersionUpdated() {
-        return this._onVersionUpdated;
-    }
-    get onError() {
-        return this._onError;
-    }
-    get onEvents() {
-        return this._onEvents;
-    }
-    get onStatusUpdated() {
-        return this._onStatusUpdated;
-    }
     unsubscribe() {
         return this._sub.unsubscribe();
     }
@@ -85,51 +71,13 @@ export class RemoteYjsPartitionImpl {
     get realtimeStrategy() {
         return this._static ? 'delayed' : 'immediate';
     }
-    get site() {
-        return this._currentSite;
-    }
-    get onUpdates() {
-        return this._onUpdates.pipe(startWith([fromByteArray(encodeStateAsUpdate(this._doc))]));
-    }
-    get doc() {
-        return this._doc;
-    }
-    get _remoteSite() {
-        return this._remoteId.toString();
-    }
-    get _currentSite() {
-        return this._localId.toString();
-    }
     constructor(client, authSource, config) {
-        this._onError = new Subject();
-        this._onEvents = new Subject();
-        this._onStatusUpdated = new Subject();
-        this._hasRegisteredSubs = false;
-        this._sub = new Subscription();
+        super(client, authSource, config);
         this._emittedMaxSizeReached = false;
-        this._doc = new Doc();
-        this._isLocalTransaction = true;
-        this._isRemoteUpdate = false;
-        this._sendInitialUpdates = false;
         this.type = 'yjs';
         this.private = config.private || false;
-        this._client = client;
-        this._static = config.static;
-        this._skipInitialLoad = config.skipInitialLoad;
         this._remoteEvents =
             'remoteEvents' in config ? config.remoteEvents : true;
-        this._recordName = config.recordName;
-        this._inst = config.inst;
-        this._branch = config.branch;
-        this._temporary = config.temporary;
-        this._persistence = config.localPersistence;
-        this._synced = false;
-        this._authorized = false;
-        this._authSource = authSource;
-        // static implies read only
-        this._readOnly = config.readOnly || this._static || false;
-        this._localId = this._doc.clientID;
-        this._remoteId = new Doc().clientID;
         this._bots = this._doc.getMap('bots');
         this._masks = this._doc.getMap('masks');
         this._doc.on('afterTransaction', (transaction) => {
@@ -141,7 +89,6 @@ export class RemoteYjsPartitionImpl {
             vector: {},
         };
         this._onVersionUpdated = new BehaviorSubject(this._currentVersion);
-        this._onUpdates = new Subject();
         this._internalPartition = new MemoryPartitionImpl({
             type: 'memory',
             initialState: {},
@@ -194,26 +141,6 @@ export class RemoteYjsPartitionImpl {
             return [];
         });
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    connect() {
-        var _a, _b;
-        if (!this._temporary && ((_a = this._persistence) === null || _a === void 0 ? void 0 : _a.saveToIndexedDb)) {
-            console.log('[RemoteYjsPartition] Using IndexedDB persistence');
-            const name = `${(_b = this._recordName) !== null && _b !== void 0 ? _b : ''}/${this._inst}/${this._branch}`;
-            this._indexeddb = new YjsIndexedDBPersistence(name, this._doc);
-        }
-        if (this._skipInitialLoad) {
-            this._initializePartitionWithoutLoading();
-        }
-        else if (this._static) {
-            this._requestBranch();
-        }
-        else {
-            this._watchBranch();
-        }
-    }
     sendRemoteEvents(events) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._readOnly || !this._remoteEvents) {
@@ -310,7 +237,7 @@ export class RemoteYjsPartitionImpl {
                     else if (event.event.type === 'apply_updates_to_inst') {
                         const action = event.event;
                         try {
-                            this._applyUpdates(action.updates.map((u) => u.update), APPLY_UPDATES_TO_INST_TRANSACTION_ORIGIN);
+                            this.applyStateUpdates(action.updates);
                             this._onEvents.next([
                                 asyncResult(event.taskId, null, false),
                             ]);
@@ -322,11 +249,7 @@ export class RemoteYjsPartitionImpl {
                     else if (event.event.type === 'get_current_inst_update') {
                         const action = event.event;
                         try {
-                            const update = {
-                                id: 0,
-                                timestamp: Date.now(),
-                                update: fromByteArray(encodeStateAsUpdate(this._doc)),
-                            };
+                            const update = this.getStateUpdate();
                             this._onEvents.next([
                                 asyncResult(event.taskId, update, false),
                             ]);
@@ -345,277 +268,56 @@ export class RemoteYjsPartitionImpl {
             }
         });
     }
-    enableCollaboration() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._static = false;
-            this._skipInitialLoad = false;
-            this._sendInitialUpdates = true;
-            this._synced = false;
-            const promise = firstValueFrom(this._onStatusUpdated.pipe(filter((u) => u.type === 'sync' && u.synced)));
-            this._watchBranch();
-            yield promise;
-        });
-    }
-    _initializePartitionWithoutLoading() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            this._onStatusUpdated.next({
-                type: 'connection',
-                connected: true,
-            });
-            const indicator = this._client.connection.indicator;
-            const connectionId = indicator
-                ? getConnectionId(indicator)
-                : 'missing-connection-id';
-            this._onStatusUpdated.next({
-                type: 'authentication',
-                authenticated: true,
-                info: (_a = this._client.connection.info) !== null && _a !== void 0 ? _a : {
-                    connectionId: connectionId,
-                    sessionId: null,
-                    userId: null,
-                },
-            });
-            this._updateSynced(true);
-        });
-    }
-    _requestBranch() {
-        this._client
-            .getBranchUpdates(this._recordName, this._inst, this._branch)
-            .subscribe({
-            next: (updates) => {
-                this._onStatusUpdated.next({
-                    type: 'connection',
-                    connected: true,
-                });
-                this._onStatusUpdated.next({
-                    type: 'authentication',
-                    authenticated: true,
-                    info: this._client.connection.info,
-                });
-                this._updateSynced(true);
-                this._applyUpdates(updates.updates);
-                if (!this._static) {
-                    // the partition has been unlocked while getting the branch
-                    this._watchBranch();
-                }
-            },
-            error: (err) => this._onError.next(err),
-        });
-    }
-    _watchBranch() {
-        if (this._watchingBranch) {
-            return;
+    _handleClientEvent(event) {
+        if (event.action.type === 'device') {
+            if (event.action.event.type === 'action') {
+                const remoteAction = event.action.event;
+                this._onEvents.next([
+                    action(ON_REMOTE_DATA_ACTION_NAME, null, null, {
+                        name: remoteAction.eventName,
+                        that: remoteAction.argument,
+                        remoteId: event.action.connection.connectionId,
+                    }),
+                    action(ON_REMOTE_WHISPER_ACTION_NAME, null, null, {
+                        name: remoteAction.eventName,
+                        that: remoteAction.argument,
+                        playerId: event.action.connection.connectionId,
+                    }),
+                ]);
+            }
+            else if (hasValue(event.action.taskId)) {
+                const newEvent = device(event.action.connection, Object.assign(Object.assign({}, event.action.event), { taskId: event.action.taskId, playerId: event.action.connection.connectionId }), event.action.taskId);
+                this._onEvents.next([newEvent]);
+            }
+            else {
+                this._onEvents.next([event.action]);
+            }
         }
-        this._watchingBranch = true;
-        this._sub.add(this._client.connection.connectionState.subscribe({
-            next: (state) => {
-                const connected = state.connected;
-                this._onStatusUpdated.next({
-                    type: 'connection',
-                    connected: !!connected,
-                });
-                if (connected) {
-                    this._onStatusUpdated.next({
-                        type: 'authentication',
-                        authenticated: true,
-                        info: state.info,
-                    });
-                }
-                else {
-                    this._updateSynced(false);
-                }
-            },
-            error: (err) => this._onError.next(err),
-        }));
-        this._sub.add(this._client
-            .watchBranchUpdates({
-            type: 'repo/watch_branch',
-            recordName: this._recordName,
-            inst: this._inst,
-            branch: this._branch,
-            temporary: this._temporary,
-        })
-            .subscribe({
-            next: (event) => {
-                // The partition should become synced if it was not synced
-                // and it just got some new data.
-                if (!this._synced && event.type === 'updates') {
-                    if (this._sendInitialUpdates) {
-                        this._sendInitialUpdates = false;
-                        const update = encodeStateAsUpdate(this._doc);
-                        const updates = [fromByteArray(update)];
-                        this._client.addUpdates(this._recordName, this._inst, this._branch, updates);
-                    }
-                    this._updateSynced(true);
-                }
-                if (event.type === 'updates') {
-                    this._applyUpdates(event.updates);
-                }
-                else if (event.type === 'event') {
-                    if (event.action.type === 'device') {
-                        if (event.action.event.type === 'action') {
-                            const remoteAction = event.action
-                                .event;
-                            this._onEvents.next([
-                                action(ON_REMOTE_DATA_ACTION_NAME, null, null, {
-                                    name: remoteAction.eventName,
-                                    that: remoteAction.argument,
-                                    remoteId: event.action.connection
-                                        .connectionId,
-                                }),
-                                action(ON_REMOTE_WHISPER_ACTION_NAME, null, null, {
-                                    name: remoteAction.eventName,
-                                    that: remoteAction.argument,
-                                    playerId: event.action.connection
-                                        .connectionId,
-                                }),
-                            ]);
-                        }
-                        else if (hasValue(event.action.taskId)) {
-                            const newEvent = device(event.action.connection, Object.assign(Object.assign({}, event.action.event), { taskId: event.action.taskId, playerId: event.action.connection
-                                    .connectionId }), event.action.taskId);
-                            this._onEvents.next([newEvent]);
-                        }
-                        else {
-                            this._onEvents.next([event.action]);
-                        }
-                    }
-                    else {
-                        this._onEvents.next([event.action]);
-                    }
-                }
-                else if (event.type === 'error') {
-                    if (event.kind === 'max_size_reached') {
-                        if (!this._emittedMaxSizeReached) {
-                            console.log('[RemoteYjsPartition] Max size reached!', this.space);
-                            this._emittedMaxSizeReached = true;
-                            this._onEvents.next([
-                                action(ON_SPACE_MAX_SIZE_REACHED, null, null, {
-                                    space: this.space,
-                                    maxSizeInBytes: event.maxBranchSizeInBytes,
-                                    neededSizeInBytes: event.neededBranchSizeInBytes,
-                                }),
-                            ]);
-                        }
-                    }
-                    else if (event.kind === 'error') {
-                        const errorCode = event.info.errorCode;
-                        if (errorCode === 'not_authorized' ||
-                            errorCode ===
-                                'subscription_limit_reached' ||
-                            errorCode === 'inst_not_found' ||
-                            errorCode === 'record_not_found' ||
-                            errorCode === 'invalid_record_key' ||
-                            errorCode === 'invalid_token' ||
-                            errorCode ===
-                                'unacceptable_connection_id' ||
-                            errorCode ===
-                                'unacceptable_connection_token' ||
-                            errorCode === 'user_is_banned' ||
-                            errorCode === 'not_logged_in' ||
-                            errorCode === 'session_expired') {
-                            this._onStatusUpdated.next({
-                                type: 'authorization',
-                                authorized: false,
-                                error: event.info,
-                            });
-                            this._authSource.sendAuthRequest({
-                                type: 'request',
-                                kind: 'not_authorized',
-                                errorCode: event.info.errorCode,
-                                errorMessage: event.info.errorMessage,
-                                origin: this._client.connection.origin,
-                                reason: event.info.reason,
-                                resource: {
-                                    type: 'inst',
-                                    recordName: this._recordName,
-                                    inst: this._inst,
-                                },
-                            });
-                        }
-                    }
-                }
-                else if (event.type === 'repo/watch_branch_result') {
-                    if (event.success === false) {
-                        const errorCode = event.errorCode;
-                        if (errorCode === 'not_authorized' ||
-                            errorCode ===
-                                'subscription_limit_reached' ||
-                            errorCode === 'inst_not_found' ||
-                            errorCode === 'record_not_found' ||
-                            errorCode === 'invalid_record_key' ||
-                            errorCode === 'invalid_token' ||
-                            errorCode ===
-                                'unacceptable_connection_id' ||
-                            errorCode ===
-                                'unacceptable_connection_token' ||
-                            errorCode === 'user_is_banned' ||
-                            errorCode === 'not_logged_in' ||
-                            errorCode === 'session_expired') {
-                            const { type } = event, error = __rest(event, ["type"]);
-                            this._onStatusUpdated.next({
-                                type: 'authorization',
-                                authorized: false,
-                                error: error,
-                            });
-                            this._authSource.sendAuthRequest({
-                                type: 'request',
-                                kind: 'not_authorized',
-                                errorCode: event.errorCode,
-                                errorMessage: event.errorMessage,
-                                origin: this._client.connection.origin,
-                                reason: event.reason,
-                                resource: {
-                                    type: 'inst',
-                                    recordName: this._recordName,
-                                    inst: this._inst,
-                                },
-                            });
-                        }
-                    }
-                }
-            },
-            error: (err) => this._onError.next(err),
-        }));
-        this._sub.add(this._client.watchRateLimitExceeded().subscribe((event) => {
-            console.error('[RemoteYjsPartition] Rate limit exceeded!', event);
+        else {
+            super._handleClientEvent(event);
+        }
+    }
+    _onMaxSizeReached(event) {
+        super._onMaxSizeReached(event);
+        if (!this._emittedMaxSizeReached) {
+            console.log('[RemoteYjsPartition] Max size reached!', this.recordName, this.address);
+            this._emittedMaxSizeReached = true;
             this._onEvents.next([
-                action(ON_SPACE_RATE_LIMIT_EXCEEDED_ACTION_NAME, null, null, {
+                action(ON_SPACE_MAX_SIZE_REACHED, null, null, {
                     space: this.space,
+                    maxSizeInBytes: event.maxBranchSizeInBytes,
+                    neededSizeInBytes: event.neededBranchSizeInBytes,
                 }),
             ]);
-        }));
-        const updateHandler = (update, origin, doc, transaction) => {
-            if (this._readOnly) {
-                return;
-            }
-            if (transaction &&
-                (transaction.local ||
-                    origin === APPLY_UPDATES_TO_INST_TRANSACTION_ORIGIN)) {
-                const updates = [fromByteArray(update)];
-                this._client.addUpdates(this._recordName, this._inst, this._branch, updates);
-                this._onUpdates.next(updates);
-            }
-        };
-        this._doc.on('update', updateHandler);
-        this._sub.add(new Subscription(() => {
-            this._doc.off('update', updateHandler);
-        }));
-    }
-    _updateSynced(synced) {
-        if (synced && !this._authorized) {
-            this._authorized = true;
-            this._onStatusUpdated.next({
-                type: 'authorization',
-                authorized: true,
-            });
         }
-        this._synced = synced;
-        this._onStatusUpdated.next({
-            type: 'sync',
-            synced: synced,
-        });
+    }
+    _onRateLimitExceeded(event) {
+        super._onRateLimitExceeded(event);
+        this._onEvents.next([
+            action(ON_SPACE_RATE_LIMIT_EXCEEDED_ACTION_NAME, null, null, {
+                space: this.space,
+            }),
+        ]);
     }
     _applyEvents(events) {
         try {
@@ -689,18 +391,17 @@ export class RemoteYjsPartitionImpl {
             this._isLocalTransaction = false;
         }
     }
-    _applyUpdates(updates, transactionOrigin) {
-        try {
-            this._isRemoteUpdate = true;
-            for (let updateBase64 of updates) {
-                const update = toByteArray(updateBase64);
-                applyUpdate(this._doc, update, transactionOrigin);
-            }
-        }
-        finally {
-            this._isRemoteUpdate = false;
-        }
-    }
+    // private _applyUpdates(updates: string[], transactionOrigin?: string) {
+    //     try {
+    //         this._isRemoteUpdate = true;
+    //         for (let updateBase64 of updates) {
+    //             const update = toByteArray(updateBase64);
+    //             applyUpdate(this._doc, update, transactionOrigin);
+    //         }
+    //     } finally {
+    //         this._isRemoteUpdate = false;
+    //     }
+    // }
     _processTransaction(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
             let memoryEvents = [];