Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

13.4 kB

// @flow
const { db } = require('shared/db');
import intersection from 'lodash.intersection';
const { parseRange } = require('./utils');
import { deleteMessagesInThread } from '../models/message';
import type { PaginationOptions } from '../utils/paginate-arrays';
import type { DBThread } from 'shared/types';
import type { Timeframe } from './utils';

const NOT_WATERCOOLER = thread =>
  db.not(thread.hasFields('watercooler')).or(thread('watercooler').eq(false));

export const getThread = (threadId: string): Promise<DBThread> => {
  return db
    .table('threads')
    .get(threadId)
    .run();
};

// prettier-ignore
export const getThreads = (threadIds: Array<string>): Promise<Array<DBThread>> => {
  return db
    .table('threads')
    .getAll(...threadIds)
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .run();
};

export const getThreadById = (threadId: string): Promise<?DBThread> => {
  return db
    .table('threads')
    .getAll(threadId)
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .run()
    .then(results => {
      if (!results || results.length === 0) return null;
      return results[0];
    });
};

// this is used to get all threads that need to be marked as deleted whenever a channel is deleted
export const getThreadsByChannelToDelete = (channelId: string) => {
  return db
    .table('threads')
    .getAll(channelId, { index: 'channelId' })
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .run();
};

// prettier-ignore
export const getThreadsByChannel = (channelId: string, options: PaginationOptions): Promise<Array<DBThread>> => {
  const { first, after } = options

  return db
    .table('threads')
    .between(
      [channelId, db.minval],
      [channelId, after ? new Date(after) : db.maxval],
      {
        index: 'channelIdAndLastActive',
        leftBound: 'open',
        rightBound: 'open',
      }
    )
    .orderBy({ index: db.desc('channelIdAndLastActive') })
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .limit(first)
    .run();
};

// prettier-ignore
type GetThreadsByChannelPaginationOptions = {
  first: number,
  after: number,
  sort: 'latest' | 'trending'
};

export const getThreadsByChannels = (
  channelIds: Array<string>,
  options: GetThreadsByChannelPaginationOptions
): Promise<Array<DBThread>> => {
  const { first, after, sort = 'latest' } = options;

  let order = [db.desc('lastActive'), db.desc('createdAt')];
  // If we want the top threads, first sort by the score and then lastActive
  if (sort === 'trending') order.unshift(db.desc('score'));

  return db
    .table('threads')
    .getAll(...channelIds, { index: 'channelId' })
    .filter(thread =>
      db.not(thread.hasFields('deletedAt')).and(NOT_WATERCOOLER(thread))
    )
    .orderBy(...order)
    .skip(after || 0)
    .limit(first || 999999)
    .run();
};

// prettier-ignore
export const getThreadsByCommunity = (communityId: string): Promise<Array<DBThread>> => {
  return db
    .table('threads')
    .between([communityId, db.minval], [communityId, db.maxval], {
      index: 'communityIdAndLastActive',
      leftBound: 'open',
      rightBound: 'open',
    })
    .orderBy({ index: db.desc('communityIdAndLastActive') })
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .run();
};

// prettier-ignore
export const getThreadsInTimeframe = (range: Timeframe): Promise<Array<Object>> => {
  const { current } = parseRange(range);
  return db
    .table('threads')
    .filter(db.row('createdAt').during(db.now().sub(current), db.now()))
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .run();
};

// We do not filter by deleted threads intentionally to prevent users from spam
// creating/deleting threads
// prettier-ignore
export const getThreadsByUserAsSpamCheck = (userId: string, timeframe: number = 60 * 10): Promise<Array<?DBThread>> => {
  return db
    .table('threads')
    .getAll(userId, { index: 'creatorId' })
    .filter(db.row('createdAt').during(db.now().sub(timeframe), db.now()))
    .run();
};

/*
  When viewing a user profile we have to take two arguments into account:
  1. The user who is being viewed
  2. The user who is doing the viewing
  We need to return only threads that meet the following criteria:
  1. The thread was posted to a public channel
  2. The thread was posted to a private channel and the viewing user is a member
*/
export const getViewableThreadsByUser = async (
  evalUser: string,
  currentUser: string,
  options: PaginationOptions
): Promise<Array<DBThread>> => {
  const { first, after } = options;
  // get a list of the channelIds the current user is allowed to see threads
  const getCurrentUsersChannelIds = db
    .table('usersChannels')
    .getAll(
      [currentUser, 'member'],
      [currentUser, 'moderator'],
      [currentUser, 'owner'],
      {
        index: 'userIdAndRole',
      }
    )
    .map(userChannel => userChannel('channelId'))
    .run();

  const getCurrentUserCommunityIds = db
    .table('usersCommunities')
    .getAll([currentUser, true], { index: 'userIdAndIsMember' })
    .map(userCommunity => userCommunity('communityId'))
    .run();

  // get a list of the channels where the user posted a thread
  const getPublishedChannelIds = db
    .table('threads')
    .getAll(evalUser, { index: 'creatorId' })
    .map(thread => thread('channelId'))
    .run();

  const getPublishedCommunityIds = db
    .table('threads')
    .getAll(evalUser, { index: 'creatorId' })
    .map(thread => thread('communityId'))
    .run();

  const [
    currentUsersChannelIds,
    publishedChannelIds,
    currentUsersCommunityIds,
    publishedCommunityIds,
  ] = await Promise.all([
    getCurrentUsersChannelIds,
    getPublishedChannelIds,
    getCurrentUserCommunityIds,
    getPublishedCommunityIds,
  ]);

  // get a list of all the channels that are public
  const publicChannelIds = await db
    .table('channels')
    .getAll(...publishedChannelIds)
    .filter({ isPrivate: false })
    .map(channel => channel('id'))
    .run();

  const publicCommunityIds = await db
    .table('communities')
    .getAll(...publishedCommunityIds)
    .filter({ isPrivate: false })
    .map(community => community('id'))
    .run();

  const allIds = [
    ...currentUsersChannelIds,
    ...currentUsersCommunityIds,
    ...publicChannelIds,
    ...publicCommunityIds,
  ];
  const distinctIds = allIds.filter((x, i, a) => a.indexOf(x) === i);
  let validChannelIds = intersection(distinctIds, publishedChannelIds);
  let validCommunityIds = intersection(distinctIds, publishedCommunityIds);

  // takes ~70ms for a heavy load
  return await db
    .table('threads')
    .getAll(evalUser, { index: 'creatorId' })
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .filter(thread => db.expr(validChannelIds).contains(thread('channelId')))
    .filter(thread =>
      db.expr(validCommunityIds).contains(thread('communityId'))
    )
    .orderBy(db.desc('lastActive'), db.desc('createdAt'))
    .skip(after || 0)
    .limit(first)
    .run()
    .then(res => {
      return res;
    });
};

// prettier-ignore
export const getPublicThreadsByUser = (evalUser: string, options: PaginationOptions): Promise<Array<DBThread>> => {
  const { first, after } = options
  return db
    .table('threads')
    .getAll(evalUser, { index: 'creatorId' })
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .eqJoin('channelId', db.table('channels'))
    .filter({ right: { isPrivate: false } })
    .without('right')
    .zip()
    .eqJoin('communityId', db.table('communities'))
    .filter({ right: { isPrivate: false } })
    .without('right')
    .zip()
    .orderBy(db.desc('lastActive'), db.desc('createdAt'))
    .skip(after || 0)
    .limit(first || 10)
    .run();
};

