ghost 5.9.4 → 5.10.0

package/core/frontend/services/member-attribution-assets/index.js

@@ -0,0 +1,4 @@
+const MemberAttributionAssetsService = require('./service');
+const memberAttributionAssets = new MemberAttributionAssetsService();
+
+module.exports = memberAttributionAssets;

package/core/frontend/services/member-attribution-assets/service.js

@@ -0,0 +1,83 @@
+// const debug = require('@tryghost/debug')('comments-counts-assets');
+const Minifier = require('@tryghost/minifier');
+const path = require('path');
+const fs = require('fs').promises;
+const logging = require('@tryghost/logging');
+const config = require('../../../shared/config');
+
+class MemberAttributionAssetsService {
+    constructor(options = {}) {
+        /** @private */
+        this.src = options.src || path.join(config.get('paths').assetSrc, 'member-attribution');
+        /** @private */
+        this.dest = options.dest || config.getContentPath('public');
+        /** @private */
+        this.minifier = new Minifier({src: this.src, dest: this.dest});
+    }
+
+    /**
+     * @private
+     */
+    generateGlobs() {
+        return {
+            'member-attribution.min.js': '*.js'
+        };
+    }
+
+    /**
+     * @private
+     */
+    generateReplacements() {
+        return {};
+    }
+
+    /**
+     * @private
+     * @returns {Promise<void>}
+     */
+    async minify(globs, options) {
+        try {
+            await this.minifier.minify(globs, options);
+        } catch (error) {
+            if (error.code === 'EACCES') {
+                logging.error('Ghost was not able to write member-attribution asset files due to permissions.');
+                return;
+            }
+
+            throw error;
+        }
+    }
+
+    /**
+     * @private
+     * @returns {Promise<void>}
+     */
+    async clearFiles() {
+        const rmFile = async (name) => {
+            await fs.unlink(path.join(this.dest, name));
+        };
+
+        const promises = [];
+        for (const key of Object.keys(this.generateGlobs())) {
+            // @deprecated switch this to use fs.rm when we drop support for Node v12
+            promises.push(rmFile(key));
+        }
+
+        // We don't care if removing these files fails as it's valid for them to not exist
+        await Promise.allSettled(promises);
+    }
+
+    /**
+     * Minify, move into the destination directory, and clear existing asset files.
+     *
+     * @returns {Promise<void>}
+     */
+    async load() {
+        const globs = this.generateGlobs();
+        const replacements = this.generateReplacements();
+        await this.clearFiles();
+        await this.minify(globs, {replacements});
+    }
+}
+
+module.exports = MemberAttributionAssetsService;

package/core/frontend/src/member-attribution/.eslintrc

@@ -0,0 +1,10 @@
+{
+    "extends": "../../../../.eslintrc.js",
+    "env": {
+        "browser": true,
+        "node": false
+    },
+    "rules": {
+        "no-console": "off"
+    }
+}

package/core/frontend/src/member-attribution/member-attribution.js

@@ -0,0 +1,90 @@
+// Location where we want to store the history in localStorage
+const STORAGE_KEY = 'ghost-history';
+
+// How long before an item should expire (24h)
+const TIMEOUT = 24 * 60 * 60 * 1000;
+
+// Maximum amount of urls in the history
+const LIMIT = 15;
+
+// History is saved in JSON format, from old to new
+// Time is saved to be able to exclude old items
+// [
+//     {
+//         "time": 12341234,
+//         "path": "/about/"
+//     },
+//     {
+//         "time": 12341235,
+//         "path": "/welcome/"
+//     }
+// ]
+
+(async function () {
+    try {
+        const storage = window.localStorage;
+        const historyString = storage.getItem(STORAGE_KEY);
+        const currentTime = new Date().getTime();
+
+        // Append current location
+        let history = [];
+
+        if (historyString) {
+            try {
+                history = JSON.parse(historyString);
+            } catch (error) {
+                // Ignore invalid JSON, ans clear history
+                console.warn('[Member Attribution] Error while parsing history', error);
+            }
+        }
+
+        // Remove all items that are expired
+        const firstNotExpiredIndex = history.findIndex((item) => {
+            // Return true to keep all items after and including this item
+            // Return false to remove the item
+
+            if (!item.time || typeof item.time !== 'number') {
+                return false;
+            }
+
+            const difference = currentTime - item.time;
+
+            if (isNaN(item.time) || difference > TIMEOUT) {
+                // Expired or invalid
+                return false;
+            }
+
+            // Valid item (so all following items are also valid by definition)
+            return true;
+        });
+        
+        if (firstNotExpiredIndex > 0) {
+            // Remove until the first valid item
+            history.splice(0, firstNotExpiredIndex);
+        } else if (firstNotExpiredIndex === -1) {
+            // Not a single valid item found, remove all
+            history = [];
+        }
+
+        const currentPath = window.location.pathname;
+
+        if (history.length === 0 || history[history.length - 1].path !== currentPath) {
+            history.push({
+                path: currentPath,
+                time: currentTime
+            });
+        } else if (history.length > 0) {
+            history[history.length - 1].time = currentTime;
+        }
+        
+        // Restrict length
+        if (history.length > LIMIT) {
+            history = history.slice(-LIMIT);
+        }
+
+        // Save current timestamp
+        storage.setItem(STORAGE_KEY, JSON.stringify(history));
+    } catch (error) {
+        console.error('[Member Attribution] Failed with error', error);
+    }
+})();

