wip: many to many

Author: kingRayhan

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

@@ -4,25 +4,44 @@ import React from "react";
 import * as sessionActions from "@/backend/services/session.actions";
 import { notFound } from "next/navigation";
 import { persistenceRepository } from "@/backend/persistence-repositories";
-import { eq, and } from "@/backend/persistence/persistence-where-operator";
+import {
+  eq,
+  and,
+  manyToManyJoin,
+  leftJoin,
+} from "@/backend/persistence/persistence-where-operator";
+import { Article, Tag, User } from "@/backend/models/domain-models";
+import { DatabaseTableName } from "@/backend/persistence/persistence-contracts";
 
 interface Props {
   params: Promise<{ uuid: string }>;
 }
 const page: React.FC<Props> = async ({ params }) => {
   const sessionUserId = await sessionActions.getSessionUserId();
   const _params = await params;
-
+  // eq("author_id", sessionUserId)
   const [article] = await persistenceRepository.article.findRows({
     limit: 1,
-    where: and(eq("id", _params.uuid), eq("author_id", sessionUserId)),
+    where: and(eq("id", _params.uuid)),
+    columns: ["id", "title", "handle"],
+    joins: [
+      leftJoin<Article, User>({
+        as: "author",
+        joinTo: DatabaseTableName.users,
+        localField: "author_id",
+        foreignField: "id",
+        columns: ["id", "name", "username"],
+      }),
+    ],
   });
 
   if (!article) {
     throw notFound();
   }
 
-  return <ArticleEditor uuid={_params.uuid} article={article} />;
+  return <pre>{JSON.stringify(article, null, 2)}</pre>;
+
+  // return <ArticleEditor uuid={_params.uuid} article={article} />;
 };
 
 export default page;

src/app/[username]/[articleHandle]/opengraph-image.tsx

@@ -1,9 +1,6 @@
 import { Article, User } from "@/backend/models/domain-models";
 import { persistenceRepository } from "@/backend/persistence-repositories";
