10623170100

Committed 29 Aug 2024 09:53PM UTC coverage: 31.918% (+0.003%) from 31.915%

Build # 10623170100

Build Type

Pull #9677

github

Committed by

darkruby501

Commit Message

pr nit

Pull Request Pull Request #9677: character counts on llm conversation viewing page

Run Details

5023 of 41029 branches covered (12.24%)

Branch coverage included in aggregate %.

0 of 4 new or added lines in 1 file covered. (0.0%)

488 existing lines in 21 files now uncovered.

29310 of 66536 relevant lines covered (44.05%)

188.31 hits per line

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

12.7

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

import range from "lodash/range";
import { schemaDefaultValue, resolverOnlyField, accessFilterSingle, accessFilterMultiple } from "../../utils/schemaUtils";
import { graphqlTypeToCollectionName } from "../../vulcan-lib/collections";
import { isLWorAF } from "../../instanceSettings";

const DOCUMENT_TYPES = ['Sequence', 'Post'];

interface ShiftSpotlightItemParams {
  startBound: number;
  endBound: number;
  offset: -1 | 1;
  context: ResolverContext;
}

/**
 * Range is not inclusive of the "end"
 * 
 * ex: Moving item from position 7 to position 3.  We want to shift items in the range of positions [3..6] to [4..7].
 * 
 * So range(3, 7) gives us [3,4,5,6].
 * 
 * `offset: -1` is to push items "backward" (when you're either creating a new spotlight item in the middle of the existing set, or moving one earlier in the order)
 * 
 * `offset: 1` is to pull items "forward" (when you're moving an existing item back)
 */
const shiftSpotlightItems = async ({ startBound, endBound, offset, context }: ShiftSpotlightItemParams) => {
  const shiftRange = range(startBound, endBound);

  // Shift the intermediate spotlights backward or forward (according to `offset`)
  await context.Spotlights.rawUpdateMany({ position: { $in: shiftRange } }, { $inc: { position: offset } }, { multi:true });
};

