sitero 0.1.6 → 0.2.0

package/dist/src/shared/zod.js

@@ -58,25 +58,12 @@ const schemas = {
   //   function key() {
   //     return trimmedString().max(1024);
   //   }
-  //   // --- file checksum
-  //   function sha256Hash() {
-  //     return trimmedString()
-  //       .length(64)
-  //       .regex(/^[a-f0-9]{64}$/);
-  //   }
   //   // --- post slug
   //   function slug() {
   //     return trimmedString()
   //       .regex(/^$|^[\p{L}0-9-_]+$/u)
   //       .max(100); // Invalid: " ", "/", "\", "!", "@", "#", "$", "%", "^", "&", "*", etc.
   //   }
-  //   // --- folder name
-  //   function pathSegment() {
-  //     return trimmedString()
-  //       .min(1)
-  //       .regex(/^(?!\.\.?$)[^\u0000-\u001F/\\]+$/u) // Invalid: "." or ".." alone, or any string containing "/" or "\"
-  //       .max(255);
-  //   }
   //   // ---------------------------------------------------------------
   //   // item
   //   // ---------------------------------------------------------------
@@ -112,7 +99,6 @@ const schemas = {
   //     // resource related
   //     id,
   //     key,
-  //     sha256Hash,
   //     slug,
   //     pathSegment,
   //     // item

package/dist/src/web/client/applications/structured-data/build/build-content.js

@@ -1,6 +1,11 @@
 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';

package/dist/src/web/client/applications/structured-data/build/build-web-page.js

@@ -1,6 +1,11 @@
 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';

package/dist/src/web/client/applications/structured-data/get-page-identity.js

@@ -1,6 +1,11 @@
 import { localizePathname } from 'intor';
 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';

package/dist/src/web/client/applications/structured-data/resolve-topic-item-list/map-category-item.js

@@ -1,6 +1,11 @@
 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';

package/dist/src/web/client/applications/structured-data/resolve-topic-item-list/map-post-item.js

@@ -1,6 +1,11 @@
 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';

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

@@ -1,41 +1,35 @@
-import { createWebApplications } from './applications/create-web-applications.js';
-import 'intor';
-import 'intor/next/server';
-import 'mime-types';
-import 'sitero-domain';
-import 'clsx';
-import 'tailwind-merge';
-import 'zod';
-import { createWebInterfaces } from './interfaces/create-web-interfaces.js';
-import '../../constants/paths/redirect.js';
-import '../../constants/cms-locale.js';
-import '../../core/server/infrastructure/argon2/argon2-service.js';
-import '@keyv/redis';
-import 'keyv';
-import '../../core/server/infrastructure/cookie/cookie-service.js';
-import 'node:crypto';
-import 'ulid';
-import 'nodemailer';
-import '../../core/server/infrastructure/email/template/render-email-template.js';
-import 'jsonwebtoken';
-import 'node:path/posix';
-import 'p-limit';
+import { resolveRequestContext } from '../../shared/next/server/request.js';
 import 'next/server';
-import 'next/dist/client/components/redirect-error';
+import 'sitero-server';
+import 'zod';
+import { createWebInquiryActions } from './features/inquiry/actions.js';
+import { createWebConfigActions } from './resources/config/actions.js';
+import { createWebPostActions } from './resources/post/actions.js';
 
-function createWebServer(input) {
-  const { coreServer, constants, logger } = input;
-  const applications = createWebApplications({
-    coreServer,
-    constants
+function createWebServer({
+  siteroServer,
+  staticTopics
+}) {
+  const config = createWebConfigActions({ siteroServer });
+  const inquiry = createWebInquiryActions({
+    siteroServer,
+    resolveRequestContext
   });
-  const interfaces = createWebInterfaces({
-    coreServer,
-    applications,
-    constants});
+  const post = createWebPostActions({ siteroServer, staticTopics });
   return {
-    applications,
-    interfaces
+    actions: {
+      features: {
+        inquiry
+      },
+      resources: {
+        config: config.actions,
+        post: post.actions
+      }
+    },
+    loaders: {
+      ...config.loaders,
+      ...post.loaders
+    }
   };
 }
 

package/dist/src/web/server/features/inquiry/actions.js

@@ -0,0 +1,22 @@
+function createWebInquiryActions({
+  siteroServer,
+  resolveRequestContext
+}) {
+  const inquirySubmitAction = async ({
+    formData
+  }) => {
+    const context = await resolveRequestContext();
+    return siteroServer.executor.execute(
+      siteroServer.features.inquiry.submit,
+      {
+        formData
+      },
+      context
+    );
+  };
+  return {
+    submit: inquirySubmitAction
+  };
+}
+
+export { createWebInquiryActions };

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

@@ -0,0 +1,28 @@
+function createWebConfigActions({
+  siteroServer
+}) {
+  const configFindDetailAction = async (input) => {
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.config.findDetail,
+      input,
+      {}
+    );
+    return result;
+  };
+  const loadConfig = async (input) => {
+    const response = await configFindDetailAction(input);
+    return {
+      config: response.success ? response.data.config : void 0
+    };
+  };
+  return {
+    actions: {
+      findDetail: configFindDetailAction
+    },
+    loaders: {
+      loadConfig
+    }
+  };
+}
+
+export { createWebConfigActions };

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

@@ -0,0 +1,264 @@
+import { POST_TYPES } from 'sitero-domain';
+import { operationResult } from 'sitero-server';
+
+function toWebPostListCard(post) {
+  return {
+    ...post,
+    children: [],
+    parents: []
+  };
+}
+function toNullableWebPostListCard(post) {
+  return post ? toWebPostListCard(post) : null;
+}
+function getSlug(post) {
+  return "slug" in post && typeof post.slug === "string" ? post.slug : "";
+}
+function topicHasRole(staticTopics, topicSlug, role) {
+  const topic = staticTopics[topicSlug];
+  return !!topic && topic.roles.includes(role);
+}
+function createWebPostActions({
+  siteroServer,
+  staticTopics
+}) {
+  const postFindDetailAction = async (input) => {
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.post.findDetail,
+      { ...input, isActive: true },
+      {}
+    );
+    if (!result.success) return result;
+    return operationResult.success({
+      post: result.data.post,
+      prev: await hydrateListCardParents(
+        toNullableWebPostListCard(result.data.previous)
+      ),
+      next: await hydrateListCardParents(
+        toNullableWebPostListCard(result.data.next)
+      )
+    });
+  };
+  const postFindListCardsAction = async (input) => {
+    const result = await siteroServer.executor.execute(
+      siteroServer.resources.post.findListCards,
+      { ...input, isActive: true },
+      {}
+    );
+    if (!result.success) return result;
+    return operationResult.success({
+      ...result.data,
+      items: result.data.items.map(toWebPostListCard)
+    });
+  };
+  async function hydrateListCardParents(post) {
+    if (!post) return post;
+    const response = await siteroServer.executor.execute(
+      siteroServer.resources.post.findDetail,
+      { id: post.id, isActive: true },
+      {}
+    );
+    if (!response.success) return post;
+    return {
+      ...post,
+      parents: response.data.post.parents
+    };
+  }
+  const loadPage = async ({ pageSlug }) => {
+    const response = await postFindDetailAction({
+      type: POST_TYPES.PAGE,
+      slug: pageSlug
+    });
+    return {
+      page: response.success ? response.data?.post : void 0
+    };
+  };
+  const loadCategories = async ({
+    locale,
+    topicSlug,
+    childrenCount
+  }) => {
+    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.CATEGORY)) {
+      return { categories: [] };
+    }
+    const response = await postFindListCardsAction({
+      locale,
+      type: POST_TYPES.CATEGORY,
+      topicSlug
+    });
+    if (!response.success) {
+      return { categories: [] };
+    }
+    const categories = response.data?.items ?? [];
+    if (!childrenCount) {
+      return { categories };
+    }
+    return {
+      categories: await Promise.all(
+        categories.map(async (category) => {
+          const { posts } = await loadPosts({
+            locale,
+            topicSlug,
+            categorySlug: getSlug(category),
+            currentPage: 1,
+            pageSize: childrenCount
+          });
+          return {
+            ...category,
+            children: posts
+          };
+        })
+      )
+    };
+  };
+  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,
+    categorySlug,
+    childrenCount
+  }) => {
+    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.SUBCATEGORY)) {
+      return { subcategories: [] };
+    }
+    const response = await postFindListCardsAction({
+      locale,
+      type: POST_TYPES.SUBCATEGORY,
+      topicSlug,
+      ...categorySlug ? { parentSlug: categorySlug } : {}
+    });
+    if (!response.success) {
+      return { subcategories: [] };
+    }
+    const subcategories = response.data?.items ?? [];
+    if (!childrenCount) {
+      return { subcategories };
+    }
+    return {
+      subcategories: await Promise.all(
+        subcategories.map(async (subcategory) => {
+          const { posts } = await loadPosts({
+            locale,
+            topicSlug,
+            categorySlug: getSlug(subcategory),
+            currentPage: 1,
+            pageSize: childrenCount
+          });
+          return {
+            ...subcategory,
+            children: posts
+          };
+        })
+      )
+    };
+  };
+  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
+  }) => {
+    if (!topicHasRole(staticTopics, topicSlug, POST_TYPES.POST)) {
+      return { post: void 0, prev: void 0, next: void 0 };
+    }
+    const response = await postFindDetailAction({
+      type: POST_TYPES.POST,
+      slug,
+      topicSlug
+    });
+    if (!response.success) {
+      return { post: void 0, prev: void 0, next: void 0 };
+    }
+    return {
+      post: response.data?.post,
+      prev: response.data?.prev,
+      next: response.data?.next
+    };
+  };
+  return {
+    actions: {
+      findDetail: postFindDetailAction,
+      findListCards: postFindListCardsAction
+    },
+    loaders: {
+      loadPage,
+      loadCategories,
+      loadCategory,
+      loadSubcategories,
+      loadSubcategory,
+      loadPosts,
+      loadPost
+    }
+  };
+}
+
+export { createWebPostActions };

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

