Page MenuHomePhabricator
Differential D8656

[native] generate C++ spec for CommRustModule
ClosedPublic
Actions

Authored by kamil on Jul 28 2023, 9:47 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Mar 20, 3:14 AM
Unknown Object (File)
Tue, Mar 18, 9:24 AM
Unknown Object (File)
Sat, Mar 15, 1:56 PM
Unknown Object (File)
Wed, Mar 12, 1:35 PM
Unknown Object (File)
Feb 22 2025, 1:53 PM
Unknown Object (File)
Feb 22 2025, 1:53 PM
Unknown Object (File)
Feb 22 2025, 1:53 PM
Unknown Object (File)
Feb 22 2025, 1:53 PM
View All Files
Subscribers
ashoat

Details

Reviewers
bartek
michal
tomek
varun
Commits
rCOMM7d6853161f4e: [native] generate C++ spec for CommRustModule
Summary

ENG-4232

Creating a separate module for Rust API. This is a part of CommCoreModule refactor.

Make codegen generate C++ for module.

Depends on D8655

Test Plan

run codegen-jsi

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

kamil created this revision.Jul 28 2023, 9:47 AM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptJul 28 2023, 9:47 AM
kamil added a child revision: D8657: [native] add CommRustModule implementation.Jul 28 2023, 9:54 AM
Harbormaster failed remote builds in B21308: Diff 29184!Jul 28 2023, 10:10 AM
kamil published this revision for review.Jul 28 2023, 10:20 AM
bartek accepted this revision.Jul 31 2023, 2:46 AM
This revision is now accepted and ready to land.Jul 31 2023, 2:46 AM
kamil updated this revision to Diff 29288.Jul 31 2023, 8:50 AM

rebase

Harbormaster failed remote builds in B21376: Diff 29288!Jul 31 2023, 9:56 AM
kamil updated this revision to Diff 29296.Jul 31 2023, 10:05 AM

fix dependencies (I messed up while resolving conflicts)

Harbormaster completed remote builds in B21384: Diff 29296.Jul 31 2023, 11:44 AM
Closed by commit rCOMM7d6853161f4e: [native] generate C++ spec for CommRustModule (authored by kamil). · Explain WhyAug 1 2023, 2:17 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMM7d6853161f4e: [native] generate C++ spec for CommRustModule.

Revision Contents
Changeset List

PathSize
native/
android/
app/
1 line
codegen/
src/
4 lines
cpp/
CommonCpp/
_generated/
ios/
Comm.xcodeproj/
4 lines

Diff 29288

View Options

native/android/app/CMakeLists.txt

