@mac777/project-pinecone-schema 1.0.1 → 1.0.3

package/src/events/utils/admin.schema.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+
+// Metrics schema
+export const metricsSchema = z.object({
+  views: z.number({ required_error: 'Views must be a number' }).int('Views must be an integer').min(0, 'Views cannot be negative').default(0),
+  ticketsSold: z.number({ required_error: 'Tickets sold must be a number' }).int('Tickets sold must be an integer').min(0, 'Tickets sold cannot be negative').default(0),
+  revenue: z.number({ required_error: 'Revenue must be a number' }).min(0, 'Revenue cannot be negative').default(0),
+  checkIns: z.number({ required_error: 'Check-ins must be a number' }).int('Check-ins must be an integer').min(0, 'Check-ins cannot be negative').default(0),
+  averageRating: z.number().min(0, 'Rating must be at least 0').max(5, 'Rating cannot exceed 5').optional(),
+  reviewCount: z.number({ required_error: 'Review count must be a number' }).int('Review count must be an integer').min(0, 'Review count cannot be negative').default(0),
+});
+
+// Business schemas
+export const pricingSchema = z.object({
+  platformFee: z.number({ required_error: 'Platform fee must be a number' }).min(0, 'Platform fee cannot be negative').default(5),
+  paymentProcessingFee: z.number().min(0, 'Payment processing fee cannot be negative').optional(),
+  currency: z.string().optional(),
+});
+
+export const payoutSchema = z.object({
+  status: z.enum(['pending', 'scheduled', 'completed'], { required_error: 'Payout status must be pending, scheduled, or completed' }).optional(),
+  amount: z.number().min(0, 'Payout amount cannot be negative').optional(),
+  scheduledDate: z.string().datetime('Payout scheduled date must be a valid ISO datetime string').optional(),
+  paidAt: z.string().datetime('Payout paid date must be a valid ISO datetime string').optional(),
+  stripePayoutId: z.string().optional(),
+});
+
+// Policies schemas
+export const cancellationSchema = z.object({
+  allowed: z.boolean({ required_error: 'Cancellation allowed must be true or false' }).default(true),
+  refundPercentage: z.number({ required_error: 'Refund percentage must be a number' }).min(0, 'Refund percentage cannot be less than 0').max(100, 'Refund percentage cannot exceed 100').default(100),
+  deadlineHours: z.number().min(0, 'Deadline hours cannot be negative').optional(),
+});
+
+export const policiesSchema = z.object({
+  cancellation: cancellationSchema.optional(),
+  transferable: z.boolean({ required_error: 'Transferable must be true or false' }).default(false),
+});
+
+// Moderation schemas
+export const flagSchema = z.object({
+  reportedBy: z.string({ required_error: 'Reported by user ID is required' }), // ObjectId as string
+  reason: z.string({ required_error: 'Report reason is required' }),
+  description: z.string({ required_error: 'Report description is required' }),
+  createdAt: z.string().datetime('Report created date must be a valid ISO datetime string').optional(),
+  status: z.enum(['pending', 'resolved', 'dismissed'], { required_error: 'Report status must be pending, resolved, or dismissed' }).default('pending'),
+});
+
+export const moderationSchema = z.object({
+  isFlagged: z.boolean({ required_error: 'Is flagged must be true or false' }).default(false),
+  flags: z.array(flagSchema, { required_error: 'Flags must be an array' }).optional(),
+  suspendedUntil: z.string().datetime('Suspension date must be a valid ISO datetime string').optional(),
+  banReason: z.string().optional(),
+});
+
+// SEO schema
+export const seoSchema = z.object({
+  metaTitle: z.string().optional(),
+  metaDescription: z.string().optional(),
+  keywords: z.array(z.string(), { required_error: 'SEO keywords must be an array of strings' }).optional(),
+  ogImage: z.string().optional(),
+});
+
+// Features schema
+export const featuresSchema = z.object({
+  isFeatured: z.boolean({ required_error: 'Is featured must be true or false' }).default(false),
+  isPremium: z.boolean({ required_error: 'Is premium must be true or false' }).default(false),
+  badges: z.array(z.string(), { required_error: 'Badges must be an array of strings' }).optional(),
+});
+
+// History schema
+export const historySchema = z.object({
+  action: z.string({ required_error: 'History action is required' }),
+  performedBy: z.string({ required_error: 'Performed by user ID is required' }), // ObjectId as string
+  timestamp: z.string().datetime('History timestamp must be a valid ISO datetime string').optional(),
+  changes: z.record(z.any()).optional(),
+});

package/src/events/utils/age.restriction.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const ageRestrictionSchema = z.enum(['all_ages', '18+', '21+'], {required_error: "Age restriction is required"}).default('all_ages');

package/src/events/utils/document.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const documentSchema = z.object({
+  type: z.enum(['venue_booking', 'permit', 'insurance', 'license', 'portfolio', 'other'], { required_error: 'Document type is required' }).optional(),
+  url: z.string({ required_error: 'Document URL is required' }).url('Document URL must be valid').optional(),
+  filename: z.string({ required_error: 'Document filename is required' }),
+  objectKey: z.string({ required_error: 'Document object key is required' }),
+});

package/src/events/utils/event.type.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const eventTypeSchema = z.enum(['concert', 'festival', 'conference', 'theater', 'sports', 'other'], {required_error: "Event type is required"}).default('concert');

package/src/events/utils/media.schema.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+export const coverImageSchema = z.object({
+  alt: z.string({
+    required_error: 'Alt text is required',
+    invalid_type_error: 'Alt text must be a string'
+  }),
+  thumbnailUrl: z.string({
+    required_error: 'Thumbnail URL is required',
+    invalid_type_error: 'Thumbnail URL must be a string'
+  }),
+  url: z.string({
+    required_error: 'URL is required',
+    invalid_type_error: 'URL must be a string'
+  })
+});
+
+export const gallerySchema = z.array(z.object({
+  alt: z.string({
+    required_error: 'Alt text is required',
+    invalid_type_error: 'Alt text must be a string'
+  }),
+  thumbnailUrl: z.string({
+    required_error: 'Thumbnail URL is required',
+    invalid_type_error: 'Thumbnail URL must be a string'
+  }),
+  url: z.string({
+    required_error: 'URL is required',
+    invalid_type_error: 'URL must be a string'
+  })
+}));
+
+export const mediaSchema = z.object({
+  coverImage: coverImageSchema,
+  gallery: gallerySchema.optional()
+});

package/src/events/utils/organizer.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const contactPersonSchema = z.object({
+  name: z.string({ required_error: 'Contact person name is required' }),
+  phone: z.string({ required_error: 'Contact person phone is required' }).min(11, 'Phone number must be 11 digits 11 digits'),
+  email: z.string({ required_error: 'Contact person email is required' }).email('Contact person email must be valid'),
+  designation: z.string().optional(),
+});
+
+export const organizerSchema = z.object({
+  role: z.enum(['event_organizer', 'venue_owner', 'authorized_rep', 'artist'], { required_error: 'Organizer role must be event_organizer, venue_owner, authorized_rep, or artist' }).optional(),
+  companyName: z.string().optional(),
+  contactPerson: contactPersonSchema,
+});

package/src/events/utils/schedule.schema.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const scheduleSchema = z.object({
+  startDate: z.string({ required_error: 'Event start date is required' }).datetime('Start date must be a valid ISO datetime string'),
+  endDate: z.string({ required_error: 'Event end date is required' }).datetime('End date must be a valid ISO datetime string'),
+  timezone: z.string().optional(),
+  isMultiDay: z.boolean().optional(),
+  doors: z.string().optional(),
+});
+

