@bash-app/bash-common 30.51.0 → 30.52.0

package/src/extendedSchemas.ts

@@ -5,22 +5,35 @@ import {
   BashComment,
   BashEvent,
   BashEventPromoCode,
+  BashEventType,
+  BashStatus,
+  BlogPost,
+  BlogCategory,
+  BlogTag,
+  BlogComment,
   Checkout,
+  Competition,
+  CompetitionSponsor,
   Contact,
+  ContactList,
   Coordinates,
   Demerit,
-  EntertainmentService,
-  EventService,
+  DocumentID,
   EventTask,
-  Exhibitor,
   Invitation,
+  InvestmentType,
   Link,
   Media,
   Notification,
-  Organization,
+  NotificationActionType,
+  NotificationPriority,
+  NotificationType,
   Prisma,
+  Prize,
+  PrizeType,
+  Promoter,
+  PromoterStats,
   Recurrence,
-  Reminder,
   Review,
   Service,
   ServiceAddon,
@@ -51,14 +64,28 @@ import {
   TicketTier,
   TicketTransfer,
   User,
+  UserFollowing,
   UserPreferences,
+  UserPromoCodeRedemption,
+  UserReport,
   UserStats,
   UserSubscription,
   Vendor,
   Venue,
   VolunteerService,
+  EntertainmentService,
+  EventService,
+  Exhibitor,
+  Organization,
+  Reminder,
+  ServiceBookingStatus,
+  ServiceBookingType,
+  ServiceCondition,
+  ServiceStatus,
+  ServiceSubscriptionStatus,
+  ServiceTypes,
 } from "@prisma/client";
-import { SERVICE_LINK_DATA_TO_INCLUDE } from "./definitions";
+import { SERVICE_LINK_DATA_TO_INCLUDE, BlogStatus, CommentStatus } from "./definitions";
 import { RemoveCommonProperties, UnionFromArray } from "./utils/typeUtils";
 
 export interface ApiResponse<T> {
@@ -839,3 +866,147 @@ export type PublicStripeAccount = Pick<
   StripeAccountExt,
   keyof typeof PUBLIC_STRIPE_ACCOUNT_DATA_TO_SELECT
 >;
+
+//-------------------------------------------------------------------------------------------------------------------------------
+// Blog Extended Schemas
+//-------------------------------------------------------------------------------------------------------------------------------
+
+export const BLOG_POST_DATA_TO_INCLUDE = {
+  author: {
+    select: FRONT_END_USER_DATA_TO_SELECT,
+  },
+  category: true,
+  tags: true,
+  comments: {
+    include: {
+      author: {
+        select: FRONT_END_USER_DATA_TO_SELECT,
+      },
+      replies: {
+        include: {
+          author: {
+            select: FRONT_END_USER_DATA_TO_SELECT,
+          },
+        },
+      },
+    },
+    where: {
+      status: 'Published',
+    },
+    orderBy: {
+      createdAt: 'desc',
+    },
+  },
+} satisfies Prisma.BlogPostInclude;
+
+export const BLOG_POST_PREVIEW_DATA_TO_INCLUDE = {
+  author: {
+    select: FRONT_END_USER_DATA_TO_SELECT,
+  },
+  category: true,
+  tags: true,
+  _count: {
+    select: {
+      comments: {
+        where: {
+          status: 'Published',
+        },
+      },
+    },
+  },
+} satisfies Prisma.BlogPostInclude;
+
+export interface BlogPostExt extends BlogPost {
+  author: PublicUser;
+  category?: BlogCategory | null;
+  tags: BlogTag[];
+  comments?: BlogCommentExt[];
+  _count?: {
+    comments: number;
+  };
+}
+
+export interface BlogCommentExt extends BlogComment {
+  author: PublicUser;
+  replies?: BlogCommentExt[];
+}
+
+export interface BlogCategoryExt extends BlogCategory {
+  _count?: {
+    posts: number;
+  };
+}
+
+export interface BlogTagExt extends BlogTag {
+  _count?: {
+    posts: number;
+  };
+}
+
+// Blog search and filtering types
+export interface BlogSearchParams {
+  query?: string;
+  category?: string;
+  tag?: string;
+  author?: string;
+  status?: BlogStatus;
+  page?: number;
+  limit?: number;
+  sortBy?: 'createdAt' | 'publishedAt' | 'viewCount' | 'title';
+  sortOrder?: 'asc' | 'desc';
+}
+
+export interface BlogSearchResult {
+  posts: BlogPostExt[];
+  totalCount: number;
+  totalPages: number;
+  currentPage: number;
+  categories: BlogCategoryExt[];
+  tags: BlogTagExt[];
+}
+
+// Blog analytics types
+export interface BlogAnalytics {
+  totalPosts: number;
+  totalViews: number;
+  totalComments: number;
+  popularPosts: BlogPostExt[];
+  popularCategories: BlogCategoryExt[];
+  popularTags: BlogTagExt[];
+  recentActivity: {
+    date: string;
+    views: number;
+    comments: number;
+    posts: number;
+  }[];
+}
+
+// Blog form types
+export interface BlogPostFormData {
+  title: string;
+  slug?: string;
+  excerpt?: string;
+  content: string;
+  coverImage?: string;
+  metaTitle?: string;
+  metaDescription?: string;
+  metaKeywords: string[];
+  categoryId?: string;
+  tags: string[];
+  status: BlogStatus;
+  publishedAt?: Date;
+  scheduledFor?: Date;
+}
+
+export interface BlogCategoryFormData {
+  name: string;
+  slug?: string;
+  description?: string;
+  color?: string;
+}
+
+export interface BlogTagFormData {
+  name: string;
+  slug?: string;
+  color?: string;
+}

package/src/index.ts

@@ -1,34 +1,45 @@
-export * from "./extendedSchemas";
 export * from "./definitions";
-export * from "./utils/ticketListUtils";
-export * from "./utils/dateTimeUtils";
-export * from "./utils/recurrenceUtils";
+export * from "./extendedSchemas";
 export * from "./utils/addressUtils";
-export * from "./utils/paymentUtils";
-export * from "./utils/awsS3Utils";
-export * from "./utils/qrCodeUtils";
-export * from "./utils/sortUtils";
 export * from "./utils/apiUtils";
-export * from "./utils/urlUtils";
-export * from "./utils/stringUtils";
 export * from "./utils/arrayUtils";
+export * from "./utils/awsS3Utils";
+export * from "./utils/dateTimeUtils";
+export * from "./utils/objUtils";
+export * from "./utils/paymentUtils";
 export * from "./utils/promoCodesUtils";
-export * from "./utils/userPromoCodeUtils";
-export * from "./utils/userSubscriptionUtils";
+export * from "./utils/qrCodeUtils";
+export * from "./utils/recurrenceUtils";
+export * from "./utils/service/attendeeOptionUtils";
 export * from "./utils/service/regexUtils";
-export * from "./utils/objUtils";
 export * from "./utils/service/serviceUtils";
 export * from "./utils/service/venueUtils";
-export * from "./utils/service/attendeeOptionUtils";
+export * from "./utils/slugUtils";
+export * from "./utils/sortUtils";
+export * from "./utils/stringUtils";
+export * from "./utils/ticketListUtils";
+export * from "./utils/urlUtils";
+export * from "./utils/userPromoCodeUtils";
+export * from "./utils/userSubscriptionUtils";
 // export * from "./utils/service/serviceRateDBUtils";
-export * from "./utils/service/serviceDBUtils";
-export * from "./utils/service/serviceRateUtils";
-export * from "./utils/service/frontendServiceBookingUtils";
-export * from "./utils/service/apiServiceBookingApiUtils";
-export * from "./utils/service/serviceBookingStatusUtils";
-export * from "./utils/stripeAccountUtils";
+export * from "./utils/blog/blogDbUtils";
+export * from "./utils/blogUtils";
 export * from "./utils/entityUtils";
 export * from "./utils/generalDateTimeUtils";
-export * from "./utils/userUtils";
 export * from "./utils/luxonUtils";
 export * from "./utils/mathUtils";
+export * from "./utils/service/apiServiceBookingApiUtils";
+export * from "./utils/service/frontendServiceBookingUtils";
+export * from "./utils/service/serviceBookingStatusUtils";
+export * from "./utils/service/serviceDBUtils";
+export * from "./utils/service/serviceRateUtils";
+export * from "./utils/stripeAccountUtils";
+export * from "./utils/userUtils";
+
+// Export typeUtils types individually to avoid ValueOf conflict with definitions
+export { createAllTrueObject } from "./utils/typeUtils";
+export type {
+    DeepPartial, MakeOptional,
+    MakeRequired, Override, RemoveCommonProperties, UnionFromArray
+} from "./utils/typeUtils";
+

package/src/utils/blog/blogDbUtils.ts

@@ -0,0 +1,343 @@
+import { PrismaClient, BlogPost, BlogCategory, BlogTag, BlogStatus } from '@prisma/client';
+import { generateSlug, generateUniqueSlug } from '../slugUtils';
+import { generateExcerpt, calculateReadingTime } from '../blogUtils';
+import { BLOG_POST_DATA_TO_INCLUDE, BLOG_POST_PREVIEW_DATA_TO_INCLUDE, BlogPostExt, BlogSearchParams, BlogSearchResult } from '../../extendedSchemas';
+
+// Blog slug utilities
+export async function checkBlogSlugExists(
+  prisma: PrismaClient,
+  slug: string,
+  excludeId?: string
+): Promise<boolean> {
+  const existingPost = await prisma.blogPost.findFirst({
+    where: {
+      slug,
+      ...(excludeId && { id: { not: excludeId } }),
+    },
+  });
+  return !!existingPost;
+}
+
+export async function generateUniqueBlogSlug(
+  prisma: PrismaClient,
+  title: string,
+  excludeId?: string
+): Promise<string> {
+  return generateUniqueSlug(
+    title,
+    (slug, excludeId) => checkBlogSlugExists(prisma, slug, excludeId),
+    excludeId
+  );
+}
+
+// Blog CRUD operations
+export async function createBlogPost(
+  prisma: PrismaClient,
+  data: {
+    title: string;
+    content: string;
+    authorId: string;
+    excerpt?: string;
+    coverImage?: string;
+    categoryId?: string;
+    tags?: string[];
+    metaTitle?: string;
+    metaDescription?: string;
+    metaKeywords?: string[];
+    status?: BlogStatus;
+    publishedAt?: Date;
+    scheduledFor?: Date;
+  }
+): Promise<BlogPostExt> {
+  const slug = await generateUniqueBlogSlug(prisma, data.title);
+  const excerpt = data.excerpt || generateExcerpt(data.content);
+  const readTime = calculateReadingTime(data.content);
+
+  // Handle tags
+  const tagConnections = data.tags ? await connectOrCreateTags(prisma, data.tags) : [];
+
+  const blogPost = await prisma.blogPost.create({
+    data: {
+      title: data.title,
+      slug,
+      content: data.content,
+      excerpt,
+      readTime,
+      authorId: data.authorId,
+      coverImage: data.coverImage,
+      categoryId: data.categoryId,
+      metaTitle: data.metaTitle,
+      metaDescription: data.metaDescription,
+      metaKeywords: data.metaKeywords || [],
+      status: data.status || BlogStatus.Draft,
+      publishedAt: data.status === BlogStatus.Published ? (data.publishedAt || new Date()) : data.publishedAt,
+      scheduledFor: data.scheduledFor,
+      tags: {
+        connect: tagConnections,
+      },
+    },
+    include: BLOG_POST_DATA_TO_INCLUDE,
+  });
+
+  return blogPost as BlogPostExt;
+}
+
+export async function updateBlogPost(
+  prisma: PrismaClient,
+  id: string,
+  data: {
+    title?: string;
+    content?: string;
+    excerpt?: string;
+    coverImage?: string;
+    categoryId?: string;
+    tags?: string[];
+    metaTitle?: string;
+    metaDescription?: string;
+    metaKeywords?: string[];
+    status?: BlogStatus;
+    publishedAt?: Date;
+    scheduledFor?: Date;
+  }
+): Promise<BlogPostExt> {
+  const updateData: any = { ...data };
+
+  // Generate new slug if title changed
+  if (data.title) {
+    updateData.slug = await generateUniqueBlogSlug(prisma, data.title, id);
+  }
+
+  // Update excerpt if content changed
+  if (data.content) {
+    updateData.excerpt = data.excerpt || generateExcerpt(data.content);
+    updateData.readTime = calculateReadingTime(data.content);
+  }
+
+  // Handle publishing
+  if (data.status === BlogStatus.Published && !data.publishedAt) {
+    updateData.publishedAt = new Date();
+  }
+
+  // Handle tags
+  if (data.tags) {
+    const tagConnections = await connectOrCreateTags(prisma, data.tags);
+    updateData.tags = {
+      set: tagConnections,
+    };
+  }
+
+  const blogPost = await prisma.blogPost.update({
+    where: { id },
+    data: updateData,
+    include: BLOG_POST_DATA_TO_INCLUDE,
+  });
+
+  return blogPost as BlogPostExt;
+}
+
+export async function getBlogPost(
+  prisma: PrismaClient,
+  id: string,
+  includeComments: boolean = true
+): Promise<BlogPostExt | null> {
+  const blogPost = await prisma.blogPost.findUnique({
+    where: { id },
+    include: includeComments ? BLOG_POST_DATA_TO_INCLUDE : BLOG_POST_PREVIEW_DATA_TO_INCLUDE,
+  });
+
+  return blogPost as BlogPostExt | null;
+}
+
+export async function getBlogPostBySlug(
+  prisma: PrismaClient,
+  slug: string,
+  includeComments: boolean = true
+): Promise<BlogPostExt | null> {
+  const blogPost = await prisma.blogPost.findUnique({
+    where: { slug },
+    include: includeComments ? BLOG_POST_DATA_TO_INCLUDE : BLOG_POST_PREVIEW_DATA_TO_INCLUDE,
+  });
+
+  return blogPost as BlogPostExt | null;
+}
+
+export async function searchBlogPosts(
+  prisma: PrismaClient,
+  params: BlogSearchParams
+): Promise<BlogSearchResult> {
+  const {
+    query,
+    category,
+    tag,
+    author,
+    status = BlogStatus.Published,
+    page = 1,
+    limit = 12,
+    sortBy = 'publishedAt',
+    sortOrder = 'desc',
+  } = params;
+
+  const skip = (page - 1) * limit;
+
+  // Build where clause
+  const where: any = {
+    status,
+  };
+
+  if (query) {
+    where.OR = [
+      { title: { contains: query, mode: 'insensitive' } },
+      { excerpt: { contains: query, mode: 'insensitive' } },
+      { content: { contains: query, mode: 'insensitive' } },
+    ];
+  }
+
+  if (category) {
+    where.category = { slug: category };
+  }
+
+  if (tag) {
+    where.tags = { some: { slug: tag } };
+  }
+
+  if (author) {
+    where.author = { username: author };
+  }
+
+  // Get posts
+  const posts = await prisma.blogPost.findMany({
+    where,
+    include: BLOG_POST_PREVIEW_DATA_TO_INCLUDE,
+    orderBy: { [sortBy]: sortOrder },
+    skip,
+    take: limit,
+  });
+
+  // Get total count
+  const totalCount = await prisma.blogPost.count({ where });
+
+  // Get categories and tags for filters
+  const [categories, tags] = await Promise.all([
+    prisma.blogCategory.findMany({
+      include: {
+        _count: {
+          select: {
+            posts: {
+              where: { status: BlogStatus.Published },
+            },
+          },
+        },
+      },
+      orderBy: { name: 'asc' },
+    }),
+    prisma.blogTag.findMany({
+      include: {
+        _count: {
+          select: {
+            posts: {
+              where: { status: BlogStatus.Published },
+            },
+          },
+        },
+      },
+      orderBy: { name: 'asc' },
+    }),
+  ]);
+
+  return {
+    posts: posts as BlogPostExt[],
+    totalCount,
+    totalPages: Math.ceil(totalCount / limit),
+    currentPage: page,
+    categories,
+    tags,
+  };
+}
+
+export async function incrementBlogPostViews(
+  prisma: PrismaClient,
+  id: string
+): Promise<void> {
+  await prisma.blogPost.update({
+    where: { id },
+    data: {
+      viewCount: {
+        increment: 1,
+      },
+    },
+  });
+}
+
+// Category utilities
+export async function createBlogCategory(
+  prisma: PrismaClient,
+  data: {
+    name: string;
+    description?: string;
+    color?: string;
+  }
+): Promise<BlogCategory> {
+  const slug = generateSlug(data.name);
+  
+  return prisma.blogCategory.create({
+    data: {
+      name: data.name,
+      slug,
+      description: data.description,
+      color: data.color,
+    },
+  });
+}
+
+// Tag utilities
+export async function connectOrCreateTags(
+  prisma: PrismaClient,
+  tagNames: string[]
+): Promise<{ id: string }[]> {
+  const connections: { id: string }[] = [];
+
+  for (const tagName of tagNames) {
+    const slug = generateSlug(tagName);
+    
+    const tag = await prisma.blogTag.upsert({
+      where: { slug },
+      update: {},
+      create: {
+        name: tagName,
+        slug,
+      },
+    });
+
+    connections.push({ id: tag.id });
+  }
+
+  return connections;
+}
+
+export async function getPopularBlogPosts(
+  prisma: PrismaClient,
+  limit: number = 5
+): Promise<BlogPostExt[]> {
+  const posts = await prisma.blogPost.findMany({
+    where: { status: BlogStatus.Published },
+    include: BLOG_POST_PREVIEW_DATA_TO_INCLUDE,
+    orderBy: { viewCount: 'desc' },
+    take: limit,
+  });
+
+  return posts as BlogPostExt[];
+}
+
+export async function getRecentBlogPosts(
+  prisma: PrismaClient,
+  limit: number = 5
+): Promise<BlogPostExt[]> {
+  const posts = await prisma.blogPost.findMany({
+    where: { status: BlogStatus.Published },
+    include: BLOG_POST_PREVIEW_DATA_TO_INCLUDE,
+    orderBy: { publishedAt: 'desc' },
+    take: limit,
+  });
+
+  return posts as BlogPostExt[];
+}