Paths

Table of Contentst

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

[sqlite] implement C++ aux user store ops
ClosedPublic
Actions

Authored by will on Mar 31 2024, 10:39 PM.

Details

Reviewers

ginsu
kamil
atul

Commits

rCOMM5a0daf51e0c7: [sqlite] implement C++ aux user store ops

Summary

Introduces code allowing native to use sqlite aux user store ops

Depends on D11508

Test Plan

Ran the following code and confirmed matching expected results:

await commCoreModule.processAuxUserStoreOperations([
  {
    type: 'replace_aux_user_info',
    payload: {
      id: 'test_aux_user_A',
      auxUserInfo: JSON.stringify({ fid: 'test_fid_of_user_A' }),
    },
  },
  {
    type: 'remove_all_aux_user_infos',
  },
  {
    type: 'replace_aux_user_info',
    payload: {
      id: 'test_aux_user_B',
      auxUserInfo: JSON.stringify({ fid: 'test_fid_of_user_B' }),
    },
  },
  {
    type: 'replace_aux_user_info',
    payload: {
      id: 'test_aux_user_C',
      auxUserInfo: JSON.stringify({ fid: 'test_fid_of_user_C' }),
    },
  },
  {
    type: 'remove_aux_user_infos',
    payload: {
      ids: ['test_aux_user_C'],
    },
  },
]);

Screenshot 2024-04-01 at 1.39.53 AM.png (768×1 px, 186 KB)

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

will created this revision.Mar 31 2024, 10:39 PM

Herald added subscribers: tomek, ashoat. · View Herald TranscriptMar 31 2024, 10:39 PM

will edited the summary of this revision. (Show Details)Mar 31 2024, 10:39 PM

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

will added a parent revision: D11508: [sqlite] introduce aux user store C++ methods.

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

Harbormaster completed remote builds in B27889: Diff 38622.Mar 31 2024, 10:54 PM

will requested review of this revision.Mar 31 2024, 10:54 PM

will added a child revision: D11510: [sqlite] Implement C++ for native to get all aux user infos.Mar 31 2024, 11:05 PM

Did not read through createOperations super carefully, so please double check that everything seems correct there.

This revision is now accepted and ready to land.Apr 1 2024, 1:53 PM

rebase

Harbormaster completed remote builds in B27999: Diff 38808.Apr 4 2024, 1:35 PM

Closed by commit rCOMM5a0daf51e0c7: [sqlite] implement C++ aux user store ops (authored by will). · Explain WhyApr 4 2024, 9:42 PM

This revision was automatically updated to reflect the committed changes.

will added a commit: rCOMM5a0daf51e0c7: [sqlite] implement C++ aux user store ops.

kamil mentioned this in D12795: [native] Add message search store.Jul 19 2024, 5:15 AM

Revision Contents
Changeset List

Path

Size

native/

cpp/

CommonCpp/

NativeModules/

AuxUserStoreOperations.h

48 lines

CMakeLists.txt

3 lines

CommCoreModule.h

5 lines

CommCoreModule.cpp

9 lines

PersistentStorageUtilities/

DataStores/

AuxUserStore.h

30 lines

AuxUserStore.cpp

67 lines

_generated/

commJSI-generated.cpp

commJSI.h

ios/

Comm.xcodeproj/

project.pbxproj

8 lines

schema/

CommCoreModuleSchema.js

4 lines

Diff 38833

View Options

native/cpp/CommonCpp/NativeModules/AuxUserStoreOperations.h

// @flow		// @flow

import invariant from 'invariant';
import * as React from 'react';		import * as React from 'react';

import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';		import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';

import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';		import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';
import LoadableImage from './loadable-image.react.js';		import LoadableImage from './loadable-image.react.js';
import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
import { useSelector } from '../redux/redux-utils.js';		import { useSelector } from '../redux/redux-utils.js';
import type { ImageSource } from '../types/react-native.js';		import type { ImageSource } from '../types/react-native.js';
import type { ImageStyle } from '../types/styles.js';		import type { ImageStyle } from '../types/styles.js';

