ghost 6.54.0 → 6.54.1

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

@@ -1,14 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 // # Local File Base Storage module
 // The (default) module for storing files using the local file system
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const tpl_1 = __importDefault(require("@tryghost/tpl"));
+const errors_1 = __importDefault(require("@tryghost/errors"));
+const ghost_storage_base_1 = require("ghost-storage-base");
+const url_utils_1 = __importDefault(require("../../../shared/url-utils"));
+const errify_1 = require("../../../shared/errify");
 const serveStatic = require('../../../shared/express').static;
-
-const fs = require('fs-extra');
-const path = require('path');
-const tpl = require('@tryghost/tpl');
-const errors = require('@tryghost/errors');
-const urlUtils = require('../../../shared/url-utils').default;
-const {StorageBase} = require('ghost-storage-base');
-
 const messages = {
     notFound: 'File not found',
     notFoundWithRef: 'File not found: {file}',
@@ -16,50 +20,34 @@ const messages = {
     invalidUrlParameter: `The URL "{url}" is not a valid URL for this site.`,
     invalidPathParameter: 'The path "{path}" is not valid for this storage.'
 };
-
-class LocalStorageBase extends StorageBase {
-    /**
-     *
-     * @param {Object} options
-     * @param {string} options.storagePath
-     * @param {string} options.siteUrl
-     * @param {string} [options.staticFileURLPrefix]
-     * @param {Object} [options.errorMessages]
-     * @param {string} [options.errorMessages.notFound]
-     * @param {string} [options.errorMessages.notFoundWithRef]
-     * @param {string} [options.errorMessages.cannotRead]
-     */
-    constructor({storagePath, staticFileURLPrefix, siteUrl, errorMessages}) {
+class LocalStorageBase extends ghost_storage_base_1.StorageBase {
+    staticFileURLPrefix;
+    siteUrl;
+    staticFileUrl;
+    errorMessages;
+    constructor({ storagePath, staticFileURLPrefix, siteUrl, errorMessages }) {
         super();
-
         this.storagePath = storagePath;
         this.staticFileURLPrefix = staticFileURLPrefix;
         this.siteUrl = siteUrl;
         this.staticFileUrl = `${siteUrl}${staticFileURLPrefix}`;
         this.errorMessages = errorMessages || messages;
     }
-
     /**
      * Normalizes a relative storage path and rejects traversal outside the storage root.
-     *
-     * @param {string} filePath
-     * @returns {string}
      */
     _normalizeStorageRelativePath(filePath) {
-        const normalized = path.posix.normalize(String(filePath || '')
+        const normalized = path_1.default.posix.normalize(String(filePath || '')
             .replaceAll('\\', '/')
             .replace(/^\/+/, '')
             .replace(/\/+$/, ''));
-
         if (normalized === '.' || normalized === '..' || normalized.startsWith('../')) {
-            throw new errors.IncorrectUsageError({
-                message: tpl(messages.invalidPathParameter, {path: filePath})
+            throw new errors_1.default.IncorrectUsageError({
+                message: (0, tpl_1.default)(messages.invalidPathParameter, { path: filePath })
             });
         }
-
         return normalized;
     }
-
     /**
      * Resolves a target directory and optional file name into a full path,
      * validating the result is inside the storage root.
@@ -67,258 +55,210 @@ class LocalStorageBase extends StorageBase {
      * Supports relative paths (preferred) and absolute paths (legacy).
      * TODO: remove absolute path support once all callers pass relative paths
      *
-     * @param {string} [targetDir] absolute or relative directory
-     * @param {string} [fileName] file name to normalize and append
-     * @returns {string} resolved absolute path inside storagePath
+     * @param targetDir absolute or relative directory
+     * @param fileName file name to normalize and append
+     * @returns resolved absolute path inside storagePath
      */
     _resolveAndValidateStoragePath(targetDir, fileName) {
-        const resolvedRoot = path.resolve(this.storagePath);
-
+        const resolvedRoot = path_1.default.resolve(this.storagePath);
         // Resolve targetDir: if already inside storage root use as-is, otherwise treat as relative
         let resolvedBase;
         if (targetDir) {
-            const resolvedTargetDir = path.resolve(targetDir);
-            const relToRoot = path.relative(resolvedRoot, resolvedTargetDir);
-            if (relToRoot === '' || (!relToRoot.startsWith('..') && !path.isAbsolute(relToRoot))) {
+            const resolvedTargetDir = path_1.default.resolve(targetDir);
+            const relToRoot = path_1.default.relative(resolvedRoot, resolvedTargetDir);
+            if (relToRoot === '' || (!relToRoot.startsWith('..') && !path_1.default.isAbsolute(relToRoot))) {
                 resolvedBase = resolvedTargetDir;
-            } else {
-                resolvedBase = path.resolve(this.storagePath, targetDir);
             }
-        } else {
+            else {
+                resolvedBase = path_1.default.resolve(this.storagePath, targetDir);
+            }
+        }
+        else {
             resolvedBase = resolvedRoot;
         }
-
         // If fileName provided, normalize and resolve
         let resolvedPath;
         if (fileName) {
             const normalizedFileName = this._normalizeStorageRelativePath(fileName);
-            resolvedPath = path.resolve(resolvedBase, normalizedFileName);
-        } else {
+            resolvedPath = path_1.default.resolve(resolvedBase, normalizedFileName);
+        }
+        else {
             resolvedPath = resolvedBase;
         }
-
         // Validate the resolved path is strictly inside the storage root (not equal to it)
-        const relative = path.relative(resolvedRoot, resolvedPath);
-        if (relative === '' || relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) {
-            throw new errors.IncorrectUsageError({
-                message: tpl(messages.invalidPathParameter, {path: fileName || targetDir || ''})
+        const relative = path_1.default.relative(resolvedRoot, resolvedPath);
+        if (relative === '' || relative === '..' || relative.startsWith('..' + path_1.default.sep) || path_1.default.isAbsolute(relative)) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: (0, tpl_1.default)(messages.invalidPathParameter, { path: fileName || targetDir || '' })
             });
         }
-
         return resolvedPath;
     }
-
     /**
      * Saves the file to storage (the file system)
      * - returns a promise which ultimately returns the full url to the uploaded file
-     *
-     * @param {import('ghost-storage-base').StorageFile} file
-     * @param {string} targetDir
-     * @returns {Promise<String>}
      */
     async save(file, targetDir) {
         let targetFilename;
-
         targetDir = targetDir
             ? this._resolveAndValidateStoragePath(targetDir)
             : this.getTargetDir(this.storagePath);
-
         const filename = await this.getUniqueFileName(file, targetDir);
-
         targetFilename = filename;
-        await fs.mkdirs(targetDir);
-
+        // Verify that we are saving directly under `targetDir` and not outside of it.
+        const expectedPrefix = path_1.default.join(path_1.default.resolve(targetDir), '/');
+        if (!path_1.default.resolve(targetFilename).startsWith(expectedPrefix)) {
+            throw new errors_1.default.BadRequestError({ message: 'Cannot save to the given filename' });
+        }
+        await fs_extra_1.default.mkdirs(targetDir);
         try {
-            await fs.copy(file.path, targetFilename);
-        } catch (err) {
+            await fs_extra_1.default.copy(file.path, targetFilename);
+        }
+        catch (err) {
             if (err.code === 'ENAMETOOLONG') {
-                throw new errors.BadRequestError({err});
+                throw new errors_1.default.BadRequestError({ err: (0, errify_1.errify)(err) });
             }
-
             throw err;
         }
-
         // The src for the image must be in URI format, not a file system path, which in Windows uses \
         // For local file system storage can use relative path so add a slash
-        const fullUrl = (
-            urlUtils.urlJoin('/',
-                urlUtils.getSubdir(),
-                this.staticFileURLPrefix,
-                path.relative(this.storagePath, targetFilename))
-        ).replace(new RegExp(`\\${path.sep}`, 'g'), '/');
-
+        const fullUrl = (url_utils_1.default.urlJoin('/', url_utils_1.default.getSubdir(), this.staticFileURLPrefix, path_1.default.relative(this.storagePath, targetFilename))).replace(new RegExp(`\\${path_1.default.sep}`, 'g'), '/');
         return fullUrl;
     }
-
     /**
      * Saves a buffer in the targetPath
-     * @param {Buffer} buffer is an instance of Buffer
-     * @param {string} targetPath relative path NOT including storage path to which the buffer should be written
-     * @returns {Promise<String>} a URL to retrieve the data
+     *
+     * @param buffer is an instance of Buffer
+     * @param targetPath relative path NOT including storage path to which the buffer should be written
+     * @returns a URL to retrieve the data
      */
     async saveRaw(buffer, targetPath) {
-        const storagePath = path.join(this.storagePath, this._normalizeStorageRelativePath(targetPath));
-        const targetDir = path.dirname(storagePath);
-
-        await fs.mkdirs(targetDir);
-        await fs.writeFile(storagePath, buffer);
-
+        const storagePath = path_1.default.join(this.storagePath, this._normalizeStorageRelativePath(targetPath));
+        const targetDir = path_1.default.dirname(storagePath);
+        await fs_extra_1.default.mkdirs(targetDir);
+        await fs_extra_1.default.writeFile(storagePath, buffer);
         // For local file system storage can use relative path so add a slash
-        const fullUrl = (
-            urlUtils.urlJoin('/', urlUtils.getSubdir(),
-                this.staticFileURLPrefix,
-                targetPath)
-        ).replace(new RegExp(`\\${path.sep}`, 'g'), '/');
-
+        const fullUrl = (url_utils_1.default.urlJoin('/', url_utils_1.default.getSubdir(), this.staticFileURLPrefix, targetPath)).replace(new RegExp(`\\${path_1.default.sep}`, 'g'), '/');
         return fullUrl;
     }
-
     /**
-     * @param {string} url full url under which the stored content is served, result of save method
-     * @returns {string} relative path under which the content is stored
+     * @param url full url under which the stored content is served, result of save method
+     * @returns relative path under which the content is stored
      */
     urlToPath(url) {
         let relativePath;
-
-        const prefix = urlUtils.urlJoin('/',
-            urlUtils.getSubdir(),
-            this.staticFileURLPrefix
-        );
-
+        const prefix = url_utils_1.default.urlJoin('/', url_utils_1.default.getSubdir(), this.staticFileURLPrefix);
         if (url.startsWith(this.staticFileUrl)) {
             // CASE: full path that includes the site url
             relativePath = url.replace(this.staticFileUrl, '');
-        } else if (url.startsWith(prefix)) {
+        }
+        else if (url.startsWith(prefix)) {
             // CASE: The result of the save method doesn't include the site url. So we need to handle this case.
             relativePath = url.replace(prefix, '');
-        } else {
-            throw new errors.IncorrectUsageError({
-                message: tpl(messages.invalidUrlParameter, {url})
+        }
+        else {
+            throw new errors_1.default.IncorrectUsageError({
+                message: (0, tpl_1.default)(messages.invalidUrlParameter, { url })
             });
         }
-
         try {
             return this._normalizeStorageRelativePath(relativePath);
-        } catch (err) {
-            throw new errors.IncorrectUsageError({
-                message: tpl(messages.invalidUrlParameter, {url})
+        }
+        catch (err) {
+            throw new errors_1.default.IncorrectUsageError({
+                message: (0, tpl_1.default)(messages.invalidUrlParameter, { url })
             });
         }
     }
-
     async exists(fileName, targetDir) {
         let filePath;
-
         try {
             filePath = this._resolveAndValidateStoragePath(targetDir, fileName);
-        } catch (err) {
-            if (err instanceof errors.IncorrectUsageError) {
+        }
+        catch (err) {
+            if (err instanceof errors_1.default.IncorrectUsageError) {
                 return false;
             }
-
             throw err;
         }
-
         try {
-            await fs.stat(filePath);
+            await fs_extra_1.default.stat(filePath);
             return true;
-        } catch {
+        }
+        catch {
             return false;
         }
     }
-
     /**
      * For some reason send divides the max age number by 1000
      * Fallthrough: false ensures that if an image isn't found, it automatically 404s
      * Wrap server static errors
-     *
-     * @returns {serveStaticContent}
      */
     serve() {
-        const {storagePath, errorMessages} = this;
-
+        const { storagePath, errorMessages } = this;
         return function serveStaticContent(req, res, next) {
-            return serveStatic(
-                storagePath,
-                {
-                    maxAge: (365 * 24 * 60 * 60 * 1000), // 1 year in ms
-                    fallthrough: false
-                }
-            )(req, res, (err) => {
+            return serveStatic(storagePath, {
+                maxAge: (365 * 24 * 60 * 60 * 1000), // 1 year in ms
+                fallthrough: false
+            })(req, res, (err) => {
                 if (err) {
                     if (err.statusCode === 404) {
-                        return next(new errors.NotFoundError({
-                            message: tpl(errorMessages.notFound),
+                        return next(new errors_1.default.NotFoundError({
+                            message: (0, tpl_1.default)(errorMessages.notFound),
                             code: 'STATIC_FILE_NOT_FOUND',
                             property: err.path
                         }));
                     }
-
                     if (err.statusCode === 400) {
-                        return next(new errors.BadRequestError({err: err}));
+                        return next(new errors_1.default.BadRequestError({ err: err }));
                     }
-
                     if (err.statusCode === 403) {
-                        return next(new errors.NoPermissionError({err: err}));
+                        return next(new errors_1.default.NoPermissionError({ err: err }));
                     }
-
                     if (err.name === 'RangeNotSatisfiableError') {
-                        return next(new errors.RangeNotSatisfiableError({err}));
+                        return next(new errors_1.default.RangeNotSatisfiableError({ err }));
                     }
-
-                    return next(new errors.InternalServerError({err: err}));
+                    return next(new errors_1.default.InternalServerError({ err: err }));
                 }
-
                 next();
             });
         };
     }
-
-    /**
-     * @param {string} filePath
-     * @returns {Promise.<*>}
-     */
     async delete(fileName, targetDir) {
         const filePath = this._resolveAndValidateStoragePath(targetDir, fileName);
-        return await fs.remove(filePath);
+        return await fs_extra_1.default.remove(filePath);
     }
-
     /**
      * Reads bytes from disk for a target file
      * - path of target file (without content path!)
-     *
-     * @param options
      */
     async read(options) {
         options = options || {};
-
         const normalizedPath = this._normalizeStorageRelativePath(options.path);
-        const targetPath = path.join(this.storagePath, normalizedPath);
-
+        const targetPath = path_1.default.join(this.storagePath, normalizedPath);
         try {
-            return await fs.readFile(targetPath);
-        } catch (err) {
-            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') {
-                throw new errors.NotFoundError({
+            return await fs_extra_1.default.readFile(targetPath);
+        }
+        catch (rawError) {
+            const err = (0, errify_1.errify)(rawError);
+            const code = rawError.code;
+            if (code === 'ENOENT' || code === 'ENOTDIR') {
+                throw new errors_1.default.NotFoundError({
                     err: err,
-                    message: tpl(this.errorMessages.notFoundWithRef, {file: options.path})
+                    message: (0, tpl_1.default)(this.errorMessages.notFoundWithRef, { file: options.path })
                 });
             }
-
-            if (err.code === 'ENAMETOOLONG') {
-                throw new errors.BadRequestError({err: err});
+            if (code === 'ENAMETOOLONG') {
+                throw new errors_1.default.BadRequestError({ err: err });
             }
-
-            if (err.code === 'EACCES') {
-                throw new errors.NoPermissionError({err: err});
+            if (code === 'EACCES') {
+                throw new errors_1.default.NoPermissionError({ err: err });
             }
-
-            throw new errors.InternalServerError({
+            throw new errors_1.default.InternalServerError({
                 err: err,
-                message: tpl(this.errorMessages.cannotRead, {file: options.path})
+                message: (0, tpl_1.default)(this.errorMessages.cannotRead, { file: options.path })
             });
         }
     }
 }
-
-module.exports = LocalStorageBase;
+exports.default = LocalStorageBase;