@mac777/project-pinecone-schema 1.0.0 → 1.0.2

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);

package/src/orders/payments.type.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import {
+  paymentSchema,
+  paymentStatusSchema,
+  paymentMethodSchema,
+  cardBrandSchema,
+  failureCodeSchema,
+  createPaymentSchema,
+  updatePaymentStatusSchema,
+  refundPaymentSchema,
+  paymentResponseSchema,
+  paymentsListResponseSchema
+} from './payments.schema';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+// Enum types
+export type PaymentStatus = z.infer<typeof paymentStatusSchema>;
+export type PaymentMethod = z.infer<typeof paymentMethodSchema>;
+export type CardBrand = z.infer<typeof cardBrandSchema>;
+export type FailureCode = z.infer<typeof failureCodeSchema>;
+
+// Main payment type
+export type Payment = z.infer<typeof paymentSchema>;
+
+// API request/response types
+export type CreatePaymentRequest = z.infer<typeof createPaymentSchema>;
+export type UpdatePaymentStatusRequest = z.infer<typeof updatePaymentStatusSchema>;
+export type RefundPaymentRequest = z.infer<typeof refundPaymentSchema>;
+
+export type PaymentResponse = z.infer<typeof paymentResponseSchema>;
+export type PaymentsListResponse = z.infer<typeof paymentsListResponseSchema>;
+
+// Service method parameter types
+export interface CreatePaymentData {
+  orderId: string;
+  userId: string;
+  paymentId: string;
+  amount: number;
+  currency?: string;
+  paymentMethod: PaymentMethod;
+  last4?: string;
+  brand?: CardBrand;
+}
+
+export interface UpdatePaymentData {
+  paymentId: string;
+  status: PaymentStatus;
+  failureCode?: FailureCode;
+  failureMessage?: string;
+}
+
+export interface RefundPaymentData {
+  paymentId: string;
+  refundAmount: number;
+  refundId: string;
+  reason: string;
+}
+
+// Utility types for frontend
+export interface PaymentWithOrder extends Omit<Payment, 'orderId'> {
+  orderId: {
+    _id: string;
+    orderNumber: string;
+    eventId: {
+      _id: string;
+      title: string;
+      schedule: {
+        startDate: string;
+        venue: {
+          name: string;
+        };
+      };
+    };
+  };
+}
+
+export interface PaymentSummary {
+  totalPayments: number;
+  successfulPayments: number;
+  failedPayments: number;
+  refundedPayments: number;
+  totalAmount: number;
+  totalRefunded: number;
+}

package/src/orders/ticket.schema.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+
+// Ticket status enum
+export const ticketStatusSchema = z.enum(['valid', 'used', 'cancelled', 'refunded', 'transferred']);
+
+// Check-in status enum
+export const checkInStatusSchema = z.enum(['not_checked_in', 'checked_in']);
+
+// Main ticket schema
+export const ticketSchema = z.object({
+  _id: z.string().optional(), // MongoDB ObjectId
+  ticketNumber: z.string().regex(/^TKT-[A-Z0-9]{6}-[A-Z0-9]{4}-\d{2}$/), // TKT-EVT123-A3K9-01
+
+  // BELONGS TO
+  orderId: z.string(), // Parent order
+  eventId: z.string(), // Which event
+  userId: z.string(), // Owner
+  ticketVariantId: z.string(), // Which type (VIP, GA, etc)
+
+  // DETAILS (denormalized for speed)
+  eventTitle: z.string(),
+  eventDate: z.date(),
+  eventVenue: z.string(),
+  ticketType: z.string(), // "VIP Pass"
+  price: z.number().min(0),
+
+  // QR CODE
+  qrCode: z.string(), // SHA256 hash
+  qrCodeUrl: z.string(), // ImageKit/S3 URL
+
+  // STATUS
+  status: ticketStatusSchema,
+
+  // CHECK-IN
+  checkInStatus: checkInStatusSchema,
+  checkedInAt: z.date().optional(),
+  checkedInBy: z.string().optional(), // Staff user ID
+
+  // TRANSFER
+  transferredTo: z.string().optional(), // New owner user ID
+  transferredAt: z.date().optional(),
+
+  // LIFECYCLE
+  issuedAt: z.date().default(() => new Date()),
+  validUntil: z.date(), // Event end date
+
+  // SECURITY
+  secretHash: z.string(), // Internal validation hash
+});
+
+// API request/response schemas
+export const createTicketSchema = z.object({
+  orderId: z.string(),
+  eventId: z.string(),
+  userId: z.string(),
+  ticketVariantId: z.string(),
+  eventTitle: z.string(),
+  eventDate: z.date(),
+  eventVenue: z.string(),
+  ticketType: z.string(),
+  price: z.number().min(0),
+});
+
+export const updateTicketStatusSchema = z.object({
+  status: ticketStatusSchema,
+});
+
+export const checkInTicketSchema = z.object({
+  staffUserId: z.string(),
+});
+
+export const transferTicketSchema = z.object({
+  newOwnerId: z.string(),
+});
+
+// Response schemas
+export const ticketResponseSchema = ticketSchema;
+export const ticketsListResponseSchema = z.array(ticketResponseSchema);

