sitero 0.0.1

package/dist/src/core/server/infrastructure/cache/normalize-cache-key.js

@@ -0,0 +1,20 @@
+import { CACHE_KEY_DELIMITER } from './cache-key-delimiter.js';
+
+const sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
+const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
+  if (key == null || key === "") return null;
+  if (Array.isArray(key)) {
+    if (key.length === 0) return null;
+    const normalized = key.map((k) => {
+      if (k === null) return "__null";
+      if (k === void 0) return "__undefined";
+      if (typeof k === "boolean") return k ? "__true" : "__false";
+      return sanitize(String(k));
+    });
+    return normalized.join(delimiter);
+  }
+  if (typeof key === "boolean") return key ? "__true" : "__false";
+  return String(key);
+};
+
+export { normalizeCacheKey };

package/dist/src/core/server/infrastructure/cookie/cookie-service.js

@@ -0,0 +1,81 @@
+import { timingSafeEqual } from 'node:crypto';
+
+const DEFAULT_OPTIONS = {
+  httpOnly: true,
+  secure: process.env["NODE_ENV"] === "production",
+  sameSite: "strict",
+  path: "/"
+};
+function createCookieService(nextCookies, cryptoService, options = DEFAULT_OPTIONS) {
+  async function set({
+    name,
+    value,
+    expireSeconds
+  }) {
+    const cookieStore = await nextCookies();
+    cookieStore.set(name, value, { ...options, maxAge: expireSeconds });
+  }
+  async function setSignedCookie({
+    name,
+    value,
+    expireSeconds
+  }) {
+    const createdAt = Date.now();
+    const { signed } = cryptoService.sign({
+      value,
+      expireSeconds,
+      createdAt
+    });
+    await set({ name, value: signed, expireSeconds });
+  }
+  async function get({ name }) {
+    const cookieStore = await nextCookies();
+    const cookieValue = cookieStore.get(name)?.value;
+    return cookieValue;
+  }
+  async function getSignedCookie({ name }) {
+    const signed = await get({ name });
+    const value = verifySignedCookie({ signed });
+    return value;
+  }
+  function verifySignedCookie({ signed }) {
+    if (!signed) throw new Error("Invalid cookie");
+    const parts = signed.split("|");
+    if (parts.length !== 4) throw new Error("Invalid cookie");
+    const [value, expireSecondsStr, createdAtStr, signature] = parts;
+    const expireSeconds = Number.parseInt(expireSecondsStr, 10);
+    const createdAt = Number.parseInt(createdAtStr, 10);
+    if (Number.isNaN(expireSeconds) || Number.isNaN(createdAt)) {
+      throw new TypeError("Invalid cookie");
+    }
+    const now = Date.now();
+    if (now > createdAt + expireSeconds * 1e3) {
+      throw new Error("Cookie expired");
+    }
+    const { signature: generatedSignature } = cryptoService.sign({
+      value,
+      expireSeconds,
+      createdAt
+    });
+    const sig = Buffer.from(signature);
+    const gen = Buffer.from(generatedSignature);
+    if (sig.length !== gen.length || !timingSafeEqual(sig, gen)) {
+      throw new Error("Invalid cookie signature");
+    }
+    return value;
+  }
+  async function deleteCokkie({ name }) {
+    const cookieStore = await nextCookies();
+    cookieStore.delete(name);
+  }
+  return {
+    set,
+    setSignedCookie,
+    get,
+    getSignedCookie,
+    verifySignedCookie,
+    delete: deleteCokkie
+  };
+}
+
+export { createCookieService };

package/dist/src/core/server/infrastructure/create-core-infrastructure.js