package/core/frontend/web/site.js

@@ -75,6 +75,9 @@ module.exports = function setupSiteApp(routerConfig) {
     // Comment counts
     siteApp.use(mw.servePublicFile('built', 'public/comment-counts.min.js', 'application/javascript', constants.ONE_YEAR_S));
 
+    // Member attribution
+    siteApp.use(mw.servePublicFile('built', 'public/member-attribution.min.js', 'application/javascript', constants.ONE_YEAR_S));
+
     // Serve blog images using the storage adapter
     siteApp.use(STATIC_IMAGE_URL_PREFIX, mw.handleImageSizes, storage.getStorage('images').serve());
     // Serve blog media using the storage adapter

package/core/server/adapters/cache/ImageSizesCacheSyncInMemory.js

@@ -0,0 +1,7 @@
+const Memory = require('./Memory');
+
+class ImageSizesCacheSyncInMemory extends Memory {
+
+}
+
+module.exports = ImageSizesCacheSyncInMemory;

package/core/server/adapters/cache/SettingsCacheSyncInMemory.js

@@ -0,0 +1,7 @@
+const Memory = require('./Memory');
+
+class SettingsCacheSyncInMemory extends Memory {
+
+}
+
+module.exports = SettingsCacheSyncInMemory;

package/core/server/api/endpoints/posts.js

@@ -2,7 +2,16 @@ const models = require('../../models');
 const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 const getPostServiceInstance = require('../../services/posts/posts-service');
-const allowedIncludes = ['tags', 'authors', 'authors.roles', 'email', 'tiers', 'newsletter'];
+const allowedIncludes = [
+    'tags',
+    'authors',
+    'authors.roles',
+    'email',
+    'tiers',
+    'newsletter',
+    'count.signups',
+    'count.conversions'
+];
 const unsafeAttrs = ['status', 'authors', 'visibility'];
 
 const messages = {

package/core/server/api/endpoints/utils/serializers/input/posts.js

@@ -23,7 +23,7 @@ function defaultRelations(frame) {
         return false;
     }
 
-    frame.options.withRelated = ['tags', 'authors', 'authors.roles', 'email', 'tiers', 'newsletter'];
+    frame.options.withRelated = ['tags', 'authors', 'authors.roles', 'email', 'tiers', 'newsletter', 'count.signups', 'count.conversions'];
 }
 
 function setDefaultOrder(frame) {

package/core/server/api/endpoints/utils/serializers/output/mappers/posts.js

@@ -10,6 +10,7 @@ const extraAttrs = require('../utils/extra-attrs');
 const gating = require('../utils/post-gating');
 const url = require('../utils/url');
 
+const labs = require('../../../../../../../shared/labs');
 const utils = require('../../../index');
 
 const postsMetaSchema = require('../../../../../../data/schema').tables.posts_meta;
@@ -109,5 +110,9 @@ module.exports = async (model, frame, options = {}) => {
         });
     }
 
+    if (!labs.isSet('memberAttribution')) {
+        delete jsonModel.count;
+    }
+
     return jsonModel;
 };

package/core/server/data/exporter/table-lists.js

