@mac777/project-pinecone-models 1.0.0

package/dist/Payment.d.ts

@@ -0,0 +1,61 @@
+import mongoose from 'mongoose';
+declare const paymentSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    createdAt: NativeDate;
+    status: "pending" | "refunded" | "succeeded" | "failed";
+    amount: number;
+    currency: string;
+    userId: mongoose.Types.ObjectId;
+    paymentId: string;
+    paymentMethod: "card" | "bkash";
+    orderId: mongoose.Types.ObjectId;
+    refundedAt?: NativeDate | null | undefined;
+    last4?: string | null | undefined;
+    failureCode?: string | null | undefined;
+    failureMessage?: string | null | undefined;
+    refundId?: string | null | undefined;
+    refundAmount?: number | null | undefined;
+    succeededAt?: NativeDate | null | undefined;
+    failedAt?: NativeDate | null | undefined;
+    brand?: "visa" | "mastercard" | "amex" | "discover" | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    status: "pending" | "refunded" | "succeeded" | "failed";
+    amount: number;
+    currency: string;
+    userId: mongoose.Types.ObjectId;
+    paymentId: string;
+    paymentMethod: "card" | "bkash";
+    orderId: mongoose.Types.ObjectId;
+    refundedAt?: NativeDate | null | undefined;
+    last4?: string | null | undefined;
+    failureCode?: string | null | undefined;
+    failureMessage?: string | null | undefined;
+    refundId?: string | null | undefined;
+    refundAmount?: number | null | undefined;
+    succeededAt?: NativeDate | null | undefined;
+    failedAt?: NativeDate | null | undefined;
+    brand?: "visa" | "mastercard" | "amex" | "discover" | null | undefined;
+}>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    status: "pending" | "refunded" | "succeeded" | "failed";
+    amount: number;
+    currency: string;
+    userId: mongoose.Types.ObjectId;
+    paymentId: string;
+    paymentMethod: "card" | "bkash";
+    orderId: mongoose.Types.ObjectId;
+    refundedAt?: NativeDate | null | undefined;
+    last4?: string | null | undefined;
+    failureCode?: string | null | undefined;
+    failureMessage?: string | null | undefined;
+    refundId?: string | null | undefined;
+    refundAmount?: number | null | undefined;
+    succeededAt?: NativeDate | null | undefined;
+    failedAt?: NativeDate | null | undefined;
+    brand?: "visa" | "mastercard" | "amex" | "discover" | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default paymentSchema;

package/dist/Payment.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+// Payment schema for transaction logging
+const paymentSchema = new mongoose_1.default.Schema({
+    // LINKS
+    orderId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true, index: true }, // Which order
+    userId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true, index: true }, // Who paid
+    paymentId: { type: String, required: true, unique: true, index: true }, // Stripe PI (unique)
+    // MONEY
+    amount: { type: Number, required: true },
+    currency: { type: String, required: true, default: 'BDT' },
+    // STATUS
+    status: {
+        type: String,
+        required: true,
+        enum: ['pending', 'succeeded', 'failed', 'refunded'],
+        default: 'pending'
+    },
+    // METADATA
+    paymentMethod: { type: String, required: true, enum: ['bkash', 'card'] },
+    last4: String, // Card last 4 digits (for receipt)
+    brand: { type: String, enum: ['visa', 'mastercard', 'amex', 'discover'] }, // Card brand
+    // FAILURE (if failed)
+    failureCode: String, // "insufficient_funds", "card_declined", etc.
+    failureMessage: String,
+    // REFUND (if refunded)
+    refundId: String, // Stripe refund ID
+    refundAmount: Number,
+    refundedAt: Date,
+    // TIMESTAMPS
+    createdAt: { type: Date, default: Date.now },
+    succeededAt: Date,
+    failedAt: Date,
+});
+// Indexes for performance
+paymentSchema.index({ orderId: 1 });
+paymentSchema.index({ userId: 1, createdAt: -1 });
+paymentSchema.index({ status: 1, createdAt: -1 });
+// Pre-save middleware to set timestamps based on status
+paymentSchema.pre('save', function (next) {
+    if (this.isModified('status')) {
+        const now = new Date();
+        if (this.status === 'succeeded' && !this.succeededAt) {
+            this.succeededAt = now;
+        }
+        else if (this.status === 'failed' && !this.failedAt) {
+            this.failedAt = now;
+        }
+    }
+    next();
+});
+exports.default = paymentSchema;

package/dist/Ticket.d.ts