package/src/orders/ticket.type.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import {
+  ticketSchema,
+  ticketStatusSchema,
+  checkInStatusSchema,
+  createTicketSchema,
+  updateTicketStatusSchema,
+  checkInTicketSchema,
+  transferTicketSchema,
+  ticketResponseSchema,
+  ticketsListResponseSchema
+} from './ticket.schema';
+
+// =============================================================================
+// TYPE EXPORTS
+// =============================================================================
+
+// Enum types
+export type TicketStatus = z.infer<typeof ticketStatusSchema>;
+export type CheckInStatus = z.infer<typeof checkInStatusSchema>;
+
+// Main ticket type
+export type Ticket = z.infer<typeof ticketSchema>;
+
+// API request/response types
+export type CreateTicketRequest = z.infer<typeof createTicketSchema>;
+export type UpdateTicketStatusRequest = z.infer<typeof updateTicketStatusSchema>;
+export type CheckInTicketRequest = z.infer<typeof checkInTicketSchema>;
+export type TransferTicketRequest = z.infer<typeof transferTicketSchema>;
+
+export type TicketResponse = z.infer<typeof ticketResponseSchema>;
+export type TicketsListResponse = z.infer<typeof ticketsListResponseSchema>;
+
+// Service method parameter types
+export interface CreateTicketData {
+  orderId: string;
+  eventId: string;
+  userId: string;
+  ticketVariantId: string;
+  eventTitle: string;
+  eventDate: Date;
+  eventVenue: string;
+  ticketType: string;
+  price: number;
+  quantity: number; // For creating multiple tickets
+}
+
+export interface UpdateTicketData {
+  ticketId: string;
+  status: TicketStatus;
+}
+
+export interface CheckInTicketData {
+  ticketId: string;
+  staffUserId: string;
+}
+
+export interface TransferTicketData {
+  ticketId: string;
+  newOwnerId: string;
+}
+
+// Utility types for frontend
+export interface TicketWithOrder extends Omit<Ticket, 'orderId'> {
+  orderId: {
+    _id: string;
+    orderNumber: string;
+    status: string;
+    createdAt: string;
+  };
+}
+
+export interface TicketWithEvent extends Omit<Ticket, 'eventId'> {
+  eventId: {
+    _id: string;
+    title: string;
+    schedule: {
+      startDate: string;
+      venue: {
+        name: string;
+      };
+    };
+  };
+}
+
+export interface TicketSummary {
+  totalTickets: number;
+  validTickets: number;
+  usedTickets: number;
+  checkedInTickets: number;
+  cancelledTickets: number;
+  refundedTickets: number;
+}
+
+// QR Code generation types
+export interface QRCodeData {
+  ticketId: string;
+  ticketNumber: string;
+  eventTitle: string;
+  eventDate: string;
+  userId: string;
+  secretHash: string;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}

package/dist/auth.d.ts

@@ -1 +0,0 @@
-export * from './auth/index';

package/dist/auth.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// Re-export from the modular auth structure
-__exportStar(require("./auth/index"), exports);