sitero 0.0.1

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

@@ -0,0 +1,31 @@
+import { localizePathname } from 'intor';
+import { readIntorUrlState } from 'intor/next/server';
+import { buildAlternatePathnames } from './build-alternate-pathnames.js';
+
+function createResolveUrls({
+  intorConfig,
+  defaultLocale,
+  locales
+}) {
+  return async function resolveUrls(locale) {
+    const { pathname: rawPathname } = await readIntorUrlState();
+    if (!rawPathname) throw new Error("[metadata] Missing x-intor-pathname");
+    const canonicalPathname = localizePathname(
+      rawPathname,
+      intorConfig,
+      locale ?? defaultLocale
+    ).pathname;
+    const alternates = buildAlternatePathnames({
+      rawPathname,
+      intorConfig,
+      defaultLocale,
+      locales
+    });
+    return {
+      canonical: canonicalPathname,
+      alternates
+    };
+  };
+}
+
+export { createResolveUrls };

package/dist/src/web/server/applications/metadata/utils/build-alternate-map.js

@@ -0,0 +1,10 @@
+const buildAlternateMap = (alternates = []) => {
+  const result = {};
+  for (const { hreflang, href } of alternates) {
+    if (!href) continue;
+    result[hreflang] = href;
+  }
+  return result;
+};
+
+export { buildAlternateMap };

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

@@ -0,0 +1,26 @@
+import { lookup } from 'mime-types';
+
+const buildOgImages = ({
+  url,
+  secureUrl,
+  alt,
+  type,
+  width,
+  height
+}) => {
+  if (!url) return void 0;
+  const mimeType = lookup(url);
+  const validType = typeof mimeType === "string" && mimeType.startsWith("image/") ? mimeType : void 0;
+  return [
+    {
+      url,
+      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
+    }
+  ];
+};
+
+export { buildOgImages };

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

@@ -0,0 +1,12 @@
+import 'mime-types';
+import { OG_TYPE_ARRAY } from '../../../../../shared/seo-metadata.js';
+import 'clsx';
+import 'tailwind-merge';
+
+const ensureOgType = (fallback, ogType) => {
+  if (typeof ogType !== "string") return fallback;
+  const isValid = OG_TYPE_ARRAY.includes(ogType);
+  return isValid ? ogType : fallback;
+};
+
+export { ensureOgType };

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

@@ -0,0 +1,12 @@
+import 'mime-types';
+import { TWITTER_CARD_ARRAY } from '../../../../../shared/seo-metadata.js';
+import 'clsx';
+import 'tailwind-merge';
+
+const ensureTwitterCard = (fallback, twitterCard) => {
+  if (typeof twitterCard !== "string") return fallback;
+  const isValid = TWITTER_CARD_ARRAY.includes(twitterCard);
+  return isValid ? twitterCard : fallback;
+};
+
+export { ensureTwitterCard };

package/dist/src/web/server/applications/metadata/utils/sanitize-string-array.js

@@ -0,0 +1,8 @@
+const sanitizeStringArray = (array) => {
+  if (!Array.isArray(array)) return void 0;
+  return array.filter(
+    (a) => typeof a === "string" && a.trim() !== ""
+  );
+};
+
+export { sanitizeStringArray };

package/dist/src/web/server/applications/metadata/utils/to-og-locale.js

@@ -0,0 +1,6 @@
+function toOgLocale(locale) {
+  if (!locale) return void 0;
+  return locale.replaceAll("-", "_");
+}
+
+export { toOgLocale };

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

@@ -0,0 +1,37 @@
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../shared/utils/join-url.js';
+import { buildAlternatePathnames } from '../metadata/build-alternate-pathnames.js';
+import 'intor';
+import 'intor/next/server';
+
+function createBuildUrlsFromPathname({
+  intorConfig,
+  locales,
+  defaultLocale,
+  webUrl
+}) {
+  return function buildUrlsFromPathname(pathname) {
+    const alternates = buildAlternatePathnames({
+      rawPathname: pathname,
+      intorConfig,
+      locales,
+      defaultLocale
+    });
+    const localizedMap = Object.fromEntries(
+      Object.entries(alternates).map(([locale, path]) => [
+        locale,
+        joinUrl(webUrl, path)
+      ])
+    );
+    return {
+      url: localizedMap[defaultLocale],
+      alternates: {
+        languages: localizedMap
+      }
+    };
+  };
+}
+
+export { createBuildUrlsFromPathname };

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

@@ -0,0 +1,23 @@
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../shared/utils/join-url.js';
+
+function createGetCategoryItems({
+  loadCategories,
+  buildUrlsFromPathname
+}) {
+  return async function getCategoryItems({ topicSlug }) {
+    const { categories } = await loadCategories({ topicSlug });
+    return categories.map((c) => {
+      const url = joinUrl("/", topicSlug, c.slug);
+      const entry = buildUrlsFromPathname(url);
+      return {
+        ...entry,
+        lastModified: new Date(c.updatedAt)
+      };
+    });
+  };
+}
+
+export { createGetCategoryItems };

package/dist/src/web/server/applications/sitemap/get-flat-post-items.js

@@ -0,0 +1,23 @@
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../shared/utils/join-url.js';
+
+function createGetFlatPostItems({
+  loadPosts,
+  buildUrlsFromPathname
+}) {
+  return async function getFlatPostItems({ topicSlug }) {
+    const { posts } = await loadPosts({ topicSlug });
+    return posts.map((p) => {
+      const url = joinUrl("/", topicSlug, p.slug);
+      const entry = buildUrlsFromPathname(url);
+      return {
+        ...entry,
+        lastModified: new Date(p.updatedAt)
+      };
+    });
+  };
+}
+
+export { createGetFlatPostItems };

package/dist/src/web/server/applications/sitemap/get-page-items.js

@@ -0,0 +1,19 @@
+function createGetPageItems({
+  loadPage,
+  buildUrlsFromPathname
+}) {
+  return async function getPageItems({ pages }) {
+    return await Promise.all(
+      Object.entries(pages).map(async ([key, { pathname }]) => {
+        const { page } = await loadPage({ pageSlug: key });
+        const entry = buildUrlsFromPathname(pathname);
+        return {
+          ...entry,
+          lastModified: page?.updatedAt ? new Date(page.updatedAt) : /* @__PURE__ */ new Date()
+        };
+      })
+    );
+  };
+}
+
+export { createGetPageItems };

package/dist/src/web/server/applications/sitemap/get-post-items.js

@@ -0,0 +1,27 @@
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../shared/utils/join-url.js';
+
+function createGetPostItems({
+  loadPosts,
+  buildUrlsFromPathname
+}) {
+  return async function getPostItems({ topicSlug }) {
+    const { posts } = await loadPosts({
+      topicSlug,
+      include: { parents: true }
+    });
+    return posts.filter((p) => p.parents?.[0]?.slug).map((p) => {
+      const categorySlug = p.parents?.[0]?.slug ?? "";
+      const pathname = joinUrl("/", topicSlug, categorySlug, p.slug);
+      const entry = buildUrlsFromPathname(pathname);
+      return {
+        ...entry,
+        lastModified: new Date(p.updatedAt)
+      };
+    });
+  };
+}
+
+export { createGetPostItems };

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

@@ -0,0 +1,44 @@
+import { createWebApplications } from './applications/create-web-applications.js';
+import 'intor';
+import 'intor/next/server';
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { createWebInterfaces } from './interfaces/create-web-interfaces.js';
+import '../../constants/paths/auth.js';
+import '../../constants/paths/main.js';
+import '../../constants/paths/resources.js';
+import '../../constants/redirect-paths.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 '../../core/domain/resources/admin/constants.js';
+import 'ulid';
+import 'nodemailer';
+import '../../core/server/infrastructure/email/render-email-template.js';
+import 'jsonwebtoken';
+import 'zod';
+import 'next/server';
+import 'next-body-parser';
+import 'p-limit';
+
+function createWebServer(input) {
+  const { coreServer, constants } = input;
+  const applications = createWebApplications({
+    coreServer,
+    constants
+  });
+  const interfaces = createWebInterfaces({
+    coreServer,
+    applications,
+    constants
+  });
+  return {
+    applications,
+    interfaces
+  };
+}
+
+export { createWebServer };