package/src/events/utils/ticket.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+
+export const priceSchema = z.object({
+  amount: z.number({ required_error: 'Ticket price amount is required' }).min(0, 'Ticket price cannot be negative'),
+  currency: z.string({ required_error: 'Ticket currency is required' }).default('BDT'),
+});
+
+export const salesWindowSchema = z.object({
+  startDate: z.string().datetime('Sales start date must be a valid ISO datetime string').optional(),
+  endDate: z.string().datetime('Sales end date must be a valid ISO datetime string').optional(),
+});
+
+export const limitsSchema = z.object({
+  minPerOrder: z.number({ required_error: 'Min per order must be a number' }).int('Min per order must be an integer').min(1, 'Min per order must be at least 1').default(1),
+  maxPerOrder: z.number({ required_error: 'Max per order must be a number' }).int('Max per order must be an integer').min(1, 'Max per order must be at least 1').default(10),
+});
+
+export const displayTicketSchema = z.object({
+  _id: z.string().optional(),
+  name: z.string({ required_error: 'Ticket name is required' }),
+  description: z.string().optional(),
+  price: priceSchema,
+  quantity: z.number({ required_error: 'Ticket quantity is required' }).int('Quantity must be an integer').positive('Quantity must be positive'),
+  salesWindow: salesWindowSchema.optional(),
+  limits: limitsSchema.optional(),
+  remaining: z.number().optional(),
+  sold: z.number().optional(),
+  reserved: z.number().optional(),
+  visibility: z.enum(['public', 'hidden', 'invite_only'], { required_error: 'Ticket visibility must be public, hidden, or invite_only' }).default('public').optional(),
+  status: z.enum(['active', 'inactive'], { required_error: 'Ticket status must be active or inactive' }).default('active').optional(),
+  benefits: z.array(z.string(), { required_error: 'Benefits must be an array of strings' }).optional(),
+  tier: z.enum(['early_bird', 'regular', 'vip'], { required_error: 'Ticket tier must be early_bird, regular or vip' }).default('regular')
+});

package/src/events/utils/venue.schema.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+export const venueTypeSchema = z.enum(['indoor', 'outdoor', 'hybrid'], { required_error: 'Venue type must be indoor, outdoor, or hybrid' }).optional();
+
+export const addressSchema = z.object({
+  street: z.string({ required_error: 'Street is required' }).min(1, 'Street is required'),
+  city: z.string({ required_error: 'City is required' }).min(1, 'City is required'),
+  country: z.string({ required_error: 'Country is required' }).min(1, 'Country is required'),
+});
+
+export const venueSchema = z.object({
+  name: z.string({ required_error: 'Venue name is required' }).min(1, 'Venue name is required'),
+  address: addressSchema,
+  coordinates: z.object({
+    type: z.literal('Point', { required_error: 'Coordinates type must be Point' }),
+    coordinates: z.tuple([z.number({ required_error: 'Longitude is required' }), z.number({ required_error: 'Latitude is required' })], { required_error: 'Coordinates array [lng, lat] is required' }), // [lng, lat]
+  }).optional(),
+  capacity: z.number({ required_error: 'Venue capacity is required' }).int('Capacity must be an integer').positive('Capacity must be positive').min(10, 'Capacity must be at least 10'),
+  type: venueTypeSchema,
+  parking: z.boolean().optional(),
+  publicTransit: z.string().optional(),
+});

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './auth/index';
+export * from './events/index';
+export * from './media/index';
+export * from './orders/index';
+

package/src/media/index.ts

@@ -0,0 +1,2 @@
+export * from './media.schema';
+export * from './media.type';

