mirror of
https://github.com/mattermost/mattermost-mobile.git
synced 2026-11-17 17:08:16 +00:00
Client, mapping, and capability layer only — intentionally NOT wired into any
lifecycle/trigger path yet (no coordinator, no workers).
- types/api/drafts.d.ts: add DraftApi (server response) and DraftUpsertRequest
(POST body) DTOs alongside DraftProps.
- types/api/config.d.ts: add AllowSyncedDrafts to ClientConfig.
- client/rest/base.ts: add draft route helpers (drafts POST, user/team GET,
channel/thread DELETE).
- client/rest/drafts.ts (+test): ClientDrafts mixin — getDrafts, upsertDraft,
deleteDraft (channel vs thread by rootId), Connection-Id header on POST/DELETE.
Mixed into client/rest/index.ts (also drops a pre-existing duplicate
ClientScheduledPost entry in the .with() list).
- constants/preferences.ts: add ADVANCED_SYNC_DRAFTS ('sync_drafts').
- utils/draft/sync.ts (+test): pure bidirectional normalization. server->mobile
maps update_at->server_update_at (never local update_at), priority, props
passthrough, exact file_ids, files from metadata.files; mobile->server sends
only channel_id/root_id/message/type/props/file_ids/priority and returns null
for an empty message so it never POSTs. Fail-closed burn-on-read reconstruction
(durations come from server config, not props; missing/invalid -> no enabled
borConfig).
- queries/servers/drafts.ts: getIsDraftSyncEnabled / observeIsDraftSyncEnabled —
enabled when AllowSyncedDrafts==='true' AND sync_drafts pref not 'false'
(absent = enabled). No server-version gate.
Checks: npm run tsc clean; eslint --quiet clean; 69 focused Jest tests pass
across the new client/sync suites and the scheduled_post/post-handler/drafts
regression neighbors.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
241 lines
9.3 KiB
TypeScript
241 lines
9.3 KiB
TypeScript
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
import {Database, Q} from '@nozbe/watermelondb';
|
|
import {combineLatest, distinctUntilChanged, of as of$, switchMap} from 'rxjs';
|
|
|
|
import {Preferences} from '@constants';
|
|
import {MM_TABLES} from '@constants/database';
|
|
import DraftModel from '@typings/database/models/servers/draft';
|
|
|
|
import {queryPreferencesByCategoryAndName} from './preference';
|
|
import {getConfigBooleanValue, observeConfigBooleanValue} from './system';
|
|
|
|
import type Model from '@nozbe/watermelondb/Model';
|
|
import type DraftOutboxModel from '@typings/database/models/servers/draft_outbox';
|
|
|
|
const {SERVER: {DRAFT, DRAFT_OUTBOX, CHANNEL}} = MM_TABLES;
|
|
|
|
/**
|
|
* buildDraftOutboxId: shared deterministic local ID for a DraftOutbox row.
|
|
* Mattermost IDs are alphanumeric and cannot contain the hyphen delimiter, and the
|
|
* `root` fallback for channel drafts (root_id === '') cannot collide with a real
|
|
* 26-character alphanumeric root ID. This is a local-only WatermelonDB record ID and
|
|
* is never sent to the server.
|
|
*/
|
|
export const buildDraftOutboxId = (channelId: string, rootId = '') => {
|
|
return `${channelId}-${rootId || 'root'}`;
|
|
};
|
|
|
|
/**
|
|
* isDraftSyncPreferenceEnabled: the advanced setting gate. Synchronization stays enabled
|
|
* when the `advanced_settings/sync_drafts` preference is absent (opt-out defaults to on)
|
|
* and is only disabled when the preference is explicitly set to 'false'.
|
|
*/
|
|
const isDraftSyncPreferenceEnabled = (value: string | undefined) => {
|
|
return value !== 'false';
|
|
};
|
|
|
|
/**
|
|
* getIsDraftSyncEnabled: draft synchronization is enabled ONLY when BOTH the server config
|
|
* `AllowSyncedDrafts` is 'true' AND the user's `advanced_settings/sync_drafts` preference is
|
|
* not explicitly 'false'. There is deliberately no server-version gate: drafts predate the
|
|
* minimum supported server.
|
|
*/
|
|
export const getIsDraftSyncEnabled = async (database: Database) => {
|
|
const allowed = await getConfigBooleanValue(database, 'AllowSyncedDrafts');
|
|
if (!allowed) {
|
|
return false;
|
|
}
|
|
|
|
const prefs = await queryPreferencesByCategoryAndName(
|
|
database,
|
|
Preferences.CATEGORIES.ADVANCED_SETTINGS,
|
|
Preferences.ADVANCED_SYNC_DRAFTS,
|
|
).fetch();
|
|
|
|
return isDraftSyncPreferenceEnabled(prefs[0]?.value);
|
|
};
|
|
|
|
/**
|
|
* observeIsDraftSyncEnabled: reactive form of getIsDraftSyncEnabled. Emits true only when
|
|
* the `AllowSyncedDrafts` config is 'true' AND the `advanced_settings/sync_drafts` preference
|
|
* is not explicitly 'false'.
|
|
*/
|
|
export const observeIsDraftSyncEnabled = (database: Database) => {
|
|
const allowed = observeConfigBooleanValue(database, 'AllowSyncedDrafts');
|
|
const preference = queryPreferencesByCategoryAndName(
|
|
database,
|
|
Preferences.CATEGORIES.ADVANCED_SETTINGS,
|
|
Preferences.ADVANCED_SYNC_DRAFTS,
|
|
).observeWithColumns(['value']);
|
|
|
|
return combineLatest([allowed, preference]).pipe(
|
|
switchMap(([isAllowed, prefs]) => of$(isAllowed && isDraftSyncPreferenceEnabled(prefs[0]?.value))),
|
|
distinctUntilChanged(),
|
|
);
|
|
};
|
|
|
|
export const getDraft = async (database: Database, channelId: string, rootId = '') => {
|
|
const record = await queryDraft(database, channelId, rootId).fetch();
|
|
|
|
// Check done to force types
|
|
if (record.length) {
|
|
return record[0];
|
|
}
|
|
return undefined;
|
|
};
|
|
|
|
export const queryDraft = (database: Database, channelId: string, rootId = '') => {
|
|
return database.collections.get<DraftModel>(DRAFT).query(
|
|
Q.where('channel_id', channelId),
|
|
Q.where('root_id', rootId),
|
|
);
|
|
};
|
|
|
|
export function observeFirstDraft(v: DraftModel[]) {
|
|
return v[0]?.observe() || of$(undefined);
|
|
}
|
|
|
|
export const queryDraftsForTeam = (database: Database, teamId: string) => {
|
|
return database.collections.get<DraftModel>(DRAFT).query(
|
|
Q.on(CHANNEL,
|
|
Q.and(
|
|
Q.or(
|
|
Q.where('team_id', teamId), // Channels associated with the given team
|
|
Q.where('type', 'D'), // Direct Message
|
|
Q.where('type', 'G'), // Group Message
|
|
),
|
|
Q.where('delete_at', 0), // Ensure the channel is not deleted
|
|
),
|
|
),
|
|
Q.sortBy('update_at', Q.desc),
|
|
);
|
|
};
|
|
|
|
export const observeDraftsForTeam = (database: Database, teamId: string) => {
|
|
return queryDraftsForTeam(database, teamId).observeWithColumns(['update_at']);
|
|
};
|
|
|
|
export const observeDraftCount = (database: Database, teamId: string) => {
|
|
return queryDraftsForTeam(database, teamId).observeCount();
|
|
};
|
|
|
|
export const observeDraftById = (database: Database, draftId: string) => {
|
|
return database.collections.get<DraftModel>(DRAFT).
|
|
query(Q.where('id', draftId)).observe().pipe(
|
|
switchMap((drafts) => observeFirstDraft(drafts)),
|
|
);
|
|
};
|
|
|
|
export const queryDraftOutbox = (database: Database, channelId: string, rootId = '') => {
|
|
return database.collections.get<DraftOutboxModel>(DRAFT_OUTBOX).query(
|
|
Q.where('channel_id', channelId),
|
|
Q.where('root_id', rootId),
|
|
);
|
|
};
|
|
|
|
export const getDraftOutbox = async (database: Database, channelId: string, rootId = '') => {
|
|
const records = await queryDraftOutbox(database, channelId, rootId).fetch();
|
|
return records.length ? records[0] : undefined;
|
|
};
|
|
|
|
/**
|
|
* Prepare function passed to mutateDraftAndOutbox. It receives the current Draft and
|
|
* DraftOutbox rows for the composite key (already fetched inside the writer) and must
|
|
* return the prepared records (via prepareCreate/prepareUpdate/prepareDestroyPermanently)
|
|
* to commit. It must NOT commit anything itself; the primitive batches everything atomically.
|
|
*/
|
|
export type PrepareDraftAndOutbox = (args: {
|
|
database: Database;
|
|
channelId: string;
|
|
rootId: string;
|
|
draft?: DraftModel;
|
|
outbox?: DraftOutboxModel;
|
|
}) => Model[] | Promise<Model[]>;
|
|
|
|
/**
|
|
* mutateDraftAndOutbox: the single serialized primitive for all Draft/DraftOutbox state
|
|
* transitions. It enters database.write BEFORE querying both tables, queries by the full
|
|
* composite key (channel_id, root_id), lets the caller prepare all changes, and commits
|
|
* them in one writer.batch. WatermelonDB serializes writers, so concurrent callers see each
|
|
* other's committed rows, which preserves the "at most one Draft and one DraftOutbox per key"
|
|
* invariant. Do not route these transitions through the generic read-before-write handlers.
|
|
*/
|
|
export const mutateDraftAndOutbox = async (
|
|
database: Database,
|
|
channelId: string,
|
|
rootId: string,
|
|
prepare: PrepareDraftAndOutbox,
|
|
): Promise<Model[]> => {
|
|
return database.write(async (writer) => {
|
|
const draft = await getDraft(database, channelId, rootId);
|
|
const outbox = await getDraftOutbox(database, channelId, rootId);
|
|
const models = await prepare({database, channelId, rootId, draft, outbox});
|
|
if (models.length) {
|
|
await writer.batch(...models);
|
|
}
|
|
return models;
|
|
}, 'mutateDraftAndOutbox');
|
|
};
|
|
|
|
/**
|
|
* repairDuplicateDrafts: deterministically removes pre-existing duplicate Draft rows that
|
|
* share a composite key (channel_id, root_id). Keeps the row with the greatest local
|
|
* update_at; on ties keeps the greatest WatermelonDB ID by UTF-16 code-unit order. Returns
|
|
* the number of removed rows.
|
|
*
|
|
* The fetch, grouping, winner selection, and deletion all happen inside a single
|
|
* database.write. Because WatermelonDB serializes writers, this prevents a concurrent
|
|
* mutateDraftAndOutbox from updating a row after it has been selected for deletion (which
|
|
* would otherwise destroy a freshly-edited draft).
|
|
*/
|
|
export const repairDuplicateDrafts = async (database: Database): Promise<number> => {
|
|
return database.write(async (writer) => {
|
|
const drafts = await database.collections.get<DraftModel>(DRAFT).query().fetch();
|
|
|
|
const groups = new Map<string, DraftModel[]>();
|
|
for (const draft of drafts) {
|
|
// JSON.stringify of the key tuple is unambiguous regardless of the characters
|
|
// in channel_id/root_id, and keeps the file free of control characters.
|
|
const key = JSON.stringify([draft.channelId, draft.rootId]);
|
|
const group = groups.get(key);
|
|
if (group) {
|
|
group.push(draft);
|
|
} else {
|
|
groups.set(key, [draft]);
|
|
}
|
|
}
|
|
|
|
const toDestroy: DraftModel[] = [];
|
|
for (const group of groups.values()) {
|
|
if (group.length <= 1) {
|
|
continue;
|
|
}
|
|
|
|
const sorted = [...group].sort((a, b) => {
|
|
if (b.updateAt !== a.updateAt) {
|
|
return b.updateAt - a.updateAt;
|
|
}
|
|
|
|
// Descending UTF-16 code-unit comparison so the greatest id is kept.
|
|
// localeCompare is locale-aware and not guaranteed to match code-unit order
|
|
// for mixed-case WatermelonDB IDs.
|
|
if (a.id === b.id) {
|
|
return 0;
|
|
}
|
|
return a.id > b.id ? -1 : 1;
|
|
});
|
|
|
|
// Keep sorted[0] (greatest update_at, then greatest id); remove the rest.
|
|
toDestroy.push(...sorted.slice(1));
|
|
}
|
|
|
|
if (toDestroy.length) {
|
|
await writer.batch(...toDestroy.map((draft) => draft.prepareDestroyPermanently()));
|
|
}
|
|
|
|
return toDestroy.length;
|
|
}, 'repairDuplicateDrafts');
|
|
};
|