Page MenuHomePhabricator
Differential D11190

[lib/native/web] read communites from sqlite on app start
ClosedPublic
Actions

Authored by ginsu on Feb 27 2024, 11:35 PM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Feb 21, 7:26 PM
Unknown Object (File)
Fri, Feb 21, 7:26 PM
Unknown Object (File)
Fri, Feb 21, 7:26 PM
Unknown Object (File)
Fri, Feb 21, 7:26 PM
Unknown Object (File)
Fri, Feb 21, 7:26 PM
Unknown Object (File)
Jan 23 2025, 3:12 PM
Unknown Object (File)
Jan 23 2025, 3:12 PM
Unknown Object (File)
Jan 23 2025, 3:11 PM
View All 85 Files
Subscribers
ashoat
tomek

Details

Reviewers
atul
inka
kamil
Commits
rCOMMcace3a54d8b3: [lib/native/web] read communites from sqlite on app start
Summary

This code gets the communty data from the client db and populates it into the redux store

Linear task: https://linear.app/comm/issue/ENG-6536/read-communities-from-sqlite-on-app-start

Depends on D11166

Test Plan

Confrimed that the community data in redux matches what is found in the client db

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

ginsu created this revision.Feb 27 2024, 11:35 PM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptFeb 27 2024, 11:35 PM
ginsu edited the summary of this revision. (Show Details)Feb 27 2024, 11:37 PM
ginsu added reviewers: atul, inka, kamil.
ginsu added a parent revision: D11166: [lib] introduce community reducer.
Harbormaster completed remote builds in B27220: Diff 37679.Feb 27 2024, 11:51 PM
ginsu requested review of this revision.Feb 27 2024, 11:51 PM
ginsu added a child revision: D11191: DRAFT [lib/native/web] introduce migration to populate community store.Feb 28 2024, 12:19 AM
kamil accepted this revision.Feb 28 2024, 1:00 AM
This revision is now accepted and ready to land.Feb 28 2024, 1:00 AM
kamil added a comment.Feb 28 2024, 1:01 AM

Confrimed that the community data in redux matches what is found in the client db

was it tested on both the web and native?

ginsu added a comment.Mar 4 2024, 12:07 PM

was it tested on both the web and native?

Yes confirmed that I was able to read and see communities on both web and native from sqlite

ginsu updated this revision to Diff 37797.Mar 4 2024, 12:34 PM

rebase before landing

This revision was landed with ongoing or failed builds.Mar 4 2024, 12:39 PM
Closed by commit rCOMMcace3a54d8b3: [lib/native/web] read communites from sqlite on app start (authored by ginsu). · Explain Why
This revision was automatically updated to reflect the committed changes.
ginsu added a commit: rCOMMcace3a54d8b3: [lib/native/web] read communites from sqlite on app start.
Harbormaster completed remote builds in B27315: Diff 37797.Mar 4 2024, 1:35 PM

Revision Contents
Changeset List

PathSize
lib/
reducers/
20 lines
1 line
types/
2 lines
native/
data/
5 lines
web/
database/
utils/
9 lines

Diff 37799

View Options

lib/reducers/community-reducer.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

lib/reducers/message-reducer.test.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

lib/types/store-ops-types.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

native/data/sqlite-data-handler.js

// @flow // @flow
import invariant from 'invariant';
import * as React from 'react';
import { import {
extractKeyserverIDFromID, extractKeyserverIDFromID,
extractKeyserverIDFromIDOptional, extractKeyserverIDFromIDOptional,
} from '../keyserver-conn/keyserver-call-utils.js'; } from '../keyserver-conn/keyserver-call-utils.js';
import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js'; import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js'; import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
import type { OutboundDMOperationSpecification } from '../shared/dm-ops/dm-op-utils.js';
import { dmOperationSpecificationTypes } from '../shared/dm-ops/dm-op-utils.js';
import { useProcessAndSendDMOperation } from '../shared/dm-ops/process-dm-ops.js';
import type { import type {
ActivityUpdate, ActivityUpdate,
ActivityUpdateSuccessPayload, ActivityUpdateSuccessPayload,
SetThreadUnreadStatusPayload, SetThreadUnreadStatusPayload,
SetThreadUnreadStatusRequest, SetThreadUnreadStatusRequest,
} from '../types/activity-types.js'; } from '../types/activity-types.js';
import type { DMChangeThreadReadStatusOperation } from '../types/dm-ops.js';
import type { ThreadInfo } from '../types/minimally-encoded-thread-permissions-types';
import { threadTypeIsThick } from '../types/thread-types-enum.js';
import { useSelector } from '../utils/redux-utils.js';
export type UpdateActivityInput = { export type UpdateActivityInput = {
+activityUpdates: $ReadOnlyArray<ActivityUpdate>, +activityUpdates: $ReadOnlyArray<ActivityUpdate>,
}; };
const updateActivityActionTypes = Object.freeze({ const updateActivityActionTypes = Object.freeze({
started: 'UPDATE_ACTIVITY_STARTED', started: 'UPDATE_ACTIVITY_STARTED',
success: 'UPDATE_ACTIVITY_SUCCESS', success: 'UPDATE_ACTIVITY_SUCCESS',
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines const responses = await callKeyserverEndpoint(
requests, requests,
); );
return { return {
resetToUnread: responses[keyserverID].resetToUnread, resetToUnread: responses[keyserverID].resetToUnread,
threadID: input.threadID, threadID: input.threadID,
}; };
}; };
function useSetThreadUnreadStatus(): ( function useSetThreadUnreadStatus(
threadInfo: ThreadInfo,
): (
request: SetThreadUnreadStatusRequest, request: SetThreadUnreadStatusRequest,
) => Promise<SetThreadUnreadStatusPayload> { ) => Promise<SetThreadUnreadStatusPayload> {
return useKeyserverCall(setThreadUnreadStatus); const viewerID = useSelector(
state => state.currentUserInfo && state.currentUserInfo.id,
);
const processAndSendDMOperation = useProcessAndSendDMOperation();
const keyserverCall = useKeyserverCall(setThreadUnreadStatus);
return React.useCallback(
async (input: SetThreadUnreadStatusRequest) => {
if (!threadTypeIsThick(threadInfo.type)) {
return await keyserverCall(input);
}
invariant(viewerID, 'viewerID must be set');
const op: DMChangeThreadReadStatusOperation = {
type: 'change_thread_read_status',
time: Date.now(),
threadID: threadInfo.id,
creatorID: viewerID,
unread: !threadInfo.currentUser.unread,
};
const opSpecification: OutboundDMOperationSpecification = {
type: dmOperationSpecificationTypes.OUTBOUND,
op,
recipients: {
type: 'self_devices',
},
};
await processAndSendDMOperation(opSpecification);
return {
resetToUnread: false,
threadID: threadInfo.id,
};
},
[keyserverCall, threadInfo, viewerID, processAndSendDMOperation],
);
} }
export { export {
updateActivityActionTypes, updateActivityActionTypes,
useUpdateActivity, useUpdateActivity,
setThreadUnreadStatusActionTypes, setThreadUnreadStatusActionTypes,
useSetThreadUnreadStatus, useSetThreadUnreadStatus,
}; };
View Options

web/database/utils/store.js

Loading...