@@ -0,0 +1,73 @@
+import mongoose from 'mongoose';
+declare const ticketSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+    status: "cancelled" | "refunded" | "valid" | "used" | "transferred";
+    price: number;
+    userId: mongoose.Types.ObjectId;
+    ticketVariantId: mongoose.Types.ObjectId;
+    eventId: mongoose.Types.ObjectId;
+    orderId: mongoose.Types.ObjectId;
+    ticketNumber: string;
+    eventTitle: string;
+    eventDate: NativeDate;
+    eventVenue: string;
+    ticketType: string;
+    qrCode: string;
+    qrCodeUrl: string;
+    checkInStatus: "not_checked_in" | "checked_in";
+    issuedAt: NativeDate;
+    validUntil: NativeDate;
+    secretHash: string;
+    checkedInAt?: NativeDate | null | undefined;
+    checkedInBy?: mongoose.Types.ObjectId | null | undefined;
+    transferredTo?: mongoose.Types.ObjectId | null | undefined;
+    transferredAt?: NativeDate | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    status: "cancelled" | "refunded" | "valid" | "used" | "transferred";
+    price: number;
+    userId: mongoose.Types.ObjectId;
+    ticketVariantId: mongoose.Types.ObjectId;
+    eventId: mongoose.Types.ObjectId;
+    orderId: mongoose.Types.ObjectId;
+    ticketNumber: string;
+    eventTitle: string;
+    eventDate: NativeDate;
+    eventVenue: string;
+    ticketType: string;
+    qrCode: string;
+    qrCodeUrl: string;
+    checkInStatus: "not_checked_in" | "checked_in";
+    issuedAt: NativeDate;
+    validUntil: NativeDate;
+    secretHash: string;
+    checkedInAt?: NativeDate | null | undefined;
+    checkedInBy?: mongoose.Types.ObjectId | null | undefined;
+    transferredTo?: mongoose.Types.ObjectId | null | undefined;
+    transferredAt?: NativeDate | null | undefined;
+}>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<{
+    status: "cancelled" | "refunded" | "valid" | "used" | "transferred";
+    price: number;
+    userId: mongoose.Types.ObjectId;
+    ticketVariantId: mongoose.Types.ObjectId;
+    eventId: mongoose.Types.ObjectId;
+    orderId: mongoose.Types.ObjectId;
+    ticketNumber: string;
+    eventTitle: string;
+    eventDate: NativeDate;
+    eventVenue: string;
+    ticketType: string;
+    qrCode: string;
+    qrCodeUrl: string;
+    checkInStatus: "not_checked_in" | "checked_in";
+    issuedAt: NativeDate;
+    validUntil: NativeDate;
+    secretHash: string;
+    checkedInAt?: NativeDate | null | undefined;
+    checkedInBy?: mongoose.Types.ObjectId | null | undefined;
+    transferredTo?: mongoose.Types.ObjectId | null | undefined;
+    transferredAt?: NativeDate | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default ticketSchema;

package/dist/Ticket.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+// Ticket schema for individual issued tickets
+const ticketSchema = new mongoose_1.default.Schema({
+    ticketNumber: { type: String, required: true, unique: true, index: true }, // Human-readable: "TKT-EVT123-A3K9-01"
+    // BELONGS TO
+    orderId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true, index: true }, // Parent order
+    eventId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true, index: true }, // Which event
+    userId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true, index: true }, // Owner
+    ticketVariantId: { type: mongoose_1.default.Schema.Types.ObjectId, required: true }, // Which type (VIP, GA, etc)
+    // DETAILS (denormalized for speed)
+    eventTitle: { type: String, required: true },
+    eventDate: { type: Date, required: true },
+    eventVenue: { type: String, required: true },
+    ticketType: { type: String, required: true }, // "VIP Pass"
+    price: { type: Number, required: true },
+    // QR CODE
+    qrCode: { type: String, unique: true, required: true }, // Unique hash: SHA256(ticketId + secret)
+    qrCodeUrl: { type: String, required: true }, // ImageKit/S3 URL to QR image
+    // STATUS
+    status: {
+        type: String,
+        required: true,
+        enum: ['valid', 'used', 'cancelled', 'refunded', 'transferred'],
+        default: 'valid',
+        index: true
+    },
+    // CHECK-IN
+    checkInStatus: {
+        type: String,
+        required: true,
+        enum: ['not_checked_in', 'checked_in'],
+        default: 'not_checked_in'
+    },
+    checkedInAt: Date,
+    checkedInBy: mongoose_1.default.Schema.Types.ObjectId, // Staff/scanner user ID
+    // TRANSFER (if user transfers ticket to friend)
+    transferredTo: mongoose_1.default.Schema.Types.ObjectId, // New owner user ID
+    transferredAt: Date,
+    // LIFECYCLE
+    issuedAt: { type: Date, default: Date.now }, // When ticket was created
+    validUntil: { type: Date, required: true }, // Event end date (after this, ticket expires)
+    // SECURITY
+    secretHash: { type: String, required: true }, // Internal validation hash (never exposed)
+});
+// Pre-save middleware to set default validUntil if not provided
+ticketSchema.pre('save', function (next) {
+    if (this.isNew && !this.validUntil && this.eventDate) {
+        // Set validUntil to end of event day if eventDate is provided
+        const eventEnd = new Date(this.eventDate);
+        eventEnd.setHours(23, 59, 59, 999); // End of the event day
+        this.validUntil = eventEnd;
+    }
+    next();
+});
+// Virtual for checking if ticket is expired
+ticketSchema.virtual('isExpired').get(function () {
+    return new Date() > this.validUntil;
+});
+// Method to check if ticket can be used
+ticketSchema.methods.canBeUsed = function () {
+    return this.status === 'valid' &&
+        this.checkInStatus === 'not_checked_in' &&
+        !this.isExpired;
+};
+// Method to mark as used (check-in)
+ticketSchema.methods.checkIn = function (staffUserId) {
+    if (!this.canBeUsed()) {
+        throw new Error('Ticket cannot be checked in');
+    }
+    this.checkInStatus = 'checked_in';
+    this.checkedInAt = new Date();
+    this.checkedInBy = new mongoose_1.default.Types.ObjectId(staffUserId);
+    return this.save();
+};
+// Method to transfer ticket
+ticketSchema.methods.transfer = function (newOwnerId) {
+    if (this.status !== 'valid') {
+        throw new Error('Only valid tickets can be transferred');
+    }
+    this.transferredTo = new mongoose_1.default.Types.ObjectId(newOwnerId);
+    this.transferredAt = new Date();
+    this.userId = new mongoose_1.default.Types.ObjectId(newOwnerId); // Update ownership
+    return this.save();
+};
+exports.default = ticketSchema;