// @flow // @flow
import { addCommunityActionType } from '../actions/community-actions.js'; import { addCommunityActionType } from '../actions/community-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {
logInActionTypes,
keyserverRegisterActionTypes,
} from '../actions/user-actions.js';
import { import {
communityStoreOpsHandlers, communityStoreOpsHandlers,
type CommunityStoreOperation, type CommunityStoreOperation,
type ReplaceCommunityOperation, type ReplaceCommunityOperation,
type RemoveAllCommunitiesOperation,
} from '../ops/community-store-ops.js'; } from '../ops/community-store-ops.js';
import type { CommunityStore } from '../types/community-types.js'; import type {
CommunityStore,
CommunityInfo,
} from '../types/community-types.js';
import { defaultEnabledApps } from '../types/enabled-apps.js';
import type { BaseAction } from '../types/redux-types'; import type { BaseAction } from '../types/redux-types';
import type { RawThreadInfos } from '../types/thread-types';
import { threadTypeIsCommunityRoot } from '../types/thread-types-enum.js';
const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers; const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers;
export default function reduceCommunityStore( export default function reduceCommunityStore(
state: CommunityStore, state: CommunityStore,
action: BaseAction, action: BaseAction,
newThreadInfos: RawThreadInfos,
): { ): {
communityStore: CommunityStore, communityStore: CommunityStore,
communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>, communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>,
} { } {
if (action.type === addCommunityActionType) { if (
action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success ||
action.type === keyserverRegisterActionTypes.success
) {
kamilUnsubmitted
Not Done
Inline Actions

wondering, shouldn't we also add action.type === fullStateSyncActionType?

kamil: wondering, shouldn't we also add `action.type === fullStateSyncActionType`?
ginsuAuthorUnsubmitted
Done
Inline Actions

I spoke to @atul about this and from what I understood we don't need this type since the community store is not synced with the keyserver

ginsu: I spoke to @atul about this and from what I understood we don't need this type since the…
kamilUnsubmitted
Not Done
Inline Actions

But based on the code below, communities are computed based on newThreadInfos which are synced - see here (cc. @atul)

I am afraid that on fullStateSyncActionType we will have inconsistency between threads (threadTypeIsCommunityRoot) and communities in this store

kamil: But based on the code below, communities are computed based on `newThreadInfos` which are…
const removeAllOpertation: RemoveAllCommunitiesOperation = {
type: 'remove_all_communities',
};
const replaceOperations = Object.keys(newThreadInfos)
.filter(threadID =>
threadTypeIsCommunityRoot(newThreadInfos[threadID].type),
)
.map(threadID => {
const communityInfo: CommunityInfo = {
enabledApps: defaultEnabledApps,
};
return {
type: 'replace_community',
payload: {
id: threadID,
communityInfo,
},
};
});
atulUnsubmitted
Not Done
Inline Actions

You could do something like following:

const replaceOperations = Object.keys(newThreadInfos).reduce((acc, threadID) => {
  if (threadTypeIsCommunityRoot(newThreadInfos[threadID].type)) {
    const communityInfo = {
      enabledApps: defaultEnabledApps,
    };
    acc.push({
      type: 'replace_community',
      payload: {
        id: threadID,
        communityInfo,
      },
    });
  }
  return acc;
}, []);

(generated with ChatGPT)

that lets us avoid an iteration, but probably doesn't make a difference

atul: You could do something like following: ```lang=js const replaceOperations = Object.keys…
const commmunityStoreOperations = [
removeAllOpertation,
...replaceOperations,
];
return {
communityStore: processStoreOps(state, commmunityStoreOperations),
communityStoreOperations: commmunityStoreOperations,
};
} else if (action.type === addCommunityActionType) {
const replaceOperation: ReplaceCommunityOperation = { const replaceOperation: ReplaceCommunityOperation = {
type: 'replace_community', type: 'replace_community',
payload: { payload: {
id: action.payload.id, id: action.payload.id,
communityInfo: { communityInfo: {
...action.payload.newCommunityInfo, ...action.payload.newCommunityInfo,
}, },
}, },
Show All 13 Lines
View Options

native/codegen/src/index.js

// @flow // @flow
import { addCommunityActionType } from '../actions/community-actions.js'; import { addCommunityActionType } from '../actions/community-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {
logInActionTypes,
keyserverRegisterActionTypes,
} from '../actions/user-actions.js';
import { import {
communityStoreOpsHandlers, communityStoreOpsHandlers,
type CommunityStoreOperation, type CommunityStoreOperation,
type ReplaceCommunityOperation, type ReplaceCommunityOperation,
type RemoveAllCommunitiesOperation,
} from '../ops/community-store-ops.js'; } from '../ops/community-store-ops.js';
import type { CommunityStore } from '../types/community-types.js'; import type {
CommunityStore,
CommunityInfo,
} from '../types/community-types.js';
import { defaultEnabledApps } from '../types/enabled-apps.js';
import type { BaseAction } from '../types/redux-types'; import type { BaseAction } from '../types/redux-types';
import type { RawThreadInfos } from '../types/thread-types';
import { threadTypeIsCommunityRoot } from '../types/thread-types-enum.js';
const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers; const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers;
export default function reduceCommunityStore( export default function reduceCommunityStore(
state: CommunityStore, state: CommunityStore,
action: BaseAction, action: BaseAction,
newThreadInfos: RawThreadInfos,
): { ): {
communityStore: CommunityStore, communityStore: CommunityStore,
communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>, communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>,
} { } {
if (action.type === addCommunityActionType) { if (
action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success ||
action.type === keyserverRegisterActionTypes.success
) {
kamilUnsubmitted
Not Done
Inline Actions

wondering, shouldn't we also add action.type === fullStateSyncActionType?

kamil: wondering, shouldn't we also add `action.type === fullStateSyncActionType`?
ginsuAuthorUnsubmitted
Done
Inline Actions

I spoke to @atul about this and from what I understood we don't need this type since the community store is not synced with the keyserver

ginsu: I spoke to @atul about this and from what I understood we don't need this type since the…
kamilUnsubmitted
Not Done
Inline Actions

But based on the code below, communities are computed based on newThreadInfos which are synced - see here (cc. @atul)

I am afraid that on fullStateSyncActionType we will have inconsistency between threads (threadTypeIsCommunityRoot) and communities in this store

kamil: But based on the code below, communities are computed based on `newThreadInfos` which are…
const removeAllOpertation: RemoveAllCommunitiesOperation = {
type: 'remove_all_communities',
};
const replaceOperations = Object.keys(newThreadInfos)
.filter(threadID =>
threadTypeIsCommunityRoot(newThreadInfos[threadID].type),
)
.map(threadID => {
const communityInfo: CommunityInfo = {
enabledApps: defaultEnabledApps,
};
return {
type: 'replace_community',
payload: {
id: threadID,
communityInfo,
},
};
});
atulUnsubmitted
Not Done
Inline Actions

You could do something like following:

const replaceOperations = Object.keys(newThreadInfos).reduce((acc, threadID) => {
  if (threadTypeIsCommunityRoot(newThreadInfos[threadID].type)) {
    const communityInfo = {
      enabledApps: defaultEnabledApps,
    };
    acc.push({
      type: 'replace_community',
      payload: {
        id: threadID,
        communityInfo,
      },
    });
  }
  return acc;
}, []);

(generated with ChatGPT)

that lets us avoid an iteration, but probably doesn't make a difference

atul: You could do something like following: ```lang=js const replaceOperations = Object.keys…
const commmunityStoreOperations = [
removeAllOpertation,
...replaceOperations,
];
return {
communityStore: processStoreOps(state, commmunityStoreOperations),
communityStoreOperations: commmunityStoreOperations,
};
} else if (action.type === addCommunityActionType) {
const replaceOperation: ReplaceCommunityOperation = { const replaceOperation: ReplaceCommunityOperation = {
type: 'replace_community', type: 'replace_community',
payload: { payload: {
id: action.payload.id, id: action.payload.id,
communityInfo: { communityInfo: {
...action.payload.newCommunityInfo, ...action.payload.newCommunityInfo,
}, },
}, },
Show All 13 Lines
View Options

native/cpp/CommonCpp/_generated/rustJSI-generated.cpp

// @flow // @flow
import { addCommunityActionType } from '../actions/community-actions.js'; import { addCommunityActionType } from '../actions/community-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {
logInActionTypes,
keyserverRegisterActionTypes,
} from '../actions/user-actions.js';
import { import {
communityStoreOpsHandlers, communityStoreOpsHandlers,
type CommunityStoreOperation, type CommunityStoreOperation,
type ReplaceCommunityOperation, type ReplaceCommunityOperation,
type RemoveAllCommunitiesOperation,
} from '../ops/community-store-ops.js'; } from '../ops/community-store-ops.js';
import type { CommunityStore } from '../types/community-types.js'; import type {
CommunityStore,
CommunityInfo,
} from '../types/community-types.js';
import { defaultEnabledApps } from '../types/enabled-apps.js';
import type { BaseAction } from '../types/redux-types'; import type { BaseAction } from '../types/redux-types';
import type { RawThreadInfos } from '../types/thread-types';
import { threadTypeIsCommunityRoot } from '../types/thread-types-enum.js';
const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers; const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers;
export default function reduceCommunityStore( export default function reduceCommunityStore(
state: CommunityStore, state: CommunityStore,
action: BaseAction, action: BaseAction,
newThreadInfos: RawThreadInfos,
): { ): {
communityStore: CommunityStore, communityStore: CommunityStore,
communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>, communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>,
} { } {
if (action.type === addCommunityActionType) { if (
action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success ||
action.type === keyserverRegisterActionTypes.success
) {
kamilUnsubmitted
Not Done
Inline Actions

wondering, shouldn't we also add action.type === fullStateSyncActionType?

kamil: wondering, shouldn't we also add `action.type === fullStateSyncActionType`?
ginsuAuthorUnsubmitted
Done
Inline Actions

I spoke to @atul about this and from what I understood we don't need this type since the community store is not synced with the keyserver

ginsu: I spoke to @atul about this and from what I understood we don't need this type since the…
kamilUnsubmitted
Not Done
Inline Actions

But based on the code below, communities are computed based on newThreadInfos which are synced - see here (cc. @atul)

I am afraid that on fullStateSyncActionType we will have inconsistency between threads (threadTypeIsCommunityRoot) and communities in this store

kamil: But based on the code below, communities are computed based on `newThreadInfos` which are…
const removeAllOpertation: RemoveAllCommunitiesOperation = {
type: 'remove_all_communities',
};
const replaceOperations = Object.keys(newThreadInfos)
.filter(threadID =>
threadTypeIsCommunityRoot(newThreadInfos[threadID].type),
)
.map(threadID => {
const communityInfo: CommunityInfo = {
enabledApps: defaultEnabledApps,
};
return {
type: 'replace_community',
payload: {
id: threadID,
communityInfo,
},
};
});
atulUnsubmitted
Not Done
Inline Actions

You could do something like following:

const replaceOperations = Object.keys(newThreadInfos).reduce((acc, threadID) => {
  if (threadTypeIsCommunityRoot(newThreadInfos[threadID].type)) {
    const communityInfo = {
      enabledApps: defaultEnabledApps,
    };
    acc.push({
      type: 'replace_community',
      payload: {
        id: threadID,
        communityInfo,
      },
    });
  }
  return acc;
}, []);

(generated with ChatGPT)

that lets us avoid an iteration, but probably doesn't make a difference

atul: You could do something like following: ```lang=js const replaceOperations = Object.keys…
const commmunityStoreOperations = [
removeAllOpertation,
...replaceOperations,
];
return {
communityStore: processStoreOps(state, commmunityStoreOperations),
communityStoreOperations: commmunityStoreOperations,
};
} else if (action.type === addCommunityActionType) {
const replaceOperation: ReplaceCommunityOperation = { const replaceOperation: ReplaceCommunityOperation = {
type: 'replace_community', type: 'replace_community',
payload: { payload: {
id: action.payload.id, id: action.payload.id,
communityInfo: { communityInfo: {
...action.payload.newCommunityInfo, ...action.payload.newCommunityInfo,
}, },
}, },
Show All 13 Lines
View Options

native/cpp/CommonCpp/_generated/rustJSI.h

// @flow // @flow
import { addCommunityActionType } from '../actions/community-actions.js'; import { addCommunityActionType } from '../actions/community-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {
logInActionTypes,
keyserverRegisterActionTypes,
} from '../actions/user-actions.js';
import { import {
communityStoreOpsHandlers, communityStoreOpsHandlers,
type CommunityStoreOperation, type CommunityStoreOperation,
type ReplaceCommunityOperation, type ReplaceCommunityOperation,
type RemoveAllCommunitiesOperation,
} from '../ops/community-store-ops.js'; } from '../ops/community-store-ops.js';
import type { CommunityStore } from '../types/community-types.js'; import type {
CommunityStore,
CommunityInfo,
} from '../types/community-types.js';
import { defaultEnabledApps } from '../types/enabled-apps.js';
import type { BaseAction } from '../types/redux-types'; import type { BaseAction } from '../types/redux-types';
import type { RawThreadInfos } from '../types/thread-types';
import { threadTypeIsCommunityRoot } from '../types/thread-types-enum.js';
const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers; const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers;
export default function reduceCommunityStore( export default function reduceCommunityStore(
state: CommunityStore, state: CommunityStore,
action: BaseAction, action: BaseAction,
newThreadInfos: RawThreadInfos,
): { ): {
communityStore: CommunityStore, communityStore: CommunityStore,
communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>, communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>,
} { } {
if (action.type === addCommunityActionType) { if (
action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success ||
action.type === keyserverRegisterActionTypes.success
) {
kamilUnsubmitted
Not Done
Inline Actions

wondering, shouldn't we also add action.type === fullStateSyncActionType?

kamil: wondering, shouldn't we also add `action.type === fullStateSyncActionType`?
ginsuAuthorUnsubmitted
Done
Inline Actions

I spoke to @atul about this and from what I understood we don't need this type since the community store is not synced with the keyserver

ginsu: I spoke to @atul about this and from what I understood we don't need this type since the…
kamilUnsubmitted
Not Done
Inline Actions

But based on the code below, communities are computed based on newThreadInfos which are synced - see here (cc. @atul)

I am afraid that on fullStateSyncActionType we will have inconsistency between threads (threadTypeIsCommunityRoot) and communities in this store

kamil: But based on the code below, communities are computed based on `newThreadInfos` which are…
const removeAllOpertation: RemoveAllCommunitiesOperation = {
type: 'remove_all_communities',
};
const replaceOperations = Object.keys(newThreadInfos)
.filter(threadID =>
threadTypeIsCommunityRoot(newThreadInfos[threadID].type),
)
.map(threadID => {
const communityInfo: CommunityInfo = {
enabledApps: defaultEnabledApps,
};
return {
type: 'replace_community',
payload: {
id: threadID,
communityInfo,
},
};
});
atulUnsubmitted
Not Done
Inline Actions

You could do something like following:

const replaceOperations = Object.keys(newThreadInfos).reduce((acc, threadID) => {
  if (threadTypeIsCommunityRoot(newThreadInfos[threadID].type)) {
    const communityInfo = {
      enabledApps: defaultEnabledApps,
    };
    acc.push({
      type: 'replace_community',
      payload: {
        id: threadID,
        communityInfo,
      },
    });
  }
  return acc;
}, []);

(generated with ChatGPT)

that lets us avoid an iteration, but probably doesn't make a difference

atul: You could do something like following: ```lang=js const replaceOperations = Object.keys…
const commmunityStoreOperations = [
removeAllOpertation,
...replaceOperations,
];
return {
communityStore: processStoreOps(state, commmunityStoreOperations),
communityStoreOperations: commmunityStoreOperations,
};
} else if (action.type === addCommunityActionType) {
const replaceOperation: ReplaceCommunityOperation = { const replaceOperation: ReplaceCommunityOperation = {
type: 'replace_community', type: 'replace_community',
payload: { payload: {
id: action.payload.id, id: action.payload.id,
communityInfo: { communityInfo: {
...action.payload.newCommunityInfo, ...action.payload.newCommunityInfo,
}, },
}, },
Show All 13 Lines
View Options

native/ios/Comm.xcodeproj/project.pbxproj

// @flow // @flow
import { addCommunityActionType } from '../actions/community-actions.js'; import { addCommunityActionType } from '../actions/community-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {
logInActionTypes,
keyserverRegisterActionTypes,
} from '../actions/user-actions.js';
import { import {
communityStoreOpsHandlers, communityStoreOpsHandlers,
type CommunityStoreOperation, type CommunityStoreOperation,
type ReplaceCommunityOperation, type ReplaceCommunityOperation,
type RemoveAllCommunitiesOperation,
} from '../ops/community-store-ops.js'; } from '../ops/community-store-ops.js';
import type { CommunityStore } from '../types/community-types.js'; import type {
CommunityStore,
CommunityInfo,
} from '../types/community-types.js';
import { defaultEnabledApps } from '../types/enabled-apps.js';
import type { BaseAction } from '../types/redux-types'; import type { BaseAction } from '../types/redux-types';
import type { RawThreadInfos } from '../types/thread-types';
import { threadTypeIsCommunityRoot } from '../types/thread-types-enum.js';
const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers; const { processStoreOperations: processStoreOps } = communityStoreOpsHandlers;
export default function reduceCommunityStore( export default function reduceCommunityStore(
state: CommunityStore, state: CommunityStore,
action: BaseAction, action: BaseAction,
newThreadInfos: RawThreadInfos,
): { ): {
communityStore: CommunityStore, communityStore: CommunityStore,
communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>, communityStoreOperations: $ReadOnlyArray<CommunityStoreOperation>,
} { } {
if (action.type === addCommunityActionType) { if (
action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success ||
action.type === keyserverRegisterActionTypes.success
) {
kamilUnsubmitted
Not Done
Inline Actions

wondering, shouldn't we also add action.type === fullStateSyncActionType?

kamil: wondering, shouldn't we also add `action.type === fullStateSyncActionType`?
ginsuAuthorUnsubmitted
Done
Inline Actions

I spoke to @atul about this and from what I understood we don't need this type since the community store is not synced with the keyserver

ginsu: I spoke to @atul about this and from what I understood we don't need this type since the…
kamilUnsubmitted
Not Done
Inline Actions

But based on the code below, communities are computed based on newThreadInfos which are synced - see here (cc. @atul)

I am afraid that on fullStateSyncActionType we will have inconsistency between threads (threadTypeIsCommunityRoot) and communities in this store

kamil: But based on the code below, communities are computed based on `newThreadInfos` which are…
const removeAllOpertation: RemoveAllCommunitiesOperation = {
type: 'remove_all_communities',
};
const replaceOperations = Object.keys(newThreadInfos)
.filter(threadID =>
threadTypeIsCommunityRoot(newThreadInfos[threadID].type),
)
.map(threadID => {
const communityInfo: CommunityInfo = {
enabledApps: defaultEnabledApps,
};
return {
type: 'replace_community',
payload: {
id: threadID,
communityInfo,
},
};
});
atulUnsubmitted
Not Done
Inline Actions

You could do something like following:

const replaceOperations = Object.keys(newThreadInfos).reduce((acc, threadID) => {
  if (threadTypeIsCommunityRoot(newThreadInfos[threadID].type)) {
    const communityInfo = {
      enabledApps: defaultEnabledApps,
    };
    acc.push({
      type: 'replace_community',
      payload: {
        id: threadID,
        communityInfo,
      },
    });
  }
  return acc;
}, []);

(generated with ChatGPT)

that lets us avoid an iteration, but probably doesn't make a difference

atul: You could do something like following: ```lang=js const replaceOperations = Object.keys…
const commmunityStoreOperations = [
removeAllOpertation,
...replaceOperations,
];
return {
communityStore: processStoreOps(state, commmunityStoreOperations),
communityStoreOperations: commmunityStoreOperations,
};
} else if (action.type === addCommunityActionType) {
const replaceOperation: ReplaceCommunityOperation = { const replaceOperation: ReplaceCommunityOperation = {
type: 'replace_community', type: 'replace_community',
payload: { payload: {
id: action.payload.id, id: action.payload.id,
communityInfo: { communityInfo: {
...action.payload.newCommunityInfo, ...action.payload.newCommunityInfo,
}, },
}, },
Show All 13 Lines