@fplpool/fpl-models 1.0.0

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

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

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

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

@@ -0,0 +1,89 @@
+import { Schema, model, Types, Document } from "mongoose";
+import config from "../config";
+import { poolAmountPattern } from "./pool-transaction.model";
+
+
+
+export interface IPoolWallet extends Document {
+    _id: Types.ObjectId;
+    pool: Types.ObjectId;
+    balance: string;
+    availableBalance: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+const poolWalletSchema = new Schema<IPoolWallet>({
+    pool: {
+        type: Schema.Types.ObjectId, 
+        ref: config.models.pool,
+        required: true
+    },
+    balance: {
+        type: String,
+        required: true,
+        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;
+        },
+        default: "0.00"
+    },
+    availableBalance: {
+        type: String,
+        required: false,
+        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;
+        },
+        default: "0.00"
+    }
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+
+
+const PoolWallet = model<IPoolWallet>(config.models.poolWallet, poolWalletSchema);
+
+export default PoolWallet;

package/src/models/pool.model.ts

@@ -0,0 +1,146 @@
+import { Document, Schema, Types, model } from "mongoose";
+import config from "../config";
+import { PoolType } from "../types/pool";
+import { poolService } from "../services/pool.service";
+
+
+
+
+export interface IPool extends Document {
+    _id: Types.ObjectId;
+    uid: string | null;
+    admin: Types.ObjectId;
+    code: string;
+    private: boolean;
+    name: string;
+    description: string;
+    amount: number;
+    startGameweek: number;
+    currency: string;
+    members: number;
+    maxMembers: number;
+    type: PoolType;
+    status: PoolStatus;
+    createdAt: Date;
+    updatedAt: Date;
+    settings: PoolSettings;
+}
+
+export interface PoolSettings {
+    poolType: PoolSettingsType,
+    percentages: number[];
+}
+
+export enum PoolSettingsType {
+    WinnerTakesAll = 'winner-takes-all',
+    Top3 = 'top-3-split'
+}
+
+export enum PoolStatus {
+    Active = "active",
+    Inactive = "inactive"
+}
+
+
+const poolSchema = new Schema<IPool>({
+    uid: {
+        type: String,
+        required: false,
+        default: null
+    },
+    admin: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.user,
+        required: true
+    },
+    code: {
+        type: String,
+        required: [true, 'Code is required'],
+        trim: true,
+        unique: true,
+        length: [12, 'Code must be 12 characters'],
+    },
+    private: {
+        type: Boolean,
+        required: [true, 'Private is required'],
+        default: false
+    },
+    name: {
+        type: String,
+        required: [true, 'Name is required'],
+        trim: true, // This option removes leading and trailing whitespace from the value before saving to the database
+        unique: [true, 'Pool name already exists'],
+        maxLength: [50, 'Name must be less than 50 characters'],
+    },
+    description: {
+        type: String,
+        required: [true, 'Description is required'],
+        trim: true,
+        maxLength: [200, 'Description must be less than 200 characters'],
+    },
+    members: {
+        type: Number,
+        default: 1
+    },
+    maxMembers: {
+        type: Number,
+        default: 100
+    },
+    amount: {
+        type: Number,
+        required: [true, 'Amount is required'],
+        default: 0
+    },
+    startGameweek: {
+        type: Number,
+        required: [true, 'Start gameweek is required'],
+        default: 1
+    },
+    currency: {
+        type: String,
+        required: [true, 'Currency is required'],
+        default: 'USD'
+    },
+    type: {
+        type: String,
+        required: [true, 'Type is required'],
+        enum: PoolType,
+        default: PoolType.Weekly
+    },
+    status: {
+        type: String,
+        required: [true, 'Status is required'],
+        enum: PoolStatus,
+        default: PoolStatus.Active
+    },
+    settings: {
+        poolType: {
+            type: String,
+            required: [true, 'Pool type is required'],
+            enum: PoolSettingsType,
+            default: PoolSettingsType.WinnerTakesAll
+        },
+        percentages: [{
+            type: Number,
+            required: [true, 'Percentage is required']
+        }]
+    },
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+// poolSchema.method("generateLink", async function(){
+//     const link = await poolService.getPoolInviteLink(this);
+//     return link;
+// })
+
+
+
+
+const Pool = model<IPool>(config.models.pool, poolSchema);
+
+
+export default Pool;

package/src/models/session.model.ts

@@ -0,0 +1,45 @@
+import {Schema, model, Types, Document} from "mongoose";
+
+import config from "../config";
+
+
+
+
+export interface ISession extends Document{
+    _id: Types.ObjectId;
+    user: Types.ObjectId;
+    userAgent: String;
+    device: Object;
+    expired: Boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+
+const sessionSchema = new Schema<ISession>({
+    user: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.user,
+        required: true
+    },
+    device: Object,
+    userAgent: String,
+    expired: {
+        required: true,
+        type: Boolean,
+        default: false
+    },
+}, 
+{
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+});
+
+
+
+
+const Session = model<ISession>(config.models.session, sessionSchema);
+
+
+export default Session;

package/src/models/transaction.model.ts

@@ -0,0 +1,144 @@
+import { randomUUID } from "node:crypto";
+
+import { Schema, model, Types, Document } from "mongoose";
+
+import config from "../config";
+import { poolAmountPattern } from "./pool-transaction.model";
+import { TransactionMethod, TransactionStatus, TransactionType } from "../types/wallet";
+
+
+
+
+
+export interface ITransaction extends Document {
+    _id: Types.ObjectId;
+    key: Types.UUID;
+    wallet: Types.ObjectId;
+    type: TransactionType;
+    paymentIntentId?: string;
+    description: string;
+    amount: string;
+    // currency: string;
+    method: TransactionMethod;
+    metadata: {
+        address?: string;
+        hash?: string;
+        chainId?: number;
+        token?: string;
+        value?: string;
+        cardId?: Types.ObjectId;
+    };
+    status: TransactionStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+
+
+const transactionSchema = new Schema<ITransaction>({
+    wallet: {
+        type: Schema.Types.ObjectId,
+        ref: config.models.wallet,
+        required: true
+    },
+    key: {
+        type: Schema.Types.UUID,
+        required: false,
+        unique: true,
+        default: () => new Types.UUID(randomUUID())
+    },
+    type: {
+        type: String,
+        enum: TransactionType,
+        required: true
+    },
+    description: {
+        type: String,
+        required: false,
+        default: "No description"
+    },
+    paymentIntentId: {
+        type: String,
+        required: false,
+        default: null
+    },
+    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;
+        }
+    },
+    method: {
+        type: String,
+        enum: TransactionMethod,
+        required: false,
+        default: TransactionMethod.Card
+    },
+    metadata: {
+        cardId: {
+            type: Schema.Types.ObjectId,
+            ref: config.models.card,
+            required: false,
+            default: null
+        },
+        address: {
+            type: String,
+            required: false,
+            default: null
+        },
+        hash: {
+            type: String,
+            required: false,
+            default: null
+        },
+        chainId: {
+            type: Number,
+            required: false,
+            default: null
+        },
+        token: {
+            type: String,
+            required: false,
+            default: null
+        },
+    },
+    status: {
+        type: String,
+        enum: TransactionStatus,
+        required: false,
+        default: TransactionStatus.Pending
+    }
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+// transactionSchema.index({paymentIntentId: 1}, {unique: true});
+
+
+const Transaction = model<ITransaction>(config.models.transaction, transactionSchema);
+
+export default Transaction;

package/src/models/user-settings.model.ts

@@ -0,0 +1,53 @@
+import {Document, Schema, model} from "mongoose";
+import { Types } from "mongoose";
+
+import config from "../config";
+
+
+
+
+export interface IUserSettings extends Document {
+    _id: Types.ObjectId;
+    twoFaEnabled: boolean;
+    twoFaSecret?: string;
+    country: string;
+    currency: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+
+const userSettingsSchema = new Schema<IUserSettings>({
+    twoFaEnabled: {
+        type: Boolean,
+        required: [true, 'Two factor authentication is required'],
+        default: false
+    },
+    twoFaSecret: {
+        type: String,
+        required: false,
+        default: null
+    },
+    country: {
+        type: String,
+        required: [true, 'Country is required'],
+        trim: true,
+        maxLength: [50, 'Country must be less than 50 characters'],
+    },
+    currency: {
+        type: String,
+        required: [true, 'Currency is required'],
+        trim: true,
+        maxLength: [50, 'Currency must be less than 50 characters']
+    },
+}, {
+    timestamps: true,
+    toJSON: {virtuals: true},
+    toObject: {virtuals: true}
+})
+
+
+
+const UserSettings = model<IUserSettings>(config.models.userSettings, userSettingsSchema);
+
+export default UserSettings;