@@ -0,0 +1,148 @@
+import { createArgon2Service } from './argon2/argon2-service.js';
+import { createCache } from './cache/cache.js';
+import { createCacheResult } from './cache/cache-result.js';
+import { createIpRateLimiter } from './cache/ip-rate-limiter.js';
+import { createCookieService } from './cookie/cookie-service.js';
+import { createCryptoService } from './crypto/crypto-service.js';
+import { createAdminCommandRepository } from './database/admin/command/admin-command-repository.js';
+import { createAdminQueryRepository } from './database/admin/query/admin-query-repository.js';
+import { createAdminRefreshTokenCommandRepository } from './database/admin-refresh-token/command/admin-refresh-token-command-repository.js';
+import { createAdminRefreshTokenQueryRepository } from './database/admin-refresh-token/query/admin-refresh-token-query-repository.js';
+import { createUserCommandRepository } from './database/user/command/user-command-repository.js';
+import { createUserQueryRepository } from './database/user/query/user-query-repository.js';
+import { createUserRefreshTokenCommandRepository } from './database/user-refresh-token/command/user-refresh-token-command-repository.js';
+import { createUserRefreshTokenQueryRepository } from './database/user-refresh-token/query/user-refresh-token-query-repository.js';
+import { createFileCommandRepository } from './database/file/command/file-command-repository.js';
+import { createFileQueryRepository } from './database/file/query/file-query-repository.js';
+import { createFolderCommandRepository } from './database/folder/command/folder-command-repository.js';
+import { createFolderQueryRepository } from './database/folder/query/folder-query-repository.js';
+import { createPostCommandRepository } from './database/post/command/post-command-repository.js';
+import { createPostQueryRepository } from './database/post/query/post-query-repository.js';
+import { createSeoMetadataCommandRepository } from './database/seo-metadata/command/seo-metadata-command-repository.js';
+import { createConfigCommandRepository } from './database/config/command/config-command-repository.js';
+import { createConfigQueryRepository } from './database/config/query/config-query-repository.js';
+import { createInquiryCommandRepository } from './database/inquiry/command/inquiry-command-repository.js';
+import { createInquiryQueryRepository } from './database/inquiry/query/post-query-repository.js';
+import { createTransporter } from './email/transporter.js';
+import { createSendEmail } from './email/send-email.js';
+import { createRenderEmailTemplate } from './email/render-email-template.js';
+import { createIntorConfig } from './i18n/intor-config.js';
+import { createJwtService } from './jwt/jwt-service.js';
+import { createZod } from './zod/zod.js';
+import { createUnique } from './zod/rules/unique.js';
+import { createExist } from './zod/rules/exist.js';
+import { createSchemas } from './zod/schemas/schemas.js';
+import { createFileSchema, createMultiFileSchema } from './zod/schemas/file.js';
+import { createTocItemSchema } from './zod/schemas/toc-item.js';
+
+function createCoreInfrastructure(input) {
+  const prisma = input.prisma;
+  const argon2Service = createArgon2Service();
+  const cryptoService = createCryptoService({
+    defaultSecret: input.constants.defaultSecret
+  });
+  const jwtService = createJwtService({
+    defaultSecret: input.constants.defaultSecret,
+    ...input.constants.jwt
+  });
+  const cookieService = createCookieService(input.next.cookies, cryptoService);
+  const storageService = input.storage.service;
+  const cache = createCache({
+    redisUrl: input.constants.redisUrl,
+    namespace: input.constants.appName
+  });
+  const cacheResult = createCacheResult(cache, input.logger);
+  const ipRateLimiter = createIpRateLimiter({
+    cache,
+    appName: cache.namespace,
+    headers: input.next.headers
+  });
+  const transporter = createTransporter(input.constants.email.transporter);
+  const sendEmail = createSendEmail({
+    transporter,
+    config: input.constants.email.sendMail.config,
+    logger: input.logger
+  });
+  const renderEmailTemplate = createRenderEmailTemplate({
+    siteName: input.constants.siteName,
+    webUrl: input.constants.webUrl,
+    logoUrl: input.constants.logoUrl,
+    logger: input.logger
+  });
+  const unique = createUnique(prisma);
+  const exist = createExist(prisma);
+  const z = createZod({ unique, exist });
+  const schemas = createSchemas({ z, exist });
+  const fileSchema = createFileSchema({
+    z,
+    maxSizeInMb: input.constants.maxFileSizeInMb
+  });
+  const multiFilesSchema = createMultiFileSchema({
+    z,
+    fileSchema,
+    maxSizeInMb: input.constants.maxFileSizeInMb
+  });
+  const tocItemSchema = createTocItemSchema({ z, schemas });
+  const intorConfig = createIntorConfig(input.constants.i18n);
+  const repositories = {
+    adminQueryRepository: createAdminQueryRepository(prisma),
+    adminCommandRepository: createAdminCommandRepository(prisma),
+    adminRefreshTokenQueryRepository: createAdminRefreshTokenQueryRepository(prisma),
+    adminRefreshTokenCommandRepository: createAdminRefreshTokenCommandRepository(prisma),
+    userQueryRepository: createUserQueryRepository(prisma),
+    userCommandRepository: createUserCommandRepository(prisma),
+    userRefreshTokenQueryRepository: createUserRefreshTokenQueryRepository(prisma),
+    userRefreshTokenCommandRepository: createUserRefreshTokenCommandRepository(prisma),
+    folderQueryRepository: createFolderQueryRepository(prisma),
+    folderCommandRepository: createFolderCommandRepository(prisma),
+    fileQueryRepository: createFileQueryRepository(prisma),
+    fileCommandRepository: createFileCommandRepository(prisma),
+    postQueryRepository: createPostQueryRepository(prisma),
+    postCommandRepository: createPostCommandRepository(prisma),
+    seoMetadataCommandRepository: createSeoMetadataCommandRepository(prisma),
+    configCommandRepository: createConfigCommandRepository(prisma),
+    configQueryRepository: createConfigQueryRepository(prisma),
+    inquiryCommandRepository: createInquiryCommandRepository(prisma),
+    inquiryQueryRepository: createInquiryQueryRepository(prisma)
+  };
+  return {
+    // prisma (client)
+    prisma,
+    // services
+    services: {
+      argon2Service,
+      cryptoService,
+      jwtService,
+      cookieService,
+      storageService
+    },
+    // cache
+    cache: {
+      cache,
+      cacheResult,
+      ipRateLimiter
+    },
+    // email
+    email: {
+      transporter,
+      sendEmail,
+      renderEmailTemplate
+    },
+    // zod
+    zod: {
+      z,
+      schemas,
+      fileSchema,
+      multiFilesSchema,
+      tocItemSchema
+    },
+    // i18n
+    i18n: {
+      intorConfig
+    },
+    // repositories
+    repositories
+  };
+}
+
+export { createCoreInfrastructure };

