Paths

Table of Contentst

-
native/
-
cpp/CommonCpp/
-
CommonCpp/
-
NativeModules/
-
CMakeLists.txt
-
CommCoreModule.h
-
CommCoreModule.cpp
-
PersistentStorageUtilities/DataStores/
-
DataStores/
-
SyncedMetadataStore.h
-
SyncedMetadataStore.cpp
-
SyncedMetadataStoreOperations.h
-
_generated/
-
commJSI-generated.cpp
-
commJSI.h
-
ios/Comm.xcodeproj/
-
Comm.xcodeproj/
-
project.pbxproj
-
schema/
-
CommCoreModuleSchema.js

[sqlite] implement C++ synced metadata store ops
ClosedPublic
Actions

Authored by will on Mar 27 2024, 3:26 PM.

Details

Reviewers

kamil
ginsu
atul

Commits

rCOMM585c20c0a367: [sqlite] implement C++ synced metadata store ops

Summary

Introduces code allowing native to use sqlite synced metadata store ops

Depends on D11417

Test Plan

Ran the following code:

async function run_test() {
  console.log('running run_test()');

  await commCoreModule.processSyncedMetadataStoreOperations([
    {
      type: 'remove_all_synced_metadata',
    },
  ]);

  let data = await commCoreModule.getClientDBStore();
  console.log(data.syncedMetadata);

  await commCoreModule.processSyncedMetadataStoreOperations([
    {
      type: 'replace_synced_metadata_entry',
      payload: {
        name: 'test_B_name',
        data: 'test_B_data',
      },
    },
    {
      type: 'replace_synced_metadata_entry',
      payload: {
        name: 'test_A_name',
        data: 'test_A_data',
      },
    },
    {
      type: 'replace_synced_metadata_entry',
      payload: {
        name: 'test_A_name',
        data: 'test_A_update',
      },
    },
    {
      type: 'remove_synced_metadata',
      payload: { names: ['test_B_name'] },
    },
  ]);

  data = await commCoreModule.getClientDBStore();
  console.log(data.syncedMetadata);
}

And received the correct response of [{"data": "test_A_update", "name": "test_A_name"}]

Screenshot 2024-03-27 at 6.22.06 PM.png (768×846 px, 139 KB)

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

will created this revision.Mar 27 2024, 3:26 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptMar 27 2024, 3:26 PM

will edited the summary of this revision. (Show Details)Mar 27 2024, 3:27 PM

will edited the test plan for this revision. (Show Details)

will added a parent revision: D11417: [sqlite] add methods to operate on synced metadata table.

Harbormaster completed remote builds in B27736: Diff 38399.Mar 27 2024, 3:41 PM

will requested review of this revision.Mar 27 2024, 3:41 PM

will added a child revision: D11419: [sqlite] implement C++ code to get synced metadata.Mar 27 2024, 4:10 PM

ashoat added inline comments.Mar 27 2024, 5:41 PM

native/cpp/CommonCpp/NativeModules/SyncedMetadataStoreOperations.h
7 ↗	(On Diff #38399)	Nit: maybe add a newline here

kamil accepted this revision.Mar 28 2024, 4:51 AM

This revision is now accepted and ready to land.Mar 28 2024, 4:51 AM

review feedback

will marked an inline comment as done.Mar 28 2024, 10:04 AM

Harbormaster completed remote builds in B27781: Diff 38471.Mar 28 2024, 10:19 AM

Closed by commit rCOMM585c20c0a367: [sqlite] implement C++ synced metadata store ops (authored by will). · Explain WhyApr 2 2024, 11:21 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM585c20c0a367: [sqlite] implement C++ synced metadata store ops.

Revision Contents
Changeset List

Path

Size

native/

cpp/

CommonCpp/

NativeModules/

CMakeLists.txt

3 lines

CommCoreModule.h

5 lines

CommCoreModule.cpp

10 lines

PersistentStorageUtilities/

DataStores/

SyncedMetadataStore.h

32 lines

SyncedMetadataStore.cpp

74 lines

SyncedMetadataStoreOperations.h

51 lines

_generated/

commJSI-generated.cpp

commJSI.h

ios/

Comm.xcodeproj/

project.pbxproj

8 lines

schema/

CommCoreModuleSchema.js

4 lines

Diff 38692

View Options

native/cpp/CommonCpp/NativeModules/CMakeLists.txt

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines	if (oldLastUpdate < viewer.sessionLastUpdated) {
// or the user restored the client app from a backup. Either way, we should		// or the user restored the client app from a backup. Either way, we should
// invalidate the existing session, since the server has assumed that the		// invalidate the existing session, since the server has assumed that the
// checkpoint is further along than it is on the client, and might not still		// checkpoint is further along than it is on the client, and might not still
// have all of the updates necessary to do an incremental update		// have all of the updates necessary to do an incremental update
await setNewSession(viewer, calendarQuery, oldLastUpdate);		await setNewSession(viewer, calendarQuery, oldLastUpdate);
return { sessionContinued: false };		return { sessionContinued: false };
}		}

		if (oldLastUpdate === 0 && viewer.sessionLastUpdated === 0) {
		// If both oldLastUpdate and viewer.sessionLastUpdated are 0, that indicates
		// either a fresh registration, or a fresh login following a policy update
		// that requires acknowledgment. In the latter case, we don't want to leave
		// oldLastUpdate as 0, as it might result in a lot of old updates being
		// downloaded. So we make sure to use Date.now() for the new session, and
		// return { sessionContinued: false } to make sure the client gets a
		// stateSyncPayloadTypes.FULL.
		await setNewSession(viewer, calendarQuery, Date.now());
		return { sessionContinued: false };
		}