@@ -0,0 +1,35 @@
+import 'intor';
+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';
+
+function createWebSeo(input) {
+  const { constants } = input;
+  const metadataContext = {
+    constants
+  };
+  const resolveUrls = createResolveUrls(metadataContext);
+  const buildMetadata = createBuildMetadata(metadataContext);
+  return {
+    // metadata
+    metadata: {
+      resolveUrls,
+      buildMetadata
+    },
+    sitemap: {
+      createBuildUrlsFromPathname,
+      createGetPageItems,
+      createGetFlatPostItems,
+      createGetCategoryItems,
+      createGetSubcategoryItems,
+      createGetPostItems
+    }
+  };
+}
+
+export { createWebSeo };

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

@@ -0,0 +1,132 @@
+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 { sanitizeStringArray } from './utils/sanitize-string-array.js';
+import { toOgLocale } from './utils/to-og-locale.js';
+
+function createBuildMetadata(ctx) {
+  const { siteConfig, storageUrl } = ctx.constants;
+  return function buildMetadata(urls, post, locale, isArticle = false) {
+    const { defaultLocale, webLocales: locales, site } = siteConfig;
+    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 articleCoverImageUrl = joinUrl(storageUrl, post?.coverImage?.key);
+    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
+      alternates: {
+        canonical: seoMetadata.canonical || urls.canonical,
+        languages: seoMetadata.alternate?.length ? buildAlternateMap(seoMetadata.alternate) : urls.alternates
+      },
+      // robots
+      robots: seoMetadata.robots || {
+        index: true,
+        follow: true,
+        "max-image-preview": "large"
+      },
+      // -----------------------------------------------------------------------
+      // Open Graph
+      // -----------------------------------------------------------------------
+      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),
+        alternateLocale: sanitizeStringArray(
+          seoMetadata.ogLocaleAlternate?.length ? seoMetadata.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
+        } : {}
+      },
+      // -----------------------------------------------------------------------
+      // Twitter
+      // -----------------------------------------------------------------------
+      twitter: {
+        card: ensureTwitterCard("summary_large_image", seoMetadata.twitterCard),
+        // identity
+        site: seoMetadata.twitterSite || void 0,
+        creator: seoMetadata.twitterCreator || void 0
+      }
+    };
+  };
+}
+
+export { createBuildMetadata };

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

@@ -0,0 +1,19 @@
+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;
+  const isValid = OG_TYPE_ARRAY.includes(ogType);
+  return isValid ? ogType : fallback;
+};
+
+export { ensureOgType };