@@ -31,6 +31,8 @@ const BACKUP_TABLES = [
     'members_paid_subscription_events',
     'members_subscribe_events',
     'members_product_events',
+    'members_created_events',
+    'members_subscription_created_events',
     'members_newsletters',
     'comments',
     'comment_likes',

package/core/server/data/migrations/versions/5.10/2022-08-15-05-34-add-expiry-at-column-to-members-products.js

@@ -0,0 +1,6 @@
+const {createAddColumnMigration} = require('../../utils');
+
+module.exports = createAddColumnMigration('members_products', 'expiry_at', {
+    type: 'dateTime',
+    nullable: true
+});

package/core/server/data/migrations/versions/5.10/2022-08-16-14-25-add-member-created-events-table.js

@@ -0,0 +1,11 @@
+const {addTable} = require('../../utils');
+
+module.exports = addTable('members_created_events', {
+    id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+    created_at: {type: 'dateTime', nullable: false},
+    member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+    attribution_id: {type: 'string', maxlength: 24, nullable: true},
+    attribution_type: {type: 'string', maxlength: 50, nullable: true},
+    attribution_url: {type: 'string', maxlength: 2000, nullable: true},
+    source: {type: 'string', maxlength: 50, nullable: false}
+});

package/core/server/data/migrations/versions/5.10/2022-08-16-14-25-add-subscription-created-events-table.js

@@ -0,0 +1,11 @@
+const {addTable} = require('../../utils');
+
+module.exports = addTable('members_subscription_created_events', {
+    id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+    created_at: {type: 'dateTime', nullable: false},
+    member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+    subscription_id: {type: 'string', maxlength: 24, nullable: false, references: 'members_stripe_customers_subscriptions.id', cascadeDelete: true},
+    attribution_id: {type: 'string', maxlength: 24, nullable: true},
+    attribution_type: {type: 'string', maxlength: 50, nullable: true},
+    attribution_url: {type: 'string', maxlength: 2000, nullable: true}
+});

package/core/server/data/migrations/versions/5.10/2022-08-19-14-15-fix-comments-deletion-strategy.js

@@ -0,0 +1,45 @@
+const {addForeign, dropForeign} = require('../../../schema/commands');
+const logging = require('@tryghost/logging');
+const {createTransactionalMigration} = require('../../utils');
+
+module.exports = createTransactionalMigration(
+    async function up(knex) {
+        logging.info('Adding on delete CASCADE for comments parent_id');
+
+        await dropForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            transaction: knex
+        });
+
+        await addForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            cascadeDelete: true,
+            transaction: knex
+        });
+    },
+    async function down(knex) {
+        logging.info('Restoring foreign key for comments parent_id');
+
+        await dropForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            transaction: knex
+        });
+
+        await addForeign({
+            fromTable: 'comments',
+            fromColumn: 'parent_id',
+            toTable: 'comments',
+            toColumn: 'id',
+            transaction: knex
+        });
+    }
+);

package/core/server/data/schema/schema.js

@@ -466,7 +466,8 @@ module.exports = {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
         product_id: {type: 'string', maxlength: 24, nullable: false, references: 'products.id', cascadeDelete: true},
-        sort_order: {type: 'integer', nullable: false, unsigned: true, defaultTo: 0}
+        sort_order: {type: 'integer', nullable: false, unsigned: true, defaultTo: 0},
+        expiry_at: {type: 'dateTime', nullable: true}
     },
     posts_products: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
@@ -474,6 +475,15 @@ module.exports = {
         product_id: {type: 'string', maxlength: 24, nullable: false, references: 'products.id', cascadeDelete: true},
         sort_order: {type: 'integer', nullable: false, unsigned: true, defaultTo: 0}
     },
+    members_created_events: {
+        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        created_at: {type: 'dateTime', nullable: false},
+        member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+        attribution_id: {type: 'string', maxlength: 24, nullable: true},
+        attribution_type: {type: 'string', maxlength: 50, nullable: true},
+        attribution_url: {type: 'string', maxlength: 2000, nullable: true},
+        source: {type: 'string', maxlength: 50, nullable: false}
+    },
     members_cancel_events: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
@@ -594,6 +604,15 @@ module.exports = {
         plan_amount: {type: 'integer', nullable: false},
         plan_currency: {type: 'string', maxLength: 3, nullable: false}
     },