package/src/media/media.schema.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { backblazeUploadUrlSchema } from './utils/backblaze.schema';
+import { imageKitAuthSchema, imageKitFinalizeSchema, imageKitTrackSchema } from './utils/imagekit.schema';
+
+// =============================================================================
+// MEDIA SCHEMAS
+// =============================================================================
+
+// Re-export utility schemas for convenience
+export { backblazeUploadUrlSchema } from './utils/backblaze.schema';
+export { imageKitAuthSchema, imageKitFinalizeSchema, imageKitTrackSchema } from './utils/imagekit.schema';
+
+// Common media types enum
+export const mediaTypeSchema = z.enum(['event_cover', 'event_gallery', 'verification_doc']);
+
+// File upload response schema
+export const fileUploadResponseSchema = z.object({
+  url: z.string(),
+  key: z.string(),
+  bucket: z.string(),
+  fileName: z.string(),
+  fileType: z.string(),
+  size: z.number(),
+  uploadedAt: z.date(),
+});
+
+// Document schema (used in events)
+export const documentSchema = z.object({
+  id: z.string().optional(),
+  name: z.string({ required_error: 'Document name is required' }),
+  url: z.string({ required_error: 'Document URL is required' }),
+  type: mediaTypeSchema,
+  size: z.number({ required_error: 'Document size is required' }),
+  mimeType: z.string({ required_error: 'Document MIME type is required' }),
+  uploadedAt: z.date().optional(),
+  objectKey: z.string().optional(), // For S3/Backblaze reference
+});

package/src/media/media.type.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { mediaTypeSchema, fileUploadResponseSchema } from './media.schema';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+// Media types
+export type MediaType = z.infer<typeof mediaTypeSchema>;
+export type FileUploadResponse = z.infer<typeof fileUploadResponseSchema>;
+
+// Backblaze types
+export type BackblazeUploadUrlInput = z.infer<typeof import('./utils/backblaze.schema').backblazeUploadUrlSchema>;
+
+// ImageKit types
+export type ImageKitAuthInput = z.infer<typeof import('./utils/imagekit.schema').imageKitAuthSchema>;
+export type ImageKitFinalizeInput = z.infer<typeof import('./utils/imagekit.schema').imageKitFinalizeSchema>;
+export type ImageKitTrackInput = z.infer<typeof import('./utils/imagekit.schema').imageKitTrackSchema>;

package/src/media/utils/backblaze.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+// Schema for Backblaze upload URL endpoint
+export const backblazeUploadUrlSchema = z.object({
+  filename: z.string({ required_error: 'File name is required' }),
+  fileType: z.string({ required_error: 'File type is required' }),
+  documentType: z.enum(['event_cover', 'event_gallery', 'verification_doc']).default('verification_doc'),
+});

package/src/media/utils/imagekit.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+// Schema for ImageKit auth endpoint - GET request, no body needed
+export const imageKitAuthSchema = z.object({});
+
+// Schema for ImageKit finalize endpoint
+export const imageKitFinalizeSchema = z.object({
+  fileId: z.string({ required_error: 'File ID is required' }),
+  fromFolder: z.string({ required_error: 'From folder is required' }),
+  toFolder: z.string({ required_error: 'To folder is required' }),
+});
+
+// Schema for ImageKit track endpoint
+export const imageKitTrackSchema = z.object({
+  fileId: z.string({ required_error: 'File ID is required' }),
+  url: z.string({ required_error: 'URL is required' }),
+  filename: z.string({ required_error: 'Filename is required' }),
+  type: z.enum(['event_cover', 'event_gallery', 'verification_doc']),
+  status: z.enum(['temp', 'permanent', 'deleted']).default('temp'),
+});

package/src/orders/index.ts

@@ -0,0 +1,6 @@
+export * from './orders.schema';
+export * from './orders.type';
+export * from './payments.schema';
+export * from './payments.type';
+export * from './ticket.schema';
+export * from './ticket.type';

