ghost 6.55.0 → 6.57.0

package/core/server/services/members-custom-fields/values-service.ts

@@ -3,28 +3,35 @@ import errors from '@tryghost/errors';
 import logging from '@tryghost/logging';
 import type {Knex} from 'knex';
 import {z} from 'zod';
-import {FIELD_TYPES, type FieldType} from '@tryghost/custom-field-types';
-import {DbCustomFieldValueWithField, FIELD_STATUS} from './schema';
+import {FIELD_TYPES, subFieldsOf, type FieldType} from '@tryghost/custom-field-types';
+import {DbCustomFieldLeaf, DbCustomFieldValue, FIELD_STATUS} from './schema';
 import {activeFields} from './queries';
-import {storageCodecFor, storageColumnsFor} from './storage';
+import {leavesToWrite, valuesFromLeaves, type StoredLeaf} from './storage';
 
 const FIELDS_TABLE = 'members_custom_fields';
 const VALUES_TABLE = 'members_custom_field_values';
 
-// Matches the `members_custom_fields.key` column (schema.js), so no key a site
-// could actually have minted is ever refused by it.
+/** Matches the `members_custom_fields.key` column, so no key a site could hold is refused. */
 const MAX_KEY_LENGTH = 191;
 
-// Values arrive keyed by field key. Each value stays `unknown` here: it is
-// validated by its own field type's schema, which isn't known until the key is
-// resolved to a definition.
+/**
+ * Rows per insert statement, bounded by knex rather than by either database. SQLite takes
+ * a multi-row `VALUES` perfectly well; knex's SQLite dialect emits that form only for a
+ * single row and compiles anything longer into `INSERT ... SELECT ? UNION ALL SELECT ?`,
+ * which SQLite refuses past 500 terms.
+ *
+ * Open as knex#721 since 2015, with an approved but unmerged fix in knex#5780. This can
+ * go when that lands; until then the alternative is hand-written upsert SQL per engine.
+ */
+const UPSERT_CHUNK = 400;
+
+/** Derived, not restated, so a column changing shape in `schema.ts` changes here too. */
+type DbLeafRow = z.infer<typeof DbCustomFieldValue>;
+
+// Values stay `unknown`: each is validated by its own field type, which is not known
+// until the key is resolved to a definition.
 const ValuesInput = z.record(z.string().max(MAX_KEY_LENGTH), z.unknown());
 