let comparisonResult = null;		let comparisonResult = null;
try {		try {
comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);		comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);
} catch (e) {		} catch (e) {
if (e.message !== 'unknown_error') {		if (e.message !== 'unknown_error') {
throw e;		throw e;
}		}
}		}
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines	if (oldLastUpdate < viewer.sessionLastUpdated) {
// or the user restored the client app from a backup. Either way, we should		// or the user restored the client app from a backup. Either way, we should
// invalidate the existing session, since the server has assumed that the		// invalidate the existing session, since the server has assumed that the
// checkpoint is further along than it is on the client, and might not still		// checkpoint is further along than it is on the client, and might not still
// have all of the updates necessary to do an incremental update		// have all of the updates necessary to do an incremental update
await setNewSession(viewer, calendarQuery, oldLastUpdate);		await setNewSession(viewer, calendarQuery, oldLastUpdate);
return { sessionContinued: false };		return { sessionContinued: false };
}		}

		if (oldLastUpdate === 0 && viewer.sessionLastUpdated === 0) {
		// If both oldLastUpdate and viewer.sessionLastUpdated are 0, that indicates
		// either a fresh registration, or a fresh login following a policy update
		// that requires acknowledgment. In the latter case, we don't want to leave
		// oldLastUpdate as 0, as it might result in a lot of old updates being
		// downloaded. So we make sure to use Date.now() for the new session, and
		// return { sessionContinued: false } to make sure the client gets a
		// stateSyncPayloadTypes.FULL.
		await setNewSession(viewer, calendarQuery, Date.now());
		return { sessionContinued: false };
		}

let comparisonResult = null;		let comparisonResult = null;
try {		try {
comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);		comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);
} catch (e) {		} catch (e) {
if (e.message !== 'unknown_error') {		if (e.message !== 'unknown_error') {
throw e;		throw e;
}		}
}		}
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines	if (oldLastUpdate < viewer.sessionLastUpdated) {
// or the user restored the client app from a backup. Either way, we should		// or the user restored the client app from a backup. Either way, we should
// invalidate the existing session, since the server has assumed that the		// invalidate the existing session, since the server has assumed that the
// checkpoint is further along than it is on the client, and might not still		// checkpoint is further along than it is on the client, and might not still
// have all of the updates necessary to do an incremental update		// have all of the updates necessary to do an incremental update
await setNewSession(viewer, calendarQuery, oldLastUpdate);		await setNewSession(viewer, calendarQuery, oldLastUpdate);
return { sessionContinued: false };		return { sessionContinued: false };
}		}

		if (oldLastUpdate === 0 && viewer.sessionLastUpdated === 0) {
		// If both oldLastUpdate and viewer.sessionLastUpdated are 0, that indicates
		// either a fresh registration, or a fresh login following a policy update
		// that requires acknowledgment. In the latter case, we don't want to leave
		// oldLastUpdate as 0, as it might result in a lot of old updates being
		// downloaded. So we make sure to use Date.now() for the new session, and
		// return { sessionContinued: false } to make sure the client gets a
		// stateSyncPayloadTypes.FULL.
		await setNewSession(viewer, calendarQuery, Date.now());
		return { sessionContinued: false };
		}

let comparisonResult = null;		let comparisonResult = null;
try {		try {
comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);		comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);
} catch (e) {		} catch (e) {
if (e.message !== 'unknown_error') {		if (e.message !== 'unknown_error') {
throw e;		throw e;
}		}
}		}
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

View Options

native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/SyncedMetadataStore.h

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines	if (oldLastUpdate < viewer.sessionLastUpdated) {
// or the user restored the client app from a backup. Either way, we should		// or the user restored the client app from a backup. Either way, we should
// invalidate the existing session, since the server has assumed that the		// invalidate the existing session, since the server has assumed that the
// checkpoint is further along than it is on the client, and might not still		// checkpoint is further along than it is on the client, and might not still
// have all of the updates necessary to do an incremental update		// have all of the updates necessary to do an incremental update
await setNewSession(viewer, calendarQuery, oldLastUpdate);		await setNewSession(viewer, calendarQuery, oldLastUpdate);
return { sessionContinued: false };		return { sessionContinued: false };
}		}

		if (oldLastUpdate === 0 && viewer.sessionLastUpdated === 0) {
		// If both oldLastUpdate and viewer.sessionLastUpdated are 0, that indicates
		// either a fresh registration, or a fresh login following a policy update
		// that requires acknowledgment. In the latter case, we don't want to leave
		// oldLastUpdate as 0, as it might result in a lot of old updates being
		// downloaded. So we make sure to use Date.now() for the new session, and
		// return { sessionContinued: false } to make sure the client gets a
		// stateSyncPayloadTypes.FULL.
		await setNewSession(viewer, calendarQuery, Date.now());
		return { sessionContinued: false };
		}

let comparisonResult = null;		let comparisonResult = null;
try {		try {
comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);		comparisonResult = compareNewCalendarQuery(viewer, calendarQuery);
} catch (e) {		} catch (e) {
if (e.message !== 'unknown_error') {		if (e.message !== 'unknown_error') {
throw e;		throw e;
}		}
}		}
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines