@yimingliao/cms 0.0.1

package/dist/index.js

@@ -0,0 +1,1264 @@
+import jwt from 'jsonwebtoken';
+import argon2, { argon2id } from 'argon2';
+import crypto, { timingSafeEqual } from 'crypto';
+import 'next/headers';
+import { extension, lookup } from 'mime-types';
+import { ulid } from 'ulid';
+
+// src/infrastructure/jwt/jwt.service.ts
+function createJwtService(config) {
+  const { defaultSecret, ...options } = config;
+  function sign({
+    payload = {},
+    secret = defaultSecret,
+    expiresIn = 60 * 60
+  }) {
+    return jwt.sign(payload, secret, {
+      algorithm: "HS256",
+      expiresIn,
+      ...options
+    });
+  }
+  function verify({
+    token,
+    secret = defaultSecret
+  }) {
+    const payload = jwt.verify(token, secret, {
+      algorithms: ["HS256"],
+      ...options
+    });
+    if (typeof payload === "string") {
+      throw new TypeError("Invalid JWT payload");
+    }
+    return payload;
+  }
+  return {
+    sign,
+    verify
+  };
+}
+var OPTIONS = {
+  type: argon2id,
+  memoryCost: 19456,
+  // ~19MB
+  timeCost: 2,
+  parallelism: 1
+};
+function createArgon2Service() {
+  async function hash(password) {
+    return await argon2.hash(password, OPTIONS);
+  }
+  async function verify(hash2, plain) {
+    return await argon2.verify(hash2, plain);
+  }
+  return {
+    hash,
+    verify
+  };
+}
+function createCryptoService(config) {
+  const { defaultSecret } = config;
+  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
+  };
+}
+var DEFAULTS = {
+  httpOnly: true,
+  secure: process.env["NODE_ENV"] === "production",
+  sameSite: "strict",
+  path: "/"
+};
+function createCookieService(nextCookies, cryptoService) {
+  async function set({
+    name,
+    value,
+    expireSeconds
+  }) {
+    const cookieStore = await nextCookies();
+    cookieStore.set(name, value, { ...DEFAULTS, 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
+  };
+}
+
+// src/database/utils/connect.ts
+var 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) };
+}
+
+// src/database/admin/command/create-admin-command-repository.ts
+function createAdminCommandRepository(prisma) {
+  async function create({
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // File
+    avatarImage,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations,
+    // rest
+    ...params
+  }) {
+    const created = await prisma.admin.create({
+      data: {
+        ...params,
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // File
+        avatarImage: connectOne(avatarImage),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: { create: translations }
+      }
+    });
+    return created;
+  }
+  async function update({
+    id,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // File
+    avatarImage,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations,
+    // rest
+    ...params
+  }) {
+    const updated = await prisma.admin.update({
+      where: { id },
+      data: {
+        ...params,
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // File
+        avatarImage: updateOne(avatarImage),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: {
+          upsert: translations.map((t) => ({
+            where: { adminId_locale: { adminId: id, locale: t.locale } },
+            update: t,
+            create: t
+          }))
+        }
+      }
+    });
+    return updated;
+  }
+  async function _delete({ id }) {
+    const deleted = await prisma.admin.delete({
+      where: { id }
+    });
+    return deleted;
+  }
+  return {
+    create,
+    update,
+    delete: _delete
+  };
+}
+
+// src/database/constants.ts
+var ORDER_BY = [
+  { updatedAt: "desc" },
+  { createdAt: "desc" },
+  { id: "asc" }
+];
+var ADMIN_ORDER_BY = [
+  { role: "asc" },
+  ...ORDER_BY
+];
+var POST_ORDER_BY = [
+  { index: "asc" },
+  ...ORDER_BY
+];
+
+// src/domain/admin/props.ts
+var ADMIN_ROLES = {
+  SUPER_ADMIN: "SUPER_ADMIN"};
+
+// src/database/admin/include.ts
+var ADMIN_FULL_INCLUDE = {
+  // ---------------------------
+  // relations: AdminRefreshToken
+  // ---------------------------
+  adminRefreshTokens: true,
+  // ---------------------------
+  // relations: File
+  // ---------------------------
+  avatarImage: { include: { translations: true } },
+  // ---------------------------
+  // relations: Post
+  // ---------------------------
+  posts: true,
+  // ---------------------------
+  // translation
+  // ---------------------------
+  translations: true
+};
+
+// src/database/utils/create-search.ts
+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 } : {};
+}
+
+// src/database/utils/create-pagination.ts
+function createPagination(page, pageSize) {
+  if (!page || !pageSize) return {};
+  return {
+    skip: (page - 1) * pageSize,
+    take: pageSize
+  };
+}
+
+// src/database/admin/query/create-admin-query-repository.ts
+var 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?.length ? { 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 await 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
+  };
+}
+
+// src/database/admin-refresh-token/command/create-admin-refresh-token-command-repository.ts
+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
+  };
+}
+
+// src/database/admin-refresh-token/query/create-admin-refresh-token-query-repository.ts
+function createAdminRefreshTokenQueryRepository(prisma) {
+  async function findManyByAdminId({
+    adminId
+  }) {
+    return await prisma.adminRefreshToken.findMany({
+      where: { adminId },
+      orderBy: [{ createdAt: "desc" }, { id: "asc" }]
+    });
+  }
+  async function findByToken({
+    tokenHash
+  }) {
+    return await prisma.adminRefreshToken.findUnique({
+      where: { tokenHash }
+    });
+  }
+  return {
+    findManyByAdminId,
+    findByToken
+  };
+}
+
+// src/database/file/include.ts
+var FILE_FULL_INCLUDE = {
+  // ---------------------------
+  // relations: Folder
+  // ---------------------------
+  folder: true,
+  // ---------------------------
+  // relations: Admin
+  // ---------------------------
+  adminAsAvatarImage: true,
+  // ---------------------------
+  // relations: Post
+  // ---------------------------
+  postsAsCoverImage: true,
+  postsAsContentImage: true,
+  // ---------------------------
+  // --- custom fields
+  // ---------------------------
+  postsAsImages1: true,
+  postsAsImages2: true,
+  postsAsImage1: true,
+  postsAsImage2: true,
+  postsAsImage3: true,
+  postsAsImage4: true,
+  // ---------------------------
+  // translation
+  // ---------------------------
+  translations: true
+};
+
+// src/domain/file/props.ts
+var FILE_TYPES = {
+  IMAGE: "IMAGE",
+  AUDIO: "AUDIO",
+  VIDEO: "VIDEO",
+  DOCUMENT: "DOCUMENT",
+  ARCHIVE: "ARCHIVE",
+  OTHER: "OTHER"
+};
+
+// src/domain/file/utils/get-file-type.ts
+var getFileType = (mimeType, extension2) => {
+  if (!mimeType && extension2) {
+    mimeType = lookup(extension2) || "unknown";
+  }
+  if (!mimeType) {
+    return FILE_TYPES.OTHER;
+  }
+  if (mimeType.startsWith("image/")) {
+    return FILE_TYPES.IMAGE;
+  }
+  if (mimeType.startsWith("video/")) {
+    return FILE_TYPES.VIDEO;
+  }
+  if (mimeType.startsWith("audio/")) {
+    return FILE_TYPES.AUDIO;
+  }
+  if (mimeType.startsWith("text/") || mimeType.startsWith("application/")) {
+    return FILE_TYPES.DOCUMENT;
+  }
+  if (mimeType === "application/zip" || mimeType === "application/x-rar-compressed") {
+    return FILE_TYPES.ARCHIVE;
+  }
+  if (mimeType.startsWith("application/x-") || mimeType === "application/octet-stream") {
+    return FILE_TYPES.OTHER;
+  }
+  return FILE_TYPES.OTHER;
+};
+var getExtension = (fileType) => {
+  if (typeof fileType !== "string") {
+    return "unknown";
+  }
+  return (extension(fileType) || "unknown").toLowerCase();
+};
+
+// src/database/file/command/create-file-command-repository.ts
+function createFileCommandRepository(prisma) {
+  async function create({
+    // meta
+    fileMeta,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // Folder
+    folder,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations,
+    // rest
+    ...params
+  }) {
+    const extension2 = getExtension(fileMeta.type);
+    const created = await prisma.file.create({
+      data: {
+        ...params,
+        // derived
+        originalName: fileMeta.name || "unknown",
+        size: fileMeta.size ?? 0,
+        extension: extension2,
+        mimeType: fileMeta.type || "unknown",
+        type: getFileType(fileMeta.type, extension2),
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // Folder
+        folder: connectOne(folder),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: {
+          create: translations.map((t) => ({
+            ...t,
+            name: t.name ?? fileMeta.name ?? "unknown"
+          }))
+        }
+      },
+      include: FILE_FULL_INCLUDE
+    });
+    return created;
+  }
+  async function update({
+    file,
+    // Original file (File)
+    id,
+    // meta
+    fileMeta,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // Folder
+    folder,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations,
+    // rest
+    ...params
+  }) {
+    const extension2 = getExtension(fileMeta.type);
+    const updated = await prisma.file.update({
+      where: { id: file.id },
+      data: {
+        ...params,
+        // derived
+        size: fileMeta.size ?? file.size,
+        extension: fileMeta ? extension2 : file.extension,
+        mimeType: fileMeta.type || file.mimeType,
+        type: fileMeta.type ? getFileType(fileMeta.type, extension2) : file.type,
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // Folder
+        folder: updateOne(folder),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: {
+          upsert: translations.map((t) => ({
+            where: { fileId_locale: { fileId: id, locale: t.locale } },
+            update: t,
+            create: t
+          }))
+        }
+      }
+    });
+    return updated;
+  }
+  async function softDelete({ id }) {
+    const updated = await prisma.file.update({
+      where: { id, isLocked: false },
+      data: { deletedAt: /* @__PURE__ */ new Date() }
+    });
+    return updated;
+  }
+  async function softDeleteMany({ ids: ids2 }) {
+    const { count } = await prisma.file.updateMany({
+      where: { id: { in: ids2 }, isLocked: false },
+      data: { deletedAt: /* @__PURE__ */ new Date() }
+    });
+    return count;
+  }
+  async function restoreMany({ ids: ids2 }) {
+    const { count } = await prisma.file.updateMany({
+      where: { id: { in: ids2 } },
+      data: { deletedAt: null }
+    });
+    return count;
+  }
+  async function _delete({ id }) {
+    const deleted = await prisma.file.delete({
+      where: { id }
+    });
+    return deleted;
+  }
+  return {
+    create,
+    update,
+    softDelete,
+    softDeleteMany,
+    restoreMany,
+    delete: _delete
+  };
+}
+
+// src/database/utils/build-file-usage.ts
+function buildFileUsage(isLocked) {
+  const relations = [
+    "adminAsAvatarImage",
+    "postsAsCoverImage",
+    "postsAsContentImage",
+    "postsAsImages1",
+    "postsAsImages2",
+    "postsAsImage1",
+    "postsAsImage2",
+    "postsAsImage3",
+    "postsAsImage4"
+  ];
+  if (isLocked === void 0 || isLocked === null) return {};
+  const condition = relations.map((r) => ({
+    [r]: { [isLocked ? "some" : "none"]: {} }
+  }));
+  return isLocked ? { OR: condition } : { AND: condition };
+}
+
+// src/domain/folder/constants/root-folder.ts
+var ROOT_FOLDER_ID = "01ARZ3NDEKTSV4RRFFQ69G5FAV";
+
+// src/database/file/query/create-file-query-repository.ts
+function createFileQueryRepository(prisma) {
+  async function findListCards({
+    locale,
+    // pagination
+    page,
+    pageSize,
+    // search
+    searchString,
+    type,
+    folderId,
+    isLocked,
+    isDeleted = false,
+    fileIds
+  }) {
+    const where = {
+      // search
+      ...createSearch({
+        ...searchString !== void 0 ? { searchString } : {},
+        locale,
+        translationFields: ["name"]
+      }),
+      // type
+      ...type ? { type } : {},
+      // state: isLocked
+      ...buildFileUsage(isLocked),
+      // state: deleteAt
+      deletedAt: isDeleted ? { not: null } : null,
+      // Find deleted files in trash page
+      // relations: Folder
+      ...folderId ? { folderId: folderId === ROOT_FOLDER_ID ? null : folderId } : {},
+      // Specified ids
+      ...fileIds ? { id: { in: fileIds } } : {}
+    };
+    const [items, total] = await prisma.$transaction([
+      prisma.file.findMany({
+        where,
+        orderBy: [...ORDER_BY],
+        include: FILE_FULL_INCLUDE,
+        ...createPagination(page, pageSize)
+      }),
+      prisma.file.count({ where })
+    ]);
+    return { items, total };
+  }
+  async function findManyByIds({
+    ids: ids2
+  }) {
+    return await prisma.file.findMany({
+      where: { id: { in: ids2 } },
+      include: FILE_FULL_INCLUDE
+    });
+  }
+  async function findFull({ id }) {
+    return await prisma.file.findUnique({
+      where: { id },
+      include: FILE_FULL_INCLUDE
+    });
+  }
+  return {
+    findListCards,
+    findManyByIds,
+    findFull
+  };
+}
+
+// src/database/folder/command/create-folder-command-repository.ts
+function createFolderCommandRepository(prisma) {
+  async function create({
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // Folder
+    parentFolder,
+    // rest
+    ...params
+  }) {
+    const created = await prisma.folder.create({
+      data: {
+        ...params,
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // Folder
+        parentFolder: connectOne(parentFolder)
+      }
+    });
+    return created;
+  }
+  async function update({
+    id,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // Folder
+    parentFolder,
+    // rest
+    ...params
+  }) {
+    const updated = await prisma.folder.update({
+      where: { id },
+      data: {
+        ...params,
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // Folder
+        parentFolder: updateOne(parentFolder)
+      }
+    });
+    return updated;
+  }
+  async function _delete({ id }) {
+    const deleted = await prisma.folder.delete({
+      where: { id }
+    });
+    return deleted;
+  }
+  return {
+    create,
+    update,
+    delete: _delete
+  };
+}
+
+// src/database/folder/include.ts
+var FOLDER_FULL_INCLUDE = {
+  // ---------------------------
+  // relations: Folder
+  // ---------------------------
+  parentFolder: { include: { subFolders: true, files: true } },
+  subFolders: true,
+  // ---------------------------
+  // relations: File
+  // ---------------------------
+  files: true
+};
+
+// src/database/folder/query/create-folder-query-repository.ts
+function buildWhere2(params) {
+  if (params.id) return { id: params.id };
+  if (params.key) return { key: params.key };
+  return;
+}
+function createFolderQueryRepository(prisma) {
+  async function findListCards({
+    // search
+    searchString,
+    parentFolderId,
+    folderIds,
+    // pagination
+    page,
+    pageSize
+  }) {
+    const where = {
+      // search
+      ...searchString ? { name: { contains: searchString, mode: "insensitive" } } : {},
+      // relations: Folder
+      ...parentFolderId ? parentFolderId === ROOT_FOLDER_ID ? { parentFolderId: null } : { parentFolderId } : {},
+      // Specified ids
+      ...folderIds ? { id: { in: folderIds } } : {}
+    };
+    const [items, total] = await prisma.$transaction([
+      prisma.folder.findMany({
+        where,
+        orderBy: [...ORDER_BY],
+        include: FOLDER_FULL_INCLUDE,
+        ...createPagination(page, pageSize)
+      }),
+      prisma.folder.count({ where })
+    ]);
+    return { items, total };
+  }
+  async function findFull(params) {
+    const where = buildWhere2(params);
+    if (!where) return null;
+    return await prisma.folder.findUnique({
+      where,
+      include: FOLDER_FULL_INCLUDE
+    });
+  }
+  return {
+    findListCards,
+    findFull
+  };
+}
+function createPostCommandRepository(prisma) {
+  async function create({
+    slug,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // Admin
+    author,
+    // Post
+    topicId,
+    parents,
+    tags,
+    relatedPosts,
+    // File
+    coverImage,
+    contentImageIds,
+    // ------------------------------------
+    // --- custom fields
+    // ------------------------------------
+    // multi images
+    images1,
+    images2,
+    // single images
+    image1,
+    image2,
+    image3,
+    image4,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations,
+    // rest
+    ...params
+  }) {
+    const id = ulid();
+    const created = await prisma.post.create({
+      data: {
+        ...params,
+        id,
+        // ------------------------------------------------------------------------
+        // states
+        // ------------------------------------------------------------------------
+        slug: slug?.trim() || id,
+        // Use id when slug is null or empty string
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // Admin
+        author: connectOne(author),
+        // Post
+        topic: connectOne(topicId ? { id: topicId } : null),
+        parents: connectMany(parents),
+        tags: connectMany(tags),
+        relatedPosts: connectMany(relatedPosts),
+        // File
+        coverImage: connectOne(coverImage),
+        contentImages: connectMany(contentImageIds.map((id2) => ({ id: id2 }))),
+        // ------------------------------------------------------------------------
+        // --- custom fields
+        // ------------------------------------------------------------------------
+        // multi images
+        images1: connectMany(images1),
+        images2: connectMany(images2),
+        // single images
+        image1: connectOne(image1),
+        image2: connectOne(image2),
+        image3: connectOne(image3),
+        image4: connectOne(image4),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: {
+          create: translations.map((t) => ({
+            ...t,
+            externalLinks: t.externalLinks,
+            faq: t.faq,
+            toc: t.toc
+          }))
+        }
+      }
+    });
+    return created;
+  }
+  async function update({
+    id,
+    slug,
+    // ------------------------------------
+    // relations
+    // ------------------------------------
+    // Admin
+    author,
+    // Post
+    topicId,
+    parents,
+    tags,
+    relatedPosts,
+    // File
+    coverImage,
+    contentImageIds,
+    // ------------------------------------
+    // --- custom fields
+    // ------------------------------------
+    // multi images
+    images1,
+    images2,
+    // single images
+    image1,
+    image2,
+    image3,
+    image4,
+    // ------------------------------------
+    // translation
+    // ------------------------------------
+    translations,
+    // rest
+    ...params
+  }) {
+    const updated = await prisma.post.update({
+      where: { id },
+      data: {
+        ...params,
+        // ------------------------------------------------------------------------
+        // states
+        // ------------------------------------------------------------------------
+        slug: slug?.trim() || id,
+        // Use id when slug is null or empty string
+        // ------------------------------------------------------------------------
+        // relations
+        // ------------------------------------------------------------------------
+        // Admin
+        author: updateOne(author),
+        // Post
+        topic: updateOne(topicId ? { id: topicId } : null),
+        parents: updateMany(parents),
+        tags: updateMany(tags),
+        relatedPosts: updateMany(relatedPosts),
+        // File
+        coverImage: updateOne(coverImage),
+        contentImages: updateMany(contentImageIds.map((id2) => ({ id: id2 }))),
+        // ------------------------------------------------------------------------
+        // --- custom fields
+        // ------------------------------------------------------------------------
+        // multi images
+        images1: updateMany(images1),
+        images2: updateMany(images2),
+        // single images
+        image1: updateOne(image1),
+        image2: updateOne(image2),
+        image3: updateOne(image3),
+        image4: updateOne(image4),
+        // ------------------------------------------------------------------------
+        // translation
+        // ------------------------------------------------------------------------
+        translations: {
+          upsert: translations.map((t) => ({
+            where: { postId_locale: { postId: id, locale: t.locale } },
+            update: {
+              ...t,
+              externalLinks: t.externalLinks,
+              faq: t.faq,
+              toc: t.toc
+            },
+            create: {
+              ...t,
+              externalLinks: t.externalLinks,
+              faq: t.faq,
+              toc: t.toc
+            }
+          }))
+        }
+      }
+    });
+    return updated;
+  }
+  async function _delete({ id }) {
+    const deleted = await prisma.post.delete({
+      where: { id }
+    });
+    return deleted;
+  }
+  return {
+    create,
+    update,
+    delete: _delete
+  };
+}
+
+// src/database/post/include.ts
+var 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
+  // ---------------------------
+  // relations: File
+  // ---------------------------
+  coverImage: true,
+  // ---------------------------
+  // translation
+  // ---------------------------
+  translations: true
+};
+var POST_FULL_INCLUDE = {
+  // ---------------------------
+  // relations: Admin
+  // ---------------------------
+  author: { include: { translations: 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 } },
+  // ---------------------------
+  // --- custom fields
+  // ---------------------------
+  images1: { include: { translations: true } },
+  images2: { include: { translations: true } },
+  image1: { include: { translations: true } },
+  image2: { include: { translations: true } },
+  image3: { include: { translations: true } },
+  image4: { include: { translations: true } },
+  // ---------------------------
+  // translation
+  // ---------------------------
+  translations: true
+};
+
+// src/database/post/query/create-post-query-repository.ts
+function buildWhere3(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,
+    topicId,
+    postIds,
+    isActive,
+    isIndexActive,
+    isSlugActive,
+    isFeatured,
+    isShownOnHome,
+    // pagination
+    page,
+    pageSize
+  }) {
+    const where = {
+      // search
+      ...createSearch({
+        ...searchString ? { searchString } : {},
+        locale,
+        rootFields: ["slug"],
+        translationFields: ["title", "summary", "description", "content"]
+      }),
+      // type
+      ...type ? { type } : {},
+      // states
+      ...isActive ? { isActive: true } : {},
+      ...isIndexActive ? { isIndexActive: true } : {},
+      ...isSlugActive ? { isSlugActive: true } : {},
+      ...isFeatured ? { isFeatured: true } : {},
+      ...isShownOnHome ? { isShownOnHome: true } : {},
+      // relations: Post
+      ...topicId ? { topicId } : {},
+      // Specified ids
+      ...postIds ? { id: { in: postIds } } : {}
+    };
+    const [items, total] = await prisma.$transaction([
+      prisma.post.findMany({
+        where,
+        orderBy: POST_ORDER_BY,
+        include: POST_LIST_CARD_INCLUDE,
+        ...createPagination(page, pageSize)
+      }),
+      prisma.post.count({ where })
+    ]);
+    return { items, total };
+  }
+  async function find(params) {
+    const where = buildWhere3(params);
+    if (!where) return null;
+    return prisma.post.findFirst({
+      where,
+      include: { translations: true }
+    });
+  }
+  async function findMany({
+    type,
+    topicId
+  }) {
+    return await prisma.post.findMany({
+      where: { type, ...topicId ? { topicId } : {} },
+      orderBy: POST_ORDER_BY,
+      include: { translations: true }
+    });
+  }
+  async function findFull(params) {
+    const where = buildWhere3(params);
+    if (!where) return null;
+    return prisma.post.findFirst({
+      where,
+      include: POST_FULL_INCLUDE
+    });
+  }
+  async function findWithSeoMetadata(params) {
+    const where = buildWhere3(params);
+    if (!where) return null;
+    return await prisma.post.findFirst({
+      where,
+      include: { translations: true, seoMetadatas: true }
+    });
+  }
+  return {
+    findListCards,
+    findMany,
+    find,
+    findFull,
+    findWithSeoMetadata
+  };
+}
+
+export { createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createCookieService, createCryptoService, createFileCommandRepository, createFileQueryRepository, createFolderCommandRepository, createFolderQueryRepository, createJwtService, createPostCommandRepository, createPostQueryRepository };