sitero 0.0.1

package/dist/src/core/server/infrastructure/database/post/include.js

@@ -0,0 +1,67 @@
+import { ADMIN_FULL_INCLUDE } from '../admin/include.js';
+
+const POST_LIST_CARD_INCLUDE = {
+  // ---------------------------
+  // relations: Post
+  // ---------------------------
+  topic: { include: { translations: true } },
+  // Use as post, category
+  postsInTopic: true,
+  // Use as topic
+  children: true,
+  // Use as category
+  taggedPosts: true,
+  // Use as tag
+  tags: { include: { translations: true } },
+  // ---------------------------
+  // relations: File
+  // ---------------------------
+  coverImage: { include: { translations: true } },
+  // ---------------------------
+  // translation
+  // ---------------------------
+  translations: true
+};
+const POST_FULL_INCLUDE = {
+  // ---------------------------
+  // relations: Admin
+  // ---------------------------
+  author: {
+    include: ADMIN_FULL_INCLUDE,
+    omit: { passwordHash: true }
+  },
+  // ---------------------------
+  // relations: Post
+  // ---------------------------
+  topic: { include: POST_LIST_CARD_INCLUDE },
+  postsInTopic: { include: POST_LIST_CARD_INCLUDE },
+  parents: { include: POST_LIST_CARD_INCLUDE },
+  children: { include: POST_LIST_CARD_INCLUDE },
+  tags: { include: POST_LIST_CARD_INCLUDE },
+  taggedPosts: { include: POST_LIST_CARD_INCLUDE },
+  relatedPosts: { include: POST_LIST_CARD_INCLUDE },
+  referencingPosts: { include: POST_LIST_CARD_INCLUDE },
+  // ---------------------------
+  // relations: File
+  // ---------------------------
+  coverImage: { include: { translations: true } },
+  // ---------------------------
+  // relations: File
+  // ---------------------------
+  seoMetadatas: true,
+  // ---------------------------
+  // --- custom fields
+  // ---------------------------
+  files1: { include: { translations: true } },
+  files2: { include: { translations: true } },
+  file1: { include: { translations: true } },
+  file2: { include: { translations: true } },
+  file3: { include: { translations: true } },
+  file4: { include: { translations: true } },
+  // ---------------------------
+  // translation
+  // ---------------------------
+  translations: true
+};
+
+export { POST_FULL_INCLUDE, POST_LIST_CARD_INCLUDE };

package/dist/src/core/server/infrastructure/database/post/query/post-query-repository.js

@@ -0,0 +1,186 @@
+import { POST_ORDER_BY } from '../../constants.js';
+import { createPagination } from '../../utils/create-pagination.js';
+import { createSearch } from '../../utils/create-search.js';
+import { POST_FULL_INCLUDE, POST_LIST_CARD_INCLUDE } from '../include.js';
+
+function buildWhere(params) {
+  if (params.id) return { id: params.id };
+  if (params.type && params.slug)
+    return { type: params.type, slug: params.slug };
+  return;
+}
+function createPostQueryRepository(prisma) {
+  async function findListCards({
+    locale,
+    // search
+    searchString,
+    // type
+    type,
+    // states
+    isActive,
+    isIndexActive,
+    isSlugActive,
+    isFeatured,
+    isShownOnHome,
+    state1,
+    state2,
+    state3,
+    state4,
+    state5,
+    state6,
+    state7,
+    state8,
+    state9,
+    state10,
+    // relations
+    topicId,
+    topicSlug,
+    categoryId,
+    categorySlug,
+    // specified ids
+    postIds,
+    excludeIds,
+    // pagination
+    page,
+    pageSize,
+    // extra include
+    include
+  }) {
+    const where = {
+      // search
+      ...createSearch({
+        ...searchString ? { searchString } : {},
+        locale,
+        rootFields: ["slug"],
+        translationFields: [
+          "title",
+          "subtitle",
+          "summary",
+          "description",
+          "content"
+        ]
+      }),
+      // type
+      ...type ? { type } : {},
+      // states
+      ...isActive ? { isActive: true } : {},
+      ...isIndexActive ? { isIndexActive: true } : {},
+      ...isSlugActive ? { isSlugActive: true } : {},
+      ...isFeatured ? { isFeatured: true } : {},
+      ...isShownOnHome ? { isShownOnHome: true } : {},
+      ...state1 ? { state1: true } : {},
+      ...state2 ? { state2: true } : {},
+      ...state3 ? { state3: true } : {},
+      ...state4 ? { state4: true } : {},
+      ...state5 ? { state5: true } : {},
+      ...state6 ? { state6: true } : {},
+      ...state7 ? { state7: true } : {},
+      ...state8 ? { state8: true } : {},
+      ...state9 ? { state9: true } : {},
+      ...state10 ? { state10: true } : {},
+      // relations
+      ...topicId ? { topicId } : {},
+      ...topicSlug ? { topic: { slug: topicSlug } } : {},
+      ...categoryId ? { parents: { some: { id: categoryId } } } : {},
+      ...categorySlug ? { parents: { some: { slug: categorySlug } } } : {},
+      // Specified ids
+      ...postIds || excludeIds ? {
+        id: {
+          ...postIds ? { in: postIds } : {},
+          ...excludeIds ? { notIn: excludeIds } : {}
+        }
+      } : {}
+    };
+    const [items, total] = await prisma.$transaction([
+      prisma.post.findMany({
+        where,
+        orderBy: POST_ORDER_BY,
+        include: { ...POST_LIST_CARD_INCLUDE, ...include ?? {} },
+        ...createPagination(page, pageSize)
+      }),
+      prisma.post.count({ where })
+    ]);
+    return { items, total };
+  }
+  async function find({
+    isActive,
+    ...rest
+  }) {
+    const where = buildWhere(rest);
+    if (!where) return null;
+    return prisma.post.findFirst({
+      where: { ...where, ...isActive ? { isActive } : {} },
+      include: { translations: true }
+    });
+  }
+  async function findMany({
+    type,
+    topicId
+  }) {
+    return prisma.post.findMany({
+      where: { type, ...topicId ? { topicId } : {} },
+      orderBy: POST_ORDER_BY,
+      include: { translations: true }
+    });
+  }
+  async function findFull({
+    // states
+    isActive,
+    // relations
+    topicSlug,
+    ...rest
+  }) {
+    const where = buildWhere(rest);
+    if (!where) return { post: void 0, prev: void 0, next: void 0 };
+    const baseWhere = {
+      // states
+      ...isActive ? { isActive } : {},
+      // relations
+      ...topicSlug ? { topic: { slug: topicSlug } } : {}
+    };
+    const post = await prisma.post.findFirst({
+      where: { ...baseWhere, ...where },
+      include: POST_FULL_INCLUDE
+    });
+    if (!post) return { post: void 0, prev: void 0, next: void 0 };
+    const next = await prisma.post.findFirst({
+      where: {
+        ...baseWhere,
+        ...rest.type !== void 0 ? { type: rest.type } : {}
+      },
+      orderBy: POST_ORDER_BY,
+      cursor: { id: post.id },
+      skip: 1,
+      take: 1,
+      include: POST_LIST_CARD_INCLUDE
+    });
+    const reversedOrder = POST_ORDER_BY.map((o) => {
+      const key = Object.keys(o)[0];
+      return { [key]: o[key] === "asc" ? "desc" : "asc" };
+    });
+    const prev = await prisma.post.findFirst({
+      where: {
+        ...baseWhere,
+        ...rest.type !== void 0 ? { type: rest.type } : {}
+      },
+      orderBy: reversedOrder,
+      cursor: { id: post.id },
+      skip: 1,
+      take: 1,
+      include: POST_LIST_CARD_INCLUDE
+    });
+    return {
+      post,
+      prev,
+      next
+    };
+  }
+  return {
+    findListCards,
+    findMany,
+    find,
+    findFull
+  };
+}
+
+export { createPostQueryRepository };

package/dist/src/core/server/infrastructure/database/seo-metadata/command/seo-metadata-command-repository.js

