Blog Plugin

import { createBackendStack } from "@btst/stack/api"
import { blogBackendPlugin } from "@btst/stack/plugins/blog/api"
// ... your adapter imports

const { handler, dbSchema } = createBackendStack({
  basePath: "/api/data",
  plugins: {
    blog: blogBackendPlugin()
  },
  adapter: (db) => createPrismaAdapter(prisma, db, { 
    provider: "postgresql" 
  })
})

export { handler, dbSchema }

import { createClientStack } from "@btst/stack/client"
import { blogClientPlugin } from "@btst/stack/plugins/blog/client"
import { QueryClient } from "@tanstack/react-query"

const getBaseURL = () =>
  typeof window !== "undefined"
    ? window.location.origin
    : process.env.BASE_URL || "http://localhost:3000"

export const getStackClient = (
  queryClient: QueryClient,
  options?: { headers?: HeadersInit },
) => {
  const baseURL = getBaseURL()
  return createClientStack({
    api: {
      baseURL,
      basePath: "/api/data",
      headers: options?.headers,
    },
    site: { baseURL, basePath: "/pages" },
    queryClient,
    plugins: {
      blog: blogClientPlugin({
        seo: {
          siteName: "My Blog",
          author: "Your Name",
          twitterHandle: "@yourhandle",
          locale: "en_US",
          defaultImage: `${baseURL}/og-image.png`,
        },
      })
    }
  })
}

@import "@btst/stack/plugins/blog/css";

npx @btst/cli generate --orm prisma --config lib/stack.ts  --output prisma/schema.prisma

blogClientPlugin({
  // ... other config
  pageComponents: {
    // Replace the published posts list page
    posts: MyCustomPostsPage,
    // Replace the single post page — receives the route context as props
    post: ({ params }) => <MyCustomPostPage slug={params.slug} />,
    // Replace the edit post page — receives the route context as props
    editPost: ({ params }) => <MyCustomEditPage slug={params.slug} />,
    // Replace the tag page — receives the route context as props
    tag: ({ params }) => <MyCustomTagPage tagSlug={params.tagSlug} />,
    // Replace the drafts list page
    drafts: MyCustomDraftsPage,
    // Replace the new post page
    newPost: MyCustomNewPostPage,
  },
})

import { defineAuthorization } from "@btst/stack/authorization";
import { blogPermissions } from "@btst/stack/plugins/blog/permissions";
import { z } from "zod";

export const authorization = defineAuthorization({
  identity: z.object({
    id: z.string(),
    role: z.enum(["user", "admin"]),
  }),
  permissions: [blogPermissions] as const,
  rules: ({ blog }) => [
    blog.post.read.when(({ identity, facts }) => {
      if (facts.scope === "published") return true;
      if (facts.scope === "post" && (!facts.exists || facts.published)) return true;
      return identity?.role === "admin" ||
        (facts.scope === "post" && identity?.id === facts.authorId);
    }),
    blog.post.create.when(({ identity, facts }) =>
      identity !== null &&
      (facts.publish === "draft" || identity.role === "admin")
    ),
    blog.post.update.when(({ identity, facts }) =>
      identity !== null &&
      (identity.role === "admin" ||
        (identity.id === facts.authorId && facts.publish === "unchanged"))
    ),
    blog.post.delete.when(({ identity, facts }) =>
      identity !== null &&
      (identity.role === "admin" || identity.id === facts.authorId)
    ),
    blog.tag.read.allow(),
  ],
});

import { blogBackendPlugin, type BlogBackendHooks } from "@btst/stack/plugins/blog/api"

const blogHooks: BlogBackendHooks = {
  async onBeforeDeletePost(postId, context) {
    if (isProtectedPost(postId))
      throw new Error("Protected posts cannot be deleted")
    auditDeleteAttempt(context.identity?.id, context.facts)
  },
  async onAfterUpdatePost(post, context) {
    await auditPostChange({
      actorId: context.identity?.id,
      postId: post.id,
      publishTransition: context.facts.publish,
    })
  },
}

const { handler, dbSchema } = createBackendStack({
  plugins: {
    blog: blogBackendPlugin({ hooks: blogHooks })
  },
  // ...
})

createClientStack({
  api: { baseURL, basePath: "/api/data", headers: options?.headers },
  site: { baseURL, basePath: "/pages" },
  queryClient,
  plugins: {
    blog: blogClientPlugin({
      seo: {
        siteName: "My Awesome Blog",
        author: "John Doe",
        twitterHandle: "@johndoe",
        locale: "en_US",
        defaultImage: `${baseURL}/og-image.png`,
      },
    }),
  },
})