package/dist/src/core/server/infrastructure/crypto/crypto-service.js

@@ -0,0 +1,66 @@
+import crypto from 'node:crypto';
+
+function createCryptoService({
+  defaultSecret
+}) {
+  const SECRET = crypto.createHash("sha256").update(defaultSecret).digest();
+  const ALGORITHM = "aes-256-gcm";
+  const IV_LENGTH = 12;
+  function generateToken() {
+    return crypto.randomBytes(32).toString("base64url");
+  }
+  function hash(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+  }
+  function hashBuffer(value) {
+    return crypto.createHash("sha256").update(value).digest();
+  }
+  function encrypt(data) {
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, SECRET, iv);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return [
+      iv.toString("hex"),
+      encrypted.toString("hex"),
+      tag.toString("hex")
+    ].join(":");
+  }
+  function decrypt(data) {
+    const parts = data.split(":");
+    if (parts.length !== 3 || !parts.every(Boolean)) {
+      throw new Error("Invalid encrypted payload");
+    }
+    const [ivHex, encryptedHex, tagHex] = parts;
+    const iv = Buffer.from(ivHex, "hex");
+    const encrypted = Buffer.from(encryptedHex, "hex");
+    const tag = Buffer.from(tagHex, "hex");
+    const decipher = crypto.createDecipheriv(ALGORITHM, SECRET, iv);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([
+      decipher.update(encrypted),
+      decipher.final()
+    ]);
+    return decrypted.toString("utf8");
+  }
+  function sign({
+    value,
+    expireSeconds,
+    createdAt
+  }) {
+    const payload = `${value}|${expireSeconds}|${createdAt ?? Date.now()}`;
+    const signature = crypto.createHmac("sha256", SECRET).update(payload).digest("hex");
+    const signed = `${payload}|${signature}`;
+    return { signed, signature };
+  }
+  return {
+    generateToken,
+    hash,
+    hashBuffer,
+    encrypt,
+    decrypt,
+    sign
+  };
+}
+
+export { createCryptoService };

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

@@ -0,0 +1,107 @@
+import { updateOne, connectOne } from '../../utils/connect.js';
+
+function createAdminCommandRepository(prisma) {
+  async function create({
+    // core
+    role,
+    email,
+    passwordHash,
+    // better seo
+    socialLinks,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // File
+    avatarImage,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations
+  }) {
+    const created = await prisma.admin.create({
+      data: {
+        // core
+        role,
+        email,
+        passwordHash,
+        // better seo
+        socialLinks,
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // File
+        avatarImage: connectOne(avatarImage),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: { create: translations }
+      }
+    });
+    return created;
+  }
+  async function update({
+    id,
+    // core
+    role,
+    email,
+    // better seo
+    socialLinks,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // File
+    avatarImage,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations,
+    // ------------------------------------
+    // timestamps
+    // ------------------------------------
+    emailVerifiedAt
+  }) {
+    const updated = await prisma.admin.update({
+      where: { id },
+      data: {
+        // core
+        role,
+        ...email !== void 0 ? { email } : {},
+        // better seo
+        socialLinks,
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // File
+        avatarImage: updateOne(avatarImage),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: {
+          upsert: translations.map((t) => ({
+            where: { adminId_locale: { adminId: id, locale: t.locale } },
+            update: t,
+            create: t
+          }))
+        },
+        // ------------------------------------------------------------------------
+        // timestamps
+        // ------------------------------------------------------------------------
+        emailVerifiedAt
+      }
+    });
+    return updated;
+  }
+  async function _delete({ id }) {
+    const deleted = await prisma.admin.delete({
+      where: { id }
+    });
+    return deleted;
+  }
+  return {
+    create,
+    update,
+    delete: _delete
+  };
+}
+
+export { createAdminCommandRepository };

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

