@btst/stack 2.7.0 → 2.8.1

package/src/plugins/comments/client/index.ts

@@ -0,0 +1,14 @@
+export {
+	commentsClientPlugin,
+	type CommentsClientConfig,
+	type CommentsClientHooks,
+	type LoaderContext,
+} from "./plugin";
+export {
+	type CommentsPluginOverrides,
+	type RouteContext,
+} from "./overrides";
+export {
+	COMMENTS_LOCALIZATION,
+	type CommentsLocalization,
+} from "./localization";

package/src/plugins/comments/client/localization/comments-moderation.ts

@@ -0,0 +1,75 @@
+export const COMMENTS_MODERATION = {
+	COMMENTS_MODERATION_TITLE: "Comment Moderation",
+	COMMENTS_MODERATION_DESCRIPTION:
+		"Review and manage comments across all resources.",
+
+	COMMENTS_MODERATION_TAB_PENDING: "Pending",
+	COMMENTS_MODERATION_TAB_APPROVED: "Approved",
+	COMMENTS_MODERATION_TAB_SPAM: "Spam",
+
+	COMMENTS_MODERATION_SELECTED: "{n} selected",
+	COMMENTS_MODERATION_APPROVE_SELECTED: "Approve selected",
+	COMMENTS_MODERATION_DELETE_SELECTED: "Delete selected",
+	COMMENTS_MODERATION_EMPTY: "No {status} comments.",
+
+	COMMENTS_MODERATION_COL_AUTHOR: "Author",
+	COMMENTS_MODERATION_COL_COMMENT: "Comment",
+	COMMENTS_MODERATION_COL_RESOURCE: "Resource",
+	COMMENTS_MODERATION_COL_DATE: "Date",
+	COMMENTS_MODERATION_COL_ACTIONS: "Actions",
+	COMMENTS_MODERATION_SELECT_ALL: "Select all",
+	COMMENTS_MODERATION_SELECT_ONE: "Select comment",
+
+	COMMENTS_MODERATION_ACTION_VIEW: "View",
+	COMMENTS_MODERATION_ACTION_APPROVE: "Approve",
+	COMMENTS_MODERATION_ACTION_SPAM: "Mark as spam",
+	COMMENTS_MODERATION_ACTION_DELETE: "Delete",
+
+	COMMENTS_MODERATION_TOAST_APPROVED: "Comment approved",
+	COMMENTS_MODERATION_TOAST_APPROVE_ERROR: "Failed to approve comment",
+	COMMENTS_MODERATION_TOAST_SPAM: "Marked as spam",
+	COMMENTS_MODERATION_TOAST_SPAM_ERROR: "Failed to update status",
+	COMMENTS_MODERATION_TOAST_DELETED: "Comment deleted",
+	COMMENTS_MODERATION_TOAST_DELETED_PLURAL: "{n} comments deleted",
+	COMMENTS_MODERATION_TOAST_DELETE_ERROR: "Failed to delete comment(s)",
+	COMMENTS_MODERATION_TOAST_BULK_APPROVED: "{n} comment(s) approved",
+	COMMENTS_MODERATION_TOAST_BULK_APPROVE_ERROR: "Failed to approve comments",
+
+	COMMENTS_MODERATION_DIALOG_TITLE: "Comment Details",
+	COMMENTS_MODERATION_DIALOG_RESOURCE: "Resource",
+	COMMENTS_MODERATION_DIALOG_LIKES: "Likes",
+	COMMENTS_MODERATION_DIALOG_REPLY_TO: "Reply to",
+	COMMENTS_MODERATION_DIALOG_EDITED: "Edited",
+	COMMENTS_MODERATION_DIALOG_BODY: "Body",
+	COMMENTS_MODERATION_DIALOG_APPROVE: "Approve",
+	COMMENTS_MODERATION_DIALOG_MARK_SPAM: "Mark spam",
+	COMMENTS_MODERATION_DIALOG_DELETE: "Delete",
+
+	COMMENTS_MODERATION_DELETE_TITLE_SINGULAR: "Delete comment?",
+	COMMENTS_MODERATION_DELETE_TITLE_PLURAL: "Delete {n} comments?",
+	COMMENTS_MODERATION_DELETE_DESCRIPTION_SINGULAR:
+		"This action cannot be undone. The comment will be permanently deleted.",
+	COMMENTS_MODERATION_DELETE_DESCRIPTION_PLURAL:
+		"This action cannot be undone. The comments will be permanently deleted.",
+	COMMENTS_MODERATION_DELETE_CANCEL: "Cancel",
+	COMMENTS_MODERATION_DELETE_CONFIRM: "Delete",
+	COMMENTS_MODERATION_DELETE_DELETING: "Deleting…",
+
+	COMMENTS_MODERATION_PAGINATION_PREVIOUS: "Previous",
+	COMMENTS_MODERATION_PAGINATION_NEXT: "Next",
+	COMMENTS_MODERATION_PAGINATION_SHOWING: "Showing {from}–{to} of {total}",
+
+	COMMENTS_RESOURCE_TITLE: "Comments",
+	COMMENTS_RESOURCE_PENDING_SECTION: "Pending Review",
+	COMMENTS_RESOURCE_THREAD_SECTION: "Thread",
+	COMMENTS_RESOURCE_ACTION_APPROVE: "Approve",
+	COMMENTS_RESOURCE_ACTION_SPAM: "Spam",
+	COMMENTS_RESOURCE_ACTION_DELETE: "Delete",
+	COMMENTS_RESOURCE_DELETE_CONFIRM: "Delete this comment?",
+	COMMENTS_RESOURCE_TOAST_APPROVED: "Comment approved",
+	COMMENTS_RESOURCE_TOAST_APPROVE_ERROR: "Failed to approve",
+	COMMENTS_RESOURCE_TOAST_SPAM: "Marked as spam",
+	COMMENTS_RESOURCE_TOAST_SPAM_ERROR: "Failed to update",
+	COMMENTS_RESOURCE_TOAST_DELETED: "Comment deleted",
+	COMMENTS_RESOURCE_TOAST_DELETE_ERROR: "Failed to delete",
+};

