8758717919

Committed 19 Apr 2024 07:35PM UTC coverage: 32.051% (-0.003%) from 32.054%

Build # 8758717919

Build Type

push

github

Committed by

b0b3rt

Commit Message

some cleanup

Run Details

4681 of 38018 branches covered (12.31%)

Branch coverage included in aggregate %.

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

2 existing lines in 2 files now uncovered.

27184 of 61402 relevant lines covered (44.27%)

182.01 hits per line

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

32.72

/packages/lesswrong/server/scripts/convertImagesToCloudinary.ts

import { Globals } from '../../lib/vulcan-lib/config';
import { Revisions } from '../../lib/collections/revisions/collection';
import { Images } from '../../lib/collections/images/collection';
import { DatabaseServerSetting } from '../databaseSettings';
import { ckEditorUploadUrlSetting, cloudinaryCloudNameSetting } from '../../lib/publicSettings';
import { randomId } from '../../lib/random';
import cloudinary from 'cloudinary';
import cheerio from 'cheerio';
import { cheerioParse } from '../utils/htmlUtil';
import { URL } from 'url';
import { ckEditorUploadUrlOverrideSetting } from '../../lib/instanceSettings';
import { getCollection } from '../../lib/vulcan-lib/getCollection';
import uniq from 'lodash/uniq';
import { loggerConstructor } from '../../lib/utils/logging';
import { Posts } from '../../lib/collections/posts';
import { getAtPath, setAtPath } from '../../lib/helpers';
import { getLatestRev, getNextVersion, htmlToChangeMetrics } from '../editor/utils';

const cloudinaryApiKey = new DatabaseServerSetting<string>("cloudinaryApiKey", "");
const cloudinaryApiSecret = new DatabaseServerSetting<string>("cloudinaryApiSecret", "");

// Given a URL which (probably) points to an image, download that image,
// re-upload it to cloudinary, and return a cloudinary URL for that image. If
// the URL is already Cloudinary or can't be downloaded, returns null instead.
export async function moveImageToCloudinary(oldUrl: string, originDocumentId: string): Promise<string|null> {
  const logger = loggerConstructor("image-conversion")
  const alreadyRehosted = await findAlreadyMovedImage(oldUrl);
  if (alreadyRehosted) return alreadyRehosted;
  
  const cloudName = cloudinaryCloudNameSetting.get();
  const apiKey = cloudinaryApiKey.get();
  const apiSecret = cloudinaryApiSecret.get();
  
  if (!cloudName || !apiKey || !apiSecret) {
    // eslint-disable-next-line no-console
    console.error("Cannot upload image to Cloudinary: not configured");
    return null;
  }
  
  const result = await cloudinary.v2.uploader.upload(
    oldUrl,
    {
      folder: `mirroredImages/${originDocumentId}`,
      cloud_name: cloudName,
      api_key: apiKey,
      api_secret: apiSecret,
    }
  );
  logger(`Result of moving image: ${result.secure_url}`);

  // Serve all images with automatic quality and format transformations to save on bandwidth
  const autoQualityFormatUrl = cloudinary.v2.url(result.public_id, {
    cloud_name: cloudName,
    api_key: apiKey,
    api_secret: apiSecret,
    quality: 'auto',
    fetch_format: 'auto',
    secure: true
  });
  
  await Images.rawInsert({
    originalUrl: oldUrl,
    cdnHostedUrl: autoQualityFormatUrl,
  });
  
  return autoQualityFormatUrl;
}

/// If an image has already been re-hosted, return its CDN URL. Otherwise null.
async function findAlreadyMovedImage(url: string): Promise<string|null> {
  const image = await Images.findOne({originalUrl: url});
  return image?.cdnHostedUrl ?? null;
}

/**
 * Images on domains not in this list will be mirrored on Cloudinary and have
 * their src updated.
 */