-// The field facts the value path needs: the id to write the FK, the key to match
-// input against, the name for error messages, and the type to pick the validator
-// and storage column. All columns on members_custom_fields, so a value operation
-// resolves them with a direct query rather than routing through the definitions
-// service — the same way the read path already joins the table directly.
 interface ActiveField {
     id: string;
     key: string;
@@ -32,30 +39,20 @@ interface ActiveField {
     type: FieldType;
 }
 
-// A resolved, validated write. `value` absent means clear (delete the row).
+/** An absent `value` means clear the field. */
 interface PlannedWrite {
     field: ActiveField;
     value?: unknown;
 }
 
 /**
- * The value half of member custom fields: reading and writing what a member holds
- * for each defined field. It belongs to the member aggregate — a value is data
- * about a member — while field definitions belong to the site's settings; that
- * aggregate boundary, not a technical layer, is why this is a separate service.
- *
- * It owns the `members_custom_field_values` table and reads `members_custom_fields`
- * directly for the reference data it needs (which fields are active, and how they
- * validate), rather than calling the definitions service — the same way the other
- * knex services here talk to the database.
+ * What a member holds for each defined field. Separate from the definitions service
+ * because a value belongs to the member and a definition belongs to the site's settings,
+ * which are different aggregates rather than different layers.
  */
 export class CustomFieldValuesService {
     private knex: Knex;
-    /**
-     * @private
-     * A getter rather than a number: the ceiling is an operator setting that can
-     * change between requests.
-     */
+    /** A getter, not a number: the ceiling is an operator setting that changes between requests. */
     private getMaxDefinitions: () => number;
 
     constructor({knex, getMaxDefinitions}: {knex: Knex, getMaxDefinitions: () => number}) {
@@ -63,11 +60,6 @@ export class CustomFieldValuesService {
         this.getMaxDefinitions = getMaxDefinitions;
     }
 
-    /**
-     * The active fields for a set of keys, keyed by key, for resolving a write.
-     * Scoped to the keys the caller is actually writing rather than every active
-     * field, since a publisher may have defined many and an edit touches few.
-     */
     private async activeFieldsByKey(keys: string[]): Promise<Map<string, ActiveField>> {
         if (keys.length === 0) {
             return new Map();
@@ -79,63 +71,39 @@ export class CustomFieldValuesService {
     }
 
     /**
-     * Members' values for every active field, keyed by member id, then by field
-     * key. A member with no values is absent from the outer map; a field a member
-     * has no value for is absent from the inner one — "not set" is the absence of
-     * a key, told apart from a value by not being there. Archived fields are
-     * excluded to match the definitions `browse`: their values stay in the
-     * database, they just stop being addressable.
-     *
-     * One query for the whole set, so a member list can't turn into an N+1.
+     * Members' values, keyed by member id then field key; anything absent is unset.
      *
-     * Reading is best-effort per value: a stored value whose type has since left
-     * the catalog, or that won't decode, is omitted and logged rather than failing
-     * the whole read. Stored data outlives the catalog, so one stale row must not
-     * take down a member's payload.
+     * Archived fields are excluded to match the definitions browse: their values stay in
+     * the database and stop being addressable. A row that will not parse is dropped and
+     * logged rather than failing the read, so one stale row cannot take down a member.
      */
     async getValuesForMembers(memberIds: string[]): Promise<Map<string, Record<string, unknown>>> {
-        const byMember = new Map<string, Record<string, unknown>>();
         if (memberIds.length === 0) {
-            return byMember;
+            return new Map();
         }
 
         const rows = await this.knex(VALUES_TABLE)
             .join(FIELDS_TABLE, `${VALUES_TABLE}.custom_field_id`, `${FIELDS_TABLE}.id`)
             .whereIn(`${VALUES_TABLE}.member_id`, memberIds)
-            // Read join, so the status filter is qualified and lives inline — it
-            // shares the invariant's vocabulary with queries.ts, not its builder.
             .where(`${FIELDS_TABLE}.status`, FIELD_STATUS.active)
             .orderBy(`${FIELDS_TABLE}.created_at`, 'asc')
             .orderBy(`${FIELDS_TABLE}.id`, 'asc')
-            .select(`${VALUES_TABLE}.member_id`, `${FIELDS_TABLE}.key`, `${FIELDS_TABLE}.type`, `${VALUES_TABLE}.value_text`, `${VALUES_TABLE}.value_json`);
+            .orderBy(`${VALUES_TABLE}.path`, 'asc')
+            .select(`${VALUES_TABLE}.member_id`, `${FIELDS_TABLE}.key`, `${FIELDS_TABLE}.type`, `${VALUES_TABLE}.path`, `${VALUES_TABLE}.value_text`);
 
+        const leaves: StoredLeaf[] = [];
         for (const row of rows) {
             try {
-                const {member_id: memberId, key, type, ...stored} = DbCustomFieldValueWithField.parse(row);
-                const codec = storageCodecFor(type);
-                const raw = stored[codec.column];
-                // The column the type routes to is the only one that can hold this
-                // field's value; a null there means the row is not carrying one.
-                if (raw === null) {
-                    continue;
-                }
-                const values = byMember.get(memberId) ?? {};
-                values[key] = codec.decode(raw);
-                byMember.set(memberId, values);
+                leaves.push(DbCustomFieldLeaf.parse(row));
             } catch (err) {
-                logging.warn(`Skipping undecodable custom field value (field '${row.key}', type '${row.type}'): ${err instanceof Error ? err.message : String(err)}`);
+                logging.warn(`Skipping unreadable custom field value (field '${row.key}', path '${row.path}'): ${err instanceof Error ? err.message : String(err)}`);
             }
         }
 
-        return byMember;
+        return valuesFromLeaves(leaves);
     }
 
-    /**
-     * @private
-     * Input as the values object it claims to be, rejecting anything that isn't
-     * one. Shared by every caller so they cannot disagree on what a values object
-     * is, or on the error when it isn't one.
-     */
+    /** Shared by every caller so they cannot disagree on what a values object is. */
     private parseValues(input: unknown): Record<string, unknown> {
         const parsed = ValuesInput.safeParse(input);
         if (!parsed.success) {
@@ -146,12 +114,8 @@ export class CustomFieldValuesService {
     }
 
     /**
-     * Whether input names any values. An absent key names none; anything present
-     * that isn't a values object throws, with the same error resolving it would
-     * have raised.
-     *
-     * Answers the shape question alone, with no catalog lookup, so it can be asked
-     * before a write is known to be permitted.
+     * Whether input names any values. Asks the shape question alone, with no catalog
+     * lookup, so it can be asked before a write is known to be permitted.
      */
     namesValues(input: unknown): boolean {
         if (input === undefined) {
@@ -162,20 +126,16 @@ export class CustomFieldValuesService {
     }
 
     /**
-     * Resolve input into the writes it implies, rejecting anything invalid, and
-     * writing nothing. Returned so a caller can validate before it commits to a
-     * change it would have to unwind (the member edit and the importer both validate
-     * up front, before opening a transaction), then apply the same plan without
-     * re-resolving or re-validating.
+     * Resolve input into the writes it implies, writing nothing. Returned so a caller can
+     * validate before opening a transaction it would otherwise have to unwind, then apply
+     * the same plan without re-resolving it.
      */
     async planWrite(input: unknown): Promise<PlannedWrite[]> {
         const values = this.parseValues(input);
         const keys = Object.keys(values);
 
-        // A write cannot name more fields than the site may define, so the
-        // definitions ceiling bounds it. This also holds the lookup below within the
-        // database driver's bound-parameter limit, which one key per parameter would
-        // otherwise exceed.
+        // Bounded by the definitions ceiling, which also holds the lookup below inside
+        // the driver's bound-parameter limit.
         const maxKeys = this.getMaxDefinitions();
         if (keys.length > maxKeys) {
             throw new errors.ValidationError({
@@ -190,29 +150,29 @@ export class CustomFieldValuesService {
         for (const [key, raw] of Object.entries(values)) {
             const field = byKey.get(key);
             if (!field) {
-                // Unknown (or archived) key. Rejected rather than ignored: a typo
-                // that silently drops a value is worse than a failed save.
+                // Unknown or archived. Refused rather than ignored: a typo that silently
+                // drops what somebody typed is worse than a save that fails. The catalog
+                // applies the same rule to the parts of a composite value.
                 throw new errors.ValidationError({message: `Unknown custom field: ${key}`, property: `custom_fields.${key}`});
             }
 
-            // `null` clears any field. An empty string clears a text-backed field —
-            // an emptied input — but for any other storage type '' is a value to
-            // validate, not a clear, so nothing is coerced: a string sent to a
-            // (future) non-text field fails validation rather than silently deleting.
-            if (raw === null || (raw === '' && FIELD_TYPES[field.type].storageType === 'text')) {
+            // `null` clears any field, and `''` clears one with no parts. For a value
+            // with parts `''` names nothing, so it is left to fail validation rather than
+            // being read as a silent delete.
+            if (raw === null || (raw === '' && subFieldsOf(field.type) === null)) {
                 writes.push({field});
                 continue;
             }
 
-            // The field type owns what a valid value is — core just runs it. For a
-            // composite the issue path points at the offending sub-field, so the
-            // property reads `custom_fields.home_address.postal_code`.
+            // Message only, no `context`: the API error handler moves a message into
+            // `context` when `context` is empty and prepends it when it is not, so
+            // anything added here reaches the client glued to the front of the reason.
+            // Which field failed rides in `property`.
             const value = FIELD_TYPES[field.type].value.safeParse(raw);
             if (!value.success) {
                 const issue = value.error.issues[0];
                 throw new errors.ValidationError({
-                    message: `Invalid value for custom field '${field.name}'.`,
-                    context: issue.message,
+                    message: issue.message,
                     property: [`custom_fields.${key}`, ...issue.path].join('.')
                 });
             }
@@ -225,39 +185,81 @@ export class CustomFieldValuesService {
     /**
      * Apply a plan from `planWrite`.
      *
-     * Merge, not replace: only the fields in the plan are touched, so a caller
-     * that doesn't know about a field can't erase it.
+     * A write touches the paths it names and nothing else, at every level: naming a path
+     * with an empty value clears that part, naming the field with `null` clears all of
+     * them, and saying nothing about a path leaves it alone. There is no whole-value
+     * replace, so a caller that does not know about a field cannot erase it.
      *
-     * Always transactional, so a mid-batch failure rolls the batch back. Passed an
-     * executor it joins that transaction -- the importer passes its per-member one, so a
-     * failed value write takes the member with it; passed nothing it opens its own.
+     * Always transactional. Given an executor it joins that transaction, so the importer's
+     * failed value write takes its member with it; given none it opens its own.
      */
-    async applyWrite(memberId: string, writes: PlannedWrite[], executor: Knex = this.knex): Promise<void> {
+    async applyWrite(
+        memberId: string,
+        writes: PlannedWrite[],
+        {executor = this.knex}: {executor?: Knex} = {}
+    ): Promise<void> {
         if (writes.length === 0) {
             return;
         }
 
         const apply = async (trx: Knex) => {
-            for (const {field, value} of writes) {
-                const target = {member_id: memberId, custom_field_id: field.id};
+            // Built first, then sent as whole statements: a handful per member rather
+            // than one per part, under one timestamp, because a write happened once
+            // however many rows record it.
+            const now = new Date();
+            const clearedFields: string[] = [];
+            const clearedPaths: Array<{fieldId: string, paths: string[]}> = [];
+            const rows: DbLeafRow[] = [];
 
+            for (const {field, value} of writes) {
                 if (value === undefined) {
-                    await trx(VALUES_TABLE).where(target).del();
+                    clearedFields.push(field.id);
                     continue;
                 }
 
-                const valueColumns = storageColumnsFor(field.type, value);
-                await trx(VALUES_TABLE)
-                    .insert({id: new ObjectID().toHexString(), ...target, ...valueColumns, created_at: new Date()})
-                    // The unique index on (member_id, custom_field_id) is
-                    // what makes this an upsert rather than a read-then-write race.
-                    .onConflict(['member_id', 'custom_field_id'])
-                    .merge({...valueColumns, updated_at: new Date()});
+                const {set, cleared} = leavesToWrite(value);
+                if (cleared.length > 0) {
+                    clearedPaths.push({fieldId: field.id, paths: cleared});
+                }
+
+                rows.push(...set.map(leaf => ({
+                    id: new ObjectID().toHexString(),
+                    member_id: memberId,
+                    custom_field_id: field.id,
+                    path: leaf.path,
+                    value_text: leaf.value_text,
+                    created_at: now,
+                    updated_at: now
+                })));
+            }
+
+            if (clearedFields.length > 0) {
+                await trx(VALUES_TABLE).where('member_id', memberId).whereIn('custom_field_id', clearedFields).del();
+            }
+
+            if (clearedPaths.length > 0) {
+                // One statement with a group per field, rather than a statement per field.
+                await trx(VALUES_TABLE).where('member_id', memberId).where((builder) => {
+                    for (const {fieldId, paths} of clearedPaths) {
+                        builder.orWhere(pair => pair.where('custom_field_id', fieldId).whereIn('path', paths));
+                    }
+                }).del();
+            }
+
+            for (let from = 0; from < rows.length; from += UPSERT_CHUNK) {
+                // Typed as the plain row because `merge` takes its columns as `keyof` the
+                // builder's record, which for a composite table registration is the scope
+                // names rather than the columns.
+                await trx<DbLeafRow>(VALUES_TABLE)
+                    .insert(rows.slice(from, from + UPSERT_CHUNK))
+                    // Naming the columns rather than giving values takes each from the row
+                    // that lost the conflict, so every part updates to its own value.
+                    .onConflict(['member_id', 'custom_field_id', 'path'])
+                    .merge(['value_text', 'updated_at']);
             }
         };
 
-        // isTransaction is knex's marker for a transactor: join an existing transaction
-        // rather than nesting a savepoint under it, otherwise open one.
+        // knex's marker for a transactor: join it rather than nesting a savepoint under it.
         if (executor.isTransaction) {
             await apply(executor);
         } else {

package/core/server/services/mentions/resource-service.js

@@ -30,7 +30,7 @@ module.exports = class ResourceService {
      */
     async getByURL(url) {
         const path = this.#urlUtils.absoluteToRelative(url.href, {withoutSubdirectory: true});
-        const resource = await this.#urlService.facade.resolveUrl(path);
+        const resource = await this.#urlService.resolveUrl(path);
         if (resource?.type === 'posts') {
             return {
                 type: 'post',

package/core/server/services/mentions/service.js

@@ -20,7 +20,7 @@ const jobsService = require('../mentions-jobs');
 // relations it reads for filtered collections (event-emitted models don't
 // reliably carry them).
 async function getPostData(post) {
-    const missing = urlService.facade.getRequiredRelations().filter(relation => !post.relations[relation]);
+    const missing = urlService.getRequiredRelations().filter(relation => !post.relations[relation]);
     if (missing.length) {
         await post.load(missing);
     }
@@ -31,7 +31,7 @@ function getPostUrl(id, postData) {
     const jsonModel = {...postData};
     // The URL service routes by resource type. Pages and posts share the Post
     // model, so the page's own type must reach forPost — otherwise it defaults
-    // to 'posts', matches no post collection, and 404s under the lazy service.
+    // to 'posts', matches no post collection, and 404s.
     const type = postData.type === 'page' ? 'pages' : 'posts';
     outputSerializerUrlUtil.forPost(id, jsonModel, {options: {}}, type);
     return jsonModel.url;

package/core/server/services/oembed/oembed-service.js

@@ -9,6 +9,7 @@ const charset = require('charset');
 const iconv = require('iconv-lite');
 const path = require('path');
 const crypto = require('crypto');
+const imageTransform = require('@tryghost/image-transform');
 
 // Some sites block non-standard user agents so we need to mimic a typical browser
 // Note: the Ghost/5.0 string _may_ be in use by 3rd parties so use caution when updating across majors
@@ -39,7 +40,26 @@ const messages = {
     insufficientMetadata: 'URL contains insufficient metadata.',
     unknownProvider: 'No provider found for supplied URL.',
     unableToFetchOembed: 'Unable to fetch requested embed.',
-    unauthorized: 'URL contains a private resource.'
+    unauthorized: 'URL contains a private resource.',
+    unconvertibleSvg: 'SVG image is too large or compressed to convert.'
+};
+
+const SVG_RASTER_SIZE = 256;
+const SVG_RASTER_TIMEOUT_SECONDS = 10;
+const MAX_SVG_BYTES = 32 * 1024;
+const GZIP_MAGIC = [0x1f, 0x8b];
+
+const SVG_EXTENSIONS = new Set(['.svg', '.svgz']);
+const SVG_SNIFF_BYTES = 1024;
+
+const shouldRasterize = (buffer, ext) => {
+    if (SVG_EXTENSIONS.has(ext.toLowerCase())) {
+        return true;
+    }
+
+    const head = buffer.subarray(0, SVG_SNIFF_BYTES).toString('utf8').trimStart();
+
+    return head.startsWith('<') && /<svg[\s:>]/i.test(head);
 };
 
 /**
@@ -175,14 +195,35 @@ class OEmbedService {
         }
 
         // Fetch image buffer from the URL
-        const imageBuffer = await this.fetchImageBuffer(imageUrl);
+        let imageBuffer = await this.fetchImageBuffer(imageUrl);
 
         // Extract file name from URL
         const fileName = path.basename(new URL(imageUrl).pathname);
-        const ext = path.extname(fileName);
+        let ext = path.extname(fileName);
         const baseName = ext ? path.basename(fileName, ext) : fileName;
         const name = this.imageStore.getSanitizedFileName(baseName);
 
+        if (shouldRasterize(imageBuffer, ext)) {
+            if (imageBuffer.length > MAX_SVG_BYTES || GZIP_MAGIC.every((byte, index) => imageBuffer[index] === byte)) {
+                throw new errors.ValidationError({
+                    message: tpl(messages.unconvertibleSvg),
+                    context: imageUrl
+                });
+            }
+
+            imageBuffer = await imageTransform.resizeFromBuffer(imageBuffer, {
+                // without `format` this returns the original bytes whenever they
+                // are smaller, storing the SVG under a .png name
+                format: 'png',
+                width: SVG_RASTER_SIZE,
+                height: SVG_RASTER_SIZE,
+                withoutEnlargement: false,
+                timeout: SVG_RASTER_TIMEOUT_SECONDS
+            });
+
+            ext = '.png';
+        }
+
         const uniqueFileName = `${name}-${crypto.randomUUID()}${ext}`;
         const targetPath = path.join(imageType, uniqueFileName);
 

package/core/server/services/posts/posts-service.js

@@ -312,6 +312,17 @@ class PostsService {
             });
         }
 
+        // The `comments.in_reply_to_id` references form chains between a post's
+        // comments, which MySQL cannot resolve while cascade-deleting them
+        // alongside `comments.parent_id`. Clear the references first so the
+        // `comments.post_id` cascade delete can do its job
+        await this.models.Post.bulkEdit(deleteIds, 'comments', {
+            data: {in_reply_to_id: null},
+            column: 'post_id',
+            transacting: options.transacting,
+            throwErrors: true
+        });
+
         // Posts and emails
         await this.models.Post.bulkDestroy(deleteEmailIds, 'emails', {transacting: options.transacting, throwErrors: true});
         const result = await this.models.Post.bulkDestroy(deleteIds, 'posts', {...options, throwErrors: true});

package/core/server/services/route-settings/dynamic-routing-service.js

@@ -1,11 +1,6 @@
 const debug = require('@tryghost/debug')('services:route-settings:service');
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
-const tpl = require('@tryghost/tpl');
-
-const messages = {
-    loadError: 'Could not load routes.yaml file.'
-};
 
 function isStoredContentError(err) {
     return err.errorType === 'ValidationError' || err.errorType === 'IncorrectUsageError';
@@ -25,8 +20,7 @@ class DynamicRoutingService {
 
     /**
      * Wire the storage-layer dependency so the API surface (upload, download)
-     * works immediately after boot — even when the frontend is disabled and
-     * `start()` is never called.
+     * works from early boot, well before `start()` wires up routing.
      *
      * @param {object} deps
      * @param {RouteSettingsStore} deps.store - adapter-manager provided store
@@ -38,11 +32,13 @@ class DynamicRoutingService {
 
     /**
      * Wire the routing dependencies and load route settings into the router.
-     * Called from initDynamicRouting in boot.js — only when the frontend is enabled.
+     * Called from initDynamicRouting in boot.js on every boot: the URL service
+     * has to learn the routes even where no page is served, so that the APIs and
+     * background services can build URLs.
      *
      * @param {object} deps
      * @param {object} deps.routerManager - frontend RouterManager singleton
-     * @param {object} deps.urlService    - UrlServiceFacade
+     * @param {object} deps.urlService    - the URL service singleton
      */
     async start({routerManager, urlService}) {
         debug('start');
@@ -54,10 +50,8 @@ class DynamicRoutingService {
     }
 
     async loadRouteSettings() {
-        const {buildRouterSettings} = require('./activation-bridge');
-
         try {
-            return buildRouterSettings(await this.store.get());
+            return await this.store.get();
         } catch (err) {
             // A stored-content error means the site's routes.yaml is invalid —
             // either it fails validation or it isn't parseable YAML. Log a
@@ -92,60 +86,14 @@ class DynamicRoutingService {
         // Parse and validate before anything is persisted — an invalid
         // upload is rejected here and never reaches the store.
         const next = parseRouteSettings(parseYaml(yamlContent), yamlContent);
-        let previous = null;
-        try {
-            previous = await this.store.get();
-        } catch (err) {
-            if (!isStoredContentError(err)) {
-                throw err;
-            }
-        }
 
         await this.store.replace(next);
 
-        urlService.resetGenerators({releaseResourcesOnly: true});
-
-        const bringBackValidRoutes = async () => {
-            urlService.resetGenerators({releaseResourcesOnly: true});
-
-            if (previous) {
-                await this.store.replace(previous);
-            }
-
-            return bridge.reloadFrontend(this, urlService);
-        };
-
+        // Registration is synchronous inside the reload: RouterManager.start()
+        // always mounts the static pages router, which has permalinks, so the
+        // URL service has routers again — and reports ready — by the time this
+        // resolves. Nothing left to wait for.
         await bridge.reloadFrontend(this, urlService);
-
-        let tries = 0;
-
-        function isBlogRunning() {
-            debug('waiting for blog running');
-            return new Promise((resolve) => {
-                setTimeout(resolve, 1000);
-            })
-                .then(() => {
-                    debug('waited for blog running');
-                    if (!urlService.hasFinished()) {
-                        if (tries > 5) {
-                            throw new errors.InternalServerError({
-                                message: tpl(messages.loadError)
-                            });
-                        }
-
-                        tries = tries + 1;
-                        return isBlogRunning();
-                    }
-                });
-        }
-
-        return isBlogRunning()
-            .catch((err) => {
-                return bringBackValidRoutes()
-                    .finally(() => {
-                        throw err;
-                    });
-            });
     }
 }