ghost 5.119.3 → 5.120.0

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

@@ -39,13 +39,12 @@ const controller = {
             });
 
             if (notificationsToAdd.length){
-                return await settingsBREADService.edit([{
+                await settingsBREADService.edit([{
                     key: 'notifications',
                     // @NOTE: We always need to store all notifications!
                     value: allNotifications.concat(notificationsToAdd)
-                }], internalContext).then(() => {
-                    return notificationsToAdd;
-                });
+                }], internalContext);
+                return notificationsToAdd;
             }
         }
     },

package/core/server/api/endpoints/pages-public.js

@@ -86,21 +86,19 @@ const controller = {
             }
         },
         permissions: true,
-        query(frame) {
+        async query(frame) {
             const options = {
                 ...frame.options,
                 mongoTransformer: rejectPrivateFieldsTransformer
             };
-            return models.Post.findOne(frame.data, options)
-                .then((model) => {
-                    if (!model) {
-                        throw new errors.NotFoundError({
-                            message: tpl(messages.pageNotFound)
-                        });
-                    }
-
-                    return model;
+            const model = await models.Post.findOne(frame.data, options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.pageNotFound)
                 });
+            }
+
+            return model;
         }
     }
 };

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

@@ -81,17 +81,15 @@ const controller = {
             docName: 'posts',
             unsafeAttrs: UNSAFE_ATTRS
         },
-        query(frame) {
-            return models.Post.findOne(frame.data, frame.options)
-                .then((model) => {
-                    if (!model) {
-                        throw new errors.NotFoundError({
-                            message: tpl(messages.pageNotFound)
-                        });
-                    }
-
-                    return model;
+        async query(frame) {
+            const model = await models.Post.findOne(frame.data, frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.pageNotFound)
                 });
+            }
+
+            return model;
         }
     },
 
@@ -119,15 +117,13 @@ const controller = {
             docName: 'posts',
             unsafeAttrs: UNSAFE_ATTRS
         },
-        query(frame) {
-            return models.Post.add(frame.data.pages[0], frame.options)
-                .then((model) => {
-                    if (model.get('status') === 'published') {
-                        frame.setHeader('X-Cache-Invalidate', '/*');
-                    }
+        async query(frame) {
+            const model = await models.Post.add(frame.data.pages[0], frame.options);
+            if (model.get('status') === 'published') {
+                frame.setHeader('X-Cache-Invalidate', '/*');
+            }
 
-                    return model;
-                });
+            return model;
         }
     },
 

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

@@ -162,21 +162,19 @@ const controller = {
             }
         },
         permissions: true,
-        query(frame) {
+        async query(frame) {
             const options = {
                 ...frame.options,
                 mongoTransformer: rejectPrivateFieldsTransformer
             };
-            return models.Post.findOne(frame.data, options)
-                .then((model) => {
-                    if (!model) {
-                        throw new errors.NotFoundError({
-                            message: tpl(messages.postNotFound)
-                        });
-                    }
-
-                    return model;
+            const model = await models.Post.findOne(frame.data, options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.postNotFound)
                 });
+            }
+
+            return model;
         }
     }
 };

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

@@ -171,15 +171,13 @@ const controller = {
         permissions: {
             unsafeAttrs: unsafeAttrs
         },
-        query(frame) {
-            return models.Post.add(frame.data.posts[0], frame.options)
-                .then((model) => {
-                    if (model.get('status') === 'published') {
-                        frame.setHeader('X-Cache-Invalidate', '/*');
-                    }
+        async query(frame) {
+            const model = await models.Post.add(frame.data.posts[0], frame.options);
+            if (model.get('status') === 'published') {
+                frame.setHeader('X-Cache-Invalidate', '/*');
+            }
 
-                    return model;
-                });
+            return model;
         }
     },
 

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

@@ -66,19 +66,17 @@ const controller = {
                 }
             }
         },
-        query(frame) {
+        async query(frame) {
             _addMemberContextToFrame(frame);
 
-            return models.Post.findOne(Object.assign({status: 'all'}, frame.data), frame.options)
-                .then((model) => {
-                    if (!model) {
-                        throw new errors.NotFoundError({
-                            message: tpl(messages.postNotFound)
-                        });
-                    }
-
-                    return model;
+            const model = await models.Post.findOne(Object.assign({status: 'all'}, frame.data), frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.postNotFound)
                 });
+            }
+
+            return model;
         }
     }
 };

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