export const getViewableParticipantThreadsByUser = async (
  evalUser: string,
  currentUser: string,
  options: PaginationOptions
): Promise<Array<DBThread>> => {
  const { first, after } = options;
  // get a list of the channelIds the current user is allowed to see threads for
  const getCurrentUsersChannelIds = db
    .table('usersChannels')
    .getAll(
      [currentUser, 'member'],
      [currentUser, 'moderator'],
      [currentUser, 'owner'],
      {
        index: 'userIdAndRole',
      }
    )
    .map(userChannel => userChannel('channelId'))
    .run();

  const getCurrentUserCommunityIds = db
    .table('usersCommunities')
    .getAll([currentUser, true], { index: 'userIdAndIsMember' })
    .map(userCommunity => userCommunity('communityId'))
    .run();

  // get a list of the channels where the user participated in a thread
  const getParticipantChannelIds = db
    .table('usersThreads')
    .getAll([evalUser, true], { index: 'userIdAndIsParticipant' })
    .eqJoin('threadId', db.table('threads'))
    .zip()
    .pluck('channelId', 'threadId')
    .run();

  const getParticipantCommunityIds = db
    .table('usersThreads')
    .getAll([evalUser, true], { index: 'userIdAndIsParticipant' })
    .eqJoin('threadId', db.table('threads'))
    .zip()
    .pluck('communityId', 'threadId')
    .run();

  const [
    currentUsersChannelIds,
    participantChannelIds,
    currentUsersCommunityIds,
    participantCommunityIds,
  ] = await Promise.all([
    getCurrentUsersChannelIds,
    getParticipantChannelIds,
    getCurrentUserCommunityIds,
    getParticipantCommunityIds,
  ]);

  const participantThreadIds = participantChannelIds.map(c => c && c.threadId);
  const distinctParticipantChannelIds = participantChannelIds
    .map(c => c.channelId)
    .filter((x, i, a) => a.indexOf(x) === i);

  const distinctParticipantCommunityIds = participantCommunityIds
    .map(c => c.communityId)
    .filter((x, i, a) => a.indexOf(x) === i);

  // get a list of all the channels that are public
  const publicChannelIds = await db
    .table('channels')
    .getAll(...distinctParticipantChannelIds)
    .filter({ isPrivate: false })
    .map(channel => channel('id'))
    .run();

  const publicCommunityIds = await db
    .table('communities')
    .getAll(...distinctParticipantCommunityIds)
    .filter({ isPrivate: false })
    .map(community => community('id'))
    .run();

  const allIds = [
    ...currentUsersChannelIds,
    ...publicChannelIds,
    ...currentUsersCommunityIds,
    ...publicCommunityIds,
  ];
  const distinctIds = allIds.filter((x, i, a) => a.indexOf(x) === i);
  let validChannelIds = intersection(
    distinctIds,
    distinctParticipantChannelIds
  );
  let validCommunityIds = intersection(
    distinctIds,
    distinctParticipantCommunityIds
  );

  return await db
    .table('threads')
    .getAll(...participantThreadIds)
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .filter(thread => db.expr(validChannelIds).contains(thread('channelId')))
    .filter(thread =>
      db.expr(validCommunityIds).contains(thread('communityId'))
    )
    .orderBy(db.desc('lastActive'), db.desc('createdAt'))
    .skip(after || 0)
    .limit(first)
    .run()
    .then(res => {
      return res;
    });
};

// prettier-ignore
export const getPublicParticipantThreadsByUser = (evalUser: string, options: PaginationOptions): Promise<Array<DBThread>> => {
  const { first, after } = options
  return db
    .table('usersThreads')
    .getAll([evalUser, true], { index: 'userIdAndIsParticipant' })
    .eqJoin('threadId', db.table('threads'))
    .without({
      left: [
        'id',
        'userId',
        'threadId',
        'createdAt',
        'isParticipant',
        'receiveNotifications',
      ],
    })
    .zip()
    .filter(thread => db.not(thread.hasFields('deletedAt')))
    .eqJoin('channelId', db.table('channels'))
    .filter({ right: { isPrivate: false } })
    .without('right')
    .zip()
    .eqJoin('communityId', db.table('communities'))
    .filter({ right: { isPrivate: false } })
    .without('right')
    .zip()
    .orderBy(db.desc('lastActive'), db.desc('createdAt'))
    .skip(after || 0)
    .limit(first || 10)
    .run()
    .then(res => {
      return res;
    });
};

export const getWatercoolerThread = (
  communityId: string
): Promise<?DBThread> => {
  return db
    .table('threads')
    .getAll([communityId, true], { index: 'communityIdAndWatercooler' })
    .run()
    .then(result => {
      if (!Array.isArray(result) || result.length === 0) return null;
      return result[0];
    });
};

// prettier-ignore
export const deleteThread = (threadId: string, userId: string): Promise<Boolean> => {
  return db
    .table('threads')
    .get(threadId)
    .update(
      {
        deletedBy: userId,
        deletedAt: new Date(),
      },
      {
        returnChanges: true,
        nonAtomic: true,
      }
    )
    .run()
    .then(result =>
      Promise.all([
        result,
        deleteMessagesInThread(threadId, userId),
      ])
    )
    .then(([result]) => {
      return result.replaced >= 1 ? true : false;
    });
};

export const incrementMessageCount = (threadId: string) => {
  return db
    .table('threads')
    .get(threadId)
    .update({
      messageCount: db
        .row('messageCount')
        .default(0)
        .add(1),
    })
    .run();
};

