Page MenuHomePhabricator
Differential D11417

[sqlite] add methods to operate on synced metadata table
ClosedPublic
Actions

Authored by will on Mar 27 2024, 1:48 PM.
Tags
None
Referenced Files
F5357242: D11417.diff
Wed, Apr 9, 11:39 AM
Unknown Object (File)
Thu, Apr 3, 3:54 PM
Unknown Object (File)
Fri, Mar 28, 6:26 AM
Unknown Object (File)
Fri, Mar 28, 6:26 AM
Unknown Object (File)
Thu, Mar 27, 5:34 PM
Unknown Object (File)
Feb 26 2025, 12:44 PM
Unknown Object (File)
Feb 21 2025, 10:59 AM
Unknown Object (File)
Feb 20 2025, 2:23 PM
View All 59 Files
Subscribers
ashoat
tomek

Details

Reviewers
kamil
ginsu
Commits
rCOMMf947cab385e0: [sqlite] add methods to operate on synced metadata table
Summary

This implements the C++ SQLite operations for the synced metadata store

Depends on D11416

Test Plan

synced metadata queries test

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

will created this revision.Mar 27 2024, 1:48 PM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptMar 27 2024, 1:48 PM
will edited the summary of this revision. (Show Details)Mar 27 2024, 1:49 PM
will added a parent revision: D11416: [sqlite] add sync metadata table to sqlite.
Harbormaster completed remote builds in B27733: Diff 38396.Mar 27 2024, 2:11 PM
will requested review of this revision.Mar 27 2024, 2:11 PM
will added a child revision: D11418: [sqlite] implement C++ synced metadata store ops.Mar 27 2024, 3:27 PM
kamil accepted this revision.Mar 28 2024, 4:44 AM
kamil added inline comments.
native/ios/Comm.xcodeproj/project.pbxproj
146 ↗(On Diff #38396)

how about adding to makefile on Android?

web/shared-worker/queries/synced-metadata-queries.test.js
11–12 ↗(On Diff #38396)

I think you can add more specific types or you don;t have to use ? operator below when calling methods

63–65 ↗(On Diff #38396)

looks like the test name is not correct with what the test is doing

web/shared-worker/types/sqlite-query-executor.js
129 ↗(On Diff #38396)

match param names here with native code for clarity

This revision is now accepted and ready to land.Mar 28 2024, 4:44 AM
will added inline comments.Mar 28 2024, 8:59 AM
native/ios/Comm.xcodeproj/project.pbxproj
146 ↗(On Diff #38396)

I think I understand what's going on. A similar issue was mentioned in https://phab.comm.dev/D11300?vs=37980&id=38151#toc, where I didn't include IntegrityThreadHash.h in project.pbxproj.

I just removed SyncedMetadataEntry.h from project.pbxproj and everything still seems to compile. This explains why CommunityInfo.h wasn't included in project.pbxproj in its diff stack.

I think I can remove all references to SyncedMetadataEntry.h in project.pbxproj and create a follow-up task to remove IntegrityThreadHash.h as well.

I believe this means we don't need to include them in the android Makefile

will updated this revision to Diff 38467.Mar 28 2024, 9:40 AM

review feedback

will marked 3 inline comments as done.Mar 28 2024, 9:41 AM
Harbormaster completed remote builds in B27777: Diff 38467.Mar 28 2024, 9:55 AM
will mentioned this in D11444: [native] Fix up project.pbxproj after yarn cleaninstall.Mar 28 2024, 4:16 PM
will added inline comments.Mar 28 2024, 4:23 PM
native/ios/Comm.xcodeproj/project.pbxproj
146 ↗(On Diff #38396)

Linear issue for removing IntegrityThreadHash.h: https://linear.app/comm/issue/ENG-7601/remove-integritythreadhashh-from-native-projectpbxproj

Closed by commit rCOMMf947cab385e0: [sqlite] add methods to operate on synced metadata table (authored by will). · Explain WhyApr 2 2024, 11:21 PM
This revision was automatically updated to reflect the committed changes.
will added a commit: rCOMMf947cab385e0: [sqlite] add methods to operate on synced metadata table.

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
DatabaseManagers/
7 lines
6 lines
46 lines
entities/
24 lines
web/
cpp/
8 lines
shared-worker/
_generated/
queries/
98 lines
types/
8 lines

Diff 38467

View Options

native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h

  • This file was added.
// @flow
import uuid from 'uuid';
import type {
DMOperationSpec,
ProcessDMOperationUtilities,
} from './dm-op-spec.js';
import type { DMRemoveMembersOperation } from '../../types/dm-ops.js';
import { messageTypes } from '../../types/message-types-enum.js';
import type { ThickRawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import { updateTypes } from '../../types/update-types-enum.js';
import type { ClientUpdateInfo } from '../../types/update-types.js';
const removeMembersSpec: DMOperationSpec<DMRemoveMembersOperation> =
Object.freeze({
processDMOperation: async (
dmOperation: DMRemoveMembersOperation,
viewerID: string,
utilities: ProcessDMOperationUtilities,
) => {
const { editorID, time, messageID, threadID, removedUserIDs } =
dmOperation;
const threadInfoOptional = utilities.getThreadInfo(threadID);
if (!threadInfoOptional || !threadInfoOptional.thick) {
// We can't perform this operation now. It should be queued for later.
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const threadInfo: ThickRawThreadInfo = threadInfoOptional;
const removeMembersMessage = {
type: messageTypes.REMOVE_MEMBERS,
id: messageID,
threadID,
time,
creatorID: editorID,
removedUserIDs: [...removedUserIDs],
};
const removedUserIDsSet = new Set(removedUserIDs);
const viewerIsRemoved = removedUserIDsSet.has(viewerID);
const updateInfos: Array<ClientUpdateInfo> = [];
if (viewerIsRemoved) {
updateInfos.push({
type: updateTypes.DELETE_THREAD,
id: uuid.v4(),
time,
threadID,
});
} else {
const updatedThreadInfo = {
...threadInfo,
members: threadInfo.members.filter(
member => !removedUserIDsSet.has(member.id),
),
};
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: updatedThreadInfo,
});
}
return {
rawMessageInfos: [removeMembersMessage],
updateInfos,
};
},
});
export { removeMembersSpec };
View Options

native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h

  • This file was added.
// @flow
import uuid from 'uuid';
import type {
DMOperationSpec,
ProcessDMOperationUtilities,
} from './dm-op-spec.js';
import type { DMRemoveMembersOperation } from '../../types/dm-ops.js';
import { messageTypes } from '../../types/message-types-enum.js';
import type { ThickRawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import { updateTypes } from '../../types/update-types-enum.js';
import type { ClientUpdateInfo } from '../../types/update-types.js';
const removeMembersSpec: DMOperationSpec<DMRemoveMembersOperation> =
Object.freeze({
processDMOperation: async (
dmOperation: DMRemoveMembersOperation,
viewerID: string,
utilities: ProcessDMOperationUtilities,
) => {
const { editorID, time, messageID, threadID, removedUserIDs } =
dmOperation;
const threadInfoOptional = utilities.getThreadInfo(threadID);
if (!threadInfoOptional || !threadInfoOptional.thick) {
// We can't perform this operation now. It should be queued for later.
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const threadInfo: ThickRawThreadInfo = threadInfoOptional;
const removeMembersMessage = {
type: messageTypes.REMOVE_MEMBERS,
id: messageID,
threadID,
time,
creatorID: editorID,
removedUserIDs: [...removedUserIDs],
};
const removedUserIDsSet = new Set(removedUserIDs);
const viewerIsRemoved = removedUserIDsSet.has(viewerID);
const updateInfos: Array<ClientUpdateInfo> = [];
if (viewerIsRemoved) {
updateInfos.push({
type: updateTypes.DELETE_THREAD,
id: uuid.v4(),
time,
threadID,
});
} else {
const updatedThreadInfo = {
...threadInfo,
members: threadInfo.members.filter(
member => !removedUserIDsSet.has(member.id),
),
};
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: updatedThreadInfo,
});
}
return {
rawMessageInfos: [removeMembersMessage],
updateInfos,
};
},
});
export { removeMembersSpec };
View Options

native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp

  • This file was added.
// @flow
import uuid from 'uuid';
import type {
DMOperationSpec,
ProcessDMOperationUtilities,
} from './dm-op-spec.js';
import type { DMRemoveMembersOperation } from '../../types/dm-ops.js';
import { messageTypes } from '../../types/message-types-enum.js';
import type { ThickRawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import { updateTypes } from '../../types/update-types-enum.js';
import type { ClientUpdateInfo } from '../../types/update-types.js';
const removeMembersSpec: DMOperationSpec<DMRemoveMembersOperation> =
Object.freeze({
processDMOperation: async (
dmOperation: DMRemoveMembersOperation,
viewerID: string,
utilities: ProcessDMOperationUtilities,
) => {
const { editorID, time, messageID, threadID, removedUserIDs } =
dmOperation;
const threadInfoOptional = utilities.getThreadInfo(threadID);
if (!threadInfoOptional || !threadInfoOptional.thick) {
// We can't perform this operation now. It should be queued for later.
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const threadInfo: ThickRawThreadInfo = threadInfoOptional;
const removeMembersMessage = {
type: messageTypes.REMOVE_MEMBERS,
id: messageID,
threadID,
time,
creatorID: editorID,
removedUserIDs: [...removedUserIDs],
};
const removedUserIDsSet = new Set(removedUserIDs);
const viewerIsRemoved = removedUserIDsSet.has(viewerID);
const updateInfos: Array<ClientUpdateInfo> = [];
if (viewerIsRemoved) {
updateInfos.push({
type: updateTypes.DELETE_THREAD,
id: uuid.v4(),
time,
threadID,
});
} else {
const updatedThreadInfo = {
...threadInfo,
members: threadInfo.members.filter(
member => !removedUserIDsSet.has(member.id),
),
};
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: updatedThreadInfo,
});
}
return {
rawMessageInfos: [removeMembersMessage],
updateInfos,
};
},
});
export { removeMembersSpec };
View Options

native/cpp/CommonCpp/DatabaseManagers/entities/SyncedMetadataEntry.h

  • This file was added.
// @flow
import uuid from 'uuid';
import type {
DMOperationSpec,
ProcessDMOperationUtilities,
} from './dm-op-spec.js';
import type { DMRemoveMembersOperation } from '../../types/dm-ops.js';
import { messageTypes } from '../../types/message-types-enum.js';
import type { ThickRawThreadInfo } from '../../types/minimally-encoded-thread-permissions-types.js';
import { updateTypes } from '../../types/update-types-enum.js';
import type { ClientUpdateInfo } from '../../types/update-types.js';
const removeMembersSpec: DMOperationSpec<DMRemoveMembersOperation> =
Object.freeze({
processDMOperation: async (
dmOperation: DMRemoveMembersOperation,
viewerID: string,
utilities: ProcessDMOperationUtilities,
) => {
const { editorID, time, messageID, threadID, removedUserIDs } =
dmOperation;
const threadInfoOptional = utilities.getThreadInfo(threadID);
if (!threadInfoOptional || !threadInfoOptional.thick) {
// We can't perform this operation now. It should be queued for later.
return {
rawMessageInfos: [],
updateInfos: [],
};
}
const threadInfo: ThickRawThreadInfo = threadInfoOptional;
const removeMembersMessage = {
type: messageTypes.REMOVE_MEMBERS,
id: messageID,
threadID,
time,
creatorID: editorID,
removedUserIDs: [...removedUserIDs],
};
const removedUserIDsSet = new Set(removedUserIDs);
const viewerIsRemoved = removedUserIDsSet.has(viewerID);
const updateInfos: Array<ClientUpdateInfo> = [];
if (viewerIsRemoved) {
updateInfos.push({
type: updateTypes.DELETE_THREAD,
id: uuid.v4(),
time,
threadID,
});
} else {
const updatedThreadInfo = {
...threadInfo,
members: threadInfo.members.filter(
member => !removedUserIDsSet.has(member.id),
),
};
updateInfos.push({
type: updateTypes.UPDATE_THREAD,
id: uuid.v4(),
time,
threadInfo: updatedThreadInfo,
});
}
return {
rawMessageInfos: [removeMembersMessage],
updateInfos,
};
},
});
export { removeMembersSpec };
View Options

web/cpp/SQLiteQueryExecutorBindings.cpp

Loading...
View Options

web/shared-worker/_generated/comm-query-executor.js

Loading...
View Options

web/shared-worker/_generated/comm_query_executor.wasm

Loading...
View Options

web/shared-worker/queries/synced-metadata-queries.test.js

Loading...
View Options

web/shared-worker/types/sqlite-query-executor.js

Loading...