@@ -10,14 +10,13 @@ const controller = {
         headers: {
             disposition: {
                 type: 'file',
-                value() {
-                    return customRedirects.api.getRedirectsFilePath()
-                        .then((filePath) => {
-                            // @deprecated: .json was deprecated in v4.0 but is still the default for backwards compat
-                            return filePath === null || path.extname(filePath) === '.json'
-                                ? 'redirects.json'
-                                : 'redirects.yaml';
-                        });
+                async value() {
+                    const filePath = await customRedirects.api.getRedirectsFilePath();
+
+                    // @deprecated: .json was deprecated in v4.0 but is still the default for backwards compat
+                    return filePath === null || path.extname(filePath) === '.json'
+                        ? 'redirects.json'
+                        : 'redirects.yaml';
                 }
             },
             cacheInvalidate: false

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

@@ -69,19 +69,17 @@ const controller = {
                 }
             }
         },
-        query(frame) {
+        async query(frame) {
             const resourceModel = 'Post';
             const resourceType = (frame.options.resource === 'post') ? 'post' : 'page';
             const cleanOptions = {};
             cleanOptions.filter = `status:scheduled+type:${resourceType}`;
             cleanOptions.columns = ['id', 'published_at', 'created_at', 'type'];
 
-            return models[resourceModel].findAll(cleanOptions)
-                .then((result) => {
-                    let response = {};
-                    response[resourceType] = result;
-                    return response;
-                });
+            const result = await models[resourceModel].findAll(cleanOptions);
+            let response = {};
+            response[resourceType] = result;
+            return response;
         }
     }
 };

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

@@ -44,16 +44,14 @@ const controller = {
                 }
             }
         },
-        query(frame) {
-            return models.Base.Model.generateSlug(allowedTypes[frame.options.type], frame.data.name, {status: 'all', modelId: frame.options.id})
-                .then((slug) => {
-                    if (!slug) {
-                        return Promise.reject(new errors.InternalServerError({
-                            message: tpl(messages.couldNotGenerateSlug)
-                        }));
-                    }
-                    return slug;
+        async query(frame) {
+            const slug = await models.Base.Model.generateSlug(allowedTypes[frame.options.type], frame.data.name, {status: 'all', modelId: frame.options.id});
+            if (!slug) {
+                throw new errors.InternalServerError({
+                    message: tpl(messages.couldNotGenerateSlug)
                 });
+            }
+            return slug;
         }
     }
 };

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

@@ -46,17 +46,15 @@ const controller = {
             'id'
         ],
         permissions: true,
-        query(frame) {
-            return models.Snippet.findOne(frame.data, frame.options)
-                .then((model) => {
-                    if (!model) {
-                        return Promise.reject(new errors.NotFoundError({
-                            message: tpl(messages.snippetNotFound)
-                        }));
-                    }
-
-                    return model;
+        async query(frame) {
+            const model = await models.Snippet.findOne(frame.data, frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.snippetNotFound)
                 });
+            }
+
+            return model;
         }
     },
 
@@ -97,17 +95,15 @@ const controller = {
             }
         },
         permissions: true,
-        query(frame) {
-            return models.Snippet.edit(frame.data.snippets[0], frame.options)
-                .then((model) => {
-                    if (!model) {
-                        return Promise.reject(new errors.NotFoundError({
-                            message: tpl(messages.snippetNotFound)
-                        }));
-                    }
-
-                    return model;
+        async query(frame) {
+            const model = await models.Snippet.edit(frame.data.snippets[0], frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.snippetNotFound)
                 });
+            }
+
+            return model;
         }
     },
 

package/core/server/api/endpoints/tags-public.js

@@ -63,17 +63,15 @@ const controller = {
             }
         },
         permissions: true,
-        query(frame) {
-            return models.TagPublic.findOne(frame.data, frame.options)
-                .then((model) => {
-                    if (!model) {
-                        return Promise.reject(new errors.NotFoundError({
-                            message: tpl(messages.tagNotFound)
-                        }));
-                    }
-
-                    return model;
+        async query(frame) {
+            const model = await models.TagPublic.findOne(frame.data, frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.tagNotFound)
                 });
+            }
+
+            return model;
         }
     }
 };

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

