@teleporthq/teleport-plugin-next-data-source 0.43.67 → 0.43.68

package/src/items-path.ts

@@ -0,0 +1,74 @@
+import * as types from '@babel/types'
+
+/**
+ * Where a paginated/searchable list's rows sit inside the payload its data
+ * source returns, read off the repeater's `source` expression.
+ *
+ * A REST API or JavaScript source may answer `{ templates: [...], total }`, and
+ * the editor binds the list to `All_Templates_data_data?.templates || []`. The
+ * generated fetcher only searches, filters, sorts and slices a payload that IS
+ * an array, so without this every row came back on every page (the canvas
+ * slices on the client and looked right) and the count measured the wrapper as
+ * 0 rows, disabling "Next".
+ *
+ * Returns undefined when the list is bound to the payload itself, or when the
+ * source is anything other than a plain property chain off the data source's
+ * render prop — an expression this cannot read is left exactly as before.
+ */
+const SEGMENT_RE =
+  /^(?:\?\.([A-Za-z_$][\w$]*)|\.([A-Za-z_$][\w$]*)|(?:\?\.)?\[\s*(?:"([^"]*)"|'([^']*)')\s*\])/
+
+const PATH_AWARE_SOURCE_TYPES = new Set(['rest-api', 'javascript'])
+
+export const extractItemsPath = (
+  source: unknown,
+  dataSourceIdentifier: string,
+  dataSourceType: string
+): string[] | undefined => {
+  if (typeof source !== 'string' || !dataSourceIdentifier) {
+    return undefined
+  }
+  if (!PATH_AWARE_SOURCE_TYPES.has(dataSourceType)) {
+    return undefined
+  }
+
+  let rest = source
+    .trim()
+    .replace(/\s*\|\|\s*\[\s*\]$/, '')
+    .trim()
+  if (!rest.startsWith(dataSourceIdentifier)) {
+    return undefined
+  }
+  rest = rest.slice(dataSourceIdentifier.length)
+
+  const path: string[] = []
+  while (rest.length > 0) {
+    const match = rest.match(SEGMENT_RE)
+    if (!match) {
+      return undefined
+    }
+    path.push(match[1] ?? match[2] ?? match[3] ?? match[4])
+    rest = rest.slice(match[0].length)
+  }
+
+  return path.length > 0 ? path : undefined
+}
+
+/**
+ * Push `<key>: '["templates"]'` onto a params object. Fetch calls send it as
+ * `itemsPath` (process the inner array, keep the wrapper the page reads back
+ * through); count calls send it as `collectionPath`, so the count handler
+ * measures the inner array instead of the wrapper.
+ */
+export const appendItemsPathParam = (
+  paramsProps: types.ObjectProperty[],
+  itemsPath: string[] | undefined,
+  key: 'itemsPath' | 'collectionPath'
+): void => {
+  if (!itemsPath || itemsPath.length === 0) {
+    return
+  }
+  paramsProps.push(
+    types.objectProperty(types.identifier(key), types.stringLiteral(JSON.stringify(itemsPath)))
+  )
+}

package/src/localized-columns.ts

@@ -118,6 +118,19 @@ export const generateLocalizedColumnsHelper = (families: LocalizedColumnMap): st
     "  return '(' + clauses.join(' OR ') + ')'",
     '}',
     '',
+    '// A translatable list (tags) and its per-language copies, for a filter that',
+    '// matches a value in ANY language (a localized tag link resolves under every',
+    '// locale, like a localized slug). Null for a column with no copies.',
+    'function localizedColumnList(field) {',
+    '  var copies = LOCALIZED_COLUMNS[field]',
+    '  if (!copies) return null',
+    '  var columns = [quoteLocalizedColumn(field)]',
+    '  for (var locale in copies) {',
+    '    if (Object.prototype.hasOwnProperty.call(copies, locale)) columns.push(quoteLocalizedColumn(copies[locale]))',
+    '  }',
+    '  return columns',
+    '}',
+    '',
     "// ORDER BY a translatable column in the request's language, falling back to",
     '// the base column for a row with no translation — the same resolution the',
     '// row transform applies to what is displayed. Null when the field or the',

package/src/pagination-plugin.ts

@@ -13,6 +13,7 @@ import { generateDataSourceFetcherWithCore } from './data-source-fetchers'
 import { buildProductTransformOptions, type EntityTransformOptions } from './transformations'
 import { appendSortsParam, DynamicSortAST, extractDynamicSort } from './sort-utils'
 import { appendFiltersParam, pushStateIdsAsDeps, pushPropIdsAsDeps } from './filter-utils'
+import { appendItemsPathParam, extractItemsPath } from './items-path'
 import {
   applyLoadingStateToDataProvider,
   buildLoadingStateDeclarations,
@@ -255,6 +256,9 @@ interface DataSourceUsage {
   // `URLSearchParamSync` builders. Page 1 is written as the ABSENCE of the key.
   // Cleared when `infiniteScroll` is set.
   pageUrlParamKey?: string
+  // Path to the rows inside a wrapped REST/JavaScript payload, when the list is
+  // bound to one (`data?.templates` -> `['templates']`). See `items-path.ts`.
+  itemsPath?: string[]
   // Computed category
   category: 'paginated+search' | 'paginated-only' | 'search-only' | 'plain'
 }
@@ -656,6 +660,11 @@ function buildStateRegistry(uidlNode: any): StateRegistry {
           infiniteScroll,
           infiniteScrollLoadMore: infiniteScroll && !!content.infiniteScrollLoadMore,
           pageUrlParamKey,
+          itemsPath: extractItemsPath(
+            content.source,
+            parentDataSource.identifier,
+            parentDataSource.resourceDef.dataSourceType || ''
+          ),
           category: 'plain',
         }
 
@@ -1410,6 +1419,7 @@ export const createNextArrayMapperPaginationPlugin: ComponentPluginFactory<{}> =
         }
         // Add filters to count fetch params if present
         appendFiltersParam(urlParams, usage.filters, buildFilterDestinationExpression)
+        appendItemsPathParam(urlParams, usage.itemsPath, 'collectionPath')
 
         const countEffectDeps: types.Expression[] = [
           types.memberExpression(
@@ -1526,6 +1536,7 @@ export const createNextArrayMapperPaginationPlugin: ComponentPluginFactory<{}> =
             )
           }
           appendFiltersParam(countUrlParams, usage.filters, buildFilterDestinationExpression)
+          appendItemsPathParam(countUrlParams, usage.itemsPath, 'collectionPath')
 
           // Default to mount-only; refresh when ANY filter destination
           // changes — state-bound (e.g. `selectedCategory`) and URL-driven —
@@ -2364,6 +2375,7 @@ function updateDataProviderForPaginatedSearch(
 
   // Add filters if present
   appendFiltersParam(paramsProps, usage.filters, buildFilterDestinationExpression)
+  appendItemsPathParam(paramsProps, usage.itemsPath, 'itemsPath')
 
   // Build useMemo dependencies including filter state IDs and dynamic sort state IDs
   const memoDeps: types.Expression[] = [types.identifier(vars.combinedStateVar)]
@@ -2523,6 +2535,7 @@ function updateDataProviderForPaginationOnly(
 
   // Add filters if present
   appendFiltersParam(paramsProps, usage.filters, buildFilterDestinationExpression)
+  appendItemsPathParam(paramsProps, usage.itemsPath, 'itemsPath')
 
   // Build useMemo dependencies including filter state IDs and dynamic sort state IDs
   const memoDeps: types.Expression[] = [types.identifier(vars.pageStateVar)]
@@ -2643,6 +2656,7 @@ function updateDataProviderForSearchOnly(
 
   // Add filters if present
   appendFiltersParam(paramsProps, usage.filters, buildFilterDestinationExpression)
+  appendItemsPathParam(paramsProps, usage.itemsPath, 'itemsPath')
 
   // Build useMemo dependencies including filter state IDs and dynamic sort state IDs
   const memoDeps: types.Expression[] = [types.identifier(vars.debouncedSearchQueryVar)]
@@ -3668,6 +3682,8 @@ function updateGetStaticProps(
         )
       }
 
+      appendItemsPathParam(fetchParams, usage.itemsPath, 'itemsPath')
+
       // The prefetch is per locale — getStaticProps runs once per language.
       if (localized) {
         fetchParams.push(buildServerLocaleParam())
@@ -3749,8 +3765,10 @@ function updateGetStaticProps(
         const staticFiltersForCount = (usage.filters || []).filter(
           (f: any) => !ASTUtils.isUIDLDynamicReference(f.destination)
         )
-        const hasStaticFilters = staticFiltersForCount.length > 0
-        const countVarName = hasStaticFilters
+        // A count scoped to an inner array is a different number from the
+        // whole-payload one, so it gets its own variable just like a filtered one.
+        const hasScopedCount = staticFiltersForCount.length > 0 || !!usage.itemsPath
+        const countVarName = hasScopedCount
           ? `${usage.dataSourceIdentifier}_ds_${usage.index}_count`
           : `${usage.dataSourceIdentifier}_count`
 
@@ -3822,7 +3840,7 @@ function updateGetStaticProps(
     // Group usages by their filters (stringify for comparison)
     const usagesByFilters = new Map<string, DataSourceUsage[]>()
     for (const usage of usagesForDataSource) {
-      const filtersKey = JSON.stringify(usage.filters || [])
+      const filtersKey = JSON.stringify([usage.filters || [], usage.itemsPath || []])
       const existing = usagesByFilters.get(filtersKey) || []
       existing.push(usage)
       usagesByFilters.set(filtersKey, existing)
@@ -3837,10 +3855,12 @@ function updateGetStaticProps(
       )
       const hasStaticFilters = staticFiltersForCount.length > 0
 
-      // Create unique count variable name based on filters
-      const countVarName = hasStaticFilters
-        ? `${firstUsage.dataSourceIdentifier}_ds_${firstUsage.index}_count`
-        : `${firstUsage.dataSourceIdentifier}_count`
+      // Create unique count variable name based on filters (and inner-array
+      // scope — must match the naming at the maxPages site above)
+      const countVarName =
+        hasStaticFilters || firstUsage.itemsPath
+          ? `${firstUsage.dataSourceIdentifier}_ds_${firstUsage.index}_count`
+          : `${firstUsage.dataSourceIdentifier}_count`
 
       // Check if this count was already processed
       const countKey = `${key}:${filtersKey}`
@@ -3892,6 +3912,8 @@ function updateGetStaticProps(
           )
         }
 
+        appendItemsPathParam(countParams, firstUsage.itemsPath, 'collectionPath')
+
         fetchesArray.elements.push(
           types.callExpression(
             types.memberExpression(

package/src/transformations/blog-adjacent-posts.ts

@@ -0,0 +1,74 @@
+/**
+ * How many posts each direction is read, so a neighbour that only REDIRECTS
+ * elsewhere can be stepped over without a second query.
+ */
+const ADJACENT_POST_CANDIDATES = 5
+
+/**
+ * Generates the code that finds a post's neighbours for its "previous / next"
+ * navigation: the published posts right before and after it in the order the
+ * blog listing shows them (`created_at`, then `id`, newest first). "Previous"
+ * is the older one.
+ *
+ * Only a post DETAILS fetch (a single record) asks. A neighbour whose row
+ * carries a redirect is skipped — linking to it would only bounce the reader
+ * somewhere else — which is read off the row in code rather than in SQL, so a
+ * table provisioned before the SEO columns still works.
+ *
+ * MUST mirror `findAdjacentBlogPosts` in teleport-gui
+ * `packages/renderer/src/utils/blog-adjacent-posts.ts` (the canvas).
+ */
+export const generateAdjacentPostsCode = (): string => `
+var BLOG_ADJACENT_CANDIDATES = ${ADJACENT_POST_CANDIDATES}
+
+function blogAdjacentPostsSql(comparison, direction) {
+  return (
+    'SELECT p.* FROM teleport_blog_posts p,' +
+    ' (SELECT created_at, id FROM teleport_blog_posts WHERE id = $1) cur' +
+    " WHERE p.status = 'published' AND (p.created_at, p.id) " + comparison + ' (cur.created_at, cur.id)' +
+    ' ORDER BY p.created_at ' + direction + ', p.id ' + direction +
+    ' LIMIT ' + BLOG_ADJACENT_CANDIDATES
+  )
+}
+
+function firstLinkableBlogPost(result) {
+  var rows = result && Array.isArray(result.rows) ? result.rows : []
+  for (var i = 0; i < rows.length; i++) {
+    var row = rows[i]
+    if (!row) continue
+    var redirect = pickFirst(row.redirect_url, row.redirectUrl)
+    if (typeof redirect === 'string' && redirect.trim() !== '') continue
+    // Through JSON, like the rows the fetcher itself hands the transform.
+    return JSON.parse(JSON.stringify(row))
+  }
+  return null
+}
+
+// { [postId]: { previous, next } } — raw rows or null — for a single-record
+// fetch; {} otherwise and on any failure (the navigation then hides).
+async function getAdjacentPostsMap(getClientFn, records) {
+  var map = {}
+  if (!Array.isArray(records) || records.length !== 1) return map
+  var postId = records[0] && records[0].id
+  if (postId === null || postId === undefined) return map
+
+  var client
+  try {
+    client = getClientFn()
+    await client.connect()
+    var older = await client.query(blogAdjacentPostsSql('<', 'DESC'), [String(postId)])
+    var newer = await client.query(blogAdjacentPostsSql('>', 'ASC'), [String(postId)])
+    map[String(postId)] = {
+      previous: firstLinkableBlogPost(older),
+      next: firstLinkableBlogPost(newer),
+    }
+  } catch (e) {
+    // Leaves the navigation hidden.
+  } finally {
+    if (client) {
+      try { await client.end() } catch (e) { /* ignore */ }
+    }
+  }
+  return map
+}
+`

package/src/transformations/blog-comments.ts

@@ -0,0 +1,132 @@
+/**
+ * How many TOP-LEVEL comments a post page carries: the newest ones, shown
+ * oldest-first, each with all of its replies. The count in the section's
+ * heading still counts every approved comment.
+ *
+ * ⛔ PAIRED with `BLOG_COMMENTS_RENDER_LIMIT` in teleport-gui
+ * `features/blog/constants/blog-comments.ts` (the canvas mirror).
+ */
+export const BLOG_COMMENTS_RENDER_LIMIT = 200
+
+/**
+ * Generates the code that loads and shapes a post's approved comments.
+ *
+ * Read server-side, with the post: only a post DETAILS fetch (a single record)
+ * asks, so a listing never pays for it, and the comments arrive in the page's
+ * HTML — rendered by SSR/ISR, carried along a client-side navigation to another
+ * post, no request of their own.
+ *
+ * Public columns only. `teleport_blog_comments` holds the commenters' email
+ * addresses and the comments still waiting for approval, which is why it is a
+ * customer-record table no browser may read (see teleport-shared's
+ * `table-access.ts`); nothing here selects either.
+ *
+ * Replies are one level deep: a reply whose parent is not among the rows (not
+ * approved, deleted) is dropped rather than promoted to the top level.
+ *
+ * MUST mirror `buildBlogComments` in teleport-gui
+ * `packages/renderer/src/utils/blog-comments.ts` (the canvas).
+ */
+export const generateBlogCommentsCode = (): string => `
+var BLOG_COMMENTS_RENDER_LIMIT = ${BLOG_COMMENTS_RENDER_LIMIT}
+
+var BLOG_COMMENTS_SQL =
+  'WITH top AS (' +
+  ' SELECT id FROM teleport_blog_comments' +
+  " WHERE post_id = $1 AND parent_id IS NULL AND status = 'approved'" +
+  ' ORDER BY created_at DESC, id DESC LIMIT ' + BLOG_COMMENTS_RENDER_LIMIT +
+  ')' +
+  ' SELECT c.id, c.parent_id, c.author_name, c.content, c.is_author_reply, c.created_at' +
+  ' FROM teleport_blog_comments c' +
+  " WHERE c.post_id = $1 AND c.status = 'approved'" +
+  ' AND (c.id IN (SELECT id FROM top) OR c.parent_id IN (SELECT id FROM top))' +
+  ' ORDER BY c.created_at ASC, c.id ASC'
+
+// Every approved comment the page could show — a reply counts only while the
+// comment it answers is approved too.
+var BLOG_COMMENTS_COUNT_SQL =
+  'SELECT COUNT(*) AS n FROM teleport_blog_comments c' +
+  " WHERE c.post_id = $1 AND c.status = 'approved'" +
+  ' AND (c.parent_id IS NULL OR EXISTS (' +
+  ' SELECT 1 FROM teleport_blog_comments p' +
+  " WHERE p.id = c.parent_id AND p.status = 'approved'))"
+
+function blogAuthorInitials(name) {
+  if (typeof name !== 'string') return ''
+  var words = name.trim().split(' ').filter(function(word) { return word !== '' })
+  if (words.length === 0) return ''
+  // Code points, not UTF-16 units: an initial may be an emoji or a letter
+  // outside the BMP, and half of a surrogate pair renders as a box.
+  var first = Array.from(words[0])[0] || ''
+  var last = words.length > 1 ? Array.from(words[words.length - 1])[0] || '' : ''
+  return (first + last).toUpperCase()
+}
+
+function buildBlogComment(row) {
+  var name = typeof row.author_name === 'string' ? row.author_name.trim() : ''
+  var authorName = name || 'Reader'
+  return {
+    id: String(row.id),
+    authorName: authorName,
+    authorInitials: blogAuthorInitials(authorName),
+    content: typeof row.content === 'string' ? row.content : '',
+    createdAt: normalizeTimestamp(row.created_at),
+    isAuthorReply: coerceBoolean(row.is_author_reply, false),
+  }
+}
+
+function isTopLevelComment(row) {
+  return row.parent_id === null || row.parent_id === undefined || row.parent_id === ''
+}
+
+function buildBlogComments(rows) {
+  var comments = []
+  if (!Array.isArray(rows)) return comments
+  var byId = {}
+  for (var i = 0; i < rows.length; i++) {
+    var row = rows[i]
+    if (!row || row.id == null || !isTopLevelComment(row)) continue
+    var comment = buildBlogComment(row)
+    comment.replies = []
+    byId[comment.id] = comment
+    comments.push(comment)
+  }
+  for (var j = 0; j < rows.length; j++) {
+    var reply = rows[j]
+    if (!reply || reply.id == null || isTopLevelComment(reply)) continue
+    var parent = byId[String(reply.parent_id)]
+    if (parent) parent.replies.push(buildBlogComment(reply))
+  }
+  return comments
+}
+
+// { [postId]: { rows, count } } for a single-record (details) fetch; {} for
+// anything else, and on any failure — a blog whose comments table does not
+// exist yet renders its posts without comments rather than failing the page.
+async function getBlogCommentsMap(getClientFn, records) {
+  var map = {}
+  if (!Array.isArray(records) || records.length !== 1) return map
+  var postId = records[0] && records[0].id
+  if (postId === null || postId === undefined) return map
+
+  var client
+  try {
+    client = getClientFn()
+    await client.connect()
+    var listed = await client.query(BLOG_COMMENTS_SQL, [String(postId)])
+    var counted = await client.query(BLOG_COMMENTS_COUNT_SQL, [String(postId)])
+    // Through JSON, like every other row the fetcher hands the transform: the
+    // driver returns timestamps as Date objects.
+    var rows = listed && Array.isArray(listed.rows) ? JSON.parse(JSON.stringify(listed.rows)) : []
+    var count = counted && counted.rows && counted.rows[0] ? Number(counted.rows[0].n) : NaN
+    map[String(postId)] = { rows: rows, count: isNaN(count) ? rows.length : count }
+  } catch (e) {
+    // Leaves the post without comments.
+  } finally {
+    if (client) {
+      try { await client.end() } catch (e) { /* ignore */ }
+    }
+  }
+  return map
+}
+`

package/src/transformations/blog-post.ts

@@ -1,10 +1,15 @@
 import type { UIDLEcommerceCategory } from '@teleporthq/teleport-types'
 import { generateCategoryTaxonomyCode } from './category-taxonomy'
+import { generateAdjacentPostsCode } from './blog-adjacent-posts'
+import { generateBlogCommentsCode } from './blog-comments'
+import { generateHeadingAnchorsCode } from './heading-anchors'
 
 /** What the blog-post transform bakes in at export time beyond the row itself. */
 export interface BlogPostTransformOptions {
   /** Category taxonomy — lives only in the UIDL, there is no DB table for it. */
   categories?: UIDLEcommerceCategory[]
+  /** Content headings get ids and `#` links — see `heading-anchors.ts`. */
+  headingAnchors?: boolean
 }
 
 /**
@@ -20,6 +25,10 @@ export const generateBlogPostTransformationCode = (
 // Blog Post Transformation
 // ============================================================
 ${generateCategoryTaxonomyCode('BLOG_CATEGORIES_BY_ID', options.categories)}
+${generateBlogCommentsCode()}
+${generateAdjacentPostsCode()}
+${generateHeadingAnchorsCode()}
+var BLOG_HEADING_ANCHORS = ${options.headingAnchors === true}
 
 function buildBlogPost(record, options) {
   if (!record || typeof record !== 'object') return record
@@ -34,6 +43,7 @@ function buildBlogPost(record, options) {
   var title = resolveI18nField(record, 'title', 'title', currentLang, mainLang) || ''
   var slug = resolveI18nField(record, 'slug', 'slug', currentLang, mainLang) || ''
   var content = resolveI18nField(record, 'content', 'content', currentLang, mainLang) || ''
+  if (BLOG_HEADING_ANCHORS) content = addHeadingAnchors(content)
   var excerpt = resolveI18nField(record, 'excerpt', 'excerpt', currentLang, mainLang) || ''
   var category = resolveI18nField(record, 'category', 'category', currentLang, mainLang) || null
 
@@ -53,6 +63,7 @@ function buildBlogPost(record, options) {
   var metaTitle = resolveI18nField(record, 'meta_title', 'metaTitle', currentLang, mainLang) || null
   var metaDescription = resolveI18nField(record, 'meta_description', 'metaDescription', currentLang, mainLang) || null
   var featuredImageAlt = resolveI18nField(record, 'featured_image_alt', 'featuredImageAlt', currentLang, mainLang) || null
+  var authorBio = resolveI18nField(record, 'author_bio', 'authorBio', currentLang, mainLang) || null
 
   // Status
   var status = record.status || 'draft'
@@ -78,6 +89,7 @@ function buildBlogPost(record, options) {
 
   // Simple pass-through fields
   var authorName = pickFirst(record.author_name, record.authorName)
+  var authorInitials = blogAuthorInitials(authorName)
   var authorEmail = pickFirst(record.author_email, record.authorEmail)
   var readingTimeMinutes = safeNumber(pickFirst(record.reading_time_minutes, record.readingTimeMinutes), null)
 
@@ -132,12 +144,14 @@ function buildBlogPost(record, options) {
   var relatedPostIds = parseRelatedIds(record.related_post_ids)
   var relatedPostsById = options.relatedPostsById
   var relatedPosts = []
+  // The nested builds of the related and adjacent posts get NO maps: each is a
+  // card, not a page, and two posts that point at each other would recurse.
+  var relatedNestedOptions = {
+    assetMap: assetMap,
+    currentLanguage: currentLang,
+    mainLanguage: mainLang,
+  }
   if (relatedPostsById && relatedPostIds.length > 0) {
-    var relatedNestedOptions = {
-      assetMap: assetMap,
-      currentLanguage: currentLang,
-      mainLanguage: mainLang,
-    }
     for (var rp = 0; rp < relatedPostIds.length; rp++) {
       var relatedId = relatedPostIds[rp]
       if (id != null && relatedId === String(id)) continue
@@ -150,6 +164,19 @@ function buildBlogPost(record, options) {
     }
   }
 
+  // The previous (older) and next (newer) published post, as 0-or-1-item
+  // lists: the post navigation maps over them like the related rail does, so an
+  // end of the blog simply renders no card on that side.
+  var adjacent = options.adjacentPostsById && id != null ? options.adjacentPostsById[String(id)] : null
+  var previousPosts = adjacent && adjacent.previous ? [buildBlogPost(adjacent.previous, relatedNestedOptions)] : []
+  var nextPosts = adjacent && adjacent.next ? [buildBlogPost(adjacent.next, relatedNestedOptions)] : []
+
+  // The approved comments — the newest top-level ones, each with its replies —
+  // present only on a details fetch; see blog-comments.ts.
+  var commentsEntry = options.commentsByPostId && id != null ? options.commentsByPostId[String(id)] : null
+  var comments = commentsEntry ? buildBlogComments(commentsEntry.rows) : []
+  var commentsCount = commentsEntry ? commentsEntry.count : 0
+
   // Timestamps
   var rawPublishedAt = pickFirst(record.published_at, record.publishedAt)
   var publishedAt = rawPublishedAt != null ? normalizeTimestamp(rawPublishedAt) : null
@@ -184,11 +211,17 @@ function buildBlogPost(record, options) {
     author_name: authorName,
     author_email: authorEmail,
     authorAvatarUrl: authorAvatarUrl,
+    authorBio: authorBio,
+    authorInitials: authorInitials,
     metaTitle: metaTitle,
     metaDescription: metaDescription,
     readingTimeMinutes: readingTimeMinutes,
     isFeatured: isFeatured,
     allowComments: allowComments,
+    comments: comments,
+    commentsCount: commentsCount,
+    previousPosts: previousPosts,
+    nextPosts: nextPosts,
     noIndex: noIndex,
     canonicalUrl: canonicalUrl,
     redirectUrl: redirectUrl,