package/src/plugins/comments/client/localization/comments-my.ts

@@ -0,0 +1,32 @@
+export const COMMENTS_MY = {
+	COMMENTS_MY_LOGIN_TITLE: "Please log in to view your comments",
+	COMMENTS_MY_LOGIN_DESCRIPTION:
+		"You need to be logged in to see your comment history.",
+
+	COMMENTS_MY_EMPTY_TITLE: "No comments yet",
+	COMMENTS_MY_EMPTY_DESCRIPTION: "Comments you post will appear here.",
+
+	COMMENTS_MY_PAGE_TITLE: "My Comments",
+
+	COMMENTS_MY_COL_COMMENT: "Comment",
+	COMMENTS_MY_COL_RESOURCE: "Resource",
+	COMMENTS_MY_COL_STATUS: "Status",
+	COMMENTS_MY_COL_DATE: "Date",
+
+	COMMENTS_MY_REPLY_INDICATOR: "↩ Reply",
+	COMMENTS_MY_VIEW_LINK: "View",
+
+	COMMENTS_MY_STATUS_APPROVED: "Approved",
+	COMMENTS_MY_STATUS_PENDING: "Pending",
+	COMMENTS_MY_STATUS_SPAM: "Spam",
+
+	COMMENTS_MY_TOAST_DELETED: "Comment deleted",
+	COMMENTS_MY_TOAST_DELETE_ERROR: "Failed to delete comment",
+
+	COMMENTS_MY_DELETE_TITLE: "Delete comment?",
+	COMMENTS_MY_DELETE_DESCRIPTION:
+		"This action cannot be undone. The comment will be permanently removed.",
+	COMMENTS_MY_DELETE_CANCEL: "Cancel",
+	COMMENTS_MY_DELETE_CONFIRM: "Delete",
+	COMMENTS_MY_DELETE_BUTTON_SR: "Delete comment",
+};

package/src/plugins/comments/client/localization/comments-thread.ts

@@ -0,0 +1,32 @@
+export const COMMENTS_THREAD = {
+	COMMENTS_TITLE: "Comments",
+	COMMENTS_EMPTY: "Be the first to comment.",
+
+	COMMENTS_EDITED_BADGE: "(edited)",
+	COMMENTS_PENDING_BADGE: "Pending approval",
+
+	COMMENTS_LIKE_ARIA: "Like",
+	COMMENTS_UNLIKE_ARIA: "Unlike",
+	COMMENTS_REPLY_BUTTON: "Reply",
+	COMMENTS_EDIT_BUTTON: "Edit",
+	COMMENTS_DELETE_BUTTON: "Delete",
+	COMMENTS_SAVE_EDIT: "Save",
+
+	COMMENTS_REPLIES_SINGULAR: "reply",
+	COMMENTS_REPLIES_PLURAL: "replies",
+	COMMENTS_HIDE_REPLIES: "Hide replies",
+	COMMENTS_DELETE_CONFIRM: "Delete this comment?",
+
+	COMMENTS_LOGIN_PROMPT: "Please sign in to leave a comment.",
+	COMMENTS_LOGIN_LINK: "Sign in",
+
+	COMMENTS_FORM_PLACEHOLDER: "Write a comment…",
+	COMMENTS_FORM_CANCEL: "Cancel",
+	COMMENTS_FORM_POST_COMMENT: "Post comment",
+	COMMENTS_FORM_POST_REPLY: "Post reply",
+	COMMENTS_FORM_POSTING: "Posting…",
+	COMMENTS_FORM_SUBMIT_ERROR: "Failed to submit comment",
+
+	COMMENTS_LOAD_MORE: "Load more comments",
+	COMMENTS_LOADING_MORE: "Loading…",
+};

package/src/plugins/comments/client/localization/index.ts

@@ -0,0 +1,11 @@
+import { COMMENTS_THREAD } from "./comments-thread";
+import { COMMENTS_MODERATION } from "./comments-moderation";
+import { COMMENTS_MY } from "./comments-my";
+
+export const COMMENTS_LOCALIZATION = {
+	...COMMENTS_THREAD,
+	...COMMENTS_MODERATION,
+	...COMMENTS_MY,
+};
+
+export type CommentsLocalization = typeof COMMENTS_LOCALIZATION;

package/src/plugins/comments/client/overrides.ts