@@ -61,17 +61,15 @@ const controller = {
             }
         },
         permissions: true,
-        query(frame) {
-            return models.Tag.findOne(frame.data, frame.options)
-                .then((model) => {
-                    if (!model) {
-                        return Promise.reject(new errors.NotFoundError({
-                            message: tpl(messages.tagNotFound)
-                        }));
-                    }
-
-                    return model;
+        async query(frame) {
+            const model = await models.Tag.findOne(frame.data, frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.tagNotFound)
                 });
+            }
+
+            return model;
         }
     },
 
@@ -115,21 +113,19 @@ const controller = {
             }
         },
         permissions: true,
-        query(frame) {
-            return models.Tag.edit(frame.data.tags[0], frame.options)
-                .then((model) => {
-                    if (!model) {
-                        return Promise.reject(new errors.NotFoundError({
-                            message: tpl(messages.tagNotFound)
-                        }));
-                    }
+        async query(frame) {
+            const model = await models.Tag.edit(frame.data.tags[0], frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.tagNotFound)
+                });
+            }
 
-                    if (model.wasChanged()) {
-                        frame.setHeader('X-Cache-Invalidate', '/*');
-                    }
+            if (model.wasChanged()) {
+                frame.setHeader('X-Cache-Invalidate', '/*');
+            }
 
-                    return model;
-                });
+            return model;
         }
     },
 

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

@@ -123,14 +123,12 @@ const controller = {
                 name: frame.file.originalname
             };
 
-            return themeService.api.setFromZip(zip)
-                .then(({theme, themeOverridden}) => {
-                    if (themeOverridden) {
-                        frame.setHeader('X-Cache-Invalidate', '/*');
-                    }
-                    events.emit('theme.uploaded', {name: theme.name});
-                    return theme;
-                });
+            const {theme, themeOverridden} = await themeService.api.setFromZip(zip);
+            if (themeOverridden) {
+                frame.setHeader('X-Cache-Invalidate', '/*');
+            }
+            events.emit('theme.uploaded', {name: theme.name});
+            return theme;
         }
     },
 

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

@@ -134,17 +134,15 @@ const controller = {
             }
         },
         permissions: true,
-        query(frame) {
-            return models.User.findOne(frame.data, frame.options)
-                .then((model) => {
-                    if (!model) {
-                        return Promise.reject(new errors.NotFoundError({
-                            message: tpl(messages.userNotFound)
-                        }));
-                    }
-
-                    return model;
+        async query(frame) {
+            const model = await models.User.findOne(frame.data, frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.userNotFound)
                 });
+            }
+
+            return model;
         }
     },
 
@@ -169,21 +167,19 @@ const controller = {
         permissions: {
             unsafeAttrs: UNSAFE_ATTRS
         },
-        query(frame) {
-            return models.User.edit(frame.data.users[0], frame.options)
-                .then((model) => {
-                    if (!model) {
-                        return Promise.reject(new errors.NotFoundError({
-                            message: tpl(messages.userNotFound)
-                        }));
-                    }
+        async query(frame) {
+            const model = await models.User.edit(frame.data.users[0], frame.options);
+            if (!model) {
+                throw new errors.NotFoundError({
+                    message: tpl(messages.userNotFound)
+                });
+            }
 
-                    if (shouldInvalidateCacheAfterChange(model)) {
-                        frame.setHeader('X-Cache-Invalidate', '/*');
-                    }
+            if (shouldInvalidateCacheAfterChange(model)) {
+                frame.setHeader('X-Cache-Invalidate', '/*');
+            }
 
-                    return model;
-                });
+            return model;
         }
     },
 
@@ -203,11 +199,13 @@ const controller = {
         },
         permissions: true,
         async query(frame) {
-            return userService.destroyUser(frame.options).catch((err) => {
-                return Promise.reject(new errors.NoPermissionError({
+            try {
+                return userService.destroyUser(frame.options);
+            } catch (err) {
+                throw new errors.NoPermissionError({
                     err: err
-                }));
-            });
+                });
+            }
         }
     },
 
