| |
| const { db } = require('shared/db'); |
| import { incrementMessageCount, decrementMessageCount } from './thread'; |
| import type { DBMessage } from 'shared/types'; |
|
|
| export type MessageTypes = 'text' | 'media'; |
|
|
| export const getMessage = (messageId: string): Promise<DBMessage> => { |
| return db |
| .table('messages') |
| .get(messageId) |
| .run() |
| .then(message => { |
| if (!message || message.deletedAt) return null; |
| return message; |
| }); |
| }; |
|
|
| export const getManyMessages = (messageIds: string[]): Promise<DBMessage[]> => { |
| return db |
| .table('messages') |
| .getAll(...messageIds) |
| .run() |
| .then(messages => { |
| return messages.filter(message => message && !message.deletedAt); |
| }); |
| }; |
|
|
| type BackwardsPaginationOptions = { last?: number, before?: number | Date }; |
|
|
| |
| const getBackwardsMessages = (threadId: string, { last, before }: BackwardsPaginationOptions) => { |
| return db |
| .table('messages') |
| .between( |
| [threadId, db.minval], |
| [threadId, before ? new Date(before) : db.maxval], |
| { index: 'threadIdAndTimestamp' } |
| ) |
| .orderBy({ index: db.desc('threadIdAndTimestamp') }) |
| .filter(db.row.hasFields('deletedAt').not()) |
| .limit(last || 0) |
| .run(); |
| }; |
|
|
| type ForwardsPaginationOptions = { first?: number, after?: number | Date }; |
|
|
| |
| const getForwardMessages = (threadId: string, { first, after }: ForwardsPaginationOptions) => { |
| return db |
| .table('messages') |
| .between( |
| [threadId, after ? new Date(after) : db.minval], |
| [threadId, db.maxval], |
| { index: 'threadIdAndTimestamp', leftBound: 'open', rightBound: 'closed' } |
| ) |
| .orderBy({ index: 'threadIdAndTimestamp' }) |
| .filter(db.row.hasFields('deletedAt').not()) |
| .limit(first || 0) |
| .run(); |
| }; |
|
|
| export const getMessages = ( |
| threadId: string, |
| { |
| first, |
| after, |
| last, |
| before, |
| }: { ...BackwardsPaginationOptions, ...ForwardsPaginationOptions } |
| ): Promise<Array<DBMessage>> => { |
| |
| if (last || before) return getBackwardsMessages(threadId, { last, before }); |
| |
| return getForwardMessages(threadId, { first, after }); |
| }; |
|
|
| export const getLastMessage = (threadId: string): Promise<?DBMessage> => { |
| return db |
| .table('messages') |
| .between([threadId, db.minval], [threadId, db.maxval], { |
| index: 'threadIdAndTimestamp', |
| leftBound: 'open', |
| rightBound: 'closed', |
| }) |
| .orderBy({ index: db.desc('threadIdAndTimestamp') }) |
| .filter(db.row.hasFields('deletedAt').not()) |
| .limit(1) |
| .run() |
| .then(res => (Array.isArray(res) && res.length > 0 ? res[0] : null)); |
| }; |
|
|
| export const getLastMessageOfThreads = ( |
| threadIds: Array<string> |
| ): Promise<Array<?DBMessage>> => { |
| return Promise.all(threadIds.map(id => getLastMessage(id))); |
| }; |
|
|
| |
| export const getMediaMessagesForThread = (threadId: string): Promise<Array<DBMessage>> => { |
| return db |
| .table('messages') |
| .getAll(threadId, { index: 'threadId' }) |
| .filter({ messageType: 'media' }) |
| .filter(db.row.hasFields('deletedAt').not()) |
| .run(); |
| }; |
|
|
| export const getMessageCount = (threadId: string): Promise<number> => { |
| return db |
| .table('messages') |
| .getAll(threadId, { index: 'threadId' }) |
| .filter(db.row.hasFields('deletedAt').not()) |
| .count() |
| .run(); |
| }; |
|
|
| |
| export const getMessageCountInThreads = (threadIds: Array<string>): Promise<Array<mixed>> => { |
| return db |
| .table('messages') |
| .getAll(...threadIds, { index: 'threadId' }) |
| .filter(db.row.hasFields('deletedAt').not()) |
| .group('threadId') |
| .count() |
| .run(); |
| }; |
|
|
| export const deleteMessage = (userId: string, messageId: string) => { |
| return db |
| .table('messages') |
| .get(messageId) |
| .update( |
| { |
| deletedBy: userId, |
| deletedAt: new Date(), |
| }, |
| { returnChanges: 'always' } |
| ) |
| .run() |
| .then(result => result.changes[0].new_val || result.changes[0].old_val) |
| .then(async message => { |
| await Promise.all([ |
| message.threadType === 'story' |
| ? decrementMessageCount(message.threadId) |
| : Promise.resolve(), |
| ]); |
|
|
| return message; |
| }); |
| }; |
|
|
| |
| export const deleteMessagesInThread = async (threadId: string, userId: string) => { |
| const messages = await db |
| .table('messages') |
| .getAll(threadId, { index: 'threadId' }) |
| .run(); |
|
|
| if (!messages || messages.length === 0) return; |
|
|
| const deletePromise = db |
| .table('messages') |
| .getAll(threadId, { index: 'threadId' }) |
| .update({ |
| deletedBy: userId, |
| deletedAt: new Date(), |
| }) |
| .run(); |
|
|
| return await Promise.all([ |
| deletePromise, |
| ]).then(() => { |
| return Promise.all(Array.from({ length: messages.length }).map(() => decrementMessageCount(threadId))) |
| }); |
| }; |
|
|
| export const userHasMessagesInThread = (threadId: string, userId: string) => { |
| return db |
| .table('messages') |
| .getAll(threadId, { index: 'threadId' }) |
| .filter(db.row.hasFields('deletedAt').not())('senderId') |
| .contains(userId) |
| .run(); |
| }; |
|
|