@@ -0,0 +1,164 @@
+/**
+ * Context passed to lifecycle hooks
+ */
+export interface RouteContext {
+	/** Current route path */
+	path: string;
+	/** Route parameters (e.g., { resourceId: "my-post", resourceType: "blog-post" }) */
+	params?: Record<string, string>;
+	/** Whether rendering on server (true) or client (false) */
+	isSSR: boolean;
+	/** Additional context properties */
+	[key: string]: unknown;
+}
+
+import type { CommentsLocalization } from "./localization";
+
+/**
+ * Overridable configuration and hooks for the Comments plugin.
+ *
+ * Provide these in the layout wrapping your pages via `PluginOverridesProvider`.
+ */
+export interface CommentsPluginOverrides {
+	/**
+	 * Localization strings for all Comments plugin UI.
+	 * Defaults to English when not provided.
+	 */
+	localization?: Partial<CommentsLocalization>;
+	/**
+	 * Base URL for API calls (e.g., "https://example.com")
+	 */
+	apiBaseURL: string;
+
+	/**
+	 * Path where the API is mounted (e.g., "/api/data")
+	 */
+	apiBasePath: string;
+
+	/**
+	 * Optional headers for authenticated API calls (e.g., forwarding cookies)
+	 */
+	headers?: Record<string, string>;
+
+	/**
+	 * Whether to show the "Powered by BTST" attribution on plugin pages.
+	 * Defaults to true.
+	 */
+	showAttribution?: boolean;
+
+	/**
+	 * The ID of the currently authenticated user.
+	 *
+	 * Used by the User Comments page and the per-resource comments admin view to
+	 * scope the comment list to the current user and to enable posting.
+	 * Can be a static string or an async function (useful when the user ID must
+	 * be resolved from a session cookie at render time).
+	 *
+	 * When absent both pages show a "Please log in" prompt.
+	 */
+	currentUserId?:
+		| string
+		| (() => string | undefined | Promise<string | undefined>);
+
+	/**
+	 * URL to redirect unauthenticated users to when they try to post a comment.
+	 *
+	 * Forwarded to every embedded `CommentThread` (including the one on the
+	 * per-resource admin comments view). When absent no login link is shown.
+	 */
+	loginHref?: string;
+
+	/**
+	 * Default number of top-level comments to load per page in `CommentThread`.
+	 * Can be overridden per-instance via the `pageSize` prop.
+	 * Defaults to 100 when not set.
+	 */
+	defaultCommentPageSize?: number;
+
+	/**
+	 * When false, the comment form and reply buttons are hidden in all
+	 * `CommentThread` instances. Users can still read existing comments.
+	 * Defaults to true.
+	 *
+	 * Can be overridden per-instance via the `allowPosting` prop on `CommentThread`.
+	 */
+	allowPosting?: boolean;
+
+	/**
+	 * When false, the edit button is hidden on all comment cards in all
+	 * `CommentThread` instances.
+	 * Defaults to true.
+	 *
+	 * Can be overridden per-instance via the `allowEditing` prop on `CommentThread`.
+	 */
+	allowEditing?: boolean;
+
+	/**
+	 * Per-resource-type URL builders used to link each comment back to its
+	 * original resource on the User Comments page.
+	 *
+	 * @example
+	 * ```ts
+	 * resourceLinks: {
+	 *   "blog-post": (slug) => `/pages/blog/${slug}`,
+	 *   "kanban-task": (id) => `/pages/kanban?task=${id}`,
+	 * }
+	 * ```
+	 *
+	 * When a resource type has no entry the ID is shown as plain text.
+	 */
+	resourceLinks?: Record<string, (id: string) => string>;
+
+	// ============ Access Control Hooks ============
+
+	/**
+	 * Called before the moderation dashboard page is rendered.
+	 * Return false to block rendering (e.g., redirect to login or show 403).
+	 * @param context - Route context
+	 */
+	onBeforeModerationPageRendered?: (context: RouteContext) => boolean;
+
+	/**
+	 * Called before the per-resource comments page is rendered.
+	 * Return false to block rendering (e.g., for authorization).
+	 * @param resourceType - The type of resource (e.g., "blog-post")
+	 * @param resourceId - The ID of the resource
+	 * @param context - Route context
+	 */
+	onBeforeResourceCommentsRendered?: (
+		resourceType: string,
+		resourceId: string,
+		context: RouteContext,
+	) => boolean;
+
+	/**
+	 * Called before the User Comments page is rendered.
+	 * Throw to block rendering (e.g., when the user is not authenticated).
+	 * @param context - Route context
+	 */
+	onBeforeUserCommentsPageRendered?: (context: RouteContext) => boolean | void;
+
+	// ============ Lifecycle Hooks ============
+
+	/**
+	 * Called when a route is rendered.
+	 * @param routeName - Name of the route (e.g., 'moderation', 'resourceComments')
+	 * @param context - Route context
+	 */
+	onRouteRender?: (
+		routeName: string,
+		context: RouteContext,
+	) => void | Promise<void>;
+
+	/**
+	 * Called when a route encounters an error.
+	 * @param routeName - Name of the route
+	 * @param error - The error that occurred
+	 * @param context - Route context
+	 */
+	onRouteError?: (
+		routeName: string,
+		error: Error,
+		context: RouteContext,
+	) => void | Promise<void>;
+}

package/src/plugins/comments/client/plugin.tsx

