Front Matter에 타입을 붙였는데 왜 깨질까? Deno로 Markdown 메타데이터 검증하기

const { attrs, body } = extractYaml<PostMeta>(
  source,
);

export interface PostMeta {
  title: string;
  description: string;
  date: string | Date;
  order?: number;
  category: string;
  tags: string[];
  draft: boolean;
  featured?: boolean;
  image?: string;
}

const tags = post.meta.tags.map(normalize);

if (attrs.draft) {
  continue;
}

const { attrs } = extractYaml<unknown>(source);

import type { PostMeta } from "./posts.ts";

function isRecord(
  value: unknown,
): value is Record<string, unknown> {
  return typeof value === "object" &&
    value !== null &&
    !Array.isArray(value);
}

function isNonEmptyString(
  value: unknown,
): value is string {
  return typeof value === "string" &&
    value.trim().length > 0;
}

function isDateString(
  value: unknown,
): value is string {
  if (
    typeof value !== "string" ||
    !/^\d{4}-\d{2}-\d{2}$/.test(value)
  ) {
    return false;
  }

  const date = new Date(
    `${value}T00:00:00.000Z`,
  );

  return Number.isFinite(date.getTime()) &&
    date.toISOString().slice(0, 10) === value;
}

export function getPostMetaIssues(
  value: unknown,
): string[] {
  if (!isRecord(value)) {
    return ["Front Matter: 객체여야 합니다."];
  }

  const issues: string[] = [];

  for (const field of ["title", "description"]) {
    if (!isNonEmptyString(value[field])) {
      issues.push(
        `${field}: 비어 있지 않은 문자열이어야 합니다.`,
      );
    }
  }

  if (!isDateString(value.date)) {
    issues.push(
      "date: 유효한 YYYY-MM-DD 문자열이어야 합니다.",
    );
  }

  if (
    typeof value.category !== "string" ||
    !["Fresh", "Deno", "Vite", "Preact"].includes(
      value.category,
    )
  ) {
    issues.push(
      "category: Fresh, Deno, Vite, Preact 중 하나여야 합니다.",
    );
  }

  if (
    !Array.isArray(value.tags) ||
    value.tags.length === 0 ||
    !value.tags.every(isNonEmptyString)
  ) {
    issues.push(
      "tags: 비어 있지 않은 문자열 배열이어야 합니다.",
    );
  }

  if (typeof value.draft !== "boolean") {
    issues.push(
      "draft: true 또는 false여야 합니다.",
    );
  }

  if (
    value.order !== undefined &&
    (
      typeof value.order !== "number" ||
      !Number.isSafeInteger(value.order) ||
      value.order < 1
    )
  ) {
    issues.push(
      "order: 1 이상의 안전한 정수여야 합니다.",
    );
  }

  if (
    value.featured !== undefined &&
    typeof value.featured !== "boolean"
  ) {
    issues.push(
      "featured: true 또는 false여야 합니다.",
    );
  }

  if (
    value.image !== undefined &&
    !isNonEmptyString(value.image)
  ) {
    issues.push(
      "image: 비어 있지 않은 문자열이어야 합니다.",
    );
  }

  return issues;
}

export function assertPostMeta(
  value: unknown,
  source: string,
): asserts value is PostMeta {
  const issues = getPostMetaIssues(value);

  if (issues.length > 0) {
    throw new Error(
      issues
        .map((issue) => `${source}: ${issue}`)
        .join("\n"),
    );
  }
}

/^\d{4}-\d{2}-\d{2}$/

const date = new Date(
  `${value}T00:00:00.000Z`,
);

return Number.isFinite(date.getTime()) &&
  date.toISOString().slice(0, 10) === value;

import { extractYaml } from "@std/front-matter";
import { assertPostMeta } from "../utils/post-meta.ts";

const postsDir = Deno.args[0] ??
  "./content/posts";

const files: string[] = [];

for await (const entry of Deno.readDir(postsDir)) {
  if (
    entry.isFile &&
    entry.name.endsWith(".md")
  ) {
    files.push(entry.name);
  }
}

files.sort();

const errors: string[] = [];
const orders = new Map<number, string>();

for (const file of files) {
  const path = `${postsDir}/${file}`;

  try {
    const source = await Deno.readTextFile(path);

    const { attrs } = extractYaml<unknown>(
      source,
    );

    assertPostMeta(attrs, path);

    if (attrs.order !== undefined) {
      const previous = orders.get(attrs.order);

      if (previous) {
        errors.push(
          `${path}: order 중복: ${attrs.order} (기존 파일: ${previous})`,
        );
      } else {
        orders.set(attrs.order, path);
      }
    }
  } catch (error) {
    const message = error instanceof Error
      ? error.message
      : String(error);

    errors.push(
      message.startsWith(`${path}:`)
        ? message
        : `${path}: ${message}`,
    );
  }
}

if (errors.length > 0) {
  console.error(errors.join("\n"));
  Deno.exit(1);
}

console.log(
  `콘텐츠 검증 통과: ${files.length}개 파일`,
);

if (attrs.draft) {
  continue;
}

import { assertPostMeta } from "./post-meta.ts";

const { attrs } = extractYaml<unknown>(
  source,
);

assertPostMeta(
  attrs,
  `${POSTS_DIR}/${entry.name}`,
);

if (attrs.draft) {
  continue;
}

const { attrs, body } = extractYaml<unknown>(
  source,
);

assertPostMeta(
  attrs,
  `${POSTS_DIR}/${slug}.md`,
);

catch (error) {
  if (error instanceof Deno.errors.NotFound) {
    return null;
  }

  throw error;
}