@@ -0,0 +1,20 @@
+const ADMIN_FULL_INCLUDE = {
+  // ---------------------------
+  // relations: AdminRefreshToken
+  // ---------------------------
+  adminRefreshTokens: true,
+  // ---------------------------
+  // relations: File
+  // ---------------------------
+  avatarImage: { include: { translations: true } },
+  // ---------------------------
+  // relations: Post
+  // ---------------------------
+  posts: true,
+  // ---------------------------
+  // translation
+  // ---------------------------
+  translations: true
+};
+
+export { ADMIN_FULL_INCLUDE };

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

@@ -0,0 +1,81 @@
+import { ADMIN_ROLES } from '../../../../../domain/resources/admin/props.js';
+import '../../../../../domain/resources/admin/constants.js';
+import { ADMIN_ORDER_BY } from '../../constants.js';
+import { createPagination } from '../../utils/create-pagination.js';
+import { createSearch } from '../../utils/create-search.js';
+import { ADMIN_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 createAdminQueryRepository(prisma) {
+  async function findListCards({
+    locale,
+    // search
+    searchString,
+    role,
+    adminIds,
+    // pagination
+    page,
+    pageSize
+  }) {
+    const where = {
+      // search
+      ...createSearch({
+        ...searchString !== void 0 ? { searchString } : {},
+        locale,
+        translationFields: ["name"]
+      }),
+      // role
+      ...role !== ADMIN_ROLES.SUPER_ADMIN ? { role: { notIn: [ADMIN_ROLES.SUPER_ADMIN] } } : {},
+      // Specified ids
+      ...adminIds ? { id: { in: adminIds } } : {}
+    };
+    const [items, total] = await prisma.$transaction([
+      prisma.admin.findMany({
+        where,
+        orderBy: ADMIN_ORDER_BY,
+        include: ADMIN_FULL_INCLUDE,
+        ...createPagination(page, pageSize),
+        ...OMIT_PASSWORD
+      }),
+      prisma.admin.count({ where })
+    ]);
+    return { items, total };
+  }
+  async function find(params) {
+    const where = buildWhere(params);
+    if (!where) return null;
+    return prisma.admin.findUnique({
+      where,
+      ...OMIT_PASSWORD
+    });
+  }
+  async function findFull(params) {
+    const where = buildWhere(params);
+    if (!where) return null;
+    return prisma.admin.findUnique({
+      where,
+      include: ADMIN_FULL_INCLUDE,
+      ...OMIT_PASSWORD
+    });
+  }
+  async function findWithPasswordHash(params) {
+    const where = buildWhere(params);
+    if (!where) return null;
+    return prisma.admin.findUnique({
+      where
+    });
+  }
+  return {
+    findListCards,
+    find,
+    findFull,
+    findWithPasswordHash
+  };
+}
+
+export { createAdminQueryRepository };

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

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

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

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

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

@@ -0,0 +1,52 @@
+import { updateOne, updateMany } from '../../utils/connect.js';
+
+function createConfigCommandRepository(prisma) {
+  async function update({
+    id,
+    // ------------------------------------
+    // --- custom fields
+    // ------------------------------------
+    // multi images
+    files1,
+    files2,
+    // single images
+    file1,
+    file2,
+    file3,
+    file4,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations
+  }) {
+    const updated = await prisma.config.update({
+      where: { id },
+      data: {
+        // ------------------------------------------------------------------------
+        // --- custom fields
+        // ------------------------------------------------------------------------
+        // multi images
+        files1: updateMany(files1),
+        files2: updateMany(files2),
+        // single images
+        file1: updateOne(file1),
+        file2: updateOne(file2),
+        file3: updateOne(file3),
+        file4: updateOne(file4),
+        translations: {
+          upsert: translations.map((t) => ({
+            where: { configId_locale: { configId: id, locale: t.locale } },
+            update: t,
+            create: t
+          }))
+        }
+      }
+    });
+    return updated;
+  }
+  return {
+    update
+  };
+}
+
+export { createConfigCommandRepository };

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

@@ -0,0 +1,17 @@
+const CONFIG_FULL_INCLUDE = {
+  // ---------------------------
+  // --- 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 { CONFIG_FULL_INCLUDE };

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

@@ -0,0 +1,23 @@
+import { CONFIG_ORDER_BY } from '../../constants.js';
+import { CONFIG_FULL_INCLUDE } from '../include.js';
+
+function createConfigQueryRepository(prisma) {
+  async function find({ slug }) {
+    return prisma.config.findUnique({
+      where: { slug },
+      include: CONFIG_FULL_INCLUDE
+    });
+  }
+  async function findMany() {
+    return prisma.config.findMany({
+      include: CONFIG_FULL_INCLUDE,
+      orderBy: CONFIG_ORDER_BY
+    });
+  }
+  return {
+    find,
+    findMany
+  };
+}
+
+export { createConfigQueryRepository };