@@ -0,0 +1,31 @@
+function createSeoMetadataCommandRepository(prisma) {
+  async function upsert({
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // Post
+    postId,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations
+  }) {
+    await prisma.post.update({
+      where: { id: postId },
+      data: {
+        seoMetadatas: {
+          upsert: translations.map((t) => ({
+            where: { postId_locale: { postId, locale: t.locale } },
+            update: { ...t, alternate: t.alternate },
+            create: { ...t, alternate: t.alternate }
+          }))
+        }
+      }
+    });
+  }
+  return {
+    upsert
+  };
+}
+
+export { createSeoMetadataCommandRepository };

package/dist/src/core/server/infrastructure/database/user/command/user-command-repository.js

@@ -0,0 +1,55 @@
+function createUserCommandRepository(prisma) {
+  async function create({
+    // core
+    email,
+    passwordHash,
+    name
+  }) {
+    const created = await prisma.user.create({
+      data: {
+        // core
+        email,
+        passwordHash,
+        ...name !== void 0 ? { name } : {}
+      }
+    });
+    return created;
+  }
+  async function update({
+    id,
+    // core
+    email,
+    name,
+    // ------------------------------------
+    // timestamps
+    // ------------------------------------
+    emailVerifiedAt
+  }) {
+    const updated = await prisma.user.update({
+      where: { id },
+      data: {
+        // core
+        ...email !== void 0 ? { email } : {},
+        ...name !== void 0 ? { name } : {},
+        // ------------------------------------------------------------------------
+        // timestamps
+        // ------------------------------------------------------------------------
+        emailVerifiedAt
+      }
+    });
+    return updated;
+  }
+  async function _delete({ id }) {
+    const deleted = await prisma.user.delete({
+      where: { id }
+    });
+    return deleted;
+  }
+  return {
+    create,
+    update,
+    delete: _delete
+  };
+}
+
+export { createUserCommandRepository };

package/dist/src/core/server/infrastructure/database/user/include.js

@@ -0,0 +1,8 @@
+const USER_FULL_INCLUDE = {
+  // ---------------------------
+  // relations: UserRefreshToken
+  // ---------------------------
+  userRefreshTokens: true
+};
+
+export { USER_FULL_INCLUDE };

package/dist/src/core/server/infrastructure/database/user/query/user-query-repository.js

@@ -0,0 +1,74 @@
+import { ORDER_BY } from '../../constants.js';
+import { createPagination } from '../../utils/create-pagination.js';
+import { createSearch } from '../../utils/create-search.js';
+import { USER_FULL_INCLUDE } from '../include.js';
+
+const OMIT_PASSWORD = { omit: { passwordHash: true } };
+function buildWhere(params) {
+  if (params.id) return { id: params.id };
+  if (params.email) return { email: params.email };
+  return;
+}
+function createUserQueryRepository(prisma) {
+  async function findListCards({
+    // search
+    searchString,
+    status,
+    // pagination
+    page,
+    pageSize
+  }) {
+    const where = {
+      // search
+      ...createSearch({
+        ...searchString !== void 0 ? { searchString } : {},
+        rootFields: ["email", "name"]
+      }),
+      // status
+      ...status !== void 0 ? { status } : {}
+    };
+    const [items, total] = await prisma.$transaction([
+      prisma.user.findMany({
+        where,
+        orderBy: [...ORDER_BY],
+        include: USER_FULL_INCLUDE,
+        ...createPagination(page, pageSize),
+        ...OMIT_PASSWORD
+      }),
+      prisma.user.count({ where })
+    ]);
+    return { items, total };
+  }
+  async function find(params) {
+    const where = buildWhere(params);
+    if (!where) return null;
+    return prisma.user.findUnique({
+      where,
+      ...OMIT_PASSWORD
+    });
+  }
+  async function findFull(params) {
+    const where = buildWhere(params);
+    if (!where) return null;
+    return prisma.user.findUnique({
+      where,
+      include: USER_FULL_INCLUDE,
+      ...OMIT_PASSWORD
+    });
+  }
+  async function findWithPasswordHash(params) {
+    const where = buildWhere(params);
+    if (!where) return null;
+    return prisma.user.findUnique({
+      where
+    });
+  }
+  return {
+    findListCards,
+    find,
+    findFull,
+    findWithPasswordHash
+  };
+}
+
+export { createUserQueryRepository };

