ghost 6.57.1 → 6.58.0

package/core/server/adapters/redirects/FileStore.ts

@@ -1,113 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import {RedirectsStoreBase, RedirectConfig} from '@tryghost/adapter-base-redirects'
-
-import {parseJson, parseYaml} from '../../services/custom-redirects/redirect-config-parser';
-import {getBackupRedirectsFilePath} from '../../services/custom-redirects/utils';
-
-const YAML_FILENAME = 'redirects.yaml';
-const JSON_FILENAME = 'redirects.json';
-
-interface FileStoreOptions {
-    basePath: string;
-    getBackupFilePath?: (filePath: string) => string;
-}
-
-/**
- * Reads existing `.yaml` and `.json` configs (backward-compatible with
- * pre-refactor self-hosted installs) and always writes new configs as
- * `.json`. The previous canonical file becomes a timestamped backup on
- * every successive `replaceAll`.
- */
-export default class FileStore extends RedirectsStoreBase {
-    private readonly basePath: string;
-    private readonly getBackupFilePath: (filePath: string) => string;
-
-    constructor({basePath, getBackupFilePath = getBackupRedirectsFilePath}: FileStoreOptions) {
-        super();
-        this.basePath = basePath;
-        this.getBackupFilePath = getBackupFilePath;
-    }
-
-    async getAll(): Promise<RedirectConfig[]> {
-        const existingPath = await this._findExistingFile();
-        if (!existingPath) {
-            return [];
-        }
-
-        const content = await fs.readFile(existingPath, 'utf-8');
-
-        return path.extname(existingPath) === '.yaml'
-            ? parseYaml(content)
-            : parseJson(content);
-    }
-
-    async replaceAll(redirects: RedirectConfig[]): Promise<void> {
-        const existingPath = await this._findExistingFile();
-        const targetPath = path.join(this.basePath, JSON_FILENAME);
-
-        // The ordering here keeps the canonical path readable across
-        // every failure mode. See the inline notes — the obvious
-        // backup-first, write-second sequence would wipe redirects on
-        // a failed write.
-
-        // Same path: backup must happen before the atomic write because
-        // the rename would otherwise clobber the previous content with
-        // no copy elsewhere.
-        if (existingPath && existingPath === targetPath) {
-            const backupPath = this.getBackupFilePath(existingPath);
-            const content = await fs.readFile(existingPath, 'utf-8');
-            await this._writeAtomic(backupPath, content);
-        }
-
-        await this._writeAtomic(targetPath, JSON.stringify(redirects));
-
-        // Different path (yaml → json): backup must happen AFTER the
-        // write so a failed write doesn't leave nothing at any canonical
-        // path. If the backup itself fails, the legacy yaml takes
-        // precedence over the new json on next read — roll the new json
-        // back so the operator sees a consistent old state.
-        if (existingPath && existingPath !== targetPath) {
-            try {
-                await this._backup(existingPath);
-            } catch (err) {
-                await fs.remove(targetPath).catch(() => {});
-                throw err;
-            }
-        }
-    }
-
-    private async _findExistingFile(): Promise<string | null> {
-        const yamlPath = path.join(this.basePath, YAML_FILENAME);
-        if (await fs.pathExists(yamlPath)) {
-            return yamlPath;
-        }
-
-        const jsonPath = path.join(this.basePath, JSON_FILENAME);
-        if (await fs.pathExists(jsonPath)) {
-            return jsonPath;
-        }
-
-        return null;
-    }
-
-    private async _backup(existingPath: string): Promise<void> {
-        const backupPath = this.getBackupFilePath(existingPath);
-        // Per-second timestamp granularity → same-second writes collide.
-        // Overwrite rather than fail.
-        await fs.move(existingPath, backupPath, {overwrite: true});
-    }
-
-    // `fs-extra.move({overwrite: true})` handles the Windows EPERM/EEXIST
-    // path that bare `fs.rename` doesn't.
-    private async _writeAtomic(targetPath: string, content: string): Promise<void> {
-        const tmpPath = `${targetPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-        await fs.writeFile(tmpPath, content, 'utf-8');
-        try {
-            await fs.move(tmpPath, targetPath, {overwrite: true});
-        } catch (err) {
-            await fs.remove(tmpPath).catch(() => {});
-            throw err;
-        }
-    }
-}

package/core/server/adapters/redirects/S3RedirectsStore.ts

@@ -1,185 +0,0 @@
-import {
-    CopyObjectCommand,
-    GetObjectCommand,
-    HeadObjectCommand,
-    NoSuchKey,
-    NotFound,
-    PutObjectCommand,
-    S3Client,
-    S3ClientConfig
-} from '@aws-sdk/client-s3';
-import {z} from 'zod';
-import tpl from '@tryghost/tpl';
-import * as errors from '@tryghost/errors';
-import {RedirectsStoreBase, type RedirectConfig} from '@tryghost/adapter-base-redirects';
-
-import {parseJson} from '../../services/custom-redirects/redirect-config-parser';
-import {getBackupRedirectsFilePath} from '../../services/custom-redirects/utils';
-
-const DEFAULT_FILENAME = 'redirects.json';
-
-const messages = {
-    missingBucket: 'S3RedirectsStore requires a bucket name',
-    missingStaticFileURLPrefix: 'S3RedirectsStore requires a staticFileURLPrefix',
-    partialCredentials: 'S3RedirectsStore requires both accessKeyId and secretAccessKey when either is provided',
-    missingResponseBody: 'S3 GetObject returned no body'
-};
-
-const stripLeadingAndTrailingSlashes = (value = '') => value.replace(/^\/+|\/+$/g, '');
-
-// Validates and normalises the config: the slash-trimmed fields
-// (`staticFileURLPrefix`, `tenantPrefix`) are stripped via `transform` so the
-// constructor consumes ready-to-use values, plus the credential-pair rule
-// (accessKeyId and secretAccessKey must be supplied together).
-const configSchema = z.object({
-    bucket: z.string({error: tpl(messages.missingBucket)}).min(1, {error: tpl(messages.missingBucket)}),
-    staticFileURLPrefix: z.string({error: tpl(messages.missingStaticFileURLPrefix)})
-        .transform(stripLeadingAndTrailingSlashes)
-        .refine(value => value.length > 0, {error: tpl(messages.missingStaticFileURLPrefix)}),
-    tenantPrefix: z.string().transform(stripLeadingAndTrailingSlashes).optional(),
-    region: z.string().optional(),
-    endpoint: z.string().optional(),
-    forcePathStyle: z.boolean().optional(),
-    accessKeyId: z.string().optional(),
-    secretAccessKey: z.string().optional(),
-    sessionToken: z.string().optional()
-}).refine((config) => {
-    // accessKeyId and secretAccessKey must be supplied together (or not at all).
-    const hasAccessKey = Boolean(config.accessKeyId);
-    const hasSecretKey = Boolean(config.secretAccessKey);
-    const hasSessionToken = Boolean(config.sessionToken);
-    const hasCredentialPair = hasAccessKey && hasSecretKey;
-    return !((hasAccessKey || hasSecretKey || hasSessionToken) && !hasCredentialPair);
-}, {error: tpl(messages.partialCredentials)});
-
-export type S3RedirectsStoreOptions = z.infer<typeof configSchema>;
-
-/**
- * Implements RedirectsStore against an S3-compatible bucket. Reads and
- * writes a single JSON object at the configured key, keeping a
- * timestamped server-side copy of the previous contents on each
- * overwrite.
- */
-export default class S3RedirectsStore extends RedirectsStoreBase {
-    private readonly client: S3Client;
-    private readonly bucket: string;
-    private readonly staticFileURLPrefix: string;
-    private readonly tenantPrefix: string;
-
-    /**
-     * Parse + normalise the config, throwing an actionable IncorrectUsageError
-     * on the first problem. Shared by `validate` (boot-time check) and the
-     * constructor (which uses the normalised result).
-     */
-    private static parseConfig(config: unknown): z.infer<typeof configSchema> {
-        const result = configSchema.safeParse(config);
-        if (!result.success) {
-            throw new errors.IncorrectUsageError({
-                message: [...new Set(result.error.issues.map(issue => issue.message))].join('; ')
-            });
-        }
-        return result.data;
-    }
-
-    /**
-     * Validate the options S3RedirectsStore would be constructed with, without
-     * instantiating it (no S3 client is created). Called by the adapter manager
-     * at boot so misconfiguration fails early. Narrows `config` to
-     * `S3RedirectsStoreOptions`.
-     */
-    static validate(config: unknown): asserts config is S3RedirectsStoreOptions {
-        S3RedirectsStore.parseConfig(config);
-    }
-
-    constructor(config: unknown) {
-        super();
-
-        const options = S3RedirectsStore.parseConfig(config);
-
-        const hasCredentialPair = Boolean(options.accessKeyId) && Boolean(options.secretAccessKey);
-
-        this.bucket = options.bucket;
-        this.staticFileURLPrefix = options.staticFileURLPrefix;
-        this.tenantPrefix = options.tenantPrefix ?? '';
-
-        const clientConfig: S3ClientConfig = {
-            region: options.region,
-            endpoint: options.endpoint,
-            forcePathStyle: options.forcePathStyle
-        };
-        if (hasCredentialPair) {
-            clientConfig.credentials = {
-                accessKeyId: options.accessKeyId!,
-                secretAccessKey: options.secretAccessKey!,
-                sessionToken: options.sessionToken
-            };
-        }
-        this.client = new S3Client(clientConfig);
-    }
-
-    async getAll(): Promise<RedirectConfig[]> {
-        let body: string;
-        try {
-            const response = await this.client.send(new GetObjectCommand({
-                Bucket: this.bucket,
-                Key: this.buildKey()
-            }));
-            if (!response.Body) {
-                throw new errors.InternalServerError({
-                    message: tpl(messages.missingResponseBody)
-                });
-            }
-            body = await response.Body.transformToString('utf-8');
-        } catch (err) {
-            if (this._isNotFound(err)) {
-                return [];
-            }
-            throw err;
-        }
-
-        return parseJson(body);
-    }
-
-    async replaceAll(redirects: RedirectConfig[]): Promise<void> {
-        const key = this.buildKey();
-
-        if (await this._canonicalExists()) {
-            await this.client.send(new CopyObjectCommand({
-                Bucket: this.bucket,
-                Key: getBackupRedirectsFilePath(key),
-                CopySource: `${this.bucket}/${key}`
-            }));
-        }
-
-        await this.client.send(new PutObjectCommand({
-            Bucket: this.bucket,
-            Key: key,
-            Body: JSON.stringify(redirects),
-            ContentType: 'application/json'
-        }));
-    }
-
-    private buildKey(): string {
-        const parts = [this.tenantPrefix, this.staticFileURLPrefix, DEFAULT_FILENAME].filter(Boolean);
-        return parts.join('/');
-    }
-
-    private async _canonicalExists(): Promise<boolean> {
-        try {
-            await this.client.send(new HeadObjectCommand({
-                Bucket: this.bucket,
-                Key: this.buildKey()
-            }));
-            return true;
-        } catch (err) {
-            if (this._isNotFound(err)) {
-                return false;
-            }
-            throw err;
-        }
-    }
-
-    private _isNotFound(err: unknown): boolean {
-        return err instanceof NotFound || err instanceof NoSuchKey;
-    }
-}

package/core/server/adapters/route-settings/FileStore.ts

@@ -1,144 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import {z} from 'zod';
-import * as errors from '@tryghost/errors';
-import tpl from '@tryghost/tpl';
-
-import {RouteSettingsStoreBase, type RouteSettings} from '@tryghost/adapter-base-route-settings';
-
-import parseYaml from '../../services/route-settings/yaml-parser';
-import {parseRouteSettings} from '../../services/route-settings/route-settings-parser';
-import {getBackupRouteSettingsFilePath} from './utils';
-
-const YAML_FILENAME = 'routes.yaml';
-const DEFAULT_SETTINGS_FILENAME = 'default-routes.yaml';
-
-const messages = {
-    missingPaths: 'FileStore requires basePath and defaultSettingsBasePath.',
-    ensureSettings: 'Error trying to access settings files in {path}.'
-};
-
-// Validates the required paths sourced from config. Used by `FileStore.validate`.
-const configSchema = z.object({
-    basePath: z.string({error: tpl(messages.missingPaths)}).min(1, {error: tpl(messages.missingPaths)}),
-    defaultSettingsBasePath: z.string({error: tpl(messages.missingPaths)}).min(1, {error: tpl(messages.missingPaths)})
-});
-
-type FileStoreOptions = z.infer<typeof configSchema>;
-
-/**
- * Local-disk store for route settings. Reads and writes the user's
- * original `routes.yaml` verbatim — comments, ordering and formatting are
- * preserved because we persist `settings.yamlSource` (the exact bytes the
- * domain model was parsed from) rather than a re-serialised model. Every
- * `replace` turns the previous file into a timestamped backup. When no
- * `routes.yaml` exists the parsed bundled defaults are returned without
- * touching the disk; a real file only materialises on the first `replace`.
- */
-export default class FileStore extends RouteSettingsStoreBase {
-    private readonly basePath: string;
-    private readonly defaultSettingsBasePath: string;
-    private readonly getBackupFilePath: (filePath: string) => string;
-
-    /**
-     * Validate the options FileStore would be constructed with, without
-     * instantiating it. Called by the adapter manager at boot so
-     * misconfiguration fails early, and by the constructor so the two share a
-     * single source of truth. Narrows `config` to `FileStoreOptions`.
-     */
-    static validate(config: unknown): asserts config is FileStoreOptions {
-        const result = configSchema.safeParse(config);
-        if (!result.success) {
-            throw new errors.IncorrectUsageError({
-                message: [...new Set(result.error.issues.map(issue => issue.message))].join('; ')
-            });
-        }
-    }
-
-    constructor(config: unknown) {
-        super();
-
-        FileStore.validate(config);
-        this.basePath = config.basePath;
-        this.defaultSettingsBasePath = config.defaultSettingsBasePath;
-
-        // `getBackupFilePath` is a test-only injection seam — it never comes from
-        // config (nconf holds static values), so it's read from the raw input
-        // rather than the validated schema output.
-        this.getBackupFilePath = (config as {getBackupFilePath?: (filePath: string) => string}).getBackupFilePath
-            ?? getBackupRouteSettingsFilePath;
-    }
-
-    async get(): Promise<RouteSettings> {
-        const yamlPath = path.join(this.basePath, YAML_FILENAME);
-        const yamlContent = await this.readIfExists(yamlPath);
-        if (yamlContent !== null) {
-            return parseRouteSettings(parseYaml(yamlContent), yamlContent);
-        }
-
-        const defaultContent = await this.readDefaultSettings();
-        return parseRouteSettings(parseYaml(defaultContent), defaultContent);
-    }
-
-    async replace(settings: RouteSettings): Promise<void> {
-        const targetPath = path.join(this.basePath, YAML_FILENAME);
-
-        // Back up the current file before the atomic write clobbers it. The
-        // content is captured up front so the backup holds exactly what was on
-        // disk; a file that isn't there just skips the backup and real read
-        // failures surface as typed errors.
-        const existing = await this.readIfExists(targetPath);
-        if (existing !== null) {
-            await this.writeAtomic(this.getBackupFilePath(targetPath), existing);
-        }
-
-        // Persist the exact YAML the operator authored — never a re-serialised
-        // model — so comments, key order and formatting survive a round-trip.
-        await this.writeAtomic(targetPath, settings.yamlSource);
-    }
-
-    private async readIfExists(filePath: string): Promise<string | null> {
-        try {
-            return await fs.readFile(filePath, 'utf8');
-        } catch (err) {
-            if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-                return null;
-            }
-
-            throw new errors.InternalServerError({
-                message: tpl(messages.ensureSettings, {path: this.basePath}),
-                err: err as Error,
-                context: (err as NodeJS.ErrnoException).path
-            });
-        }
-    }
-
-    private async readDefaultSettings(): Promise<string> {
-        const defaultFilePath = path.join(this.defaultSettingsBasePath, DEFAULT_SETTINGS_FILENAME);
-        try {
-            return await fs.readFile(defaultFilePath, 'utf8');
-        } catch (err) {
-            throw new errors.InternalServerError({
-                message: tpl(messages.ensureSettings, {path: this.defaultSettingsBasePath}),
-                err: err as Error,
-                context: (err as NodeJS.ErrnoException).path
-            });
-        }
-    }
-
-    private async writeAtomic(targetPath: string, content: string): Promise<void> {
-        const tmpPath = `${targetPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-        try {
-            await fs.ensureDir(path.dirname(targetPath));
-            await fs.writeFile(tmpPath, content, 'utf-8');
-            await fs.move(tmpPath, targetPath, {overwrite: true});
-        } catch (err) {
-            await fs.remove(tmpPath).catch(() => {});
-            throw new errors.InternalServerError({
-                message: tpl(messages.ensureSettings, {path: this.basePath}),
-                err: err as Error,
-                context: (err as NodeJS.ErrnoException).path
-            });
-        }
-    }
-}

package/core/server/adapters/route-settings/S3RouteSettingsStore.ts

@@ -1,199 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import {
-    CopyObjectCommand,
-    GetObjectCommand,
-    HeadObjectCommand,
-    NoSuchKey,
-    NotFound,
-    PutObjectCommand,
-    S3Client,
-    S3ClientConfig
-} from '@aws-sdk/client-s3';
-import {z} from 'zod';
-import tpl from '@tryghost/tpl';
-import * as errors from '@tryghost/errors';
-import {RouteSettingsStoreBase, type RouteSettings} from '@tryghost/adapter-base-route-settings';
-
-import parseYaml from '../../services/route-settings/yaml-parser';
-import {parseRouteSettings} from '../../services/route-settings/route-settings-parser';
-import {getBackupRouteSettingsFilePath} from './utils';
-
-const YAML_FILENAME = 'routes.yaml';
-const DEFAULT_SETTINGS_FILENAME = 'default-routes.yaml';
-
-const CONTENT_TYPE = 'application/yaml; charset=utf-8';
-
-const messages = {
-    missingBucket: 'S3RouteSettingsStore requires a bucket name',
-    missingStaticFileURLPrefix: 'S3RouteSettingsStore requires a staticFileURLPrefix',
-    missingDefaultSettingsBasePath: 'S3RouteSettingsStore requires a defaultSettingsBasePath',
-    partialCredentials: 'S3RouteSettingsStore requires both accessKeyId and secretAccessKey when either is provided',
-    missingResponseBody: 'S3 GetObject returned no body',
-    ensureDefaults: 'Error trying to access the default settings file in {path}.'
-};
-
-const stripLeadingAndTrailingSlashes = (value = '') => value.replace(/^\/+|\/+$/g, '');
-
-const configSchema = z.object({
-    bucket: z.string({error: tpl(messages.missingBucket)}).min(1, {error: tpl(messages.missingBucket)}),
-    staticFileURLPrefix: z.string({error: tpl(messages.missingStaticFileURLPrefix)})
-        .transform(stripLeadingAndTrailingSlashes)
-        .refine(value => value.length > 0, {error: tpl(messages.missingStaticFileURLPrefix)}),
-    defaultSettingsBasePath: z.string({error: tpl(messages.missingDefaultSettingsBasePath)})
-        .min(1, {error: tpl(messages.missingDefaultSettingsBasePath)}),
-    tenantPrefix: z.string().transform(stripLeadingAndTrailingSlashes).optional(),
-    region: z.string().optional(),
-    endpoint: z.string().optional(),
-    forcePathStyle: z.boolean().optional(),
-    accessKeyId: z.string().optional(),
-    secretAccessKey: z.string().optional(),
-    sessionToken: z.string().optional()
-}).refine((config) => {
-    const hasAccessKey = Boolean(config.accessKeyId);
-    const hasSecretKey = Boolean(config.secretAccessKey);
-    const hasSessionToken = Boolean(config.sessionToken);
-    const hasCredentialPair = hasAccessKey && hasSecretKey;
-    return !((hasAccessKey || hasSecretKey || hasSessionToken) && !hasCredentialPair);
-}, {error: tpl(messages.partialCredentials)});
-
-export type S3RouteSettingsStoreOptions = z.infer<typeof configSchema>;
-
-/**
- * Remote store for route settings backed by an S3-compatible bucket (MinIO in
- * tests, GCS in production). Reads and writes the operator's original
- * `routes.yaml` verbatim.
- */
-export default class S3RouteSettingsStore extends RouteSettingsStoreBase {
-    private readonly client: S3Client;
-    private readonly bucket: string;
-    private readonly staticFileURLPrefix: string;
-    private readonly tenantPrefix: string;
-    private readonly defaultSettingsBasePath: string;
-
-    private static parseConfig(config: unknown): z.infer<typeof configSchema> {
-        const result = configSchema.safeParse(config);
-        if (!result.success) {
-            throw new errors.IncorrectUsageError({
-                message: [...new Set(result.error.issues.map(issue => issue.message))].join('; ')
-            });
-        }
-        return result.data;
-    }
-
-    static validate(config: unknown): asserts config is S3RouteSettingsStoreOptions {
-        S3RouteSettingsStore.parseConfig(config);
-    }
-
-    constructor(config: unknown) {
-        super();
-
-        const options = S3RouteSettingsStore.parseConfig(config);
-
-        const hasCredentialPair = Boolean(options.accessKeyId) && Boolean(options.secretAccessKey);
-
-        this.bucket = options.bucket;
-        this.staticFileURLPrefix = options.staticFileURLPrefix;
-        this.tenantPrefix = options.tenantPrefix ?? '';
-        this.defaultSettingsBasePath = options.defaultSettingsBasePath;
-
-        const clientConfig: S3ClientConfig = {
-            region: options.region,
-            endpoint: options.endpoint,
-            forcePathStyle: options.forcePathStyle
-        };
-        if (hasCredentialPair) {
-            clientConfig.credentials = {
-                accessKeyId: options.accessKeyId!,
-                secretAccessKey: options.secretAccessKey!,
-                sessionToken: options.sessionToken
-            };
-        }
-
-        // `s3Client` is a test-only injection seam — it never comes from config
-        // (nconf holds static values), so it's read from the raw input rather
-        // than the validated schema output.
-        const injectedClient = (config as {s3Client?: S3Client} | null | undefined)?.s3Client;
-        this.client = injectedClient || new S3Client(clientConfig);
-    }
-
-    async get(): Promise<RouteSettings> {
-        let body: string;
-        try {
-            const response = await this.client.send(new GetObjectCommand({
-                Bucket: this.bucket,
-                Key: this.buildKey()
-            }));
-            if (!response.Body) {
-                throw new errors.InternalServerError({
-                    message: tpl(messages.missingResponseBody)
-                });
-            }
-            body = await response.Body.transformToString('utf-8');
-        } catch (err) {
-            if (this._isNotFound(err)) {
-                const defaultContent = await this.readDefaultSettings();
-                return parseRouteSettings(parseYaml(defaultContent), defaultContent);
-            }
-            throw err;
-        }
-
-        return parseRouteSettings(parseYaml(body), body);
-    }
-
-    async replace(settings: RouteSettings): Promise<void> {
-        const key = this.buildKey();
-
-        if (await this._canonicalExists()) {
-            await this.client.send(new CopyObjectCommand({
-                Bucket: this.bucket,
-                Key: getBackupRouteSettingsFilePath(key),
-                CopySource: `${this.bucket}/${key}`
-            }));
-        }
-
-        await this.client.send(new PutObjectCommand({
-            Bucket: this.bucket,
-            Key: key,
-            Body: settings.yamlSource,
-            ContentType: CONTENT_TYPE
-        }));
-    }
-
-    private buildKey(): string {
-        const parts = [this.tenantPrefix, this.staticFileURLPrefix, YAML_FILENAME].filter(Boolean);
-        return parts.join('/');
-    }
-
-    private async _canonicalExists(): Promise<boolean> {
-        try {
-            await this.client.send(new HeadObjectCommand({
-                Bucket: this.bucket,
-                Key: this.buildKey()
-            }));
-            return true;
-        } catch (err) {
-            if (this._isNotFound(err)) {
-                return false;
-            }
-            throw err;
-        }
-    }
-
-    private async readDefaultSettings(): Promise<string> {
-        const defaultFilePath = path.join(this.defaultSettingsBasePath, DEFAULT_SETTINGS_FILENAME);
-        try {
-            return await fs.readFile(defaultFilePath, 'utf8');
-        } catch (err) {
-            throw new errors.InternalServerError({
-                message: tpl(messages.ensureDefaults, {path: this.defaultSettingsBasePath}),
-                err: err as Error,
-                context: (err as NodeJS.ErrnoException).path
-            });
-        }
-    }
-
-    private _isNotFound(err: unknown): boolean {
-        return err instanceof NotFound || err instanceof NoSuchKey;
-    }
-}

package/core/server/adapters/route-settings/utils.ts

@@ -1,17 +0,0 @@
-import path from 'path';
-
-const pad = (value: number, length = 2): string => String(value).padStart(length, '0');
-
-const timestamp = (date: Date): string => [
-    pad(date.getFullYear(), 4),
-    pad(date.getMonth() + 1),
-    pad(date.getDate()),
-    pad(date.getHours()),
-    pad(date.getMinutes()),
-    pad(date.getSeconds())
-].join('-');
-
-export const getBackupRouteSettingsFilePath = (filePath: string): string => {
-    const {dir, name, ext} = path.parse(filePath);
-    return path.join(dir, `${name}-${timestamp(new Date())}${ext}`);
-};

package/core/server/adapters/scheduling/deps.d.ts

@@ -1 +0,0 @@
-declare module "@tryghost/request"