function getImageUrlWhitelist() {
  const localUploadUrl = ckEditorUploadUrlOverrideSetting.get() || ckEditorUploadUrlSetting.get()
  return [
    "cloudinary.com",
    "res.cloudinary.com",
    "www.lesswrong.com",
    "www.alignmentforum.org",
  ].concat(localUploadUrl ? [new URL(localUploadUrl).host] : []);
}

function urlNeedsMirroring(url: string, filterFn: (url: string) => boolean) {
  try {
    const parsedUrl = new URL(url);
    if (getImageUrlWhitelist().indexOf(parsedUrl.hostname) !== -1) {
      return false;
    }
    return filterFn(url);
  } catch (e) {
    return false;
  }
}

export async function convertImagesInHTML(html: string, originDocumentId: string, urlFilterFn: (url: string) => boolean = () => true): Promise<{count: number, html: string}> {
  const parsedHtml = cheerioParse(html);
  const imgTags = parsedHtml("img").toArray();
  const imgUrls: string[] = [];
  
  for (let imgTag of imgTags) {
    const urls = getImageUrlsFromImgTag(cheerio(imgTag));
    for (let url of urls) {
      if (urlNeedsMirroring(url, urlFilterFn)) {
        imgUrls.push(url);
      }
    }
  }

  // Upload all the images to Cloudinary (slow)
  const mirrorUrls: Record<string,string> = {};
  await Promise.all(imgUrls.map(async (url) => {
    // resolve to the url of the image on cloudinary
    const movedImage = await moveImageToCloudinary(url, originDocumentId)
    if (movedImage) {
      mirrorUrls[url] = movedImage;
    }
  }));

  // cheerio is not guarantueed to return the same html so explicitly count
  // the number of images that were converted
  let count = 0
  
  for (let i=0; i<imgTags.length; i++) {
    const imgTag = cheerio(imgTags[i]);
    const src: string|undefined = imgTag.attr("src");
    if (src) {
      const replacement = mirrorUrls[src];
      if (replacement) {
        imgTag.attr("src", replacement);
        count++;
      }
    }
    
    const srcset: string|undefined = imgTag.attr("srcset");
    if (srcset) {
      const replacement = rewriteSrcset(srcset, mirrorUrls);
      if (replacement) {
        imgTag.attr("srcset", replacement);
        count++;
      }
    }
  }
  
  return {count, html: parsedHtml.html()};
}

function getImageUrlsFromImgTag(tag: any): string[] {
  let imageUrls: string[] = [];
  const src: string = tag.attr("src");
  if (src) {
    imageUrls.push(src);
  }
  const srcset: string = tag.attr("srcset");
  if (srcset) {
    const imageVariants = srcset.split(/,\s/g).map(tok=>tok.trim());
    for (let imageVariant of imageVariants) {
      const [url, _size] = imageVariant.split(" ").map(tok=>tok.trim());
      if (url) imageUrls.push(url);
    }
  }
  
  return uniq(imageUrls);
}

function rewriteSrcset(srcset: string, urlMap: Record<string,string>): string {
  const imageVariants = srcset.split(/,\s/g).map(tok=>tok.trim());
  const rewrittenImageVariants = imageVariants.map(variant => {
    let tokens = variant.split(" ");
    if (tokens[0] in urlMap)
      tokens[0] = urlMap[tokens[0]];
    return tokens.join(" ");
  });
  return rewrittenImageVariants.join(", ");
}

/**
 * Reupload all images in an object (post, tag, user, etc) to Cloudinary, for a
 * specific editable field. Creates a new revision with the updated HTML.
 *
 * @param collectionName - The collection that this object is in
 * @param _id - The object to reupload images for
 * @param fieldName - The content-editable field tos can for images
 * @param urlFilterFn - A function that takes a URL and returns true if it should be mirrored, by default all URLs are mirrored except those in getImageUrlWhitelist()
 * @returns The number of images that were mirrored
 */
export async function convertImagesInObject<N extends CollectionNameString>(
  collectionName: N,
  _id: string,
  fieldName = "contents",
  urlFilterFn: (url: string) => boolean = ()=>true
): Promise<number> {
  const logger = loggerConstructor("image-conversion")
  let totalUploaded = 0;
  try {
    const collection = getCollection(collectionName);
    const obj = await collection.findOne({_id});

    if (!obj) {
      // eslint-disable-next-line no-console
      console.error(`Cannot convert images in ${collectionName}.${_id}: ID not found`);
      return 0;
    }
    
    const latestRev = await getLatestRev(_id, fieldName);
    if (!latestRev) {
      // If this field doesn't have a latest rev, it's empty (common eg for
      // moderation guidelines).
      return 0;
    }
    
    const newVersion = getNextVersion(latestRev, "patch", false);
    const now = new Date();
    // NOTE: we use the post contents rather than the revision contents because we don't
    // create a revision for no-op edits (this is arguably a bug)
    //
    // We also manually downcast the document because it's otherwise a union type of all possible DbObjects, and we can't use a random string as an index accessor
    // This is because `collection` is itself a union of all possible collections
    // I tried to make a mutual constraint between `fieldName` and `collectionName` but it was a bit too finnicky to be worth it; this is mostly being (unsafely) called from Globals anyways
    const oldHtml = (obj as AnyBecauseHard)?.[fieldName]?.html;
    if (!oldHtml) {
      return 0;
    }
    const {count: uploadCount, html: newHtml} = await convertImagesInHTML(oldHtml, _id, urlFilterFn);
    if (!uploadCount) {
      logger("No images to convert.");
      return 0;
    } else {
      logger(`Converted ${uploadCount} images`)
    }
    
    const newRevision = {
      ...latestRev,
      _id: randomId(),
      html: newHtml,
      editedAt: now,
      updateType: "patch",
      version: newVersion,
      commitMessage: "Move images to CDN",
      changeMetrics: htmlToChangeMetrics(oldHtml, newHtml),
    };
    const insertedRevisionId: string = await Revisions.rawInsert(newRevision);
    await collection.rawUpdateOne({_id}, {
      $set: {
        [`${fieldName}_latest`]: insertedRevisionId,
        [fieldName]: {
          ...(obj as AnyBecauseHard)[fieldName],
          html: newHtml,
          version: newVersion,
          editedAt: now,
          updateType: "patch",
        },
      }
    });
    totalUploaded += uploadCount;
    return totalUploaded;
  } catch (e) {
    // Always catch the error because the obj should mostly load fine without rehosting the images
    // eslint-disable-next-line no-console
    console.error("Error in convertImagesInObject", e)
    return 0
  }
}

const postMetaImageFields: string[][] = [
  ["socialPreview", "imageId"],
  ["eventImageId"],
  ["socialPreviewImageAutoUrl"],
  ["socialPreviewImageId"],
];

export const rehostPostMetaImages = async (post: DbPost) => {
  const operations: MongoBulkWriteOperations<DbPost> = [];

  for (const field of postMetaImageFields) {
    const currentUrl = getAtPath<DbPost, string>(post, field);
    if (!currentUrl || !urlNeedsMirroring(currentUrl, () => true)) {
      continue;
    }

    let newUrl: string | null = null;
    try {
      newUrl = await moveImageToCloudinary(currentUrl, post._id);
    } catch (e) {
      // eslint-disable-next-line
      console.error(`Failed to move image for ${post._id}:`, field, `(error ${e})`);
      continue;
    }
    if (!newUrl) {
      // eslint-disable-next-line
      console.error(`Failed to move image for ${post._id}:`, field);
      continue;
    }

    setAtPath(post, field, newUrl);

    operations.push({
      updateOne: {
        filter: {
          _id: post._id,
        },
        update: {
          $set: {
            [field.join(".")]: newUrl,
          },
        },
      },
    });
  }

  await Posts.rawCollection().bulkWrite(operations);
}