package/dist/src/core/server/infrastructure/database/user-refresh-token/command/user-refresh-token-command-repository.js

@@ -0,0 +1,36 @@
+function createUserRefreshTokenCommandRepository(prisma) {
+  async function create({
+    userId,
+    ...params
+  }) {
+    const created = await prisma.userRefreshToken.create({
+      data: {
+        ...params,
+        user: { connect: { id: userId } },
+        deviceInfo: params.deviceInfo
+      }
+    });
+    return created;
+  }
+  async function _delete({ id, tokenHash }) {
+    const where = id ? { id } : tokenHash ? { tokenHash } : void 0;
+    if (where) {
+      await prisma.userRefreshToken.delete({
+        where
+      });
+    }
+  }
+  async function deleteManyByExpired() {
+    const { count } = await prisma.userRefreshToken.deleteMany({
+      where: { expiresAt: { lt: /* @__PURE__ */ new Date() } }
+    });
+    return count;
+  }
+  return {
+    create,
+    delete: _delete,
+    deleteManyByExpired
+  };
+}
+
+export { createUserRefreshTokenCommandRepository };

package/dist/src/core/server/infrastructure/database/user-refresh-token/query/user-refresh-token-query-repository.js

@@ -0,0 +1,23 @@
+function createUserRefreshTokenQueryRepository(prisma) {
+  async function findManyByUserId({
+    userId
+  }) {
+    return prisma.userRefreshToken.findMany({
+      where: { userId },
+      orderBy: [{ createdAt: "desc" }, { id: "asc" }]
+    });
+  }
+  async function findByToken({
+    tokenHash
+  }) {
+    return prisma.userRefreshToken.findUnique({
+      where: { tokenHash }
+    });
+  }
+  return {
+    findManyByUserId,
+    findByToken
+  };
+}
+
+export { createUserRefreshTokenQueryRepository };

package/dist/src/core/server/infrastructure/database/utils/build-file-usage.js

@@ -0,0 +1,20 @@
+function buildFileUsage(isLocked) {
+  const relations = [
+    "adminAsAvatarImage",
+    "postsAsCoverImage",
+    "postsAsContentImage",
+    "postsAsFiles1",
+    "postsAsFiles2",
+    "postsAsFile1",
+    "postsAsFile2",
+    "postsAsFile3",
+    "postsAsFile4"
+  ];
+  if (isLocked === void 0 || isLocked === null) return {};
+  const condition = relations.map((r) => ({
+    [r]: { [isLocked ? "some" : "none"]: {} }
+  }));
+  return isLocked ? { OR: condition } : { AND: condition };
+}
+
+export { buildFileUsage };

package/dist/src/core/server/infrastructure/database/utils/connect.js

@@ -0,0 +1,15 @@
+const ids = (items) => items.map(({ id }) => ({ id }));
+function connectOne(item) {
+  return item ? { connect: { id: item.id } } : {};
+}
+function connectMany(items) {
+  return { connect: ids(items) };
+}
+function updateOne(item) {
+  return item ? { connect: { id: item.id } } : { disconnect: true };
+}
+function updateMany(items) {
+  return { set: ids(items) };
+}
+
+export { connectMany, connectOne, updateMany, updateOne };

package/dist/src/core/server/infrastructure/database/utils/create-pagination.js

@@ -0,0 +1,9 @@
+function createPagination(page, pageSize) {
+  if (!page || !pageSize) return {};
+  return {
+    skip: (page - 1) * pageSize,
+    take: pageSize
+  };
+}
+
+export { createPagination };

package/dist/src/core/server/infrastructure/database/utils/create-search.js