export const decrementMessageCount = (threadId: string) => {
  return db
    .table('threads')
    .get(threadId)
    .update({
      messageCount: db
        .row('messageCount')
        .default(1)
        .sub(1),
    })
    .run();
};

	// @flow
	const { db } = require('shared/db');
	import intersection from 'lodash.intersection';
	const { parseRange } = require('./utils');
	import { deleteMessagesInThread } from '../models/message';
	import type { PaginationOptions } from '../utils/paginate-arrays';
	import type { DBThread } from 'shared/types';
	import type { Timeframe } from './utils';

	const NOT_WATERCOOLER = thread =>
	db.not(thread.hasFields('watercooler')).or(thread('watercooler').eq(false));

	export const getThread = (threadId: string): Promise<DBThread> => {
	return db
	.table('threads')
	.get(threadId)
	.run();
	};

	// prettier-ignore
	export const getThreads = (threadIds: Array<string>): Promise<Array<DBThread>> => {
	return db
	.table('threads')
	.getAll(...threadIds)
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.run();
	};

	export const getThreadById = (threadId: string): Promise<?DBThread> => {
	return db
	.table('threads')
	.getAll(threadId)
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.run()
	.then(results => {
	if (!results \|\| results.length === 0) return null;
	return results[0];
	});
	};

	// this is used to get all threads that need to be marked as deleted whenever a channel is deleted
	export const getThreadsByChannelToDelete = (channelId: string) => {
	return db
	.table('threads')
	.getAll(channelId, { index: 'channelId' })
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.run();
	};

	// prettier-ignore
	export const getThreadsByChannel = (channelId: string, options: PaginationOptions): Promise<Array<DBThread>> => {
	const { first, after } = options

	return db
	.table('threads')
	.between(
	[channelId, db.minval],
	[channelId, after ? new Date(after) : db.maxval],
	{
	index: 'channelIdAndLastActive',
	leftBound: 'open',
	rightBound: 'open',
	}
	)
	.orderBy({ index: db.desc('channelIdAndLastActive') })
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.limit(first)
	.run();
	};

	// prettier-ignore
	type GetThreadsByChannelPaginationOptions = {
	first: number,
	after: number,
	sort: 'latest' \| 'trending'
	};

	export const getThreadsByChannels = (
	channelIds: Array<string>,
	options: GetThreadsByChannelPaginationOptions
	): Promise<Array<DBThread>> => {
	const { first, after, sort = 'latest' } = options;

	let order = [db.desc('lastActive'), db.desc('createdAt')];
	// If we want the top threads, first sort by the score and then lastActive
	if (sort === 'trending') order.unshift(db.desc('score'));

	return db
	.table('threads')
	.getAll(...channelIds, { index: 'channelId' })
	.filter(thread =>
	db.not(thread.hasFields('deletedAt')).and(NOT_WATERCOOLER(thread))
	)
	.orderBy(...order)
	.skip(after \|\| 0)
	.limit(first \|\| 999999)
	.run();
	};

	// prettier-ignore
	export const getThreadsByCommunity = (communityId: string): Promise<Array<DBThread>> => {
	return db
	.table('threads')
	.between([communityId, db.minval], [communityId, db.maxval], {
	index: 'communityIdAndLastActive',
	leftBound: 'open',
	rightBound: 'open',
	})
	.orderBy({ index: db.desc('communityIdAndLastActive') })
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.run();
	};

	// prettier-ignore
	export const getThreadsInTimeframe = (range: Timeframe): Promise<Array<Object>> => {
	const { current } = parseRange(range);
	return db
	.table('threads')
	.filter(db.row('createdAt').during(db.now().sub(current), db.now()))
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.run();
	};

	// We do not filter by deleted threads intentionally to prevent users from spam
	// creating/deleting threads
	// prettier-ignore
	export const getThreadsByUserAsSpamCheck = (userId: string, timeframe: number = 60 * 10): Promise<Array<?DBThread>> => {
	return db
	.table('threads')
	.getAll(userId, { index: 'creatorId' })
	.filter(db.row('createdAt').during(db.now().sub(timeframe), db.now()))
	.run();
	};

	/*
	When viewing a user profile we have to take two arguments into account:
	1. The user who is being viewed
	2. The user who is doing the viewing

	We need to return only threads that meet the following criteria:
	1. The thread was posted to a public channel
	2. The thread was posted to a private channel and the viewing user is a member
	*/
	export const getViewableThreadsByUser = async (
	evalUser: string,
	currentUser: string,
	options: PaginationOptions
	): Promise<Array<DBThread>> => {
	const { first, after } = options;
	// get a list of the channelIds the current user is allowed to see threads
	const getCurrentUsersChannelIds = db
	.table('usersChannels')
	.getAll(
	[currentUser, 'member'],
	[currentUser, 'moderator'],
	[currentUser, 'owner'],
	{
	index: 'userIdAndRole',
	}
	)
	.map(userChannel => userChannel('channelId'))
	.run();

	const getCurrentUserCommunityIds = db
	.table('usersCommunities')
	.getAll([currentUser, true], { index: 'userIdAndIsMember' })
	.map(userCommunity => userCommunity('communityId'))
	.run();

	// get a list of the channels where the user posted a thread
	const getPublishedChannelIds = db
	.table('threads')
	.getAll(evalUser, { index: 'creatorId' })
	.map(thread => thread('channelId'))
	.run();

	const getPublishedCommunityIds = db
	.table('threads')
	.getAll(evalUser, { index: 'creatorId' })
	.map(thread => thread('communityId'))
	.run();

	const [
	currentUsersChannelIds,
	publishedChannelIds,
	currentUsersCommunityIds,
	publishedCommunityIds,
	] = await Promise.all([
	getCurrentUsersChannelIds,
	getPublishedChannelIds,
	getCurrentUserCommunityIds,
	getPublishedCommunityIds,
	]);

	// get a list of all the channels that are public
	const publicChannelIds = await db
	.table('channels')
	.getAll(...publishedChannelIds)
	.filter({ isPrivate: false })
	.map(channel => channel('id'))
	.run();

	const publicCommunityIds = await db
	.table('communities')
	.getAll(...publishedCommunityIds)
	.filter({ isPrivate: false })
	.map(community => community('id'))
	.run();

	const allIds = [
	...currentUsersChannelIds,
	...currentUsersCommunityIds,
	...publicChannelIds,
	...publicCommunityIds,
	];
	const distinctIds = allIds.filter((x, i, a) => a.indexOf(x) === i);
	let validChannelIds = intersection(distinctIds, publishedChannelIds);
	let validCommunityIds = intersection(distinctIds, publishedCommunityIds);

	// takes ~70ms for a heavy load
	return await db
	.table('threads')
	.getAll(evalUser, { index: 'creatorId' })
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.filter(thread => db.expr(validChannelIds).contains(thread('channelId')))
	.filter(thread =>
	db.expr(validCommunityIds).contains(thread('communityId'))
	)
	.orderBy(db.desc('lastActive'), db.desc('createdAt'))
	.skip(after \|\| 0)
	.limit(first)
	.run()
	.then(res => {
	return res;
	});
	};

	// prettier-ignore
	export const getPublicThreadsByUser = (evalUser: string, options: PaginationOptions): Promise<Array<DBThread>> => {
	const { first, after } = options
	return db
	.table('threads')
	.getAll(evalUser, { index: 'creatorId' })
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.eqJoin('channelId', db.table('channels'))
	.filter({ right: { isPrivate: false } })
	.without('right')
	.zip()
	.eqJoin('communityId', db.table('communities'))
	.filter({ right: { isPrivate: false } })
	.without('right')
	.zip()
	.orderBy(db.desc('lastActive'), db.desc('createdAt'))
	.skip(after \|\| 0)
	.limit(first \|\| 10)
	.run();
	};

	export const getViewableParticipantThreadsByUser = async (
	evalUser: string,
	currentUser: string,
	options: PaginationOptions
	): Promise<Array<DBThread>> => {
	const { first, after } = options;
	// get a list of the channelIds the current user is allowed to see threads for
	const getCurrentUsersChannelIds = db
	.table('usersChannels')
	.getAll(
	[currentUser, 'member'],
	[currentUser, 'moderator'],
	[currentUser, 'owner'],
	{
	index: 'userIdAndRole',
	}
	)
	.map(userChannel => userChannel('channelId'))
	.run();

	const getCurrentUserCommunityIds = db
	.table('usersCommunities')
	.getAll([currentUser, true], { index: 'userIdAndIsMember' })
	.map(userCommunity => userCommunity('communityId'))
	.run();

	// get a list of the channels where the user participated in a thread
	const getParticipantChannelIds = db
	.table('usersThreads')
	.getAll([evalUser, true], { index: 'userIdAndIsParticipant' })
	.eqJoin('threadId', db.table('threads'))
	.zip()
	.pluck('channelId', 'threadId')
	.run();

	const getParticipantCommunityIds = db
	.table('usersThreads')
	.getAll([evalUser, true], { index: 'userIdAndIsParticipant' })
	.eqJoin('threadId', db.table('threads'))
	.zip()
	.pluck('communityId', 'threadId')
	.run();

	const [
	currentUsersChannelIds,
	participantChannelIds,
	currentUsersCommunityIds,
	participantCommunityIds,
	] = await Promise.all([
	getCurrentUsersChannelIds,
	getParticipantChannelIds,
	getCurrentUserCommunityIds,
	getParticipantCommunityIds,
	]);

	const participantThreadIds = participantChannelIds.map(c => c && c.threadId);
	const distinctParticipantChannelIds = participantChannelIds
	.map(c => c.channelId)
	.filter((x, i, a) => a.indexOf(x) === i);

	const distinctParticipantCommunityIds = participantCommunityIds
	.map(c => c.communityId)
	.filter((x, i, a) => a.indexOf(x) === i);

	// get a list of all the channels that are public
	const publicChannelIds = await db
	.table('channels')
	.getAll(...distinctParticipantChannelIds)
	.filter({ isPrivate: false })
	.map(channel => channel('id'))
	.run();

	const publicCommunityIds = await db
	.table('communities')
	.getAll(...distinctParticipantCommunityIds)
	.filter({ isPrivate: false })
	.map(community => community('id'))
	.run();

	const allIds = [
	...currentUsersChannelIds,
	...publicChannelIds,
	...currentUsersCommunityIds,
	...publicCommunityIds,
	];
	const distinctIds = allIds.filter((x, i, a) => a.indexOf(x) === i);
	let validChannelIds = intersection(
	distinctIds,
	distinctParticipantChannelIds
	);
	let validCommunityIds = intersection(
	distinctIds,
	distinctParticipantCommunityIds
	);

	return await db
	.table('threads')
	.getAll(...participantThreadIds)
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.filter(thread => db.expr(validChannelIds).contains(thread('channelId')))
	.filter(thread =>
	db.expr(validCommunityIds).contains(thread('communityId'))
	)
	.orderBy(db.desc('lastActive'), db.desc('createdAt'))
	.skip(after \|\| 0)
	.limit(first)
	.run()
	.then(res => {
	return res;
	});
	};

	// prettier-ignore
	export const getPublicParticipantThreadsByUser = (evalUser: string, options: PaginationOptions): Promise<Array<DBThread>> => {
	const { first, after } = options
	return db
	.table('usersThreads')
	.getAll([evalUser, true], { index: 'userIdAndIsParticipant' })
	.eqJoin('threadId', db.table('threads'))
	.without({
	left: [
	'id',
	'userId',
	'threadId',
	'createdAt',
	'isParticipant',
	'receiveNotifications',
	],
	})
	.zip()
	.filter(thread => db.not(thread.hasFields('deletedAt')))
	.eqJoin('channelId', db.table('channels'))
	.filter({ right: { isPrivate: false } })
	.without('right')
	.zip()
	.eqJoin('communityId', db.table('communities'))
	.filter({ right: { isPrivate: false } })
	.without('right')
	.zip()
	.orderBy(db.desc('lastActive'), db.desc('createdAt'))
	.skip(after \|\| 0)
	.limit(first \|\| 10)
	.run()
	.then(res => {
	return res;
	});
	};

	export const getWatercoolerThread = (
	communityId: string
	): Promise<?DBThread> => {
	return db
	.table('threads')
	.getAll([communityId, true], { index: 'communityIdAndWatercooler' })
	.run()
	.then(result => {
	if (!Array.isArray(result) \|\| result.length === 0) return null;
	return result[0];
	});
	};

	// prettier-ignore
	export const deleteThread = (threadId: string, userId: string): Promise<Boolean> => {
	return db
	.table('threads')
	.get(threadId)
	.update(
	{
	deletedBy: userId,
	deletedAt: new Date(),
	},
	{
	returnChanges: true,
	nonAtomic: true,
	}
	)
	.run()
	.then(result =>
	Promise.all([
	result,
	deleteMessagesInThread(threadId, userId),
	])
	)
	.then(([result]) => {
	return result.replaced >= 1 ? true : false;
	});
	};

	export const incrementMessageCount = (threadId: string) => {
	return db
	.table('threads')
	.get(threadId)
	.update({
	messageCount: db
	.row('messageCount')
	.default(0)
	.add(1),
	})
	.run();
	};

	export const decrementMessageCount = (threadId: string) => {
	return db
	.table('threads')
	.get(threadId)
	.update({
	messageCount: db
	.row('messageCount')
	.default(1)
	.sub(1),
	})
	.run();
	};