@notion-headless-cms/core 0.0.6 → 0.0.7

package/dist/index.d.ts

@@ -3,6 +3,14 @@ import { BlockHandler } from '@notion-headless-cms/transformer';
 import { PageObjectResponse, RichTextItemResponse } from '@notionhq/client/build/src/api-endpoints';
 import { PluggableList } from 'unified';
 
+/** 文字列をSHA-256でハッシュ化し、16進数文字列として返す。画像キーの生成に使用。 */
+declare function sha256Hex(input: string): Promise<string>;
+/**
+ * キャッシュが有効期限切れかどうかを判定する。
+ * ttlMs が未指定の場合は常に false（無期限有効）を返す。
+ */
+declare function isStale(cachedAt: number, ttlMs?: number): boolean;
+
 /**
  * ライブラリが動作するために必須なフィールド。
  * 利用者はこのインターフェースを拡張して独自のコンテンツ型を定義する。
@@ -12,7 +20,7 @@ import { PluggableList } from 'unified';
  *   title: string;
  *   author: string;
  * }
- * createCMS<Post>({ schema: { mapItem: (page) => ... } })
+ * createCMS<Post>({ source: notionAdapter({ ... }) })
  */
 interface BaseContentItem {
     id: string;
@@ -38,20 +46,6 @@ interface StorageBinary {
     data: ArrayBuffer;
     contentType?: string;
 }
-/** CMSコアが依存するストレージ抽象。 */
-interface StorageAdapter {
-    get(key: string): Promise<ArrayBuffer | null>;
-    put(key: string, data: ArrayBuffer | ArrayBufferView | string, options?: {
-        contentType?: string;
-    }): Promise<void>;
-    json<T>(key: string): Promise<T | null>;
-    binary(key: string): Promise<StorageBinary | null>;
-}
-/** ライブラリが必要とする最小限の環境バインディング。 */
-interface CMSEnv {
-    NOTION_TOKEN: string;
-    NOTION_DATA_SOURCE_ID: string;
-}
 /** Notionのプロパティ名マッピング（すべてオプション）。 */
 interface CMSSchemaProperties {
     /** Notionのスラッグプロパティ名。デフォルト: 'Slug' */
@@ -61,127 +55,188 @@ interface CMSSchemaProperties {
     /** Notionの公開日プロパティ名。デフォルト: 'CreatedAt' */
     date?: string;
 }
+
+/** ドキュメントキャッシュを抽象化するインターフェース。 */
+interface DocumentCacheAdapter<T extends BaseContentItem = BaseContentItem> {
+    readonly name: string;
+    getList(): Promise<CachedItemList<T> | null>;
+    setList(data: CachedItemList<T>): Promise<void>;
+    getItem(slug: string): Promise<CachedItem<T> | null>;
+    setItem(slug: string, data: CachedItem<T>): Promise<void>;
+    invalidate?(scope: "all" | {
+        slug: string;
+    } | {
+        tag: string;
+    }): Promise<void>;
+}
+/** 画像キャッシュを抽象化するインターフェース。 */
+interface ImageCacheAdapter {
+    readonly name: string;
+    get(hash: string): Promise<StorageBinary | null>;
+    set(hash: string, data: ArrayBuffer, contentType: string): Promise<void>;
+}
+/** キャッシュ設定オブジェクト。document / image それぞれ独立したアダプタを差し込める。 */
+interface CacheConfig<T extends BaseContentItem = BaseContentItem> {
+    document?: DocumentCacheAdapter<T> | false;
+    image?: ImageCacheAdapter | false;
+    /** キャッシュの有効期間（ミリ秒）。未設定の場合はTTLなし。 */
+    ttlMs?: number;
+}
+
 /**
- * CMSの設定オブジェクト。
- * ジェネリクス型 T にカスタムコンテンツ型を指定できる（デフォルト: BaseContentItem）。
+ * コンテンツソース（Notion など）を抽象化するインターフェース。
+ * core は Notion の知識を持たず、DataSourceAdapter 経由でのみデータを取得する。
  */
-interface CMSConfig<T extends BaseContentItem = BaseContentItem> {
-    /** Notion API 認証情報。コンストラクタでクライアントを事前生成するために使用。 */
-    env?: CMSEnv;
-    /** キャッシュ/画像保存用ストレージ。未設定時はキャッシュ機能を無効化。 */
-    storage?: StorageAdapter;
-    schema?: {
-        /**
-         * Notionページをコンテンツ型 T にマッピングするカスタム関数。
-         * 指定した場合 properties の設定は無視される（slug プロパティ名のみ例外）。
-         */
-        mapItem?: (page: PageObjectResponse) => T;
-        /** mapItem 未使用時のプロパティ名マッピング。 */
-        properties?: CMSSchemaProperties;
-        /** getItems() で返す「公開済み」ステータス値の配列。デフォルト: [] （全件返す） */
-        publishedStatuses?: string[];
-        /** getItemBySlug() でアクセス可能なステータス値の配列。デフォルト: [] （全件許可） */
-        accessibleStatuses?: string[];
-    };
-    transformer?: {
-        /** カスタムブロックハンドラーのマップ。Notionブロックタイプをキーとする。 */
-        blocks?: Record<string, BlockHandler>;
-    };
-    renderer?: {
-        /** 画像プロキシのベースURL。デフォルト: '/api/images' */
-        imageProxyBase?: string;
-        /** 追加する remark プラグイン。 */
-        remarkPlugins?: PluggableList;
-        /** 追加する rehype プラグイン。 */
-        rehypePlugins?: PluggableList;
-        /** デフォルトのパイプラインを置き換えるカスタムレンダラー。 */
-        render?: RendererFn;
-    };
-    cache?: {
-        /** コンテンツ一覧のキャッシュキー。デフォルト: 'content.json' */
-        listKey?: string;
-        /** 個別コンテンツのキャッシュキープレフィックス。デフォルト: 'content/' */
-        itemPrefix?: string;
-        /** 画像キャッシュのキープレフィックス。デフォルト: 'images/' */
-        imagePrefix?: string;
-        /** キャッシュの有効期間（ミリ秒）。未設定の場合はTTLなし。 */
-        ttlMs?: number;
-    };
+interface DataSourceAdapter<T extends BaseContentItem = BaseContentItem> {
+    readonly name: string;
+    readonly publishedStatuses?: readonly string[];
+    readonly accessibleStatuses?: readonly string[];
+    list(opts?: {
+        publishedStatuses?: readonly string[];
+    }): Promise<T[]>;
+    findBySlug(slug: string): Promise<T | null>;
+    loadMarkdown(item: T): Promise<string>;
 }
 
-/** 文字列をSHA-256でハッシュ化し、16進数文字列として返す。画像キーの生成に使用。 */
-declare function sha256Hex(input: string): Promise<string>;
+/** スキーマ設定。公開ステータスのフィルタやプロパティ名マッピングを制御する。 */
+interface SchemaConfig<T extends BaseContentItem = BaseContentItem> {
+    /**
+     * Notionページをコンテンツ型 T にマッピングするカスタム関数。
+     * 指定した場合 properties の設定は無視される（slug プロパティ名のみ例外）。
+     */
+    mapItem?: (page: PageObjectResponse) => T;
+    /** mapItem 未使用時のプロパティ名マッピング。 */
+    properties?: CMSSchemaProperties;
+    /** list() で返す「公開済み」ステータス値の配列。デフォルト: [] （全件返す） */
+    publishedStatuses?: string[];
+    /** findBySlug() でアクセス可能なステータス値の配列。デフォルト: [] （全件許可） */
+    accessibleStatuses?: string[];
+}
+/** レンダリング・コンテンツ処理設定。 */
+interface ContentConfig {
+    /** 画像プロキシのベースURL。デフォルト: '/api/images' */
+    imageProxyBase?: string;
+    /** 追加する remark プラグイン。 */
+    remarkPlugins?: PluggableList;
+    /** 追加する rehype プラグイン。 */
+    rehypePlugins?: PluggableList;
+    /** デフォルトのパイプラインを置き換えるカスタムレンダラー。 */
+    render?: RendererFn;
+    /** カスタムブロックハンドラーのマップ。Notionブロックタイプをキーとする。 */
+    blocks?: Record<string, BlockHandler>;
+}
 /**
- * キャッシュが有効期限切れかどうかを判定する。
- * ttlMs が未指定の場合は常に false（無期限有効）を返す。
+ * createCMS() に渡すオプション。
+ * ジェネリクス型 T にカスタムコンテンツ型を指定できる（デフォルト: BaseContentItem）。
  */
-declare function isStale(cachedAt: number, ttlMs?: number): boolean;
-/** ストレージキャッシュ操作をまとめたヘルパークラス。キープレフィックスは設定で変更可能。 */
-declare class CacheStore<T extends BaseContentItem = BaseContentItem> {
-    private readonly storage?;
-    private readonly listKey;
-    private readonly itemPrefix;
-    private readonly imagePrefix;
-    constructor(storage: StorageAdapter | undefined, listKey: string, itemPrefix: string, imagePrefix: string);
-    getItemList(): Promise<CachedItemList<T> | null>;
-    setItemList(items: T[]): Promise<void>;
-    getItem(slug: string): Promise<CachedItem<T> | null>;
-    setItem(slug: string, data: CachedItem<T>): Promise<void>;
-    getImage(hash: string): Promise<StorageBinary | null>;
-    setImage(hash: string, data: ArrayBuffer, contentType: string): Promise<void>;
+interface CreateCMSOptions<T extends BaseContentItem = BaseContentItem> {
+    /** データソースアダプタ（Notion など）。 */
+    source: DataSourceAdapter<T>;
+    /** キャッシュ設定。未設定時はキャッシュなし。 */
+    cache?: CacheConfig<T>;
+    /** スキーマ・ステータス設定。 */
+    schema?: SchemaConfig<T>;
+    /** レンダリング・コンテンツ処理設定。 */
+    content?: ContentConfig;
+    /** Cloudflare Workers の waitUntil に相当する非同期処理の登録関数。 */
+    waitUntil?: (p: Promise<unknown>) => void;
 }
 
+/** インメモリキャッシュ（ドキュメント用）を生成する。 */
+declare function memoryDocumentCache<T extends BaseContentItem = BaseContentItem>(): DocumentCacheAdapter<T>;
+/** インメモリキャッシュ（画像用）を生成する。 */
+declare function memoryImageCache(): ImageCacheAdapter;
 /**
- * Notion をバックエンドとして使う汎用ヘッドレス CMSクラス。
+ * ドキュメントと画像の両方にインメモリキャッシュを返す便利関数。
+ * memoryCache() はドキュメントキャッシュを返す（後方互換）。
+ */
+declare function memoryCache<T extends BaseContentItem = BaseContentItem>(): DocumentCacheAdapter<T>;
+
+/** 何もしないドキュメントキャッシュを返す（シングルトン）。 */
+declare function noopDocumentCache<T extends BaseContentItem = BaseContentItem>(): DocumentCacheAdapter<T>;
+/** 何もしない画像キャッシュを返す（シングルトン）。 */
+declare function noopImageCache(): ImageCacheAdapter;
+
+/**
+ * Notion をバックエンドとして使う汎用ヘッドレス CMS クラス。
  *
  * @example
  * const cms = createCMS({
- *   env: { NOTION_TOKEN: '...', NOTION_DATA_SOURCE_ID: '...' },
- *   schema: { publishedStatuses: ['Published'] }
+ *   source: notionAdapter({ token: '...', dataSourceId: '...' }),
+ *   schema: { publishedStatuses: ['公開'] },
  * });
- * const items = await cms.getItems();
+ * const items = await cms.list();
  */
 declare class CMS<T extends BaseContentItem = BaseContentItem> {
-    private readonly itemMapper;
-    private readonly slugPropName;
+    private readonly source;
+    private readonly docCache;
+    private readonly imgCache;
+    private readonly hasImageCache;
+    private readonly ttlMs;
     private readonly publishedStatuses;
     private readonly accessibleStatuses;
     private readonly imageProxyBase;
-    private readonly transformerConfig;
-    private readonly rendererConfig;
-    private readonly store;
-    private readonly hasStorage;
-    private readonly ttlMs;
-    private readonly client;
-    private readonly dataSourceId;
-    constructor(config?: CMSConfig<T>);
-    private requireClient;
-    /** 公開済みコンテンツ一覧を Notion から直接取得する。 */
-    getItems(): Promise<T[]>;
-    /** スラッグでコンテンツを Notion から直接取得する。 */
-    getItemBySlug(slug: string): Promise<T | null>;
+    private readonly contentConfig;
+    private readonly waitUntil;
+    constructor(opts: CreateCMSOptions<T>);
+    /** 公開済みコンテンツ一覧をソースから直接取得する。 */
+    list(): Promise<T[]>;
+    /** スラッグでコンテンツをソースから直接取得する。 */
+    findBySlug(slug: string): Promise<T | null>;
     /** アイテムが publishedStatuses に含まれるステータスかどうかを返す。 */
     isPublished(item: T): boolean;
-    /** コンテンツをMarkdown→HTMLにレンダリングし、CachedItemとして返す。 */
-    renderItem(item: T): Promise<CachedItem<T>>;
-    /** スラッグでコンテンツを取得してMarkdown→HTMLにレンダリングする。 */
-    renderItemBySlug(slug: string): Promise<CachedItem<T> | null>;
-    getCachedItemList(): Promise<CachedItemList<T> | null>;
-    setCachedItemList(items: T[]): Promise<void>;
-    getCachedItem(slug: string): Promise<CachedItem<T> | null>;
-    setCachedItem(slug: string, data: CachedItem<T>): Promise<void>;
-    getCachedImage(hash: string): Promise<StorageBinary | null>;
-    createCachedImageResponse(hash: string): Promise<Response | null>;
-    getItemsCachedFirst(options?: {
-        waitUntil?: (promise: Promise<void>) => void;
+    /** コンテンツを Markdown → HTML にレンダリングし、CachedItem として返す。 */
+    render(item: T): Promise<CachedItem<T>>;
+    /** スラッグでコンテンツを取得して Markdown → HTML にレンダリングする。 */
+    renderBySlug(slug: string): Promise<CachedItem<T> | null>;
+    /** ステータスでフィルタリングした一覧を返す。 */
+    listByStatus(status: string | readonly string[]): Promise<T[]>;
+    /** 任意の条件でフィルタリングした一覧を返す。 */
+    where(predicate: (item: T) => boolean): Promise<T[]>;
+    /** ページネーション付き一覧を返す。 */
+    paginate(opts: {
+        page: number;
+        perPage: number;
+    }): Promise<{
+        items: T[];
+        total: number;
+        page: number;
+        perPage: number;
+        hasNext: boolean;
+    }>;
+    /** 指定スラッグの前後コンテンツを返す。 */
+    getAdjacent(slug: string): Promise<{
+        prev: T | null;
+        next: T | null;
+    }>;
+    /** 全コンテンツを事前レンダリングしてキャッシュに保存する。 */
+    prefetchAll(opts?: {
+        concurrency?: number;
+        onProgress?: (done: number, total: number) => void;
+    }): Promise<{
+        ok: number;
+        failed: number;
+    }>;
+    /** 静的生成用のスラッグ一覧を返す。 */
+    getStaticSlugs(): Promise<string[]>;
+    /** 指定スコープのキャッシュを無効化する。 */
+    revalidate(scope?: "all" | {
+        slug: string;
+    }): Promise<void>;
+    /** Webhook ペイロードを元にキャッシュを同期する。 */
+    syncFromWebhook(payload?: {
+        slug?: string;
     }): Promise<{
+        updated: string[];
+    }>;
+    /** キャッシュ優先でコンテンツ一覧を返す（SWR）。 */
+    getList(): Promise<{
         items: T[];
         listVersion: string;
     }>;
-    getItemCachedFirst(slug: string, options?: {
-        waitUntil?: (promise: Promise<void>) => void;
-    }): Promise<CachedItem<T> | null>;
-    checkItemsUpdate(clientVersion: string): Promise<{
+    /** キャッシュ優先で単一コンテンツを返す（SWR）。 */
+    getItem(slug: string): Promise<CachedItem<T> | null>;
+    checkListUpdate(version: string): Promise<{
         changed: false;
     } | {
         changed: true;
@@ -195,10 +250,14 @@ declare class CMS<T extends BaseContentItem = BaseContentItem> {
         item: T;
         notionUpdatedAt: string;
     }>;
+    /** ハッシュキーでキャッシュ画像を取得する。 */
+    getCachedImage(hash: string): Promise<StorageBinary | null>;
+    /** ハッシュキーでキャッシュ画像を Response として返す。 */
+    createCachedImageResponse(hash: string): Promise<Response | null>;
     private buildCachedItem;
 }
-/** 設定済みのCMSインスタンスを生成するファクトリ関数。 */
-declare function createCMS<T extends BaseContentItem = BaseContentItem>(config?: CMSConfig<T>): CMS<T>;
+/** 設定済みの CMS インスタンスを生成するファクトリ関数。 */
+declare function createCMS<T extends BaseContentItem = BaseContentItem>(opts: CreateCMSOptions<T>): CMS<T>;
 
 type CMSErrorCode = "CONFIG_INVALID" | "NOTION_ITEM_SCHEMA_INVALID" | "NOTION_FETCH_ITEMS_FAILED" | "NOTION_FETCH_ITEM_BY_SLUG_FAILED" | "NOTION_GET_BLOCKS_FAILED" | "NOTION_MARKDOWN_FETCH_FAILED" | "IMAGE_CACHE_FAILED" | "RENDERER_FAILED";
 interface CMSErrorContext {
@@ -230,4 +289,4 @@ declare function getPlainText(items: RichTextItemResponse[] | undefined): string
  */
 declare function mapItem(page: PageObjectResponse, props: Required<CMSSchemaProperties>): BaseContentItem;
 
-export { type BaseContentItem, CMS, type CMSConfig, type CMSEnv, CMSError, type CMSErrorCode, type CMSErrorContext, type CMSSchemaProperties, CacheStore, type CachedItem, type CachedItemList, type StorageAdapter, type StorageBinary, createCMS, getPlainText, isCMSError, isStale, mapItem, sha256Hex };
+export { type BaseContentItem, CMS, CMSError, type CMSErrorCode, type CMSErrorContext, type CMSSchemaProperties, type CacheConfig, type CachedItem, type CachedItemList, type ContentConfig, type CreateCMSOptions, type DataSourceAdapter, type DocumentCacheAdapter, type ImageCacheAdapter, type SchemaConfig, type StorageBinary, createCMS, getPlainText, isCMSError, isStale, mapItem, memoryCache, memoryDocumentCache, memoryImageCache, noopDocumentCache, noopImageCache, sha256Hex };

package/dist/index.js

@@ -8,58 +8,95 @@ function isStale(cachedAt, ttlMs) {
   if (ttlMs === void 0) return false;
   return Date.now() - cachedAt > ttlMs;
 }
-var CacheStore = class {
-  storage;
-  listKey;
-  itemPrefix;
-  imagePrefix;
-  constructor(storage, listKey, itemPrefix, imagePrefix) {
-    this.storage = storage;
-    this.listKey = listKey;
-    this.itemPrefix = itemPrefix;
-    this.imagePrefix = imagePrefix;
-  }
-  getItemList() {
-    if (!this.storage) return Promise.resolve(null);
-    return this.storage.json(this.listKey);
-  }
-  async setItemList(items) {
-    if (!this.storage) return;
-    const data = { items, cachedAt: Date.now() };
-    await this.storage.put(this.listKey, JSON.stringify(data), {
-      contentType: "application/json"
-    });
+
+// src/cache/memory.ts
+var MemoryDocumentCache = class {
+  name = "memory-document";
+  list = null;
+  items = /* @__PURE__ */ new Map();
+  getList() {
+    return Promise.resolve(this.list);
+  }
+  setList(data) {
+    this.list = data;
+    return Promise.resolve();
   }
   getItem(slug) {
-    if (!this.storage) return Promise.resolve(null);
-    return this.storage.json(`${this.itemPrefix}${slug}.json`);
-  }
-  async setItem(slug, data) {
-    if (!this.storage) return;
-    await this.storage.put(
-      `${this.itemPrefix}${slug}.json`,
-      JSON.stringify(data),
-      { contentType: "application/json" }
-    );
+    return Promise.resolve(this.items.get(slug) ?? null);
+  }
+  setItem(slug, data) {
+    this.items.set(slug, data);
+    return Promise.resolve();
   }
-  getImage(hash) {
-    if (!this.storage) return Promise.resolve(null);
-    return this.storage.binary(`${this.imagePrefix}${hash}`);
+  async invalidate(scope) {
+    if (scope === "all") {
+      this.list = null;
+      this.items.clear();
+    } else if ("slug" in scope) {
+      this.items.delete(scope.slug);
+    }
+  }
+};
+var MemoryImageCache = class {
+  name = "memory-image";
+  store = /* @__PURE__ */ new Map();
+  get(hash) {
+    return Promise.resolve(this.store.get(hash) ?? null);
+  }
+  set(hash, data, contentType) {
+    this.store.set(hash, { data, contentType });
+    return Promise.resolve();
+  }
+};
+function memoryDocumentCache() {
+  return new MemoryDocumentCache();
+}
+function memoryImageCache() {
+  return new MemoryImageCache();
+}
+function memoryCache() {
+  return new MemoryDocumentCache();
+}
+
+// src/cache/noop.ts
+var NoopDocumentCache = class {
+  name = "noop-document";
+  getList() {
+    return Promise.resolve(null);
+  }
+  setList(_data) {
+    return Promise.resolve();
+  }
+  getItem(_slug) {
+    return Promise.resolve(null);
+  }
+  setItem(_slug, _data) {
+    return Promise.resolve();
+  }
+  invalidate(_scope) {
+    return Promise.resolve();
+  }
+};
+var NoopImageCache = class {
+  name = "noop-image";
+  get(_hash) {
+    return Promise.resolve(null);
   }
-  async setImage(hash, data, contentType) {
-    if (!this.storage) return;
-    await this.storage.put(`${this.imagePrefix}${hash}`, data, { contentType });
+  set(_hash, _data, _contentType) {
+    return Promise.resolve();
   }
 };
+var _noopDocument = new NoopDocumentCache();
+var _noopImage = new NoopImageCache();
+function noopDocumentCache() {
+  return _noopDocument;
+}
+function noopImageCache() {
+  return _noopImage;
+}
 
 // src/cms.ts
-import {
-  createClient,
-  queryAllPages,
-  queryPageBySlug
-} from "@notion-headless-cms/fetcher";
 import { renderMarkdown } from "@notion-headless-cms/renderer";
-import { Transformer } from "@notion-headless-cms/transformer";
 
 // src/errors.ts
 var CMSError = class extends Error {
@@ -88,10 +125,10 @@ function inferContentType(url, responseContentType) {
   if (url.includes(".webp")) return "image/webp";
   return "image/jpeg";
 }
-async function fetchAndCacheImage(store, notionUrl, imageProxyBase) {
+async function fetchAndCacheImage(cache, notionUrl, imageProxyBase) {
   const hash = await sha256Hex(notionUrl);
   const proxyUrl = `${imageProxyBase}/${hash}`;
-  const existing = await store.getImage(hash);
+  const existing = await cache.get(hash);
   if (existing) return proxyUrl;
   try {
     const response = await fetch(notionUrl, {
@@ -103,7 +140,7 @@ async function fetchAndCacheImage(store, notionUrl, imageProxyBase) {
       notionUrl,
       response.headers.get("content-type")
     );
-    await store.setImage(hash, data, contentType);
+    await cache.set(hash, data, contentType);
   } catch (err) {
     throw new CMSError({
       code: "IMAGE_CACHE_FAILED",
@@ -114,282 +151,228 @@ async function fetchAndCacheImage(store, notionUrl, imageProxyBase) {
   }
   return proxyUrl;
 }
-function buildCacheImageFn(store, imageProxyBase) {
-  return (notionUrl) => fetchAndCacheImage(store, notionUrl, imageProxyBase);
-}
-
-// src/mapper.ts
-import { z } from "zod";
-var baseContentItemSchema = z.object({
-  id: z.string().min(1),
-  slug: z.string(),
-  status: z.string(),
-  publishedAt: z.string().min(1),
-  updatedAt: z.string().min(1)
-});
-function getPlainText(items) {
-  return items?.map((item) => item.plain_text).join("") ?? "";
-}
-function mapItem(page, props) {
-  const statusProperty = page.properties[props.status];
-  const dateProperty = page.properties[props.date];
-  const parsed = baseContentItemSchema.safeParse({
-    id: page.id,
-    slug: getPlainText(
-      page.properties[props.slug]?.rich_text
-    ),
-    status: statusProperty?.status?.name ?? statusProperty?.select?.name ?? "",
-    publishedAt: dateProperty?.date?.start ?? page.created_time,
-    updatedAt: page.last_edited_time
-  });
-  if (!parsed.success) {
-    throw new CMSError({
-      code: "NOTION_ITEM_SCHEMA_INVALID",
-      message: "Failed to parse Notion page into BaseContentItem.",
-      context: {
-        operation: "mapItem",
-        pageId: page.id,
-        issues: JSON.stringify(parsed.error.issues)
-      }
-    });
-  }
-  return parsed.data;
+function buildCacheImageFn(cache, imageProxyBase) {
+  return (notionUrl) => fetchAndCacheImage(cache, notionUrl, imageProxyBase);
 }
 
 // src/cms.ts
-var DEFAULT_PROPERTIES = {
-  slug: "Slug",
-  status: "Status",
-  date: "CreatedAt"
-};
 var DEFAULT_IMAGE_PROXY_BASE = "/api/images";
-var DEFAULT_LIST_KEY = "content.json";
-var DEFAULT_ITEM_PREFIX = "content/";
-var DEFAULT_IMAGE_PREFIX = "images/";
 function buildListVersion(items) {
   return items.map((item) => `${item.id}:${item.updatedAt}`).join("|");
 }
-function validateEnv(env) {
-  if (!env.NOTION_TOKEN || !env.NOTION_DATA_SOURCE_ID) {
-    throw new CMSError({
-      code: "CONFIG_INVALID",
-      message: "NOTION_TOKEN and NOTION_DATA_SOURCE_ID are required to use Notion CMS APIs.",
-      context: {
-        operation: "validateEnv",
-        hasNotionToken: !!env.NOTION_TOKEN,
-        hasNotionDataSourceId: !!env.NOTION_DATA_SOURCE_ID
-      }
-    });
+function resolveDocumentCache(cache) {
+  if (!cache || cache.document === false || cache.document === void 0) {
+    return noopDocumentCache();
   }
-  return { dataSourceId: env.NOTION_DATA_SOURCE_ID };
+  return cache.document;
+}
+function resolveImageCache(cache) {
+  if (!cache || cache.image === false || cache.image === void 0) {
+    return noopImageCache();
+  }
+  return cache.image;
 }
 var CMS = class {
-  itemMapper;
-  slugPropName;
+  source;
+  docCache;
+  imgCache;
+  hasImageCache;
+  ttlMs;
   publishedStatuses;
   accessibleStatuses;
   imageProxyBase;
-  transformerConfig;
-  rendererConfig;
-  store;
-  hasStorage;
-  ttlMs;
-  client;
-  dataSourceId;
-  constructor(config) {
-    const props = {
-      ...DEFAULT_PROPERTIES,
-      ...config?.schema?.properties
-    };
-    this.slugPropName = props.slug;
-    if (config?.schema?.mapItem) {
-      this.itemMapper = config.schema.mapItem;
-    } else {
-      this.itemMapper = (page) => mapItem(page, props);
-    }
-    this.publishedStatuses = config?.schema?.publishedStatuses ?? [];
-    this.accessibleStatuses = config?.schema?.accessibleStatuses ?? [];
-    this.imageProxyBase = config?.renderer?.imageProxyBase ?? DEFAULT_IMAGE_PROXY_BASE;
-    this.transformerConfig = config?.transformer;
-    this.rendererConfig = config?.renderer;
-    this.hasStorage = !!config?.storage;
-    this.ttlMs = config?.cache?.ttlMs;
-    this.store = new CacheStore(
-      config?.storage,
-      config?.cache?.listKey ?? DEFAULT_LIST_KEY,
-      config?.cache?.itemPrefix ?? DEFAULT_ITEM_PREFIX,
-      config?.cache?.imagePrefix ?? DEFAULT_IMAGE_PREFIX
-    );
-    if (config?.env) {
-      const { dataSourceId } = validateEnv(config.env);
-      this.client = createClient(config.env);
-      this.dataSourceId = dataSourceId;
-    }
-  }
-  // ── プライベートヘルパー（認証） ──────────────────────────────────────
-  requireClient() {
-    if (!this.client || !this.dataSourceId) {
-      throw new CMSError({
-        code: "CONFIG_INVALID",
-        message: "NOTION_TOKEN \u3068 NOTION_DATA_SOURCE_ID \u306F CMS \u306E\u8A2D\u5B9A\u306B\u5FC5\u8981\u3067\u3059\u3002",
-        context: { operation: "requireClient" }
-      });
-    }
-    return { client: this.client, dataSourceId: this.dataSourceId };
+  contentConfig;
+  waitUntil;
+  constructor(opts) {
+    this.source = opts.source;
+    this.docCache = resolveDocumentCache(opts.cache);
+    this.imgCache = resolveImageCache(opts.cache);
+    this.hasImageCache = !!opts.cache?.image;
+    this.ttlMs = opts.cache?.ttlMs;
+    this.publishedStatuses = opts.schema?.publishedStatuses ?? (opts.source.publishedStatuses ? [...opts.source.publishedStatuses] : []);
+    this.accessibleStatuses = opts.schema?.accessibleStatuses ?? (opts.source.accessibleStatuses ? [...opts.source.accessibleStatuses] : []);
+    this.imageProxyBase = opts.content?.imageProxyBase ?? DEFAULT_IMAGE_PROXY_BASE;
+    this.contentConfig = opts.content;
+    this.waitUntil = opts.waitUntil;
   }
-  // ── コンテンツ取得 ────────────────────────────────────────────────────
-  /** 公開済みコンテンツ一覧を Notion から直接取得する。 */
-  async getItems() {
-    const { client, dataSourceId } = this.requireClient();
-    try {
-      const pages = await queryAllPages(client, dataSourceId);
-      const items = pages.map(this.itemMapper);
-      const filtered = this.publishedStatuses.length > 0 ? items.filter((item) => this.publishedStatuses.includes(item.status)) : items;
-      return filtered.sort(
-        (a, b) => new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime()
-      );
-    } catch (err) {
-      if (isCMSError(err)) throw err;
-      throw new CMSError({
-        code: "NOTION_FETCH_ITEMS_FAILED",
-        message: "Failed to fetch items from Notion data source.",
-        cause: err,
-        context: { operation: "getItems", dataSourceId }
-      });
-    }
+  // ── コンテンツ取得 ──────────────────────────────────────────────────────
+  /** 公開済みコンテンツ一覧をソースから直接取得する。 */
+  list() {
+    return this.source.list({
+      publishedStatuses: this.publishedStatuses.length > 0 ? this.publishedStatuses : void 0
+    });
   }
-  /** スラッグでコンテンツを Notion から直接取得する。 */
-  async getItemBySlug(slug) {
-    const { client, dataSourceId } = this.requireClient();
-    try {
-      const page = await queryPageBySlug(
-        client,
-        dataSourceId,
-        slug,
-        this.slugPropName
-      );
-      if (!page) return null;
-      const item = this.itemMapper(page);
-      if (this.accessibleStatuses.length > 0 && !this.accessibleStatuses.includes(item.status)) {
-        return null;
-      }
-      return item;
-    } catch (err) {
-      if (isCMSError(err)) throw err;
-      throw new CMSError({
-        code: "NOTION_FETCH_ITEM_BY_SLUG_FAILED",
-        message: "Failed to fetch item by slug from Notion data source.",
-        cause: err,
-        context: { operation: "getItemBySlug", dataSourceId, slug }
-      });
+  /** スラッグでコンテンツをソースから直接取得する。 */
+  async findBySlug(slug) {
+    const item = await this.source.findBySlug(slug);
+    if (!item) return null;
+    if (this.accessibleStatuses.length > 0 && !this.accessibleStatuses.includes(item.status)) {
+      return null;
     }
+    return item;
   }
   /** アイテムが publishedStatuses に含まれるステータスかどうかを返す。 */
   isPublished(item) {
     if (this.publishedStatuses.length === 0) return true;
     return this.publishedStatuses.includes(item.status);
   }
-  /** コンテンツをMarkdown→HTMLにレンダリングし、CachedItemとして返す。 */
-  async renderItem(item) {
-    const { client } = this.requireClient();
-    return this.buildCachedItem(client, item);
+  /** コンテンツを Markdown → HTML にレンダリングし、CachedItem として返す。 */
+  async render(item) {
+    return this.buildCachedItem(item);
   }
-  /** スラッグでコンテンツを取得してMarkdown→HTMLにレンダリングする。 */
-  async renderItemBySlug(slug) {
-    const { client, dataSourceId } = this.requireClient();
+  /** スラッグでコンテンツを取得して Markdown → HTML にレンダリングする。 */
+  async renderBySlug(slug) {
     try {
-      const page = await queryPageBySlug(
-        client,
-        dataSourceId,
-        slug,
-        this.slugPropName
-      );
-      if (!page) return null;
-      const item = this.itemMapper(page);
-      if (this.accessibleStatuses.length > 0 && !this.accessibleStatuses.includes(item.status)) {
-        return null;
-      }
-      return this.buildCachedItem(client, item);
+      const item = await this.findBySlug(slug);
+      if (!item) return null;
+      return this.buildCachedItem(item);
     } catch (err) {
       if (isCMSError(err)) throw err;
       throw new CMSError({
         code: "NOTION_FETCH_ITEM_BY_SLUG_FAILED",
         message: "Failed to fetch item by slug from Notion data source.",
         cause: err,
-        context: { operation: "renderItemBySlug", dataSourceId, slug }
+        context: { operation: "renderBySlug", slug }
       });
     }
   }
-  // ── キャッシュ操作 ─────────────────────────────────────────────────────
-  getCachedItemList() {
-    return this.store.getItemList();
+  // ── 便利 API ───────────────────────────────────────────────────────────
+  /** ステータスでフィルタリングした一覧を返す。 */
+  async listByStatus(status) {
+    const statuses = Array.isArray(status) ? status : [status];
+    const all = await this.source.list();
+    return all.filter((item) => statuses.includes(item.status));
   }
-  setCachedItemList(items) {
-    return this.store.setItemList(items);
+  /** 任意の条件でフィルタリングした一覧を返す。 */
+  async where(predicate) {
+    const items = await this.list();
+    return items.filter(predicate);
   }
-  getCachedItem(slug) {
-    return this.store.getItem(slug);
+  /** ページネーション付き一覧を返す。 */
+  async paginate(opts) {
+    const all = await this.list();
+    const total = all.length;
+    const start = (opts.page - 1) * opts.perPage;
+    const items = all.slice(start, start + opts.perPage);
+    return {
+      items,
+      total,
+      page: opts.page,
+      perPage: opts.perPage,
+      hasNext: start + opts.perPage < total
+    };
   }
-  setCachedItem(slug, data) {
-    return this.store.setItem(slug, data);
+  /** 指定スラッグの前後コンテンツを返す。 */
+  async getAdjacent(slug) {
+    const items = await this.list();
+    const idx = items.findIndex((item) => item.slug === slug);
+    if (idx === -1) return { prev: null, next: null };
+    return {
+      prev: idx > 0 ? items[idx - 1] : null,
+      next: idx < items.length - 1 ? items[idx + 1] : null
+    };
   }
-  getCachedImage(hash) {
-    return this.store.getImage(hash);
+  /** 全コンテンツを事前レンダリングしてキャッシュに保存する。 */
+  async prefetchAll(opts) {
+    const items = await this.list();
+    const concurrency = opts?.concurrency ?? 3;
+    let ok = 0;
+    let failed = 0;
+    for (let i = 0; i < items.length; i += concurrency) {
+      const chunk = items.slice(i, i + concurrency);
+      await Promise.all(
+        chunk.map(async (item) => {
+          try {
+            const rendered = await this.buildCachedItem(item);
+            await this.docCache.setItem(item.slug, rendered);
+            ok++;
+          } catch {
+            failed++;
+          }
+        })
+      );
+      opts?.onProgress?.(Math.min(i + concurrency, items.length), items.length);
+    }
+    await this.docCache.setList({ items, cachedAt: Date.now() });
+    return { ok, failed };
   }
-  async createCachedImageResponse(hash) {
-    const object = await this.store.getImage(hash);
-    if (!object) return null;
-    const headers = new Headers();
-    if (object.contentType) headers.set("content-type", object.contentType);
-    headers.set("cache-control", "public, max-age=31536000, immutable");
-    return new Response(object.data, { headers });
+  /** 静的生成用のスラッグ一覧を返す。 */
+  async getStaticSlugs() {
+    const items = await this.list();
+    return items.map((item) => item.slug);
+  }
+  /** 指定スコープのキャッシュを無効化する。 */
+  async revalidate(scope) {
+    if (!this.docCache.invalidate) return;
+    await this.docCache.invalidate(scope ?? "all");
+  }
+  /** Webhook ペイロードを元にキャッシュを同期する。 */
+  async syncFromWebhook(payload) {
+    const updated = [];
+    if (payload?.slug) {
+      const item = await this.findBySlug(payload.slug);
+      if (item) {
+        const rendered = await this.buildCachedItem(item);
+        await this.docCache.setItem(item.slug, rendered);
+        updated.push(item.slug);
+      }
+    } else {
+      const result = await this.prefetchAll();
+      if (result.ok > 0) {
+        const items = await this.list();
+        for (const item of items) updated.push(item.slug);
+      }
+    }
+    return { updated };
   }
   // ── キャッシュ優先取得（Stale-While-Revalidate） ─────────────────────
-  async getItemsCachedFirst(options) {
-    const cached = await this.store.getItemList();
+  /** キャッシュ優先でコンテンツ一覧を返す（SWR）。 */
+  async getList() {
+    const cached = await this.docCache.getList();
     if (cached && !isStale(cached.cachedAt, this.ttlMs)) {
       return {
         items: cached.items,
         listVersion: buildListVersion(cached.items)
       };
     }
-    const items = await this.getItems();
-    const save = this.store.setItemList(items);
-    if (options?.waitUntil) {
-      options.waitUntil(save);
+    const items = await this.list();
+    const save = this.docCache.setList({ items, cachedAt: Date.now() });
+    if (this.waitUntil) {
+      this.waitUntil(save);
     } else {
       await save;
     }
     return { items, listVersion: buildListVersion(items) };
   }
-  async getItemCachedFirst(slug, options) {
-    const cached = await this.store.getItem(slug);
+  /** キャッシュ優先で単一コンテンツを返す（SWR）。 */
+  async getItem(slug) {
+    const cached = await this.docCache.getItem(slug);
     if (cached && !isStale(cached.cachedAt, this.ttlMs)) return cached;
-    const entry = await this.renderItemBySlug(slug);
+    const entry = await this.renderBySlug(slug);
     if (!entry) return null;
-    const save = this.store.setItem(slug, entry);
-    if (options?.waitUntil) {
-      options.waitUntil(save);
+    const save = this.docCache.setItem(slug, entry);
+    if (this.waitUntil) {
+      this.waitUntil(save);
     } else {
       await save;
     }
     return entry;
   }
-  async checkItemsUpdate(clientVersion) {
-    const items = await this.getItems();
+  async checkListUpdate(version) {
+    const items = await this.list();
     const serverVersion = buildListVersion(items);
-    if (serverVersion === clientVersion) return { changed: false };
-    await this.store.setItemList(items);
+    if (serverVersion === version) return { changed: false };
+    await this.docCache.setList({ items, cachedAt: Date.now() });
     return { changed: true, items };
   }
   async checkItemUpdate(slug, lastEdited) {
-    const item = await this.getItemBySlug(slug);
+    const item = await this.findBySlug(slug);
     if (!item) return { changed: false };
     if (!this.isPublished(item)) return { changed: false };
     if (item.updatedAt === lastEdited) return { changed: false };
-    const entry = await this.renderItemBySlug(slug);
+    const entry = await this.renderBySlug(slug);
     if (!entry) return { changed: false };
-    await this.store.setItem(slug, entry);
+    await this.docCache.setItem(slug, entry);
     return {
       changed: true,
       html: entry.html,
@@ -397,36 +380,47 @@ var CMS = class {
       notionUpdatedAt: entry.notionUpdatedAt
     };
   }
-  // ── プライベートヘルパー ───────────────────────────────────────────────
-  async buildCachedItem(client, item) {
-    const transformer = new Transformer(
-      this.transformerConfig?.blocks ? { blocks: this.transformerConfig.blocks } : void 0
-    );
+  // ── 画像配信 ───────────────────────────────────────────────────────────
+  /** ハッシュキーでキャッシュ画像を取得する。 */
+  getCachedImage(hash) {
+    return this.imgCache.get(hash);
+  }
+  /** ハッシュキーでキャッシュ画像を Response として返す。 */
+  async createCachedImageResponse(hash) {
+    const object = await this.imgCache.get(hash);
+    if (!object) return null;
+    const headers = new Headers();
+    if (object.contentType) headers.set("content-type", object.contentType);
+    headers.set("cache-control", "public, max-age=31536000, immutable");
+    return new Response(object.data, { headers });
+  }
+  // ── プライベートヘルパー ────────────────────────────────────────────────
+  async buildCachedItem(item) {
     let markdown;
     try {
-      markdown = await transformer.transform(client, item.id);
+      markdown = await this.source.loadMarkdown(item);
     } catch (err) {
       if (isCMSError(err)) throw err;
       throw new CMSError({
         code: "NOTION_MARKDOWN_FETCH_FAILED",
-        message: "Failed to load markdown from Notion.",
+        message: "Failed to load markdown from source.",
         cause: err,
         context: {
-          operation: "buildCachedItem:transform",
+          operation: "buildCachedItem:loadMarkdown",
           pageId: item.id,
           slug: item.slug
         }
       });
     }
-    const cacheImage = this.hasStorage ? buildCacheImageFn(this.store, this.imageProxyBase) : void 0;
+    const cacheImage = this.hasImageCache ? buildCacheImageFn(this.imgCache, this.imageProxyBase) : void 0;
     let html;
     try {
       html = await renderMarkdown(markdown, {
         imageProxyBase: this.imageProxyBase,
         cacheImage,
-        remarkPlugins: this.rendererConfig?.remarkPlugins,
-        rehypePlugins: this.rendererConfig?.rehypePlugins,
-        render: this.rendererConfig?.render
+        remarkPlugins: this.contentConfig?.remarkPlugins,
+        rehypePlugins: this.contentConfig?.rehypePlugins,
+        render: this.contentConfig?.render
       });
     } catch (err) {
       if (isCMSError(err)) throw err;
@@ -449,17 +443,59 @@ var CMS = class {
     };
   }
 };
-function createCMS(config) {
-  return new CMS(config);
+function createCMS(opts) {
+  return new CMS(opts);
+}
+
+// src/mapper.ts
+import { z } from "zod";
+var baseContentItemSchema = z.object({
+  id: z.string().min(1),
+  slug: z.string(),
+  status: z.string(),
+  publishedAt: z.string().min(1),
+  updatedAt: z.string().min(1)
+});
+function getPlainText(items) {
+  return items?.map((item) => item.plain_text).join("") ?? "";
+}
+function mapItem(page, props) {
+  const statusProperty = page.properties[props.status];
+  const dateProperty = page.properties[props.date];
+  const parsed = baseContentItemSchema.safeParse({
+    id: page.id,
+    slug: getPlainText(
+      page.properties[props.slug]?.rich_text
+    ),
+    status: statusProperty?.status?.name ?? statusProperty?.select?.name ?? "",
+    publishedAt: dateProperty?.date?.start ?? page.created_time,
+    updatedAt: page.last_edited_time
+  });
+  if (!parsed.success) {
+    throw new CMSError({
+      code: "NOTION_ITEM_SCHEMA_INVALID",
+      message: "Failed to parse Notion page into BaseContentItem.",
+      context: {
+        operation: "mapItem",
+        pageId: page.id,
+        issues: JSON.stringify(parsed.error.issues)
+      }
+    });
+  }
+  return parsed.data;
 }
 export {
   CMS,
   CMSError,
-  CacheStore,
   createCMS,
   getPlainText,
   isCMSError,
   isStale,
   mapItem,
+  memoryCache,
+  memoryDocumentCache,
+  memoryImageCache,
+  noopDocumentCache,
+  noopImageCache,
   sha256Hex
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notion-headless-cms/core",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Core CMS engine for notion-headless-cms — fetch, transform, cache with stale-while-revalidate strategy",
   "keywords": [
     "notion",