type BaseProps = {		type BaseProps = {
+blobURI: string,		+blobURI: string,
+encryptionKey: string,		+encryptionKey: string,
+onLoad?: (uri: string) => void,		+onLoad?: (uri: string) => void,
Show All 14 Lines	const {
thumbHash: encryptedThumbHash,		thumbHash: encryptedThumbHash,
} = props;		} = props;

const fetchAndDecryptMedia = useFetchAndDecryptMedia();		const fetchAndDecryptMedia = useFetchAndDecryptMedia();

const mediaCache = React.useContext(MediaCacheContext);		const mediaCache = React.useContext(MediaCacheContext);
const [source, setSource] = React.useState<?ImageSource>(null);		const [source, setSource] = React.useState<?ImageSource>(null);

const connection = useSelector(connectionSelector(authoritativeKeyserverID));		const connected = useSelector(state => state.connectivity.connected);
invariant(connection, 'keyserver missing from keyserverStore');		const prevConnectedRef = React.useRef(connected);
const connectionStatus = connection.status;
const prevConnectionStatusRef = React.useRef(connectionStatus);
const [attempt, setAttempt] = React.useState(0);		const [attempt, setAttempt] = React.useState(0);
const [errorOccured, setErrorOccured] = React.useState(false);		const [errorOccured, setErrorOccured] = React.useState(false);

if (prevConnectionStatusRef.current !== connectionStatus) {		if (prevConnectedRef.current !== connected) {
if (!source && connectionStatus === 'connected') {		if (!source && connected) {
setAttempt(attempt + 1);		setAttempt(attempt + 1);
}		}
prevConnectionStatusRef.current = connectionStatus;		prevConnectedRef.current = connected;
}		}

const placeholder = React.useMemo(() => {		const placeholder = React.useMemo(() => {
if (!encryptedThumbHash) {		if (!encryptedThumbHash) {
return null;		return null;
}		}
try {		try {
const decryptedThumbHash = decryptBase64(		const decryptedThumbHash = decryptBase64(
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

View Options

native/cpp/CommonCpp/NativeModules/CMakeLists.txt

// @flow		// @flow

import invariant from 'invariant';
import * as React from 'react';		import * as React from 'react';

import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';		import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';

import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';		import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';
import LoadableImage from './loadable-image.react.js';		import LoadableImage from './loadable-image.react.js';
import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
import { useSelector } from '../redux/redux-utils.js';		import { useSelector } from '../redux/redux-utils.js';
import type { ImageSource } from '../types/react-native.js';		import type { ImageSource } from '../types/react-native.js';
import type { ImageStyle } from '../types/styles.js';		import type { ImageStyle } from '../types/styles.js';

type BaseProps = {		type BaseProps = {
+blobURI: string,		+blobURI: string,
+encryptionKey: string,		+encryptionKey: string,
+onLoad?: (uri: string) => void,		+onLoad?: (uri: string) => void,
Show All 14 Lines	const {
thumbHash: encryptedThumbHash,		thumbHash: encryptedThumbHash,
} = props;		} = props;

const fetchAndDecryptMedia = useFetchAndDecryptMedia();		const fetchAndDecryptMedia = useFetchAndDecryptMedia();

const mediaCache = React.useContext(MediaCacheContext);		const mediaCache = React.useContext(MediaCacheContext);
const [source, setSource] = React.useState<?ImageSource>(null);		const [source, setSource] = React.useState<?ImageSource>(null);

const connection = useSelector(connectionSelector(authoritativeKeyserverID));		const connected = useSelector(state => state.connectivity.connected);
invariant(connection, 'keyserver missing from keyserverStore');		const prevConnectedRef = React.useRef(connected);
const connectionStatus = connection.status;
const prevConnectionStatusRef = React.useRef(connectionStatus);
const [attempt, setAttempt] = React.useState(0);		const [attempt, setAttempt] = React.useState(0);
const [errorOccured, setErrorOccured] = React.useState(false);		const [errorOccured, setErrorOccured] = React.useState(false);

if (prevConnectionStatusRef.current !== connectionStatus) {		if (prevConnectedRef.current !== connected) {
if (!source && connectionStatus === 'connected') {		if (!source && connected) {
setAttempt(attempt + 1);		setAttempt(attempt + 1);
}		}
prevConnectionStatusRef.current = connectionStatus;		prevConnectedRef.current = connected;
}		}

const placeholder = React.useMemo(() => {		const placeholder = React.useMemo(() => {
if (!encryptedThumbHash) {		if (!encryptedThumbHash) {
return null;		return null;
}		}
try {		try {
const decryptedThumbHash = decryptBase64(		const decryptedThumbHash = decryptBase64(
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

// @flow		// @flow

import invariant from 'invariant';
import * as React from 'react';		import * as React from 'react';

import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';		import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';

import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';		import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';
import LoadableImage from './loadable-image.react.js';		import LoadableImage from './loadable-image.react.js';
import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
import { useSelector } from '../redux/redux-utils.js';		import { useSelector } from '../redux/redux-utils.js';
import type { ImageSource } from '../types/react-native.js';		import type { ImageSource } from '../types/react-native.js';
import type { ImageStyle } from '../types/styles.js';		import type { ImageStyle } from '../types/styles.js';

type BaseProps = {		type BaseProps = {
+blobURI: string,		+blobURI: string,
+encryptionKey: string,		+encryptionKey: string,
+onLoad?: (uri: string) => void,		+onLoad?: (uri: string) => void,
Show All 14 Lines	const {
thumbHash: encryptedThumbHash,		thumbHash: encryptedThumbHash,
} = props;		} = props;

const fetchAndDecryptMedia = useFetchAndDecryptMedia();		const fetchAndDecryptMedia = useFetchAndDecryptMedia();

const mediaCache = React.useContext(MediaCacheContext);		const mediaCache = React.useContext(MediaCacheContext);
const [source, setSource] = React.useState<?ImageSource>(null);		const [source, setSource] = React.useState<?ImageSource>(null);

const connection = useSelector(connectionSelector(authoritativeKeyserverID));		const connected = useSelector(state => state.connectivity.connected);
invariant(connection, 'keyserver missing from keyserverStore');		const prevConnectedRef = React.useRef(connected);
const connectionStatus = connection.status;
const prevConnectionStatusRef = React.useRef(connectionStatus);
const [attempt, setAttempt] = React.useState(0);		const [attempt, setAttempt] = React.useState(0);
const [errorOccured, setErrorOccured] = React.useState(false);		const [errorOccured, setErrorOccured] = React.useState(false);

if (prevConnectionStatusRef.current !== connectionStatus) {		if (prevConnectedRef.current !== connected) {
if (!source && connectionStatus === 'connected') {		if (!source && connected) {
setAttempt(attempt + 1);		setAttempt(attempt + 1);
}		}
prevConnectionStatusRef.current = connectionStatus;		prevConnectedRef.current = connected;
}		}

const placeholder = React.useMemo(() => {		const placeholder = React.useMemo(() => {
if (!encryptedThumbHash) {		if (!encryptedThumbHash) {
return null;		return null;
}		}
try {		try {
const decryptedThumbHash = decryptBase64(		const decryptedThumbHash = decryptBase64(
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

// @flow		// @flow

import invariant from 'invariant';
import * as React from 'react';		import * as React from 'react';

import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';		import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';

import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';		import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';
import LoadableImage from './loadable-image.react.js';		import LoadableImage from './loadable-image.react.js';
import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
import { useSelector } from '../redux/redux-utils.js';		import { useSelector } from '../redux/redux-utils.js';
import type { ImageSource } from '../types/react-native.js';		import type { ImageSource } from '../types/react-native.js';
import type { ImageStyle } from '../types/styles.js';		import type { ImageStyle } from '../types/styles.js';

type BaseProps = {		type BaseProps = {
+blobURI: string,		+blobURI: string,
+encryptionKey: string,		+encryptionKey: string,
+onLoad?: (uri: string) => void,		+onLoad?: (uri: string) => void,
Show All 14 Lines	const {
thumbHash: encryptedThumbHash,		thumbHash: encryptedThumbHash,
} = props;		} = props;

const fetchAndDecryptMedia = useFetchAndDecryptMedia();		const fetchAndDecryptMedia = useFetchAndDecryptMedia();

const mediaCache = React.useContext(MediaCacheContext);		const mediaCache = React.useContext(MediaCacheContext);
const [source, setSource] = React.useState<?ImageSource>(null);		const [source, setSource] = React.useState<?ImageSource>(null);

const connection = useSelector(connectionSelector(authoritativeKeyserverID));		const connected = useSelector(state => state.connectivity.connected);
invariant(connection, 'keyserver missing from keyserverStore');		const prevConnectedRef = React.useRef(connected);
const connectionStatus = connection.status;
const prevConnectionStatusRef = React.useRef(connectionStatus);
const [attempt, setAttempt] = React.useState(0);		const [attempt, setAttempt] = React.useState(0);
const [errorOccured, setErrorOccured] = React.useState(false);		const [errorOccured, setErrorOccured] = React.useState(false);

if (prevConnectionStatusRef.current !== connectionStatus) {		if (prevConnectedRef.current !== connected) {
if (!source && connectionStatus === 'connected') {		if (!source && connected) {
setAttempt(attempt + 1);		setAttempt(attempt + 1);
}		}
prevConnectionStatusRef.current = connectionStatus;		prevConnectedRef.current = connected;
}		}

const placeholder = React.useMemo(() => {		const placeholder = React.useMemo(() => {
if (!encryptedThumbHash) {		if (!encryptedThumbHash) {
return null;		return null;
}		}
try {		try {
const decryptedThumbHash = decryptBase64(		const decryptedThumbHash = decryptBase64(
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

View Options

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

// @flow		// @flow

import invariant from 'invariant';
import * as React from 'react';		import * as React from 'react';

import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';		import { MediaCacheContext } from 'lib/components/media-cache-provider.react.js';
import { connectionSelector } from 'lib/selectors/keyserver-selectors.js';

import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';		import { decryptBase64, useFetchAndDecryptMedia } from './encryption-utils.js';
import LoadableImage from './loadable-image.react.js';		import LoadableImage from './loadable-image.react.js';
import { authoritativeKeyserverID } from '../authoritative-keyserver.js';
import { useSelector } from '../redux/redux-utils.js';		import { useSelector } from '../redux/redux-utils.js';
import type { ImageSource } from '../types/react-native.js';		import type { ImageSource } from '../types/react-native.js';
import type { ImageStyle } from '../types/styles.js';		import type { ImageStyle } from '../types/styles.js';

type BaseProps = {		type BaseProps = {
+blobURI: string,		+blobURI: string,
+encryptionKey: string,		+encryptionKey: string,
+onLoad?: (uri: string) => void,		+onLoad?: (uri: string) => void,
Show All 14 Lines	const {
thumbHash: encryptedThumbHash,		thumbHash: encryptedThumbHash,
} = props;		} = props;

const fetchAndDecryptMedia = useFetchAndDecryptMedia();		const fetchAndDecryptMedia = useFetchAndDecryptMedia();

const mediaCache = React.useContext(MediaCacheContext);		const mediaCache = React.useContext(MediaCacheContext);
const [source, setSource] = React.useState<?ImageSource>(null);		const [source, setSource] = React.useState<?ImageSource>(null);

const connection = useSelector(connectionSelector(authoritativeKeyserverID));		const connected = useSelector(state => state.connectivity.connected);
invariant(connection, 'keyserver missing from keyserverStore');		const prevConnectedRef = React.useRef(connected);
const connectionStatus = connection.status;
const prevConnectionStatusRef = React.useRef(connectionStatus);
const [attempt, setAttempt] = React.useState(0);		const [attempt, setAttempt] = React.useState(0);
const [errorOccured, setErrorOccured] = React.useState(false);		const [errorOccured, setErrorOccured] = React.useState(false);

if (prevConnectionStatusRef.current !== connectionStatus) {		if (prevConnectedRef.current !== connected) {
if (!source && connectionStatus === 'connected') {		if (!source && connected) {
setAttempt(attempt + 1);		setAttempt(attempt + 1);
}		}
prevConnectionStatusRef.current = connectionStatus;		prevConnectedRef.current = connected;
}		}

const placeholder = React.useMemo(() => {		const placeholder = React.useMemo(() => {
if (!encryptedThumbHash) {		if (!encryptedThumbHash) {
return null;		return null;
}		}
try {		try {
const decryptedThumbHash = decryptBase64(		const decryptedThumbHash = decryptBase64(
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines