MM_33226 [v2] DataOperator - User section (#5255)

* MM_30475 : ADDED default schema * MM_30475 : ADDED todo for field 'value' of default/Global entity * MM_30476 : Created schema for SERVER DB * MM_30476 : Server model [ IN PROGRESS ] * MM_30476 : Including types for group, groups_in_channel and role * MM_30476 : ADDED models for Group - @typings absolute path has been added to the tsconfig.json * MM_30476 : ADDED typings to current models * MM_30476 : ADDED typings to current models * MM_30476 : ADDED models related to TEAM section of the ERD * MM_30476 : ADDED models for User section of the ERD * MM_30476 : ADDED models for POST section of the ERD * MM_30476 : ADDED models for Channel section of the ERD * MM_30475 : Updated typings and references to MM_TABLES * MM_30476 : Verified all field names * MM_30476 : Verified every table associations * MM_30476 : Verified all relation fields * MM_30476 : Updated primary id of the main models We will override the wdb id at component level when we create a new records. This involves the models : channel, group, post, team and user. * MM_30476 : Including 1:1 relationship amongs some entities * MM_30476 : ADDED Schema Managers * The migration array will hold all the migration steps. * The initial app release (e.g. v2 )will have an empty array and subsequent releases (e.g. v2.1 ) will have the steps listed in that array. * On initialization, the database will perform the migration to accomodate for new columns/tables creation and while it will conserve the mobile phone's data, it will also make it conform to this new schema. * If a migration fails, the migration process will rollback any changes. This migration will be thoroughly tested in development before pushing it live. * Revert "MM_30476 : ADDED Schema Managers" This reverts commit a505bd5e11. * MM_30478 : Converted schema_manager into a function * MM_30478 : Updated schema manager and included patch for wdb * MM_30478: Updated watermelondb patch package * MM_30478 : Update function create_schema_manager to createSqliteAdaptorOptions * MM_30476 : Update constant name to reflect directory name * MM_30476 : Updated msgCount from my_channel model to message_count in server schema * MM_30482 : Added tests for schema_manager * MM_30482 : Database Manager [ IN PROGRESS ] * MM_30478 : Returning an sqliteAdapter instead of an object * MM_30476 : Apply suggestions from code review Co-authored-by: Elias Nahum <nahumhbl@gmail.com> * MM_30476 : Updated all imports as per instruction. * MM_30476 : Shortening object chains by destructuring * MM_30476 : Updated schema file structure * MM_30476 : Prettifying @typings folder * MM_30476 : Removing useless ids * MM_30476 : Prettify imports for decorators * MM_30476 : ADDED documentations and lazy queries to Channel and Channel_Info * MM_30476 : ADDED documentations for default schema * MM_30476 : Documentation [ IN PROGRESS ] - Following JSDoc syntax for single line comment - Removed redundant fields in the 'membership' tables and left only the @relation records. * MM_30476 : Documentations [ IN PROGRESS ] * MM_30476 : Documentations [ IN PROGRESS ] * MM_30476 : Documentations [ IN PROGRESS ] * MM_30476 : Documentations [ IN PROGRESS] Updated 1) my_team and team, 2) my_channel and channel, to each have 1:1 relationship with one another * MM_30476 : Updated all Typescript definitions * MM_30476 :Updated @relation to @immutableRelation * MM_30476 : Updated description for previous_post_id * MM_30478 : Updated patch package for wdb module * MM_30478: DB Manager [IN PROGRESS ] * MM_30478: DB Manager [IN PROGRESS] * MM_30478: DB Manager [IN PROGRESS] * MM_30478 : DB Manager [IN PROGRESS] * MM_30478 : Deleting .db file on iOS * MM_30478: Successfully deleting .db files and directory on iOS side * MM_30478 : Update definition for default/global * MM_30478 : Updated all models * MM_30478 : Doing a bit of house cleaning * MM_30478: Record of new server connection added to default/servers db * TS Definitely Typed Assignment issue is now FIXED * MM_30478 : TS Definitely Typed Assignment \n Removed all the constructors but error still in editor tabs. But this time the app is not crashing * MM_30478 : Attempt 1 [SUCCESSFUL] * MM_30478 : Removing useDefineForClassFields * MM_30478 : Retrieving the servers in a list + Improved the DB Manager and Babel config * MM_30478 : Updated babel.config.js * MM_30478 : Minor UI correction * MM_30478 : Jest and Typescript configuration * MM_30478 : A bit of housekeeping * MM_30478 : Installed WDB on Android * MM_30478 : Deletes new server record from default DB * MM_30478 : Returns subset of server db instances * MM_30478 : Code clean up * MM_30478 : Code clean up on db manager * MM_30478 : House keeping + Patch for WDB * MM_30478 : Android - Saving & Deleting in FilesDir [COMPLETED] * MM_30478 : Code clean up * MM_30478 : Code clean up * MM_30478 : Code clean up * MM_30478 : Test successful on Android device * MM_30478 : Rolling back change to jest.config.js * MM_30478 : Updated test to test_integration * MM_30478 : Fix imports * MM_30478 : Refactored the manual testscript * MM_30478 : Renamed database manager test file * MM_30478 : Code clean up * MM_30478 : Updated manual test file with a note. * MM_30482 : DataOperator [ IN PROGRESS ] * MM_30482 : DataOperator - setting up the factory [ IN PROGRESS ] * MM_30482: Code refactoring * MM_30482 : DataOperator - setting up the factory [ IN PROGRESS ] * MM_30482 : DataOperator - code clean up [ IN PROGRESS ] * MM_30482 : Minor code clean up * MM_30478 : Fixed JEST issue with TS * MM_30478 : Fixed JEST issue with TS * MM_30478 : Fixed JEST issue with TS * MM_30478 : Implementing JEST test cases * MM_30478 : Implementing JEST last test cases * MM_30478 : Jest fixing ts errors * MM_30478 : Database Manager Jest testing [ IN PROGRESS ] * MM_30482 - Fixing DataOperator [ IN PROGRESS ] * MM_30482 : Code clean up * MM_30482 - Creates multiple records [ IN PROGRESS ] * MM_30482 - Creates multiple records [ IN PROGRESS ] * MM_30482 : Update operation [ COMPLETED ] * MM_30482 : Code clean up * MM_30482 : Updated TS for Data Operator * Update mobile v2 detox deps * MM_30482 : Added factories for all isolated tables * MM_30482 : Refactored TS * MM_30482 : Refactored base factory * MM_30482 : Updated JSDoc for operateBaseRecord - Delete CASE * MM_30482 : Implementing test for Data Operator * MM_30482 : Completed tests for all isolated tables * MM_30482 : Renamed entity_factory into operators * MM_30482 : Fix all imports * MM_30482 : Update multiple records * MM_30482 : Edge case for existing records ( update instead of create ) * MM_30482 : Edge case - create instead of update * MM_30482 : Code clean up * MM_30482 : Code clean up * MM_30482 : Code clean up * MM_30482 : Code clean up * Update app/database/admin/data_operator/operators.ts Co-authored-by: Joseph Baylon <joseph.baylon@mattermost.com> * Update app/database/admin/data_operator/operators.ts Co-authored-by: Joseph Baylon <joseph.baylon@mattermost.com> * Update app/database/admin/data_operator/operators.ts Co-authored-by: Joseph Baylon <joseph.baylon@mattermost.com> * MM_30482 : Imposing usage of correct table name for isolated entities * MM_30482 : Code improvement as per Joseph reviews * MM_30482 : Updated tests to validate choice of operator service wrt tableName * MM_30482 : Updated PR as per suggestions * MM_30482 : Updated comments to follow jsdoc conventions * MM_33223 : Renamed DBInstance to DatabaseInstance * MM_33223 : ADDED Prettier * MM_33223 - Prettier formatting * MM_33223 : Prettier formatting * MM_33223 - Post section [ in progress ] * MM_33223 : PostsInThread [99% completed ] * MM_33223: Reaction entity completed * MM_33223: Added Reaction to the Post * MM_33223 : Refactored reactions utils * MM_33223 : Added previous post id to all posts * MM_33223 : Added File Metadata * MM_33223 : Code clean up * MM_33223 : Added PostMetadata * MM_33223 : Added Draft * MM_33223 - Removed Prettier * MM_33223 - Undo files changes due to Prettier * MM_33223 : Making use of MM eslint plugins * MM_33223 : PostsInChannel [ IN PROGRESS ] * MM_33223 : Including update_at in Post schema * MM_33223: Code clean up * MM_33223: Code clean up * MM_33223 : Code clean up * MM_33223: Testing Reaction [IN PROGRESS] * MM_33223 : Updated typings for RawCustomEmoji in Reactions * MM_33223 : Refactored DataOperator test * MM_33223 : Jest - handleReactions - Completed * MM_33223 : Jest - HandleDraft - Completed * MM_33223 : Jest - HandleFiles - Completed * MM_33223 : Refactored DataOperator-PostMetadata * MM_33223 : Jest - HandlePostMetadata - Completed * MM_33223 : Refactored posts into ordered and unordered * MM_33223 : Refactoring + Jest Utils [ IN PROGRESS ] * MM_33223 - Jest Utils - Completed * MM_33223 : Jest - Remaining operators - Completed * MM_33223 : Jest - Handler PostsInThread - Completed * MM_33223 : Jest - HandlePostsInChannel - Completed * MM_33223 : Refactored DataOperator class * MM_33223 : DataOperator test clean up * MM_33223 : DataOperator code clean up * MM_33223 : Jest - HandlePosts - Completed * MM_33223: JSDoc - Operators - Completed * MM_33223 : Refactoring file types.ts * MM_33223 : Refactored import statements * MM_33223 : Added @database alias * MM_33223 : Added missing JSDoc * MM_33223 : Minor code clean up * MM_33223 : Lint fixed * MM_33223 : Disable eslint rules for Notification * MM_33223 : Disable eslint rule for screens * Update app/database/admin/data_operator/index.ts Co-authored-by: Miguel Alatzar <migbot@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: Miguel Alatzar <migbot@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: Miguel Alatzar <migbot@users.noreply.github.com> * MM_33223 : Update data_operatator as per suggestion * MM_33226: Removed optType * MM_33226 : ADDED User Handler+Operator+Jest, Included update_at field for User * MM_33226 : Preference entity - Completed * MM_33226 : Team Membership entity - Completed * MM_33226 : Team Membership - Jest - Completed * MM_33226 : Removing duplicates for TeamMembership and Preferences * MM_33226 : Refactored Custom Emojis to remove duplicates * MM_33226 : Group Membership - Completed * MM_33226 : ChannelMembership - Completed * MM_33226 : Refactored some handlers whose response have no Ids * MM_33226 : Refactoring - in progress * MM_33226 : Refactoring - in progress * MM_33226 : Refactoring - in progress * MM_33226 : Code clean up * MM_33226 : Polishing Operator tests * MM_33226 : Removing redundant test cases * MM_33226 : Polishing Operators * MM_33226 : Testing for duplicate post id in Raw values * MM_33226 : Including some error-throwing in the Database Manager * MM_33226 : Merged in DataOperator/Post-section * MM_33226 : Fixing the merging issues * MM_33226 : fixing merge issues * MM_33226 : Code polishing * MM_33226 : Enabling user notify props comment * MM_33226 : Correcting type casting * MM_33226 : Correcting data operators * MM_33226 : Corrections * MM_33226 : Code clean up * MM_33226 : Rename oneOfField to fieldName * MM_33226 : Renaming comparators to Boolean name and oneOfField to fieldName * MM_33226 : Putting back custom emoji into handleIsolatedEntity * MM_33226 : Comparing simple arrays * MM_33226 : Renaming DiscardDuplicates to ProcessInputs * MM_33226 : Sort imports * MM_33226 : Types clean up Co-authored-by: Elias Nahum <nahumhbl@gmail.com> Co-authored-by: Avinash Lingaloo <> Co-authored-by: Joseph Baylon <joseph.baylon@mattermost.com> Co-authored-by: Miguel Alatzar <migbot@users.noreply.github.com>
2021-04-02 00:26:05 +04:00
parent 040bf22264
commit e3f7c178bb
21 changed files with 3078 additions and 2040 deletions
--- a/app/database/admin/data_operator/operators/index.ts
+++ b/app/database/admin/data_operator/operators/index.ts
@@ -5,124 +5,147 @@ import {Q} from '@nozbe/watermelondb';
 import Model from '@nozbe/watermelondb/Model';

 import {MM_TABLES} from '@constants/database';
+import {User} from '@database/server/models';
 import App from '@typings/database/app';
+import ChannelMembership from '@typings/database/channel_membership';
 import CustomEmoji from '@typings/database/custom_emoji';
 import {
-    BaseOperator,
-    IdenticalRecord,
-    Operator,
+    DataFactoryArgs,
    RawApp,
+    RawChannelMembership,
    RawCustomEmoji,
    RawDraft,
    RawFile,
    RawGlobal,
+    RawGroupMembership,
    RawPost,
    RawPostMetadata,
    RawPostsInChannel,
    RawPostsInThread,
+    RawPreference,
    RawReaction,
    RawRole,
    RawServers,
    RawSystem,
+    RawTeamMembership,
    RawTermsOfService,
+    RawUser,
 } from '@typings/database/database';
 import Draft from '@typings/database/draft';
+import {OperationType} from '@typings/database/enums';
 import File from '@typings/database/file';
 import Global from '@typings/database/global';
+import GroupMembership from '@typings/database/group_membership';
 import Post from '@typings/database/post';
 import PostMetadata from '@typings/database/post_metadata';
 import PostsInChannel from '@typings/database/posts_in_channel';
 import PostsInThread from '@typings/database/posts_in_thread';
+import Preference from '@typings/database/preference';
 import Reaction from '@typings/database/reaction';
 import Role from '@typings/database/role';
 import Servers from '@typings/database/servers';
 import System from '@typings/database/system';
+import TeamMembership from '@typings/database/team_membership';
 import TermsOfService from '@typings/database/terms_of_service';

 const {APP, GLOBAL, SERVERS} = MM_TABLES.DEFAULT;
 const {
+    CHANNEL_MEMBERSHIP,
    CUSTOM_EMOJI,
    DRAFT,
    FILE,
+    GROUP_MEMBERSHIP,
    POST,
-    POST_METADATA,
    POSTS_IN_CHANNEL,
    POSTS_IN_THREAD,
+    POST_METADATA,
+    PREFERENCE,
    REACTION,
    ROLE,
    SYSTEM,
+    TEAM_MEMBERSHIP,
    TERMS_OF_SERVICE,
+    USER,
 } = MM_TABLES.SERVER;

 /**
 * operateAppRecord: Prepares record of entity 'App' from the DEFAULT database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateAppRecord = async ({database, value}: Operator) => {
-    const record = value as RawApp;
+export const operateAppRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawApp;
+    const record = value.record as App;
+    const isCreateAction = action === OperationType.CREATE;

    const generator = (app: App) => {
-        app._raw.id = record?.id ?? app.id;
-        app.buildNumber = record?.buildNumber;
-        app.createdAt = record?.createdAt;
-        app.versionNumber = record?.versionNumber;
+        app._raw.id = isCreateAction ? app.id : record.id;
+        app.buildNumber = raw?.buildNumber;
+        app.createdAt = raw?.createdAt;
+        app.versionNumber = raw?.versionNumber;
    };

    return operateBaseRecord({
+        action,
        database,
+        generator,
        tableName: APP,
        value,
-        generator,
    });
 };

 /**
 * operateGlobalRecord: Prepares record of entity 'Global' from the DEFAULT database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateGlobalRecord = async ({database, value}: Operator) => {
-    const record = value as RawGlobal;
+export const operateGlobalRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawGlobal;
+    const record = value.record as Global;
+    const isCreateAction = action === OperationType.CREATE;

    const generator = (global: Global) => {
-        global._raw.id = record?.id ?? global.id;
-        global.name = record?.name;
-        global.value = record?.value;
+        global._raw.id = isCreateAction ? global.id : record.id;
+        global.name = raw?.name;
+        global.value = raw?.value;
    };

    return operateBaseRecord({
+        action,
        database,
+        generator,
        tableName: GLOBAL,
        value,
-        generator,
    });
 };

 /**
 * operateServersRecord: Prepares record of entity 'Servers' from the DEFAULT database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateServersRecord = async ({database, value}: Operator) => {
-    const record = value as RawServers;
+export const operateServersRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawServers;
+    const record = value.record as Servers;
+    const isCreateAction = action === OperationType.CREATE;

    const generator = (servers: Servers) => {
-        servers._raw.id = record?.id ?? servers.id;
-        servers.dbPath = record?.dbPath;
-        servers.displayName = record?.displayName;
-        servers.mentionCount = record?.mentionCount;
-        servers.unreadCount = record?.unreadCount;
-        servers.url = record?.url;
+        servers._raw.id = isCreateAction ? servers.id : record.id;
+        servers.dbPath = raw?.dbPath;
+        servers.displayName = raw?.displayName;
+        servers.mentionCount = raw?.mentionCount;
+        servers.unreadCount = raw?.unreadCount;
+        servers.url = raw?.url;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: SERVERS,
        value,
@@ -132,29 +155,24 @@ export const operateServersRecord = async ({database, value}: Operator) => {

 /**
 * operateCustomEmojiRecord: Prepares record of entity 'CustomEmoji' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateCustomEmojiRecord = async ({database, value}: Operator) => {
-    const record = value as RawCustomEmoji;
+export const operateCustomEmojiRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawCustomEmoji;
+    const record = value.record as CustomEmoji;
+    const isCreateAction = action === OperationType.CREATE;
+
+    // id of emoji comes from server response
    const generator = (emoji: CustomEmoji) => {
-        emoji._raw.id = record?.id ?? emoji.id;
-        emoji.name = record.name;
+        emoji._raw.id = isCreateAction ? (raw?.id ?? emoji.id) : record.id;
+        emoji.name = raw.name;
    };

-    const appRecord = (await database.collections.
-        get(CUSTOM_EMOJI!).
-        query(Q.where('name', record.name)).
-        fetch()) as Model[];
-    const isPresent = appRecord.length > 0;
-
-    if (isPresent) {
-        return null;
-    }
-
    return operateBaseRecord({
+        action,
        database,
        tableName: CUSTOM_EMOJI,
        value,
@@ -164,21 +182,25 @@ export const operateCustomEmojiRecord = async ({database, value}: Operator) => {

 /**
 * operateRoleRecord: Prepares record of entity 'Role' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateRoleRecord = async ({database, value}: Operator) => {
-    const record = value as RawRole;
+export const operateRoleRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawRole;
+    const record = value.record as Role;
+    const isCreateAction = action === OperationType.CREATE;

+    // id of role comes from server response
    const generator = (role: Role) => {
-        role._raw.id = record?.id ?? role.id;
-        role.name = record?.name;
-        role.permissions = record?.permissions;
+        role._raw.id = isCreateAction ? (raw?.id ?? role.id) : record.id;
+        role.name = raw?.name;
+        role.permissions = raw?.permissions;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: ROLE,
        value,
@@ -188,21 +210,25 @@ export const operateRoleRecord = async ({database, value}: Operator) => {

 /**
 * operateSystemRecord: Prepares record of entity 'System' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateSystemRecord = async ({database, value}: Operator) => {
-    const record = value as RawSystem;
+export const operateSystemRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawSystem;
+    const record = value.record as System;
+    const isCreateAction = action === OperationType.CREATE;

+    // id of system comes from server response
    const generator = (system: System) => {
-        system._raw.id = record?.id ?? system.id;
-        system.name = record?.name;
-        system.value = record?.value;
+        system._raw.id = isCreateAction ? (raw?.id ?? system.id) : record?.id;
+        system.name = raw?.name;
+        system.value = raw?.value;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: SYSTEM,
        value,
@@ -212,20 +238,24 @@ export const operateSystemRecord = async ({database, value}: Operator) => {

 /**
 * operateTermsOfServiceRecord: Prepares record of entity 'TermsOfService' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateTermsOfServiceRecord = async ({database, value}: Operator) => {
-    const record = value as RawTermsOfService;
+export const operateTermsOfServiceRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawTermsOfService;
+    const record = value.record as TermsOfService;
+    const isCreateAction = action === OperationType.CREATE;

+    // id of TOS comes from server response
    const generator = (tos: TermsOfService) => {
-        tos._raw.id = record?.id ?? tos.id;
-        tos.acceptedAt = record?.acceptedAt;
+        tos._raw.id = isCreateAction ? (raw?.id ?? tos.id) : record?.id;
+        tos.acceptedAt = raw?.acceptedAt;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: TERMS_OF_SERVICE,
        value,
@@ -235,33 +265,37 @@ export const operateTermsOfServiceRecord = async ({database, value}: Operator) =

 /**
 * operatePostRecord: Prepares record of entity 'Post' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operatePostRecord = async ({database, value}: Operator) => {
-    const record = value as RawPost;
+export const operatePostRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawPost;
+    const record = value.record as Post;
+    const isCreateAction = action === OperationType.CREATE;

+    // id of post comes from server response
    const generator = (post: Post) => {
-        post._raw.id = record?.id;
-        post.channelId = record?.channel_id;
-        post.createAt = record?.create_at;
-        post.deleteAt = record?.delete_at || record?.delete_at === 0 ? record?.delete_at : 0;
-        post.editAt = record?.edit_at;
-        post.updateAt = record?.update_at;
-        post.isPinned = record!.is_pinned!;
-        post.message = Q.sanitizeLikeString(record?.message);
-        post.userId = record?.user_id;
-        post.originalId = record?.original_id ?? '';
-        post.pendingPostId = record?.pending_post_id ?? '';
-        post.previousPostId = record?.prev_post_id ?? '';
-        post.rootId = record?.root_id ?? '';
-        post.type = record?.type ?? '';
-        post.props = record?.props ?? {};
+        post._raw.id = isCreateAction ? (raw?.id ?? post.id) : record?.id;
+        post.channelId = raw?.channel_id;
+        post.createAt = raw?.create_at;
+        post.deleteAt = raw?.delete_at || raw?.delete_at === 0 ? raw?.delete_at : 0;
+        post.editAt = raw?.edit_at;
+        post.updateAt = raw?.update_at;
+        post.isPinned = raw!.is_pinned!;
+        post.message = Q.sanitizeLikeString(raw?.message);
+        post.userId = raw?.user_id;
+        post.originalId = raw?.original_id ?? '';
+        post.pendingPostId = raw?.pending_post_id ?? '';
+        post.previousPostId = raw?.prev_post_id ?? '';
+        post.rootId = raw?.root_id ?? '';
+        post.type = raw?.type ?? '';
+        post.props = raw?.props ?? {};
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: POST,
        value,
@@ -271,22 +305,24 @@ export const operatePostRecord = async ({database, value}: Operator) => {

 /**
 * operatePostInThreadRecord: Prepares record of entity 'POSTS_IN_THREAD' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operatePostInThreadRecord = async ({database, value}: Operator) => {
-    const record = value as RawPostsInThread;
+export const operatePostInThreadRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawPostsInThread;
+    const record = value.record as PostsInThread;
+    const isCreateAction = action === OperationType.CREATE;

    const generator = (postsInThread: PostsInThread) => {
-        postsInThread._raw.id = postsInThread.id;
-        postsInThread.postId = record.post_id;
-        postsInThread.earliest = record.earliest;
-        postsInThread.latest = record.latest!;
+        postsInThread.postId = isCreateAction ? raw.post_id : record.id;
+        postsInThread.earliest = raw.earliest;
+        postsInThread.latest = raw.latest!;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: POSTS_IN_THREAD,
        value,
@@ -296,23 +332,27 @@ export const operatePostInThreadRecord = async ({database, value}: Operator) =>

 /**
 * operateReactionRecord: Prepares record of entity 'REACTION' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateReactionRecord = async ({database, value}: Operator) => {
-    const record = value as RawReaction;
+export const operateReactionRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawReaction;
+    const record = value.record as Reaction;
+    const isCreateAction = action === OperationType.CREATE;

+    // id of reaction comes from server response
    const generator = (reaction: Reaction) => {
-        reaction._raw.id = reaction.id;
-        reaction.userId = record.user_id;
-        reaction.postId = record.post_id;
-        reaction.emojiName = record.emoji_name;
-        reaction.createAt = record.create_at;
+        reaction._raw.id = isCreateAction ? (raw?.id ?? reaction.id) : record?.id;
+        reaction.userId = raw.user_id;
+        reaction.postId = raw.post_id;
+        reaction.emojiName = raw.emoji_name;
+        reaction.createAt = raw.create_at;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: REACTION,
        value,
@@ -322,28 +362,32 @@ export const operateReactionRecord = async ({database, value}: Operator) => {

 /**
 * operateFileRecord: Prepares record of entity 'FILE' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateFileRecord = async ({database, value}: Operator) => {
-    const record = value as RawFile;
+export const operateFileRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawFile;
+    const record = value.record as File;
+    const isCreateAction = action === OperationType.CREATE;

+    // id of file comes from server response
    const generator = (file: File) => {
-        file._raw.id = record?.id ?? file.id;
-        file.postId = record.post_id;
-        file.name = record.name;
-        file.extension = record.extension;
-        file.size = record.size;
-        file.mimeType = record?.mime_type ?? '';
-        file.width = record?.width ?? 0;
-        file.height = record?.height ?? 0;
-        file.imageThumbnail = record?.mini_preview ?? '';
-        file.localPath = record?.localPath ?? '';
+        file._raw.id = isCreateAction ? (raw?.id ?? file.id) : record?.id;
+        file.postId = raw.post_id;
+        file.name = raw.name;
+        file.extension = raw.extension;
+        file.size = raw.size;
+        file.mimeType = raw?.mime_type ?? '';
+        file.width = raw?.width ?? 0;
+        file.height = raw?.height ?? 0;
+        file.imageThumbnail = raw?.mini_preview ?? '';
+        file.localPath = raw?.localPath ?? '';
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: FILE,
        value,
@@ -353,22 +397,25 @@ export const operateFileRecord = async ({database, value}: Operator) => {

 /**
 * operatePostMetadataRecord: Prepares record of entity 'POST_METADATA' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operatePostMetadataRecord = async ({database, value}: Operator) => {
-    const record = value as RawPostMetadata;
+export const operatePostMetadataRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawPostMetadata;
+    const record = value.record as PostMetadata;
+    const isCreateAction = action === OperationType.CREATE;

    const generator = (postMeta: PostMetadata) => {
-        postMeta._raw.id = postMeta.id;
-        postMeta.data = record.data;
-        postMeta.postId = record.postId;
-        postMeta.type = record.type;
+        postMeta._raw.id = isCreateAction ? postMeta.id : record.id;
+        postMeta.data = raw.data;
+        postMeta.postId = raw.postId;
+        postMeta.type = raw.type;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: POST_METADATA,
        value,
@@ -378,24 +425,26 @@ export const operatePostMetadataRecord = async ({database, value}: Operator) =>

 /**
 * operateDraftRecord: Prepares record of entity 'DRAFT' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operateDraftRecord = async ({database, value}: Operator) => {
-    const record = value as RawDraft;
+export const operateDraftRecord = async ({action, database, value}: DataFactoryArgs) => {
    const emptyFileInfo: FileInfo[] = [];
+    const raw = value.raw as RawDraft;

+    // Draft is client side only; plus you would only be creating/deleting one
    const generator = (draft: Draft) => {
-        draft._raw.id = record?.id ?? draft.id;
-        draft.rootId = record?.root_id ?? '';
-        draft.message = record?.message ?? '';
-        draft.channelId = record?.channel_id ?? '';
-        draft.files = record?.files ?? emptyFileInfo;
+        draft._raw.id = draft.id;
+        draft.rootId = raw?.root_id ?? '';
+        draft.message = raw?.message ?? '';
+        draft.channelId = raw?.channel_id ?? '';
+        draft.files = raw?.files ?? emptyFileInfo;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: DRAFT,
        value,
@@ -405,22 +454,23 @@ export const operateDraftRecord = async ({database, value}: Operator) => {

 /**
 * operatePostsInChannelRecord: Prepares record of entity 'POSTS_IN_CHANNEL' from the SERVER database for update or create actions.
- * @param {Operator} operator
+ * @param {DataFactoryArgs} operator
 * @param {Database} operator.database
- * @param {RecordValue} operator.value
- * @returns {Promise<Model>}
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
 */
-export const operatePostsInChannelRecord = async ({database, value}: Operator) => {
-    const record = value as RawPostsInChannel;
+export const operatePostsInChannelRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawPostsInChannel;

    const generator = (postsInChannel: PostsInChannel) => {
-        postsInChannel._raw.id = record?.id ?? postsInChannel.id;
-        postsInChannel.channelId = record.channel_id;
-        postsInChannel.earliest = record.earliest;
-        postsInChannel.latest = record.latest;
+        postsInChannel._raw.id = raw?.id ?? postsInChannel.id;
+        postsInChannel.channelId = raw.channel_id;
+        postsInChannel.earliest = raw.earliest;
+        postsInChannel.latest = raw.latest;
    };

    return operateBaseRecord({
+        action,
        database,
        tableName: POSTS_IN_CHANNEL,
        value,
@@ -429,49 +479,180 @@ export const operatePostsInChannelRecord = async ({database, value}: Operator) =
 };

 /**
- * operateBaseRecord:  The 'id' of a record is key to this function. Please note that - at the moment - if WatermelonDB
- * encounters an existing record during a CREATE operation, it silently fails the operation.
+ * operateUserRecord: Prepares record of entity 'USER' from the SERVER database for update or create actions.
+ * @param {DataFactoryArgs} operator
+ * @param {Database} operator.database
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
+ */
+export const operateUserRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawUser;
+    const record = value.record as User;
+    const isCreateAction = action === OperationType.CREATE;
+
+    // id of user comes from server response
+    const generator = (user: User) => {
+        user._raw.id = isCreateAction ? (raw?.id ?? user.id) : record?.id;
+        user.authService = raw.auth_service;
+        user.deleteAt = raw.delete_at;
+        user.updateAt = raw.update_at;
+        user.email = raw.email;
+        user.firstName = raw.first_name;
+        user.isGuest = raw.roles.includes('system_guest');
+        user.lastName = raw.last_name;
+        user.lastPictureUpdate = raw.last_picture_update;
+        user.locale = raw.locale;
+        user.nickname = raw.nickname;
+        user.position = raw?.position ?? '';
+        user.roles = raw.roles;
+        user.username = raw.username;
+        user.notifyProps = raw.notify_props;
+        user.props = raw.props;
+        user.timezone = raw.timezone;
+        user.isBot = raw.is_bot;
+    };
+
+    return operateBaseRecord({
+        action,
+        database,
+        tableName: USER,
+        value,
+        generator,
+    });
+};
+
+/**
+ * operatePreferenceRecord: Prepares record of entity 'PREFERENCE' from the SERVER database for update or create actions.
+ * @param {DataFactoryArgs} operator
+ * @param {Database} operator.database
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
+ */
+export const operatePreferenceRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawPreference;
+    const record = value.record as Preference;
+    const isCreateAction = action === OperationType.CREATE;
+
+    // id of preference comes from server response
+    const generator = (preference: Preference) => {
+        preference._raw.id = isCreateAction ? (raw?.id ?? preference.id) : record?.id;
+        preference.category = raw.category;
+        preference.name = raw.name;
+        preference.userId = raw.user_id;
+        preference.value = raw.value;
+    };
+
+    return operateBaseRecord({
+        action,
+        database,
+        tableName: PREFERENCE,
+        value,
+        generator,
+    });
+};
+
+/**
+ * operatePreferenceRecord: Prepares record of entity 'TEAM_MEMBERSHIP' from the SERVER database for update or create actions.
+ * @param {DataFactoryArgs} operator
+ * @param {Database} operator.database
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
+ */
+export const operateTeamMembershipRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawTeamMembership;
+    const record = value.record as TeamMembership;
+    const isCreateAction = action === OperationType.CREATE;
+
+    // id of preference comes from server response
+    const generator = (teamMembership: TeamMembership) => {
+        teamMembership._raw.id = isCreateAction ? (raw?.id ?? teamMembership.id) : record?.id;
+        teamMembership.teamId = raw.team_id;
+        teamMembership.userId = raw.user_id;
+    };
+
+    return operateBaseRecord({
+        action,
+        database,
+        tableName: TEAM_MEMBERSHIP,
+        value,
+        generator,
+    });
+};
+
+/**
+ * operateGroupMembershipRecord: Prepares record of entity 'GROUP_MEMBERSHIP' from the SERVER database for update or create actions.
+ * @param {DataFactoryArgs} operator
+ * @param {Database} operator.database
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
+ */
+export const operateGroupMembershipRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawGroupMembership;
+    const record = value.record as GroupMembership;
+    const isCreateAction = action === OperationType.CREATE;
+
+    // id of preference comes from server response
+    const generator = (groupMember: GroupMembership) => {
+        groupMember._raw.id = isCreateAction ? (raw?.id ?? groupMember.id) : record?.id;
+        groupMember.groupId = raw.group_id;
+        groupMember.userId = raw.user_id;
+    };
+
+    return operateBaseRecord({
+        action,
+        database,
+        tableName: GROUP_MEMBERSHIP,
+        value,
+        generator,
+    });
+};
+
+/**
+ * operateChannelMembershipRecord: Prepares record of entity 'CHANNEL_MEMBERSHIP' from the SERVER database for update or create actions.
+ * @param {DataFactoryArgs} operator
+ * @param {Database} operator.database
+ * @param {MatchExistingRecord} operator.value
+ * @returns {Promise<void>}
+ */
+export const operateChannelMembershipRecord = async ({action, database, value}: DataFactoryArgs) => {
+    const raw = value.raw as RawChannelMembership;
+    const record = value.record as ChannelMembership;
+    const isCreateAction = action === OperationType.CREATE;
+
+    // id of preference comes from server response
+    const generator = (channelMember: ChannelMembership) => {
+        channelMember._raw.id = isCreateAction ? (raw?.id ?? channelMember.id) : record?.id;
+        channelMember.channelId = raw.channel_id;
+        channelMember.userId = raw.user_id;
+    };
+
+    return operateBaseRecord({
+        action,
+        database,
+        tableName: CHANNEL_MEMBERSHIP,
+        value,
+        generator,
+    });
+};
+
+/**
+ * operateBaseRecord:  This is the last step for each operator and depending on the 'action', it will either prepare an
+ * existing record for UPDATE or prepare a collection for CREATE
 *
- * This operator decides to go through an UPDATE action if we have an existing record in the table bearing the same id.
- * If not, it will go for a CREATE operation.
- *
- * However, if the tableName points to a major entity ( like Post, User or Channel, etc.), it verifies first if the
- * update_at value of the existing record is different from the parameter 'value' own update_at.  Only if they differ,
- * that it prepares the record for update.
- *
- * @param {Operator} operatorBase
+ * @param {DataFactoryArgs} operatorBase
 * @param {Database} operatorBase.database
 * @param {string} operatorBase.tableName
- * @param {RecordValue} operatorBase.value
+ * @param {MatchExistingRecord} operatorBase.value
 * @param {((model: Model) => void)} operatorBase.generator
- * @returns {Promise<Model>}
+ * @returns {Promise<any>}
 */
-const operateBaseRecord = async ({database, tableName, value, generator}: BaseOperator) => {
-    // We query first to see if we have a record on that entity with the current value.id
-    const appRecord = (await database.collections.
-        get(tableName!).
-        query(Q.where('id', value.id!)).
-        fetch()) as Model[];
+const operateBaseRecord = async ({action, database, tableName, value, generator}: DataFactoryArgs) => {
+    if (action === OperationType.UPDATE) {
+    // Two possible scenarios:
+    // 1. We are dealing with either duplicates here and if so, we'll update instead of create
+    // 2. This is just a normal update operation

-    const isPresent = appRecord.length > 0;
-
-    if (isPresent) {
-        const record = appRecord[0];
-
-        // We avoid unnecessary updates if we already have a record with the same update_at value for this model/entity
-        const isRecordIdentical = checkForIdenticalRecord({
-            tableName: tableName!,
-            newValue: value,
-            existingRecord: record,
-        });
-
-        if (isRecordIdentical) {
-            return null;
-        }
-
-        // Two possible scenarios:
-        // 1. We are dealing with either duplicates here and if so, we'll update instead of create
-        // 2. This is just a normal update operation
+        const record = value.record as Model;
        return record.prepareUpdate(() => generator!(record));
    }

@@ -480,28 +661,3 @@ const operateBaseRecord = async ({database, tableName, value, generator}: BaseOp
    // 2. This is just a normal create operation
    return database.collections.get(tableName!).prepareCreate(generator);
 };
-
-/**
- * checkForIdenticalRecord:
- * @param {IdenticalRecord} identicalRecord
- * @param {string} identicalRecord.tableName
- * @param {RecordValue} identicalRecord.newValue
- * @param {Model} identicalRecord.existingRecord
- * @returns {boolean}
- */
-const checkForIdenticalRecord = ({tableName, newValue, existingRecord}: IdenticalRecord) => {
-    const guardTables = [POST];
-    if (guardTables.includes(tableName)) {
-        switch (tableName) {
-            case POST: {
-                const tempPost = newValue as RawPost;
-                const currentRecord = (existingRecord as unknown) as Post;
-                return tempPost.update_at === currentRecord.updateAt;
-            }
-            default: {
-                return false;
-            }
-        }
-    }
-    return false;
-};
--- a/app/database/admin/data_operator/operators/test.ts
+++ b/app/database/admin/data_operator/operators/test.ts
@@ -1,33 +1,34 @@
 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
 // See LICENSE.txt for license information.
-import {Q} from '@nozbe/watermelondb';

-import {MM_TABLES} from '@constants/database';
 import DatabaseManager from '@database/admin/database_manager';
-import DataOperator from '@database/admin/data_operator';
-import App from '@typings/database/app';
-import {DatabaseType, IsolatedEntities} from '@typings/database/enums';
+import {DatabaseType, OperationType} from '@typings/database/enums';

 import {
    operateAppRecord,
+    operateChannelMembershipRecord,
    operateCustomEmojiRecord,
    operateDraftRecord,
    operateFileRecord,
    operateGlobalRecord,
+    operateGroupMembershipRecord,
    operatePostInThreadRecord,
    operatePostMetadataRecord,
    operatePostRecord,
    operatePostsInChannelRecord,
+    operatePreferenceRecord,
    operateReactionRecord,
    operateRoleRecord,
    operateServersRecord,
    operateSystemRecord,
+    operateTeamMembershipRecord,
    operateTermsOfServiceRecord,
+    operateUserRecord,
 } from './index';

 jest.mock('@database/admin/database_manager');

-const {APP} = MM_TABLES.DEFAULT;
+/* eslint-disable  @typescript-eslint/no-explicit-any */

 describe('*** DataOperator: Operators tests ***', () => {
    const createConnection = async (setActive = false) => {
@@ -60,12 +61,16 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateAppRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                buildNumber: 'build-7',
-                createdAt: 1,
-                id: 'id-18',
-                versionNumber: 'v-1',
+                record: undefined,
+                raw: {
+                    buildNumber: 'build-7',
+                    createdAt: 1,
+                    id: 'id-18',
+                    versionNumber: 'v-1',
+                },
            },
        });

@@ -80,8 +85,12 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateGlobalRecord({
+            action: OperationType.CREATE,
            database: database!,
-            value: {id: 'g-1', name: 'g-n1', value: 'g-v1'},
+            value: {
+                record: undefined,
+                raw: {id: 'g-1', name: 'g-n1', value: 'g-v1'},
+            },
        });

        expect(preparedRecords).toBeTruthy();
@@ -95,14 +104,18 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateServersRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                dbPath: 'mm-server',
-                displayName: 's-displayName',
-                id: 's-1',
-                mentionCount: 1,
-                unreadCount: 0,
-                url: 'https://community.mattermost.com',
+                record: undefined,
+                raw: {
+                    dbPath: 'mm-server',
+                    displayName: 's-displayName',
+                    id: 's-1',
+                    mentionCount: 1,
+                    unreadCount: 0,
+                    url: 'https://community.mattermost.com',
+                },
            },
        });

@@ -110,21 +123,6 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(preparedRecords!.collection.modelClass.name).toMatch('Servers');
    });

-    it('=> operateCustomEmojiRecord: should return an array of type CustomEmoji', async () => {
-        expect.assertions(3);
-
-        const database = await createConnection();
-        expect(database).toBeTruthy();
-
-        const preparedRecords = await operateCustomEmojiRecord({
-            database: database!,
-            value: {id: 'emo-1', name: 'emoji'},
-        });
-
-        expect(preparedRecords).toBeTruthy();
-        expect(preparedRecords!.collection.modelClass.name).toMatch('CustomEmoji');
-    });
-
    it('=> operateRoleRecord: should return an array of type Role', async () => {
        expect.assertions(3);

@@ -132,8 +130,12 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateRoleRecord({
+            action: OperationType.CREATE,
            database: database!,
-            value: {id: 'role-1', name: 'role-name-1', permissions: []},
+            value: {
+                record: undefined,
+                raw: {id: 'role-1', name: 'role-name-1', permissions: []},
+            },
        });

        expect(preparedRecords).toBeTruthy();
@@ -147,8 +149,12 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateSystemRecord({
+            action: OperationType.CREATE,
            database: database!,
-            value: {id: 'system-1', name: 'system-name-1', value: 'system'},
+            value: {
+                record: undefined,
+                raw: {id: 'system-1', name: 'system-name-1', value: 'system'},
+            },
        });

        expect(preparedRecords).toBeTruthy();
@@ -162,8 +168,18 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateTermsOfServiceRecord({
+            action: OperationType.CREATE,
            database: database!,
-            value: {id: 'system-1', acceptedAt: 1},
+            value: {
+                record: undefined,
+                raw: {
+                    id: 'tos-1',
+                    acceptedAt: 1,
+                    create_at: 1613667352029,
+                    user_id: 'user1613667352029',
+                    text: '',
+                },
+            },
        });

        expect(preparedRecords).toBeTruthy();
@@ -172,216 +188,6 @@ describe('*** DataOperator: Operators tests ***', () => {
        );
    });

-    it('=> should create a record in the App table in the default database', async () => {
-        expect.assertions(2);
-
-        // Creates a record in the App table
-        await DataOperator.handleIsolatedEntity({
-            tableName: IsolatedEntities.APP,
-            values: [
-                {
-                    buildNumber: 'build-1',
-                    createdAt: 1,
-                    id: 'id-1',
-                    versionNumber: 'version-1',
-                },
-            ],
-        });
-
-        // Do a query and find out if the value has been registered in the App table of the default database
-        const connection = await DatabaseManager.getDefaultDatabase();
-        expect(connection).toBeTruthy();
-
-        const records = (await connection!.collections.
-            get(APP).
-            query(Q.where('id', 'id-1')).
-            fetch()) as App[];
-
-        // We should expect to have a record returned as dictated by our query
-        expect(records.length).toBe(1);
-    });
-
-    it('=> should create several records in the App table in the default database', async () => {
-        expect.assertions(2);
-
-        // Creates a record in the App table
-        await DataOperator.handleIsolatedEntity({
-            tableName: IsolatedEntities.APP,
-            values: [
-                {
-                    buildNumber: 'build-10',
-                    createdAt: 1,
-                    id: 'id-10',
-                    versionNumber: 'version-10',
-                },
-                {
-                    buildNumber: 'build-11',
-                    createdAt: 1,
-                    id: 'id-11',
-                    versionNumber: 'version-11',
-                },
-                {
-                    buildNumber: 'build-12',
-                    createdAt: 1,
-                    id: 'id-12',
-                    versionNumber: 'version-12',
-                },
-                {
-                    buildNumber: 'build-13',
-                    createdAt: 1,
-                    id: 'id-13',
-                    versionNumber: 'version-13',
-                },
-            ],
-        });
-
-        // Do a query and find out if the value has been registered in the App table of the default database
-        const defaultDB = await DatabaseManager.getDefaultDatabase();
-        expect(defaultDB).toBeTruthy();
-
-        const records = (await defaultDB!.collections.
-            get(APP).
-            query(Q.where('id', Q.oneOf(['id-10', 'id-11', 'id-12', 'id-13']))).
-            fetch()) as App[];
-
-        // We should expect to have 4 records created
-        expect(records.length).toBe(4);
-    });
-
-    it('=> should update a record in the App table in the default database', async () => {
-        expect.assertions(3);
-
-        const defaultDB = await DatabaseManager.getDefaultDatabase();
-        expect(defaultDB).toBeTruthy();
-
-        // Update record having id 'id-1'
-        await DataOperator.handleIsolatedEntity({
-            tableName: IsolatedEntities.APP,
-            values: [
-                {
-                    buildNumber: 'build-13-13',
-                    createdAt: 1,
-                    id: 'id-1',
-                    versionNumber: 'version-1',
-                },
-            ],
-        });
-
-        const records = (await defaultDB!.collections.
-            get(APP).
-            query(Q.where('id', 'id-1')).
-            fetch()) as App[];
-        expect(records.length).toBeGreaterThan(0);
-
-        // Verify if the buildNumber for this record has been updated
-        expect(records[0].buildNumber).toMatch('build-13-13');
-    });
-
-    it('=> should update several records in the App table in the default database', async () => {
-        expect.assertions(4);
-
-        const defaultDB = await DatabaseManager.getDefaultDatabase();
-        expect(defaultDB).toBeTruthy();
-
-        // Update records having id 'id-10' and 'id-11'
-        await DataOperator.handleIsolatedEntity({
-            tableName: IsolatedEntities.APP,
-            values: [
-                {
-                    buildNumber: 'build-10x',
-                    createdAt: 1,
-                    id: 'id-10',
-                    versionNumber: 'version-10',
-                },
-                {
-                    buildNumber: 'build-11y',
-                    createdAt: 1,
-                    id: 'id-11',
-                    versionNumber: 'version-11',
-                },
-            ],
-        });
-
-        const records = (await defaultDB!.collections.
-            get(APP).
-            query(Q.where('id', Q.oneOf(['id-10', 'id-11']))).
-            fetch()) as App[];
-        expect(records.length).toBe(2);
-
-        // Verify if the buildNumber for those two record has been updated
-        expect(records[0].buildNumber).toMatch('build-10x');
-        expect(records[1].buildNumber).toMatch('build-11y');
-    });
-
-    it('=> [EDGE CASE] should UPDATE instead of CREATE record for existing id', async () => {
-        expect.assertions(3);
-
-        const defaultDB = await DatabaseManager.getDefaultDatabase();
-        expect(defaultDB).toBeTruthy();
-
-        await DataOperator.handleIsolatedEntity({
-            tableName: IsolatedEntities.APP,
-            values: [
-                {
-                    buildNumber: 'build-10x',
-                    createdAt: 1,
-                    id: 'id-10',
-                    versionNumber: 'version-10',
-                },
-                {
-                    buildNumber: 'build-11x',
-                    createdAt: 1,
-                    id: 'id-11',
-                    versionNumber: 'version-11',
-                },
-            ],
-        });
-
-        const records = (await defaultDB!.collections.
-            get(APP).
-            query(Q.where('id', Q.oneOf(['id-10', 'id-11']))).
-            fetch()) as App[];
-
-        // Verify if the buildNumber for those two record has been updated
-        expect(records[0].buildNumber).toMatch('build-10x');
-        expect(records[1].buildNumber).toMatch('build-11x');
-    });
-
-    it('=> [EDGE CASE] should CREATE instead of UPDATE record for non-existing id', async () => {
-        expect.assertions(3);
-
-        const defaultDB = await DatabaseManager.getDefaultDatabase();
-        expect(defaultDB).toBeTruthy();
-
-        // id-15 and id-16 do not exist but yet the optType is UPDATE.  The operator should then prepareCreate the records instead of prepareUpdate
-        await DataOperator.handleIsolatedEntity({
-            tableName: IsolatedEntities.APP,
-            values: [
-                {
-                    buildNumber: 'build-10x',
-                    createdAt: 1,
-                    id: 'id-15',
-                    versionNumber: 'version-10',
-                },
-                {
-                    buildNumber: 'build-11x',
-                    createdAt: 1,
-                    id: 'id-16',
-                    versionNumber: 'version-11',
-                },
-            ],
-        });
-
-        const records = (await defaultDB!.collections.
-            get(APP).
-            query(Q.where('id', Q.oneOf(['id-15', 'id-16']))).
-            fetch()) as App[];
-
-        // Verify if the buildNumber for those two record has been created
-        expect(records[0].buildNumber).toMatch('build-10x');
-        expect(records[1].buildNumber).toMatch('build-11x');
-    });
-
    it('=> operatePostRecord: should return an array of type Post', async () => {
        expect.assertions(3);

@@ -389,28 +195,32 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operatePostRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                id: '8swgtrrdiff89jnsiwiip3y1eoe',
-                create_at: 1596032651748,
-                update_at: 1596032651748,
-                edit_at: 0,
-                delete_at: 0,
-                is_pinned: false,
-                user_id: 'q3mzxua9zjfczqakxdkowc6u6yy',
-                channel_id: 'xxoq1p6bqg7dkxb3kj1mcjoungw',
-                root_id: 'ps81iqbesfby8jayz7owg4yypoo',
-                parent_id: 'ps81iqbddesfby8jayz7owg4yypoo',
-                original_id: '',
-                message: 'Testing operator post',
-                type: '',
-                props: {},
-                hashtags: '',
-                pending_post_id: '',
-                reply_count: 4,
-                last_reply_at: 0,
-                participants: null,
-                metadata: {},
+                record: undefined,
+                raw: {
+                    id: '8swgtrrdiff89jnsiwiip3y1eoe',
+                    create_at: 1596032651748,
+                    update_at: 1596032651748,
+                    edit_at: 0,
+                    delete_at: 0,
+                    is_pinned: false,
+                    user_id: 'q3mzxua9zjfczqakxdkowc6u6yy',
+                    channel_id: 'xxoq1p6bqg7dkxb3kj1mcjoungw',
+                    root_id: 'ps81iqbesfby8jayz7owg4yypoo',
+                    parent_id: 'ps81iqbddesfby8jayz7owg4yypoo',
+                    original_id: '',
+                    message: 'Testing operator post',
+                    type: '',
+                    props: {},
+                    hashtags: '',
+                    pending_post_id: '',
+                    reply_count: 4,
+                    last_reply_at: 0,
+                    participants: null,
+                    metadata: {},
+                },
            },
        });

@@ -425,17 +235,23 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operatePostInThreadRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                id: 'ps81iqbddesfby8jayz7owg4yypoo',
-                post_id: '8swgtrrdiff89jnsiwiip3y1eoe',
-                earliest: 1596032651748,
-                latest: 1597032651748,
+                record: undefined,
+                raw: {
+                    id: 'ps81iqbddesfby8jayz7owg4yypoo',
+                    post_id: '8swgtrrdiff89jnsiwiip3y1eoe',
+                    earliest: 1596032651748,
+                    latest: 1597032651748,
+                },
            },
        });

        expect(preparedRecords).toBeTruthy();
-        expect(preparedRecords!.collection.modelClass.name).toMatch('PostsInThread');
+        expect(preparedRecords!.collection.modelClass.name).toMatch(
+            'PostsInThread',
+        );
    });

    it('=> operateReactionRecord: should return an array of type Reaction', async () => {
@@ -445,15 +261,19 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateReactionRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                id: 'ps81iqbddesfby8jayz7owg4yypoo',
-                user_id: 'q3mzxua9zjfczqakxdkowc6u6yy',
-                post_id: 'ps81iqbddesfby8jayz7owg4yypoo',
-                emoji_name: 'thumbsup',
-                create_at: 1596032651748,
-                update_at: 1608253011321,
-                delete_at: 0,
+                record: undefined,
+                raw: {
+                    id: 'ps81iqbddesfby8jayz7owg4yypoo',
+                    user_id: 'q3mzxua9zjfczqakxdkowc6u6yy',
+                    post_id: 'ps81iqbddesfby8jayz7owg4yypoo',
+                    emoji_name: 'thumbsup',
+                    create_at: 1596032651748,
+                    update_at: 1608253011321,
+                    delete_at: 0,
+                },
            },
        });

@@ -468,12 +288,21 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateFileRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                post_id: 'ps81iqbddesfby8jayz7owg4yypoo',
-                name: 'test_file',
-                extension: '.jpg',
-                size: 1000,
+                record: undefined,
+                raw: {
+                    post_id: 'ps81iqbddesfby8jayz7owg4yypoo',
+                    name: 'test_file',
+                    extension: '.jpg',
+                    size: 1000,
+                    create_at: 1609253011321,
+                    delete_at: 1609253011321,
+                    height: 20,
+                    update_at: 1609253011321,
+                    user_id: 'wqyby5r5pinxxdqhoaomtacdhc',
+                },
            },
        });

@@ -488,12 +317,16 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operatePostMetadataRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                id: 'ps81i4yypoo',
-                data: {},
-                postId: 'ps81iqbddesfby8jayz7owg4yypoo',
-                type: 'opengraph',
+                record: undefined,
+                raw: {
+                    id: 'ps81i4yypoo',
+                    data: {},
+                    postId: 'ps81iqbddesfby8jayz7owg4yypoo',
+                    type: 'opengraph',
+                },
            },
        });

@@ -508,13 +341,17 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operateDraftRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                id: 'ps81i4yypoo',
-                root_id: 'ps81iqbddesfby8jayz7owg4yypoo',
-                message: 'draft message',
-                channel_id: 'channel_idp23232e',
-                files: [],
+                record: undefined,
+                raw: {
+                    id: 'ps81i4yypoo',
+                    root_id: 'ps81iqbddesfby8jayz7owg4yypoo',
+                    message: 'draft message',
+                    channel_id: 'channel_idp23232e',
+                    files: [],
+                },
            },
        });

@@ -529,16 +366,213 @@ describe('*** DataOperator: Operators tests ***', () => {
        expect(database).toBeTruthy();

        const preparedRecords = await operatePostsInChannelRecord({
+            action: OperationType.CREATE,
            database: database!,
            value: {
-                id: 'ps81i4yypoo',
-                channel_id: 'channel_idp23232e',
-                earliest: 1608253011321,
-                latest: 1609253011321,
+                record: undefined,
+                raw: {
+                    id: 'ps81i4yypoo',
+                    channel_id: 'channel_idp23232e',
+                    earliest: 1608253011321,
+                    latest: 1609253011321,
+                },
            },
        });

        expect(preparedRecords).toBeTruthy();
-        expect(preparedRecords!.collection.modelClass.name).toMatch('PostsInChannel');
+        expect(preparedRecords!.collection.modelClass.name).toMatch(
+            'PostsInChannel',
+        );
+    });
+
+    it('=> operateUserRecord: should return an array of type User', async () => {
+        expect.assertions(3);
+
+        const database = await createConnection();
+        expect(database).toBeTruthy();
+
+        const preparedRecords = await operateUserRecord({
+            action: OperationType.CREATE,
+            database: database!,
+            value: {
+                record: undefined,
+                raw: {
+                    id: '9ciscaqbrpd6d8s68k76xb9bte',
+                    is_bot: false,
+                    create_at: 1599457495881,
+                    update_at: 1607683720173,
+                    delete_at: 0,
+                    username: 'a.l',
+                    auth_service: 'saml',
+                    email: 'a.l@mattermost.com',
+                    email_verified: true,
+                    nickname: '',
+                    first_name: 'A',
+                    last_name: 'L',
+                    position: 'Mobile Engineer',
+                    roles: 'system_user',
+                    props: {},
+                    notify_props: {
+                        desktop: 'all',
+                        desktop_sound: true,
+                        email: true,
+                        first_name: true,
+                        mention_keys: '',
+                        push: 'mention',
+                        channel: true,
+                        auto_responder_active: false,
+                        auto_responder_message: 'Hello, I am out of office and unable to respond to messages.',
+                        comments: 'never',
+                        desktop_notification_sound: 'Hello',
+                        push_status: 'online',
+                    },
+                    last_password_update: 1604323112537,
+                    last_picture_update: 1604686302260,
+                    locale: 'en',
+                    timezone: {
+                        automaticTimezone: 'Indian/Mauritius',
+                        manualTimezone: '',
+                        useAutomaticTimezone: true,
+                    },
+                },
+            },
+        });
+
+        expect(preparedRecords).toBeTruthy();
+        expect(preparedRecords!.collection.modelClass.name).toMatch('User');
+    });
+
+    it('=> operatePreferenceRecord: should return an array of type Preference', async () => {
+        expect.assertions(3);
+
+        const database = await createConnection();
+        expect(database).toBeTruthy();
+
+        const preparedRecords = await operatePreferenceRecord({
+            action: OperationType.CREATE,
+            database: database!,
+            value: {
+                record: undefined,
+                raw: {user_id: '9ciscaqbrpd6d8s68k76xb9bte', category: 'tutorial_step', name: '9ciscaqbrpd6d8s68k76xb9bte', value: '2'},
+            },
+        });
+
+        expect(preparedRecords).toBeTruthy();
+        expect(preparedRecords!.collection.modelClass.name).toMatch('Preference');
+    });
+
+    it('=> operatePreferenceRecord: should return an array of type TEAM_MEMBERSHIP', async () => {
+        expect.assertions(3);
+
+        const database = await createConnection();
+        expect(database).toBeTruthy();
+
+        const preparedRecords = await operateTeamMembershipRecord({
+            action: OperationType.CREATE,
+            database: database!,
+            value: {
+                record: undefined,
+                raw: {
+                    team_id: 'a',
+                    user_id: 'ab',
+                    roles: '3ngdqe1e7tfcbmam4qgnxp91bw',
+                    delete_at: 0,
+                    scheme_guest: false,
+                    scheme_user: true,
+                    scheme_admin: false,
+                    explicit_roles: '',
+                },
+            },
+        });
+
+        expect(preparedRecords).toBeTruthy();
+        expect(preparedRecords!.collection.modelClass.name).toMatch('TeamMembership');
+    });
+
+    it('=> operateCustomEmojiRecord: should return an array of type CustomEmoji', async () => {
+        expect.assertions(3);
+
+        const database = await createConnection();
+        expect(database).toBeTruthy();
+
+        const preparedRecords = await operateCustomEmojiRecord({
+            action: OperationType.CREATE,
+            database: database!,
+            value: {
+                record: undefined,
+                raw: {
+                    id: 'i',
+                    create_at: 1580913641769,
+                    update_at: 1580913641769,
+                    delete_at: 0,
+                    creator_id: '4cprpki7ri81mbx8efixcsb8jo',
+                    name: 'boomI',
+                },
+            },
+        });
+
+        expect(preparedRecords).toBeTruthy();
+        expect(preparedRecords!.collection.modelClass.name).toMatch('CustomEmoji');
+    });
+
+    it('=> operateGroupMembershipRecord: should return an array of type GroupMembership', async () => {
+        expect.assertions(3);
+
+        const database = await createConnection();
+        expect(database).toBeTruthy();
+
+        const preparedRecords = await operateGroupMembershipRecord({
+            action: OperationType.CREATE,
+            database: database!,
+            value: {
+                record: undefined,
+                raw: {
+                    user_id: 'u4cprpki7ri81mbx8efixcsb8jo',
+                    group_id: 'g4cprpki7ri81mbx8efixcsb8jo',
+
+                },
+            },
+        });
+
+        expect(preparedRecords).toBeTruthy();
+        expect(preparedRecords!.collection.modelClass.name).toMatch('GroupMembership');
+    });
+
+    it('=> operateChannelMembershipRecord: should return an array of type ChannelMembership', async () => {
+        expect.assertions(3);
+
+        const database = await createConnection();
+        expect(database).toBeTruthy();
+
+        const preparedRecords = await operateChannelMembershipRecord({
+            action: OperationType.CREATE,
+            database: database!,
+            value: {
+                record: undefined,
+                raw: {
+                    channel_id: '17bfnb1uwb8epewp4q3x3rx9go',
+                    user_id: '9ciscaqbrpd6d8s68k76xb9bte',
+                    roles: 'wqyby5r5pinxxdqhoaomtacdhc',
+                    last_viewed_at: 1613667352029,
+                    msg_count: 3864,
+                    mention_count: 0,
+                    notify_props: {
+                        desktop: 'default',
+                        email: 'default',
+                        ignore_channel_mentions: 'default',
+                        mark_unread: 'mention',
+                        push: 'default',
+                    },
+                    last_update_at: 1613667352029,
+                    scheme_guest: false,
+                    scheme_user: true,
+                    scheme_admin: false,
+                    explicit_roles: '',
+                },
+            },
+        });
+
+        expect(preparedRecords).toBeTruthy();
+        expect(preparedRecords!.collection.modelClass.name).toMatch('ChannelMembership');
    });
 });