@yimingliao/cms 0.0.126 → 0.0.127

package/dist/src/server/interfaces/middlewares/auth/create-auth-middleware.js

@@ -0,0 +1,31 @@
+import { ServerError } from '../../../server-error.js';
+
+function createAuthMiddleware({
+  adminRefreshTokenCommandRepository,
+  authUseCases,
+  verifyAccessToken,
+  verifyRefreshToken,
+  headers
+}) {
+  const authMiddleware = {
+    async authenticate() {
+      const verifiedAccessToken = await verifyAccessToken();
+      if (verifiedAccessToken) return verifiedAccessToken.admin;
+      const verifiedRefreshToken = await verifyRefreshToken();
+      if (!verifiedRefreshToken) throw ServerError.unauthorized();
+      const { adminRefreshToken, admin } = verifiedRefreshToken;
+      await adminRefreshTokenCommandRepository.delete({
+        id: adminRefreshToken.id
+      });
+      await authUseCases.refreshTokens({
+        admin,
+        deviceInfo: adminRefreshToken.deviceInfo,
+        ip: (await headers()).get("x-forwarded-for") || "unknown"
+      });
+      return admin;
+    }
+  };
+  return authMiddleware;
+}
+
+export { createAuthMiddleware };

package/dist/src/server/interfaces/middlewares/auth/create-verify-access-token.js

@@ -0,0 +1,27 @@
+function createVerifyAccessToken({
+  adminQueryRepository,
+  jwtService,
+  cryptoService,
+  cookieService,
+  config
+}) {
+  return async function verifyAccessToken() {
+    try {
+      const token = await cookieService.getSignedCookie({
+        name: config.accessTokenName
+      });
+      const payload = jwtService.verify({
+        token,
+        secret: cryptoService.hash(config.accessTokenSecret)
+      });
+      const admin = await adminQueryRepository.findFull({
+        id: payload["id"]
+      });
+      return admin ? { admin } : null;
+    } catch {
+      return null;
+    }
+  };
+}
+
+export { createVerifyAccessToken };

package/dist/src/server/interfaces/middlewares/auth/create-verify-refresh-token.js

@@ -0,0 +1,27 @@
+function createVerifyRefreshToken({
+  adminQueryRepository,
+  adminRefreshTokenQueryRepository,
+  cryptoService,
+  cookieService,
+  config
+}) {
+  return async function verifyRefreshToken() {
+    try {
+      const token = await cookieService.getSignedCookie({
+        name: config.refreshTokenName
+      });
+      const adminRefreshToken = await adminRefreshTokenQueryRepository.findByToken({
+        tokenHash: cryptoService.hash(token)
+      });
+      if (!adminRefreshToken) return null;
+      const admin = await adminQueryRepository.findFull({
+        id: adminRefreshToken.adminId
+      });
+      return admin ? { adminRefreshToken, admin } : null;
+    } catch {
+      return null;
+    }
+  };
+}
+
+export { createVerifyRefreshToken };

package/dist/src/server/server-error.js

@@ -0,0 +1,35 @@
+class ServerError extends Error {
+  i18nKey;
+  statusCode;
+  constructor({
+    message,
+    i18nKey,
+    statusCode
+  }) {
+    super(message);
+    this.name = this.constructor.name;
+    if (i18nKey) this.i18nKey = i18nKey;
+    if (statusCode) this.statusCode = statusCode;
+  }
+  /** 401 Unauthorized */
+  static unauthorized() {
+    return new ServerError({ i18nKey: "error.unauthorized", statusCode: 401 });
+  }
+  /** 403 Forbidden */
+  static forbidden() {
+    return new ServerError({ i18nKey: "error.forbidden", statusCode: 403 });
+  }
+  /** 404 Not found */
+  static notFound() {
+    return new ServerError({ i18nKey: "error.not-found", statusCode: 404 });
+  }
+  /** 500 Internal Server Error */
+  static internalServerError() {
+    return new ServerError({
+      i18nKey: "error.internal-server-error",
+      statusCode: 500
+    });
+  }
+}
+
+export { ServerError };

package/dist/src/shared/blob-file/classify-file-type.js