package/dist/src/web/server/interfaces/actions/resources/config/queries/config-find-action.js

@@ -0,0 +1,50 @@
+import '../../../../../../../constants/paths/auth.js';
+import '../../../../../../../constants/paths/main.js';
+import '../../../../../../../constants/paths/resources.js';
+import '../../../../../../../constants/redirect-paths.js';
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { ServerError } from '../../../../../../../core/server/server-error.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 '../../../../../../../core/domain/resources/admin/constants.js';
+import 'ulid';
+import 'nodemailer';
+import '../../../../../../../core/server/infrastructure/email/render-email-template.js';
+import 'intor';
+import 'jsonwebtoken';
+import 'zod';
+import 'next/server';
+import 'next-body-parser';
+import 'p-limit';
+import 'intor/next/server';
+
+function createConfigFindAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories },
+      interfaces: { executions }
+    }
+  } = ctx;
+  return async function configFindAction(params) {
+    return executions.executeAction(
+      async () => {
+        const found = await repositories.configQueryRepository.find(params);
+        if (!found) throw ServerError.notFound();
+        return {
+          data: { config: found }
+        };
+      },
+      {
+        type: "query",
+        key: ["config", "findAction", params.slug]
+      }
+    );
+  };
+}
+
+export { createConfigFindAction };

package/dist/src/web/server/interfaces/actions/resources/inquiry/commands/create/inquiry-create-action.js

@@ -0,0 +1,68 @@
+import 'mime-types';
+import { findTranslation } from '../../../../../../../../shared/translation/find-translation.js';
+import 'clsx';
+import 'tailwind-merge';
+import { inquiryCreateValidator } from './inquiry-create-validator.js';
+
+function createInquiryCreateAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories, cache, zod },
+      interfaces: { executions }
+    },
+    applications: { emails },
+    constants: { inquiryEmailsSlug }
+  } = ctx;
+  return async function inquiryCreateAction({
+    formData
+  }) {
+    return executions.executeAction(async (translator) => {
+      await cache.ipRateLimiter({ key: ["create-inquiry"], maxAttempts: 3 });
+      const {
+        text1,
+        text2,
+        text3,
+        text4,
+        text5,
+        text6,
+        text7,
+        text8,
+        text9,
+        text10
+      } = await inquiryCreateValidator(zod.schemas).parseAsync(formData);
+      const created = await repositories.inquiryCommandRepository.create({
+        ...text1 !== void 0 && { text1 },
+        ...text2 !== void 0 && { text2 },
+        ...text3 !== void 0 && { text3 },
+        ...text4 !== void 0 && { text4 },
+        ...text5 !== void 0 && { text5 },
+        ...text6 !== void 0 && { text6 },
+        ...text7 !== void 0 && { text7 },
+        ...text8 !== void 0 && { text8 },
+        ...text9 !== void 0 && { text9 },
+        ...text10 !== void 0 && { text10 }
+      });
+      const inquiryEmailsConfig = await repositories.configQueryRepository.find(
+        { slug: inquiryEmailsSlug }
+      );
+      if (inquiryEmailsConfig) {
+        const targetEmails = findTranslation(inquiryEmailsConfig.translations, translator.locale)?.data1 ?? [];
+        if (Array.isArray(targetEmails) && targetEmails.length > 0) {
+          void Promise.all(
+            targetEmails.map(
+              (email) => emails.newInquiryEmail.send({ translator, email })
+            )
+          ).catch((err) => {
+            console.error("Failed to send inquiry emails:", err);
+          });
+        }
+      }
+      return {
+        i18nKey: "ok.store-ok",
+        data: { inquiry: created }
+      };
+    });
+  };
+}
+
+export { createInquiryCreateAction };

