ghost/webmentions/lib/Mention.js
const ObjectID = require('bson-objectid').default;
const {ValidationError} = require('@tryghost/errors');
const MentionCreatedEvent = require('./MentionCreatedEvent');
const cheerio = require('cheerio');
module.exports = class Mention {
/** @type {Array} */
events = [];
/** @type {ObjectID} */
#id;
get id() {
return this.#id;
}
/** @type {boolean} */
#verified = false;
get verified() {
return this.#verified;
}
/** @type {boolean} */
#deleted = false;
get deleted() {
return this.#deleted;
}
delete() {
this.#deleted = true;
}
#undelete() {
// When an earlier mention is deleted, but then it gets verified again, we need to undelete it
if (this.#deleted) {
this.#deleted = false;
this.events.push(MentionCreatedEvent.create({mention: this}));
}
}
/**
* @param {string} html
* @param {string} contentType
*/
verify(html, contentType) {
const wasVerified = this.#verified;
if (contentType.includes('text/html')) {
try {
const $ = cheerio.load(html);
const hasTargetUrl = $('a[href*="' + this.target.href + '"], img[src*="' + this.target.href + '"], video[src*="' + this.target.href + '"]').length > 0;
this.#verified = hasTargetUrl;
if (wasVerified && !this.#verified) {
// Delete the mention, but keep it verified (it was just deleted, because it was verified earlier, so now it is removed from the site according to the spec)
this.#deleted = true;
this.#verified = true;
} else {
this.#undelete();
}
} catch (e) {
this.#verified = false;
}
}
if (contentType.includes('application/json')) {
try {
// Check valid JSON
JSON.parse(html);
// Check full text string is present in the json
this.#verified = !!html.includes(JSON.stringify(this.target.href));
if (wasVerified && !this.#verified) {
// Delete the mention, but keep it verified (it was just deleted, because it was verified earlier, so now it is removed from the site according to the spec)
this.#deleted = true;
this.#verified = true;
} else {
this.#undelete();
}
} catch (e) {
this.#verified = false;
}
}
}
/** @type {URL} */
#source;
get source() {
return this.#source;
}
/** @type {URL} */
#target;
get target() {
return this.#target;
}
/** @type {Date} */
#timestamp;
get timestamp() {
return this.#timestamp;
}
/** @type {Object<string, any> | null} */
#payload;
get payload() {
return this.#payload;
}
/** @type {ObjectID | null} */
#resourceId;
get resourceId() {
return this.#resourceId;
}
/** @type {string | null} */
#resourceType;
get resourceType() {
return this.#resourceType;
}
/** @type {string} */
#sourceTitle;
get sourceTitle() {
return this.#sourceTitle;
}
/** @type {string | null} */
#sourceSiteTitle;
get sourceSiteTitle() {
return this.#sourceSiteTitle;
}
/** @type {string | null} */
#sourceAuthor;
get sourceAuthor() {
return this.#sourceAuthor;
}
/** @type {string | null} */
#sourceExcerpt;
get sourceExcerpt() {
return this.#sourceExcerpt;
}
/** @type {URL | null} */
#sourceFavicon;
get sourceFavicon() {
return this.#sourceFavicon;
}
/** @type {URL | null} */
#sourceFeaturedImage;
get sourceFeaturedImage() {
return this.#sourceFeaturedImage;
}
/**
* @param {object} metadata
*/
setSourceMetadata(metadata) {
/** @type {string} */
let sourceTitle = validateString(metadata.sourceTitle, 2000, 'sourceTitle');
if (sourceTitle === null) {
sourceTitle = this.#source.host;
}
/** @type {string | null} */
const sourceExcerpt = validateString(metadata.sourceExcerpt, 2000, 'sourceExcerpt');
/** @type {string | null} */
let sourceSiteTitle = validateString(metadata.sourceSiteTitle, 2000, 'sourceSiteTitle');
if (sourceSiteTitle === null) {
sourceSiteTitle = this.#source.host;
}
/** @type {string | null} */
const sourceAuthor = validateString(metadata.sourceAuthor, 2000, 'sourceAuthor');
/** @type {URL | null} */
let sourceFavicon = null;
if (metadata.sourceFavicon instanceof URL) {
sourceFavicon = metadata.sourceFavicon;
} else if (metadata.sourceFavicon) {
sourceFavicon = new URL(metadata.sourceFavicon);
}
/** @type {URL | null} */
let sourceFeaturedImage = null;
if (metadata.sourceFeaturedImage instanceof URL) {
sourceFeaturedImage = metadata.sourceFeaturedImage;
} else if (metadata.sourceFeaturedImage) {
sourceFeaturedImage = new URL(metadata.sourceFeaturedImage);
}
this.#sourceTitle = sourceTitle;
this.#sourceExcerpt = sourceExcerpt;
this.#sourceSiteTitle = sourceSiteTitle;
this.#sourceAuthor = sourceAuthor;
this.#sourceFavicon = sourceFavicon;
this.#sourceFeaturedImage = sourceFeaturedImage;
}
toJSON() {
return {
id: this.id,
source: this.source,
target: this.target,
timestamp: this.timestamp,
payload: this.payload,
resourceId: this.resourceId,
resourceType: this.resourceType,
sourceTitle: this.sourceTitle,
sourceSiteTitle: this.sourceSiteTitle,
sourceAuthor: this.sourceAuthor,
sourceExcerpt: this.sourceExcerpt,
sourceFavicon: this.sourceFavicon,
sourceFeaturedImage: this.sourceFeaturedImage,
verified: this.verified
};
}
/** @private */
constructor(data) {
this.#id = data.id;
this.#source = data.source;
this.#target = data.target;
this.#timestamp = data.timestamp;
this.#payload = data.payload;
this.#resourceId = data.resourceId;
this.#resourceType = data.resourceType;
this.#verified = data.verified;
this.#deleted = data.deleted || false;
}
/**
* @param {any} data
* @returns {Promise<Mention>}
*/
static async create(data) {
/** @type ObjectID */
let id;
let isNew = false;
if (!data.id) {
isNew = true;
id = new ObjectID();
} else if (typeof data.id === 'string') {
id = ObjectID.createFromHexString(data.id);
} else if (data.id instanceof ObjectID) {
id = data.id;
} else {
throw new ValidationError({
message: 'Invalid ID provided for Mention'
});
}
/** @type URL */
let source;
if (data.source instanceof URL) {
source = data.source;
} else {
source = new URL(data.source);
}
/** @type URL */
let target;
if (data.target instanceof URL) {
target = data.target;
} else {
target = new URL(data.target);
}
/** @type Date */
let timestamp;
if (data.timestamp instanceof Date) {
timestamp = data.timestamp;
} else if (data.timestamp) {
timestamp = new Date(data.timestamp);
if (isNaN(timestamp.valueOf())) {
throw new ValidationError({
message: 'Invalid Date'
});
}
} else {
timestamp = new Date();
}
let payload;
payload = data.payload ? JSON.parse(JSON.stringify(data.payload)) : null;
/** @type boolean */
let verified;
verified = isNew ? false : !!data.verified;
/** @type {ObjectID | null} */
let resourceId = null;
if (data.resourceId) {
if (data.resourceId instanceof ObjectID) {
resourceId = data.resourceId;
} else {
resourceId = ObjectID.createFromHexString(data.resourceId);
}
}
/** @type {string | null} */
let resourceType = null;
if (data.resourceType) {
resourceType = data.resourceType;
}
const mention = new Mention({
id,
source,
target,
timestamp,
payload,
resourceId,
resourceType,
verified,
deleted: isNew ? false : !!data.deleted
});
mention.setSourceMetadata(data);
if (isNew) {
mention.events.push(MentionCreatedEvent.create({mention}));
}
return mention;
}
/**
* @returns {boolean}
*/
isDeleted() {
return this.#deleted;
}
/**
* @param {Mention} mention
* @returns {boolean}
*/
static isDeleted(mention) {
return mention.isDeleted();
}
};
function validateString(value, maxlength, name) {
if (!value) {
return null;
}
if (typeof value !== 'string') {
throw new ValidationError({
message: `${name} must be a string`
});
}
return value.trim().slice(0, maxlength);
}