package/dist/User.d.ts

@@ -0,0 +1,41 @@
+import mongoose from "mongoose";
+declare const userSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    email: string;
+    role: "user" | "host" | "admin";
+    provider: "google" | "local";
+    firstName: string;
+    lastName: string;
+    password?: string | null | undefined;
+    organization?: string | null | undefined;
+    refreshToken?: string | null | undefined;
+    googleId?: string | null | undefined;
+} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    email: string;
+    role: "user" | "host" | "admin";
+    provider: "google" | "local";
+    firstName: string;
+    lastName: string;
+    password?: string | null | undefined;
+    organization?: string | null | undefined;
+    refreshToken?: string | null | undefined;
+    googleId?: string | null | undefined;
+} & mongoose.DefaultTimestampProps>, {}, mongoose.ResolveSchemaOptions<{
+    timestamps: true;
+}>> & mongoose.FlatRecord<{
+    email: string;
+    role: "user" | "host" | "admin";
+    provider: "google" | "local";
+    firstName: string;
+    lastName: string;
+    password?: string | null | undefined;
+    organization?: string | null | undefined;
+    refreshToken?: string | null | undefined;
+    googleId?: string | null | undefined;
+} & mongoose.DefaultTimestampProps> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export default userSchema;

package/dist/User.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const userSchema = new mongoose_1.default.Schema({
+    firstName: {
+        type: String,
+        required: true
+    },
+    lastName: {
+        type: String,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    password: {
+        type: String,
+        required: false
+    },
+    organization: {
+        type: String,
+        required: false
+    },
+    role: {
+        type: String,
+        enum: ['user', 'host', 'admin'],
+        default: 'user'
+    },
+    refreshToken: {
+        type: String,
+        required: false
+    },
+    provider: {
+        type: String,
+        enum: ['google', 'local'],
+        default: 'local'
+    },
+    googleId: {
+        type: String,
+        required: false
+    }
+}, {
+    timestamps: true
+});
+exports.default = userSchema;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { default as eventSchema } from './Event';
+export { default as ticketSchema } from './Ticket';
+export { default as mediaSchema } from './Media';
+export { default as bkashSchema } from './Bkash';
+export { default as paymentSchema } from './Payment';
+export { default as orderSchema } from './Order';
+export { default as userSchema } from './User';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userSchema = exports.orderSchema = exports.paymentSchema = exports.bkashSchema = exports.mediaSchema = exports.ticketSchema = exports.eventSchema = void 0;
+// Shared database models for Pinecone microservices
+var Event_1 = require("./Event");
+Object.defineProperty(exports, "eventSchema", { enumerable: true, get: function () { return __importDefault(Event_1).default; } });
+var Ticket_1 = require("./Ticket");
+Object.defineProperty(exports, "ticketSchema", { enumerable: true, get: function () { return __importDefault(Ticket_1).default; } });
+var Media_1 = require("./Media");
+Object.defineProperty(exports, "mediaSchema", { enumerable: true, get: function () { return __importDefault(Media_1).default; } });
+var Bkash_1 = require("./Bkash");
+Object.defineProperty(exports, "bkashSchema", { enumerable: true, get: function () { return __importDefault(Bkash_1).default; } });
+var Payment_1 = require("./Payment");
+Object.defineProperty(exports, "paymentSchema", { enumerable: true, get: function () { return __importDefault(Payment_1).default; } });
+var Order_1 = require("./Order");
+Object.defineProperty(exports, "orderSchema", { enumerable: true, get: function () { return __importDefault(Order_1).default; } });
+var User_1 = require("./User");
+Object.defineProperty(exports, "userSchema", { enumerable: true, get: function () { return __importDefault(User_1).default; } });

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@mac777/project-pinecone-models",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  },
+  "dependencies": {
+    "mongoose": "^8.0.0",
+    "zod": "^3.22.4",
+    "zxcvbn": "^4.4.2"
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}