chore(refactor): instantiate SessionConnection with plain data

Signed-off-by: Max <[email protected]>

cypress/support/sessions.js

@@ -12,7 +12,7 @@ const url = Cypress.config('baseUrl').replace(/\/index.php\/?$/g, '')
 
 Cypress.Commands.add('createTextSession', async (fileId, options = {}) => {
 	const { connection, data } = await open({ fileId, token: options.shareToken, ...options })
-	return new SessionConnection({ data }, connection)
+	return new SessionConnection(data, connection)
 })
 
 Cypress.Commands.add('destroySession', async (sessionConnection) => {

src/services/SessionConnection.js

@@ -26,7 +26,7 @@
 	#hasOwner
 	connection
 
-	constructor(response, connection) {
+	constructor(data, connection) {
 		const {
 			document,
 			session,
@@ -35,7 +35,7 @@
 			content,
 			documentState,
 			hasOwner,
-		} = response.data
+		} = data
 		this.#document = document
 		this.#session = session
 		this.#lock = lock
@@ -82,14 +82,14 @@
 			documentId: this.#document.id,
 			sessionId: this.#session.id,
 			sessionToken: this.#session.token,
 			token: this.connection.shareToken,
 		}
 	}
 
 	sync({ version }) {
 		return this.#post(this.#url(`session/${this.#document.id}/sync`), {
 			...this.#defaultParams,
 			filePath: this.connection.filePath,
 			baseVersionEtag: this.#document.baseVersionEtag,
 			version,
 		})
@@ -99,7 +99,7 @@
 		const url = this.#url(`session/${this.#document.id}/save`)
 		const postData = {
 			...this.#defaultParams,
 			filePath: this.connection.filePath,
 			baseVersionEtag: this.#document.baseVersionEtag,
 			...data,
 		}
