ghost 6.53.0 → 6.54.1

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

@@ -0,0 +1,199 @@
+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.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBackupRouteSettingsFilePath = void 0;
+const path_1 = __importDefault(require("path"));
+const date_fns_1 = require("date-fns");
+const getBackupRouteSettingsFilePath = (filePath) => {
+    const { dir, name, ext } = path_1.default.parse(filePath);
+    return path_1.default.join(dir, `${name}-${(0, date_fns_1.format)(new Date(), 'yyyy-MM-dd-HH-mm-ss')}${ext}`);
+};
+exports.getBackupRouteSettingsFilePath = getBackupRouteSettingsFilePath;

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

@@ -0,0 +1,7 @@
+import path from 'path';
+import {format} from 'date-fns';
+
+export const getBackupRouteSettingsFilePath = (filePath: string): string => {
+    const {dir, name, ext} = path.parse(filePath);
+    return path.join(dir, `${name}-${format(new Date(), 'yyyy-MM-dd-HH-mm-ss')}${ext}`);
+};

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

@@ -1,3 +1 @@
-declare module "@tryghost/debug"
-declare module "@tryghost/logging"
 declare module "@tryghost/request"

package/core/server/adapters/scheduling/error-capture.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCapturingSchedulingAdapter = void 0;
+exports.withErrorCapture = withErrorCapture;
+const logging_1 = __importDefault(require("@tryghost/logging"));
+// CJS-only module without TS declarations.
+// TODO: replace with dependency injection once the sentry module is TS
+const sentry = require('../../../shared/sentry');
+/**
+ * Job URLs carry a signed admin token in their query string which stays valid
+ * for hours after the scheduled time, so only the path is safe to report.
+ */
+function redactToken(url) {
+    return url.split('?')[0];
+}
+function report(err, operation, job) {
+    sentry.captureException(err);
+    logging_1.default.error({
+        event: { name: `scheduler.${operation}.failed` },
+        err,
+        url: redactToken(job.url),
+        time: job.time
+    }, `Scheduler failed to ${operation} a job`);
+}
+/**
+ * Decorates a scheduling adapter so that failures from `schedule`/`unschedule`
+ * are reported by Ghost rather than by each adapter. Adapters signal failure
+ * however the contract permits — throwing, or rejecting the returned promise —
+ * and both are handled here.
+ *
+ * Failures are reported rather than propagated because no caller awaits these:
+ * `rescheduleAll` queues one job per scheduled post, and awaiting each would
+ * stall boot behind an adapter's rate limiting.
+ */
+class ErrorCapturingSchedulingAdapter {
+    #adapter;
+    constructor(adapter) {
+        this.#adapter = adapter;
+    }
+    get rescheduleOnBoot() {
+        return this.#adapter.rescheduleOnBoot;
+    }
+    run() {
+        return this.#adapter.run();
+    }
+    register(rescheduler) {
+        this.#adapter.register(rescheduler);
+    }
+    rescheduleAll(opts) {
+        return this.#adapter.rescheduleAll(opts);
+    }
+    schedule(job) {
+        this.#capture(() => this.#adapter.schedule(job), 'schedule', job);
+    }
+    unschedule(job, opts) {
+        this.#capture(() => this.#adapter.unschedule(job, opts), 'unschedule', job);
+    }
+    #capture(run, operation, job) {
+        try {
+            const result = run();
+            if (result) {
+                Promise.resolve(result).catch(err => report(err, operation, job));
+            }
+        }
+        catch (err) {
+            report(err, operation, job);
+        }
+    }
+}
+exports.ErrorCapturingSchedulingAdapter = ErrorCapturingSchedulingAdapter;
+function withErrorCapture(adapter) {
+    return new ErrorCapturingSchedulingAdapter(adapter);
+}

package/core/server/adapters/scheduling/error-capture.ts

