8787152133

Committed 22 Apr 2024 03:59PM UTC coverage: 32.067% (-0.01%) from 32.077%

Build # 8787152133

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9151 from ForumMagnum/master

[EA] Deploy waiting for first render before starting bundle, fix for colour of ellipses

Run Details

4683 of 37963 branches covered (12.34%)

Branch coverage included in aggregate %.

11 of 48 new or added lines in 16 files covered. (22.92%)

1 existing line in 1 file now uncovered.

27158 of 61331 relevant lines covered (44.28%)

182.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

30.43

/packages/lesswrong/lib/collections/conversations/schema.ts

import { accessFilterSingle, arrayOfForeignKeysField, denormalizedCountOfReferences, resolverOnlyField, schemaDefaultValue } from '../../utils/schemaUtils'
import * as _ from 'underscore';
import { isLWorAF } from '../../instanceSettings';
import { getWithCustomLoader } from '../../loaders';
import { isFriendlyUI } from '../../../themes/forumTheme';

const schema: SchemaType<"Conversations"> = {
  title: {
    type: String,
    canRead: ['members'],
    canUpdate: ['members'],
    canCreate: ['members'],
    optional: true,
    label: isFriendlyUI ? "Conversation title (visible to all)" : "Conversation Title"
  },
  participantIds: {
    ...arrayOfForeignKeysField({
      idFieldName: "participantIds",
      resolverName: "participants",
      collectionName: "Users",
      type: "User"
    }),
    canRead: ['members'],
    canCreate: ['members'],
    canUpdate: ['members'],
    optional: true,
    control: "FormUserMultiselect",
    label: "Participants",
  },
  'participantIds.$': {
    type: String,
    foreignKey: "Users",
    optional: true,
  },
  latestActivity: {
    type: Date,
    denormalized: true,
    canRead: ['members'],
    onInsert: (document) => {
      return new Date(); // if this is an insert, set latestActivity to current timestamp
    },
    optional: true,
  },
  af: {
    type: Boolean,
    canRead: ['guests'],
    canCreate: ['members'],
    canUpdate: ['admins'],
    optional: true,
    hidden: !isLWorAF
  },
  messageCount: {
    ...denormalizedCountOfReferences({
      fieldName: "messageCount",
      collectionName: "Conversations",
      foreignCollectionName: "Messages",
      foreignTypeName: "message",
      foreignFieldName: "conversationId"
    }),
    canRead: ['guests'],
  },
  moderator: {
    type: Boolean,
    canRead: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    canUpdate: ['admins', 'sunshineRegiment'],
    optional: true,
    nullable: true
  },
  archivedByIds: {
    ...arrayOfForeignKeysField({
      idFieldName: "archivedByIds",
      resolverName: "archivedBy",
      collectionName: "Users",
      type: "User"
    }),
    optional: true,
    hidden: true,
    canRead: ['guests'],
    canCreate: ['members'],
    canUpdate: ['members'],
    ...schemaDefaultValue([]), // Note: this sets onUpdate and onCreate. onUpdate is overridden below
    // Allow users to only update their own archived status, this has some potential concurrency problems,
    // but I don't expect this to ever come up, and it fails relatively gracefully in case one does occur
    onUpdate: ({data, currentUser, oldDocument}) => {
      if (data?.archivedByIds) {
        const changedIds = _.difference(oldDocument?.archivedByIds || [], data?.archivedByIds)
        changedIds.forEach((id => {
          if (id !== currentUser!._id) {
            throw new Error(`You can't archive or unarchive a conversation for another user. Attempted update: ${JSON.stringify(data)}`)
          }
        }))
      }
      return data.archivedByIds ?? []
    }
  },
  'archivedByIds.$': {
    type: String,
    foreignKey: "Users",
    optional: true,
  },
  latestMessage: resolverOnlyField({
    type: "Message",
    graphQLtype: "Message",
    canRead: ['members'],
    resolver: async (conversation: DbConversation, _args, context: ResolverContext) => {
      const { currentUser } = context;
      const message: DbMessage | null = await getWithCustomLoader<DbMessage | null, string>(
        context,
        "latestMessage",
        conversation._id,
        async (conversationIds: string[]): Promise<(DbMessage | null)[]> => {
          return await context.repos.conversations.getLatestMessages(conversationIds);
        }
      );
      const filteredMessage = await accessFilterSingle(currentUser, context.Messages, message, context)
      return filteredMessage;
    },
    sqlResolver: ({field, join}) => join({
      table: "Messages",
      type: "left",
      on: {
        _id: `(
          SELECT "_id"
          FROM "Messages"
          WHERE "conversationId" = ${field("_id")}
          ORDER BY "createdAt" DESC
          LIMIT 1
        )`,
      },
      resolver: (messagesField) => messagesField("*"),
    }),
  }),
  hasUnreadMessages: resolverOnlyField({
    type: Boolean,
    graphQLtype: "Boolean",
    canRead: ["members"],
    resolver: async (
      conversation: DbConversation,
      _args,
      context: ResolverContext,
    ) => {
      const {currentUser} = context;
      if (!currentUser) {
        return false;
      }
      return getWithCustomLoader<boolean, string>(
        context,
        "hasUnreadMessages",
        conversation._id,
        (conversationIds: string[]): Promise<boolean[]> =>
          context.repos.conversations.getReadStatuses(currentUser._id, conversationIds),
      );
    },
    sqlResolver: ({field, currentUserField, join}) => join({
      isNonCollectionJoin: true,
      table: "ConversationUnreadMessages",
      type: "left",
      on: {
        conversationId: field("_id"),
        userId: currentUserField("_id"),
      },
      resolver: (unreadMessagesField) =>
        `COALESCE(${unreadMessagesField("hasUnreadMessages")}, FALSE)`,
    }),
  }),
};