-import {
-  eq,
-  joinTable,
-} from "@/backend/persistence/persistence-where-operator";
+import { eq, leftJoin } from "@/backend/persistence/persistence-where-operator";
 import { ImageResponse } from "next/og";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -33,7 +30,7 @@ export default async function Image(options: ArticlePageProps) {
     columns: ["title", "excerpt", "cover_image", "body"],
     limit: 1,
     joins: [
-      joinTable<Article, User>({
+      leftJoin<Article, User>({
         as: "user",
         joinTo: "users",
         localField: "author_id",

src/app/sitemaps/articles/sitemap.tsx

@@ -3,7 +3,7 @@ import { persistenceRepository } from "@/backend/persistence-repositories";
 import {
   and,
   eq,
-  joinTable,
+  leftJoin,
   neq,
 } from "@/backend/persistence/persistence-where-operator";
 import type { MetadataRoute } from "next";
@@ -14,7 +14,7 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
     columns: ["handle", "updated_at"],
     limit: -1,
     joins: [
-      joinTable<Article, User>({
+      leftJoin<Article, User>({
         as: "user",
         joinTo: "users",
         localField: "author_id",

src/backend/persistence/persistence-contracts.ts

@@ -53,17 +53,25 @@ export type CompositeWhere<T> = {
 };
 export type WhereCondition<T> = SimpleWhere<T> | CompositeWhere<T>;
 
-export interface IPersistenceJoin {
+export interface IPersistenceLeftJoin {
   as: string;
   joinTo: string;
   localField: string;
   foreignField: string;
   columns: string[];
 }
 
+export interface IPersistenceManyToManyJoin {
+  as: string;
+  pivotTable: DatabaseTableName;
+  localField: string;
+  foreignField: string;
+  columns: string[];
+}
+
 export interface IPersistentPaginationPayload<T> {
   where?: WhereCondition<T>;
-  joins?: IPersistenceJoin[];
+  joins?: IPersistenceLeftJoin[];
   orderBy?: Array<IPersistentOrderBy<T>>;
   columns?: Array<keyof T>;
   limit?: number;
@@ -88,7 +96,7 @@ export interface IPagination<T> {
   where?: WhereCondition<T>; // No longer allows arrays
   columns?: Array<keyof T>;
   orderBy?: Array<IPersistentOrderBy<T>>;
-  joins?: IPersistenceJoin[];
+  joins?: IPersistenceLeftJoin[];
 }
 
 //------------------------------------

src/backend/persistence/persistence-utils.ts

@@ -1,5 +1,5 @@
 import {
-  IPersistenceJoin,
+  IPersistenceLeftJoin,
   IPersistentOrderBy,
   SimpleWhere,
   WhereCondition,
@@ -144,7 +144,7 @@ export const buildOrderByClause = <T>(
   return `ORDER BY ${orderByConditions.join(", ")}`;
 };
 
-export const buildJoinClause = <T>(joins?: Array<IPersistenceJoin>) => {
+export const buildJoinClause = <T>(joins?: Array<IPersistenceLeftJoin>) => {
   if (!joins || joins.length === 0) {
     return {
       joinConditionClause: "",

src/backend/persistence/persistence-where-operator.ts

@@ -2,7 +2,10 @@
  * Drizzle-style operator functions with direct generic approach
  */
 
-import { IPersistenceJoin } from "./persistence-contracts";
+import {
+  DatabaseTableName,
+  IPersistenceLeftJoin,
+} from "./persistence-contracts";
 
 // Type for all possible operators
 type Operator =
@@ -186,13 +189,13 @@ export function desc<T>(key: keyof T): IPersistentOrderBy<T> {
   };
 }
 
-export function joinTable<LOCAL_MODEL, FOREIGN_MODEL>(payload: {
+export function leftJoin<LOCAL_MODEL, FOREIGN_MODEL>(payload: {
   as: string;
   joinTo: string;
   localField: keyof LOCAL_MODEL;
   foreignField: keyof FOREIGN_MODEL;
   columns: Array<keyof FOREIGN_MODEL>;
-}): IPersistenceJoin {
+}): IPersistenceLeftJoin {
   return {
     as: payload.as,
     joinTo: payload.joinTo,
@@ -201,3 +204,19 @@ export function joinTable<LOCAL_MODEL, FOREIGN_MODEL>(payload: {
     columns: payload.columns.map((col) => col.toString()),
   };
 }
+
+export function manyToManyJoin<LOCAL_MODEL, FOREIGN_MODEL>(payload: {
+  as: string;
+  pivotTable: DatabaseTableName;
+  localField: keyof LOCAL_MODEL;
+  foreignField: keyof FOREIGN_MODEL;
+  columns: Array<keyof FOREIGN_MODEL>;
+}): IPersistenceLeftJoin {
+  return {
+    as: payload.as,
+    joinTo: payload.pivotTable,
+    localField: payload.localField.toString(),
+    foreignField: payload.foreignField.toString(),
+    columns: payload.columns.map((col) => col.toString()),
+  };
+}

src/backend/persistence/persistence.repository.ts

@@ -13,6 +13,7 @@ import {
   buildOrderByClause,
   buildSetClause,
   buildWhereClause,
+  sql,
   toSnakeCase,
 } from "./persistence-utils";
 import { removeNullOrUndefinedFromObject } from "@/lib/utils";

src/backend/services/article.actions.ts

@@ -9,8 +9,9 @@ import {
   and,
   desc,
   eq,
-  joinTable,
+  leftJoin,
   like,
+  manyToManyJoin,
   neq,
   notInArray,
   or,
@@ -199,6 +200,7 @@ export async function updateArticle(
         published_at: input.is_published ? new Date() : null,
       },
     });
+
     return article;
   } catch (error) {
     handleRepositoryException(error);
@@ -229,6 +231,11 @@ export async function updateMyArticle(
         metadata: input.metadata,
       },
     });
+    // a 1, t 1
+    // a 1, t 2
+    // a 1, t 3
+
+    // a-> (2,3,4)
 
     if (input.tag_ids) {
       await persistenceRepository.articleTag.deleteRows({
@@ -238,8 +245,8 @@ export async function updateMyArticle(
         ),
       });
 
-      await input.tag_ids.forEach((tag_id) => {
-        persistenceRepository.articleTag.createOne({
+      input.tag_ids.forEach(async (tag_id) => {
+        await persistenceRepository.articleTag.createOne({
           article_id: article.id,
           tag_id: tag_id,
         });
@@ -294,7 +301,7 @@ export async function findRecentArticles(
       orderBy: [desc("published_at")],
       columns: ["id", "title", "handle"],
       joins: [
-        joinTable<Article, User>({
+        leftJoin<Article, User>({
           as: "user",
           joinTo: "users",
           localField: "author_id",
@@ -337,7 +344,7 @@ export async function articleFeed(
         "excerpt",
       ],
       joins: [
-        joinTable<Article, User>({
+        leftJoin<Article, User>({
           as: "user",
           joinTo: "users",
           localField: "author_id",
@@ -386,7 +393,7 @@ export async function userArticleFeed(
         "excerpt",
       ],
       joins: [
-        joinTable<Article, User>({
+        leftJoin<Article, User>({
           as: "user",
           joinTo: "users",
           localField: "author_id",
@@ -429,19 +436,20 @@ export async function articleDetailByHandle(article_handle: string) {
         "updated_at",
       ],
       joins: [
-        joinTable<Article, User>({
+        leftJoin<Article, User>({
           as: "user",
           joinTo: "users",
           localField: "author_id",
           foreignField: "id",
           columns: ["id", "name", "username", "profile_photo"],
         }),
-        // joinTable<Article, Tag>({
-        //   as: "tags",
-        //   joinTo: "tags",
-        //   localField: "author_id",
-        //   foreignField: "id",
-        // }),
+        manyToManyJoin<Article, Tag>({
+          as: "tags",
+          pivotTable: DatabaseTableName.article_tag,
+          localField: "id",
+          foreignField: "id",
+          columns: ["id", "name", "icon", "color", "description"],
+        }),
       ],
       limit: 1,
     });
@@ -476,7 +484,7 @@ export async function articleDetailByUUID(uuid: string) {
         "updated_at",
       ],
       joins: [
-        joinTable<Article, User>({
+        leftJoin<Article, User>({
           as: "user",
           joinTo: "users",
           localField: "author_id",

src/backend/services/series.action.ts

@@ -6,7 +6,7 @@ import {
   asc,
   desc,
   eq,
-  joinTable,
+  leftJoin,
 } from "../persistence/persistence-where-operator";
 import { Article, Series, SeriesItem, User } from "../models/domain-models";
 
@@ -31,7 +31,7 @@ export const getSeriesDetailByHandle = async (handle: string) => {
       where: eq("handle", handle),
       limit: 1,
       joins: [
-        joinTable<Series, User>({
+        leftJoin<Series, User>({
           as: "owner",
           joinTo: "users",
           localField: "owner_id",
@@ -46,7 +46,7 @@ export const getSeriesDetailByHandle = async (handle: string) => {
       orderBy: [asc("index")],
       limit: -1,
       joins: [
-        joinTable<SeriesItem, Article>({
+        leftJoin<SeriesItem, Article>({
           as: "article",
           joinTo: "articles",
           localField: "article_id",