vr-models 1.0.42 → 1.0.44

package/dist/models/eventLog.models.d.ts

@@ -22,7 +22,7 @@ export interface EventLogAttributes {
     metadata: Record<string, any>;
     ipAddress: string | null;
     userAgent: string | null;
-    deviceSession: DeviceSessionPayload | null;
+    deviceSession?: DeviceSessionPayload | null;
     authTokenVersion?: number;
     createdAt: Date;
     actor?: User;

package/dist/models/eventLog.models.js

@@ -112,10 +112,11 @@ class EventLog extends vr_migrations_1.Model {
                 type: vr_migrations_1.DataTypes.TEXT,
                 allowNull: true,
             },
+            // In EventLog.initialize()
             deviceSession: {
                 type: vr_migrations_1.DataTypes.JSONB,
                 allowNull: true,
-                field: "session", // Keep column name as 'session' for backward compatibility
+                field: "session",
                 validate: {
                     isValidDeviceSessionObject(value) {
                         if (value === null || value === undefined)
@@ -123,12 +124,44 @@ class EventLog extends vr_migrations_1.Model {
                         if (typeof value !== "object" || Array.isArray(value)) {
                             throw new Error("Device session must be a session object");
                         }
-                        if (typeof value.sessionId !== "string" ||
-                            typeof value.startedAt !== "number" ||
-                            typeof value.expiresAt !== "number" ||
-                            typeof value.userId !== "string" ||
-                            typeof value.tokenVersion !== "number") {
-                            throw new Error("Invalid device session object: must have sessionId, startedAt, expiresAt, userId, and tokenVersion");
+                        // Required fields for device sessions
+                        const required = [
+                            "sessionId",
+                            "startedAt",
+                            "expiresAt",
+                            "userId",
+                            "tokenVersion",
+                            "deviceSerialNumber",
+                            "minutesGranted",
+                            "isExtension",
+                            "paymentPlanId",
+                        ];
+                        for (const field of required) {
+                            if (!(field in value)) {
+                                throw new Error(`Device session missing required field: ${field}`);
+                            }
+                        }
+                        // Type validation
+                        if (typeof value.sessionId !== "string") {
+                            throw new Error("sessionId must be a string");
+                        }
+                        if (typeof value.startedAt !== "number") {
+                            throw new Error("startedAt must be a number");
+                        }
+                        if (typeof value.expiresAt !== "number") {
+                            throw new Error("expiresAt must be a number");
+                        }
+                        if (typeof value.userId !== "string") {
+                            throw new Error("userId must be a string");
+                        }
+                        if (typeof value.tokenVersion !== "number") {
+                            throw new Error("tokenVersion must be a number");
+                        }
+                        if (typeof value.deviceSerialNumber !== "string") {
+                            throw new Error("deviceSerialNumber must be a string");
+                        }
+                        if (typeof value.minutesGranted !== "number") {
+                            throw new Error("minutesGranted must be a number");
                         }
                     },
                 },

package/dist/models/phoneContact.models.d.ts

@@ -0,0 +1,76 @@
+import { Model, InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute, ModelStatic } from "vr-migrations";
+import type { User } from "./user.models";
+export interface PhoneContactAttributes {
+    id: string;
+    phoneNumber: string;
+    userId: string | null;
+    isVerified: boolean;
+    verifiedAt: Date | null;
+    isPrimary: boolean;
+    isActive: boolean;
+    otp: string | null;
+    otpExpiresAt: Date | null;
+    metadata: {
+        lastOtpSentAt?: Date;
+        otpAttempts?: number;
+        lastFailedAttemptAt?: Date;
+        isLocked?: boolean;
+        lockedUntil?: Date;
+        carrier?: string;
+        countryCode?: string;
+        deactivatedAt?: Date | null;
+        deactivationReason?: string;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    user?: NonAttribute<User>;
+}
+export interface PhoneContactCreationAttributes extends Omit<PhoneContactAttributes, "id" | "createdAt" | "updatedAt" | "metadata"> {
+    id?: string;
+    metadata?: Record<string, any>;
+}
+export declare class PhoneContact extends Model<InferAttributes<PhoneContact>, InferCreationAttributes<PhoneContact>> implements PhoneContactAttributes {
+    id: CreationOptional<string>;
+    phoneNumber: string;
+    userId: CreationOptional<string | null>;
+    isVerified: CreationOptional<boolean>;
+    verifiedAt: CreationOptional<Date | null>;
+    isPrimary: CreationOptional<boolean>;
+    isActive: CreationOptional<boolean>;
+    otp: CreationOptional<string | null>;
+    otpExpiresAt: CreationOptional<Date | null>;
+    metadata: CreationOptional<{
+        lastOtpSentAt?: Date;
+        otpAttempts?: number;
+        lastFailedAttemptAt?: Date;
+        isLocked?: boolean;
+        lockedUntil?: Date;
+        carrier?: string;
+        countryCode?: string;
+        deactivatedAt?: Date | null;
+        deactivationReason?: string;
+    }>;
+    readonly createdAt: CreationOptional<Date>;
+    readonly updatedAt: CreationOptional<Date>;
+    user?: NonAttribute<User>;
+    static initialize(sequelize: any): void;
+    static associate(models: Record<string, ModelStatic<Model>>): void;
+    generateOTP(length?: number): Promise<string>;
+    verifyOTP(otp: string): Promise<boolean>;
+    markAsVerified(): Promise<void>;
+    markAsPrimary(): Promise<void>;
+    unmarkAsPrimary(): Promise<void>;
+    deactivate(reason?: string): Promise<void>;
+    reactivate(): Promise<void>;
+    isLocked(): boolean;
+    getRemainingLockTime(): number | null;
+    isExpired(): boolean;
+    getRemainingOTPTime(): number | null;
+    static findByPhoneNumber(phoneNumber: string): Promise<PhoneContact | null>;
+    static findVerifiedByPhoneNumber(phoneNumber: string): Promise<PhoneContact | null>;
+    static getUserPrimaryPhone(userId: string): Promise<PhoneContact | null>;
+    static getUserPhones(userId: string): Promise<PhoneContact[]>;
+    static isPhoneNumberAvailable(phoneNumber: string): Promise<boolean>;
+    static cleanupExpiredOTPs(): Promise<void>;
+}
+export type PhoneContactModel = typeof PhoneContact;

package/dist/models/phoneContact.models.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhoneContact = void 0;
+const vr_migrations_1 = require("vr-migrations");
+class PhoneContact extends vr_migrations_1.Model {
+    // Static initialization method
+    static initialize(sequelize) {
+        this.init({
+            id: {
+                type: vr_migrations_1.DataTypes.UUID,
+                defaultValue: vr_migrations_1.DataTypes.UUIDV4,
+                primaryKey: true,
+                allowNull: false,
+            },
+            phoneNumber: {
+                type: vr_migrations_1.DataTypes.STRING(20),
+                allowNull: false,
+                unique: true,
+                validate: {
+                    is: /^\+?[0-9]{10,15}$/,
+                },
+            },
+            userId: {
+                type: vr_migrations_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: "users",
+                    key: "id",
+                },
+                onUpdate: "CASCADE",
+                onDelete: "SET NULL",
+            },
+            isVerified: {
+                type: vr_migrations_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false,
+            },
+            verifiedAt: {
+                type: vr_migrations_1.DataTypes.DATE,
+                allowNull: true,
+            },
+            isPrimary: {
+                type: vr_migrations_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: false,
+            },
+            isActive: {
+                type: vr_migrations_1.DataTypes.BOOLEAN,
+                allowNull: false,
+                defaultValue: true,
+            },
+            otp: {
+                type: vr_migrations_1.DataTypes.STRING(10),
+                allowNull: true,
+            },
+            otpExpiresAt: {
+                type: vr_migrations_1.DataTypes.DATE,
+                allowNull: true,
+            },
+            metadata: {
+                type: vr_migrations_1.DataTypes.JSONB,
+                allowNull: false,
+                defaultValue: {
+                    otpAttempts: 0,
+                    isLocked: false,
+                },
+            },
+            createdAt: {
+                type: vr_migrations_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: vr_migrations_1.DataTypes.NOW,
+            },
+            updatedAt: {
+                type: vr_migrations_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: vr_migrations_1.DataTypes.NOW,
+            },
+        }, {
+            sequelize,
+            modelName: "PhoneContact",
+            tableName: "phone_contacts",
+            timestamps: true,
+            freezeTableName: true,
+            indexes: [
+                {
+                    unique: true,
+                    fields: ["phoneNumber"],
+                    name: "phone_contacts_phone_number_unique",
+                },
+                {
+                    fields: ["userId"],
+                    name: "phone_contacts_user_id_idx",
+                },
+                {
+                    fields: ["isVerified", "isPrimary"],
+                    name: "phone_contacts_verified_primary_idx",
+                },
+                {
+                    fields: ["otpExpiresAt"],
+                    name: "phone_contacts_otp_expiry_idx",
+                },
+            ],
+        });
+    }
+    // Static association method
+    static associate(models) {
+        this.belongsTo(models.User, {
+            foreignKey: "userId",
+            as: "user",
+            onDelete: "SET NULL",
+            onUpdate: "CASCADE",
+        });
+    }
+    // Custom instance methods
+    async generateOTP(length = 6) {
+        const digits = "0123456789";
+        let otp = "";
+        for (let i = 0; i < length; i++) {
+            otp += digits[Math.floor(Math.random() * 10)];
+        }
+        const expiryMinutes = parseInt(process.env.OTP_EXPIRY_MINUTES || "15");
+        const expiresAt = new Date();
+        expiresAt.setMinutes(expiresAt.getMinutes() + expiryMinutes);
+        this.otp = otp;
+        this.otpExpiresAt = expiresAt;
+        // Update metadata
+        this.metadata = {
+            ...this.metadata,
+            lastOtpSentAt: new Date(),
+            otpAttempts: 0,
+        };
+        await this.save();
+        return otp;
+    }
+    async verifyOTP(otp) {
+        // Check if locked
+        if (this.metadata.isLocked && this.metadata.lockedUntil) {
+            if (new Date() < new Date(this.metadata.lockedUntil)) {
+                return false;
+            }
+            // Unlock if past lock time
+            this.metadata.isLocked = false;
+            this.metadata.lockedUntil = undefined;
+        }
+        // Check OTP
+        if (!this.otp || !this.otpExpiresAt || this.otp !== otp) {
+            // Increment failed attempts
+            const attempts = (this.metadata.otpAttempts || 0) + 1;
+            this.metadata = {
+                ...this.metadata,
+                otpAttempts: attempts,
+                lastFailedAttemptAt: new Date(),
+            };
+            // Lock after 5 failed attempts
+            if (attempts >= 5) {
+                const lockMinutes = parseInt(process.env.OTP_LOCK_MINUTES || "30");
+                const lockedUntil = new Date();
+                lockedUntil.setMinutes(lockedUntil.getMinutes() + lockMinutes);
+                this.metadata.isLocked = true;
+                this.metadata.lockedUntil = lockedUntil;
+            }
+            await this.save();
+            return false;
+        }
+        // Check if expired
+        if (new Date() > new Date(this.otpExpiresAt)) {
+            return false;
+        }
+        // Clear OTP on success
+        this.otp = null;
+        this.otpExpiresAt = null;
+        this.metadata = {
+            ...this.metadata,
+            otpAttempts: 0,
+            lastFailedAttemptAt: undefined,
+        };
+        await this.save();
+        return true;
+    }
+    async markAsVerified() {
+        this.isVerified = true;
+        this.verifiedAt = new Date();
+        await this.save();
+    }
+    async markAsPrimary() {
+        // If this contact is being set as primary, ensure it's verified
+        if (!this.isVerified) {
+            throw new Error("Cannot set unverified phone as primary");
+        }
+        this.isPrimary = true;
+        await this.save();
+    }
+    async unmarkAsPrimary() {
+        this.isPrimary = false;
+        await this.save();
+    }
+    async deactivate(reason) {
+        this.isActive = false;
+        this.metadata = {
+            ...this.metadata,
+            deactivatedAt: new Date(),
+            deactivationReason: reason,
+        };
+        await this.save();
+    }
+    async reactivate() {
+        this.isActive = true;
+        this.metadata = {
+            ...this.metadata,
+            deactivatedAt: undefined,
+            deactivationReason: undefined,
+        };
+        await this.save();
+    }
+    isLocked() {
+        if (!this.metadata.isLocked)
+            return false;
+        if (this.metadata.lockedUntil &&
+            new Date() > new Date(this.metadata.lockedUntil)) {
+            // Auto-unlock
+            this.metadata.isLocked = false;
+            this.metadata.lockedUntil = undefined;
+            this.save();
+            return false;
+        }
+        return true;
+    }
+    getRemainingLockTime() {
+        if (!this.metadata.isLocked || !this.metadata.lockedUntil)
+            return null;
+        const remaining = new Date(this.metadata.lockedUntil).getTime() - new Date().getTime();
+        return Math.max(0, Math.ceil(remaining / 1000));
+    }
+    isExpired() {
+        if (!this.otpExpiresAt)
+            return true;
+        return new Date() > new Date(this.otpExpiresAt);
+    }
+    getRemainingOTPTime() {
+        if (!this.otpExpiresAt)
+            return null;
+        const remaining = new Date(this.otpExpiresAt).getTime() - new Date().getTime();
+        return Math.max(0, Math.ceil(remaining / 1000));
+    }
+    // Static methods
+    static async findByPhoneNumber(phoneNumber) {
+        return await this.findOne({
+            where: { phoneNumber },
+        });
+    }
+    static async findVerifiedByPhoneNumber(phoneNumber) {
+        return await this.findOne({
+            where: { phoneNumber, isVerified: true, isActive: true },
+        });
+    }
+    static async getUserPrimaryPhone(userId) {
+        return await this.findOne({
+            where: { userId, isPrimary: true, isActive: true },
+        });
+    }
+    static async getUserPhones(userId) {
+        return await this.findAll({
+            where: { userId, isActive: true },
+            order: [
+                ["isPrimary", "DESC"],
+                ["createdAt", "ASC"],
+            ],
+        });
+    }
+    static async isPhoneNumberAvailable(phoneNumber) {
+        const existing = await this.findOne({
+            where: { phoneNumber, isVerified: true },
+        });
+        return !existing;
+    }
+    static async cleanupExpiredOTPs() {
+        await this.update({ otp: null, otpExpiresAt: null }, {
+            where: {
+                otpExpiresAt: { [vr_migrations_1.Op.lt]: new Date() },
+                otp: { [vr_migrations_1.Op.ne]: null },
+            },
+        });
+    }
+}
+exports.PhoneContact = PhoneContact;

package/dist/models/user.models.d.ts

@@ -2,6 +2,7 @@ import { Model, InferAttributes, InferCreationAttributes, CreationOptional, NonA
 import type { Device } from "./device.models";
 import type { Payment } from "./payment.models";
 import type { SecurityClearance } from "./securityClearance.models";
+import type { PhoneContact } from "./phoneContact.models";
 import { Ban } from "./ban.models";
 import { Suspension } from "./suspension.models";
 export interface DeletionStatus {
@@ -14,19 +15,15 @@ export interface UserAttributes {
     id: string;
     firstName: string;
     lastName: string;
-    phoneNumber: string;
     jacketId?: string | null;
     email?: string | null;
     password?: string | null;
     securityClearanceId: string;
     plateNumber?: string | null;
     nationalId?: string | null;
+    primaryPhoneId: string | null;
     isActive: boolean;
     forgotPassword: boolean;
-    verified: boolean;
-    verifiedAt: Date | null;
-    otp: string | null;
-    otpExpiresAt: Date | null;
     isDeactivated: boolean;
     deactivatedAt: Date | null;
     lastLoginAt: Date | null;
@@ -36,33 +33,32 @@ export interface UserAttributes {
     devices?: Device[];
     payments?: Payment[];
     securityClearance?: SecurityClearance;
+    primaryPhone?: PhoneContact;
+    phones?: PhoneContact[];
     bans?: Ban[];
     suspensions?: Suspension[];
 }
-export interface UserCreationAttributes extends Omit<UserAttributes, "id" | "createdAt" | "isActive" | "isSuspended" | "forgotPassword" | "isDeactivated" | "tokenVersion"> {
+export interface UserCreationAttributes extends Omit<UserAttributes, "id" | "createdAt" | "isActive" | "forgotPassword" | "isDeactivated" | "tokenVersion" | "primaryPhoneId"> {
     id?: string;
     isActive?: boolean;
     forgotPassword?: boolean;
     isDeactivated?: boolean;
     tokenVersion?: number;
+    primaryPhoneId?: string | null;
 }
 export declare class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> implements UserAttributes {
     id: CreationOptional<string>;
     firstName: string;
     lastName: string;
-    phoneNumber: string;
     jacketId: CreationOptional<string | null>;
     email: CreationOptional<string | null>;
     password: CreationOptional<string | null>;
     securityClearanceId: string;
     plateNumber: CreationOptional<string | null>;
     nationalId: CreationOptional<string | null>;
+    primaryPhoneId: CreationOptional<string | null>;
     isActive: CreationOptional<boolean>;
     forgotPassword: CreationOptional<boolean>;
-    verified: CreationOptional<boolean>;
-    verifiedAt: CreationOptional<Date | null>;
-    otp: CreationOptional<string | null>;
-    otpExpiresAt: CreationOptional<Date | null>;
     isDeactivated: CreationOptional<boolean>;
     deactivatedAt: CreationOptional<Date | null>;
     lastLoginAt: CreationOptional<Date | null>;
@@ -72,14 +68,16 @@ export declare class User extends Model<InferAttributes<User>, InferCreationAttr
     devices?: NonAttribute<Device[]>;
     payments?: NonAttribute<Payment[]>;
     securityClearance?: NonAttribute<SecurityClearance>;
+    primaryPhone?: NonAttribute<PhoneContact>;
+    phones?: NonAttribute<PhoneContact[]>;
+    bans?: NonAttribute<Ban[]>;
+    suspensions?: NonAttribute<Suspension[]>;
     static initialize(sequelize: any): void;
     static associate(models: Record<string, ModelStatic<Model>>): void;
     softDelete(deletedBy: string, reason?: string): Promise<void>;
     updateLastLogin(): Promise<void>;
-    generateOTP(): Promise<string>;
-    clearOTP(): Promise<void>;
-    validateOTP(otp: string): Promise<boolean>;
     deactivate(): Promise<void>;
     activate(): Promise<void>;
+    hasVerifiedPhone(): Promise<boolean>;
 }
 export type UserModel = typeof User;

package/dist/models/user.models.js

@@ -20,11 +20,6 @@ class User extends vr_migrations_1.Model {
                 type: vr_migrations_1.DataTypes.STRING(100),
                 allowNull: false,
             },
-            phoneNumber: {
-                type: vr_migrations_1.DataTypes.STRING(100),
-                allowNull: false,
-                unique: true,
-            },
             nationalId: {
                 type: vr_migrations_1.DataTypes.STRING(100),
                 allowNull: true,
@@ -52,6 +47,10 @@ class User extends vr_migrations_1.Model {
                 type: vr_migrations_1.DataTypes.STRING(100),
                 allowNull: true,
             },
+            primaryPhoneId: {
+                type: vr_migrations_1.DataTypes.UUID,
+                allowNull: true,
+            },
             isActive: {
                 type: vr_migrations_1.DataTypes.BOOLEAN,
                 defaultValue: true,
@@ -69,23 +68,6 @@ class User extends vr_migrations_1.Model {
                 type: vr_migrations_1.DataTypes.BOOLEAN,
                 defaultValue: false,
             },
-            verified: {
-                type: vr_migrations_1.DataTypes.BOOLEAN,
-                allowNull: false,
-                defaultValue: false,
-            },
-            verifiedAt: {
-                type: vr_migrations_1.DataTypes.DATE,
-                allowNull: true,
-            },
-            otp: {
-                type: vr_migrations_1.DataTypes.STRING(50),
-                allowNull: true,
-            },
-            otpExpiresAt: {
-                type: vr_migrations_1.DataTypes.DATE,
-                allowNull: true,
-            },
             isDeactivated: {
                 type: vr_migrations_1.DataTypes.BOOLEAN,
                 defaultValue: false,
@@ -125,6 +107,18 @@ class User extends vr_migrations_1.Model {
             onDelete: "RESTRICT",
             onUpdate: "CASCADE",
         });
+        this.belongsTo(models.PhoneContact, {
+            foreignKey: "primaryPhoneId",
+            as: "primaryPhone",
+            onDelete: "SET NULL",
+            onUpdate: "CASCADE",
+        });
+        this.hasMany(models.PhoneContact, {
+            foreignKey: "userId",
+            as: "phones",
+            onDelete: "SET NULL",
+            onUpdate: "CASCADE",
+        });
         this.hasMany(models.Device, {
             foreignKey: "userId",
             as: "devices",
@@ -137,14 +131,12 @@ class User extends vr_migrations_1.Model {
             onDelete: "CASCADE",
             onUpdate: "CASCADE",
         });
-        // Suspensions
         this.hasMany(models.Suspension, {
             foreignKey: "userId",
             as: "suspensions",
             onDelete: "CASCADE",
             onUpdate: "CASCADE",
         });
-        // Bans
         this.hasMany(models.Ban, {
             foreignKey: "userId",
             as: "bans",
@@ -152,7 +144,7 @@ class User extends vr_migrations_1.Model {
             onUpdate: "CASCADE",
         });
     }
-    // Custom instance methods (example methods)
+    // Custom instance methods
     async softDelete(deletedBy, reason) {
         this.deletion = {
             deleted: true,
@@ -166,28 +158,6 @@ class User extends vr_migrations_1.Model {
         this.lastLoginAt = new Date();
         await this.save();
     }
-    async generateOTP() {
-        const otp = Math.floor(100000 + Math.random() * 900000).toString();
-        const expires = new Date();
-        expires.setMinutes(expires.getMinutes() + 15); // OTP valid for 15 minutes
-        this.otp = otp;
-        this.otpExpiresAt = expires;
-        this.forgotPassword = true;
-        await this.save();
-        return otp;
-    }
-    async clearOTP() {
-        this.otp = null;
-        this.otpExpiresAt = null;
-        this.forgotPassword = false;
-        await this.save();
-    }
-    async validateOTP(otp) {
-        if (!this.otp || !this.otpExpiresAt || this.otp !== otp) {
-            return false;
-        }
-        return new Date() < this.otpExpiresAt;
-    }
     async deactivate() {
         this.isDeactivated = true;
         this.deactivatedAt = new Date();
@@ -198,5 +168,18 @@ class User extends vr_migrations_1.Model {
         this.deactivatedAt = null;
         await this.save();
     }
+    // Helper to check if user has verified phone
+    async hasVerifiedPhone() {
+        const PhoneContact = this.constructor.sequelize.models
+            .PhoneContact;
+        const verifiedPhone = await PhoneContact.findOne({
+            where: {
+                userId: this.id,
+                isVerified: true,
+                isActive: true,
+            },
+        });
+        return !!verifiedPhone;
+    }
 }
 exports.User = User;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vr-models",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "Shared database models package for VR applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",