export default schema;

1	import { accessFilterSingle, arrayOfForeignKeysField, denormalizedCountOfReferences, resolverOnlyField, schemaDefaultValue } from '../../utils/schemaUtils'	76✔
2	import * as _ from 'underscore';	19✔
3	import { isLWorAF } from '../../instanceSettings';	19✔
4	import { getWithCustomLoader } from '../../loaders';	19✔
5	import { isFriendlyUI } from '../../../themes/forumTheme';	19✔
6
7	const schema: SchemaType<"Conversations"> = {	19✔
8	title: {
9	type: String,
10	canRead: ['members'],
11	canUpdate: ['members'],
12	canCreate: ['members'],
13	optional: true,
14	label: isFriendlyUI ? "Conversation title (visible to all)" : "Conversation Title"	19!
15	},
16	participantIds: {
17	...arrayOfForeignKeysField({
18	idFieldName: "participantIds",
19	resolverName: "participants",
20	collectionName: "Users",
21	type: "User"
22	}),
23	canRead: ['members'],
24	canCreate: ['members'],
25	canUpdate: ['members'],
26	optional: true,
27	control: "FormUserMultiselect",
28	label: "Participants",
29	},
30	'participantIds.$': {
31	type: String,
32	foreignKey: "Users",
33	optional: true,
34	},
35	latestActivity: {
36	type: Date,
37	denormalized: true,
38	canRead: ['members'],
39	onInsert: (document) => {
40	return new Date(); // if this is an insert, set latestActivity to current timestamp	3✔
41	},
42	optional: true,
43	},
44	af: {
45	type: Boolean,
46	canRead: ['guests'],
47	canCreate: ['members'],
48	canUpdate: ['admins'],
49	optional: true,
50	hidden: !isLWorAF
51	},
52	messageCount: {
53	...denormalizedCountOfReferences({
54	fieldName: "messageCount",
55	collectionName: "Conversations",
56	foreignCollectionName: "Messages",
57	foreignTypeName: "message",
58	foreignFieldName: "conversationId"
59	}),
60	canRead: ['guests'],
61	},
62	moderator: {
63	type: Boolean,
64	canRead: ['admins', 'sunshineRegiment'],
65	canCreate: ['admins', 'sunshineRegiment'],
66	canUpdate: ['admins', 'sunshineRegiment'],
67	optional: true,
68	nullable: true
69	},
70	archivedByIds: {
71	...arrayOfForeignKeysField({
72	idFieldName: "archivedByIds",
73	resolverName: "archivedBy",
74	collectionName: "Users",
75	type: "User"
76	}),
77	optional: true,
78	hidden: true,
79	canRead: ['guests'],
80	canCreate: ['members'],
81	canUpdate: ['members'],
82	...schemaDefaultValue([]), // Note: this sets onUpdate and onCreate. onUpdate is overridden below
83	// Allow users to only update their own archived status, this has some potential concurrency problems,
84	// but I don't expect this to ever come up, and it fails relatively gracefully in case one does occur
85	onUpdate: ({data, currentUser, oldDocument}) => {
86	if (data?.archivedByIds) {	3!
87	const changedIds = _.difference(oldDocument?.archivedByIds \|\| [], data?.archivedByIds)	×
88	changedIds.forEach((id => {	×
89	if (id !== currentUser!._id) {	×
90	throw new Error(`You can't archive or unarchive a conversation for another user. Attempted update: ${JSON.stringify(data)}`)	×
91	}
92	}))
93	}
94	return data.archivedByIds ?? []	3!
95	}
96	},
97	'archivedByIds.$': {
98	type: String,
99	foreignKey: "Users",
100	optional: true,
101	},
102	latestMessage: resolverOnlyField({
103	type: "Message",
104	graphQLtype: "Message",
105	canRead: ['members'],
106	resolver: async (conversation: DbConversation, _args, context: ResolverContext) => {
107	const { currentUser } = context;	×
108	const message: DbMessage \| null = await getWithCustomLoader<DbMessage \| null, string>(	×
109	context,
110	"latestMessage",
111	conversation._id,
112	async (conversationIds: string[]): Promise<(DbMessage \| null)[]> => {
113	return await context.repos.conversations.getLatestMessages(conversationIds);	×
114	}
115	);
116	const filteredMessage = await accessFilterSingle(currentUser, context.Messages, message, context)	×
117	return filteredMessage;	×
118	},
NEW 119	sqlResolver: ({field, join}) => join({	×
120	table: "Messages",
121	type: "left",
122	on: {
123	_id: `(
124	SELECT "_id"
125	FROM "Messages"
126	WHERE "conversationId" = ${field("_id")}
127	ORDER BY "createdAt" DESC
128	LIMIT 1
129	)`,
130	},
NEW 131	resolver: (messagesField) => messagesField("*"),	×
132	}),
133	}),
134	hasUnreadMessages: resolverOnlyField({
135	type: Boolean,
136	graphQLtype: "Boolean",
137	canRead: ["members"],
138	resolver: async (
139	conversation: DbConversation,
140	_args,
141	context: ResolverContext,
142	) => {
NEW 143	const {currentUser} = context;	×
NEW 144	if (!currentUser) {	×
NEW 145	return false;	×
146	}
NEW 147	return getWithCustomLoader<boolean, string>(	×
148	context,
149	"hasUnreadMessages",
150	conversation._id,
151	(conversationIds: string[]): Promise<boolean[]> =>
NEW 152	context.repos.conversations.getReadStatuses(currentUser._id, conversationIds),	×
153	);
154	},
NEW 155	sqlResolver: ({field, currentUserField, join}) => join({	×
156	isNonCollectionJoin: true,
157	table: "ConversationUnreadMessages",
158	type: "left",
159	on: {
160	conversationId: field("_id"),
161	userId: currentUserField("_id"),
162	},
163	resolver: (unreadMessagesField) =>
NEW 164	`COALESCE(${unreadMessagesField("hasUnreadMessages")}, FALSE)`,	×
165	}),
166	}),
167	};
168
169	export default schema;	19✔

ForumMagnum / ForumMagnum / 8787152133

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous