import { SelectPost } from "@/db/schema";

interface BlogPostProps {
  post: SelectPost;
}

export default function BlogPost({ post }: BlogPostProps) {

import { InferSelectModel, InferInsertModel, sql } from "drizzle-orm";
import { pgTable as table } from "drizzle-orm/pg-core";
import * as t from "drizzle-orm/pg-core";

const timestamps = {
  updatedAt: t.timestamp({ withTimezone: true, mode: "string" }),
  createdAt: t
    .timestamp({ withTimezone: true, mode: "string" })
    .defaultNow()
    .notNull(),
  deletedAt: t.timestamp({ withTimezone: true, mode: "string" }),
};

export const Post = table(
  "Post",
  {
    id: t.integer().primaryKey().generatedAlwaysAsIdentity(),
    title: t.text().notNull(),
    slug: t.text().notNull().unique(),
    excerpt: t.text().notNull(),
    author: t.text().notNull(),
    category: t.text().notNull(),
    tags: t
      .text()
      .array()
      .notNull()
      .default(sql`ARRAY[]::text[]`),
    readingTime: t.integer().notNull(),
    content: t.text().notNull(),
    components: t
      .text()
      .array()
      .notNull()
      .default(sql`ARRAY[]::text[]`),
    ...timestamps,
  },
  (table) => {
    return {
      slugIndex: t.uniqueIndex("slug_idx").on(table.slug),
      titleIndex: t.index("title_idx").on(table.title),
    };
  }
);

export type SelectPost = InferSelectModel<typeof Post>;
export type InsertPost = InferInsertModel<typeof Post>;

import "dotenv/config";
import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";

import * as schema from "@/db/schema";

const pool = new Pool({
  connectionString: process.env.DATABASE_URL!,
});

const db = drizzle(pool, {
  schema,
  logger: true,
});

// export type db = typeof db;

export default db;

pnpm run build

import { PaginationComponent } from "@/components/Pagination";
import { getBlogPosts } from "@/lib/blog";

export default async function BlogPage({
  params,
}: {
  params: { page: string };
}) {
  const { page } = await params;
  const currentPage = parseInt(page, 10) || 1;
  const { posts, totalPages } = await getBlogPosts(currentPage, 2);

  return (
    <div>
      {/* Render your blog posts here */}
      <ul className="flex flex-col gap-4">
        {posts.map((post, index) => (
          <li key={index}>
            <h2>{post.title}</h2>
            <p>{post.excerpt}</p>
            <p>Published on: {new Date(post.createdAt).toLocaleDateString()}</p>
            {post.updatedAt && (
              <p>Updated on: {new Date(post.updatedAt).toLocaleDateString()}</p>
            )}
            <p>Category: {post.category}</p>
            <p>Author: {post.author}</p>
            <p>Reading time: {post.readingTime}</p>
            <p>Tags: {post.tags.join(", ")}</p>
          </li>
        ))}
      </ul>

      <PaginationComponent
        currentPage={currentPage}
        totalPages={totalPages}
        maxPageNumbers={3}
      />
    </div>
  );
}

   Linting and checking validity of types  ..Failed to compile.

.next/types/app/post/page.ts:2:24
Type error: File 'C:/dev/nextjs/next-stable-pnpm/src/app/post/page.tsx' is not a module.

  1 | // File: C:\dev\nextjs\next-stable-pnpm\src\app\post\page.tsx
> 2 | import * as entry from '../../../../src/app/post/page.js'
    |                        ^
  3 | import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
  4 |
  5 | type TEntry = typeof import('../../../../src/app/post/page.js')
 ELIFECYCLE  Command failed with exit code 1.