ghost 5.115.0 → 5.116.0

package/core/server/services/recommendations/service/UnsafeData.js

@@ -0,0 +1,183 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsafeData = void 0;
+const errors_1 = __importDefault(require("@tryghost/errors"));
+function serializeField(field) {
+    if (field.length === 0) {
+        return 'data';
+    }
+    return field.join('.');
+}
+/**
+ * NOTE: should be moved to a separate package in case this pattern is found to be useful
+ */
+class UnsafeData {
+    data;
+    context;
+    constructor(data, context = {}) {
+        this.data = data;
+        this.context = context;
+    }
+    get field() {
+        return serializeField(this.context.field ?? []);
+    }
+    addKeyToField(key) {
+        return this.context.field ? [...this.context.field, key] : [key];
+    }
+    fieldWithKey(key) {
+        return serializeField(this.addKeyToField(key));
+    }
+    /**
+     * Returns undefined if the key is not present on the object. Note that this doesn't check for null.
+     */
+    optionalKey(key) {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an object` });
+        }
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            return undefined;
+        }
+        return new UnsafeData(this.data[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+    key(key) {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an object` });
+        }
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            throw new errors_1.default.ValidationError({ message: `${this.fieldWithKey(key)} is required` });
+        }
+        return new UnsafeData(this.data[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+    /**
+     * Use this to get a nullable value:
+     * ```
+     * const url: string|null = data.key('url').nullable.string
+     * ```
+     */
+    get nullable() {
+        if (this.data === null) {
+            const d = {
+                get string() {
+                    return null;
+                },
+                get boolean() {
+                    return null;
+                },
+                get number() {
+                    return null;
+                },
+                get integer() {
+                    return null;
+                },
+                get url() {
+                    return null;
+                },
+                enum() {
+                    return null;
+                },
+                key() {
+                    return d;
+                },
+                optionalKey() {
+                    return d;
+                },
+                get array() {
+                    return null;
+                },
+                index() {
+                    return d;
+                }
+            };
+            return d;
+        }
+        return this;
+    }
+    get string() {
+        if (typeof this.data !== 'string') {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a string` });
+        }
+        return this.data;
+    }
+    get boolean() {
+        if (typeof this.data !== 'boolean') {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a boolean` });
+        }
+        return this.data;
+    }
+    get number() {
+        if (typeof this.data === 'string') {
+            const parsed = parseFloat(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors_1.default.ValidationError({ message: `${this.field} must be a number, got ${typeof this.data}` });
+            }
+            return new UnsafeData(parsed, this.context).number;
+        }
+        if (typeof this.data !== 'number') {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a number, got ${typeof this.data}` });
+        }
+        if (Number.isNaN(this.data) || !Number.isFinite(this.data)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a finite number` });
+        }
+        return this.data;
+    }
+    get integer() {
+        if (typeof this.data === 'string') {
+            const parsed = parseInt(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors_1.default.ValidationError({ message: `${this.field} must be an integer` });
+            }
+            return new UnsafeData(parseInt(this.data), this.context).integer;
+        }
+        const number = this.number;
+        if (!Number.isSafeInteger(number)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an integer` });
+        }
+        return number;
+    }
+    get url() {
+        if (this.data instanceof URL) {
+            return this.data;
+        }
+        const string = this.string;
+        try {
+            const url = new URL(string);
+            if (!['http:', 'https:'].includes(url.protocol)) {
+                throw new errors_1.default.ValidationError({ message: `${this.field} must be a valid URL` });
+            }
+            return url;
+        }
+        catch (e) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be a valid URL` });
+        }
+    }
+    enum(allowedValues) {
+        if (!allowedValues.includes(this.data)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be one of ${allowedValues.join(', ')}` });
+        }
+        return this.data;
+    }
+    get array() {
+        if (!Array.isArray(this.data)) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an array` });
+        }
+        return this.data.map((d, i) => new UnsafeData(d, { field: this.addKeyToField(`${i}`) }));
+    }
+    index(index) {
+        const arr = this.array;
+        if (index < 0 || !Number.isSafeInteger(index)) {
+            throw new errors_1.default.IncorrectUsageError({ message: `index must be a positive integer` });
+        }
+        if (index >= arr.length) {
+            throw new errors_1.default.ValidationError({ message: `${this.field} must be an array of length ${index + 1}` });
+        }
+        return arr[index];
+    }
+}
+exports.UnsafeData = UnsafeData;