@@ -0,0 +1,91 @@
+import logging from '@tryghost/logging';
+import type {RescheduleOpts, Rescheduler, SchedulerAdapter, SchedulerJob} from '@tryghost/adapter-base-scheduling';
+
+// CJS-only module without TS declarations.
+// TODO: replace with dependency injection once the sentry module is TS
+const sentry = require('../../../shared/sentry');
+
+/**
+ * The surface Ghost consumes from a resolved scheduling adapter: the
+ * `SchedulerAdapter` contract, plus the members `SchedulingBase` supplies that
+ * the contract itself doesn't declare.
+ */
+export interface SchedulingAdapter extends SchedulerAdapter {
+    rescheduleAll(opts?: RescheduleOpts): Promise<unknown>;
+    rescheduleOnBoot?: boolean;
+}
+
+/**
+ * Job URLs carry a signed admin token in their query string which stays valid
+ * for hours after the scheduled time, so only the path is safe to report.
+ */
+function redactToken(url: string): string {
+    return url.split('?')[0];
+}
+
+function report(err: unknown, operation: 'schedule' | 'unschedule', job: SchedulerJob): void {
+    sentry.captureException(err);
+    logging.error({
+        event: {name: `scheduler.${operation}.failed`},
+        err,
+        url: redactToken(job.url),
+        time: job.time
+    }, `Scheduler failed to ${operation} a job`);
+}
+
+/**
+ * Decorates a scheduling adapter so that failures from `schedule`/`unschedule`
+ * are reported by Ghost rather than by each adapter. Adapters signal failure
+ * however the contract permits — throwing, or rejecting the returned promise —
+ * and both are handled here.
+ *
+ * Failures are reported rather than propagated because no caller awaits these:
+ * `rescheduleAll` queues one job per scheduled post, and awaiting each would
+ * stall boot behind an adapter's rate limiting.
+ */
+export class ErrorCapturingSchedulingAdapter implements SchedulingAdapter {
+    readonly #adapter: SchedulingAdapter;
+
+    constructor(adapter: SchedulingAdapter) {
+        this.#adapter = adapter;
+    }
+
+    get rescheduleOnBoot(): boolean | undefined {
+        return this.#adapter.rescheduleOnBoot;
+    }
+
+    run(): void | Promise<void> {
+        return this.#adapter.run();
+    }
+
+    register(rescheduler: Rescheduler): void {
+        this.#adapter.register(rescheduler);
+    }
+
+    rescheduleAll(opts?: RescheduleOpts): Promise<unknown> {
+        return this.#adapter.rescheduleAll(opts);
+    }
+
+    schedule(job: SchedulerJob): void {
+        this.#capture(() => this.#adapter.schedule(job), 'schedule', job);
+    }
+
+    unschedule(job: SchedulerJob, opts?: {bootstrap?: boolean}): void {
+        this.#capture(() => this.#adapter.unschedule(job, opts), 'unschedule', job);
+    }
+
+    #capture(run: () => void | Promise<void>, operation: 'schedule' | 'unschedule', job: SchedulerJob): void {
+        try {
+            const result = run();
+            if (result) {
+                Promise.resolve(result).catch(err => report(err, operation, job));
+            }
+        } catch (err) {
+            report(err, operation, job);
+        }
+    }
+}
+
+export function withErrorCapture(adapter: SchedulingAdapter): SchedulingAdapter {
+    return new ErrorCapturingSchedulingAdapter(adapter);
+}

package/core/server/adapters/scheduling/utils.js