+    members_subscription_created_events: {
+        id: {type: 'string', maxlength: 24, nullable: false, primary: true},
+        created_at: {type: 'dateTime', nullable: false},
+        member_id: {type: 'string', maxlength: 24, nullable: false, references: 'members.id', cascadeDelete: true},
+        subscription_id: {type: 'string', maxlength: 24, nullable: false, references: 'members_stripe_customers_subscriptions.id', cascadeDelete: true},
+        attribution_id: {type: 'string', maxlength: 24, nullable: true},
+        attribution_type: {type: 'string', maxlength: 50, nullable: true},
+        attribution_url: {type: 'string', maxlength: 2000, nullable: true}
+    },
     offer_redemptions: {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         offer_id: {type: 'string', maxlength: 24, nullable: false, references: 'offers.id', cascadeDelete: true},
@@ -754,7 +773,7 @@ module.exports = {
         id: {type: 'string', maxlength: 24, nullable: false, primary: true},
         post_id: {type: 'string', maxlength: 24, nullable: false, unique: false, references: 'posts.id', cascadeDelete: true},
         member_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'members.id', setNullDelete: true},
-        parent_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'comments.id'},
+        parent_id: {type: 'string', maxlength: 24, nullable: true, unique: false, references: 'comments.id', cascadeDelete: true},
         status: {type: 'string', maxlength: 50, nullable: false, defaultTo: 'published', validations: {isIn: [['published', 'hidden', 'deleted']]}},
         html: {type: 'text', maxlength: 1000000000, fieldtype: 'long', nullable: true},
         edited_at: {type: 'dateTime', nullable: true},

package/core/server/lib/image/cached-image-size-from-url.js

@@ -1,52 +1,76 @@
 const debug = require('@tryghost/debug')('utils:image-size-cache');
 const errors = require('@tryghost/errors');
 const logging = require('@tryghost/logging');