package/core/server/services/recommendations/service/UnsafeData.ts

@@ -0,0 +1,217 @@
+import errors from '@tryghost/errors';
+
+type UnsafeDataContext = {
+    field?: string[]
+}
+
+function serializeField(field: string[]) {
+    if (field.length === 0) {
+        return 'data';
+    }
+    return field.join('.');
+}
+
+type NullData = {
+    readonly string: null,
+    readonly boolean: null,
+    readonly number: null,
+    readonly integer: null,
+    readonly url: null
+    enum(allowedValues: unknown[]): null
+    key(key: string): NullData
+    optionalKey(key: string): NullData
+    readonly array: null
+    index(index: number): NullData
+}
+
+/**
+ * NOTE: should be moved to a separate package in case this pattern is found to be useful
+ */
+export class UnsafeData {
+    protected data: unknown;
+    protected context: UnsafeDataContext;
+
+    constructor(data: unknown, context: UnsafeDataContext = {}) {
+        this.data = data;
+        this.context = context;
+    }
+
+    protected get field() {
+        return serializeField(this.context.field ?? []);
+    }
+
+    protected addKeyToField(key: string) {
+        return this.context.field ? [...this.context.field, key] : [key];
+    }
+
+    protected fieldWithKey(key: string) {
+        return serializeField(this.addKeyToField(key));
+    }
+
+    /**
+     * Returns undefined if the key is not present on the object. Note that this doesn't check for null.
+     */
+    optionalKey(key: string): UnsafeData|undefined {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors.ValidationError({message: `${this.field} must be an object`});
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            return undefined;
+        }
+
+        return new UnsafeData((this.data as Record<string, unknown>)[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+
+    key(key: string): UnsafeData {
+        if (typeof this.data !== 'object' || this.data === null) {
+            throw new errors.ValidationError({message: `${this.field} must be an object`});
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(this.data, key)) {
+            throw new errors.ValidationError({message: `${this.fieldWithKey(key)} is required`});
+        }
+
+        return new UnsafeData((this.data as Record<string, unknown>)[key], {
+            field: this.addKeyToField(key)
+        });
+    }
+
+    /**
+     * Use this to get a nullable value:
+     * ```
+     * const url: string|null = data.key('url').nullable.string
+     * ```
+     */
+    get nullable(): UnsafeData|NullData {
+        if (this.data === null) {
+            const d: NullData = {
+                get string() {
+                    return null;
+                },
+                get boolean() {
+                    return null;
+                },
+                get number() {
+                    return null;
+                },
+                get integer() {
+                    return null;
+                },
+                get url() {
+                    return null;
+                },
+                enum() {
+                    return null;
+                },
+                key() {
+                    return d;
+                },
+                optionalKey() {
+                    return d;
+                },
+                get array() {
+                    return null;
+                },
+                index() {
+                    return d;
+                }
+            };
+            return d;
+        }
+        return this;
+    }
+
+    get string(): string {
+        if (typeof this.data !== 'string') {
+            throw new errors.ValidationError({message: `${this.field} must be a string`});
+        }
+        return this.data;
+    }
+
+    get boolean(): boolean {
+        if (typeof this.data !== 'boolean') {
+            throw new errors.ValidationError({message: `${this.field} must be a boolean`});
+        }
+        return this.data;
+    }
+
+    get number(): number {
+        if (typeof this.data === 'string') {
+            const parsed = parseFloat(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors.ValidationError({message: `${this.field} must be a number, got ${typeof this.data}`});
+            }
+            return new UnsafeData(parsed, this.context).number;
+        }
+
+        if (typeof this.data !== 'number') {
+            throw new errors.ValidationError({message: `${this.field} must be a number, got ${typeof this.data}`});
+        }
+        if (Number.isNaN(this.data) || !Number.isFinite(this.data)) {
+            throw new errors.ValidationError({message: `${this.field} must be a finite number`});
+        }
+        return this.data;
+    }
+
+    get integer(): number {
+        if (typeof this.data === 'string') {
+            const parsed = parseInt(this.data);
+            if (isNaN(parsed) || parsed.toString() !== this.data) {
+                throw new errors.ValidationError({message: `${this.field} must be an integer`});
+            }
+            return new UnsafeData(parseInt(this.data), this.context).integer;
+        }
+
+        const number = this.number;
+        if (!Number.isSafeInteger(number)) {
+            throw new errors.ValidationError({message: `${this.field} must be an integer`});
+        }
+        return number;
+    }
+
+    get url(): URL {
+        if (this.data instanceof URL) {
+            return this.data;
+        }
+
+        const string = this.string;
+        try {
+            const url = new URL(string);
+
+            if (!['http:', 'https:'].includes(url.protocol)) {
+                throw new errors.ValidationError({message: `${this.field} must be a valid URL`});
+            }
+            return url;
+        } catch (e) {
+            throw new errors.ValidationError({message: `${this.field} must be a valid URL`});
+        }
+    }
+
+    enum<T>(allowedValues: T[]): T {
+        if (!allowedValues.includes(this.data as T)) {
+            throw new errors.ValidationError({message: `${this.field} must be one of ${allowedValues.join(', ')}`});
+        }
+        return this.data as T;
+    }
+
+    get array(): UnsafeData[] {
+        if (!Array.isArray(this.data)) {
+            throw new errors.ValidationError({message: `${this.field} must be an array`});
+        }
+        return this.data.map((d, i) => new UnsafeData(d, {field: this.addKeyToField(`${i}`)}));
+    }
+
+    index(index: number) {
+        const arr = this.array;
+        if (index < 0 || !Number.isSafeInteger(index)) {
+            throw new errors.IncorrectUsageError({message: `index must be a positive integer`});
+        }
+        if (index >= arr.length) {
+            throw new errors.ValidationError({message: `${this.field} must be an array of length ${index + 1}`});
+        }
+        return arr[index];
+    }
+}

package/core/server/services/recommendations/service/WellknownService.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellknownService = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+class WellknownService {
+    dir;
+    urlUtils;
+    constructor({ dir, urlUtils }) {
+        this.dir = dir;
+        this.urlUtils = urlUtils;
+    }
+    #formatRecommendation(recommendation) {
+        return {
+            url: recommendation.url,
+            updated_at: (recommendation.updatedAt ?? recommendation.createdAt).toISOString(),
+            created_at: (recommendation.createdAt).toISOString()
+        };
+    }
+    getPath() {
+        return path_1.default.join(this.dir, '/.well-known/recommendations.json');
+    }
+    getURL() {
+        return new URL(this.urlUtils.relativeToAbsolute('/.well-known/recommendations.json'));
+    }
+    async set(recommendations) {
+        const content = JSON.stringify(recommendations.map(r => this.#formatRecommendation(r)));
+        const path = this.getPath();
+        await promises_1.default.mkdir(path_1.default.dirname(path), { recursive: true });
+        await promises_1.default.writeFile(path, content);
+    }
+}
+exports.WellknownService = WellknownService;

package/core/server/services/recommendations/service/WellknownService.ts

@@ -0,0 +1,47 @@
+import {Recommendation} from './Recommendation';
+import fs from 'fs/promises';
+import _path from 'path';
+
+type UrlUtils = {
+    relativeToAbsolute(url: string): string
+}
+type Options = {
+    /**
+     * Where to publish the wellknown file
+     */
+    dir: string,
+    urlUtils: UrlUtils
+}
+
+export class WellknownService {
+    dir: string;
+    urlUtils: UrlUtils;
+
+    constructor({dir, urlUtils}: Options) {
+        this.dir = dir;
+        this.urlUtils = urlUtils;
+    }
+
+    #formatRecommendation(recommendation: Recommendation) {
+        return {
+            url: recommendation.url,
+            updated_at: (recommendation.updatedAt ?? recommendation.createdAt).toISOString(),
+            created_at: (recommendation.createdAt).toISOString()
+        };
+    }
+
+    getPath() {
+        return _path.join(this.dir, '/.well-known/recommendations.json');
+    }
+
+    getURL(): URL {
+        return new URL(this.urlUtils.relativeToAbsolute('/.well-known/recommendations.json'));
+    }
+
+    async set(recommendations: Recommendation[]) {
+        const content = JSON.stringify(recommendations.map(r => this.#formatRecommendation(r)));
+        const path = this.getPath();
+        await fs.mkdir(_path.dirname(path), {recursive: true});
+        await fs.writeFile(path, content);
+    }
+}

package/core/server/services/recommendations/service/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RecommendationController"), exports);
+__exportStar(require("./RecommendationService"), exports);
+__exportStar(require("./RecommendationRepository"), exports);
+__exportStar(require("./InMemoryRecommendationRepository"), exports);
+__exportStar(require("./Recommendation"), exports);
+__exportStar(require("./WellknownService"), exports);
+__exportStar(require("./BookshelfRecommendationRepository"), exports);
+__exportStar(require("./ClickEvent"), exports);
+__exportStar(require("./BookshelfClickEventRepository"), exports);
+__exportStar(require("./SubscribeEvent"), exports);
+__exportStar(require("./BookshelfSubscribeEventRepository"), exports);
+__exportStar(require("./IncomingRecommendationController"), exports);
+__exportStar(require("./IncomingRecommendationService"), exports);
+__exportStar(require("./IncomingRecommendationEmailRenderer"), exports);
+__exportStar(require("./RecommendationMetadataService"), exports);

package/core/server/services/recommendations/service/index.ts

@@ -0,0 +1,15 @@
+export * from './RecommendationController';
+export * from './RecommendationService';
+export * from './RecommendationRepository';
+export * from './InMemoryRecommendationRepository';
+export * from './Recommendation';
+export * from './WellknownService';
+export * from './BookshelfRecommendationRepository';
+export * from './ClickEvent';
+export * from './BookshelfClickEventRepository';
+export * from './SubscribeEvent';
+export * from './BookshelfSubscribeEventRepository';
+export * from './IncomingRecommendationController';
+export * from './IncomingRecommendationService';
+export * from './IncomingRecommendationEmailRenderer';
+export * from './RecommendationMetadataService';

package/core/server/services/recommendations/service/libraries.d.ts

@@ -0,0 +1,5 @@
+declare module '@tryghost/errors';
+declare module '@tryghost/tpl';
+declare module '@tryghost/logging';
+declare module '@tryghost/mongo-utils';
+declare module '@tryghost/nql';

package/core/server/services/route-settings/SettingsPathManager.js

@@ -0,0 +1,47 @@
+const path = require('path');
+const tpl = require('@tryghost/tpl');
+const format = require('date-fns/format');
+const {IncorrectUsageError} = require('@tryghost/errors');
+
+const messages = {
+    incorrectPathsParameter: 'Attempted to setup settings path manager without paths values.'
+};
+
+class SettingsPathManager {
+    /**
+     *
+     * @param {Object} options
+     * @param {String[]} options.paths - file location paths ordered in priority by where to locate them first
+     * @param {String} options.type setting file type, e.g: 'routes' or 'redirects'
+     * @param {String[]} [options.extensions] the supported file extensions with 'yaml' and 'json' defaults. Note 'yml' extension is ignored on purpose
+    */
+    constructor({type, paths, extensions = ['yaml', 'json']}) {
+        if (!paths || !paths.length) {
+            throw new IncorrectUsageError({
+                message: tpl(messages.incorrectPathsParameter)
+            });
+        }
+
+        this.type = type;
+        this.filename = type;
+
+        this.paths = paths;
+        this.defaultPath = paths[0];
+
+        this.extensions = extensions;
+        this.defaultExtension = extensions[0];
+    }
+
+    getDefaultFilePath() {
+        const settingsFolder = this.defaultPath;
+        return path.join(settingsFolder, `${this.filename}.${this.defaultExtension}`);
+    }
+
+    getBackupFilePath() {
+        const settingsFolder = this.defaultPath;
+        const dateStamp = format(new Date(), 'yyyy-MM-dd-HH-mm-ss');
+        return path.join(settingsFolder, `${this.filename}-${dateStamp}.${this.defaultExtension}`);
+    }
+}
+
+module.exports = SettingsPathManager;

package/core/server/services/route-settings/index.js

@@ -1,6 +1,5 @@
 const config = require('../../../shared/config');
 const parseYaml = require('./yaml-parser');
-const SettingsPathManager = require('@tryghost/settings-path-manager');
 
 let settingsLoader;
 let routeSettings;
@@ -10,6 +9,7 @@ module.exports = {
         const RouteSettings = require('./RouteSettings');
         const SettingsLoader = require('./SettingsLoader');
         const DefaultSettingsManager = require('./DefaultSettingsManager');
+        const SettingsPathManager = require('./SettingsPathManager');
 
         const settingsPathManager = new SettingsPathManager({type: 'routes', paths: [config.getContentPath('settings')]});
         settingsLoader = new SettingsLoader({parseYaml, settingFilePath: settingsPathManager.getDefaultFilePath()});