@@ -1,44 +1,28 @@
-const adapterManager = require('../../services/adapter-manager');
-const moment = require('moment');
-const jwt = require('jsonwebtoken');
-
-exports.createAdapter = function createAdapter() {
-    return adapterManager.getAdapter('scheduling');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-
-/**
- * @description Get signed admin token for making authenticated scheduling requests
- *
- * @param {object} options
- * @param {string} options.publishedAt - ISO date
- * @param {string} options.apiUrl - url of the JWT's audience
- * @param {import('../../services/internal-keys').InternalApiKey} options.key
- *
- * @return {string} the JSON Web Token
- */
-exports.getSignedAdminToken = function ({publishedAt, apiUrl, key}) {
-    const JWT_OPTIONS = /** @type {const} */ ({
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSignedAdminToken = getSignedAdminToken;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const moment_1 = __importDefault(require("moment"));
+function getSignedAdminToken({ publishedAt, apiUrl, key }) {
+    const opts = {
         keyid: key.id,
         algorithm: 'HS256',
         audience: apiUrl,
         noTimestamp: true
-    });
-
+    };
     // Default token expiry is till 6 hours after scheduled time
     // or if published_at is in past then till 6 hours after blog start
     // to allow for retries in case of network issues
     // and never before 10 mins to publish time
-    let tokenExpiry = moment(publishedAt).add(6, 'h');
-    if (tokenExpiry.isBefore(moment())) {
-        tokenExpiry = moment().add(6, 'h');
+    let tokenExpiry = (0, moment_1.default)(publishedAt).add(6, 'h');
+    if (tokenExpiry.isBefore((0, moment_1.default)())) {
+        tokenExpiry = (0, moment_1.default)().add(6, 'h');
     }
-
-    return jwt.sign(
-        {
-            exp: tokenExpiry.unix(),
-            nbf: moment(publishedAt).subtract(10, 'm').unix()
-        },
-        Buffer.from(key.secret, 'hex'),
-        JWT_OPTIONS
-    );
-};
+    return jsonwebtoken_1.default.sign({
+        exp: tokenExpiry.unix(),
+        nbf: (0, moment_1.default)(publishedAt).subtract(10, 'm').unix(),
+    }, Buffer.from(key.secret, 'hex'), opts);
+}

package/core/server/adapters/scheduling/utils.ts

@@ -0,0 +1,36 @@
+import jwt, {type SignOptions} from 'jsonwebtoken'
+import moment from 'moment'
+import type {InternalApiKey} from '../../services/internal-keys'
+
+type GetSignedAdminTokenOptions = {
+    publishedAt: string
+    apiUrl: string
+    key: InternalApiKey
+}
+
+export function getSignedAdminToken({publishedAt, apiUrl, key}: GetSignedAdminTokenOptions): string {
+    const opts: SignOptions = {
+        keyid: key.id,
+        algorithm: 'HS256',
+        audience: apiUrl,
+        noTimestamp: true
+    };
+
+    // Default token expiry is till 6 hours after scheduled time
+    // or if published_at is in past then till 6 hours after blog start
+    // to allow for retries in case of network issues
+    // and never before 10 mins to publish time
+    let tokenExpiry = moment(publishedAt).add(6, 'h');
+    if (tokenExpiry.isBefore(moment())) {
+        tokenExpiry = moment().add(6, 'h');
+    }
+
+    return jwt.sign(
+        {
+            exp: tokenExpiry.unix(),
+            nbf: moment(publishedAt).subtract(10, 'm').unix(),
+        },
+        Buffer.from(key.secret, 'hex'),
+        opts
+    );
+}

package/core/server/adapters/storage/LocalFilesStorage.js

@@ -1,24 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // # Local File System Storage module
 // The (default) module for storing media, using the local file system
-const config = require('../../../shared/config');
-const urlUtils = require('../../../shared/url-utils');
-const LocalStorageBase = require('./LocalStorageBase');
-
+const config_1 = __importDefault(require("../../../shared/config"));
+const url_utils_1 = __importDefault(require("../../../shared/url-utils"));
+const LocalStorageBase_1 = __importDefault(require("./LocalStorageBase"));
 const messages = {
     notFound: 'File not found',
     notFoundWithRef: 'File not found: {file}',
     cannotRead: 'Could not read File: {file}'
 };
-
-class LocalFilesStorage extends LocalStorageBase {
+class LocalFilesStorage extends LocalStorageBase_1.default {
     constructor() {
         super({
-            storagePath: config.getContentPath('files'),
-            siteUrl: config.getSiteUrl(),
-            staticFileURLPrefix: urlUtils.STATIC_FILES_URL_PREFIX,
+            storagePath: config_1.default.getContentPath('files'),
+            siteUrl: config_1.default.getSiteUrl(),
+            staticFileURLPrefix: url_utils_1.default.STATIC_FILES_URL_PREFIX,
             errorMessages: messages
         });
     }
 }
-
-module.exports = LocalFilesStorage;
+exports.default = LocalFilesStorage;

package/core/server/adapters/storage/LocalFilesStorage.ts

@@ -0,0 +1,24 @@
+// # Local File System Storage module
+// The (default) module for storing media, using the local file system
+import config from '../../../shared/config';
+import urlUtils from '../../../shared/url-utils';
+import LocalStorageBase from './LocalStorageBase';
+
+const messages = {
+    notFound: 'File not found',
+    notFoundWithRef: 'File not found: {file}',
+    cannotRead: 'Could not read File: {file}'
+};
+
+class LocalFilesStorage extends LocalStorageBase {
+    constructor() {
+        super({
+            storagePath: config.getContentPath('files'),
+            siteUrl: config.getSiteUrl(),
+            staticFileURLPrefix: urlUtils.STATIC_FILES_URL_PREFIX,
+            errorMessages: messages
+        });
+    }
+}
+
+export default LocalFilesStorage;

package/core/server/adapters/storage/LocalImagesStorage.js

@@ -1,24 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // # Local File System Image Storage module
 // The (default) module for storing images, using the local file system
-const config = require('../../../shared/config');
-const urlUtils = require('../../../shared/url-utils');
-const LocalStorageBase = require('./LocalStorageBase');
-
-let messages = {
+const config_1 = __importDefault(require("../../../shared/config"));
+const url_utils_1 = __importDefault(require("../../../shared/url-utils"));
+const LocalStorageBase_1 = __importDefault(require("./LocalStorageBase"));
+const messages = {
     notFound: 'Image not found',
     notFoundWithRef: 'Image not found: {file}',
     cannotRead: 'Could not read image: {file}'
 };
-
-class LocalImagesStorage extends LocalStorageBase {
+class LocalImagesStorage extends LocalStorageBase_1.default {
     constructor() {
         super({
-            storagePath: config.getContentPath('images'),
-            staticFileURLPrefix: urlUtils.STATIC_IMAGE_URL_PREFIX,
-            siteUrl: config.getSiteUrl(),
+            storagePath: config_1.default.getContentPath('images'),
+            staticFileURLPrefix: url_utils_1.default.STATIC_IMAGE_URL_PREFIX,
+            siteUrl: config_1.default.getSiteUrl(),
             errorMessages: messages
         });
     }
 }
-
-module.exports = LocalImagesStorage;
+exports.default = LocalImagesStorage;

package/core/server/adapters/storage/LocalImagesStorage.ts

@@ -0,0 +1,24 @@
+// # Local File System Image Storage module
+// The (default) module for storing images, using the local file system
+import config from '../../../shared/config';
+import urlUtils from '../../../shared/url-utils';
+import LocalStorageBase from './LocalStorageBase';
+
+const messages = {
+    notFound: 'Image not found',
+    notFoundWithRef: 'Image not found: {file}',
+    cannotRead: 'Could not read image: {file}'
+};
+
+class LocalImagesStorage extends LocalStorageBase {
+    constructor() {
+        super({
+            storagePath: config.getContentPath('images'),
+            staticFileURLPrefix: urlUtils.STATIC_IMAGE_URL_PREFIX,
+            siteUrl: config.getSiteUrl(),
+            errorMessages: messages
+        });
+    }
+}
+
+export default LocalImagesStorage;

package/core/server/adapters/storage/LocalMediaStorage.js

@@ -1,24 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // # Local File System Media Storage module
 // The (default) module for storing media, using the local file system
-const config = require('../../../shared/config');
-const urlUtils = require('../../../shared/url-utils');
-const LocalStorageBase = require('./LocalStorageBase');
-
+const config_1 = __importDefault(require("../../../shared/config"));
+const url_utils_1 = __importDefault(require("../../../shared/url-utils"));
+const LocalStorageBase_1 = __importDefault(require("./LocalStorageBase"));
 const messages = {
     notFound: 'Media file not found',
     notFoundWithRef: 'Media file not found: {file}',
     cannotRead: 'Could not read media file: {file}'
 };
-
-class LocalMediaStorage extends LocalStorageBase {
+class LocalMediaStorage extends LocalStorageBase_1.default {
     constructor() {
         super({
-            storagePath: config.getContentPath('media'),
-            staticFileURLPrefix: urlUtils.STATIC_MEDIA_URL_PREFIX,
-            siteUrl: config.getSiteUrl(),
+            storagePath: config_1.default.getContentPath('media'),
+            staticFileURLPrefix: url_utils_1.default.STATIC_MEDIA_URL_PREFIX,
+            siteUrl: config_1.default.getSiteUrl(),
             errorMessages: messages
         });
     }
 }
-
-module.exports = LocalMediaStorage;
+exports.default = LocalMediaStorage;