@@ -240,11 +238,9 @@ const controller = {
         headers: {
             cacheInvalidate: false
         },
-        permissions(frame) {
-            return models.Role.findOne({name: 'Owner'})
-                .then((ownerRole) => {
-                    return permissionsService.canThis(frame.options.context).assign.role(ownerRole);
-                });
+        async permissions(frame) {
+            const ownerRole = await models.Role.findOne({name: 'Owner'});
+            return permissionsService.canThis(frame.options.context).assign.role(ownerRole);
         },
         query(frame) {
             return models.User.transferOwnership(frame.data.owner[0], frame.options);
@@ -287,11 +283,10 @@ const controller = {
             }
         },
         permissions: permissionOnlySelf,
-        query(frame) {
+        async query(frame) {
             const targetId = getTargetId(frame);
-            return fetchOrCreatePersonalToken(targetId).then((model) => {
-                return models.ApiKey.refreshSecret(model.toJSON(), Object.assign({}, {id: model.id}));
-            });
+            const model = await fetchOrCreatePersonalToken(targetId);
+            return models.ApiKey.refreshSecret(model.toJSON(), Object.assign({}, {id: model.id}));
         }
     }
 };

package/core/server/api/endpoints/utils/permissions.js

@@ -15,7 +15,7 @@ const messages = {
  * @param {import('@tryghost/api-framework').Frame} frame
  * @return {Promise}
  */
-const nonePublicAuth = (apiConfig, frame) => {
+const nonePublicAuth = async (apiConfig, frame) => {
     debug('check admin permissions');
 
     let singular;
@@ -40,9 +40,9 @@ const nonePublicAuth = (apiConfig, frame) => {
         unsafeAttrObject = apiConfig.unsafeAttrsObject(frame);
     }
 
-    const permsPromise = permissions.canThis(frame.options.context)[apiConfig.method][singular](permissionIdentifier, unsafeAttrObject);
+    try {
+        const result = await permissions.canThis(frame.options.context)[apiConfig.method][singular](permissionIdentifier, unsafeAttrObject);
 
-    return permsPromise.then((result) => {
         /*
          * Allow the permissions function to return a list of excluded attributes.
          * If it does, omit those attrs from the data passed through
@@ -56,23 +56,23 @@ const nonePublicAuth = (apiConfig, frame) => {
         if (result && result.excludedAttrs && _.has(frame, `data.[${apiConfig.docName}][0]`)) {
             frame.data[apiConfig.docName][0] = _.omit(frame.data[apiConfig.docName][0], result.excludedAttrs);
         }
-    }).catch((err) => {
+    } catch (err) {
         if (err instanceof errors.NoPermissionError) {
             err.message = tpl(messages.noPermissionToCall, {
                 method: apiConfig.method,
                 docName: apiConfig.docName
             });
-            return Promise.reject(err);
+            throw err;
         }
 
         if (errors.utils.isGhostError(err)) {
-            return Promise.reject(err);
+            throw err;
         }
 
-        return Promise.reject(new errors.InternalServerError({
-            err: err
-        }));
-    });
+        throw new errors.InternalServerError({
+            err
+        });
+    }
 };
 
 // @TODO: https://github.com/TryGhost/Ghost/issues/10735

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

@@ -2,7 +2,7 @@ const debug = require('@tryghost/debug')('api:endpoints:utils:serializers:output
 const canThis = require('../../../../../services/permissions').canThis;
 
 module.exports = {
-    browse(models, apiConfig, frame) {
+    async browse(models, apiConfig, frame) {
         debug('browse');
 
         const roles = models.toJSON(frame.options);
@@ -12,7 +12,7 @@ module.exports = {
                 roles: roles
             };
         } else {
-            return Promise.all(
+            const results = await Promise.all(
                 roles.map(async (role) => {
                     let permissionResult;
                     try {
@@ -21,14 +21,13 @@ module.exports = {
                     } catch (err) {
                         permissionResult = {};
                     }
-                    return permissionResult && permissionResult.name && (permissionResult.name !== 'Owner');   
-                }))
-                .then(results => roles.filter((_v, index) => results[index]))   
-                .then((filteredRoles) => {
-                    return frame.response = {
-                        roles: filteredRoles
-                    };
-                });
+                    return permissionResult && permissionResult.name && (permissionResult.name !== 'Owner');
+                })
+            );
+            const filteredRoles = roles.filter((_v, index) => results[index]);
+            return frame.response = {
+                roles: filteredRoles
+            };
         }
     }
 };