package/dist/src/web/server/interfaces/actions/resources/inquiry/commands/create/inquiry-create-validator.js

@@ -0,0 +1,14 @@
+const inquiryCreateValidator = (schemas) => schemas.z.object({
+  text1: schemas.text().optional(),
+  text2: schemas.text().optional(),
+  text3: schemas.text().optional(),
+  text4: schemas.text().optional(),
+  text5: schemas.text().optional(),
+  text6: schemas.text().optional(),
+  text7: schemas.text().optional(),
+  text8: schemas.text().optional(),
+  text9: schemas.text().optional(),
+  text10: schemas.text().optional()
+});
+
+export { inquiryCreateValidator };

package/dist/src/web/server/interfaces/actions/resources/post/queries/post-find-full-action.js

@@ -0,0 +1,58 @@
+import '../../../../../../../constants/paths/auth.js';
+import '../../../../../../../constants/paths/main.js';
+import '../../../../../../../constants/paths/resources.js';
+import '../../../../../../../constants/redirect-paths.js';
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { ServerError } from '../../../../../../../core/server/server-error.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 '../../../../../../../core/domain/resources/admin/constants.js';
+import 'ulid';
+import 'nodemailer';
+import '../../../../../../../core/server/infrastructure/email/render-email-template.js';
+import 'intor';
+import 'jsonwebtoken';
+import 'zod';
+import 'next/server';
+import 'next-body-parser';
+import 'p-limit';
+import 'intor/next/server';
+
+function createPostFindFullAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories },
+      interfaces: { executions }
+    }
+  } = ctx;
+  return async function postFindFullAction(params) {
+    return executions.executeAction(
+      async () => {
+        const found = await repositories.postQueryRepository.findFull(params);
+        if (!found) throw ServerError.notFound();
+        return {
+          data: found
+        };
+      },
+      {
+        type: "query",
+        key: [
+          "post",
+          "findFullAction",
+          params.id,
+          params.type,
+          params.slug,
+          params.isActive,
+          params.topicSlug
+        ]
+      }
+    );
+  };
+}
+
+export { createPostFindFullAction };

package/dist/src/web/server/interfaces/actions/resources/post/queries/post-find-list-cards-action.js

@@ -0,0 +1,57 @@
+function createPostFindListCardsAction(ctx) {
+  const {
+    coreServer: {
+      infrastructure: { repositories },
+      interfaces: { executions }
+    }
+  } = ctx;
+  return async function postFindFullAction(params) {
+    return executions.executeAction(
+      async ({ locale }) => {
+        const { items, total } = await repositories.postQueryRepository.findListCards({
+          ...params,
+          locale
+        });
+        return {
+          data: { items, total }
+        };
+      },
+      {
+        type: "query",
+        key: [
+          "post",
+          "findListCardsAction",
+          params.searchString,
+          params.type,
+          params.isActive,
+          params.isIndexActive,
+          params.isSlugActive,
+          params.isFeatured,
+          params.isShownOnHome,
+          params.state1,
+          params.state2,
+          params.state3,
+          params.state4,
+          params.state5,
+          params.state6,
+          params.state7,
+          params.state8,
+          params.state9,
+          params.state10,
+          params.topicId,
+          params.topicSlug,
+          params.categoryId,
+          params.categorySlug,
+          ...params.postIds ?? [],
+          ...params.excludeIds ?? [],
+          params.page,
+          params.pageSize,
+          JSON.stringify(params.include)
+        ],
+        isList: true
+      }
+    );
+  };
+}
+
+export { createPostFindListCardsAction };

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

