@yimingliao/cms 0.0.8 → 0.0.10

package/dist/index.js

@@ -1,1447 +1 @@
-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/server/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/server/infrastructure/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/server/infrastructure/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/server/infrastructure/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/resources/admin/props.ts
-var ADMIN_ROLES = {
-  SUPER_ADMIN: "SUPER_ADMIN",
-  ADMIN: "ADMIN",
-  EDITOR: "EDITOR"
-};
-
-// src/domain/resources/file/props.ts
-var FILE_TYPES = {
-  IMAGE: "IMAGE",
-  AUDIO: "AUDIO",
-  VIDEO: "VIDEO",
-  DOCUMENT: "DOCUMENT",
-  ARCHIVE: "ARCHIVE",
-  OTHER: "OTHER"
-};
-
-// src/domain/resources/post/props.ts
-var POST_TYPES = {
-  TOPIC: "TOPIC",
-  CATEGORY: "CATEGORY",
-  POST: "POST",
-  TAG: "TAG",
-  PAGE: "PAGE"
-};
-
-// src/domain/resources/constants.ts
-var ROOT_FOLDER_ID = "01ARZ3NDEKTSV4RRFFQ69G5FAV";
-var ROOT_FOLDER_NAME = "ROOT";
-var ROOT_FOLDER = {
-  id: ROOT_FOLDER_ID,
-  // core
-  name: ROOT_FOLDER_NAME,
-  key: "",
-  // states
-  isLocked: true,
-  // ---------------------------
-  // relations: Folder
-  // ---------------------------
-  parentFolder: null,
-  parentFolderId: null,
-  subFolders: [],
-  // ---------------------------
-  // relations: Folder
-  // ---------------------------
-  files: [],
-  // ---------------------------
-  // timestamps
-  // ---------------------------
-  createdAt: "",
-  updatedAt: ""
-};
-var SIMPLE_UPLOAD_FOLDER_NAME = "simple-upload";
-var SIMPLE_UPLOAD_FOLDER_KEY = `${SIMPLE_UPLOAD_FOLDER_NAME}`;
-
-// src/server/infrastructure/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/server/infrastructure/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/server/infrastructure/database/utils/create-pagination.ts
-function createPagination(page, pageSize) {
-  if (!page || !pageSize) return {};
-  return {
-    skip: (page - 1) * pageSize,
-    take: pageSize
-  };
-}
-
-// src/server/infrastructure/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/server/infrastructure/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/server/infrastructure/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/server/infrastructure/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
-};
-var mimeToExtension = (mimeType) => {
-  if (!mimeType) return "unknown";
-  return (extension(mimeType) || "unknown").toLowerCase();
-};
-var ARCHIVE_MIME = /* @__PURE__ */ new Set([
-  "application/zip",
-  "application/x-rar-compressed",
-  "application/x-7z-compressed",
-  "application/gzip",
-  "application/x-tar"
-]);
-var classifyFileType = (mimeType, extension2) => {
-  if (!mimeType && extension2) {
-    mimeType = lookup(extension2) || void 0;
-  }
-  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 (ARCHIVE_MIME.has(mimeType)) return FILE_TYPES.ARCHIVE;
-  if (mimeType.startsWith("text/") || mimeType === "application/pdf" || mimeType === "application/json" || mimeType === "application/xml") {
-    return FILE_TYPES.DOCUMENT;
-  }
-  if (mimeType.startsWith("application/")) return FILE_TYPES.DOCUMENT;
-  return FILE_TYPES.OTHER;
-};
-
-// src/shared/blob-file/get-media-info/get-audio-info.ts
-function getAudioInfo(file) {
-  return new Promise((resolve, reject) => {
-    const audio = document.createElement("audio");
-    const objectUrl = URL.createObjectURL(file);
-    audio.preload = "metadata";
-    const cleanup = () => {
-      audio.removeEventListener("loadedmetadata", onLoadedMetadata);
-      audio.removeEventListener("error", onError);
-      URL.revokeObjectURL(objectUrl);
-    };
-    const onLoadedMetadata = () => {
-      const duration = audio.duration;
-      cleanup();
-      resolve({ duration });
-    };
-    const onError = () => {
-      cleanup();
-      reject(new Error("Failed to load audio metadata."));
-    };
-    audio.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
-    audio.addEventListener("error", onError, { once: true });
-    audio.src = objectUrl;
-  });
-}
-
-// src/shared/blob-file/get-media-info/get-image-info.ts
-function getImageInfo(file) {
-  return new Promise((resolve, reject) => {
-    const img = new Image();
-    const objectUrl = URL.createObjectURL(file);
-    const cleanup = () => {
-      img.removeEventListener("load", onLoad);
-      img.removeEventListener("error", onError);
-      URL.revokeObjectURL(objectUrl);
-    };
-    const onLoad = () => {
-      const width = img.naturalWidth;
-      const height = img.naturalHeight;
-      cleanup();
-      resolve({ width, height });
-    };
-    const onError = () => {
-      cleanup();
-      reject(new Error("Failed to load image for size detection."));
-    };
-    img.addEventListener("load", onLoad, { once: true });
-    img.addEventListener("error", onError, { once: true });
-    img.src = objectUrl;
-  });
-}
-
-// src/shared/blob-file/get-media-info/get-video-info.ts
-function getVideoInfo(file) {
-  return new Promise((resolve, reject) => {
-    const video = document.createElement("video");
-    const objectUrl = URL.createObjectURL(file);
-    video.preload = "metadata";
-    const cleanup = () => {
-      video.removeEventListener("loadedmetadata", onLoadedMetadata);
-      video.removeEventListener("error", onError);
-      video.src = "";
-      URL.revokeObjectURL(objectUrl);
-    };
-    const onLoadedMetadata = () => {
-      const info = {
-        width: video.videoWidth,
-        height: video.videoHeight,
-        duration: video.duration
-      };
-      cleanup();
-      resolve(info);
-    };
-    const onError = () => {
-      cleanup();
-      reject(new Error("Failed to load video metadata."));
-    };
-    video.addEventListener("loadedmetadata", onLoadedMetadata, { once: true });
-    video.addEventListener("error", onError, { once: true });
-    video.src = objectUrl;
-  });
-}
-
-// src/shared/blob-file/get-media-info/get-media-info.ts
-var IMAGE_EXT = /\.(jpe?g|png|gif|webp|bmp|avif)$/i;
-var VIDEO_EXT = /\.(mp4|webm|mov|mkv)$/i;
-var AUDIO_EXT = /\.(mp3|wav|ogg|m4a)$/i;
-var getMediaInfo = async (file) => {
-  const fallback = { width: null, height: null, duration: null };
-  const mime = file.type || "";
-  const name = file instanceof File ? file.name.toLowerCase() : "";
-  try {
-    if (mime.startsWith("image/") || IMAGE_EXT.test(name)) {
-      const { width, height } = await getImageInfo(file);
-      return { width, height, duration: null };
-    }
-    if (mime.startsWith("video/") || VIDEO_EXT.test(name)) {
-      const { width, height, duration } = await getVideoInfo(file);
-      return { width, height, duration };
-    }
-    if (mime.startsWith("audio/") || AUDIO_EXT.test(name)) {
-      const { duration } = await getAudioInfo(file);
-      return { width: null, height: null, duration };
-    }
-    return fallback;
-  } catch {
-    return fallback;
-  }
-};
-
-// src/shared/blob-file/format-file-size.ts
-var formatFileSize = (size, decimals = 2) => {
-  const units = ["B", "KB", "MB", "GB", "TB"];
-  let value = size;
-  let unitIndex = 0;
-  while (value >= 1024 && unitIndex < units.length - 1) {
-    value /= 1024;
-    unitIndex++;
-  }
-  const display = unitIndex === 0 ? value.toString() : value.toFixed(decimals);
-  return `${display} ${units[unitIndex]}`;
-};
-
-// src/server/infrastructure/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 = mimeToExtension(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: classifyFileType(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 = mimeToExtension(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 ? classifyFileType(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/server/infrastructure/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/server/infrastructure/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/server/infrastructure/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/server/infrastructure/database/folder/include.ts
-var FOLDER_FULL_INCLUDE = {
-  // ---------------------------
-  // relations: Folder
-  // ---------------------------
-  parentFolder: { include: { subFolders: true, files: true } },
-  subFolders: true,
-  // ---------------------------
-  // relations: File
-  // ---------------------------
-  files: true
-};
-
-// src/server/infrastructure/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/server/infrastructure/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/server/infrastructure/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
-  };
-}
-
-// src/server/infrastructure/database/seo-metadata/command/create-seo-metadata-command-repository.ts
-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,
-            create: t
-          }))
-        }
-      }
-    });
-  }
-  return {
-    upsert
-  };
-}
-
-export { ADMIN_ORDER_BY, ADMIN_ROLES, FILE_TYPES, ORDER_BY, POST_ORDER_BY, POST_TYPES, ROOT_FOLDER, ROOT_FOLDER_ID, ROOT_FOLDER_NAME, SIMPLE_UPLOAD_FOLDER_KEY, SIMPLE_UPLOAD_FOLDER_NAME, classifyFileType, createAdminCommandRepository, createAdminQueryRepository, createAdminRefreshTokenCommandRepository, createAdminRefreshTokenQueryRepository, createArgon2Service, createCookieService, createCryptoService, createFileCommandRepository, createFileQueryRepository, createFolderCommandRepository, createFolderQueryRepository, createJwtService, createPostCommandRepository, createPostQueryRepository, createSeoMetadataCommandRepository, formatFileSize, getMediaInfo, mimeToExtension };
+export { ADMIN_ROLES, FILE_TYPES, POST_TYPES, ROOT_FOLDER, ROOT_FOLDER_ID, ROOT_FOLDER_NAME, SIMPLE_UPLOAD_FOLDER_KEY, SIMPLE_UPLOAD_FOLDER_NAME, classifyFileType, formatFileSize, getMediaInfo, mimeToExtension } from './chunk-KEQXXUK2.js';