@fplpool/fpl-models 1.0.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@fplpool/fpl-models",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Akamelu Sopuruchukwu",
+  "license": "ISC",
+  "description": "Shared application models",
+  "dependencies": {
+    "dotenv": "^17.3.1",
+    "mongoose": "^9.3.0"
+  },
+  "publishConfig": { 
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/austin230196/fpl-models.git"
+  },
+  "bugs": {
+    "url": "https://github.com/austin230196/fpl-models/issues"
+  },
+  "homepage": "https://github.com/austin230196/fpl-models#readme"
+}

package/src/config/index.ts

@@ -0,0 +1,38 @@
+import {config} from "dotenv";
+
+
+config();
+
+
+export default {
+    db: {
+        mongo: {
+            uri: process.env.MONGO_URI || ``,
+            host: process.env.MONGO_HOST || 'localhost',
+            port: process.env.MONGO_PORT || 27017,
+            database: process.env.MONGO_DATABASE || 'fpl',
+        }
+    },
+    models: {
+        user: 'User',
+        userSettings: 'UserSettings',
+        session: 'Session',
+        wallet: 'Wallet',
+        card: 'Card',
+        transaction: 'Transaction',
+        notification: 'Notification',
+        history: 'History',
+        pool: 'Pool',
+        poolGameweekDeadline: 'PoolGameweekDeadline',
+        poolMember: 'PoolMember',
+        poolWallet: 'PoolWallet',
+        poolGameweek: 'PoolGameweek',
+        poolGameweekWinner: 'PoolGameweekWinner',
+        poolInvite: 'PoolInvite',
+        poolTransaction: 'PoolTransaction',
+        poolHistory: 'PoolHistory',
+        job: 'Job',
+        invoice: 'Invoice',
+        config: 'Config',
+    },
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+export * from "./models/user.model";
+export * from "./models/user-settings.model";
+export * from "./models/session.model";
+export * from "./models/wallet.model";
+export * from "./models/card.model";
+export * from "./models/transaction.model";
+export * from "./models/pool.model";
+export * from "./models/pool-gameweek-deadline.model";
+export * from "./models/pool-member.model";
+export * from "./models/pool-wallet.model";
+export * from "./models/pool-gameweek.model";
+export * from "./models/pool-gameweek-winner.model";
+export * from "./models/pool-invite.model";
+export * from "./models/pool-transaction.model";
+export * from "./models/job.model";
+export * from "./models/invoice.model";
+export * from "./models/config.model";
+
+export * from "./repositories/generic.repository";

package/src/models/card.model.ts

@@ -0,0 +1,76 @@
+import { Schema, model, Types, Document } from "mongoose";
+import config from "../config";
+
+
+
+export interface ICard extends Document {
+    _id: Types.ObjectId;
+    paymentMethodId: string;
+    last4: string;
+    brand: string;
+    expiryMonth: number;
+    expiryYear: number;
+    holderName: string;
+    isDefault: boolean;
+    addedAt: Date;
+    updatedAt: Date;
+}
+
+
+
+const cardSchema = new Schema<ICard>({
+    paymentMethodId: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true
+    },
+    last4: {
+        type: String,
+        required: true
+    },
+    brand: {
+        type: String,
+        required: true
+    },
+    expiryMonth: {
+        type: Number,
+        required: true,
+        min: 1,
+        max: 12
+    },
+    expiryYear: {
+        type: Number,
+        required: true
+    },
+    holderName: {
+        type: String,
+        required: true
+    },
+    isDefault: {
+        type: Boolean,
+        default: false
+    },
+}, {
+    timestamps: {
+        createdAt: 'addedAt',
+        updatedAt: true
+    },
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+cardSchema.virtual('expired').get(function(){
+    const currentDate = new Date();
+    const currentYear = currentDate.getFullYear();
+    const currentMonth = currentDate.getMonth() + 1;
+    
+    if (this.expiryYear < currentYear) return true;
+    if (this.expiryYear === currentYear && this.expiryMonth < currentMonth) return true;
+    return false;
+})
+
+const Card = model<ICard>(config.models.card, cardSchema);
+
+export default Card;

package/src/models/config.model.ts

@@ -0,0 +1,52 @@
+import { Document, model, Schema, Types } from "mongoose";
+
+export interface IConfig extends Document {
+    _id: Types.ObjectId;
+    name: string,
+    version: string,
+    gameweek: {
+        active: boolean,
+        current: number,
+        next: number | null,
+        activeTable: null | Record<string, number>
+    }
+}
+
+
+const configSchema = new Schema<IConfig>({
+    name: {
+        type: String,
+        required: true
+    },
+    version: {
+        type: String,
+        required: true
+    },
+    gameweek: {
+        active: {
+            type: Boolean,
+            required: true,
+            default: false
+        },
+        current: {
+            type: Number,
+            required: true,
+        },
+        next: {
+            type: Number,
+            required: true,
+            default: null
+        },
+        activeTable: {
+            type: Object,
+            required: false,
+            default: null
+        }
+    }
+})
+
+
+const Config = model<IConfig>("Config", configSchema);
+
+
+export default Config;

package/src/models/invoice.model.ts

@@ -0,0 +1,100 @@
+import {Document, Schema, Types, model} from "mongoose";
+
+import config from "../config";
+import sperseId from "sperse-id";
+
+
+
+
+
+export enum InvoiceStatus {
+    Pending = "pending",
+    Completed = "completed",
+    Failed = "failed",
+}
+
+export interface IInvoice extends Document {
+    _id: Types.ObjectId;
+    uid: string;
+    wallet: Types.ObjectId;
+    status: InvoiceStatus;
+    receipt?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    description?: string;
+    amount: string;
+    metadata: {
+        paymentMethodType?: InvoicePaymentMethodType,
+        cardId?: Types.ObjectId;
+        currency: string;
+    };
+}
+
+export enum InvoicePaymentMethodType {
+    Card = "card",
+    BankTransfer = "bank_transfer",
+    // Crypto = "crypto",
+}
+
+
+
+const invoiceSchema = new Schema<IInvoice>({
+    uid: {
+        type: String,
+        required: true,
+        unique: true,
+        default: () => sperseId(12, {numbers: true, capitalLetters: false, smallLetters: true})
+    },
+    wallet: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.wallet,
+        required: true
+    },
+    receipt: {
+        type: String,
+        required: false,
+        default: null
+    },
+    status: {
+        type: String,
+        required: [true, 'Status is required'],
+        enum: InvoiceStatus,
+        default: InvoiceStatus.Pending
+    },
+    description: {
+        type: String,
+        required: false,
+        default: null
+    },
+    amount: {
+        type: String,
+        required: true,
+        default: "0.00"
+    },
+    metadata: {
+        paymentMethodType: {
+            type: String,
+            enum: InvoicePaymentMethodType,
+            default: InvoicePaymentMethodType.Card
+        },
+        cardId: {
+            type: String,
+            required: false,
+            default: null
+        },
+        currency: {
+            type: String,
+            required: true,
+            default: "USD"
+        }
+    }
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+const Invoice = model<IInvoice>(config.models.invoice, invoiceSchema)
+
+export default Invoice;

package/src/models/job.model.ts

@@ -0,0 +1,62 @@
+import {Document, Schema, Types, model} from "mongoose";
+
+import config from "../config";
+
+
+
+export enum JobStatus {
+    Pending = "pending",
+    Completed = "completed",
+    Failed = "failed",
+}
+
+export interface IJob extends Document {
+    _id: Types.ObjectId;
+    queueName: string;
+    payload: Record<string, any>;
+    status: JobStatus;
+    createdAt: Date;
+    updatedAt: Date;
+    lastAttemptedAt: Date | null;
+    finalizedAt: Date | null;
+    errorLogs: Array<any> | null;
+}
+
+
+const jobSchema = new Schema<IJob>({
+    queueName: {
+        type: String,
+        required: [true, 'Queue name is required'],
+    },
+    payload: {
+        type: Object
+    },
+    errorLogs: {
+        type: Array,
+        default: null
+    },
+    status: {
+        type: String,
+        required: [true, 'Status is required'],
+        enum: JobStatus,
+        default: JobStatus.Pending
+    },
+    lastAttemptedAt: {
+        type: Date,
+        default: null,
+    },
+    finalizedAt: {
+        type: Date,
+        default: null,
+    },
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+
+const Job = model<IJob>(config.models.job, jobSchema)
+
+export default Job;

package/src/models/pool-gameweek-deadline.model.ts

@@ -0,0 +1,46 @@
+import { Document, Schema, Types, model } from "mongoose";
+import config from "../config";
+import { IPool } from "./pool.model";
+
+
+export enum PoolGameweekDeadlineType {
+    Personal = 'personal',
+    Members = 'members'
+}
+
+export interface IPoolGameweekDeadline extends Document {
+    _id: Types.ObjectId;
+    pool: IPool;
+    type: PoolGameweekDeadlineType;
+    msBeforeDeadline: number;
+}
+
+
+const poolGameweekDeadlineSchema = new Schema<IPoolGameweekDeadline>({
+    pool: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.pool,
+        required: true
+    },
+    type: {
+        type: String,
+        enum: PoolGameweekDeadlineType,
+        default: PoolGameweekDeadlineType.Members
+    },
+    msBeforeDeadline: {
+        type: Number,
+        required: true,
+        default: 1000 * 60 * 30 //30 minutes before deadline
+    }
+}, 
+{
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+}
+);
+
+
+const PoolGameweekDeadline = model<IPoolGameweekDeadline>(config.models.poolGameweekDeadline, poolGameweekDeadlineSchema);
+
+export default PoolGameweekDeadline;

package/src/models/pool-gameweek-winner.model.ts

@@ -0,0 +1,55 @@
+import { Schema, model, Types, Document } from "mongoose";
+import config from "../config";
+
+
+
+
+export enum PoolGameweekWinnerStatus {
+    Pending = "pending",
+    Paid = "paid",
+    Failed = "failed"
+}
+
+export interface IPoolGameweekWinner extends Document {
+    _id: Types.ObjectId;
+    gameweek: Types.ObjectId;
+    winner: Types.ObjectId;
+    score: number;
+    status: PoolGameweekWinnerStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+
+const poolGameweekWinnerSchema = new Schema<IPoolGameweekWinner>({
+    gameweek: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.poolGameweek,
+        required: true
+    },
+    winner: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.poolMember,
+        required: true
+    },
+    score: {
+        type: Number,
+        required: true,
+        default: 0
+    },
+    status: {
+        type: String,
+        enum: PoolGameweekWinnerStatus,
+        default: PoolGameweekWinnerStatus.Pending
+    },
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+
+const PoolGameweekWinner = model<IPoolGameweekWinner>(config.models.poolGameweekWinner, poolGameweekWinnerSchema);
+
+export default PoolGameweekWinner;

package/src/models/pool-gameweek.model.ts

@@ -0,0 +1,114 @@
+import { Schema, model, Types, Document } from "mongoose";
+import config from "../config";
+import { poolAmountPattern } from "./pool-transaction.model";
+import AdvancedError from "../errors/advanced.error";
+import StatusCode from "../enums/status-code.enum";
+
+
+
+
+export interface IPoolGameweek extends Document {
+    _id: Types.ObjectId;
+    pool: Types.ObjectId;
+    gameweek: number;
+    active: boolean;
+    activePlayers: {member: Types.ObjectId, score: number}[];
+    winner: Types.ObjectId | null;
+    balance: string; 
+    startedAt: Date | null;
+    participationRateBps: number;
+    createdAt: Date;
+    updatedAt: Date;
+    hasPaid: (memberId: Types.ObjectId) => Promise<boolean>;
+}
+
+
+const poolGameweekSchema = new Schema<IPoolGameweek>({
+    pool: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.pool,
+        required: true
+    },
+    gameweek: {
+        type: Number,
+        required: true
+    },
+    activePlayers: [{
+        member: {
+            type: Schema.Types.ObjectId,
+            ref: config.models.poolMember,
+        },
+        score: {
+            type: Number,
+            required: true,
+            default: 0
+        }
+    }],
+    active: {
+        type: Boolean,
+        default: false
+    },
+    startedAt: {
+        type: Date,
+        required: false,
+        default: null
+    },
+    participationRateBps: {
+        type: Number,
+        required: false,
+        default: 0
+    },
+    balance: {
+        type: String,
+        required: false,
+        default: "0.00",
+        match: poolAmountPattern,
+        set: function(value: string) {
+            // If value already looks like a float (has a .), ensure two decimals
+            if (typeof value === "string") {
+                if (poolAmountPattern.test(value)) {
+                    // If it has a dot but is not two decimals, pad right
+                    if (value.indexOf('.') !== -1) {
+                        let [whole, decimals] = value.split('.');
+                        if (decimals === undefined) return whole + ".00";
+                        if (decimals.length === 1) return whole + "." + decimals + "0";
+                        if (decimals.length === 2) return value;
+                        if (decimals.length > 2) return whole + "." + decimals.slice(0,2);
+                    }
+                    // No decimal: add .00
+                    return value + ".00";
+                }
+                // If it's an integer, add .00
+                if (/^\d+$/.test(value)) {
+                    return value + ".00";
+                }
+            }
+            return value;
+        }
+    },
+    winner: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.poolGameweekWinner,
+        required: false,
+        default: null
+    }
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+poolGameweekSchema.methods.hasPaid = async function(memberId: Types.ObjectId): Promise<boolean> {
+    try{
+        return await this.activePlayers.some(({member}: {member: Types.ObjectId, score: number}) => member.toString() === memberId.toString());
+    }catch(e: any){
+        throw new AdvancedError(e.message, e.statusCode || StatusCode.INTERNAL_SERVER_ERROR)
+    }
+}
+
+
+
+const PoolGameweek = model<IPoolGameweek>(config.models.poolGameweek, poolGameweekSchema);
+
+export default PoolGameweek;

package/src/models/pool-invite.model.ts

@@ -0,0 +1,65 @@
+import { Schema, model, Types, Document } from "mongoose";
+import config from "../config";
+
+
+export interface IPoolInvite extends Document {
+    _id: Types.ObjectId;
+    pool: Types.ObjectId;
+    email: string;
+    status: PoolInviteStatus;
+    invitedAt: Date;
+    expiresAt: Date;
+    updatedAt: Date;
+    hasExpired: () => Promise<boolean>;
+}
+
+export enum PoolInviteStatus {
+    Pending = "pending",
+    Accepted = "accepted",
+    Declined = "declined",
+    Expired = "expired",
+}
+
+
+const poolInviteSchema = new Schema<IPoolInvite>({
+    pool: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.pool,
+        required: true
+    },
+    email: {
+        type: String,
+        required: true
+    },
+    status: {
+        type: String,
+        required: true,
+        enum: PoolInviteStatus,
+        default: PoolInviteStatus.Pending
+    },
+    expiresAt: {
+        type: Date,
+        required: true,
+        default: new Date(Date.now() + (1000 * 60 * 60 * 24 * 7)) //7 days
+    }
+}, {
+    timestamps: {
+        createdAt: 'invitedAt',
+        updatedAt: true
+    },
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+poolInviteSchema.methods.hasExpired = async function(): Promise<boolean> {
+    if(Date.now() >= this.expiresAt.getTime() && this.status.toString() !== PoolInviteStatus.Expired.toString()){
+        this.status = PoolInviteStatus.Expired;
+        await this.save();
+    }
+    return this.status.toString() === PoolInviteStatus.Expired.toString();
+}
+
+
+const PoolInvite = model<IPoolInvite>(config.models.poolInvite, poolInviteSchema);
+
+export default PoolInvite;