@@ -0,0 +1,52 @@
+import { createPostFindFullAction } from './actions/resources/post/queries/post-find-full-action.js';
+import { createPostFindListCardsAction } from './actions/resources/post/queries/post-find-list-cards-action.js';
+import { createConfigFindAction } from './actions/resources/config/queries/config-find-action.js';
+import { createInquiryCreateAction } from './actions/resources/inquiry/commands/create/inquiry-create-action.js';
+import { createLoadPage } from './loaders/load-page.js';
+import { createLoadCategories } from './loaders/load-categories.js';
+import { createLoadCategory } from './loaders/load-category.js';
+import { createLoadPosts } from './loaders/load-posts.js';
+import { createLoadPost } from './loaders/load-post.js';
+import { createLoadConfig } from './loaders/load-config.js';
+
+function createWebInterfaces(input) {
+  const { coreServer, applications, constants } = input;
+  const actionContext = {
+    coreServer,
+    applications,
+    constants
+  };
+  const actions = {
+    resources: {
+      post: {
+        findFull: createPostFindFullAction(actionContext),
+        findListCards: createPostFindListCardsAction(actionContext)
+      },
+      config: {
+        find: createConfigFindAction(actionContext)
+      },
+      inquiry: {
+        create: createInquiryCreateAction(actionContext)
+      }
+    }
+  };
+  const ctx = {
+    coreServer,
+    constants,
+    interfaces: { actions }
+  };
+  const loaders = {
+    loadPage: createLoadPage(ctx),
+    loadCategories: createLoadCategories(ctx),
+    loadCategory: createLoadCategory(ctx),
+    loadPosts: createLoadPosts(ctx),
+    loadPost: createLoadPost(ctx),
+    loadConfig: createLoadConfig(ctx)
+  };
+  return {
+    actions,
+    loaders
+  };
+}
+
+export { createWebInterfaces };

package/dist/src/web/server/interfaces/loaders/load-categories.js

@@ -0,0 +1,50 @@
+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 '../../../../core/domain/resources/admin/constants.js';
+import { POST_ORDER_BY } from '../../../../core/server/infrastructure/database/constants.js';
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { ensureArray } from '../../../../shared/utils/ensure-array.js';
+import 'ulid';
+import { POST_LIST_CARD_INCLUDE } from '../../../../core/server/infrastructure/database/post/include.js';
+import 'nodemailer';
+import '../../../../core/server/infrastructure/email/render-email-template.js';
+import 'intor';
+import 'jsonwebtoken';
+import 'zod';
+
+function createLoadCategories(ctx) {
+  const { coreServer, interfaces, constants } = ctx;
+  return async function loadCategories({
+    topicSlug,
+    childrenCount
+  }) {
+    const categoryType = constants.topics[topicSlug]?.categoryType;
+    const include = {
+      children: {
+        where: { isActive: true },
+        include: POST_LIST_CARD_INCLUDE,
+        orderBy: POST_ORDER_BY,
+        ...childrenCount && { take: childrenCount }
+      }
+    };
+    const { items: categories } = await coreServer.interfaces.executions.runAction(
+      () => interfaces.actions.resources.post.findListCards({
+        type: categoryType ?? null,
+        topicSlug,
+        isActive: true,
+        // extra children posts
+        ...childrenCount && { include }
+      })
+    );
+    return {
+      categories: ensureArray(categories)
+    };
+  };
+}
+
+export { createLoadCategories };

package/dist/src/web/server/interfaces/loaders/load-category.js

@@ -0,0 +1,20 @@
+function createLoadCategory(ctx) {
+  const { coreServer, interfaces, constants } = ctx;
+  return async function loadCategory({
+    topicSlug,
+    categorySlug
+  }) {
+    const categoryType = constants.topics[topicSlug]?.categoryType;
+    const { post: category } = await coreServer.interfaces.executions.runAction(
+      () => interfaces.actions.resources.post.findFull({
+        ...categoryType && { type: categoryType },
+        slug: categorySlug
+      })
+    );
+    return {
+      category
+    };
+  };
+}
+
+export { createLoadCategory };