blog: blogClientPlugin({
  hooks: {
    beforeLoadPosts: async (filter, context) => {
      performance.mark(`blog:list:${filter.published ? "published" : "drafts"}`)
    },
    afterLoadPost: async (post, slug, context) => {
      analytics.track("Blog post loaded", { slug, path: context.path })
    },
    onErrorLoad(error, context) {
      reportError(error, { path: context.path })
    },
  }
})

overrides={{
  blog: {
    uploadImage: async (file) => {
      // Implement your image upload logic
      return "https://example.com/uploads/image.jpg"
    },
    onRouteRender: (routeName, context) => {
      // Track page views
    },
  }
}}

import { CommentThread } from "@btst/stack/plugins/comments/client/components"

overrides={{
  blog: {
    // ...
    postBottomSlot: (post) => (
      <CommentThread
        resourceId={post.slug}
        resourceType="blog-post"
      />
    ),
  }
}}

const blog = myStack.forRequest(request).operations.blog;

const published = await blog.listPosts({ published: true });
const post = await blog.createPost({
  title: "Operation-first Blog",
  content: "...",
  excerpt: "...",
  published: false,
  tags: [],
});
await blog.updatePost({
  id: post.id,
  data: { ...post, title: "Updated", tags: [] },
});
await blog.deletePost({ id: post.id });

await myStack.trusted.blog.updatePost({
  id: postId,
  data: update,
});

import { dehydrate, HydrationBoundary } from "@tanstack/react-query"
import { getOrCreateQueryClient } from "@/lib/query-client"
import { getStackClient } from "@/lib/stack-client"
import { myStack } from "@/lib/stack"
import { metaElementsToObject, normalizePath } from "@btst/stack/client"
import type { Metadata } from "next"

// Opt into SSG — Next.js generates this page at build time
export async function generateStaticParams() {
  return [{}]
}

// export const revalidate = 3600 // uncomment for ISR (1 hour)

export async function generateMetadata(): Promise<Metadata> {
  const queryClient = getOrCreateQueryClient()
  const stackClient = getStackClient(queryClient)
  const route = stackClient.router.getRoute(normalizePath(["blog"]))
  if (!route) return { title: "Blog" }
  await myStack.raw.blog.prefetchForRoute("posts", queryClient)
  return metaElementsToObject(route.meta?.() ?? []) satisfies Metadata
}

export default async function BlogListPage() {
  const queryClient = getOrCreateQueryClient()
  const stackClient = getStackClient(queryClient)
  const route = stackClient.router.getRoute(normalizePath(["blog"]))
  if (!route) return null
  // Reads directly from DB — works at build time, no HTTP server required
  await myStack.raw.blog.prefetchForRoute("posts", queryClient)
  return (
    <HydrationBoundary state={dehydrate(queryClient)}>
      <route.PageComponent />
    </HydrationBoundary>
  )
}

export async function generateStaticParams() {
  const { items } = await myStack.trusted.blog.listPosts({ published: true, limit: 1000 })
  return items.map((p) => ({ slug: p.slug }))
}

export default async function BlogPostPage({ params }: { params: { slug: string } }) {
  const queryClient = getOrCreateQueryClient()
  const stackClient = getStackClient(queryClient)
  const route = stackClient.router.getRoute(normalizePath(["blog", params.slug]))
  if (!route) return null
  await myStack.raw.blog.prefetchForRoute("post", queryClient, { slug: params.slug })
  return (
    <HydrationBoundary state={dehydrate(queryClient)}>
      <route.PageComponent />
    </HydrationBoundary>
  )
}

import { revalidatePath } from "next/cache"
import type { BlogBackendHooks } from "@btst/stack/plugins/blog"

const blogHooks: BlogBackendHooks = {
  onAfterCreatePost: async (post) => {
    revalidatePath("/blog")
    revalidatePath(`/blog/${post.slug}`)
  },
  onAfterUpdatePost: async (post) => {
    revalidatePath("/blog")
    revalidatePath(`/blog/${post.slug}`)
  },
  onAfterDeletePost: async (postId) => {
    revalidatePath("/blog")
  },
}

import { blogClientPlugin } from "@btst/stack/plugins/blog/client"
// Import your ejected (and customized) page components
import { HomePageComponent } from "@/components/btst/blog/client/components/pages/home-page"
import { PostPageComponent } from "@/components/btst/blog/client/components/pages/post-page"

blogClientPlugin({
  pageComponents: {
    posts: HomePageComponent,       // replaces the published posts list page
    // Param routes receive the route context ({ params }) as props
    post: ({ params }) => <PostPageComponent slug={params.slug} />,
    // drafts, newPost, editPost, tag — omit to keep built-in defaults
  },
})