@@ -0,0 +1,195 @@
+// NO "use client" here! This file runs on both server and client.
+import { lazy } from "react";
+import {
+	defineClientPlugin,
+	isConnectionError,
+} from "@btst/stack/plugins/client";
+import { createRoute } from "@btst/yar";
+import type { QueryClient } from "@tanstack/react-query";
+
+// Lazy load page components for code splitting
+const ModerationPageComponent = lazy(() =>
+	import("./components/pages/moderation-page").then((m) => ({
+		default: m.ModerationPageComponent,
+	})),
+);
+
+const UserCommentsPageComponent = lazy(() =>
+	import("./components/pages/my-comments-page").then((m) => ({
+		default: m.UserCommentsPageComponent,
+	})),
+);
+
+/**
+ * Context passed to loader hooks
+ */
+export interface LoaderContext {
+	/** Current route path */
+	path: string;
+	/** Route parameters */
+	params?: Record<string, string>;
+	/** Whether rendering on server (true) or client (false) */
+	isSSR: boolean;
+	/** Base URL for API calls */
+	apiBaseURL: string;
+	/** Path where the API is mounted */
+	apiBasePath: string;
+	/** Optional headers for the request */
+	headers?: Headers;
+	/** Additional context properties */
+	[key: string]: unknown;
+}
+
+/**
+ * Hooks for Comments client plugin
+ */
+export interface CommentsClientHooks {
+	/**
+	 * Called before loading the moderation page. Throw to cancel.
+	 */
+	beforeLoadModeration?: (context: LoaderContext) => Promise<void> | void;
+	/**
+	 * Called before loading the User Comments page. Throw to cancel.
+	 */
+	beforeLoadUserComments?: (context: LoaderContext) => Promise<void> | void;
+	/**
+	 * Called when a loading error occurs.
+	 */
+	onLoadError?: (error: Error, context: LoaderContext) => Promise<void> | void;
+}
+
+/**
+ * Configuration for the Comments client plugin
+ */
+export interface CommentsClientConfig {
+	/** Base URL for API calls (e.g., "http://localhost:3000") */
+	apiBaseURL: string;
+	/** Path where the API is mounted (e.g., "/api/data") */
+	apiBasePath: string;
+	/** Base URL of your site */
+	siteBaseURL: string;
+	/** Path where pages are mounted (e.g., "/pages") */
+	siteBasePath: string;
+	/** React Query client instance */
+	queryClient: QueryClient;
+	/** Optional headers for SSR */
+	headers?: Headers;
+	/** Optional lifecycle hooks */
+	hooks?: CommentsClientHooks;
+}
+
+function createModerationLoader(config: CommentsClientConfig) {
+	return async () => {
+		if (typeof window === "undefined") {
+			const { apiBasePath, apiBaseURL, headers, hooks } = config;
+			const context: LoaderContext = {
+				path: "/comments/moderation",
+				isSSR: true,
+				apiBaseURL,
+				apiBasePath,
+				headers,
+			};
+			try {
+				if (hooks?.beforeLoadModeration) {
+					await hooks.beforeLoadModeration(context);
+				}
+			} catch (error) {
+				if (isConnectionError(error)) {
+					console.warn(
+						"[btst/comments] route.loader() failed — no server running at build time.",
+					);
+				}
+				if (hooks?.onLoadError) {
+					await hooks.onLoadError(error as Error, context);
+				}
+			}
+		}
+	};
+}
+
+function createUserCommentsLoader(config: CommentsClientConfig) {
+	return async () => {
+		if (typeof window === "undefined") {
+			const { apiBasePath, apiBaseURL, headers, hooks } = config;
+			const context: LoaderContext = {
+				path: "/comments",
+				isSSR: true,
+				apiBaseURL,
+				apiBasePath,
+				headers,
+			};
+			try {
+				if (hooks?.beforeLoadUserComments) {
+					await hooks.beforeLoadUserComments(context);
+				}
+			} catch (error) {
+				if (isConnectionError(error)) {
+					console.warn(
+						"[btst/comments] route.loader() failed — no server running at build time.",
+					);
+				}
+				if (hooks?.onLoadError) {
+					await hooks.onLoadError(error as Error, context);
+				}
+			}
+		}
+	};
+}
+
+function createCommentsRouteMeta(
+	config: CommentsClientConfig,
+	path: "/comments/moderation" | "/comments",
+	title: string,
+	description: string,
+) {
+	return () => {
+		const fullUrl = `${config.siteBaseURL}${config.siteBasePath}${path}`;
+		return [
+			{ title },
+			{ name: "title", content: title },
+			{ name: "description", content: description },
+			{ name: "robots", content: "noindex, nofollow" },
+			{ property: "og:title", content: title },
+			{ property: "og:description", content: description },
+			{ property: "og:url", content: fullUrl },
+			{ name: "twitter:card", content: "summary" },
+			{ name: "twitter:title", content: title },
+			{ name: "twitter:description", content: description },
+		];
+	};
+}
+
+/**
+ * Comments client plugin — registers admin moderation routes.
+ *
+ * The embeddable `CommentThread` and `CommentCount` components are standalone
+ * and do not require this plugin to be registered. Register them manually
+ * via the layout overrides pattern or use them directly in your pages.
+ */
+export const commentsClientPlugin = (config: CommentsClientConfig) =>
+	defineClientPlugin({
+		name: "comments",
+
+		routes: () => ({
+			moderation: createRoute("/comments/moderation", () => ({
+				PageComponent: ModerationPageComponent,
+				loader: createModerationLoader(config),
+				meta: createCommentsRouteMeta(
+					config,
+					"/comments/moderation",
+					"Comment Moderation",
+					"Review and manage comments across all resources.",
+				),
+			})),
+			userComments: createRoute("/comments", () => ({
+				PageComponent: UserCommentsPageComponent,
+				loader: createUserCommentsLoader(config),
+				meta: createCommentsRouteMeta(
+					config,
+					"/comments",
+					"User Comments",
+					"View and manage your comments across resources.",
+				),
+			})),
+		}),
+	});

