Refactor persistence layer: update schema paths, replace deprecated repositories with new persistenceRepository methods, and enhance database connection management.

Author: kingRayhan

.idea/prettier.xml

@@ -9,7 +9,7 @@ dotenv.config({
 
 export default defineConfig({
   out: "./migrations",
-  schema: "./src/backend/schemas/schemas.ts",
+  schema: "./src/backend/persistence/schema.ts",
   dialect: "postgresql",
   dbCredentials: {
     url: process.env.DATABASE_URL!,

drizzle.config.ts

@@ -32,7 +32,7 @@ const page: React.FC<Props> = async ({ params }) => {
     ],
   });
 
-  const aggregatedTags = await persistenceRepository.articleTag.find({
+  const aggregatedTags = await persistenceRepository.articleTagPivot.find({
     where: inArray("article_id", [article.id]),
     joins: [
       {

src/app/(dashboard-editor)/dashboard/articles/[uuid]/page.tsx

@@ -15,7 +15,7 @@ export async function GET(request: Request) {
   //   }
   // ]
   return NextResponse.json({
-    handle: await persistenceRepository.articleTag.delete({
+    handle: await persistenceRepository.articleTagPivot.delete({
       where: {
         AND: [
           {

src/app/api/play/route.ts

@@ -1,4 +1,23 @@
 import "dotenv/config";
+import { PostgresAdapter } from "sqlkit";
 import { drizzle } from "drizzle-orm/node-postgres";
-import * as schema from "../schemas/schemas";
-export const db = drizzle(process.env.DATABASE_URL!, { schema });
+import * as schema from "./schemas";
+import { Pool } from "pg";
+import { env } from "@/env";
+
+declare global {
+  var pgClient: PostgresAdapter | undefined;
+}
+
+export const drizzleClient = drizzle(process.env.DATABASE_URL!, { schema });
+
+// Initialize global database connection
+if (!globalThis.pgClient) {
+  const pool = new Pool({
+    connectionString: env.DATABASE_URL,
+  });
+
+  globalThis.pgClient = new PostgresAdapter(pool);
+}
+
+export const pgClient = globalThis.pgClient;

src/backend/persistence/clients.ts

@@ -1,8 +1,5 @@
 export enum DatabaseTableName {
-  tenants = "tenants",
-  clients = "clients",
   users = "users",
-  roles = "roles",
   articles = "articles",
   user_socials = "user_socials",
   user_sessions = "user_sessions",

src/backend/persistence/persistence-contracts.ts

@@ -9,50 +9,62 @@ import {
   UserSession,
   UserSocial,
 } from "../models/domain-models";
-import { pgClient } from "./database-drivers/pg.client";
+import { pgClient } from "./clients";
 import { DatabaseTableName } from "./persistence-contracts";
 
+const repositoryConfig = {
+  logging: true,
+};
+
 export const userRepository = new Repository<User>(
   DatabaseTableName.users,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 export const articleRepository = new Repository<Article>(
   DatabaseTableName.articles,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 export const tagRepository = new Repository<Tag>(
   DatabaseTableName.tags,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 export const articleTagRepository = new Repository<ArticleTag>(
   DatabaseTableName.article_tag,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 export const userSocialRepository = new Repository<UserSocial>(
   DatabaseTableName.user_socials,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 export const userSessionRepository = new Repository<UserSession>(
   DatabaseTableName.user_sessions,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 
 const seriesRepository = new Repository<Series>(
   DatabaseTableName.series,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 
 const seriesItemsRepository = new Repository<SeriesItem>(
   DatabaseTableName.series_items,
-  pgClient
+  pgClient,
+  repositoryConfig,
 );
 
 export const persistenceRepository = {
   user: userRepository,
   userSocial: userSocialRepository,
   userSession: userSessionRepository,
   article: articleRepository,
-  articleTag: articleTagRepository,
+  articleTagPivot: articleTagRepository,
   tags: tagRepository,
   series: seriesRepository,
   seriesItems: seriesItemsRepository,

src/backend/persistence/persistence-repositories.ts

@@ -9,47 +9,15 @@ import * as sk from "sqlkit";
 import { and, desc, eq, like, neq, or } from "sqlkit";
 import { z } from "zod";
 import { Article, User } from "../models/domain-models";
-import { pgClient } from "../persistence/database-drivers/pg.client";
 import { DatabaseTableName } from "../persistence/persistence-contracts";
+import { persistenceRepository } from "../persistence/persistence-repositories";
 import {
   handleRepositoryException,
   RepositoryException,
 } from "./RepositoryException";
 import { ArticleRepositoryInput } from "./inputs/article.input";
 import { getSessionUserId } from "./session.actions";
 import { syncTagsWithArticles } from "./tag.action";
-import { persistenceRepository } from "../persistence/persistence-repositories";
-
-/**
- * Creates a new article in the database.
- *
- * @param _input - The article data to create, validated against ArticleRepositoryInput.createArticleInput schema
- * @returns Promise<Article> - The newly created article
- * @throws {RepositoryException} If article creation fails or validation fails
- */
-export async function createArticle(
-  _input: z.infer<typeof ArticleRepositoryInput.createArticleInput>
-) {
-  try {
-    const input =
-      await ArticleRepositoryInput.createArticleInput.parseAsync(_input);
-    const article = await persistenceRepository.article.insert([
-      {
-        title: input.title,
-        handle: input.handle,
-        excerpt: input.excerpt ?? null,
-        body: input.body ?? null,
-        cover_image: input.cover_image ?? null,
-        is_published: input.is_published ?? false,
-        published_at: input.is_published ? new Date() : null,
-        author_id: input.author_id,
-      },
-    ]);
-    return article;
-  } catch (error) {
-    handleRepositoryException(error);
-  }
-}
 
 export async function createMyArticle(
   _input: z.infer<typeof ArticleRepositoryInput.createMyArticleInput>

src/backend/services/article.actions.ts

@@ -1,22 +1,22 @@
 "use server";
 
 import * as sessionActions from "@/backend/services/session.actions";
-import { persistenceRepository } from "../persistence/persistence-repositories";
+import { pgClient } from "@/backend/persistence/clients";
 
 const sql = String.raw;
 
 const query = sql`
 SELECT (SELECT Count(*)
-          FROM   articles
-          WHERE  author_id = $1)
-       AS total_articles,
-       (SELECT Count(*)
-          FROM   comments
-          WHERE  comments.commentable_type = 'ARTICLE'
-            AND  comments.commentable_id IN (SELECT id
-                                              FROM   articles
-                                              WHERE  articles.author_id = $1))
-       AS total_comments
+    FROM   articles
+    WHERE  author_id = $1)
+  AS total_articles,
+  (SELECT Count(*)
+    FROM   comments
+    WHERE  comments.commentable_type = 'ARTICLE'
+      AND  comments.commentable_id IN (SELECT id
+                                        FROM   articles
+                                        WHERE  articles.author_id = $1))
+  AS total_comments
 `;
 
 export async function myArticleMatrix() {

src/backend/services/dashboard.action.ts

@@ -63,7 +63,7 @@ export const ArticleRepositoryInput = {
       })
       .optional(),
 
-    // Optional boolean flag for publish status
+    // Optional boolean flag for publication status
     is_published: z.boolean().optional(),
 
     tag_ids: z.array(z.string()).optional().nullable(),