@notion-headless-cms/core 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -0,0 +1,616 @@
+import { memoryCache, memoryDocumentCache, memoryImageCache } from "./cache/memory.mjs";
+import { noopDocumentCache, noopImageCache } from "./cache/noop.mjs";
+import { CMSError, isCMSError, isCMSErrorInNamespace } from "./errors.mjs";
+import { mergeHooks, mergeLoggers } from "./hooks.mjs";
+//#region src/cache.ts
+/** 文字列をSHA-256でハッシュ化し、16進数文字列として返す。画像キーの生成に使用。 */
+async function sha256Hex(input) {
+	const data = new TextEncoder().encode(input);
+	const hash = await crypto.subtle.digest("SHA-256", data);
+	return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* キャッシュが有効期限切れかどうかを判定する。
+* ttlMs が未指定の場合は常に false（無期限有効）を返す。
+*/
+function isStale(cachedAt, ttlMs) {
+	if (ttlMs === void 0) return false;
+	return Date.now() - cachedAt > ttlMs;
+}
+//#endregion
+//#region src/image.ts
+/** レスポンスヘッダまたはURLの拡張子からContent-Typeを推測する。 */
+function inferContentType(url, responseContentType) {
+	if (responseContentType?.startsWith("image/")) return responseContentType.split(";")[0].trim();
+	if (url.includes(".png")) return "image/png";
+	if (url.includes(".gif")) return "image/gif";
+	if (url.includes(".webp")) return "image/webp";
+	return "image/jpeg";
+}
+/**
+* Notion画像URLをfetchしてImageCacheAdapterにキャッシュし、プロキシURL を返す。
+* 既存キャッシュがあれば再fetchしない。
+*/
+async function fetchAndCacheImage(cache, notionUrl, imageProxyBase) {
+	const hash = await sha256Hex(notionUrl);
+	const proxyUrl = `${imageProxyBase}/${hash}`;
+	if (await cache.get(hash)) return proxyUrl;
+	try {
+		const response = await fetch(notionUrl, { signal: AbortSignal.timeout(1e4) });
+		if (!response.ok) throw new CMSError({
+			code: "cache/image_fetch_failed",
+			message: `Failed to fetch Notion image: HTTP ${response.status}`,
+			context: {
+				operation: "fetchAndCacheImage",
+				notionUrl,
+				httpStatus: response.status
+			}
+		});
+		const data = await response.arrayBuffer();
+		const contentType = inferContentType(notionUrl, response.headers.get("content-type"));
+		await cache.set(hash, data, contentType);
+	} catch (err) {
+		if (isCMSError(err)) throw err;
+		throw new CMSError({
+			code: "cache/io_failed",
+			message: "Failed to fetch or cache Notion image.",
+			cause: err,
+			context: {
+				operation: "fetchAndCacheImage",
+				notionUrl
+			}
+		});
+	}
+	return proxyUrl;
+}
+/** ImageCacheAdapter と imageProxyBase から cacheImage 関数を構築するファクトリ。 */
+function buildCacheImageFn(cache, imageProxyBase) {
+	return (notionUrl) => fetchAndCacheImage(cache, notionUrl, imageProxyBase);
+}
+//#endregion
+//#region src/rendering.ts
+/**
+* コンテンツアイテムをソースから Markdown ロード → blocks 生成 → HTML レンダリング
+* → フック適用まで実行し、キャッシュ保存用の `CachedItem` を返す。
+*/
+async function buildCachedItem(item, ctx) {
+	const start = Date.now();
+	ctx.logger?.info?.("コンテンツのレンダリング開始", {
+		slug: item.slug,
+		pageId: item.id
+	});
+	ctx.hooks.onRenderStart?.(item.slug);
+	let markdown;
+	try {
+		markdown = await ctx.source.loadMarkdown(item);
+	} catch (err) {
+		if (isCMSError(err)) throw err;
+		throw new CMSError({
+			code: "source/load_markdown_failed",
+			message: "Failed to load markdown from source.",
+			cause: err,
+			context: {
+				operation: "buildCachedItem:loadMarkdown",
+				pageId: item.id,
+				slug: item.slug
+			}
+		});
+	}
+	let blocks = [];
+	try {
+		blocks = await ctx.source.loadBlocks(item);
+	} catch (err) {
+		ctx.logger?.warn?.("loadBlocks に失敗したため raw フォールバック", {
+			slug: item.slug,
+			error: err instanceof Error ? err.message : String(err)
+		});
+		blocks = [];
+	}
+	const cacheImage = ctx.hasImageCache ? buildCacheImageFn(ctx.imgCache, ctx.imageProxyBase) : void 0;
+	let html;
+	const rendererFn = ctx.rendererFn ?? await loadDefaultRenderer();
+	try {
+		html = await rendererFn(markdown, {
+			imageProxyBase: ctx.imageProxyBase,
+			cacheImage,
+			remarkPlugins: ctx.contentConfig?.remarkPlugins,
+			rehypePlugins: ctx.contentConfig?.rehypePlugins
+		});
+	} catch (err) {
+		if (isCMSError(err)) throw err;
+		throw new CMSError({
+			code: "renderer/failed",
+			message: "Failed to render markdown.",
+			cause: err,
+			context: {
+				operation: "buildCachedItem:renderMarkdown",
+				pageId: item.id,
+				slug: item.slug
+			}
+		});
+	}
+	if (ctx.hooks.afterRender) html = await ctx.hooks.afterRender(html, item);
+	let result = {
+		html,
+		blocks,
+		markdown,
+		item,
+		notionUpdatedAt: ctx.source.getLastModified(item),
+		cachedAt: Date.now()
+	};
+	if (ctx.hooks.beforeCache) result = await ctx.hooks.beforeCache(result);
+	const durationMs = Date.now() - start;
+	ctx.logger?.info?.("コンテンツのレンダリング完了", {
+		slug: item.slug,
+		durationMs
+	});
+	ctx.hooks.onRenderEnd?.(item.slug, durationMs);
+	return result;
+}
+/**
+* renderer オプション未指定時のフォールバック。
+* @notion-headless-cms/renderer を動的 import する。
+* adapter-cloudflare / adapter-node は renderer を明示注入するためこのパスは通らない。
+*/
+async function loadDefaultRenderer() {
+	try {
+		return (await import("@notion-headless-cms/renderer")).renderMarkdown;
+	} catch (err) {
+		throw new CMSError({
+			code: "renderer/failed",
+			message: "renderer オプションが未指定で @notion-headless-cms/renderer が見つかりません。 createCMS({ renderer }) でレンダラーを注入するか、@notion-headless-cms/renderer をインストールしてください。",
+			cause: err,
+			context: { operation: "loadDefaultRenderer" }
+		});
+	}
+}
+//#endregion
+//#region src/retry.ts
+const DEFAULT_RETRY_CONFIG = {
+	retryOn: [
+		429,
+		502,
+		503
+	],
+	maxRetries: 4,
+	baseDelayMs: 1e3,
+	jitter: true
+};
+/** 指数バックオフ（オプションでジッター付き）でリトライする。retryOn に含まれる HTTP エラーのみ対象。 */
+async function withRetry(fn, config) {
+	let lastError;
+	for (let attempt = 0; attempt <= config.maxRetries; attempt++) try {
+		return await fn();
+	} catch (err) {
+		const status = err.status;
+		if (status === void 0 || !config.retryOn.includes(status)) throw err;
+		lastError = err;
+		if (attempt < config.maxRetries) {
+			config.onRetry?.(attempt + 1, status);
+			const jitterFactor = config.jitter !== false ? .5 + Math.random() * .5 : 1;
+			const delay = config.baseDelayMs * 2 ** attempt * jitterFactor;
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+	throw lastError;
+}
+//#endregion
+//#region src/collection.ts
+/**
+* コレクション別キャッシュキーを生成する。
+* item: `{collection}:{slug}` / list: `{collection}`
+*/
+function collectionKey(collection, slug) {
+	return slug ? `${collection}:${slug}` : collection;
+}
+/** CollectionClient の実装。ユーザーは `createCMS` 経由でインスタンスを受け取る。 */
+var CollectionClientImpl = class {
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	async getItem(slug) {
+		const cached = await this.ctx.docCache.getItem(slug);
+		if (cached && !isStale(cached.cachedAt, this.ctx.ttlMs)) {
+			this.ctx.hooks.onCacheHit?.(slug, cached);
+			return this.attachContent(cached.item, cached);
+		}
+		this.ctx.hooks.onCacheMiss?.(slug);
+		const item = await this.findRaw(slug);
+		if (!item) return null;
+		const entry = await buildCachedItem(item, this.ctx.render);
+		const save = this.ctx.docCache.setItem(slug, entry);
+		if (this.ctx.waitUntil) this.ctx.waitUntil(save);
+		else await save;
+		return this.attachContent(entry.item, entry);
+	}
+	async getList(opts) {
+		return applyGetListOptions(await this.fetchList(), opts);
+	}
+	async getStaticParams() {
+		return (await this.fetchList()).map((item) => ({ slug: item.slug }));
+	}
+	async getStaticPaths() {
+		return (await this.fetchList()).map((item) => item.slug);
+	}
+	async adjacent(slug, opts) {
+		const items = applyGetListOptions(await this.fetchList(), { sort: opts?.sort });
+		const index = items.findIndex((it) => it.slug === slug);
+		if (index === -1) return {
+			prev: null,
+			next: null
+		};
+		return {
+			prev: index > 0 ? items[index - 1] ?? null : null,
+			next: index < items.length - 1 ? items[index + 1] ?? null : null
+		};
+	}
+	async revalidate(scope) {
+		if (!this.ctx.docCache.invalidate) return;
+		if (scope === void 0 || scope === "all") await this.ctx.docCache.invalidate({ collection: this.ctx.collection });
+		else await this.ctx.docCache.invalidate({
+			collection: this.ctx.collection,
+			slug: scope.slug
+		});
+	}
+	async prefetch(opts) {
+		const items = await this.fetchListRaw();
+		const concurrency = opts?.concurrency ?? this.ctx.maxConcurrent;
+		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 buildCachedItem(item, this.ctx.render);
+					await this.ctx.docCache.setItem(item.slug, rendered);
+					ok++;
+				} catch (err) {
+					failed++;
+					this.ctx.logger?.warn?.("prefetch: アイテムの事前レンダリングに失敗", {
+						slug: item.slug,
+						pageId: item.id,
+						error: err instanceof Error ? err.message : String(err)
+					});
+				}
+			}));
+			opts?.onProgress?.(Math.min(i + concurrency, items.length), items.length);
+		}
+		await this.ctx.docCache.setList({
+			items,
+			cachedAt: Date.now()
+		});
+		return {
+			ok,
+			failed
+		};
+	}
+	attachContent(item, cached) {
+		const ctx = this.ctx;
+		let blocksCache;
+		let htmlCache = cached.html;
+		let markdownCache;
+		const content = {
+			get blocks() {
+				if (!blocksCache) blocksCache = [{
+					type: "raw",
+					html: cached.html
+				}];
+				return blocksCache;
+			},
+			async html() {
+				if (htmlCache !== void 0) return htmlCache;
+				htmlCache = cached.html;
+				return htmlCache;
+			},
+			async markdown() {
+				if (markdownCache !== void 0) return markdownCache;
+				markdownCache = await ctx.source.loadMarkdown(item);
+				return markdownCache;
+			}
+		};
+		const maybeBlocks = cached.blocks;
+		if (maybeBlocks) blocksCache = maybeBlocks;
+		return Object.assign(Object.create(null), item, { content });
+	}
+	async fetchList() {
+		const cached = await this.ctx.docCache.getList();
+		if (cached && !isStale(cached.cachedAt, this.ctx.ttlMs)) {
+			this.ctx.hooks.onListCacheHit?.(cached.items, cached.cachedAt);
+			return cached.items;
+		}
+		this.ctx.hooks.onListCacheMiss?.();
+		const items = await this.fetchListRaw();
+		const cachedAt = Date.now();
+		const save = this.ctx.docCache.setList({
+			items,
+			cachedAt
+		});
+		if (this.ctx.waitUntil) this.ctx.waitUntil(save);
+		else await save;
+		return items;
+	}
+	fetchListRaw() {
+		return withRetry(() => this.ctx.source.list({ publishedStatuses: this.ctx.publishedStatuses.length > 0 ? this.ctx.publishedStatuses : void 0 }), {
+			...this.ctx.retryConfig,
+			onRetry: (attempt, status) => {
+				this.ctx.logger?.warn?.("getList() リトライ中", {
+					attempt,
+					status
+				});
+			}
+		});
+	}
+	async findRaw(slug) {
+		const item = await withRetry(() => this.ctx.source.findBySlug(slug), {
+			...this.ctx.retryConfig,
+			onRetry: (attempt, status) => {
+				this.ctx.logger?.warn?.("getItem() リトライ中", {
+					attempt,
+					status,
+					slug
+				});
+			}
+		});
+		if (!item) return null;
+		if (this.ctx.accessibleStatuses.length > 0 && (!item.status || !this.ctx.accessibleStatuses.includes(item.status))) return null;
+		return item;
+	}
+};
+function applyGetListOptions(items, opts) {
+	if (!opts) return items;
+	let result = items;
+	if (opts.statuses && opts.statuses.length > 0) {
+		const allow = new Set(opts.statuses);
+		result = result.filter((it) => it.status !== void 0 && allow.has(it.status));
+	}
+	if (opts.tag) {
+		const tag = opts.tag;
+		result = result.filter((it) => {
+			const tags = it.tags;
+			return Array.isArray(tags) && tags.includes(tag);
+		});
+	}
+	if (opts.where) {
+		const where = opts.where;
+		result = result.filter((it) => Object.entries(where).every(([key, value]) => it[key] === value));
+	}
+	if (opts.sort) result = [...result].sort(makeComparator(opts.sort));
+	const skip = opts.skip ?? 0;
+	const limit = opts.limit;
+	if (skip > 0 || limit !== void 0) result = result.slice(skip, limit !== void 0 ? skip + limit : void 0);
+	return result;
+}
+function makeComparator(sort) {
+	const by = sort.by;
+	const dir = sort.direction === "asc" ? 1 : -1;
+	return (a, b) => {
+		const av = a[by];
+		const bv = b[by];
+		if (av === bv) return 0;
+		if (av === void 0) return 1;
+		if (bv === void 0) return -1;
+		return av > bv ? dir : -dir;
+	};
+}
+//#endregion
+//#region src/handler.ts
+const DEFAULT_OPTS = {
+	basePath: "/api/cms",
+	imagesPath: "/images",
+	revalidatePath: "/revalidate"
+};
+/**
+* Web Standard な Request → Response ルーター。
+* Next.js / React Router / Hono / Cloudflare Workers いずれでも使える。
+*
+* ルート:
+* - GET  `{basePath}/images/:hash` — 画像プロキシ
+* - POST `{basePath}/revalidate`   — Webhook 受信 + $revalidate()
+*/
+function createHandler(adapter, opts = {}) {
+	const basePath = trimTrailingSlash(opts.basePath ?? DEFAULT_OPTS.basePath);
+	const imagesPath = opts.imagesPath ?? DEFAULT_OPTS.imagesPath;
+	const revalidatePath = opts.revalidatePath ?? DEFAULT_OPTS.revalidatePath;
+	return async (req) => {
+		const path = new URL(req.url).pathname;
+		if (!path.startsWith(basePath)) return new Response("Not Found", { status: 404 });
+		const rel = path.slice(basePath.length) || "/";
+		if (req.method === "GET" && rel.startsWith(`${imagesPath}/`)) {
+			const hash = rel.slice(imagesPath.length + 1);
+			if (!hash) return new Response("Bad Request", { status: 400 });
+			const object = await adapter.imageCache.get(hash);
+			if (!object) return new Response("Not Found", { status: 404 });
+			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 });
+		}
+		if (req.method === "POST" && rel === revalidatePath) {
+			const scope = await adapter.parseWebhook(req, opts.webhookSecret);
+			if (!scope) return new Response(JSON.stringify({
+				ok: false,
+				reason: "invalid"
+			}), {
+				status: 400,
+				headers: { "content-type": "application/json" }
+			});
+			await adapter.revalidate(scope);
+			return new Response(JSON.stringify({
+				ok: true,
+				scope
+			}), {
+				status: 200,
+				headers: { "content-type": "application/json" }
+			});
+		}
+		return new Response("Not Found", { status: 404 });
+	};
+}
+function trimTrailingSlash(s) {
+	return s.endsWith("/") ? s.slice(0, -1) : s;
+}
+//#endregion
+//#region src/cms.ts
+const DEFAULT_IMAGE_PROXY_BASE = "/api/images";
+function resolveDocumentCache(cache) {
+	if (!cache || cache === "disabled" || !cache.document) return noopDocumentCache();
+	return cache.document;
+}
+function resolveImageCache(cache) {
+	if (!cache || cache === "disabled" || !cache.image) return noopImageCache();
+	return cache.image;
+}
+function resolveTtl(cache) {
+	if (!cache || cache === "disabled") return void 0;
+	return cache.ttlMs;
+}
+function hasImageCacheConfigured(cache) {
+	if (!cache || cache === "disabled") return false;
+	return !!cache.image;
+}
+/**
+* `{collection}:{slug}` キー空間で動作するコレクション別キャッシュビューを生成する。
+* 単一の `DocumentCacheAdapter` に複数コレクションを同居させるためのアダプタ。
+*/
+function scopeDocumentCache(base, collection) {
+	const itemKey = (slug) => `${collection}:${slug}`;
+	const listKey = collection;
+	return {
+		name: `${base.name}@${collection}`,
+		async getList() {
+			const anyBase = base;
+			if (typeof anyBase.getListByKey === "function") return anyBase.getListByKey(listKey);
+			return base.getList();
+		},
+		async setList(data) {
+			const anyBase = base;
+			if (typeof anyBase.setListByKey === "function") return anyBase.setListByKey(listKey, data);
+			return base.setList(data);
+		},
+		async getItem(slug) {
+			const anyBase = base;
+			if (typeof anyBase.getItemByKey === "function") return anyBase.getItemByKey(itemKey(slug));
+			return base.getItem(slug);
+		},
+		async setItem(slug, data) {
+			const anyBase = base;
+			if (typeof anyBase.setItemByKey === "function") return anyBase.setItemByKey(itemKey(slug), data);
+			return base.setItem(slug, data);
+		},
+		async invalidate(scope) {
+			if (!base.invalidate) return;
+			if (scope === "all") return base.invalidate({ collection });
+			if ("slug" in scope && !("collection" in scope)) return base.invalidate({
+				collection,
+				slug: scope.slug
+			});
+			return base.invalidate(scope);
+		}
+	};
+}
+/**
+* 複数の DataSource を束ねた CMS クライアントを生成する。
+*
+* @example
+* const cms = createCMS({
+*   dataSources: {
+*     posts: createNotionCollection({ token, databaseId, schema }),
+*   },
+*   cache: { document, image, ttlMs: 60_000 },
+* });
+* const post = await cms.posts.getItem("my-slug");
+*/
+function createCMS(opts) {
+	if (!opts.dataSources || Object.keys(opts.dataSources).length === 0) throw new Error("createCMS: dataSources に少なくとも1つのコレクションを指定してください。");
+	const baseDocCache = resolveDocumentCache(opts.cache);
+	const imgCache = resolveImageCache(opts.cache);
+	const hasImageCache = hasImageCacheConfigured(opts.cache);
+	const ttlMs = resolveTtl(opts.cache);
+	const imageProxyBase = opts.content?.imageProxyBase ?? DEFAULT_IMAGE_PROXY_BASE;
+	const contentConfig = opts.content;
+	const rendererFn = opts.renderer;
+	const waitUntil = opts.waitUntil;
+	const logger = mergeLoggers(opts.plugins ?? [], opts.logger);
+	const hooks = mergeHooks(opts.plugins ?? [], opts.hooks, logger);
+	const maxConcurrent = opts.rateLimiter?.maxConcurrent ?? 3;
+	const retryConfig = {
+		...DEFAULT_RETRY_CONFIG,
+		...opts.rateLimiter ?? {}
+	};
+	const collectionNames = Object.keys(opts.dataSources);
+	const collections = {};
+	for (const name of collectionNames) {
+		const source = opts.dataSources[name];
+		collections[name] = new CollectionClientImpl({
+			collection: name,
+			source,
+			docCache: scopeDocumentCache(baseDocCache, name),
+			render: {
+				source,
+				rendererFn,
+				imgCache,
+				hasImageCache,
+				imageProxyBase,
+				contentConfig,
+				hooks,
+				logger
+			},
+			hooks,
+			logger,
+			ttlMs,
+			publishedStatuses: source.publishedStatuses ? [...source.publishedStatuses] : [],
+			accessibleStatuses: source.accessibleStatuses ? [...source.accessibleStatuses] : [],
+			retryConfig,
+			maxConcurrent,
+			waitUntil
+		});
+	}
+	const globalOps = {
+		$collections: collectionNames,
+		async $revalidate(scope) {
+			if (!baseDocCache.invalidate) return;
+			await baseDocCache.invalidate(scope ?? "all");
+		},
+		$handler(handlerOpts) {
+			return createHandler({
+				imageCache: imgCache,
+				parseWebhook: async (req, webhookSecret) => {
+					for (const name of collectionNames) {
+						const ds = opts.dataSources[name];
+						if (ds.parseWebhook) try {
+							return await ds.parseWebhook(req.clone(), { secret: webhookSecret });
+						} catch (err) {
+							logger?.warn?.("parseWebhook 失敗", {
+								collection: name,
+								error: err instanceof Error ? err.message : String(err)
+							});
+						}
+					}
+					try {
+						const body = await req.json();
+						if (body.slug && body.collection) return {
+							collection: body.collection,
+							slug: body.slug
+						};
+						if (body.collection) return { collection: body.collection };
+					} catch {}
+					return null;
+				},
+				revalidate: (scope) => globalOps.$revalidate(scope)
+			}, handlerOpts);
+		},
+		$getCachedImage(hash) {
+			return imgCache.get(hash);
+		}
+	};
+	return Object.assign(Object.create(null), collections, globalOps);
+}
+//#endregion
+//#region src/types/plugin.ts
+function definePlugin(plugin) {
+	return plugin;
+}
+//#endregion
+export { CMSError, CollectionClientImpl, DEFAULT_RETRY_CONFIG, collectionKey, createCMS, createHandler, definePlugin, isCMSError, isCMSErrorInNamespace, isStale, memoryCache, memoryDocumentCache, memoryImageCache, mergeHooks, mergeLoggers, noopDocumentCache, noopImageCache, sha256Hex, withRetry };
+
+//# sourceMappingURL=index.mjs.map