package/src/plugins/comments/client/utils.ts

@@ -0,0 +1,67 @@
+import { useState, useEffect } from "react";
+import type { CommentsPluginOverrides } from "./overrides";
+
+/**
+ * Resolves `currentUserId` from the plugin overrides, supporting both a static
+ * string and a sync/async function. Returns `undefined` until resolution completes.
+ */
+export function useResolvedCurrentUserId(
+	raw: CommentsPluginOverrides["currentUserId"],
+): string | undefined {
+	const [resolved, setResolved] = useState<string | undefined>(
+		typeof raw === "string" ? raw : undefined,
+	);
+
+	useEffect(() => {
+		if (typeof raw === "function") {
+			void Promise.resolve(raw())
+				.then((id) => setResolved(id ?? undefined))
+				.catch((err: unknown) => {
+					console.error(
+						"[btst/comments] Failed to resolve currentUserId:",
+						err,
+					);
+				});
+		} else {
+			setResolved(raw ?? undefined);
+		}
+	}, [raw]);
+
+	return resolved;
+}
+
+/**
+ * Normalise any thrown value into an Error.
+ *
+ * Handles three shapes:
+ * 1. Already an Error — returned as-is.
+ * 2. A plain object — message is taken from `.message`, then `.error` (API
+ *    error-response shape), then JSON.stringify. All original properties are
+ *    copied onto the Error via Object.assign so callers can inspect them.
+ * 3. Anything else — converted via String().
+ */
+export function toError(error: unknown): Error {
+	if (error instanceof Error) return error;
+	if (typeof error === "object" && error !== null) {
+		const obj = error as Record<string, unknown>;
+		const message =
+			(typeof obj.message === "string" ? obj.message : null) ||
+			(typeof obj.error === "string" ? obj.error : null) ||
+			JSON.stringify(error);
+		const err = new Error(message);
+		Object.assign(err, error);
+		return err;
+	}
+	return new Error(String(error));
+}
+
+export function getInitials(name: string | null | undefined): string {
+	if (!name) return "?";
+	return name
+		.split(" ")
+		.filter(Boolean)
+		.slice(0, 2)
+		.map((n) => n[0])
+		.join("")
+		.toUpperCase();
+}

package/src/plugins/comments/client.css

@@ -0,0 +1,2 @@
+/* Comments Plugin Client CSS */
+/* No custom styles needed - uses shadcn/ui components */

package/src/plugins/comments/db.ts

@@ -0,0 +1,77 @@
+import { createDbPlugin } from "@btst/db";
+
+/**
+ * Comments plugin schema.
+ * Defines two tables:
+ * - comment: the main comment record (always authenticated, no anonymous)
+ * - commentLike: join table for per-user like deduplication
+ */
+export const commentsSchema = createDbPlugin("comments", {
+	comment: {
+		modelName: "comment",
+		fields: {
+			resourceId: {
+				type: "string",
+				required: true,
+			},
+			resourceType: {
+				type: "string",
+				required: true,
+			},
+			parentId: {
+				type: "string",
+				required: false,
+			},
+			authorId: {
+				type: "string",
+				required: true,
+			},
+			body: {
+				type: "string",
+				required: true,
+			},
+			status: {
+				type: "string",
+				defaultValue: "pending",
+			},
+			likes: {
+				type: "number",
+				defaultValue: 0,
+			},
+			editedAt: {
+				type: "date",
+				required: false,
+			},
+			createdAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+			updatedAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+	commentLike: {
+		modelName: "commentLike",
+		fields: {
+			commentId: {
+				type: "string",
+				required: true,
+				references: {
+					model: "comment",
+					field: "id",
+					onDelete: "cascade",
+				},
+			},
+			authorId: {
+				type: "string",
+				required: true,
+			},
+			createdAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+});