@spfn/cms 0.1.0-alpha.6 → 0.1.0-alpha.60

package/dist/index.js

@@ -1,24 +1,1116 @@
-import "server-only";
-/**
- * @spfn/cms
- *
- * Backend + Server Components
- * 백엔드 및 서버 컴포넌트 전용 (서버에서만 실행)
- *
- * For client components, use: import { ... } from '@spfn/cms/client'
- */
-// Configuration API
-export { getCmsConfig, configureCms, resetCmsConfig } from './cms.config.js';
-// Server Components API (React Server Components)
-export * from './server';
-// Backend: Repositories (DB access)
-export * from './repositories';
-// Backend: Entities (DB schemas)
-export * from './entities';
-// Backend: Sync utilities (server startup, CLI scripts)
-export { syncSection, syncAll, initLabelSync, loadLabelsFromJson } from './helpers/sync';
-// Backend: Label helpers (for processing JSON labels)
-export * from './labels';
-// Backend: Codegen generators (for development)
-export { createLabelSyncGenerator, LabelSyncGenerator } from './generators/label-sync-generator';
+// src/cms.config.ts
+function getEnvVar(key, defaultValue) {
+  return process.env[key] || defaultValue;
+}
+function getEnvBoolean(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0) return defaultValue;
+  return value === "true" || value === "1";
+}
+function loadConfigFromEnv() {
+  const defaultLocale = getEnvVar("SPFN_CMS_DEFAULT_LOCALE", "en");
+  const supportedLocalesStr = getEnvVar("SPFN_CMS_SUPPORTED_LOCALES", "en,ko");
+  const detectBrowserLanguage2 = getEnvBoolean("SPFN_CMS_DETECT_BROWSER_LANGUAGE", true);
+  const supportedLocales = supportedLocalesStr.split(",").map((locale) => locale.trim()).filter((locale) => locale.length > 0);
+  if (!supportedLocales.includes(defaultLocale)) {
+    supportedLocales.unshift(defaultLocale);
+  }
+  return {
+    defaultLocale,
+    supportedLocales,
+    detectBrowserLanguage: detectBrowserLanguage2
+  };
+}
+var currentConfig = loadConfigFromEnv();
+function getCmsConfig() {
+  return currentConfig;
+}
+function configureCms(config) {
+  currentConfig = {
+    ...currentConfig,
+    ...config
+  };
+  if (config.defaultLocale && !currentConfig.supportedLocales.includes(config.defaultLocale)) {
+    console.warn(
+      `[CMS Config] Default locale '${config.defaultLocale}' not in supported locales, adding automatically.`,
+      `Supported locales: [${currentConfig.supportedLocales.join(", ")}]`
+    );
+    currentConfig.supportedLocales.unshift(config.defaultLocale);
+  }
+}
+function resetCmsConfig() {
+  currentConfig = loadConfigFromEnv();
+}
+
+// src/server.ts
+import { cache } from "react";
+import { client } from "@spfn/core/client";
+
+// src/contracts/published-cache.ts
+import { Type } from "@sinclair/typebox";
+var SectionData = Type.Object({
+  section: Type.String(),
+  locale: Type.String(),
+  content: Type.Record(Type.String(), Type.Any()),
+  version: Type.Number(),
+  publishedAt: Type.Union([Type.String(), Type.Null()])
+});
+var getPublishedCacheContract = {
+  method: "GET",
+  path: "/cms/published-cache",
+  query: Type.Object({
+    sections: Type.Union([
+      Type.String({ description: "\uB2E8\uC77C \uC139\uC158 \uC774\uB984 (\uC608: home)" }),
+      Type.Array(Type.String(), { description: '\uC5EC\uB7EC \uC139\uC158 \uC774\uB984 (\uC608: ["home", "footer"])' })
+    ]),
+    locale: Type.Optional(Type.String({ default: "ko", description: "\uC5B8\uC5B4 \uCF54\uB4DC" }))
+  }),
+  response: Type.Union([
+    // 성공: 항상 배열로 반환
+    Type.Array(SectionData),
+    // 에러
+    Type.Object({
+      error: Type.String()
+    })
+  ])
+};
+
+// src/helpers/locale.actions.ts
+import { cookies, headers } from "next/headers.js";
+
+// src/helpers/locale.constants.ts
+var LOCALE_COOKIE_KEY = "spfn-locale";
+
+// src/helpers/locale.actions.ts
+async function detectBrowserLanguage() {
+  try {
+    const headersList = await headers();
+    const acceptLanguage = headersList.get("accept-language");
+    if (!acceptLanguage) {
+      return null;
+    }
+    const languages = acceptLanguage.split(",").map((lang) => {
+      const [code] = lang.split(";");
+      return code.split("-")[0].trim();
+    });
+    const config = getCmsConfig();
+    for (const lang of languages) {
+      if (config.supportedLocales.includes(lang)) {
+        return lang;
+      }
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+async function getLocale() {
+  const config = getCmsConfig();
+  const cookieStore = await cookies();
+  const cookieLocale = cookieStore.get(LOCALE_COOKIE_KEY)?.value;
+  if (cookieLocale && config.supportedLocales.includes(cookieLocale)) {
+    return cookieLocale;
+  }
+  if (config.detectBrowserLanguage) {
+    const browserLang = await detectBrowserLanguage();
+    if (browserLang) {
+      return browserLang;
+    }
+  }
+  return config.defaultLocale;
+}
+
+// src/server.ts
+function replaceVariables(text7, replace) {
+  return text7.replace(/\{(\w+)}/g, (match, key) => {
+    const value = replace[key];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+var getSection = cache(async (section, locale) => {
+  const actualLocale = locale ?? await getLocale();
+  try {
+    const response = await client.call(
+      getPublishedCacheContract,
+      {
+        query: { sections: section, locale: actualLocale }
+      }
+    );
+    if ("error" in response) {
+      console.warn(`[CMS] ${response.error}`);
+      const sectionData2 = {
+        section,
+        locale: actualLocale,
+        content: {},
+        version: 0,
+        publishedAt: null
+      };
+      const t2 = (_key, defaultValue) => defaultValue ?? "";
+      return { t: t2, data: sectionData2 };
+    }
+    const found = response[0];
+    if (!found) {
+      const sectionData2 = {
+        section,
+        locale: actualLocale,
+        content: {},
+        version: 0,
+        publishedAt: null
+      };
+      const t2 = (_key, defaultValue) => defaultValue ?? "";
+      return { t: t2, data: sectionData2 };
+    }
+    const sectionData = {
+      section: found.section,
+      locale: found.locale,
+      content: found.content || {},
+      version: found.version,
+      publishedAt: found.publishedAt
+    };
+    const t = (key, defaultValue, replace) => {
+      const fullKey = `${section}.${key}`;
+      let value = sectionData.content[fullKey];
+      if (value === void 0 || value === null) {
+        value = defaultValue ?? "";
+      }
+      if (typeof value !== "string") {
+        return "";
+      }
+      if (replace) {
+        value = replaceVariables(value, replace);
+      }
+      return value;
+    };
+    return {
+      t,
+      data: sectionData
+    };
+  } catch (error) {
+    console.error(`[CMS] Failed to fetch section "${section}":`, error);
+    const sectionData = {
+      section,
+      locale: actualLocale,
+      content: {},
+      version: 0,
+      publishedAt: null
+    };
+    const t = (_key, defaultValue) => defaultValue ?? "";
+    return { t, data: sectionData };
+  }
+});
+var getSections = cache(async (sections, locale) => {
+  const actualLocale = locale ?? await getLocale();
+  try {
+    const response = await client.call(
+      getPublishedCacheContract,
+      {
+        query: { sections, locale: actualLocale }
+      }
+    );
+    if ("error" in response) {
+      console.warn(`[CMS] ${response.error}`);
+      const sectionsMap2 = {};
+      sections.forEach((section) => {
+        sectionsMap2[section] = {
+          t: (_key, defaultValue) => defaultValue ?? "",
+          data: {
+            section,
+            locale: actualLocale,
+            content: {},
+            version: 0,
+            publishedAt: null
+          }
+        };
+      });
+      return sectionsMap2;
+    }
+    const sectionsMap = {};
+    sections.forEach((section) => {
+      sectionsMap[section] = {
+        t: (_key, defaultValue) => defaultValue ?? "",
+        data: {
+          section,
+          locale: actualLocale,
+          content: {},
+          version: 0,
+          publishedAt: null
+        }
+      };
+    });
+    response.forEach((sectionData) => {
+      const createTranslationFn = (section, content) => {
+        return (key, defaultValue, replace) => {
+          const fullKey = `${section}.${key}`;
+          let value = content[fullKey];
+          if (value === void 0 || value === null) {
+            value = defaultValue ?? "";
+          }
+          if (typeof value !== "string") {
+            return "";
+          }
+          if (replace) {
+            value = replaceVariables(value, replace);
+          }
+          return value;
+        };
+      };
+      sectionsMap[sectionData.section] = {
+        t: createTranslationFn(sectionData.section, sectionData.content),
+        data: {
+          section: sectionData.section,
+          locale: sectionData.locale,
+          content: sectionData.content,
+          version: sectionData.version,
+          publishedAt: sectionData.publishedAt
+        }
+      };
+    });
+    return sectionsMap;
+  } catch (error) {
+    console.error(`[CMS] Failed to fetch sections:`, error);
+    const sectionsMap = {};
+    sections.forEach((section) => {
+      sectionsMap[section] = {
+        t: (_key, defaultValue) => defaultValue ?? "",
+        data: {
+          section,
+          locale: actualLocale,
+          content: {},
+          version: 0,
+          publishedAt: null
+        }
+      };
+    });
+    return sectionsMap;
+  }
+});
+
+// src/repositories/cms-labels.repository.ts
+import { findOne, findMany as findManyHelper, create as createHelper, updateOne, deleteOne, count as countHelper } from "@spfn/core/db";
+import { desc } from "drizzle-orm";
+
+// src/entities/cms-labels.ts
+import { index, integer, serial, text, timestamp } from "drizzle-orm/pg-core";
+import { createFunctionSchema } from "@spfn/core/db";
+var schema = createFunctionSchema("@spfn/cms");
+var cmsLabels = schema.table("labels", {
+  // Primary Key
+  id: serial("id").primaryKey(),
+  // 라벨 식별자
+  key: text("key").notNull().unique(),
+  // 예: "home.hero.title", "why-futureplay.hero.subtitle"
+  // 구조: {section}.{component}.{property}
+  // 섹션 분류 (페이지 단위)
+  section: text("section").notNull(),
+  // 예: "home", "why-futureplay", "team"
+  // 값 타입
+  type: text("type").notNull(),
+  // "text" | "image" | "video" | "file" | "object"
+  // 기본값
+  defaultValue: text("default_value"),
+  // 라벨의 기본값 (sync 시 설정)
+  // 설명
+  description: text("description"),
+  // 라벨에 대한 설명 (optional)
+  // 현재 발행된 버전 번호
+  publishedVersion: integer("published_version"),
+  // null = 미발행 상태
+  // 1, 2, 3... = 발행된 버전 번호
+  // 생성자 추적
+  createdBy: text("created_by"),
+  // 타임스탬프
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // 인덱스: 섹션별 조회 최적화
+  index("cms_labels_section_idx").on(table.section),
+  // 인덱스: key로 조회 최적화 (unique 제약으로 자동 생성되지만 명시)
+  index("cms_labels_key_idx").on(table.key)
+]);
+
+// src/entities/cms-label-values.ts
+import { serial as serial2, integer as integer2, text as text2, jsonb, timestamp as timestamp2, index as index2, unique } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema2 } from "@spfn/core/db";
+var schema2 = createFunctionSchema2("@spfn/cms");
+var cmsLabelValues = schema2.table("label_values", {
+  // Primary Key
+  id: serial2("id").primaryKey(),
+  // Foreign Key: cms_labels
+  labelId: integer2("label_id").notNull().references(() => cmsLabels.id, { onDelete: "cascade" }),
+  // 버전 번호
+  version: integer2("version").notNull().default(1),
+  // 언어 코드
+  locale: text2("locale").notNull().default("ko"),
+  // "ko" | "en" | "ja"
+  // 반응형 브레이크포인트
+  breakpoint: text2("breakpoint"),
+  // null = 기본값 (모든 화면 크기)
+  // "sm" | "md" | "lg" | "xl" | "2xl"
+  // 실제 값 (JSONB)
+  value: jsonb("value").notNull(),
+  // LabelValue 타입:
+  // - TextValue: { type: "text", content: string }
+  // - ImageValue: { type: "image", url: string, alt?: string, width?: number, height?: number }
+  // - VideoValue: { type: "video", url: string, thumbnail?: string, duration?: number }
+  // - FileValue: { type: "file", url: string, filename: string, size?: number }
+  // - ObjectValue: { type: "object", fields: Record<string, LabelValue> }
+  // 생성 시각
+  createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: 같은 버전에서 locale + breakpoint 조합은 유일
+  unique("cms_label_values_locale_breakpoint_unique").on(table.labelId, table.version, table.locale, table.breakpoint),
+  // 인덱스: labelId + version 복합 조회 최적화
+  index2("cms_label_values_label_version_idx").on(table.labelId, table.version),
+  // 인덱스: locale 필터링 최적화
+  index2("cms_label_values_locale_idx").on(table.locale)
+]);
+
+// src/entities/cms-label-versions.ts
+import { serial as serial3, integer as integer3, text as text3, timestamp as timestamp3, index as index3, unique as unique2 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema3 } from "@spfn/core/db";
+var schema3 = createFunctionSchema3("@spfn/cms");
+var cmsLabelVersions = schema3.table("label_versions", {
+  // Primary Key
+  id: serial3("id").primaryKey(),
+  // Foreign Key: cms_labels
+  labelId: integer3("label_id").notNull().references(() => cmsLabels.id, { onDelete: "cascade" }),
+  // 버전 번호
+  version: integer3("version").notNull(),
+  // 버전 상태
+  status: text3("status").notNull(),
+  // "draft" | "published" | "archived"
+  // 발행 정보
+  publishedAt: timestamp3("published_at", { withTimezone: true }),
+  publishedBy: text3("published_by"),
+  // 버전 노트 (변경사항 설명)
+  notes: text3("notes"),
+  // 버전 생성자
+  createdBy: text3("created_by"),
+  // 생성 시각
+  createdAt: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: 각 라벨의 버전 번호는 고유
+  unique2("cms_label_versions_label_version_unique").on(table.labelId, table.version),
+  // 인덱스: labelId로 버전 목록 조회 최적화
+  index3("cms_label_versions_label_id_idx").on(table.labelId),
+  // 인덱스: status 필터링 최적화
+  index3("cms_label_versions_status_idx").on(table.status)
+]);
+
+// src/entities/cms-draft-cache.ts
+import { serial as serial4, text as text4, jsonb as jsonb2, timestamp as timestamp4, index as index4, unique as unique3 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema4 } from "@spfn/core/db";
+var schema4 = createFunctionSchema4("@spfn/cms");
+var cmsDraftCache = schema4.table("draft_cache", {
+  // Primary Key
+  id: serial4("id").primaryKey(),
+  // 섹션 (페이지 단위)
+  section: text4("section").notNull(),
+  // "home" | "why-futureplay" | "team" | "our-companies" | "apply"
+  // 언어
+  locale: text4("locale").notNull(),
+  // "ko" | "en" | "ja"
+  // 사용자 ID (핵심 필드!)
+  userId: text4("user_id").notNull(),
+  // 각 관리자의 독립적인 작업 공간
+  // Draft 콘텐츠 (JSONB)
+  content: jsonb2("content").notNull(),
+  // Record<string, LabelValue>
+  // {
+  //   "home.hero.title": { type: "text", content: "수정 중..." },
+  //   "home.hero.subtitle": { type: "text", content: "새로운 문구" },
+  //   ...
+  // }
+  // 최종 수정 시각
+  updatedAt: timestamp4("updated_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // UNIQUE 제약: section + locale + userId 조합은 유일
+  unique3("cms_draft_cache_unique").on(table.section, table.locale, table.userId),
+  // 인덱스: section으로 조회 최적화
+  index4("cms_draft_cache_section_idx").on(table.section),
+  // 인덱스: userId로 사용자의 모든 draft 조회 최적화
+  index4("cms_draft_cache_user_idx").on(table.userId)
+]);
+
+// src/entities/cms-published-cache.ts
+import { serial as serial5, text as text5, jsonb as jsonb3, integer as integer4, timestamp as timestamp5, index as index5, unique as unique4 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema5 } from "@spfn/core/db";
+var schema5 = createFunctionSchema5("@spfn/cms");
+var cmsPublishedCache = schema5.table("published_cache", {
+  // Primary Key
+  id: serial5("id").primaryKey(),
+  // 섹션 (페이지 단위)
+  section: text5("section").notNull(),
+  // "home" | "why-futureplay" | "team" | "our-companies" | "apply"
+  // 언어
+  locale: text5("locale").notNull(),
+  // "ko" | "en" | "ja"
+  // 캐시된 콘텐츠 (JSONB)
+  content: jsonb3("content").notNull(),
+  // Record<string, LabelValue>
+  // {
+  //   "home.hero.title": { type: "text", content: "..." },
+  //   "home.hero.image": { type: "image", url: "...", alt: "..." },
+  //   ...
+  // }
+  // 발행 정보
+  publishedAt: timestamp5("published_at", { withTimezone: true }).notNull(),
+  publishedBy: text5("published_by"),
+  // 캐시 버전 (클라이언트 캐싱용)
+  version: integer4("version").notNull().default(1)
+}, (table) => [
+  // UNIQUE 제약: section + locale 조합은 유일
+  unique4("cms_published_cache_unique").on(table.section, table.locale),
+  // 인덱스: section으로 조회 최적화
+  index5("cms_published_cache_section_idx").on(table.section)
+]);
+
+// src/entities/cms-audit-logs.ts
+import { serial as serial6, integer as integer5, text as text6, jsonb as jsonb4, timestamp as timestamp6, index as index6 } from "drizzle-orm/pg-core";
+import { createFunctionSchema as createFunctionSchema6 } from "@spfn/core/db";
+var schema6 = createFunctionSchema6("@spfn/cms");
+var cmsAuditLogs = schema6.table("audit_logs", {
+  // Primary Key
+  id: serial6("id").primaryKey(),
+  // Foreign Key: cms_labels (nullable - 라벨 삭제 시 로그는 유지)
+  labelId: integer5("label_id").references(() => cmsLabels.id, { onDelete: "set null" }),
+  // 작업 유형
+  action: text6("action").notNull(),
+  // "create" | "update" | "publish" | "unpublish" | "archive" | "delete" | "rollback" | "duplicate"
+  // 사용자 정보
+  userId: text6("user_id").notNull(),
+  userName: text6("user_name"),
+  // 변경 내용 (before/after)
+  changes: jsonb4("changes"),
+  // { before: {...}, after: {...} }
+  // 추가 메타데이터
+  metadata: jsonb4("metadata"),
+  // { version: number, ip: string, userAgent: string, ... }
+  // 작업 시각
+  createdAt: timestamp6("created_at", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+  // 인덱스: labelId로 이력 조회 최적화
+  index6("cms_audit_logs_label_id_idx").on(table.labelId),
+  // 인덱스: userId로 사용자 활동 조회 최적화
+  index6("cms_audit_logs_user_id_idx").on(table.userId),
+  // 인덱스: action 필터링 최적화
+  index6("cms_audit_logs_action_idx").on(table.action),
+  // 인덱스: 시간순 조회 최적화
+  index6("cms_audit_logs_created_at_idx").on(table.createdAt)
+]);
+
+// src/repositories/cms-labels.repository.ts
+async function findMany(options) {
+  const { section, limit = 20, offset = 0 } = options || {};
+  return findManyHelper(cmsLabels, {
+    where: section ? { section } : void 0,
+    orderBy: desc(cmsLabels.updatedAt),
+    limit,
+    offset
+  });
+}
+async function count(section) {
+  return countHelper(cmsLabels, section ? { section } : void 0);
+}
+async function findById(id) {
+  return findOne(cmsLabels, { id });
+}
+async function findByKey(key) {
+  return findOne(cmsLabels, { key });
+}
+async function findBySection(section) {
+  return findManyHelper(cmsLabels, {
+    where: { section },
+    orderBy: desc(cmsLabels.updatedAt)
+  });
+}
+async function create(data) {
+  return createHelper(cmsLabels, data);
+}
+async function updateById(id, data) {
+  return updateOne(cmsLabels, { id }, { ...data, updatedAt: /* @__PURE__ */ new Date() });
+}
+async function deleteById(id) {
+  return deleteOne(cmsLabels, { id });
+}
+var cmsLabelsRepository = {
+  findMany,
+  count,
+  findById,
+  findByKey,
+  findBySection,
+  create,
+  updateById,
+  deleteById
+};
+
+// src/repositories/cms-label-values.repository.ts
+import { findOne as findOne2, findMany as findMany2, create as create2, updateOne as updateOne2, deleteMany } from "@spfn/core/db";
+import { eq, and, isNull } from "drizzle-orm";
+async function findByLabelIdAndVersion(labelId, version, options) {
+  const { locale, breakpoint } = options || {};
+  const conditions = [
+    eq(cmsLabelValues.labelId, labelId),
+    eq(cmsLabelValues.version, version)
+  ];
+  if (locale) {
+    conditions.push(eq(cmsLabelValues.locale, locale));
+  }
+  if (breakpoint !== void 0) {
+    conditions.push(
+      breakpoint === null ? isNull(cmsLabelValues.breakpoint) : eq(cmsLabelValues.breakpoint, breakpoint)
+    );
+  }
+  return findMany2(cmsLabelValues, {
+    where: and(...conditions)
+  });
+}
+async function upsert(data) {
+  const existing = await findOne2(
+    cmsLabelValues,
+    and(
+      eq(cmsLabelValues.labelId, data.labelId),
+      eq(cmsLabelValues.version, data.version ?? 1),
+      eq(cmsLabelValues.locale, data.locale || "ko"),
+      data.breakpoint ? eq(cmsLabelValues.breakpoint, data.breakpoint) : isNull(cmsLabelValues.breakpoint)
+    )
+  );
+  if (existing) {
+    const updated = await updateOne2(
+      cmsLabelValues,
+      { id: existing.id },
+      { value: data.value }
+    );
+    return updated;
+  } else {
+    return create2(cmsLabelValues, data);
+  }
+}
+async function upsertMany(values) {
+  const results = [];
+  for (const value of values) {
+    const result = await upsert(value);
+    results.push(result);
+  }
+  return results;
+}
+async function deleteByVersion(labelId, version) {
+  return deleteMany(
+    cmsLabelValues,
+    and(
+      eq(cmsLabelValues.labelId, labelId),
+      eq(cmsLabelValues.version, version)
+    )
+  );
+}
+var cmsLabelValuesRepository = {
+  findByLabelIdAndVersion,
+  upsert,
+  upsertMany,
+  deleteByVersion
+};
+
+// src/repositories/cms-draft-cache.repository.ts
+import { findOne as findOne3, findMany as findMany3, deleteOne as deleteOne2, deleteMany as deleteMany2, upsert as upsertHelper } from "@spfn/core/db";
+import { eq as eq2, and as and2, lt } from "drizzle-orm";
+async function findByUser(section, locale, userId) {
+  return findOne3(
+    cmsDraftCache,
+    and2(
+      eq2(cmsDraftCache.section, section),
+      eq2(cmsDraftCache.locale, locale),
+      eq2(cmsDraftCache.userId, userId)
+    )
+  );
+}
+async function upsert2(data) {
+  return upsertHelper(cmsDraftCache, data, {
+    target: [cmsDraftCache.section, cmsDraftCache.locale, cmsDraftCache.userId],
+    set: {
+      content: data.content,
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+}
+async function findAllByUser(userId) {
+  return findMany3(cmsDraftCache, {
+    where: eq2(cmsDraftCache.userId, userId)
+  });
+}
+async function deleteByUser(section, locale, userId) {
+  await deleteOne2(
+    cmsDraftCache,
+    and2(
+      eq2(cmsDraftCache.section, section),
+      eq2(cmsDraftCache.locale, locale),
+      eq2(cmsDraftCache.userId, userId)
+    )
+  );
+}
+async function cleanupOldDrafts(daysOld = 30) {
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+  return deleteMany2(
+    cmsDraftCache,
+    lt(cmsDraftCache.updatedAt, cutoffDate)
+  );
+}
+var cmsDraftCacheRepository = {
+  findByUser,
+  upsert: upsert2,
+  findAllByUser,
+  deleteByUser,
+  cleanupOldDrafts
+};
+
+// src/repositories/cms-published-cache.repository.ts
+import { findOne as findOne4, findMany as findMany4, deleteOne as deleteOne3, deleteMany as deleteMany3, upsert as upsertHelper2 } from "@spfn/core/db";
+import { eq as eq3, and as and3, sql } from "drizzle-orm";
+async function findBySection2(section, locale = "ko") {
+  return findOne4(
+    cmsPublishedCache,
+    and3(
+      eq3(cmsPublishedCache.section, section),
+      eq3(cmsPublishedCache.locale, locale)
+    )
+  );
+}
+async function upsert3(data) {
+  return upsertHelper2(cmsPublishedCache, data, {
+    target: [cmsPublishedCache.section, cmsPublishedCache.locale],
+    set: {
+      content: data.content,
+      publishedAt: data.publishedAt,
+      publishedBy: data.publishedBy,
+      version: sql`${cmsPublishedCache.version} + 1`
+      // 버전 증가로 클라이언트 캐시 무효화
+    }
+  });
+}
+async function findAllLanguages(section) {
+  return findMany4(cmsPublishedCache, {
+    where: eq3(cmsPublishedCache.section, section)
+  });
+}
+async function deleteBySection(section, locale) {
+  if (locale) {
+    await deleteOne3(
+      cmsPublishedCache,
+      and3(
+        eq3(cmsPublishedCache.section, section),
+        eq3(cmsPublishedCache.locale, locale)
+      )
+    );
+  } else {
+    await deleteMany3(
+      cmsPublishedCache,
+      eq3(cmsPublishedCache.section, section)
+    );
+  }
+}
+var cmsPublishedCacheRepository = {
+  findBySection: findBySection2,
+  upsert: upsert3,
+  findAllLanguages,
+  deleteBySection
+};
+
+// src/helpers/sync.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, join } from "path";
+
+// src/labels/helpers.ts
+function flattenLabels(labels) {
+  const result = [];
+  function isLabelDefinition(obj) {
+    return "key" in obj && "defaultValue" in obj && typeof obj.key === "string" && (typeof obj.defaultValue === "string" || typeof obj.defaultValue === "object");
+  }
+  function traverse(obj) {
+    if (isLabelDefinition(obj)) {
+      result.push({
+        key: obj.key,
+        defaultValue: obj.defaultValue,
+        description: obj.description
+      });
+    } else {
+      Object.values(obj).forEach((value) => {
+        if (typeof value === "object" && value !== null) {
+          traverse(value);
+        }
+      });
+    }
+  }
+  traverse(labels);
+  return result;
+}
+function extractLabels(definition) {
+  return flattenLabels(definition.labels);
+}
+
+// src/helpers/sync.ts
+async function syncAll(sections, options = {}) {
+  const results = [];
+  for (const definition of sections) {
+    const result = await syncSection(definition, options);
+    results.push(result);
+  }
+  return results;
+}
+function loadLabelsFromJson(labelsDir) {
+  const sections = [];
+  if (!existsSync(labelsDir)) {
+    console.warn(`[CMS] Labels directory not found: ${labelsDir}`);
+    console.warn(`[CMS] Expected directory structure:`);
+    console.warn(`[CMS]   ${labelsDir}/`);
+    console.warn(`[CMS]     \u251C\u2500\u2500 common/          # Section directory`);
+    console.warn(`[CMS]     \u2502   \u251C\u2500\u2500 messages.json`);
+    console.warn(`[CMS]     \u2502   \u2514\u2500\u2500 errors.json`);
+    console.warn(`[CMS]     \u2514\u2500\u2500 home/            # Section directory`);
+    console.warn(`[CMS]         \u2514\u2500\u2500 hero.json`);
+    return sections;
+  }
+  try {
+    const entries = readdirSync(labelsDir);
+    if (entries.length === 0) {
+      console.warn(`[CMS] Labels directory is empty: ${labelsDir}`);
+      console.warn(`[CMS] Create section directories with JSON files inside`);
+      return sections;
+    }
+    const jsonFiles = entries.filter((e) => extname(e) === ".json");
+    if (jsonFiles.length > 0) {
+      console.warn(`[CMS] Found JSON files directly in ${labelsDir}:`);
+      jsonFiles.forEach((f) => console.warn(`[CMS]   - ${f} (will be ignored)`));
+      console.warn(`[CMS] JSON files should be inside section directories`);
+      console.warn(`[CMS] Example: Move ${jsonFiles[0]} to ${labelsDir}/${basename(jsonFiles[0], ".json")}/${jsonFiles[0]}`);
+    }
+    for (const entry of entries) {
+      const sectionPath = join(labelsDir, entry);
+      const stat = statSync(sectionPath);
+      if (stat.isDirectory()) {
+        const sectionName = entry;
+        const labels = loadSectionLabels(sectionPath);
+        if (Object.keys(labels).length > 0) {
+          sections.push({ section: sectionName, labels });
+        } else {
+          console.warn(`[CMS] Section directory "${sectionName}" has no valid JSON files`);
+        }
+      }
+    }
+    if (sections.length === 0) {
+      console.warn(`[CMS] No valid section directories found in ${labelsDir}`);
+    }
+  } catch (error) {
+    console.warn(`[CMS] Could not scan labels directory: ${labelsDir}`);
+    console.error(`[CMS] Error:`, error);
+  }
+  return sections;
+}
+function loadSectionLabels(sectionPath) {
+  const labels = {};
+  try {
+    const files = readdirSync(sectionPath);
+    for (const file of files) {
+      if (extname(file) === ".json") {
+        const filePath = join(sectionPath, file);
+        const categoryName = basename(file, ".json");
+        try {
+          const content = readFileSync(filePath, "utf-8");
+          labels[categoryName] = JSON.parse(content);
+        } catch (error) {
+          console.warn(`[CMS] Failed to parse ${filePath}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.warn(`[CMS] Could not read section directory: ${sectionPath}`);
+  }
+  return labels;
+}
+async function syncSection(definition, options = {}) {
+  const {
+    dryRun = false,
+    updateExisting = false,
+    removeUnused = false,
+    verbose = false
+  } = options;
+  const { section } = definition;
+  const result = {
+    section,
+    created: 0,
+    updated: 0,
+    deleted: 0,
+    unchanged: 0,
+    errors: []
+  };
+  try {
+    const definedLabels = extractLabels(definition);
+    const definedKeys = new Set(definedLabels.map((l) => l.key));
+    const existingLabels = await cmsLabelsRepository.findBySection(section);
+    const existingMap = new Map(existingLabels.map((l) => [l.key, l]));
+    if (verbose) {
+      console.log(`
+[${section}] Found ${definedLabels.length} labels in definition`);
+      console.log(`[${section}] Found ${existingLabels.length} labels in DB`);
+    }
+    for (const label of definedLabels) {
+      const existing = existingMap.get(label.key);
+      if (!existing) {
+        if (verbose) console.log(`  [CREATE] ${label.key}`);
+        if (!dryRun) {
+          try {
+            const defaultValue = typeof label.defaultValue === "object" ? JSON.stringify(label.defaultValue) : label.defaultValue;
+            await cmsLabelsRepository.create({
+              section,
+              key: label.key,
+              type: label.type || "text",
+              // 라벨 타입 (기본값: 'text')
+              defaultValue,
+              description: label.description
+            });
+          } catch (error) {
+            result.errors.push({
+              key: label.key,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            continue;
+          }
+        }
+        result.created++;
+      } else if (updateExisting) {
+        const newDefaultValue = typeof label.defaultValue === "object" ? JSON.stringify(label.defaultValue) : label.defaultValue;
+        const hasChanged = existing.defaultValue !== newDefaultValue;
+        if (hasChanged) {
+          if (verbose) {
+            console.log(`  [UPDATE] ${label.key}`);
+            console.log(`    Old: "${existing.defaultValue}"`);
+            console.log(`    New: "${newDefaultValue}"`);
+          }
+          if (!dryRun) {
+            try {
+              await cmsLabelsRepository.updateById(existing.id, {
+                defaultValue: newDefaultValue,
+                description: label.description
+              });
+            } catch (error) {
+              result.errors.push({
+                key: label.key,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              continue;
+            }
+          }
+          result.updated++;
+        } else {
+          result.unchanged++;
+        }
+      } else {
+        result.unchanged++;
+      }
+    }
+    if (removeUnused) {
+      for (const existing of existingLabels) {
+        if (!definedKeys.has(existing.key)) {
+          if (verbose) console.log(`  [DELETE] ${existing.key}`);
+          if (!dryRun) {
+            try {
+              await cmsLabelsRepository.deleteById(existing.id);
+            } catch (error) {
+              result.errors.push({
+                key: existing.key,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              continue;
+            }
+          }
+          result.deleted++;
+        }
+      }
+    }
+    if (!dryRun && (result.created > 0 || result.updated > 0 || result.deleted > 0)) {
+      if (verbose) console.log(`  [CACHE] Updating published cache for section: ${section}`);
+      await updatePublishedCache(section);
+    }
+  } catch (error) {
+    result.errors.push({
+      key: "__section__",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  return result;
+}
+async function updatePublishedCache(section) {
+  const labels = await cmsLabelsRepository.findBySection(section);
+  const localesSet = /* @__PURE__ */ new Set();
+  const labelsByLocale = {};
+  labels.forEach((label) => {
+    try {
+      const parsed = JSON.parse(label.defaultValue || "{}");
+      if (typeof parsed === "object" && !Array.isArray(parsed)) {
+        Object.keys(parsed).forEach((locale) => localesSet.add(locale));
+        Object.entries(parsed).forEach(([locale, value]) => {
+          if (!labelsByLocale[locale]) labelsByLocale[locale] = {};
+          labelsByLocale[locale][label.key] = value;
+        });
+      } else {
+        if (!labelsByLocale.ko) labelsByLocale.ko = {};
+        labelsByLocale.ko[label.key] = label.defaultValue;
+        localesSet.add("ko");
+      }
+    } catch {
+      if (!labelsByLocale.ko) labelsByLocale.ko = {};
+      labelsByLocale.ko[label.key] = label.defaultValue;
+      localesSet.add("ko");
+    }
+  });
+  const timestamp7 = /* @__PURE__ */ new Date();
+  for (const locale of localesSet) {
+    await cmsPublishedCacheRepository.upsert({
+      section,
+      locale,
+      content: labelsByLocale[locale] || {},
+      publishedAt: timestamp7,
+      publishedBy: "system"
+    });
+  }
+}
+async function initLabelSync(options = {}) {
+  const isDevelopment = process.env.NODE_ENV === "development";
+  const verbose = options.verbose ?? isDevelopment;
+  const labelsDir = options.labelsDir ?? "src/cms/labels";
+  if (verbose) {
+    console.log("\n\u{1F504} Initializing label sync...\n");
+  }
+  const sections = loadLabelsFromJson(labelsDir);
+  if (sections.length === 0) {
+    if (verbose) {
+      console.log("\u26A0\uFE0F  No labels found in", labelsDir);
+      console.log("");
+    }
+    return;
+  }
+  const results = await syncAll(sections, {
+    updateExisting: true,
+    // 🔄 항상 업데이트 (프로덕션 포함)
+    ...options,
+    verbose
+  });
+  const totalCreated = results.reduce((sum, r) => sum + r.created, 0);
+  const totalUpdated = results.reduce((sum, r) => sum + r.updated, 0);
+  const totalUnchanged = results.reduce((sum, r) => sum + r.unchanged, 0);
+  const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+  if (verbose) {
+    console.log("\u2705 Label sync completed\n");
+    console.log(`   Sections: ${results.length}`);
+    console.log(`   Created:  ${totalCreated}`);
+    console.log(`   Updated:  ${totalUpdated}`);
+    console.log(`   Unchanged: ${totalUnchanged}`);
+    if (totalErrors > 0) {
+      console.log(`   Errors:   ${totalErrors}
+`);
+    } else {
+      console.log("");
+    }
+  }
+  if (totalErrors > 0) {
+    results.forEach((result) => {
+      result.errors.forEach((error) => {
+        console.error(`[${result.section}] ${error.key}: ${error.error}`);
+      });
+    });
+  }
+}
+
+// src/generators/label-sync-generator.ts
+import { logger } from "@spfn/core";
+import { join as join2 } from "path";
+var syncLogger = logger.child("label-sync");
+var LabelSyncGenerator = class {
+  name = "label-sync";
+  labelsDir;
+  constructor(config = {}) {
+    this.labelsDir = config.labelsDir ?? "src/cms/labels";
+  }
+  /**
+   * Watch patterns for label definition files
+   */
+  get watchPatterns() {
+    return [
+      `${this.labelsDir}/**/*.json`
+    ];
+  }
+  async generate(options) {
+    if (options.debug) {
+      syncLogger.info("Starting label sync...");
+    }
+    try {
+      const labelsPath = join2(options.cwd, this.labelsDir);
+      const sections = loadLabelsFromJson(labelsPath);
+      if (sections.length === 0) {
+        syncLogger.warn(`No labels found in ${labelsPath}`);
+        return;
+      }
+      syncLogger.info(`Found ${sections.length} sections`);
+      const results = await syncAll(sections, {
+        verbose: options.debug ?? false,
+        updateExisting: true
+        // 항상 업데이트 (프로덕션 포함)
+      });
+      const totalCreated = results.reduce((sum, r) => sum + r.created, 0);
+      const totalUpdated = results.reduce((sum, r) => sum + r.updated, 0);
+      const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+      if (options.debug || totalCreated > 0 || totalUpdated > 0) {
+        syncLogger.info("Label sync completed", {
+          sections: results.length,
+          created: totalCreated,
+          updated: totalUpdated,
+          errors: totalErrors
+        });
+      }
+      if (totalErrors > 0) {
+        results.forEach((result) => {
+          result.errors.forEach((error) => {
+            syncLogger.error(`[${result.section}] ${error.key}: ${error.error}`);
+          });
+        });
+      }
+    } catch (error) {
+      syncLogger.error(
+        "Label sync failed",
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  async onFileChange(filePath, event) {
+    syncLogger.info(`Label file ${event}`, { file: filePath });
+    await this.generate({ cwd: process.cwd(), debug: true });
+  }
+};
+function createLabelSyncGenerator(config) {
+  return new LabelSyncGenerator(config);
+}
+export {
+  LabelSyncGenerator,
+  cmsAuditLogs,
+  cmsDraftCache,
+  cmsDraftCacheRepository,
+  cmsLabelValues,
+  cmsLabelValuesRepository,
+  cmsLabelVersions,
+  cmsLabels,
+  cmsLabelsRepository,
+  cmsPublishedCache,
+  cmsPublishedCacheRepository,
+  configureCms,
+  createLabelSyncGenerator,
+  extractLabels,
+  flattenLabels,
+  getCmsConfig,
+  getSection,
+  getSections,
+  initLabelSync,
+  loadLabelsFromJson,
+  resetCmsConfig,
+  syncAll,
+  syncSection
+};
 //# sourceMappingURL=index.js.map