ghost 6.56.0 → 6.57.0

package/core/server/services/slack-ping/slack-ping-service.ts

@@ -9,9 +9,7 @@ type SettingsCache = {
 };
 
 type UrlService = {
-    facade: {
-        getUrlForResource(resource: Record<string, unknown>, options: {absolute: boolean}): string | null;
-    };
+    getUrlForResource(resource: Record<string, unknown>, options: {absolute: boolean}): string | null;
 };
 
 type UrlUtils = {
@@ -126,7 +124,7 @@ export class SlackPingService {
 
         // If this is a post, we want to send the link of the post
         if (hasPostProperties(post)) {
-            message = this.urlService.facade.getUrlForResource({...post, type: 'posts'}, {absolute: true});
+            message = this.urlService.getUrlForResource({...post, type: 'posts'}, {absolute: true});
             title = post.title ? post.title : null;
             author = post.authors ? post.authors[0] : null;
 
@@ -214,7 +212,7 @@ export class SlackPingService {
                             fields: [
                                 {
                                     title: 'Author',
-                                    value: author ? `<${this.urlService.facade.getUrlForResource({...author, type: 'authors'}, {absolute: true})} | ${author.name}>` : null,
+                                    value: author ? `<${this.urlService.getUrlForResource({...author, type: 'authors'}, {absolute: true})} | ${author.name}>` : null,
                                     short: true
                                 }
                             ],

package/core/server/services/stats/content-stats-service.js

@@ -199,7 +199,7 @@ class ContentStatsService {
         }
 
         try {
-            const resource = await this.urlService.facade.resolveUrl(pathname);
+            const resource = await this.urlService.resolveUrl(pathname);
 
             if (resource) {
                 // resource.type is the routing-level plural form (posts/pages/tags/authors).
@@ -251,8 +251,8 @@ class ContentStatsService {
             if (this.urlService && item.pathname) {
                 try {
                     // Check if URL service is ready
-                    if (this.urlService.facade.hasFinished && this.urlService.facade.hasFinished()) {
-                        const resource = await this.urlService.facade.resolveUrl(item.pathname);
+                    if (this.urlService.hasFinished && this.urlService.hasFinished()) {
+                        const resource = await this.urlService.resolveUrl(item.pathname);
                         urlExists = !!resource; // Convert to boolean
                     }
                     // If URL service isn't ready, we default to true (clickable)

package/core/server/services/stats/posts-stats-service.js

@@ -222,8 +222,8 @@ class PostsStatsService {
             if (this.urlService && row.attribution_url) {
                 try {
                     // Check if URL service is ready
-                    if (this.urlService.facade.hasFinished && this.urlService.facade.hasFinished()) {
-                        const resource = await this.urlService.facade.resolveUrl(row.attribution_url);
+                    if (this.urlService.hasFinished && this.urlService.hasFinished()) {
+                        const resource = await this.urlService.resolveUrl(row.attribution_url);
                         urlExists = !!resource; // Convert to boolean
                     }
                     // If URL service isn't ready, we default to true (clickable)

package/core/server/services/url/config.js

@@ -1,153 +1,108 @@
 /*
- * These are the default resources and filters.
- * They contain minimum filters for public accessibility of resources.
+ * Columns a routes.yaml filter must not be evaluated against.
+ *
+ * Ghost used to answer URLs from a map precomputed at boot, and kept that map
+ * lean by dropping these columns from every cached record. A collection filter
+ * referencing one therefore matched it as absent, which NQL reads as null. The
+ * URL service loads full records and would see the real value, so it strips
+ * these before evaluating a filter — otherwise routes.yaml files written
+ * against the old behaviour would start routing differently.
+ *
+ * `lazy-find-resource` strips the same columns so a resolved resource has the
+ * shape callers have always seen.
  */
 
 // TODO: switch exclude lists to include lists to make this more explicit
 module.exports = [
     {
         type: 'posts',
-        modelOptions: {
-            modelName: 'Post',
-            filter: 'status:published+type:post',
-            exclude: [
-                'title',
-                'mobiledoc',
-                'lexical',
-                'html',
-                'plaintext',
-                // @TODO: https://github.com/TryGhost/Ghost/issues/10335
-                // 'page',
-                'status',
-                'codeinjection_head',
-                'codeinjection_foot',
-                'meta_title',
-                'meta_description',
-                'custom_excerpt',
-                'og_image',
-                'og_title',
-                'og_description',
-                'twitter_image',
-                'twitter_title',
-                'twitter_description',
-                'custom_template',
-                'locale',
-                'newsletter_id',
-                'show_title_and_feature_image',
-                'email_recipient_filter',
-                'comment_id',
-                'tiers'
-            ],
-            withRelated: ['tags', 'authors'],
-            withRelatedPrimary: {
-                primary_tag: 'tags',
-                primary_author: 'authors'
-            },
-            withRelatedFields: {
-                tags: ['tags.id', 'tags.slug'],
-                authors: ['users.id', 'users.slug']
-            }
-        },
-        events: {
-            add: 'post.published',
-            update: 'post.published.edited',
-            remove: 'post.unpublished'
-        }
+        exclude: [
+            'title',
+            'mobiledoc',
+            'lexical',
+            'html',
+            'plaintext',
+            // @TODO: https://github.com/TryGhost/Ghost/issues/10335
+            // 'page',
+            'status',
+            'codeinjection_head',
+            'codeinjection_foot',
+            'meta_title',
+            'meta_description',
+            'custom_excerpt',
+            'og_image',
+            'og_title',
+            'og_description',
+            'twitter_image',
+            'twitter_title',
+            'twitter_description',
+            'custom_template',
+            'locale',
+            'newsletter_id',
+            'show_title_and_feature_image',
+            'email_recipient_filter',
+            'comment_id',
+            'tiers'
+        ]
     },
     {
         type: 'pages',
-        modelOptions: {
-            modelName: 'Post',
-            exclude: [
-                'title',
-                'mobiledoc',
-                'lexical',
-                'html',
-                'plaintext',
-                // @TODO: https://github.com/TryGhost/Ghost/issues/10335
-                // 'page',
-                // 'status',
-                'codeinjection_head',
-                'codeinjection_foot',
-                'meta_title',
-                'meta_description',
-                'custom_excerpt',
-                'og_image',
-                'og_title',
-                'og_description',
-                'twitter_image',
-                'twitter_title',
-                'twitter_description',
-                'custom_template',
-                'locale',
-                'tags',
-                'authors',
-                'primary_tag',
-                'primary_author',
-                'newsletter_id',
-                'show_title_and_feature_image',
-                'email_recipient_filter',
-                'comment_id',
-                'tiers'
-            ],
-            filter: 'status:published+type:page'
-        },
-        events: {
-            add: 'page.published',
-            update: 'page.published.edited',
-            remove: 'page.unpublished'
-        }
+        exclude: [
+            'title',
+            'mobiledoc',
+            'lexical',
+            'html',
+            'plaintext',
+            // @TODO: https://github.com/TryGhost/Ghost/issues/10335
+            // 'page',
+            // 'status',
+            'codeinjection_head',
+            'codeinjection_foot',
+            'meta_title',
+            'meta_description',
+            'custom_excerpt',
+            'og_image',
+            'og_title',
+            'og_description',
+            'twitter_image',
+            'twitter_title',
+            'twitter_description',
+            'custom_template',
+            'locale',
+            'tags',
+            'authors',
+            'primary_tag',
+            'primary_author',
+            'newsletter_id',
+            'show_title_and_feature_image',
+            'email_recipient_filter',
+            'comment_id',
+            'tiers'
+        ]
     },
     {
         type: 'tags',
-        keep: ['id', 'slug'],
-        modelOptions: {
-            modelName: 'Tag',
-            exclude: [
-                'description',
-                'meta_title',
-                'meta_description',
-                'parent_id'
-            ],
-            filter: 'visibility:public',
-            shouldHavePosts: {
-                joinTo: 'tag_id',
-                joinTable: 'posts_tags'
-            }
-        },
-        events: {
-            add: 'tag.added',
-            update: ['tag.edited', 'tag.attached', 'tag.detached'],
-            remove: 'tag.deleted'
-        }
+        exclude: [
+            'description',
+            'meta_title',
+            'meta_description',
+            'parent_id'
+        ]
     },
     {
         type: 'authors',
-        modelOptions: {
-            modelName: 'User',
-            exclude: [
-                'bio',
-                'website',
-                'location',
-                'facebook',
-                'twitter',
-                'locale',
-                'accessibility',
-                'meta_title',
-                'meta_description',
-                'tour',
-                'last_seen'
-            ],
-            filter: 'visibility:public',
-            shouldHavePosts: {
-                joinTo: 'author_id',
-                joinTable: 'posts_authors'
-            }
-        },
-        events: {
-            add: 'user.activated',
-            update: ['user.activated.edited', 'user.attached', 'user.detached'],
-            remove: 'user.deleted'
-        }
+        exclude: [
+            'bio',
+            'website',
+            'location',
+            'facebook',
+            'twitter',
+            'locale',
+            'accessibility',
+            'meta_title',
+            'meta_description',
+            'tour',
+            'last_seen'
+        ]
     }
 ];

package/core/server/services/url/index.js

@@ -1,50 +1,7 @@
-const config = require('../../../shared/config');
-const LocalFileCache = require('./local-file-cache');
-const UrlService = require('./url-service');
-const UrlServiceFacade = require('./url-service-facade');
+const LazyUrlService = require('./lazy-url-service');
+const {createFindResource} = require('./lazy-find-resource');
+const models = require('../../models');
 
-// NOTE: instead of a path we could give UrlService a "data-resolver" of some sort
-//       so it doesn't have to contain the logic to read data at all. This would be
-//       a possible improvement in the future
-let writeDisabled = false;
-let storagePath = config.getContentPath('data');
-
-// TODO: remove this hack in favor of loading from the content path when it's possible to do so
-//       by mocking content folders in pre-boot phase
-if (process.env.NODE_ENV.startsWith('test')){
-    storagePath = config.get('paths').urlCache;
-
-    // NOTE: prevents test suites from overwriting cache fixtures.
-    //       A better solution would be injecting a different implementation of the
-    //       cache based on the environment, this approach should do the trick for now
-    writeDisabled = true;
-}
-
-const cache = new LocalFileCache({storagePath, writeDisabled});
-const urlService = new UrlService({cache});
-
-// Build a lazy backend alongside eager for shadow comparison, gated by the
-// existing `lazyRouting` flag (unset by default = pure eager, unchanged).
-// models is already loaded via url-service -> resources, so this require is safe.
-let lazyUrlService = null;
-let fetchRoutableResources = null;
-if (config.get('lazyRouting')) {
-    const LazyUrlService = require('./lazy-url-service');
-    const {createFindResource} = require('./lazy-find-resource');
-    const {createFetchRoutableResources} = require('./routable-resources');
-    const models = require('../../models');
-    lazyUrlService = new LazyUrlService({findResource: createFindResource(models)});
-    fetchRoutableResources = createFetchRoutableResources({lazyUrlService});
-}
-
-const urlServiceFacade = lazyUrlService
-    ? new UrlServiceFacade({urlService, lazyUrlService, compare: true, fetchRoutableResources})
-    : new UrlServiceFacade({urlService});
-
-// Singleton: default export remains the eager UrlService for backwards
-// compatibility with existing imports. The new facade is exposed alongside
-// it via `urlService.facade` so RouterManager and migrating callers can
-// reach for it without forcing every consumer to update at once.
-urlService.facade = urlServiceFacade;
-
-module.exports = urlService;
+// Singleton: every caller shares the router registrations made by
+// RouterManager at boot and on every routes.yaml reload.
+module.exports = new LazyUrlService({findResource: createFindResource(models)});

package/core/server/services/url/lazy-find-resource.js

@@ -7,15 +7,17 @@ const POST_SCOPE = { type: 'post', status: 'published' };
 const PAGE_SCOPE = { type: 'page', status: 'published' };
 const POST_RELATIONS = ['tags', 'authors'];
 const RELATION_KEYS = ['tags', 'authors', 'primary_tag', 'primary_author'];
-// Drop the same fields the eager resourceConfig excludes so the resolved record
-// has the same shape the eager service exposes (no post body, no extra
-// author/tag fields). posts_meta is an auto-loaded relation eager never keeps.
+// Drop the same columns the URL service excludes from filter evaluation, so a
+// resolved record keeps the shape callers have always seen (no post body, no
+// extra author/tag fields). posts_meta is an auto-loaded relation Ghost has
+// never exposed here.
 function excludeFor(type) {
     const cfg = resourcesConfig.find((c) => c.type === type);
-    const exclude = (cfg && cfg.modelOptions.exclude) || [];
+    const exclude = cfg?.exclude ?? [];
     return [...exclude, 'posts_meta'];
 }
-// Eager trims relations to {id, slug} via withRelatedFields; match that.
+// Relations are trimmed to {id, slug}: permalinks and filters read nothing
+// else off them, and callers have never seen more.
 function trimRelation(value) {
     if (Array.isArray(value)) {
         return value.map(item => _.pick(item, ['id', 'slug']));
@@ -25,11 +27,11 @@ function trimRelation(value) {
     }
     return value;
 }
-function pruneToEagerShape(record, type) {
+function pruneToPublicShape(record, type) {
     const pruned = _.omit(record, excludeFor(type));
     if (type === 'pages') {
-        // Eager always exposes primary_tag/primary_author as null on pages (they
-        // are virtual Post fields) but never carries the tags/authors arrays.
+        // primary_tag/primary_author are always null on pages (they are virtual
+        // Post fields), and pages never carry the tags/authors arrays.
         pruned.primary_tag = null;
         pruned.primary_author = null;
         return pruned;
@@ -43,8 +45,9 @@ function pruneToEagerShape(record, type) {
 }
 /**
  * Builds the per-request DB lookup hook injected into LazyUrlService.resolveUrl.
- * Visibility rules mirror the eager service so a guessed slug can't surface
- * anything the eager path hid; unknown types resolve to null.
+ * Visibility rules match the forward lookup's base filters, so a guessed slug
+ * can't surface anything a generated URL would have hidden; unknown types
+ * resolve to null.
  */
 function createFindResource(models) {
     const loadOne = async (Model, query, type, options = {}) => {
@@ -57,7 +60,7 @@ function createFindResource(models) {
         if (Array.isArray(record.authors)) {
             record.primary_author = record.authors[0] ?? null;
         }
-        return pruneToEagerShape(record, type);
+        return pruneToPublicShape(record, type);
     };
     return (type, params) => {
         switch (type) {

package/core/server/services/url/lazy-find-resource.ts

@@ -18,16 +18,18 @@ const PAGE_SCOPE = {type: 'page', status: 'published'};
 const POST_RELATIONS = ['tags', 'authors'];
 const RELATION_KEYS = ['tags', 'authors', 'primary_tag', 'primary_author'];
 
-// Drop the same fields the eager resourceConfig excludes so the resolved record
-// has the same shape the eager service exposes (no post body, no extra
-// author/tag fields). posts_meta is an auto-loaded relation eager never keeps.
+// Drop the same columns the URL service excludes from filter evaluation, so a
+// resolved record keeps the shape callers have always seen (no post body, no
+// extra author/tag fields). posts_meta is an auto-loaded relation Ghost has
+// never exposed here.
 function excludeFor(type: string): string[] {
     const cfg = resourcesConfig.find((c: {type: string}) => c.type === type);
-    const exclude = (cfg && cfg.modelOptions.exclude) || [];
+    const exclude = cfg?.exclude ?? [];
     return [...exclude, 'posts_meta'];
 }
 
-// Eager trims relations to {id, slug} via withRelatedFields; match that.
+// Relations are trimmed to {id, slug}: permalinks and filters read nothing
+// else off them, and callers have never seen more.
 function trimRelation(value: unknown): unknown {
     if (Array.isArray(value)) {
         return value.map(item => _.pick(item, ['id', 'slug']));
@@ -38,12 +40,12 @@ function trimRelation(value: unknown): unknown {
     return value;
 }
 
-function pruneToEagerShape(record: Record<string, unknown>, type: string): Record<string, unknown> {
+function pruneToPublicShape(record: Record<string, unknown>, type: string): Record<string, unknown> {
     const pruned = _.omit(record, excludeFor(type));
 
     if (type === 'pages') {
-        // Eager always exposes primary_tag/primary_author as null on pages (they
-        // are virtual Post fields) but never carries the tags/authors arrays.
+        // primary_tag/primary_author are always null on pages (they are virtual
+        // Post fields), and pages never carry the tags/authors arrays.
         pruned.primary_tag = null;
         pruned.primary_author = null;
         return pruned;
@@ -59,8 +61,9 @@ function pruneToEagerShape(record: Record<string, unknown>, type: string): Recor
 
 /**
  * Builds the per-request DB lookup hook injected into LazyUrlService.resolveUrl.
- * Visibility rules mirror the eager service so a guessed slug can't surface
- * anything the eager path hid; unknown types resolve to null.
+ * Visibility rules match the forward lookup's base filters, so a guessed slug
+ * can't surface anything a generated URL would have hidden; unknown types
+ * resolve to null.
  */
 export function createFindResource(models: Models): FindResource {
     const loadOne = async (
@@ -78,7 +81,7 @@ export function createFindResource(models: Models): FindResource {
         if (Array.isArray(record.authors)) {
             record.primary_author = record.authors[0] ?? null;
         }
-        return pruneToEagerShape(record, type);
+        return pruneToPublicShape(record, type);
     };
 
     return (type: string, params: ResourceLookupParams): Promise<Record<string, unknown> | null> => {