+
+/**
+ * @example
+ * {
+ *   height: 50,
+ *   url: 'https://mysite.com/images/cat.jpg',
+ *   width: 50
+ * }
+ * @typedef ImageSizeCache
+ * @type {Object}
+ * @property {string} url image url
+ * @property {number} height image height
+ * @property {number} width image width
+ */
+
 class CachedImageSizeFromUrl {
-    constructor({imageSize}) {
-        this.imageSize = imageSize;
-        this.cache = new Map();
+    /**
+     *
+     * @param {Object} options
+     * @param {(url: string) => Promise<ImageSizeCache>} options.getImageSizeFromUrl - method that resolves images based on URL
+     * @param {Object} options.cache - cache store instance
+     */
+    constructor({getImageSizeFromUrl, cache}) {
+        this.getImageSizeFromUrl = getImageSizeFromUrl;
+        this.cache = cache;
     }
 
     /**
      * Get cached image size from URL
      * Always returns {object} imageSizeCache
      * @param {string} url
-     * @returns {Promise<Object>} imageSizeCache
+     * @returns {Promise<ImageSizeCache>}
      * @description Takes a url and returns image width and height from cache if available.
      * If not in cache, `getImageSizeFromUrl` is called and returns the dimensions in a Promise.
      */
-    getCachedImageSizeFromUrl(url) {
+    async getCachedImageSizeFromUrl(url) {
         if (!url || url === undefined || url === null) {
             return;
         }
-    
-        // image size is not in cache
-        if (!this.cache.has(url)) {
-            return this.imageSize.getImageSizeFromUrl(url).then((res) => {
-                this.cache.set(url, res);
-    
+
+        const cachedImageSize = await this.cache.get(url);
+
+        if (cachedImageSize) {
+            debug('Read image from cache:', url);
+
+            return cachedImageSize;
+        } else {
+            try {
+                const res = await this.getImageSizeFromUrl(url);
+                await this.cache.set(url, res);
+
                 debug('Cached image:', url);
-    
-                return this.cache.get(url);
-            }).catch(errors.NotFoundError, () => {
-                debug('Cached image (not found):', url);
-                // in case of error we just attach the url
-                this.cache.set(url, url);
-    
+
                 return this.cache.get(url);
-            }).catch((err) => {
-                debug('Cached image (error):', url);
-                logging.error(err);
-    
+            } catch (err) {
+                if (err instanceof errors.NotFoundError) {
+                    debug('Cached image (not found):', url);
+                } else {
+                    debug('Cached image (error):', url);
+                    logging.error(err);
+                }
+
                 // in case of error we just attach the url
-                this.cache.set(url, url);
-    
+                await this.cache.set(url, {
+                    url
+                });
+
                 return this.cache.get(url);
-            });
+            }
         }
-        debug('Read image from cache:', url);
-        // returns image size from cache
-        return this.cache.get(url);
     }
 }
 

package/core/server/lib/image/image-utils.js

@@ -4,10 +4,13 @@ const Gravatar = require('./gravatar');
 const ImageSize = require('./image-size');
 
 class ImageUtils {
-    constructor({config, urlUtils, settingsCache, storageUtils, storage, validator, request}) {
+    constructor({config, urlUtils, settingsCache, storageUtils, storage, validator, request, cacheStore}) {
         this.blogIcon = new BlogIcon({config, urlUtils, settingsCache, storageUtils});
         this.imageSize = new ImageSize({config, storage, storageUtils, validator, urlUtils, request});
-        this.cachedImageSizeFromUrl = new CachedImageSizeFromUrl({imageSize: this.imageSize});
+        this.cachedImageSizeFromUrl = new CachedImageSizeFromUrl({
+            getImageSizeFromUrl: this.imageSize.getImageSizeFromUrl.bind(this.imageSize),
+            cache: cacheStore
+        });
         this.gravatar = new Gravatar({config, request});
     }
 }

package/core/server/lib/image/index.js

@@ -7,4 +7,17 @@ const config = require('../../../shared/config');
 const settingsCache = require('../../../shared/settings-cache');
 const ImageUtils = require('./image-utils');
 
-module.exports = new ImageUtils({config, urlUtils, settingsCache, storageUtils, storage, validator, request});
+const adapterManager = require('../../services/adapter-manager');
+
+const cacheStore = adapterManager.getAdapter('cache:imageSizes');
+
+module.exports = new ImageUtils({
+    config,
+    urlUtils,
+    settingsCache,
+    storageUtils,
+    storage,
+    validator,
+    request,
+    cacheStore
+});

package/core/server/models/api-key.js

@@ -6,6 +6,9 @@ const {Role} = require('./role');
 const ApiKey = ghostBookshelf.Model.extend({
     tableName: 'api_keys',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'api_key',
+
     defaults() {
         const secret = security.secret.create(this.get('type'));
 
@@ -53,24 +56,6 @@ const ApiKey = ghostBookshelf.Model.extend({
         if (this.previous('secret') !== this.get('secret')) {
             this.addAction(model, 'refreshed', options);
         }
-    },
-
-    getAction(event, options) {
-        const actor = this.getActor(options);
-
-        // @NOTE: we ignore internal updates (`options.context.internal`) for now
-        if (!actor) {
-            return;
-        }
-
-        // @TODO: implement context
-        return {
-            event: event,
-            resource_id: this.id || this.previous('id'),
-            resource_type: 'api_key',
-            actor_id: actor.id,
-            actor_type: actor.type
-        };
     }
 }, {
     refreshSecret(data, options) {

package/core/server/models/base/plugins/actions.js

@@ -7,6 +7,38 @@ const logging = require('@tryghost/logging');
  */
 module.exports = function (Bookshelf) {
     Bookshelf.Model = Bookshelf.Model.extend({
+        /**
+         * Constructs data to be stored in the database with info
+         * on particular actions
+         */
+        getAction(event, options) {
+            const actor = this.getActor(options);
+
+            // @NOTE: we ignore internal updates (`options.context.internal`) for now
+            if (!actor) {
+                return;
+            }
+
+            if (!this.actionsCollectCRUD) {
+                return;
+            }
+
+            let resourceType = this.actionsResourceType;
+
+            if (typeof resourceType === 'function') {
+                resourceType = resourceType.bind(this)();
+            }
+
+            // @TODO: implement context
+            return {
+                event: event,
+                resource_id: this.id || this.previous('id'),
+                resource_type: resourceType,
+                actor_id: actor.id,
+                actor_type: actor.type
+            };
+        },
+
         /**
          * @NOTE:
          *

package/core/server/models/integration.js

@@ -6,6 +6,9 @@ const {NoPermissionError} = require('@tryghost/errors');
 const Integration = ghostBookshelf.Model.extend({
     tableName: 'integrations',
 
+    actionsCollectCRUD: true,
+    actionsResourceType: 'integration',
+
     relationships: ['api_keys', 'webhooks'],
 
     relationshipBelongsTo: {