export const rehostPostMetaImagesById = async (postId: string) => {
  const post = await Posts.findOne({_id: postId});
  if (!post) {
    throw new Error("Post not found");
  }
  await rehostPostMetaImages(post);
}

export const rehostAllPostMetaImages = async () => {
  const projection: Partial<Record<keyof DbPost, 1>> = {_id: 1};
  for (const field of postMetaImageFields) {
    projection[field[0] as keyof DbPost] = 1;
  }
  const posts = await Posts.find({
    $or: postMetaImageFields.map((field) => ({[field[0]]: {$exists: true}})),
  }, {projection}).fetch();
  for (const post of posts) {
    await rehostPostMetaImages(post);
  }
}

Globals.moveImageToCloudinary = moveImageToCloudinary;
Globals.convertImagesInHTML = convertImagesInHTML;
Globals.convertImagesInObject = convertImagesInObject;
Globals.rehostPostMetaImages = rehostPostMetaImages;
Globals.rehostPostMetaImagesById = rehostPostMetaImagesById;
Globals.rehostAllPostMetaImages = rehostAllPostMetaImages;

1	import { Globals } from '../../lib/vulcan-lib/config';	57✔
2	import { Revisions } from '../../lib/collections/revisions/collection';	19✔
3	import { Images } from '../../lib/collections/images/collection';	19✔
4	import { DatabaseServerSetting } from '../databaseSettings';	19✔
5	import { ckEditorUploadUrlSetting, cloudinaryCloudNameSetting } from '../../lib/publicSettings';	19✔
6	import { randomId } from '../../lib/random';	19✔
7	import cloudinary from 'cloudinary';	19✔
8	import cheerio from 'cheerio';	19✔
9	import { cheerioParse } from '../utils/htmlUtil';	19✔
10	import { URL } from 'url';	19✔
11	import { ckEditorUploadUrlOverrideSetting } from '../../lib/instanceSettings';	19✔
12	import { getCollection } from '../../lib/vulcan-lib/getCollection';	19✔
13	import uniq from 'lodash/uniq';	19✔
14	import { loggerConstructor } from '../../lib/utils/logging';	19✔
15	import { Posts } from '../../lib/collections/posts';	19✔
16	import { getAtPath, setAtPath } from '../../lib/helpers';	19✔
17	import { getLatestRev, getNextVersion, htmlToChangeMetrics } from '../editor/utils';	19✔
18
19	const cloudinaryApiKey = new DatabaseServerSetting<string>("cloudinaryApiKey", "");	19✔
20	const cloudinaryApiSecret = new DatabaseServerSetting<string>("cloudinaryApiSecret", "");	19✔
21
22	// Given a URL which (probably) points to an image, download that image,
23	// re-upload it to cloudinary, and return a cloudinary URL for that image. If
24	// the URL is already Cloudinary or can't be downloaded, returns null instead.
25	export async function moveImageToCloudinary(oldUrl: string, originDocumentId: string): Promise<string\|null> {
26	const logger = loggerConstructor("image-conversion")	×
27	const alreadyRehosted = await findAlreadyMovedImage(oldUrl);	×
28	if (alreadyRehosted) return alreadyRehosted;	×
29
30	const cloudName = cloudinaryCloudNameSetting.get();	×
31	const apiKey = cloudinaryApiKey.get();	×
32	const apiSecret = cloudinaryApiSecret.get();	×
33
34	if (!cloudName \|\| !apiKey \|\| !apiSecret) {	×
35	// eslint-disable-next-line no-console
36	console.error("Cannot upload image to Cloudinary: not configured");	×
37	return null;	×
38	}
39
40	const result = await cloudinary.v2.uploader.upload(	×
41	oldUrl,
42	{
43	folder: `mirroredImages/${originDocumentId}`,
44	cloud_name: cloudName,
45	api_key: apiKey,
46	api_secret: apiSecret,
47	}
48	);
49	logger(`Result of moving image: ${result.secure_url}`);	×
50
51	// Serve all images with automatic quality and format transformations to save on bandwidth
52	const autoQualityFormatUrl = cloudinary.v2.url(result.public_id, {	×
53	cloud_name: cloudName,
54	api_key: apiKey,
55	api_secret: apiSecret,
56	quality: 'auto',
57	fetch_format: 'auto',
58	secure: true
59	});
60
61	await Images.rawInsert({	×
62	originalUrl: oldUrl,
63	cdnHostedUrl: autoQualityFormatUrl,
64	});
65
66	return autoQualityFormatUrl;	×
67	}
68
69	/// If an image has already been re-hosted, return its CDN URL. Otherwise null.
70	async function findAlreadyMovedImage(url: string): Promise<string\|null> {
71	const image = await Images.findOne({originalUrl: url});	×
72	return image?.cdnHostedUrl ?? null;	×
73	}
74
75	/**
76	* Images on domains not in this list will be mirrored on Cloudinary and have
77	* their src updated.
78	*/
79	function getImageUrlWhitelist() {
80	const localUploadUrl = ckEditorUploadUrlOverrideSetting.get() \|\| ckEditorUploadUrlSetting.get()	×
81	return [	×
82	"cloudinary.com",
83	"res.cloudinary.com",
84	"www.lesswrong.com",
85	"www.alignmentforum.org",
86	].concat(localUploadUrl ? [new URL(localUploadUrl).host] : []);	×
87	}
88
89	function urlNeedsMirroring(url: string, filterFn: (url: string) => boolean) {
90	try {	×
91	const parsedUrl = new URL(url);	×
92	if (getImageUrlWhitelist().indexOf(parsedUrl.hostname) !== -1) {	×
93	return false;	×
94	}
95	return filterFn(url);	×
96	} catch (e) {
97	return false;	×
98	}
99	}
100
101	export async function convertImagesInHTML(html: string, originDocumentId: string, urlFilterFn: (url: string) => boolean = () => true): Promise<{count: number, html: string}> {	×
102	const parsedHtml = cheerioParse(html);	38✔
103	const imgTags = parsedHtml("img").toArray();	38✔
104	const imgUrls: string[] = [];	38✔
105
106	for (let imgTag of imgTags) {	38✔
107	const urls = getImageUrlsFromImgTag(cheerio(imgTag));	×
108	for (let url of urls) {	×
109	if (urlNeedsMirroring(url, urlFilterFn)) {	×
110	imgUrls.push(url);	×
111	}
112	}
113	}
114
115	// Upload all the images to Cloudinary (slow)
116	const mirrorUrls: Record<string,string> = {};	38✔
117	await Promise.all(imgUrls.map(async (url) => {	38✔
118	// resolve to the url of the image on cloudinary
119	const movedImage = await moveImageToCloudinary(url, originDocumentId)	×
120	if (movedImage) {	×
121	mirrorUrls[url] = movedImage;	×
122	}
123	}));
124
125	// cheerio is not guarantueed to return the same html so explicitly count
126	// the number of images that were converted
127	let count = 0	38✔
128
129	for (let i=0; i<imgTags.length; i++) {	38✔
130	const imgTag = cheerio(imgTags[i]);	×
131	const src: string\|undefined = imgTag.attr("src");	×
132	if (src) {	×
133	const replacement = mirrorUrls[src];	×
134	if (replacement) {	×
135	imgTag.attr("src", replacement);	×
136	count++;	×
137	}
138	}
139
140	const srcset: string\|undefined = imgTag.attr("srcset");	×
141	if (srcset) {	×
142	const replacement = rewriteSrcset(srcset, mirrorUrls);	×
143	if (replacement) {	×
144	imgTag.attr("srcset", replacement);	×
145	count++;	×
146	}
147	}
148	}
149
150	return {count, html: parsedHtml.html()};	38✔
151	}
152
153	function getImageUrlsFromImgTag(tag: any): string[] {
154	let imageUrls: string[] = [];	×
155	const src: string = tag.attr("src");	×
156	if (src) {	×
157	imageUrls.push(src);	×
158	}
159	const srcset: string = tag.attr("srcset");	×
160	if (srcset) {	×
161	const imageVariants = srcset.split(/,\s/g).map(tok=>tok.trim());	×
162	for (let imageVariant of imageVariants) {	×
163	const [url, _size] = imageVariant.split(" ").map(tok=>tok.trim());	×
164	if (url) imageUrls.push(url);	×
165	}
166	}
167
168	return uniq(imageUrls);	×
169	}
170
171	function rewriteSrcset(srcset: string, urlMap: Record<string,string>): string {
172	const imageVariants = srcset.split(/,\s/g).map(tok=>tok.trim());	×
173	const rewrittenImageVariants = imageVariants.map(variant => {	×
174	let tokens = variant.split(" ");	×
175	if (tokens[0] in urlMap)	×
176	tokens[0] = urlMap[tokens[0]];	×
177	return tokens.join(" ");	×
178	});
179	return rewrittenImageVariants.join(", ");	×
180	}
181
182	/**
183	* Reupload all images in an object (post, tag, user, etc) to Cloudinary, for a
184	* specific editable field. Creates a new revision with the updated HTML.
185	*
186	* @param collectionName - The collection that this object is in
187	* @param _id - The object to reupload images for
188	* @param fieldName - The content-editable field tos can for images
189	* @param urlFilterFn - A function that takes a URL and returns true if it should be mirrored, by default all URLs are mirrored except those in getImageUrlWhitelist()
190	* @returns The number of images that were mirrored
191	*/
192	export async function convertImagesInObject<N extends CollectionNameString>(
193	collectionName: N,
194	_id: string,
195	fieldName = "contents",	×
196	urlFilterFn: (url: string) => boolean = ()=>true	✔
197	): Promise<number> {
198	const logger = loggerConstructor("image-conversion")	1,076✔
199	let totalUploaded = 0;	1,076✔
200	try {	1,076✔
201	const collection = getCollection(collectionName);	1,076✔
202	const obj = await collection.findOne({_id});	1,076✔
203
204	if (!obj) {	1,076!
205	// eslint-disable-next-line no-console
206	console.error(`Cannot convert images in ${collectionName}.${_id}: ID not found`);	×
207	return 0;	×
208	}
209
210	const latestRev = await getLatestRev(_id, fieldName);	1,076✔
211	if (!latestRev) {	1,076✔
212	// If this field doesn't have a latest rev, it's empty (common eg for
213	// moderation guidelines).
214	return 0;	1,038✔
215	}
216
217	const newVersion = getNextVersion(latestRev, "patch", false);	38✔
218	const now = new Date();	38✔
219	// NOTE: we use the post contents rather than the revision contents because we don't
220	// create a revision for no-op edits (this is arguably a bug)
221	//
222	// We also manually downcast the document because it's otherwise a union type of all possible DbObjects, and we can't use a random string as an index accessor
223	// This is because `collection` is itself a union of all possible collections
224	// I tried to make a mutual constraint between `fieldName` and `collectionName` but it was a bit too finnicky to be worth it; this is mostly being (unsafely) called from Globals anyways
225	const oldHtml = (obj as AnyBecauseHard)?.[fieldName]?.html;	38!
226	if (!oldHtml) {	38!
UNCOV 227	return 0;	×
228	}
229	const {count: uploadCount, html: newHtml} = await convertImagesInHTML(oldHtml, _id, urlFilterFn);	38✔
230	if (!uploadCount) {	38!
231	logger("No images to convert.");	38✔
232	return 0;	38✔
233	} else {
234	logger(`Converted ${uploadCount} images`)	×
235	}
236
237	const newRevision = {	×
238	...latestRev,
239	_id: randomId(),
240	html: newHtml,
241	editedAt: now,
242	updateType: "patch",
243	version: newVersion,
244	commitMessage: "Move images to CDN",
245	changeMetrics: htmlToChangeMetrics(oldHtml, newHtml),
246	};
247	const insertedRevisionId: string = await Revisions.rawInsert(newRevision);	×
248	await collection.rawUpdateOne({_id}, {	×
249	$set: {
250	[`${fieldName}_latest`]: insertedRevisionId,
251	[fieldName]: {
252	...(obj as AnyBecauseHard)[fieldName],
253	html: newHtml,
254	version: newVersion,
255	editedAt: now,
256	updateType: "patch",
257	},
258	}
259	});
260	totalUploaded += uploadCount;	×
261	return totalUploaded;	×
262	} catch (e) {
263	// Always catch the error because the obj should mostly load fine without rehosting the images
264	// eslint-disable-next-line no-console
265	console.error("Error in convertImagesInObject", e)	×
266	return 0	×
267	}
268	}
269
270	const postMetaImageFields: string[][] = [	19✔
271	["socialPreview", "imageId"],
272	["eventImageId"],
273	["socialPreviewImageAutoUrl"],
274	["socialPreviewImageId"],
275	];
276
277	export const rehostPostMetaImages = async (post: DbPost) => {	19✔
278	const operations: MongoBulkWriteOperations<DbPost> = [];	294✔
279
280	for (const field of postMetaImageFields) {	294✔
281	const currentUrl = getAtPath<DbPost, string>(post, field);	1,176✔
282	if (!currentUrl \|\| !urlNeedsMirroring(currentUrl, () => true)) {	1,176!
283	continue;	1,176✔
284	}
285
286	let newUrl: string \| null = null;	×
287	try {	×
288	newUrl = await moveImageToCloudinary(currentUrl, post._id);	×
289	} catch (e) {
290	// eslint-disable-next-line
291	console.error(`Failed to move image for ${post._id}:`, field, `(error ${e})`);	×
292	continue;	×
293	}
294	if (!newUrl) {	×
295	// eslint-disable-next-line
296	console.error(`Failed to move image for ${post._id}:`, field);	×
297	continue;	×
298	}
299
300	setAtPath(post, field, newUrl);	×
301
302	operations.push({	×
303	updateOne: {
304	filter: {
305	_id: post._id,
306	},
307	update: {
308	$set: {
309	[field.join(".")]: newUrl,
310	},
311	},
312	},
313	});
314	}
315
316	await Posts.rawCollection().bulkWrite(operations);	294✔
317	}
318
319	export const rehostPostMetaImagesById = async (postId: string) => {	19✔
320	const post = await Posts.findOne({_id: postId});	×
321	if (!post) {	×
322	throw new Error("Post not found");	×
323	}
324	await rehostPostMetaImages(post);	×
325	}
326
327	export const rehostAllPostMetaImages = async () => {	19✔
328	const projection: Partial<Record<keyof DbPost, 1>> = {_id: 1};	×
329	for (const field of postMetaImageFields) {	×
330	projection[field[0] as keyof DbPost] = 1;	×
331	}
332	const posts = await Posts.find({	×
333	$or: postMetaImageFields.map((field) => ({[field[0]]: {$exists: true}})),	×
334	}, {projection}).fetch();
335	for (const post of posts) {	×
336	await rehostPostMetaImages(post);	×
337	}
338	}
339
340	Globals.moveImageToCloudinary = moveImageToCloudinary;	19✔
341	Globals.convertImagesInHTML = convertImagesInHTML;	19✔
342	Globals.convertImagesInObject = convertImagesInObject;	19✔
343	Globals.rehostPostMetaImages = rehostPostMetaImages;	19✔
344	Globals.rehostPostMetaImagesById = rehostPostMetaImagesById;	19✔
345	Globals.rehostAllPostMetaImages = rehostAllPostMetaImages;	19✔

ForumMagnum / ForumMagnum / 8758717919

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