sitero 0.1.7 → 0.3.0

package/dist/src/web/server/resources/post/actions.js

@@ -24,8 +24,8 @@ function createWebPostActions({
 }) {
   const postFindDetailAction = async (input) => {
     const result = await siteroServer.executor.execute(
-      siteroServer.resources.post.findPublic,
-      input,
+      siteroServer.resources.post.findDetail,
+      { ...input, isActive: true },
       {}
     );
     if (!result.success) return result;
@@ -41,8 +41,8 @@ function createWebPostActions({
   };
   const postFindListCardsAction = async (input) => {
     const result = await siteroServer.executor.execute(
-      siteroServer.resources.post.findPublicListCards,
-      input,
+      siteroServer.resources.post.findListCards,
+      { ...input, isActive: true },
       {}
     );
     if (!result.success) return result;
@@ -54,8 +54,8 @@ function createWebPostActions({
   async function hydrateListCardParents(post) {
     if (!post) return post;
     const response = await siteroServer.executor.execute(
-      siteroServer.resources.post.findPublic,
-      { id: post.id },
+      siteroServer.resources.post.findDetail,
+      { id: post.id, isActive: true },
       {}
     );
     if (!response.success) return post;
@@ -73,78 +73,6 @@ function createWebPostActions({
       page: response.success ? response.data?.post : void 0
     };
   };
-  const loadCategory = async ({
-    topicSlug,
-    categorySlug
-  }) => {
-    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.CATEGORY)) {
-      return { category: void 0 };
-    }
-    const response = await postFindDetailAction({
-      type: POST_TYPES.CATEGORY,
-      slug: categorySlug,
-      topicSlug
-    });
-    return {
-      category: response.success ? response.data?.post : void 0
-    };
-  };
-  const loadSubcategory = async ({
-    topicSlug,
-    subcategorySlug
-  }) => {
-    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.SUBCATEGORY)) {
-      return { subcategory: void 0 };
-    }
-    const response = await postFindDetailAction({
-      type: POST_TYPES.SUBCATEGORY,
-      slug: subcategorySlug,
-      topicSlug
-    });
-    return {
-      subcategory: response.success ? response.data?.post : void 0
-    };
-  };
-  const loadPosts = async ({
-    locale,
-    topicSlug,
-    categorySlug,
-    currentPage = 1,
-    pageSize,
-    isFeatured,
-    isShownOnHome,
-    excludeIds,
-    ...params
-  }) => {
-    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.POST)) {
-      return { posts: [], total: 0, totalPages: 1 };
-    }
-    const response = await postFindListCardsAction({
-      ...params,
-      locale,
-      type: POST_TYPES.POST,
-      topicSlug,
-      ...categorySlug ? { parentSlug: categorySlug } : {},
-      page: currentPage,
-      ...pageSize ? { pageSize } : {},
-      ...isFeatured ? { isFeatured } : {},
-      ...isShownOnHome ? { isShownOnHome } : {},
-      ...excludeIds ? { excludeIds } : {}
-    });
-    if (!response.success) {
-      return { posts: [], total: 0, totalPages: 1 };
-    }
-    const posts = await Promise.all(
-      (response.data?.items ?? []).map((post) => hydrateListCardParents(post))
-    );
-    const total = response.data?.total ?? 0;
-    const totalPages = pageSize ? Math.max(1, Math.ceil(total / pageSize)) : 1;
-    return {
-      posts,
-      total,
-      totalPages
-    };
-  };
   const loadCategories = async ({
     locale,
     topicSlug,
@@ -183,6 +111,22 @@ function createWebPostActions({
       )
     };
   };
+  const loadCategory = async ({
+    topicSlug,
+    categorySlug
+  }) => {
+    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.CATEGORY)) {
+      return { category: void 0 };
+    }
+    const response = await postFindDetailAction({
+      type: POST_TYPES.CATEGORY,
+      slug: categorySlug,
+      topicSlug
+    });
+    return {
+      category: response.success ? response.data?.post : void 0
+    };
+  };
   const loadSubcategories = async ({
     locale,
     topicSlug,
@@ -223,6 +167,62 @@ function createWebPostActions({
       )
     };
   };
+  const loadSubcategory = async ({
+    topicSlug,
+    subcategorySlug
+  }) => {
+    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.SUBCATEGORY)) {
+      return { subcategory: void 0 };
+    }
+    const response = await postFindDetailAction({
+      type: POST_TYPES.SUBCATEGORY,
+      slug: subcategorySlug,
+      topicSlug
+    });
+    return {
+      subcategory: response.success ? response.data?.post : void 0
+    };
+  };
+  const loadPosts = async ({
+    locale,
+    topicSlug,
+    categorySlug,
+    currentPage = 1,
+    pageSize,
+    isFeatured,
+    isShownOnHome,
+    excludeIds,
+    ...params
+  }) => {
+    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.POST)) {
+      return { posts: [], total: 0, totalPages: 1 };
+    }
+    const response = await postFindListCardsAction({
+      ...params,
+      locale,
+      type: POST_TYPES.POST,
+      topicSlug,
+      ...categorySlug ? { parentSlug: categorySlug } : {},
+      page: currentPage,
+      ...pageSize ? { pageSize } : {},
+      ...isFeatured ? { isFeatured } : {},
+      ...isShownOnHome ? { isShownOnHome } : {},
+      ...excludeIds ? { excludeIds } : {}
+    });
+    if (!response.success) {
+      return { posts: [], total: 0, totalPages: 1 };
+    }
+    const posts = await Promise.all(
+      (response.data?.items ?? []).map((post) => hydrateListCardParents(post))
+    );
+    const total = response.data?.total ?? 0;
+    const totalPages = pageSize ? Math.max(1, Math.ceil(total / pageSize)) : 1;
+    return {
+      posts,
+      total,
+      totalPages
+    };
+  };
   const loadPost = async ({
     topicSlug,
     slug

package/dist/src/web/server/seo/create-web-seo.js

@@ -3,7 +3,6 @@ import { createResolveUrls } from './metadata/resolve-urls.js';
 import { createBuildMetadata } from './metadata/build-metadata.js';
 import { createBuildUrlsFromPathname } from './sitemap/build-urls-from-pathname.js';
 import { createGetPageItems } from './sitemap/get-page-items.js';
-import { createGetFlatPostItems } from './sitemap/get-flat-post-items.js';
 import { createGetCategoryItems } from './sitemap/get-category-items.js';
 import { createGetSubcategoryItems } from './sitemap/get-subcategory-items.js';
 import { createGetPostItems } from './sitemap/get-post-items.js';
@@ -24,7 +23,6 @@ function createWebSeo(input) {
     sitemap: {
       createBuildUrlsFromPathname,
       createGetPageItems,
-      createGetFlatPostItems,
       createGetCategoryItems,
       createGetSubcategoryItems,
       createGetPostItems

package/dist/src/web/server/seo/metadata/build-alternate-pathnames.js

@@ -2,10 +2,9 @@ import { localizePathname } from 'intor';
 
 function buildAlternatePathnames({
   rawPathname,
-  webClientIntorConfig,
-  locales,
-  defaultLocale
+  webClientIntorConfig
 }) {
+  const { defaultLocale, supportedLocales: locales } = webClientIntorConfig;
   const result = {};
   for (const locale of locales) {
     const { pathname } = localizePathname(

package/dist/src/web/server/seo/metadata/build-metadata.js

@@ -1,129 +1,84 @@
-import 'mime-types';
-import 'sitero-domain';
-import { findTranslation } from '../../../../shared/translation/find-translation.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import { joinUrl } from '../../../../shared/utils/join-url.js';
 import { toIsoTime } from '../../../../shared/utils/to-iso-time.js';
-import 'zod';
 import { buildAlternateMap } from './utils/build-alternate-map.js';
 import { buildOgImages } from './utils/build-og-image.js';
 import { ensureOgType } from './utils/ensure-og-type.js';
 import { ensureTwitterCard } from './utils/ensure-twitter-card.js';
+import { resolveRobots } from './utils/resolve-robots.js';
 import { sanitizeStringArray } from './utils/sanitize-string-array.js';
 import { toOgLocale } from './utils/to-og-locale.js';
 
+const text = (value) => value?.trim() || void 0;
 function createBuildMetadata(ctx) {
-  const { siteConfig, storageUrl } = ctx.constants;
-  return function buildMetadata(urls, post, locale, isArticle = false) {
-    const { defaultLocale, webLocales: locales, site } = siteConfig;
+  const { siteConfig, webClientIntorConfig } = ctx.constants;
+  return function buildMetadata(urls, post, locale, isArticle = false, options = {}) {
+    const { site, sharing } = siteConfig;
+    const { defaultLocale, supportedLocales: locales } = webClientIntorConfig;
     const resolvedLocale = locale || defaultLocale;
-    const seoMetadata = findTranslation(post?.seoMetadatas, locale);
-    const authorT = findTranslation(post?.author?.translations, locale);
-    const coverImageT = findTranslation(post?.coverImage?.translations, locale);
-    const tags = sanitizeStringArray(
-      post?.tags.map((t) => findTranslation(t.translations, locale).title)
+    const seo = post?.seoMetadatas.find(
+      (item) => item.locale === resolvedLocale
     );
-    const articleCoverImageUrl = joinUrl(storageUrl, post?.coverImage?.key);
+    const title = text(seo?.title);
+    const description = text(seo?.description);
+    const canonical = text(seo?.canonical) || urls.canonical;
+    const ogTitle = text(seo?.ogTitle) || title;
+    const ogDescription = text(seo?.ogDescription) || description;
+    const ogImage = text(seo?.ogImage);
+    const images = ogImage ? buildOgImages({
+      url: ogImage,
+      secureUrl: ogImage.startsWith("https://") ? ogImage : void 0,
+      alt: text(seo?.ogImageAlt),
+      type: text(seo?.ogImageType),
+      width: seo?.ogImageWidth,
+      height: seo?.ogImageHeight
+    }) : buildOgImages({
+      url: sharing.defaultImage.url,
+      secureUrl: sharing.defaultImage.url.startsWith("https://") ? sharing.defaultImage.url : void 0,
+      alt: sharing.defaultImage.alt,
+      type: sharing.defaultImage.mimeType,
+      width: sharing.defaultImage.width,
+      height: sharing.defaultImage.height
+    });
+    const author = text(seo?.author);
+    const articleAuthor = text(seo?.ogArticleAuthor);
     return {
-      metadataBase: site.url,
-      // -----------------------------------------------------------------------
-      // Basic
-      // -----------------------------------------------------------------------
-      title: seoMetadata.title || site.name[resolvedLocale],
-      description: seoMetadata.description || site.description[resolvedLocale],
-      // identity
-      ...isArticle ? {
-        authors: [
-          {
-            name: seoMetadata.author || authorT.authorName || void 0,
-            url: authorT.url || void 0
-          }
-        ]
-      } : {},
-      // url
+      metadataBase: new URL(site.url),
+      title: title ?? null,
+      description: description ?? null,
+      authors: isArticle && author ? [{ name: author }] : null,
       alternates: {
-        canonical: seoMetadata.canonical || urls.canonical,
-        languages: seoMetadata.alternate?.length ? buildAlternateMap(seoMetadata.alternate) : urls.alternates
+        canonical,
+        languages: seo?.alternate?.length ? buildAlternateMap(seo.alternate) : urls.alternates
       },
-      // robots
-      robots: seoMetadata.robots || {
-        index: true,
-        follow: true,
-        "max-image-preview": "large"
-      },
-      // -----------------------------------------------------------------------
-      // Open Graph
-      // -----------------------------------------------------------------------
+      robots: resolveRobots(
+        seo?.robots,
+        !!ctx.constants.forceNoIndex || !!options.forceNoIndex
+      ),
       openGraph: {
-        title: seoMetadata.ogTitle || void 0,
-        description: seoMetadata.ogDescription || void 0,
-        // url
-        url: seoMetadata.ogUrl || seoMetadata.canonical || void 0,
-        // identity
-        type: ensureOgType(
-          isArticle ? "article" : "website",
-          seoMetadata.ogType
-        ),
-        siteName: seoMetadata.ogSiteName || site.name[resolvedLocale],
-        // image
-        images: isArticle ? buildOgImages({
-          url: seoMetadata.ogImage || articleCoverImageUrl,
-          secureUrl: seoMetadata.ogImage || articleCoverImageUrl,
-          alt: seoMetadata.ogImageAlt || coverImageT.alt,
-          type: seoMetadata.ogImageType,
-          width: seoMetadata.ogImageWidth,
-          height: seoMetadata.ogImageHeight
-        }) : (
-          // is `website`
-          seoMetadata.ogImage ? buildOgImages({
-            url: seoMetadata.ogImage,
-            secureUrl: seoMetadata.ogImage,
-            alt: seoMetadata.ogImageAlt,
-            type: seoMetadata.ogImageType,
-            width: seoMetadata.ogImageWidth,
-            height: seoMetadata.ogImageHeight
-          }) : (
-            // default
-            buildOgImages({
-              url: site.defaultImage.url,
-              secureUrl: site.defaultImage.url,
-              alt: site.defaultImage.alt,
-              type: site.defaultImage.mimeType,
-              width: site.defaultImage.width,
-              height: site.defaultImage.height
-            })
-          )
-        ),
-        // locale
-        locale: seoMetadata.ogLocale || toOgLocale(resolvedLocale),
+        title: ogTitle,
+        description: ogDescription,
+        url: text(seo?.ogUrl) || canonical,
+        type: ensureOgType(isArticle ? "article" : "website", seo?.ogType),
+        siteName: text(seo?.ogSiteName) || site.name[resolvedLocale],
+        images,
+        locale: text(seo?.ogLocale) || toOgLocale(resolvedLocale),
         alternateLocale: sanitizeStringArray(
-          seoMetadata.ogLocaleAlternate?.length ? seoMetadata.ogLocaleAlternate : locales.filter((l) => l !== resolvedLocale).map(toOgLocale)
+          seo?.ogLocaleAlternate?.length ? seo.ogLocaleAlternate : locales.filter((l) => l !== resolvedLocale).map(toOgLocale)
         ),
-        // article
         ...isArticle ? {
-          publishedTime: toIsoTime(seoMetadata.ogArticlePublishedTime),
-          modifiedTime: toIsoTime(seoMetadata.ogArticleModifiedTime),
-          authors: [
-            seoMetadata.ogArticleAuthor || authorT.authorName
-          ].filter(Boolean),
-          section: seoMetadata.ogArticleSection,
-          tags: sanitizeStringArray(seoMetadata.ogArticleTag) || tags
+          publishedTime: toIsoTime(seo?.ogArticlePublishedTime),
+          modifiedTime: toIsoTime(seo?.ogArticleModifiedTime),
+          authors: articleAuthor ? [articleAuthor] : void 0,
+          section: text(seo?.ogArticleSection),
+          tags: sanitizeStringArray(seo?.ogArticleTag)
         } : {}
       },
-      // -----------------------------------------------------------------------
-      // Twitter
-      // -----------------------------------------------------------------------
       twitter: {
-        card: ensureTwitterCard("summary_large_image", seoMetadata.twitterCard),
-        // identity
-        site: seoMetadata.twitterSite || void 0,
-        creator: seoMetadata.twitterCreator || void 0
+        card: ensureTwitterCard("summary_large_image", seo?.twitterCard),
+        title: ogTitle,
+        description: ogDescription,
+        images,
+        site: text(seo?.twitterSite),
+        creator: text(seo?.twitterCreator)
       }
     };
   };

package/dist/src/web/server/seo/metadata/resolve-urls.js

@@ -3,12 +3,9 @@ import { readIntorUrlState } from 'intor/next/server';
 import { buildAlternatePathnames } from './build-alternate-pathnames.js';
 
 function createResolveUrls(ctx) {
-  const {
-    webClientIntorConfig,
-    defaultLocale,
-    webLocales: locales
-  } = ctx.constants;
-  return async function resolveUrls(locale) {
+  const { webClientIntorConfig } = ctx.constants;
+  const { defaultLocale } = webClientIntorConfig;
+  return async function resolveUrls(locale = defaultLocale) {
     const { pathname: rawPathname } = await readIntorUrlState();
     if (!rawPathname) throw new Error("[metadata] Missing x-intor-pathname");
     const canonicalPathname = localizePathname(
@@ -18,9 +15,7 @@ function createResolveUrls(ctx) {
     ).pathname;
     const alternates = buildAlternatePathnames({
       rawPathname,
-      webClientIntorConfig,
-      defaultLocale,
-      locales
+      webClientIntorConfig
     });
     return {
       canonical: canonicalPathname,

package/dist/src/web/server/seo/metadata/utils/build-og-image.js

@@ -17,8 +17,8 @@ const buildOgImages = ({
       secureUrl: secureUrl ?? void 0,
       alt: alt ?? void 0,
       type: type ?? validType,
-      width: typeof width === "number" && width > 0 ? width : 1200,
-      height: typeof height === "number" && height > 0 ? height : 630
+      width: typeof width === "number" && width > 0 ? width : void 0,
+      height: typeof height === "number" && height > 0 ? height : void 0
     }
   ];
 };

package/dist/src/web/server/seo/metadata/utils/ensure-og-type.js

@@ -1,14 +1,4 @@
-import 'mime-types';
-import 'sitero-domain';
 import { OG_TYPE_ARRAY } from '../../../../../shared/seo-metadata.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import 'zod';
 
 const ensureOgType = (fallback, ogType) => {
   if (typeof ogType !== "string") return fallback;

package/dist/src/web/server/seo/metadata/utils/ensure-twitter-card.js

@@ -1,14 +1,4 @@
-import 'mime-types';
-import 'sitero-domain';
 import { TWITTER_CARD_ARRAY } from '../../../../../shared/seo-metadata.js';
-import 'react';
-import 'ua-parser-js';
-import '../../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
-import 'zod';
 
 const ensureTwitterCard = (fallback, twitterCard) => {
   if (typeof twitterCard !== "string") return fallback;

package/dist/src/web/server/seo/metadata/utils/resolve-robots.js

@@ -0,0 +1,17 @@
+function resolveRobots(value, forceNoIndex = false) {
+  const directives = value?.trim();
+  if (!directives) {
+    return {
+      index: !forceNoIndex,
+      follow: true,
+      "max-image-preview": "large"
+    };
+  }
+  if (!forceNoIndex) return directives;
+  const preserved = directives.split(",").map((item) => item.trim()).filter(
+    (item) => item && !["index", "all", "noindex"].includes(item.toLowerCase())
+  );
+  return [...preserved, "noindex"].join(", ");
+}
+
+export { resolveRobots };

package/dist/src/web/server/seo/sitemap/build-entries.js

@@ -0,0 +1,47 @@
+import { buildAlternatePathnames } from '../metadata/build-alternate-pathnames.js';
+import { createBuildMetadata } from '../metadata/build-metadata.js';
+
+function createBuildSitemapEntries(ctx) {
+  const { webClientIntorConfig, siteConfig } = ctx.constants;
+  const buildMetadata = createBuildMetadata(ctx);
+  const base = new URL(siteConfig.site.url);
+  const absoluteUrl = (value) => {
+    if (typeof value !== "string" && !(value instanceof URL)) {
+      throw new Error("[sitemap] Expected a URL from the metadata builder");
+    }
+    return new URL(value, base);
+  };
+  return function buildEntries(pathname, seoSource, lastModified, isArticle = false) {
+    const alternates = buildAlternatePathnames({
+      rawPathname: pathname,
+      webClientIntorConfig
+    });
+    const entries = [];
+    for (const locale of webClientIntorConfig.supportedLocales) {
+      const metadata = buildMetadata(
+        { canonical: alternates[locale], alternates },
+        seoSource,
+        locale,
+        isArticle
+      );
+      const robots = metadata.robots;
+      const noindex = typeof robots === "string" ? /(?:^|,)\s*(?:noindex|none)\s*(?:,|$)/i.test(robots) : robots?.index === false;
+      if (noindex) continue;
+      const url = absoluteUrl(metadata.alternates?.canonical);
+      if (url.origin !== base.origin) continue;
+      const languages = Object.fromEntries(
+        Object.entries(metadata.alternates?.languages ?? {}).map(
+          ([language, href]) => [language, absoluteUrl(href).href]
+        )
+      );
+      entries.push({
+        url: url.href,
+        alternates: { languages },
+        ...lastModified ? { lastModified: new Date(lastModified) } : {}
+      });
+    }
+    return [...new Map(entries.map((entry) => [entry.url, entry])).values()];
+  };
+}
+
+export { createBuildSitemapEntries };

package/dist/src/web/server/seo/sitemap/build-urls-from-pathname.js

@@ -1,30 +1,15 @@
-import 'mime-types';
-import 'sitero-domain';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
 import { joinUrl } from '../../../../shared/utils/join-url.js';
-import 'zod';
 import { buildAlternatePathnames } from '../metadata/build-alternate-pathnames.js';
-import 'intor';
-import 'intor/next/server';
 
 function createBuildUrlsFromPathname({
   webClientIntorConfig,
-  webLocales: locales,
-  defaultLocale,
   webUrl
 }) {
+  const { defaultLocale } = webClientIntorConfig;
   return function buildUrlsFromPathname(pathname) {
     const alternates = buildAlternatePathnames({
       rawPathname: pathname,
-      webClientIntorConfig,
-      locales,
-      defaultLocale
+      webClientIntorConfig
     });
     const localizedMap = Object.fromEntries(
       Object.entries(alternates).map(([locale, path]) => [

package/dist/src/web/server/seo/sitemap/get-category-items.js

@@ -1,33 +1,31 @@
-import 'mime-types';
-import 'sitero-domain';
-import 'react';
-import 'ua-parser-js';
-import '../../../../shared/client/react-query/client.js';
-import 'react/jsx-runtime';
-import '@tanstack/react-query';
-import 'clsx';
-import 'tailwind-merge';
+import { POST_TYPES } from 'sitero-domain';
 import { joinUrl } from '../../../../shared/utils/join-url.js';
-import 'zod';
+import { createBuildSitemapEntries } from './build-entries.js';
+import { loadSitemapCards, loadSitemapDetail } from './queries.js';
 
-function createGetCategoryItems({
-  loadCategories,
-  buildUrlsFromPathname
-}) {
+function createGetCategoryItems(ctx) {
+  const buildEntries = createBuildSitemapEntries(ctx);
   return async function getCategoryItems({ topicSlug }) {
-    const { categories } = await loadCategories({
-      locale: "",
-      // locale not important here
-      topicSlug
-    });
-    return categories.map((c) => {
-      const url = joinUrl("/", topicSlug, c.slug);
-      const entry = buildUrlsFromPathname(url);
-      return {
-        ...entry,
-        lastModified: new Date(c.updatedAt)
-      };
+    if (ctx.constants.forceNoIndex) return [];
+    const categories = await loadSitemapCards(ctx.findListCards, {
+      type: POST_TYPES.CATEGORY,
+      topicSlug,
+      locale: ctx.constants.webClientIntorConfig.defaultLocale
     });
+    const entries = [];
+    for (const card of categories) {
+      const category = await loadSitemapDetail(ctx.findDetail, { id: card.id });
+      if (!category?.isActive || category.type !== POST_TYPES.CATEGORY)
+        continue;
+      entries.push(
+        ...buildEntries(
+          joinUrl("/", topicSlug, category.slug),
+          category,
+          category.updatedAt
+        )
+      );
+    }
+    return [...new Map(entries.map((entry) => [entry.url, entry])).values()];
   };
 }