@@ -0,0 +1,32 @@
+function buildContainsOr(fields, value) {
+  return fields.map((field) => ({
+    [field]: { contains: value, mode: "insensitive" }
+  }));
+}
+function buildTranslationSearch(locale, fields, value) {
+  return {
+    translations: {
+      some: { locale, OR: buildContainsOr(fields, value) }
+    }
+  };
+}
+function createSearch({
+  locale,
+  searchString,
+  rootFields = [],
+  translationFields = []
+}) {
+  if (!searchString) return {};
+  const conditions = [];
+  if (rootFields.length > 0) {
+    conditions.push(...buildContainsOr(rootFields, searchString));
+  }
+  if (translationFields.length > 0 && locale) {
+    conditions.push(
+      buildTranslationSearch(locale, translationFields, searchString)
+    );
+  }
+  return conditions.length > 0 ? { OR: conditions } : {};
+}
+
+export { createSearch };

package/dist/src/core/server/infrastructure/email/render-email-template.js

@@ -0,0 +1,64 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const TEMPLATE_DIR = path.resolve(process.cwd(), "emails");
+const LAYOUT_PATH = path.join(TEMPLATE_DIR, "layout.html");
+const isDev = process.env.NODE_ENV !== "production";
+const cache = /* @__PURE__ */ new Map();
+async function readTemplate(filePath) {
+  if (!isDev && cache.has(filePath)) {
+    return cache.get(filePath);
+  }
+  try {
+    const html = await readFile(filePath, "utf8");
+    if (!isDev) cache.set(filePath, html);
+    return html;
+  } catch (error) {
+    throw new Error(`Email template file not found: ${filePath}`, {
+      cause: error
+    });
+  }
+}
+function applyReplacements(html, replacements, logger) {
+  return html.replace(/\{\{\{(.*?)\}\}\}/g, (_, raw) => {
+    const key = raw.trim();
+    const value = replacements[key];
+    if (value == null) {
+      logger.warn({ msg: "Email template variable missing", variable: key });
+      return "";
+    }
+    return value;
+  });
+}
+function createRenderEmailTemplate({
+  siteName,
+  webUrl,
+  logoUrl,
+  logger
+}) {
+  return async function renderEmailTemplate(templateKey, replacements = {}) {
+    try {
+      const contentPath = path.join(TEMPLATE_DIR, `${templateKey}.html`);
+      const vars = {
+        SITE_NAME: siteName,
+        WEB_URL: webUrl,
+        LOGO_URL: logoUrl,
+        ...replacements
+      };
+      const layoutHtml = await readTemplate(LAYOUT_PATH);
+      const contentHtml = await readTemplate(contentPath);
+      const merged = layoutHtml.replaceAll("{{{content}}}", contentHtml);
+      return applyReplacements(merged, vars, logger);
+    } catch (error) {
+      logger.error({
+        msg: "Email template render failed",
+        templateKey,
+        templateDir: TEMPLATE_DIR,
+        error
+      });
+      throw new Error(`Email template error: ${templateKey}`, { cause: error });
+    }
+  };
+}
+
+export { createRenderEmailTemplate };

package/dist/src/core/server/infrastructure/email/send-email.js

@@ -0,0 +1,32 @@
+function createSendEmail({
+  transporter,
+  config,
+  logger
+}) {
+  return async function sendEmail(options) {
+    try {
+      const info = await transporter.sendMail({
+        from: `${config.fromName} <${config.fromAddress}>`,
+        replyTo: `${config.replyToName} <${config.replyToaddress}>`,
+        ...options
+      });
+      logger.info("Email sent", {
+        to: options.to,
+        subject: options.subject,
+        messageId: info.messageId,
+        accepted: info.accepted,
+        rejected: info.rejected
+      });
+      return info;
+    } catch (error) {
+      logger.error("Email failed", {
+        to: options.to,
+        subject: options.subject,
+        error
+      });
+      throw error;
+    }
+  };
+}
+
+export { createSendEmail };

package/dist/src/core/server/infrastructure/email/transporter.js

@@ -0,0 +1,19 @@
+import nodemailer from 'nodemailer';
+
+function createTransporter({
+  host,
+  port,
+  user,
+  pass
+}) {
+  return nodemailer.createTransport({
+    host,
+    port,
+    auth: {
+      user,
+      pass
+    }
+  });
+}
+
+export { createTransporter };