package/src/orders/orders.schema.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+
+// Order ticket schema (embedded in order)
+export const orderTicketSchema = z.object({
+  ticketVariantId: z.string(),
+  variantName: z.string(),
+  quantity: z.number().min(1),
+  pricePerTicket: z.number().min(0),
+  subtotal: z.number().min(0)
+});
+
+// Pricing schema (embedded in order)
+export const orderPricingSchema = z.object({
+  subtotal: z.number().min(0),
+  platformFee: z.number().min(0),
+  paymentFee: z.number().min(0),
+  total: z.number().min(0),
+  currency: z.string().default('BDT'),
+  hostPayout: z.number().min(0)
+});
+
+// Refund schema (embedded in order)
+export const refundSchema = z.object({
+  reason: z.enum(['event_cancelled', 'user_request', 'fraud']),
+  amount: z.number().min(0),
+  refundedAt: z.date().default(() => new Date()),
+  stripeRefundId: z.string().optional()
+});
+
+// Main order schema
+export const orderSchema = z.object({
+  _id: z.string().optional(), // MongoDB ObjectId
+  orderNumber: z.string().regex(/^ORD-\d{6}-[A-Z0-9]{6}$/), // ORD-123456-ABC123
+
+  // WHO
+  userId: z.string(), // Buyer
+
+  // WHAT
+  eventId: z.string(), // Which event
+
+  tickets: z.array(orderTicketSchema).min(1),
+
+  // MONEY
+  pricing: orderPricingSchema,
+
+  // STATUS
+  status: z.enum(['pending', 'confirmed', 'cancelled', 'refunded']).default('pending'),
+
+  // PAYMENT
+  paymentMethod: z.enum(['card', 'bkash', 'bank_transfer']),
+  paymentStatus: z.enum(['pending', 'succeeded', 'failed']).default('pending'),
+  paidAt: z.date().optional(),
+
+  // TICKETS ISSUED
+  ticketIds: z.array(z.string()).default([]),
+
+  // LIFECYCLE
+  createdAt: z.date().default(() => new Date()),
+  expiresAt: z.date(), // Must be set when creating
+  confirmedAt: z.date().optional(),
+  cancelledAt: z.date().optional(),
+  refundedAt: z.date().optional(),
+
+  // CONTACT
+  buyerEmail: z.string().email(),
+  buyerPhone: z.string().optional(),
+
+  // AUDIT
+  ipAddress: z.string().optional(),
+  userAgent: z.string().optional(),
+
+  // REFUND (if applicable)
+  refund: refundSchema.optional()
+});
+
+// API Request/Response schemas
+export const createOrderSchema = z.object({
+  eventId: z.string(),
+  tickets: z.array(z.object({
+    ticketVariantId: z.string(),
+    variantName: z.string(),
+    quantity: z.number().min(1),
+    pricePerTicket: z.number().min(0)
+  })).min(1),
+  paymentMethod: z.enum(['card', 'bkash', 'bank_transfer']),
+  buyerEmail: z.string().email(),
+  buyerPhone: z.string().optional()
+});
+
+export const confirmOrderSchema = z.object({
+  ticketIds: z.array(z.string())
+});
+
+export const refundOrderSchema = z.object({
+  reason: z.enum(['event_cancelled', 'user_request', 'fraud']),
+  amount: z.number().min(0)
+});
+
+export const updateOrderStatusSchema = z.object({
+  status: z.enum(['pending', 'confirmed', 'cancelled', 'refunded']),
+  adminNotes: z.string().optional()
+});
+
+// Response schemas
+export const orderResponseSchema = orderSchema;
+export const ordersListResponseSchema = z.array(orderResponseSchema);