@@ -111,7 +111,7 @@
 		const url = this.#url(`session/${this.#document.id}/save`)
 		const postData = {
 			...this.#defaultParams,
 			filePath: this.connection.filePath,
 			baseVersionEtag: this.#document.baseVersionEtag,
 			...data,
 			requestToken: getRequestToken() ?? '',
@@ -145,7 +145,7 @@
 			+ '&sessionToken='
 			+ encodeURIComponent(this.#session.token)
 			+ '&token='
 			+ encodeURIComponent(this.connection.shareToken || '')
 		return this.#post(url, formData, {
 			headers: {
 				'Content-Type': 'multipart/form-data',
@@ -172,7 +172,7 @@
 	}
 
 	close() {
 		this.closed = true
 	}
 
 	// To be used in Cypress tests only

src/services/SyncService.ts

@@ -134,16 +134,16 @@
 	}
 
 	get isReadOnly() {
 		return this.sessionConnection?.state.document.readOnly
 	}
 
 	get hasOwner() {
 		return this.sessionConnection?.hasOwner
 	}
 
 	get guestName() {
 		return this.sessionConnection?.session.guestName
 	}
 
 	hasActiveConnection(): this is {
 		sessionConnection: SessionConnection
@@ -154,135 +154,132 @@
 
 	async open() {
 		if (this.hasActiveConnection()) {
 			return
 		}
 		const data = await this.#openConnection().catch((e) => this._emitError(e))
 		if (!data) {
 			// Error was already emitted above
 			return
 		}
-		this.sessionConnection = new SessionConnection(
-			{ data },
-			this.connection.value,
-		)
+		this.sessionConnection = new SessionConnection(data, this.connection.value)
 		this.backend = new PollingBackend(this, this.sessionConnection)
 		this.version = this.sessionConnection.docStateVersion
 		this.emit('opened', this.sessionConnection.state)
 	}
 
 	startSync() {
 		this.backend?.connect()
 	}
 
 	syncUp() {
 		this.backend?.resetRefetchTimer()
 	}
 
 	_emitError(error: { response?: object; code?: string }) {
 		if (!error.response || error.code === 'ECONNABORTED') {
 			this.emit('error', { type: ERROR_TYPE.CONNECTION_FAILED, data: {} })
 		} else {
 			this.emit('error', { type: ERROR_TYPE.LOAD_ERROR, data: error.response })
 		}
 	}
 
 	updateSession(guestName: string) {
 		if (!this.sessionConnection?.isPublic) {
 			return Promise.reject(new Error())
 		}
 		return this.sessionConnection.update(guestName).catch((error) => {
 			logger.error('Failed to update the session', { error })
 			return Promise.reject(error)
 		})
 	}
 
 	sendStep(step: ArrayBuffer) {
 		this.#outbox.storeStep(step)
 		this.sendSteps()
 	}
 
 	sendSteps() {
 		// If already waiting to send, do nothing.
 		if (this.#sendIntervalId) {
 			return
 		}
 		this.#sendIntervalId = setInterval(() => {
 			if (this.sessionConnection && !this.#sending) {
 				this.sendStepsNow().catch((err) => logger.error(err))
 			}
 		}, 200)
 	}
 
 	async sendStepsNow() {
 		this.#sending = true
 		clearInterval(this.#sendIntervalId)
 		this.#sendIntervalId = undefined
 		const sendable = this.#outbox.getDataToSend()
 		if (sendable.steps.length > 0) {
 			this.emit('stateChange', { dirty: true })
 		}
 		if (!this.hasActiveConnection()) {
 			return
 		}
 		return push(this.connection, {
 			version: this.version,
 			...sendable,
 		})
 			.then((response) => {
 				this.#outbox.clearSentData(sendable)
 				const { steps, documentState } = response.data as {
 					steps: Step[]
 					documentState: string
 				}
 				if (documentState) {
 					const documentStateStep = documentStateToStep(documentState)
 					this.emit('sync', {
 						version: this.version,
 						steps: [documentStateStep],
 						document: this.sessionConnection.document,
 					})
 				}
 				this.pushError = 0
 				this.#sending = false
 				if (steps?.length > 0) {
 					this.receiveSteps({ steps })
 				}
 			})
 			.catch((err) => {
 				const { response, code } = err
 				this.#sending = false
 				this.pushError++
 				logger.error('Failed to push the steps to the server', err)
 				if (!response || code === 'ECONNABORTED') {
 					this.emit('error', {
 						type: ERROR_TYPE.CONNECTION_FAILED,
 						data: {},
 					})
 				}
 				if (response?.status === 412) {
 					this.emit('error', {
 						type: ERROR_TYPE.LOAD_ERROR,
 						data: response,
 					})
 				} else if (response?.status === 403) {
 					// either the session is invalid or the document is read only.
 					logger.error('failed to write to document - not allowed')
 					this.emit('error', {
 						type: ERROR_TYPE.PUSH_FORBIDDEN,
 						data: {},
 					})
 				} else {
 					this.emit('error', { type: ERROR_TYPE.PUSH_FAILURE, data: {} })
 				}
 				throw new Error('Failed to apply steps. Retry!', { cause: err })
 			})
 	}
 
 	receiveSteps({
 		steps,
 		document,
 		sessions = [],
 	}: {
 		steps: { data: string[]; version: number; sessionId: number }[]
 		document?: object
 		sessions?: {
@@ -290,97 +287,97 @@
 			lastAwarenessMessage: string
 			clientId: number
 		}[]
 	}) {
 		const awareness = sessions
 			.filter(
 				(s) =>
 					s.lastContact
 					> Math.floor(Date.now() / 1000) - COLLABORATOR_DISCONNECT_TIME,
 			)
 			.filter((s) => s.lastAwarenessMessage)
 			.map((s) => {
 				return { step: s.lastAwarenessMessage, clientId: s.clientId }
 			})
 		const newSteps = [...awareness]
 		for (let i = 0; i < steps.length; i++) {
 			const singleSteps = steps[i].data
 			if (this.version < steps[i].version) {
 				this.version = steps[i].version
 			}
 			if (!Array.isArray(singleSteps)) {
 				logger.error('Invalid step data, skipping step', { step: steps[i] })
 				// TODO: recover
 				continue
 			}
 			singleSteps.forEach((step) => {
 				newSteps.push({
 					step,
 					clientId: steps[i].sessionId,
 				})
 			})
 		}
 		this.#lastStepPush = Date.now()
 		this.emit('sync', {
 			steps: newSteps,
 			document,
 			version: this.version,
 		})
 	}
 
 	checkIdle() {
 		const lastPushMinutesAgo = (Date.now() - this.#lastStepPush) / 1000 / 60
 		if (lastPushMinutesAgo > IDLE_TIMEOUT) {
 			logger.debug(
 				`[SyncService] Document is idle for ${IDLE_TIMEOUT} minutes, suspending connection`,
 			)
 			this.emit('idle')
 			return true
 		}
 		return false
 	}
 
 	async sendRemainingSteps() {
 		if (!this.#outbox.hasUpdate) {
 			return
 		}
 		logger.debug('sending final steps')
 		return this.sendStepsNow().catch((err) => logger.error(err))
 	}
 
 	async close() {
 		// Make sure to leave no pending requests behind.
 		this.backend?.disconnect()
 		if (this.connection.value) {
 			close(this.connection.value)
 				// Log and ignore possible network issues.
 				.catch((e) => {
 					logger.info('Failed to close connection.', { e })
 				})
 		}
 		// Mark sessionConnection closed so hasActiveConnection turns false and we can reconnect.
 		this.sessionConnection?.close()
 	}
 
 	uploadAttachment(file: object) {
 		if (!this.hasActiveConnection()) {
 			throw new Error('Not connected to server.')
 		}
 		return this.sessionConnection.uploadAttachment(file)
 	}
 
 	insertAttachmentFile(filePath: string) {
 		if (!this.hasActiveConnection()) {
 			throw new Error('Not connected to server.')
 		}
 		return this.sessionConnection.insertAttachmentFile(filePath)
 	}
 
 	createAttachment(template: object) {
 		if (!this.hasActiveConnection()) {
 			throw new Error('Not connected to server.')
 		}
 		return this.sessionConnection.createAttachment(template)
 	}
 
 	// For better typing use the bus directly: `syncService.bus.on()`.
 	on(event: keyof EventTypes, callback: Handler<unknown>) {
@@ -389,9 +386,9 @@
 	}
 
 	off(event: keyof EventTypes, callback: Handler<unknown>) {
 		this.bus.off(event, callback)
 		return this
 	}
 
 	emit(event: keyof EventTypes, data?: unknown) {
 		this.bus.emit(event, data)