const schema: SchemaType<"Spotlights"> = {
  documentId: {
    type: String,
    nullable: false,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 10,
    resolveAs: {
      fieldName: 'document',
      addOriginalField: true,
      // TODO: try a graphql union type?
      type: 'Post!',
      resolver: async (spotlight: DbSpotlight, args: void, context: ResolverContext): Promise<Partial<DbPost | DbSequence | DbCollection> | null> => {
        const collectionName = graphqlTypeToCollectionName(spotlight.documentType) as "Posts"|"Sequences";
        const collection = context[collectionName];
        const document = await collection.findOne(spotlight.documentId);
        return accessFilterSingle(context.currentUser, collection, document, context);
      }
    },
  },
  
  /**
   * Type of document that is spotlighted, from the options in DOCUMENT_TYPES.
   * Note subtle distinction: those are type names, not collection names.
   */
  documentType: {
    type: String,
    typescriptType: 'SpotlightDocumentType',
    control: 'select',
    form: {
      options: () => DOCUMENT_TYPES.map(documentType => ({ label: documentType, value: documentType }))
    },
    ...schemaDefaultValue(DOCUMENT_TYPES[0]),
    allowedValues: DOCUMENT_TYPES,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 20,
  },
  position: {
    type: Number,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 30,
    optional: true,
    nullable: false,
    onCreate: async ({ newDocument, context }) => {
      const [currentSpotlight, lastSpotlightByPosition] = await Promise.all([
        context.Spotlights.findOne({}, { sort: { lastPromotedAt: -1 } }),
        context.Spotlights.findOne({}, { sort: { position: -1 } })
      ]);
      
      // If we don't have an active spotlight (or any spotlight), the new one should be first
      if (!currentSpotlight || !lastSpotlightByPosition) {
        return 0;
      }

      // If we didn't specify a position, by default we probably want to be inserting it right after the currently-active spotlight
      // If we're instead putting the created spotlight somewhere before the last spotlight, shift everything at and after the desired position back
      const startBound = typeof newDocument.position !== 'number' ? currentSpotlight.position + 1 : newDocument.position;
      const endBound = lastSpotlightByPosition.position + 1;

      // Don't let us create a new spotlight with an arbitrarily large position
      if (newDocument.position > endBound) {
        return endBound;
      }

      // Push all the spotlight items both at and after the about-to-be-created item's position back by 1
      await shiftSpotlightItems({ startBound, endBound, offset: 1, context });

      // The to-be-created spotlight's position
      return startBound;
    },
    onUpdate: async ({ data, oldDocument, context }) => {
      if (typeof data.position === 'number' && data.position !== oldDocument.position) {
        // Figure out whether we're moving an existing spotlight item to an earlier position or a later position
        const pullingSpotlightForward = data.position < oldDocument.position;

        // Use that to determine which other spotlight items we need to move, and whether we correspondingly push them back or pull them forward
        const startBound = pullingSpotlightForward ? data.position : oldDocument.position + 1;
        const endBound = pullingSpotlightForward ? oldDocument.position : data.position + 1;
        const offset = pullingSpotlightForward ? 1 : -1;

        // Set the to-be-updated spotlight's position to something far out to avoid conflict with the spotlights we'll need to shift back
        await context.Spotlights.rawUpdateOne({ _id: oldDocument._id }, { $set: { position: 9001 } });

        // Shift the intermediate items backward
        await shiftSpotlightItems({ startBound, endBound, offset, context });        

        // The to-be-updated spotlight's position will get updated back to the desired position later in the mutator
        return data.position;
      }
    }
  },
  duration: {
    type: Number,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 40,
    ...schemaDefaultValue(3),
  },
  customTitle: {
    type: String,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 50,
    optional: true,
    nullable: true
  },
  customSubtitle: {
    type: String,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 60,
    optional: true,
    nullable: true
  },
  headerTitle: {
    type: String,
    canRead: ["guests"],
    canUpdate: ["admins", "sunshineRegiment"],
    canCreate: ["admins", "sunshineRegiment"],
    order: 65,
    optional: true,
    nullable: true,
  },
  headerTitleLeftColor: {
    type: String,
    canRead: ["guests"],
    canUpdate: ["admins", "sunshineRegiment"],
    canCreate: ["admins", "sunshineRegiment"],
    order: 66,
    optional: true,
    nullable: true,
  },
  headerTitleRightColor: {
    type: String,
    canRead: ["guests"],
    canUpdate: ["admins", "sunshineRegiment"],
    canCreate: ["admins", "sunshineRegiment"],
    order: 67,
    optional: true,
    nullable: true,
  },
  lastPromotedAt: {
    type: Date,
    control: "datetime",
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 70,
    // Default to the epoch date if not specified
    ...schemaDefaultValue(new Date(0)),
  },
  draft: {
    type: Boolean,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 80,
    ...schemaDefaultValue(true),
  },
  showAuthor: {
    type: Boolean,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 85,
    ...schemaDefaultValue(false),
   optional: true,
   nullable: false,
  },
  imageFade: {
    type: Boolean,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    order: 86,
    optional: true,
    nullable: false,
    // we're not using schemaDefaultValue because we can't use forumType
    // conditionals without breaking schema hash logic
    defaultValue: true,
    onCreate: ({document}) => document.imageFade ?? (isLWorAF ? false : true),
    canAutofillDefault: true,
  },
  imageFadeColor: {
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    type: String,
    order: 87,
    optional: true,
    nullable: true,
    control: "FormComponentColorPicker",
  },
  spotlightImageId: {
    type: String,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    control: "ImageUpload",
    optional: true,
    nullable: true,
    order: 90,
  },
  spotlightDarkImageId: {
    type: String,
    canRead: ['guests'],
    canUpdate: ['admins', 'sunshineRegiment'],
    canCreate: ['admins', 'sunshineRegiment'],
    control: "ImageUpload",
    optional: true,
    nullable: true,
    order: 100,
  },
  
  sequenceChapters: resolverOnlyField({
    type: Array,
    graphQLtype: '[Chapter]',
    canRead: ['guests'],
    resolver: async (spotlight: DbSpotlight, args: void, context: ResolverContext): Promise<Partial<DbChapter>[]|null> => {
      if (!spotlight.documentId || spotlight.documentType !== "Sequence") {
        return null;
      }
      const chapters = await context.Chapters.find({
        sequenceId: spotlight.documentId,
      }, {
        limit: 100,
        sort: {number:1},
      }).fetch();
      
      return await accessFilterMultiple(context.currentUser, context.Chapters, chapters, context);
    }
  }),
  "sequenceChapters.$": {
    type: "Chapter",
    foreignKey: "Chapters",
    optional: true,
  },
};

