index.ts

/**
 * ┌─────────────────────────────────────────────────────────────────────────┐
 * │  THE CMS SEAM                                                             │
 * │                                                                          │
 * │  Everything above the application reads content through THIS module and  │
 * │  nowhere else. Today it returns local fixtures; to wire in a real        │
 * │  headless CMS (Contentful, Sanity, Hygraph, Strapi, ...) you replace the │
 * │  bodies of these functions with network calls and map the response onto  │
 * │  the types in `./types`. Run that mapped response through                │
 * │  `lib/contract/validate.ts` so schema drift is caught at the boundary.   │
 * │                                                                          │
 * │  The functions are async on purpose: a real CMS fetch returns a promise, │
 * │  and Server Components await it. Keeping the signatures async now means   │
 * │  swapping the implementation is the ONLY change required later.          │
 * │                                                                          │
 * │  See `lib/cms/adapters/contentful.ts` for a shape-mapping stub.          │
 * └─────────────────────────────────────────────────────────────────────────┘
 */
import type { Category, Content, Post, Product } from './types';
import { posts } from './fixtures/posts';
import { products } from './fixtures/products';
import { categories } from './fixtures/categories';

function isPublished<T extends { status: Content['status'] }>(record: T): boolean {
  return record.status === 'published';
}

/** A single published post by slug, or null. Drafts/archived resolve to null. */
export async function getPost(slug: string): Promise<Post | null> {
  return posts.find((post) => post.slug === slug && isPublished(post)) ?? null;
}

/** A single published product by handle, or null. */
export async function getProduct(handle: string): Promise<Product | null> {
  return products.find((product) => product.handle === handle && isPublished(product)) ?? null;
}

/** A single published category by slug, or null. */
export async function getCategory(slug: string): Promise<Category | null> {
  return categories.find((category) => category.slug === slug && isPublished(category)) ?? null;
}

export async function getPublishedPosts(): Promise<Post[]> {
  return posts.filter(isPublished);
}

export async function getPublishedProducts(): Promise<Product[]> {
  return products.filter(isPublished);
}

export async function getPublishedCategories(): Promise<Category[]> {
  return categories.filter(isPublished);
}

/**
 * Every published record across content types. This is the route source of
 * truth that `app/sitemap.ts` builds from.
 */
export async function getAllPublished(): Promise<Content[]> {
  const [p, pr, c] = await Promise.all([
    getPublishedPosts(),
    getPublishedProducts(),
    getPublishedCategories(),
  ]);
  return [...p, ...pr, ...c];
}

export type { Category, Content, Post, Product } from './types';