@fplpool/fpl-models 1.0.0 → 1.1.0

package/src/models/invoice.model.ts

@@ -1,100 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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;

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

@@ -1,53 +0,0 @@
-import { Document, Schema, Types, model } from "mongoose";
-import config from "../config";
-
-
-export interface IPoolMember extends Document {
-    _id: Types.ObjectId;
-    pool: Types.ObjectId;
-    user: Types.ObjectId;
-    isAdmin: boolean;
-    status: PoolMemberStatus;
-    joinedAt: Date;
-}
-
-export enum PoolMemberStatus {
-    Active = "active",
-    Inactive = "inactive",
-    // Banned = "banned"
-}
-
-const poolMemberSchema = new Schema<IPoolMember>({
-    user: {
-        type: Schema.Types.ObjectId,
-        ref: config.models.user,
-        required: true
-    },
-    pool: {
-        type: Schema.Types.ObjectId,
-        ref: config.models.pool,
-        required: true
-    },
-    isAdmin: {
-        type: Boolean,
-        default: false
-    },
-    status: {
-        type: String,
-        enum: PoolMemberStatus,
-        default: PoolMemberStatus.Active
-    }
-}, {
-    timestamps: {
-        createdAt: 'joinedAt',
-        updatedAt: false
-    },
-    toJSON: {virtuals: true},
-    toObject: {virtuals: true}
-})
-
-
-const PoolMember = model<IPoolMember>(config.models.poolMember, poolMemberSchema);
-
-
-export default PoolMember;

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

@@ -1,130 +0,0 @@
-import { randomUUID } from "node:crypto";
-
-import { Schema, model, Types, Document } from "mongoose";
-
-import config from "../config";
-import { TransactionMethod, TransactionStatus, TransactionType } from "../types/wallet";
-
-
-
-
-
-export interface IPoolTransaction extends Document {
-    _id: Types.ObjectId;
-    key: Types.UUID;
-    wallet: Types.ObjectId;
-    member: Types.ObjectId;
-    paymentIntentId?: string;
-    amount: string;
-    description: string;
-    method: TransactionMethod;
-    type: TransactionType;
-    status: TransactionStatus;
-    metadata: {
-        cardId?: Types.ObjectId;
-        receiver?: Types.ObjectId;
-        gameweeks?: number[];
-    };
-    createdAt: Date;
-    updatedAt: Date;
-}
-
-export const poolAmountPattern = /^\d+(\.\d{1,2})?$/;
-
-const poolTransactionSchema = new Schema<IPoolTransaction>({
-    wallet: {
-        type: Schema.Types.ObjectId,
-        ref: config.models.poolWallet,
-    },
-    member: {
-        type: Schema.Types.ObjectId,
-        ref: config.models.poolMember
-    },
-    key: {
-        type: Schema.Types.UUID,
-        required: false,
-        unique: true,
-        default: () => new Types.UUID(randomUUID())
-    },
-    paymentIntentId: {
-        type: String,
-        required: false
-    },
-    amount: {
-        type: String,
-        required: false, 
-        default: "0.00",
-        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;
-        }
-    },
-    description: {
-        type: String,
-        required: true
-    },
-    method: {
-        type: String,
-        enum: TransactionMethod,
-        default: TransactionMethod.Wallet,
-        required: true
-    },
-    metadata: {
-        cardId: {
-            type: Schema.Types.ObjectId,
-            ref: config.models.card,
-            required: false,
-            default: null
-        },
-        receiver: {
-            type: Schema.Types.ObjectId,
-            ref: config.models.user,
-            required: false,
-            default: null
-        },
-        gameweeks: {
-            type: Array<number>,
-            required: false,
-            default: null
-        }
-    },
-    type: {
-        type: String,
-        enum: TransactionType,
-        required: true
-    },
-    status: {
-        type: String,
-        enum: TransactionStatus,
-        required: true,
-        default: TransactionStatus.Pending
-    }
-}, {
-    timestamps: true,
-    toJSON: {virtuals: true},
-    toObject: {virtuals: true}
-})
-
-
-const PoolTransaction = model<IPoolTransaction>(config.models.poolTransaction, poolTransactionSchema);
-
-
-export default PoolTransaction;