@@ -0,0 +1,27 @@
+import { lookup } from 'mime-types';
+import { FILE_TYPES } from '../../domain/resources/file/props.js';
+
+const ARCHIVE_MIME = /* @__PURE__ */ new Set([
+  "application/zip",
+  "application/x-rar-compressed",
+  "application/x-7z-compressed",
+  "application/gzip",
+  "application/x-tar"
+]);
+const classifyFileType = (mimeType, extension) => {
+  if (!mimeType && extension) {
+    mimeType = lookup(extension) || 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;
+};
+
+export { classifyFileType };

package/dist/src/shared/blob-file/format-file-size.js

@@ -0,0 +1,13 @@
+const 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]}`;
+};
+
+export { formatFileSize };

package/dist/src/shared/blob-file/get-media-info/get-audio-info.js

@@ -0,0 +1,26 @@
+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;
+  });
+}
+
+export { getAudioInfo };

package/dist/src/shared/blob-file/get-media-info/get-image-info.js

@@ -0,0 +1,26 @@
+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;
+  });
+}
+
+export { getImageInfo };

package/dist/src/shared/blob-file/get-media-info/get-media-info.js

@@ -0,0 +1,31 @@
+import { getAudioInfo } from './get-audio-info.js';
+import { getImageInfo } from './get-image-info.js';
+import { getVideoInfo } from './get-video-info.js';
+
+const IMAGE_EXT = /\.(jpe?g|png|gif|webp|bmp|avif)$/i;
+const VIDEO_EXT = /\.(mp4|webm|mov|mkv)$/i;
+const AUDIO_EXT = /\.(mp3|wav|ogg|m4a)$/i;
+const 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;
+  }
+};
+
+export { getMediaInfo };

package/dist/src/shared/blob-file/get-media-info/get-video-info.js

@@ -0,0 +1,31 @@
+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;
+  });
+}
+
+export { getVideoInfo };

package/dist/src/shared/blob-file/mime-to-extension.js

@@ -0,0 +1,8 @@
+import { extension } from 'mime-types';
+
+const mimeToExtension = (mimeType) => {
+  if (!mimeType) return "unknown";
+  return (extension(mimeType) || "unknown").toLowerCase();
+};
+
+export { mimeToExtension };

package/dist/src/shared/form/normalizers/datetime-to-db.js

@@ -0,0 +1,8 @@
+const datetimeToDb = (date) => {
+  if (date == null) return null;
+  const d = typeof date === "string" ? new Date(date) : date;
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString();
+};
+
+export { datetimeToDb };

package/dist/src/shared/form/normalizers/datetime-to-ui.js

@@ -0,0 +1,13 @@
+const datetimeToUi = (date) => {
+  if (date == null) return null;
+  const d = typeof date === "string" ? new Date(date) : date;
+  if (Number.isNaN(d.getTime())) return null;
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day}T${hours}:${minutes}`;
+};
+
+export { datetimeToUi };

package/dist/src/shared/form/normalizers/json-array-to-db.js

@@ -0,0 +1,17 @@
+const jsonArrayToDb = (data) => {
+  if (typeof data !== "string" || data.trim() === "") {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(data);
+    if (Array.isArray(parsed)) return parsed;
+    if (typeof parsed === "object" && parsed !== null) {
+      return [parsed];
+    }
+    return [];
+  } catch {
+    throw new Error("Invalid JSON");
+  }
+};
+
+export { jsonArrayToDb };

package/dist/src/shared/form/normalizers/json-array-to-ui.js

@@ -0,0 +1,9 @@
+const jsonArrayToUi = (data) => {
+  try {
+    return JSON.stringify(data ?? []);
+  } catch {
+    return "[]";
+  }
+};
+
+export { jsonArrayToUi };

package/dist/src/shared/result/result.js

@@ -0,0 +1,26 @@
+function success({
+  message,
+  data,
+  meta
+}) {
+  return {
+    success: true,
+    ...message !== void 0 ? { message } : {},
+    ...data !== void 0 ? { data } : {},
+    ...meta !== void 0 ? { meta } : {}
+  };
+}
+function error({ message, errors, code }) {
+  return {
+    success: false,
+    ...message !== void 0 ? { message } : {},
+    ...errors !== void 0 ? { errors } : {},
+    ...code !== void 0 ? { code } : {}
+  };
+}
+const result = {
+  success,
+  error
+};
+
+export { result };

package/dist/src/shared/seo-metadata/build-article-metadata.js

@@ -0,0 +1,82 @@
+import { findTranslation } from '../translation/find-translation.js';
+import { buildAlternateMap } from './utils/build-alternate-map.js';
+import { buildOgImages } from './utils/build-og-image.js';
+import { ensureOgType } from './utils/ensure-og-type.js';
+import { ensureTwitterCard } from './utils/ensure-twitter-card.js';
+import { sanitizeStringArray } from './utils/sanitize-string-array.js';
+import { toIsoTime } from './utils/to-iso-time.js';
+
+function createBuildArticleMetadata({
+  defaults,
+  storageUrl
+}) {
+  return function buildArticleMetadata(post, locale) {
+    const seoMetadata = findTranslation(post?.seoMetadatas, locale);
+    const authorT = findTranslation(post?.author?.translations, locale);
+    const coverImageT = findTranslation(post?.coverImage?.translations, locale);
+    return {
+      metadataBase: defaults.metadataBase,
+      // -----------------------------------------------------------------------
+      // Basic
+      // -----------------------------------------------------------------------
+      title: seoMetadata?.title || defaults.title,
+      description: seoMetadata?.description,
+      // identity
+      authors: [
+        {
+          name: seoMetadata?.author || authorT.authorName || defaults.author,
+          url: authorT.url || void 0
+        }
+      ],
+      // url
+      alternates: {
+        canonical: seoMetadata?.canonical,
+        languages: buildAlternateMap(seoMetadata?.alternate)
+      },
+      // robots
+      robots: seoMetadata?.robots || defaults.robots,
+      // -----------------------------------------------------------------------
+      // Open Graph
+      // -----------------------------------------------------------------------
+      openGraph: {
+        title: seoMetadata?.ogTitle || void 0,
+        description: seoMetadata?.ogDescription || void 0,
+        // url
+        url: seoMetadata?.ogUrl || seoMetadata?.canonical || void 0,
+        // identity
+        type: ensureOgType("article", seoMetadata?.ogType),
+        siteName: seoMetadata?.ogSiteName || defaults.ogSiteName,
+        // image
+        images: buildOgImages(
+          seoMetadata?.ogImage || `${storageUrl}/${post?.coverImage?.key}`,
+          seoMetadata?.ogImageAlt || coverImageT.alt,
+          seoMetadata?.ogImageType,
+          seoMetadata?.ogImageWidth,
+          seoMetadata?.ogImageHeight
+        ),
+        // locale
+        locale: seoMetadata?.ogLocale || void 0,
+        alternateLocale: sanitizeStringArray(seoMetadata?.ogLocaleAlternate),
+        // article
+        publishedTime: toIsoTime(seoMetadata?.ogArticlePublishedTime),
+        modifiedTime: toIsoTime(seoMetadata?.ogArticleModifiedTime),
+        authors: [
+          seoMetadata?.ogArticleAuthor || authorT.authorName || defaults.ogSiteName
+        ],
+        section: seoMetadata?.ogArticleSection,
+        tags: sanitizeStringArray(seoMetadata?.ogArticleTag)
+      },
+      // -----------------------------------------------------------------------
+      // Twitter
+      // -----------------------------------------------------------------------
+      twitter: {
+        card: ensureTwitterCard(defaults.twitterCard, seoMetadata?.twitterCard),
+        // identity
+        site: seoMetadata?.twitterSite || void 0,
+        creator: seoMetadata?.twitterCreator || void 0
+      }
+    };
+  };
+}
+
+export { createBuildArticleMetadata };

package/dist/src/shared/seo-metadata/build-website-metadata.js

@@ -0,0 +1,65 @@
+import { findTranslation } from '../translation/find-translation.js';
+import { buildAlternateMap } from './utils/build-alternate-map.js';
+import { buildOgImages } from './utils/build-og-image.js';
+import { ensureOgType } from './utils/ensure-og-type.js';
+import { ensureTwitterCard } from './utils/ensure-twitter-card.js';
+import { sanitizeStringArray } from './utils/sanitize-string-array.js';
+
+function createBuildWebsiteMetadata({
+  defaults
+}) {
+  return function buildWebsiteMetadata(post, locale) {
+    const seoMetadata = findTranslation(post?.seoMetadatas, locale);
+    return {
+      metadataBase: defaults.metadataBase,
+      // -----------------------------------------------------------------------
+      // Basic
+      // -----------------------------------------------------------------------
+      title: seoMetadata?.title || defaults.title,
+      description: seoMetadata?.description,
+      // identity
+      authors: [{ name: seoMetadata?.author || defaults.author }],
+      // url
+      alternates: {
+        canonical: seoMetadata?.canonical,
+        languages: buildAlternateMap(seoMetadata?.alternate)
+      },
+      // robots
+      robots: seoMetadata?.robots || defaults.robots,
+      // -----------------------------------------------------------------------
+      // Open Graph
+      // -----------------------------------------------------------------------
+      openGraph: {
+        title: seoMetadata?.ogTitle || void 0,
+        description: seoMetadata?.ogDescription || void 0,
+        // url
+        url: seoMetadata?.ogUrl || seoMetadata?.canonical || void 0,
+        // identity
+        type: ensureOgType("website", seoMetadata?.ogType),
+        siteName: seoMetadata?.ogSiteName || defaults.ogSiteName,
+        // image
+        images: buildOgImages(
+          seoMetadata?.ogImage,
+          seoMetadata?.ogImageAlt,
+          seoMetadata?.ogImageType,
+          seoMetadata?.ogImageWidth,
+          seoMetadata?.ogImageHeight
+        ),
+        // locale
+        locale: seoMetadata?.ogLocale || void 0,
+        alternateLocale: sanitizeStringArray(seoMetadata?.ogLocaleAlternate)
+      },
+      // -----------------------------------------------------------------------
+      // Twitter
+      // -----------------------------------------------------------------------
+      twitter: {
+        card: ensureTwitterCard(defaults.twitterCard, seoMetadata?.twitterCard),
+        // identity
+        site: seoMetadata?.twitterSite || void 0,
+        creator: seoMetadata?.twitterCreator || void 0
+      }
+    };
+  };
+}
+
+export { createBuildWebsiteMetadata };

package/dist/src/shared/seo-metadata/serialize-json-ld.js

@@ -0,0 +1,6 @@
+const serializeJsonLd = (data) => {
+  if (data == null) return "";
+  return JSON.stringify(data).replaceAll("<", String.raw`\u003c`).replaceAll(">", String.raw`\u003e`).replaceAll("&", String.raw`\u0026`);
+};
+
+export { serializeJsonLd };

package/dist/src/shared/seo-metadata/standards.js

@@ -0,0 +1,22 @@
+const OG_TYPE_ARRAY = [
+  "article",
+  "book",
+  "music.song",
+  "music.album",
+  "music.playlist",
+  "music.radio_station",
+  "profile",
+  "website",
+  "video.tv_show",
+  "video.other",
+  "video.movie",
+  "video.episode"
+];
+const TWITTER_CARD_ARRAY = [
+  "summary",
+  "summary_large_image",
+  "player",
+  "app"
+];
+
+export { OG_TYPE_ARRAY, TWITTER_CARD_ARRAY };

package/dist/src/shared/seo-metadata/utils/build-alternate-map.js

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

package/dist/src/shared/seo-metadata/utils/build-og-image.js

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

package/dist/src/shared/seo-metadata/utils/ensure-og-type.js

@@ -0,0 +1,9 @@
+import { OG_TYPE_ARRAY } from '../standards.js';
+
+const ensureOgType = (fallback, ogType) => {
+  if (typeof ogType !== "string") return fallback;
+  const isValid = OG_TYPE_ARRAY.includes(ogType);
+  return isValid ? ogType : fallback;
+};
+
+export { ensureOgType };

package/dist/src/shared/seo-metadata/utils/ensure-twitter-card.js

@@ -0,0 +1,9 @@
+import { TWITTER_CARD_ARRAY } from '../standards.js';
+
+const ensureTwitterCard = (fallback, twitterCard) => {
+  if (typeof twitterCard !== "string") return fallback;
+  const isValid = TWITTER_CARD_ARRAY.includes(twitterCard);
+  return isValid ? twitterCard : fallback;
+};
+
+export { ensureTwitterCard };

package/dist/src/shared/seo-metadata/utils/sanitize-string-array.js

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

package/dist/src/shared/seo-metadata/utils/to-iso-time.js

@@ -0,0 +1,6 @@
+const toIsoTime = (date) => {
+  if (!date) return void 0;
+  return date.toISOString();
+};
+
+export { toIsoTime };

package/dist/src/shared/translation/create-build-translations.js

@@ -0,0 +1,11 @@
+function createBuildTranslations(localArray) {
+  return function buildTranslations(fields) {
+    const entries = fields.map((f) => [f.key, f.value]);
+    return localArray.map((locale) => ({
+      locale,
+      ...Object.fromEntries(entries)
+    }));
+  };
+}
+
+export { createBuildTranslations };

package/dist/src/shared/translation/find-translation.js

@@ -0,0 +1,13 @@
+function findTranslation(translations, locale, defaultValue) {
+  const fallback = translations?.[0];
+  const found = translations?.find((t) => t.locale === locale) ?? fallback;
+  if (!found) return { locale: locale ?? "" };
+  const result = { ...found };
+  for (const key of Object.keys(result)) {
+    if (key === "locale") continue;
+    if (result[key] == null) result[key] = defaultValue;
+  }
+  return result;
+}
+
+export { findTranslation };

package/dist/src/shared/units.js

@@ -0,0 +1,10 @@
+const SIZE = {
+  BYTE: 1,
+  KB: 1024,
+  MB: 1024 ** 2,
+  GB: 1024 ** 3,
+  TB: 1024 ** 4,
+  PB: 1024 ** 5
+};
+
+export { SIZE };

package/dist/src/shared/utils/ensure-array.js

@@ -0,0 +1,6 @@
+function ensureArray(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export { ensureArray };