ghost 6.60.0 → 6.62.0

package/core/server/api/endpoints/db.js

@@ -3,12 +3,17 @@ const path = require('path');
 const dbBackup = require('../../data/db/backup');
 const exporter = require('../../data/exporter');
 const importer = require('../../data/importer');
-const mediaInliner = require('../../services/media-inliner');
+const jobsService = require('../../services/jobs-service');
+const ExternalMediaInlinerJob =
+  require('../../services/media-inliner/external-media-inliner-job').default;
 const errors = require('@tryghost/errors');
-const { pool } = require('@tryghost/promise');
+const logging = require('@tryghost/logging');
+const { promisePool } = require('../../lib/promise-pool');
 const models = require('../../models');
 const settingsCache = require('../../../shared/settings-cache');
 
+const DEFAULT_MEDIA_INLINER_DOMAINS = ['https://s3.amazonaws.com/revue', 'https://substackcdn.com'];
+
 /** @type {import('@tryghost/api-framework').Controller} */
 const controller = {
   docName: 'db',
@@ -125,7 +130,16 @@ const controller = {
       },
     },
     async query(frame) {
-      return mediaInliner.api.startMediaInliner(frame.data.domains);
+      const domains = frame.data.domains?.length
+        ? frame.data.domains
+        : DEFAULT_MEDIA_INLINER_DOMAINS;
+
+      logging.info('[Background Job] external-media-inliner queued');
+      await jobsService.getInstance().dispatch(new ExternalMediaInlinerJob({ domains }));
+
+      return {
+        status: 'success',
+      };
     },
   },
 
@@ -157,7 +171,7 @@ const controller = {
         try {
           const allPosts = await models.Post.findAll(queryOpts);
 
-          await pool(
+          await promisePool(
             allPosts.map((post) => () => {
               return models.Post.destroy(Object.assign({ id: post.id }, queryOpts));
             }),
@@ -166,7 +180,7 @@ const controller = {
 
           const allTags = await models.Tag.findAll(queryOpts);
 
-          await pool(
+          await promisePool(
             allTags.map((tag) => () => {
               return models.Tag.destroy(Object.assign({ id: tag.id }, queryOpts));
             }),

package/core/server/api/endpoints/index.js

@@ -112,8 +112,12 @@ module.exports = {
     return apiFramework.pipeline(require('./members'), localUtils);
   },
 
-  get membersCustomFields() {
-    return apiFramework.pipeline(require('./member-custom-fields'), localUtils);
+  get membersMetafields() {
+    return apiFramework.pipeline(require('./member-metafields'), localUtils);
+  },
+
+  get tiersCheckoutConfig() {
+    return apiFramework.pipeline(require('./tiers-checkout-config'), localUtils);
   },
 
   get memberCommenting() {

package/core/server/api/endpoints/mail.js

@@ -25,7 +25,7 @@ _private.sendMail = (object) => {
               message: [
                 tpl(messages.unableToSendEmail),
                 tpl(messages.seeLinkForInstructions, {
-                  link: 'https://ghost.org/docs/concepts/config/#mail',
+                  link: 'https://docs.ghost.org/concepts/config/#mail',
                 }),
               ].join(' '),
             },

package/core/server/api/endpoints/member-metafields.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const members_custom_fields_1 = require("../../services/members-custom-fields");
+const permissionsService = require('../../services/permissions');
+// With `permissions: true` the framework checks against the Bookshelf model named after
+// the resource. These fields have no Bookshelf model, so each handler asks the permissions
+// service directly.
+function canThis(frame) {
+    return permissionsService.canThis(frame.options.context);
+}
+const noCacheInvalidation = { cacheInvalidate: false };
+const controller = {
+    docName: 'members_metafields',
+    browse: {
+        headers: noCacheInvalidation,
+        options: ['namespace', 'filter'],
+        validation: { options: { namespace: { required: true } } },
+        permissions(frame) {
+            return canThis(frame).browse.member_custom_field();
+        },
+        query(frame) {
+            return members_custom_fields_1.definitions.browse({
+                namespace: frame.options.namespace,
+                filter: frame.options.filter,
+            });
+        },
+    },
+    read: {
+        headers: noCacheInvalidation,
+        options: ['namespace', 'key'],
+        validation: { options: { namespace: { required: true }, key: { required: true } } },
+        permissions(frame) {
+            return canThis(frame).read.member_custom_field(frame.options.key);
+        },
+        query(frame) {
+            return members_custom_fields_1.definitions.read(frame.options.namespace, frame.options.key);
+        },
+    },
+    add: {
+        statusCode: 201,
+        headers: noCacheInvalidation,
+        options: ['namespace'],
+        validation: { options: { namespace: { required: true } } },
+        permissions(frame) {
+            return canThis(frame).add.member_custom_field();
+        },
+        query(frame) {
+            return members_custom_fields_1.definitions.add((0, members_custom_fields_1.actingContext)(frame.options.context), frame.options.namespace, frame.data.members_metafields);
+        },
+    },
+    reorder: {
+        headers: noCacheInvalidation,
+        options: ['namespace'],
+        validation: { options: { namespace: { required: true } } },
+        permissions(frame) {
+            return canThis(frame).edit.member_custom_field();
+        },
+        query(frame) {
+            return members_custom_fields_1.definitions.reorder((0, members_custom_fields_1.actingContext)(frame.options.context), frame.options.namespace, frame.data.members_metafields);
+        },
+    },
+    edit: {
+        headers: noCacheInvalidation,
+        options: ['namespace', 'key'],
+        validation: { options: { namespace: { required: true }, key: { required: true } } },
+        permissions(frame) {
+            return canThis(frame).edit.member_custom_field(frame.options.key);
+        },
+        query(frame) {
+            return members_custom_fields_1.definitions.edit((0, members_custom_fields_1.actingContext)(frame.options.context), frame.options.namespace, frame.options.key, frame.data.members_metafields[0]);
+        },
+    },
+    destroy: {
+        statusCode: 204,
+        headers: noCacheInvalidation,
+        options: ['namespace', 'key'],
+        validation: { options: { namespace: { required: true }, key: { required: true } } },
+        permissions(frame) {
+            return canThis(frame).destroy.member_custom_field(frame.options.key);
+        },
+        async query(frame) {
+            await members_custom_fields_1.definitions.destroy((0, members_custom_fields_1.actingContext)(frame.options.context), frame.options.namespace, frame.options.key);
+            return null;
+        },
+    },
+};
+// The API framework loads this file with `require()`, so it exports CommonJS-style;
+// `export default` would not be picked up.
+module.exports = controller;

package/core/server/api/endpoints/members.js

@@ -44,10 +44,10 @@ const messages = {
   resourceNotFound: '{resource} not found.',
 };
 
-// `custom_fields` is a browse include only: a read returns values whenever the
-// flag is on, the same way it returns tiers. Values are not a member relation, so
-// the input serializer lifts the key out of withRelated before the model sees it.
-const allowedIncludes = ['email_recipients', 'products', 'tiers', 'custom_fields'];
+// `metafields` is not a relation on the member model. It is allowed here only so callers
+// can ask for it with `include=`; the input serializer removes it before the model tries
+// to eager-load it.
+const allowedIncludes = ['email_recipients', 'products', 'tiers', 'metafields'];
 
 /** @type {import('@tryghost/api-framework').Controller} */
 const controller = {

package/core/server/api/endpoints/posts.js

@@ -129,12 +129,13 @@ const controller = {
       method: 'importContent',
     },
     async query(frame) {
-      // The CSV must be parsed before the response goes out: the uploaded temp file is
-      // deleted as soon as it is sent. The posts are written by a background job behind
-      // the 202.
+      // The content-import service stages and validates the upload before this response;
+      // Multer deletes the request temp file as soon as the 202 is sent.
       const { importId, total } = await contentImportService.importCSV({
         filePath: frame.file.path,
+        fileName: frame.file.name,
         mapping: frame.data.mapping,
+        requestUserEmail: frame.user ? frame.user.get('email') : null,
       });
       return { meta: { import_id: importId, total } };
     },

package/core/server/api/endpoints/tiers-checkout-config.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const members_custom_fields_1 = require("../../services/members-custom-fields");
+const tier_checkout_config_1 = require("../../services/tier-checkout-config");
+const tiersService = require('../../services/tiers');
+/**
+ * Reads one tier's checkout settings for the API to return.
+ *
+ * The service answers with null when nobody has ever set up checkout for the tier, because
+ * there is genuinely nothing stored for it. The API still answers with a resource: the tier
+ * itself exists, so a client asking what it collects should be told "nothing" in the same
+ * shape as any other answer, rather than getting a 404 or an empty body to puzzle over.
+ */
+async function forTier(id) {
+    return (await tiersService.checkout.read(id)) ?? (0, tier_checkout_config_1.emptyCheckoutConfig)(id);
+}
+/**
+ * A tier's checkout configuration, as a sub-resource of the tier rather than an attribute
+ * of it.
+ *
+ * The tier resource is generally available and this concept is not, so putting it on the
+ * tier payload would add a key to every tier response on every site whether or not the
+ * feature is on. A route of its own can carry the flag, and be removed with it.
+ *
+ * Every operation here is one call. A tier's configuration is one shape the service hands
+ * out and takes back, and that it spans tables, that destinations are site-wide, and that a
+ * binding exists at all are facts about the inside of that domain.
+ */
+const controller = {
+    docName: 'tiers_checkout_config',
+    browse: {
+        headers: { cacheInvalidate: false },
+        permissions: { docName: 'products', method: 'browse' },
+        query() {
+            return tiersService.checkout.browse();
+        },
+    },
+    read: {
+        headers: { cacheInvalidate: false },
+        options: ['id'],
+        validation: { options: { id: { required: true } } },
+        permissions: { docName: 'products', method: 'read' },
+        async query(frame) {
+            return [await forTier(frame.options.id)];
+        },
+    },
+    edit: {
+        headers: { cacheInvalidate: true },
+        options: ['id'],
+        validation: { options: { id: { required: true } } },
+        permissions: { docName: 'products', method: 'edit' },
+        async query(frame) {
+            await tiersService.checkout.edit((0, members_custom_fields_1.actingContext)(frame.options.context), frame.options.id, frame.data.tiers_checkout_config?.[0] ?? {});
+            return [await forTier(frame.options.id)];
+        },
+    },
+};
+// module.exports (not export): the API framework loads controllers via require().
+module.exports = controller;

package/core/server/api/endpoints/utils/serializers/input/members.js

@@ -34,16 +34,13 @@ function mapSubscribedFlagToNewsletterRelation(frame) {
   });
 }
 
-// Values are not a member relation — they're stored per field type and read by
-// the custom fields service — so `include=custom_fields` must not reach the model
-// layer as something to eager-load. Lift it out and leave a flag browse can act on.
-function liftCustomFieldsInclude(frame) {
-  if (!frame.options.withRelated.includes('custom_fields')) {
+function liftMetafieldsInclude(frame) {
+  if (!frame.options.withRelated.includes('metafields')) {
     return;
   }
 
   frame.options.withRelated = frame.options.withRelated.filter(
-    (relation) => relation !== 'custom_fields',
+    (relation) => relation !== 'metafields',
   );
   frame.options.includeCustomFields = true;
 }
@@ -54,7 +51,7 @@ module.exports = {
       return;
     }
 
-    liftCustomFieldsInclude(frame);
+    liftMetafieldsInclude(frame);
 
     frame.options.withRelated = frame.options.withRelated.map((relation) => {
       if (relation === 'tiers') {

package/core/server/api/endpoints/utils/serializers/output/config.js

@@ -25,6 +25,7 @@ module.exports = {
       'security',
       'exploreTestimonialsUrl',
       'featurebase',
+      'docsbot',
     ];
 
     frame.response = {

package/core/server/api/endpoints/utils/serializers/output/index.js

@@ -76,14 +76,18 @@ module.exports = {
     return require('./members');
   },
 
-  get members_custom_fields() {
-    return require('./member-custom-fields');
+  get members_metafields() {
+    return require('./member-metafields');
   },
 
   get tiers() {
     return require('./tiers');
   },
 
+  get tiers_checkout_config() {
+    return require('./tiers-checkout-config');
+  },
+
   get images() {
     return require('./images');
   },

package/core/server/api/endpoints/utils/serializers/output/{member-custom-fields.js → member-metafields.js}

@@ -7,13 +7,11 @@ const serializeOne = (field, _apiConfig, frame) => {
 const serializeMany = (fields, _apiConfig, frame) => {
     frame.response = serializers_1.toCustomFieldsResponse.parse(fields);
 };
-// module.exports (not export): the API framework loads serializers via require(). The endpoint ->
-// serializer mapping lives here; the response shaping lives with the members-custom-fields service.
+// The API framework loads this file with `require()`, so it exports CommonJS-style;
+// `export default` would not be picked up.
 module.exports = {
     browse: serializeMany,
     read: serializeOne,
-    // Create is a batch, so it returns every definition it made. The response is
-    // already an array, so a one-item create looks exactly as it did before.
     add: serializeMany,
     reorder: serializeMany,
     edit: serializeOne,

package/core/server/api/endpoints/utils/serializers/output/members.js

@@ -131,10 +131,8 @@ function serializeMember(member, options) {
     serialized.tiers = json.products;
   }
 
-  // Present on a read whenever the flag is on; absent otherwise, and absent on
-  // browse. An empty object is a member with no values set.
-  if (json.custom_fields) {
-    serialized.custom_fields = json.custom_fields;
+  if (json.metafields) {
+    serialized.metafields = json.metafields;
   }
 
   serialized.current_subscription = json.current_subscription || null;

package/core/server/api/endpoints/utils/serializers/output/tiers-checkout-config.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tier_checkout_config_1 = require("../../../../../services/tier-checkout-config");
+const serialize = (configs, _apiConfig, frame) => {
+    frame.response = tier_checkout_config_1.toCheckoutConfigResponse.parse(configs);
+};
+// module.exports (not export): the API framework loads serializers via require().
+module.exports = {
+    browse: serialize,
+    read: serialize,
+    edit: serialize,
+};

package/core/server/api/endpoints/utils/validators/input/invitations.js

@@ -4,7 +4,6 @@ const tpl = require('@tryghost/tpl');
 const errors = require('@tryghost/errors');
 
 const messages = {
-  noEmailProvided: 'No email provided.',
   noNameProvided: 'No name provided.',
   noPasswordProvided: 'No password provided.',
   noTokenProvided: 'No token provided.',
@@ -21,10 +20,6 @@ module.exports = {
       return Promise.reject(new errors.ValidationError({ message: tpl(messages.noTokenProvided) }));
     }
 
-    if (!data.email) {
-      return Promise.reject(new errors.ValidationError({ message: tpl(messages.noEmailProvided) }));
-    }
-
     if (!data.password) {
       return Promise.reject(
         new errors.ValidationError({ message: tpl(messages.noPasswordProvided) }),

package/core/server/api/endpoints/utils/validators/input/pages.js

@@ -8,7 +8,7 @@ const messages = {
   onlySingleContentSource: 'Pages can have either a mobiledoc or a lexical property, never both.',
   onlySingleContentSourceContext:
     'Both the mobiledoc and lexical properties are set, one must be null',
-  onlySingleContentSourceHelp: 'https://ghost.org/docs/admin-api/#the-post-object',
+  onlySingleContentSourceHelp: 'https://docs.ghost.org/admin-api/#the-post-object',
 };
 
 const validateVisibility = async function (frame) {

package/core/server/api/endpoints/utils/validators/input/posts.js

@@ -8,7 +8,7 @@ const messages = {
   onlySingleContentSource: 'Posts can have either a mobiledoc or a lexical property, never both.',
   onlySingleContentSourceContext:
     'Both the mobiledoc and lexical properties are set, one must be null',
-  onlySingleContentSourceHelp: 'https://ghost.org/docs/admin-api/#the-post-object',
+  onlySingleContentSourceHelp: 'https://docs.ghost.org/admin-api/#the-post-object',
 };
 
 const validateVisibility = async function (frame) {

package/core/server/data/exporter/table-lists.js

@@ -44,6 +44,9 @@ const BACKUP_TABLES = [
   'members_newsletters',
   'members_custom_fields',
   'members_custom_field_values',
+  'members_custom_field_bindings',
+  'products_checkout_fields',
+  'products_checkout_config',
   'mentions',
   'comments',
   'comment_likes',

package/core/server/data/importer/content-files.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContentFileHandlers = createContentFileHandlers;
+exports.createContentFileImporters = createContentFileImporters;
+const config_1 = __importDefault(require("../../../shared/config"));
+const url_utils_1 = __importDefault(require("../../../shared/url-utils"));
+// Keep adapter loading on the existing CommonJS path so the configured adapter
+// and its base class share the same module instance during the legacy /db/ import.
+const adapterManager = require('../../services/adapter-manager').default;
+const ImageHandler = require('./handlers/image');
+const ImporterContentFileHandler = require('./handlers/importer-content-file-handler');
+const ContentFileImporter = require('./importers/content-file-importer');
+function createContentFileHandlers() {
+    const mediaStorage = adapterManager.getAdapter('storage:media');
+    const fileStorage = adapterManager.getAdapter('storage:files');
+    return [
+        ImageHandler,
+        new ImporterContentFileHandler({
+            type: 'media',
+            // These broad directory names preserve the existing /db/ archive behavior.
+            directories: ['media', 'content'],
+            ignoreRootFolderFiles: true,
+            extensions: config_1.default.get('uploads').media.extensions,
+            contentTypes: config_1.default.get('uploads').media.contentTypes,
+            urlUtils: url_utils_1.default,
+            storage: mediaStorage,
+        }),
+        new ImporterContentFileHandler({
+            type: 'files',
+            directories: ['files', 'content'],
+            ignoreRootFolderFiles: true,
+            extensions: config_1.default.get('uploads').files.extensions,
+            contentTypes: config_1.default.get('uploads').files.contentTypes,
+            urlUtils: url_utils_1.default,
+            storage: fileStorage,
+        }),
+    ];
+}
+function createContentFileImporters() {
+    return [
+        new ContentFileImporter({
+            type: 'images',
+            store: adapterManager.getAdapter('storage:images'),
+        }),
+        new ContentFileImporter({
+            type: 'media',
+            store: adapterManager.getAdapter('storage:media'),
+        }),
+        new ContentFileImporter({
+            type: 'files',
+            store: adapterManager.getAdapter('storage:files'),
+        }),
+    ];
+}

package/core/server/data/importer/handlers/image.js

@@ -30,7 +30,7 @@ ImageHandler = {
 
       file.originalPath = noBaseDir;
       file.name = noGhostDirs;
-      file.targetDir = path.join(config.getContentPath('images'), path.dirname(noGhostDirs));
+      file.targetDir = path.join(store.storagePath, path.dirname(noGhostDirs));
       return file;
     });
 
@@ -41,7 +41,7 @@ ImageHandler = {
             '/',
             urlUtils.getSubdir(),
             store.staticFileURLPrefix,
-            path.relative(config.getContentPath('images'), targetFilename),
+            path.relative(store.storagePath, targetFilename),
           );
 
           return image;

package/core/server/data/importer/import-archive.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const glob_1 = require("glob");
+const { extract } = require('@tryghost/zip');
+const tpl = require('@tryghost/tpl');
+const errors = require('@tryghost/errors');
+const messages = {
+    noContentToImport: 'Zip did not include any content to import.',
+    invalidZipStructure: 'Invalid zip file structure.',
+    invalidZipFileBaseDirectory: 'Invalid zip file: base directory read failed',
+    invalidZipFileNameEncoding: 'The uploaded zip could not be read',
+    invalidZipFileNameEncodingContext: 'The filename was too long or contained invalid characters',
+    invalidZipFileNameEncodingHelp: 'Remove any special characters from the file name, or alternatively try another archiving tool if using MacOS Archive Utility',
+};
+const ROOT_ONLY = 0;
+const ROOT_OR_SINGLE_DIR = 1;
+const ALL_DIRS = 2;
+class ImportArchive {
+    extensions;
+    directories;
+    extractArchive;
+    constructor({ extensions, directories }, { extract: extractArchive = extract } = {}) {
+        this.extensions = extensions;
+        this.directories = directories;
+        this.extractArchive = extractArchive;
+    }
+    getGlobPattern(items) {
+        return `+(${items.join('|')})`;
+    }
+    getExtensionGlob(extensions, level) {
+        const prefix = level === ALL_DIRS ? '**/*' : level === ROOT_OR_SINGLE_DIR ? '{*/*,*}' : '*';
+        return prefix + this.getGlobPattern(extensions);
+    }
+    getDirectoryGlob(directories, level) {
+        const prefix = level === ALL_DIRS ? '**/' : level === ROOT_OR_SINGLE_DIR ? '{*/,}' : '';
+        return prefix + this.getGlobPattern(directories);
+    }
+    isValid(directory) {
+        const extMatchesBase = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ROOT_OR_SINGLE_DIR), {
+            cwd: directory,
+            nocase: true,
+        });
+        const extMatchesAll = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ALL_DIRS), {
+            cwd: directory,
+            nocase: true,
+        });
+        const dirMatches = this.directories.length
+            ? (0, glob_1.globSync)(this.getDirectoryGlob(this.directories, ROOT_OR_SINGLE_DIR), {
+                cwd: directory,
+            })
+            : [];
+        if (extMatchesBase.length > 0 || (dirMatches.length > 0 && extMatchesAll.length > 0)) {
+            return true;
+        }
+        if (extMatchesAll.length < 1) {
+            throw new errors.UnsupportedMediaTypeError({ message: tpl(messages.noContentToImport) });
+        }
+        throw new errors.UnsupportedMediaTypeError({ message: tpl(messages.invalidZipStructure) });
+    }
+    getBaseDirectory(directory) {
+        const extMatches = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ROOT_ONLY), {
+            cwd: directory,
+            nocase: true,
+        });
+        const dirMatches = this.directories.length
+            ? (0, glob_1.globSync)(this.getDirectoryGlob(this.directories, ROOT_ONLY), {
+                cwd: directory,
+                nocase: true,
+            })
+            : [];
+        if (extMatches.length > 0 || dirMatches.length > 0) {
+            return;
+        }
+        const extMatchesAll = (0, glob_1.globSync)(this.getExtensionGlob(this.extensions, ALL_DIRS), {
+            cwd: directory,
+            nocase: true,
+        });
+        const firstMatch = extMatchesAll[0];
+        if (!firstMatch) {
+            throw new errors.ValidationError({ message: tpl(messages.invalidZipFileBaseDirectory) });
+        }
+        return firstMatch.split('/')[0];
+    }
+    getFiles(directory, extensions) {
+        const globPattern = this.getExtensionGlob(extensions, ALL_DIRS);
+        return (0, glob_1.globSync)(globPattern, { cwd: directory, nocase: true }).map((file) => ({
+            name: file,
+            path: node_path_1.default.join(directory, file),
+        }));
+    }
+    async extract(filePath) {
+        const tmpDir = node_path_1.default.join(node_os_1.default.tmpdir(), node_crypto_1.default.randomUUID());
+        try {
+            await this.extractArchive(filePath, tmpDir);
+            const files = (0, glob_1.globSync)('**/*', { cwd: tmpDir, nodir: true });
+            await Promise.all(files.map((file) => fs_extra_1.default.chmod(node_path_1.default.join(tmpDir, file), 0o644)));
+        }
+        catch (error) {
+            await fs_extra_1.default.remove(tmpDir).catch(() => { });
+            const message = messageOf(error);
+            if (message.startsWith('ENAMETOOLONG:')) {
+                throw new errors.UnsupportedMediaTypeError({
+                    message: tpl(messages.invalidZipFileNameEncoding),
+                    context: tpl(messages.invalidZipFileNameEncodingContext),
+                    help: tpl(messages.invalidZipFileNameEncodingHelp),
+                    code: 'INVALID_ZIP_FILE_NAME_ENCODING',
+                });
+            }
+            if (message.includes('end of central directory record signature not found') ||
+                message.includes('invalid comment length')) {
+                throw new errors.UnsupportedMediaTypeError({
+                    message: tpl(messages.invalidZipFileNameEncoding),
+                    code: 'INVALID_ZIP_FILE',
+                });
+            }
+            throw error;
+        }
+        return tmpDir;
+    }
+}
+exports.default = ImportArchive;
+function messageOf(error) {
+    return error instanceof Error ? error.message : '';
+}