export default schema;

1	import range from "lodash/range";	76✔
2	import { schemaDefaultValue, resolverOnlyField, accessFilterSingle, accessFilterMultiple } from "../../utils/schemaUtils";	19✔
3	import { graphqlTypeToCollectionName } from "../../vulcan-lib/collections";	19✔
4	import { isLWorAF } from "../../instanceSettings";	19✔
5
6	const DOCUMENT_TYPES = ['Sequence', 'Post'];	19✔
7
8	interface ShiftSpotlightItemParams {
9	startBound: number;
10	endBound: number;
11	offset: -1 \| 1;
12	context: ResolverContext;
13	}
14
15	/**
16	* Range is not inclusive of the "end"
17	*
18	* ex: Moving item from position 7 to position 3. We want to shift items in the range of positions [3..6] to [4..7].
19	*
20	* So range(3, 7) gives us [3,4,5,6].
21	*
22	* `offset: -1` is to push items "backward" (when you're either creating a new spotlight item in the middle of the existing set, or moving one earlier in the order)
23	*
24	* `offset: 1` is to pull items "forward" (when you're moving an existing item back)
25	*/
26	const shiftSpotlightItems = async ({ startBound, endBound, offset, context }: ShiftSpotlightItemParams) => {	19✔
27	const shiftRange = range(startBound, endBound);	×
28
29	// Shift the intermediate spotlights backward or forward (according to `offset`)
30	await context.Spotlights.rawUpdateMany({ position: { $in: shiftRange } }, { $inc: { position: offset } }, { multi:true });	×
31	};
32
33	const schema: SchemaType<"Spotlights"> = {	19✔
34	documentId: {
35	type: String,
36	nullable: false,
37	canRead: ['guests'],
38	canUpdate: ['admins', 'sunshineRegiment'],
39	canCreate: ['admins', 'sunshineRegiment'],
40	order: 10,
41	resolveAs: {
42	fieldName: 'document',
43	addOriginalField: true,
44	// TODO: try a graphql union type?
45	type: 'Post!',
46	resolver: async (spotlight: DbSpotlight, args: void, context: ResolverContext): Promise<Partial<DbPost \| DbSequence \| DbCollection> \| null> => {
47	const collectionName = graphqlTypeToCollectionName(spotlight.documentType) as "Posts"\|"Sequences";	×
48	const collection = context[collectionName];	×
49	const document = await collection.findOne(spotlight.documentId);	×
50	return accessFilterSingle(context.currentUser, collection, document, context);	×
51	}
52	},
53	},
54
55	/**
56	* Type of document that is spotlighted, from the options in DOCUMENT_TYPES.
57	* Note subtle distinction: those are type names, not collection names.
58	*/
59	documentType: {
60	type: String,
61	typescriptType: 'SpotlightDocumentType',
62	control: 'select',
63	form: {
64	options: () => DOCUMENT_TYPES.map(documentType => ({ label: documentType, value: documentType }))	×
65	},
66	...schemaDefaultValue(DOCUMENT_TYPES[0]),
67	allowedValues: DOCUMENT_TYPES,
68	canRead: ['guests'],
69	canUpdate: ['admins', 'sunshineRegiment'],
70	canCreate: ['admins', 'sunshineRegiment'],
71	order: 20,
72	},
73	position: {
74	type: Number,
75	canRead: ['guests'],
76	canUpdate: ['admins', 'sunshineRegiment'],
77	canCreate: ['admins', 'sunshineRegiment'],
78	order: 30,
79	optional: true,
80	nullable: false,
81	onCreate: async ({ newDocument, context }) => {
82	const [currentSpotlight, lastSpotlightByPosition] = await Promise.all([	×
83	context.Spotlights.findOne({}, { sort: { lastPromotedAt: -1 } }),
84	context.Spotlights.findOne({}, { sort: { position: -1 } })
85	]);
86
87	// If we don't have an active spotlight (or any spotlight), the new one should be first
88	if (!currentSpotlight \|\| !lastSpotlightByPosition) {	×
89	return 0;	×
90	}
91
92	// If we didn't specify a position, by default we probably want to be inserting it right after the currently-active spotlight
93	// If we're instead putting the created spotlight somewhere before the last spotlight, shift everything at and after the desired position back
94	const startBound = typeof newDocument.position !== 'number' ? currentSpotlight.position + 1 : newDocument.position;	×
95	const endBound = lastSpotlightByPosition.position + 1;	×
96
97	// Don't let us create a new spotlight with an arbitrarily large position
98	if (newDocument.position > endBound) {	×
99	return endBound;	×
100	}
101
102	// Push all the spotlight items both at and after the about-to-be-created item's position back by 1
103	await shiftSpotlightItems({ startBound, endBound, offset: 1, context });	×
104
105	// The to-be-created spotlight's position
106	return startBound;	×
107	},
108	onUpdate: async ({ data, oldDocument, context }) => {
109	if (typeof data.position === 'number' && data.position !== oldDocument.position) {	×
110	// Figure out whether we're moving an existing spotlight item to an earlier position or a later position
111	const pullingSpotlightForward = data.position < oldDocument.position;	×
112
113	// Use that to determine which other spotlight items we need to move, and whether we correspondingly push them back or pull them forward
114	const startBound = pullingSpotlightForward ? data.position : oldDocument.position + 1;	×
115	const endBound = pullingSpotlightForward ? oldDocument.position : data.position + 1;	×
116	const offset = pullingSpotlightForward ? 1 : -1;	×
117
118	// Set the to-be-updated spotlight's position to something far out to avoid conflict with the spotlights we'll need to shift back
119	await context.Spotlights.rawUpdateOne({ _id: oldDocument._id }, { $set: { position: 9001 } });	×
120
121	// Shift the intermediate items backward
122	await shiftSpotlightItems({ startBound, endBound, offset, context });	×
123
124	// The to-be-updated spotlight's position will get updated back to the desired position later in the mutator
125	return data.position;	×
126	}
127	}
128	},
129	duration: {
130	type: Number,
131	canRead: ['guests'],
132	canUpdate: ['admins', 'sunshineRegiment'],
133	canCreate: ['admins', 'sunshineRegiment'],
134	order: 40,
135	...schemaDefaultValue(3),
136	},
137	customTitle: {
138	type: String,
139	canRead: ['guests'],
140	canUpdate: ['admins', 'sunshineRegiment'],
141	canCreate: ['admins', 'sunshineRegiment'],
142	order: 50,
143	optional: true,
144	nullable: true
145	},
146	customSubtitle: {
147	type: String,
148	canRead: ['guests'],
149	canUpdate: ['admins', 'sunshineRegiment'],
150	canCreate: ['admins', 'sunshineRegiment'],
151	order: 60,
152	optional: true,
153	nullable: true
154	},
155	headerTitle: {
156	type: String,
157	canRead: ["guests"],
158	canUpdate: ["admins", "sunshineRegiment"],
159	canCreate: ["admins", "sunshineRegiment"],
160	order: 65,
161	optional: true,
162	nullable: true,
163	},
164	headerTitleLeftColor: {
165	type: String,
166	canRead: ["guests"],
167	canUpdate: ["admins", "sunshineRegiment"],
168	canCreate: ["admins", "sunshineRegiment"],
169	order: 66,
170	optional: true,
171	nullable: true,
172	},
173	headerTitleRightColor: {
174	type: String,
175	canRead: ["guests"],
176	canUpdate: ["admins", "sunshineRegiment"],
177	canCreate: ["admins", "sunshineRegiment"],
178	order: 67,
179	optional: true,
180	nullable: true,
181	},
182	lastPromotedAt: {
183	type: Date,
184	control: "datetime",
185	canRead: ['guests'],
186	canUpdate: ['admins', 'sunshineRegiment'],
187	canCreate: ['admins', 'sunshineRegiment'],
188	order: 70,
189	// Default to the epoch date if not specified
190	...schemaDefaultValue(new Date(0)),
191	},
192	draft: {
193	type: Boolean,
194	canRead: ['guests'],
195	canUpdate: ['admins', 'sunshineRegiment'],
196	canCreate: ['admins', 'sunshineRegiment'],
197	order: 80,
198	...schemaDefaultValue(true),
199	},
200	showAuthor: {
201	type: Boolean,
202	canRead: ['guests'],
203	canUpdate: ['admins', 'sunshineRegiment'],
204	canCreate: ['admins', 'sunshineRegiment'],
205	order: 85,
206	...schemaDefaultValue(false),
207	optional: true,
208	nullable: false,
209	},
210	imageFade: {
211	type: Boolean,
212	canRead: ['guests'],
213	canUpdate: ['admins', 'sunshineRegiment'],
214	canCreate: ['admins', 'sunshineRegiment'],
215	order: 86,
216	optional: true,
217	nullable: false,
218	// we're not using schemaDefaultValue because we can't use forumType
219	// conditionals without breaking schema hash logic
220	defaultValue: true,
UNCOV 221	onCreate: ({document}) => document.imageFade ?? (isLWorAF ? false : true),	×
222	canAutofillDefault: true,
223	},
224	imageFadeColor: {
225	canRead: ['guests'],
226	canUpdate: ['admins', 'sunshineRegiment'],
227	canCreate: ['admins', 'sunshineRegiment'],
228	type: String,
229	order: 87,
230	optional: true,
231	nullable: true,
232	control: "FormComponentColorPicker",
233	},
234	spotlightImageId: {
235	type: String,
236	canRead: ['guests'],
237	canUpdate: ['admins', 'sunshineRegiment'],
238	canCreate: ['admins', 'sunshineRegiment'],
239	control: "ImageUpload",
240	optional: true,
241	nullable: true,
242	order: 90,
243	},
244	spotlightDarkImageId: {
245	type: String,
246	canRead: ['guests'],
247	canUpdate: ['admins', 'sunshineRegiment'],
248	canCreate: ['admins', 'sunshineRegiment'],
249	control: "ImageUpload",
250	optional: true,
251	nullable: true,
252	order: 100,
253	},
254
255	sequenceChapters: resolverOnlyField({
256	type: Array,
257	graphQLtype: '[Chapter]',
258	canRead: ['guests'],
259	resolver: async (spotlight: DbSpotlight, args: void, context: ResolverContext): Promise<Partial<DbChapter>[]\|null> => {
UNCOV 260	if (!spotlight.documentId \|\| spotlight.documentType !== "Sequence") {	×
UNCOV 261	return null;	×
262	}
UNCOV 263	const chapters = await context.Chapters.find({	×
264	sequenceId: spotlight.documentId,
265	}, {
266	limit: 100,
267	sort: {number:1},
268	}).fetch();
269
UNCOV 270	return await accessFilterMultiple(context.currentUser, context.Chapters, chapters, context);	×
271	}
272	}),
273	"sequenceChapters.$": {
274	type: "Chapter",
275	foreignKey: "Chapters",
276	optional: true,
277	},
278	};
279
280	export default schema;	19✔

ForumMagnum / ForumMagnum / 10623170100

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