package/src/orders/orders.type.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import {
+  orderSchema,
+  orderTicketSchema,
+  orderPricingSchema,
+  refundSchema,
+  createOrderSchema,
+  confirmOrderSchema,
+  refundOrderSchema,
+  updateOrderStatusSchema,
+  orderResponseSchema,
+  ordersListResponseSchema
+} from './orders.schema';
+import { PaymentMethod } from './payments.type';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+// Embedded schema types
+export type OrderTicket = z.infer<typeof orderTicketSchema>;
+export type OrderPricing = z.infer<typeof orderPricingSchema>;
+export type Refund = z.infer<typeof refundSchema>;
+
+// Main order types
+export type Order = z.infer<typeof orderSchema>;
+export type OrderStatus = Order['status'];
+
+// API request/response types
+export type CreateOrderRequest = z.infer<typeof createOrderSchema>;
+export type ConfirmOrderRequest = z.infer<typeof confirmOrderSchema>;
+export type RefundOrderRequest = z.infer<typeof refundOrderSchema>;
+export type UpdateOrderStatusRequest = z.infer<typeof updateOrderStatusSchema>;
+
+export type OrderResponse = z.infer<typeof orderResponseSchema>;
+export type OrdersListResponse = z.infer<typeof ordersListResponseSchema>;
+
+// Service method parameter types
+export interface CreateOrderData {
+  userId: string;
+  eventId: string;
+  tickets: Array<{
+    ticketVariantId: string;
+    variantName: string;
+    quantity: number;
+    pricePerTicket: number;
+  }>;
+  paymentMethod: PaymentMethod;
+  buyerEmail: string;
+  buyerPhone?: string;
+  ipAddress?: string;
+  userAgent?: string;
+}
+
+// Service response types
+export interface CreateOrderResponse {
+  orderId: string;
+  orderNumber: string;
+  paymentIntentId: string;
+  total: number;
+  expiresAt: Date;
+}
+
+// Utility types for frontend (populated responses)
+export interface OrderWithEvent extends Omit<Order, 'eventId'> {
+  eventId: {
+    _id: string;
+    title: string;
+    schedule: {
+      venue: {
+        name: string;
+      };
+      startDate: string;
+    };
+  };
+}
+
+export interface OrderWithTickets extends Omit<Order, 'ticketIds'> {
+  ticketIds: Array<{
+    _id: string;
+    ticketNumber: string;
+    qrCode: string;
+    status: 'active' | 'used' | 'cancelled';
+  }>;
+}

package/src/orders/payments.schema.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+
+// Payment status enum
+export const paymentStatusSchema = z.enum(['pending', 'succeeded', 'failed', 'refunded']);
+
+// Payment method enum
+export const paymentMethodSchema = z.enum(['bkash', 'card']);
+
+// Card brand enum
+export const cardBrandSchema = z.enum(['visa', 'mastercard', 'amex', 'discover']);
+
+// Failure codes enum
+export const failureCodeSchema = z.enum([
+  'insufficient_funds',
+  'card_declined',
+  'expired_card',
+  'incorrect_cvc',
+  'processing_error',
+  'issuer_not_available',
+  'invalid_card_number'
+]);
+
+// Main payment schema
+export const paymentSchema = z.object({
+  _id: z.string().optional(), // MongoDB ObjectId
+
+  // LINKS
+  orderId: z.string(), // Which order
+  userId: z.string(), // Who paid
+
+  // STRIPE
+  paymentId: z.string(), // Stripe PI
+
+  // MONEY
+  amount: z.number().min(0),
+  currency: z.string().default('BDT'),
+
+  // STATUS
+  status: paymentStatusSchema,
+
+  // METADATA
+  paymentMethod: paymentMethodSchema,
+  last4: z.string().optional(), // Card last 4 digits
+  brand: cardBrandSchema.optional(), // Card brand
+
+  // FAILURE (if failed)
+  failureCode: failureCodeSchema.optional(),
+  failureMessage: z.string().optional(),
+
+  // REFUND (if refunded)
+  refundId: z.string().optional(), // Stripe refund ID
+  refundAmount: z.number().min(0).optional(),
+  refundedAt: z.date().optional(),
+
+  // TIMESTAMPS
+  createdAt: z.date().default(() => new Date()),
+  succeededAt: z.date().optional(),
+  failedAt: z.date().optional(),
+});
+
+// API request/response schemas
+export const createPaymentSchema = z.object({
+  orderId: z.string(),
+  amount: z.number().min(0),
+  paymentMethod: paymentMethodSchema,
+});
+
+export const updatePaymentStatusSchema = z.object({
+  status: paymentStatusSchema,
+  failureCode: failureCodeSchema.optional(),
+  failureMessage: z.string().optional(),
+});
+
+export const refundPaymentSchema = z.object({
+  refundAmount: z.number().min(0),
+  reason: z.string(),
+});
+
+// Response schemas
+export const paymentResponseSchema = paymentSchema;
+export const paymentsListResponseSchema = z.array(paymentResponseSchema);