vr-models 1.0.1 → 1.0.2

package/dist/models/idempotencyRecord.models.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdempotencyRecord = void 0;
 const vr_migrations_1 = require("vr-migrations");
 class IdempotencyRecord extends vr_migrations_1.Model {
+    // Static initialization method
     static initialize(sequelize) {
         this.init({
             id: {
@@ -58,5 +59,31 @@ class IdempotencyRecord extends vr_migrations_1.Model {
             },
         });
     }
+    // Static association method
+    static associate(models) {
+        // This model doesn't have foreign key associations
+    }
+    // Custom instance methods
+    static async invalidate(key) {
+        const result = await this.destroy({
+            where: { key },
+        });
+        return result > 0;
+    }
+    isValid() {
+        return new Date() < this.expiresAt;
+    }
+    isExpired() {
+        return !this.isValid();
+    }
+    getResponse() {
+        if (!this.responseStatusCode || !this.responseBody) {
+            return null;
+        }
+        return {
+            statusCode: this.responseStatusCode,
+            body: this.responseBody,
+        };
+    }
 }
 exports.IdempotencyRecord = IdempotencyRecord;

package/dist/models/payment.models.d.ts

@@ -1,7 +1,37 @@
 import { Model, InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute, ModelStatic } from "vr-migrations";
+import type { User } from "./user.models";
+import type { DevicePaymentPlan } from "./devicePaymentPlan.models";
+import type { Transaction } from "./transaction.models";
+import type { IdempotencyRecord } from "./idempotencyRecord.models";
 export type PaymentProvider = "mtn_momo" | "airtel_money";
 export type PaymentStatus = "pending" | "succeeded" | "failed";
-export declare class Payment extends Model<InferAttributes<Payment>, InferCreationAttributes<Payment>> {
+export interface PaymentAttributes {
+    id: string;
+    userId: string;
+    devicePaymentPlanId: string;
+    transactionId: string | null;
+    idempotencyKeyId: string | null;
+    amount: number;
+    provider: PaymentProvider;
+    providerReference: string | null;
+    status: PaymentStatus;
+    metadata: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+    user?: User;
+    devicePaymentPlan?: DevicePaymentPlan;
+    transaction?: Transaction;
+    idempotencyKey?: IdempotencyRecord;
+}
+export interface PaymentCreationAttributes extends Omit<PaymentAttributes, "id" | "createdAt" | "updatedAt" | "status" | "providerReference" | "metadata" | "transactionId" | "idempotencyKeyId"> {
+    id?: string;
+    status?: PaymentStatus;
+    providerReference?: string | null;
+    metadata?: Record<string, any>;
+    transactionId?: string | null;
+    idempotencyKeyId?: string | null;
+}
+export declare class Payment extends Model<InferAttributes<Payment>, InferCreationAttributes<Payment>> implements PaymentAttributes {
     id: CreationOptional<string>;
     userId: string;
     devicePaymentPlanId: string;
@@ -10,15 +40,24 @@ export declare class Payment extends Model<InferAttributes<Payment>, InferCreati
     amount: number;
     provider: PaymentProvider;
     providerReference: CreationOptional<string | null>;
-    status: PaymentStatus;
-    metadata: Record<string, any>;
+    status: CreationOptional<PaymentStatus>;
+    metadata: CreationOptional<Record<string, any>>;
     readonly createdAt: CreationOptional<Date>;
     readonly updatedAt: CreationOptional<Date>;
-    user?: NonAttribute<any>;
-    devicePaymentPlan?: NonAttribute<any>;
-    transaction?: NonAttribute<any>;
-    idempotencyKey?: NonAttribute<any>;
+    user?: NonAttribute<User>;
+    devicePaymentPlan?: NonAttribute<DevicePaymentPlan>;
+    transaction?: NonAttribute<Transaction>;
+    idempotencyKey?: NonAttribute<IdempotencyRecord>;
     static initialize(sequelize: any): void;
     static associate(models: Record<string, ModelStatic<Model>>): void;
+    markAsSucceeded(providerReference: string, metadata?: Record<string, any>): Promise<void>;
+    markAsFailed(reason: string, metadata?: Record<string, any>): Promise<void>;
+    process(transactionId: string, idempotencyKeyId?: string): Promise<void>;
+    isSuccessful(): boolean;
+    isPending(): boolean;
+    isFailed(): boolean;
+    getProviderDisplayName(): string;
+    static getUserPayments(userId: string, limit?: number): Promise<Payment[]>;
+    static getPaymentPlanPayments(devicePaymentPlanId: string): Promise<Payment[]>;
 }
 export type PaymentModel = typeof Payment;

package/dist/models/payment.models.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Payment = void 0;
 const vr_migrations_1 = require("vr-migrations");
 class Payment extends vr_migrations_1.Model {
+    // Static initialization method
     static initialize(sequelize) {
         this.init({
             id: {
@@ -29,7 +30,11 @@ class Payment extends vr_migrations_1.Model {
                 allowNull: false,
                 defaultValue: "pending",
             },
-            metadata: { type: vr_migrations_1.DataTypes.JSONB, allowNull: false, defaultValue: {} },
+            metadata: {
+                type: vr_migrations_1.DataTypes.JSONB,
+                allowNull: false,
+                defaultValue: {},
+            },
             createdAt: { type: vr_migrations_1.DataTypes.DATE, defaultValue: vr_migrations_1.DataTypes.NOW },
             updatedAt: { type: vr_migrations_1.DataTypes.DATE, defaultValue: vr_migrations_1.DataTypes.NOW },
         }, {
@@ -45,19 +50,89 @@ class Payment extends vr_migrations_1.Model {
             },
         });
     }
+    // Static association method
     static associate(models) {
-        this.belongsTo(models.User, { foreignKey: "userId", as: "user" });
+        this.belongsTo(models.User, {
+            foreignKey: "userId",
+            as: "user",
+            onDelete: "RESTRICT",
+            onUpdate: "CASCADE",
+        });
         this.belongsTo(models.DevicePaymentPlan, {
             foreignKey: "devicePaymentPlanId",
             as: "devicePaymentPlan",
+            onDelete: "RESTRICT",
+            onUpdate: "CASCADE",
         });
         this.belongsTo(models.Transaction, {
             foreignKey: "transactionId",
             as: "transaction",
+            onDelete: "SET NULL",
+            onUpdate: "CASCADE",
         });
         this.belongsTo(models.IdempotencyRecord, {
             foreignKey: "idempotencyKeyId",
             as: "idempotencyKey",
+            onDelete: "SET NULL",
+            onUpdate: "CASCADE",
+        });
+    }
+    // Custom instance methods
+    async markAsSucceeded(providerReference, metadata) {
+        this.status = "succeeded";
+        this.providerReference = providerReference;
+        if (metadata) {
+            this.metadata = { ...this.metadata, ...metadata };
+        }
+        await this.save();
+    }
+    async markAsFailed(reason, metadata) {
+        this.status = "failed";
+        const failureMetadata = {
+            failureReason: reason,
+            failedAt: new Date().toISOString(),
+            ...metadata,
+        };
+        this.metadata = { ...this.metadata, ...failureMetadata };
+        await this.save();
+    }
+    async process(transactionId, idempotencyKeyId) {
+        this.transactionId = transactionId;
+        if (idempotencyKeyId) {
+            this.idempotencyKeyId = idempotencyKeyId;
+        }
+        await this.save();
+    }
+    isSuccessful() {
+        return this.status === "succeeded";
+    }
+    isPending() {
+        return this.status === "pending";
+    }
+    isFailed() {
+        return this.status === "failed";
+    }
+    getProviderDisplayName() {
+        switch (this.provider) {
+            case "mtn_momo":
+                return "MTN Mobile Money";
+            case "airtel_money":
+                return "Airtel Money";
+            default:
+                return this.provider;
+        }
+    }
+    static async getUserPayments(userId, limit = 50) {
+        return await this.findAll({
+            where: { userId },
+            order: [["createdAt", "DESC"]],
+            limit,
+        });
+    }
+    static async getPaymentPlanPayments(devicePaymentPlanId) {
+        return await this.findAll({
+            where: { devicePaymentPlanId },
+            order: [["createdAt", "ASC"]],
         });
     }
 }

package/dist/models/pricing.models.d.ts

@@ -1,18 +1,43 @@
 import { Model, InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute, ModelStatic } from "vr-migrations";
-export declare class Pricing extends Model<InferAttributes<Pricing>, InferCreationAttributes<Pricing>> {
-    id: CreationOptional<string>;
+import type { Product } from "./product.models";
+export interface PricingAttributes {
+    id: string;
     productId: string;
     name: string;
     upfrontPrice: number;
     downPayment: number;
-    installmentAmount?: number;
-    installmentIntervalDays?: number;
+    installmentAmount: number | null;
+    installmentIntervalDays: number | null;
+    totalAmount: number;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    product?: Product;
+}
+export interface PricingCreationAttributes extends Omit<PricingAttributes, "id" | "createdAt" | "updatedAt" | "isActive" | "downPayment"> {
+    id?: string;
+    isActive?: boolean;
+    downPayment?: number;
+}
+export declare class Pricing extends Model<InferAttributes<Pricing>, InferCreationAttributes<Pricing>> implements PricingAttributes {
+    id: CreationOptional<string>;
+    productId: string;
+    name: string;
+    upfrontPrice: number;
+    downPayment: CreationOptional<number>;
+    installmentAmount: CreationOptional<number | null>;
+    installmentIntervalDays: CreationOptional<number | null>;
     totalAmount: number;
     isActive: CreationOptional<boolean>;
     readonly createdAt: CreationOptional<Date>;
     readonly updatedAt: CreationOptional<Date>;
-    product?: NonAttribute<any>;
+    product?: NonAttribute<Product>;
     static initialize(sequelize: any): void;
     static associate(models: Record<string, ModelStatic<Model>>): void;
+    activate(): Promise<void>;
+    deactivate(): Promise<void>;
+    isInstallmentPlan(): boolean;
+    getInstallmentCount(): number | null;
+    calculateRemainingAmount(paidAmount: number): number;
 }
 export type PricingModel = typeof Pricing;

package/dist/models/pricing.models.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Pricing = void 0;
 const vr_migrations_1 = require("vr-migrations");
 class Pricing extends vr_migrations_1.Model {
+    // Static initialization method
     static initialize(sequelize) {
         this.init({
             id: {
@@ -35,8 +36,35 @@ class Pricing extends vr_migrations_1.Model {
             timestamps: true,
         });
     }
+    // Static association method
     static associate(models) {
-        this.belongsTo(models.Product, { foreignKey: "productId", as: "product" });
+        this.belongsTo(models.Product, {
+            foreignKey: "productId",
+            as: "product",
+            onDelete: "CASCADE",
+            onUpdate: "CASCADE",
+        });
+    }
+    // Custom instance methods
+    async activate() {
+        this.isActive = true;
+        await this.save();
+    }
+    async deactivate() {
+        this.isActive = false;
+        await this.save();
+    }
+    isInstallmentPlan() {
+        return !!(this.installmentAmount && this.installmentIntervalDays);
+    }
+    getInstallmentCount() {
+        if (!this.isInstallmentPlan())
+            return null;
+        const remainingAmount = this.totalAmount - this.downPayment;
+        return Math.ceil(remainingAmount / (this.installmentAmount || 1));
+    }
+    calculateRemainingAmount(paidAmount) {
+        return Math.max(0, this.totalAmount - paidAmount);
     }
 }
 exports.Pricing = Pricing;

package/dist/models/product.models.d.ts

@@ -1,15 +1,42 @@
 import { Model, InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute, ModelStatic } from "vr-migrations";
-export declare class Product extends Model<InferAttributes<Product>, InferCreationAttributes<Product>> {
+import type { Pricing } from "./pricing.models";
+import type { Device } from "./device.models";
+export interface ProductAttributes {
+    id: string;
+    name: string;
+    description: string | null;
+    stock: number;
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    pricings?: Pricing[];
+    devices?: Device[];
+}
+export interface ProductCreationAttributes extends Omit<ProductAttributes, "id" | "createdAt" | "updatedAt" | "stock" | "isActive" | "description"> {
+    id?: string;
+    description?: string | null;
+    stock?: number;
+    isActive?: boolean;
+}
+export declare class Product extends Model<InferAttributes<Product>, InferCreationAttributes<Product>> implements ProductAttributes {
     id: CreationOptional<string>;
     name: string;
-    description: string;
+    description: CreationOptional<string | null>;
     stock: CreationOptional<number>;
     isActive: CreationOptional<boolean>;
     readonly createdAt: CreationOptional<Date>;
     readonly updatedAt: CreationOptional<Date>;
-    pricings?: NonAttribute<any[]>;
-    devices?: NonAttribute<any[]>;
+    pricings?: NonAttribute<Pricing[]>;
+    devices?: NonAttribute<Device[]>;
     static initialize(sequelize: any): void;
     static associate(models: Record<string, ModelStatic<Model>>): void;
+    activate(): Promise<void>;
+    deactivate(): Promise<void>;
+    incrementStock(amount?: number): Promise<void>;
+    decrementStock(amount?: number): Promise<void>;
+    isInStock(): boolean;
+    getActivePricings(): Pricing[];
+    getDefaultPricing(): Pricing | null;
+    static findAvailableProducts(): Promise<Product[]>;
 }
 export type ProductModel = typeof Product;

package/dist/models/product.models.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Product = void 0;
 const vr_migrations_1 = require("vr-migrations");
 class Product extends vr_migrations_1.Model {
+    // Static initialization method
     static initialize(sequelize) {
         this.init({
             id: {
@@ -27,9 +28,59 @@ class Product extends vr_migrations_1.Model {
             timestamps: true,
         });
     }
+    // Static association method
     static associate(models) {
-        this.hasMany(models.Pricing, { foreignKey: "productId", as: "pricings" });
-        this.hasMany(models.Device, { foreignKey: "productId", as: "devices" });
+        this.hasMany(models.Pricing, {
+            foreignKey: "productId",
+            as: "pricings",
+            onDelete: "CASCADE",
+            onUpdate: "CASCADE",
+        });
+        this.hasMany(models.Device, {
+            foreignKey: "productId",
+            as: "devices",
+            onDelete: "RESTRICT",
+            onUpdate: "CASCADE",
+        });
+    }
+    // Custom instance methods
+    async activate() {
+        this.isActive = true;
+        await this.save();
+    }
+    async deactivate() {
+        this.isActive = false;
+        await this.save();
+    }
+    async incrementStock(amount = 1) {
+        this.stock += amount;
+        await this.save();
+    }
+    async decrementStock(amount = 1) {
+        if (this.stock < amount) {
+            throw new Error(`Insufficient stock. Available: ${this.stock}, Requested: ${amount}`);
+        }
+        this.stock -= amount;
+        await this.save();
+    }
+    isInStock() {
+        return this.stock > 0;
+    }
+    getActivePricings() {
+        if (!this.pricings)
+            return [];
+        return this.pricings.filter((pricing) => pricing.isActive);
+    }
+    getDefaultPricing() {
+        if (!this.pricings)
+            return null;
+        return this.pricings.find((pricing) => pricing.isActive) || null;
+    }
+    static async findAvailableProducts() {
+        return await this.findAll({
+            where: { isActive: true },
+            include: ["pricings"],
+        });
     }
 }
 exports.Product = Product;

package/dist/models/securityClearance.models.d.ts

@@ -1,4 +1,4 @@
-import { Model, InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute } from "vr-migrations";
+import { Model, InferAttributes, InferCreationAttributes, CreationOptional, NonAttribute, ModelStatic } from "vr-migrations";
 import type { User } from "./user.models";
 export declare const USER_ROLES: readonly ["RIDER", "PASSENGER", "ADMIN", "AGENT", "SUPER_ADMIN"];
 export type UserRole = (typeof USER_ROLES)[number];
@@ -30,17 +30,42 @@ export declare enum Permission {
     MANAGE_SECURITY_CLEARANCE = "MANAGE_SECURITY_CLEARANCE",
     OVERRIDE_DEVICE_LOCK = "OVERRIDE_DEVICE_LOCK"
 }
-export declare class SecurityClearance extends Model<InferAttributes<SecurityClearance>, InferCreationAttributes<SecurityClearance>> {
-    id: CreationOptional<string>;
+export interface SecurityClearanceAttributes {
+    id: string;
     role: UserRole;
-    description: CreationOptional<string | null>;
+    description: string | null;
     level: number;
     permissions: Permission[];
     isDefault: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    users?: User[];
+}
+export interface SecurityClearanceCreationAttributes extends Omit<SecurityClearanceAttributes, "id" | "createdAt" | "updatedAt" | "permissions" | "isDefault" | "description"> {
+    id?: string;
+    permissions?: Permission[];
+    isDefault?: boolean;
+    description?: string | null;
+}
+export declare class SecurityClearance extends Model<InferAttributes<SecurityClearance>, InferCreationAttributes<SecurityClearance>> implements SecurityClearanceAttributes {
+    id: CreationOptional<string>;
+    role: UserRole;
+    description: CreationOptional<string | null>;
+    level: number;
+    permissions: CreationOptional<Permission[]>;
+    isDefault: CreationOptional<boolean>;
     createdAt: CreationOptional<Date>;
     updatedAt: CreationOptional<Date>;
     users?: NonAttribute<User[]>;
+    static initialize(sequelize: any): void;
+    static associate(models: Record<string, ModelStatic<Model>>): void;
     hasPermission(permission: Permission): boolean;
+    addPermission(permission: Permission): Promise<void>;
+    removePermission(permission: Permission): Promise<void>;
+    setAsDefault(): Promise<void>;
+    removeAsDefault(): Promise<void>;
+    getRoleDisplayName(): string;
+    static getDefaultClearance(): Promise<SecurityClearance | null>;
+    static findByRole(role: UserRole): Promise<SecurityClearance | null>;
 }
-export declare const initSecurityClearanceModel: (sequelize: any) => void;
 export type SecurityClearanceModel = typeof SecurityClearance;

package/dist/models/securityClearance.models.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initSecurityClearanceModel = exports.SecurityClearance = exports.Permission = exports.USER_ROLES = void 0;
-// src/models/securityClearance.models.ts
+exports.SecurityClearance = exports.Permission = exports.USER_ROLES = void 0;
 const vr_migrations_1 = require("vr-migrations");
+// Constants
 exports.USER_ROLES = [
     "RIDER",
     "PASSENGER",
@@ -40,54 +40,97 @@ var Permission;
     Permission["OVERRIDE_DEVICE_LOCK"] = "OVERRIDE_DEVICE_LOCK";
 })(Permission || (exports.Permission = Permission = {}));
 class SecurityClearance 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,
+            },
+            role: {
+                type: vr_migrations_1.DataTypes.ENUM(...exports.USER_ROLES),
+                allowNull: false,
+                unique: true,
+            },
+            description: {
+                type: vr_migrations_1.DataTypes.TEXT,
+                allowNull: true,
+            },
+            level: {
+                type: vr_migrations_1.DataTypes.INTEGER,
+                allowNull: false,
+            },
+            permissions: {
+                type: vr_migrations_1.DataTypes.ARRAY(vr_migrations_1.DataTypes.STRING),
+                allowNull: false,
+                defaultValue: [],
+            },
+            isDefault: {
+                type: vr_migrations_1.DataTypes.BOOLEAN,
+                defaultValue: false,
+            },
+            createdAt: {
+                type: vr_migrations_1.DataTypes.DATE,
+                defaultValue: vr_migrations_1.DataTypes.NOW,
+            },
+            updatedAt: {
+                type: vr_migrations_1.DataTypes.DATE,
+                defaultValue: vr_migrations_1.DataTypes.NOW,
+            },
+        }, {
+            sequelize,
+            modelName: "SecurityClearance",
+            tableName: "security_clearances",
+            timestamps: true,
+            freezeTableName: true,
+        });
+    }
+    // Static association method
+    static associate(models) {
+        this.hasMany(models.User, {
+            foreignKey: "securityClearanceId",
+            as: "users",
+            onDelete: "RESTRICT",
+            onUpdate: "CASCADE",
+        });
+    }
+    // Custom instance methods
     hasPermission(permission) {
         return this.permissions.includes(permission);
     }
+    async addPermission(permission) {
+        if (!this.hasPermission(permission)) {
+            this.permissions = [...this.permissions, permission];
+            await this.save();
+        }
+    }
+    async removePermission(permission) {
+        this.permissions = this.permissions.filter((p) => p !== permission);
+        await this.save();
+    }
+    async setAsDefault() {
+        // First, unset any existing default
+        await SecurityClearance.update({ isDefault: false }, { where: { isDefault: true } });
+        // Then set this as default
+        this.isDefault = true;
+        await this.save();
+    }
+    async removeAsDefault() {
+        this.isDefault = false;
+        await this.save();
+    }
+    getRoleDisplayName() {
+        return this.role
+            .split("_")
+            .map((word) => word.charAt(0) + word.slice(1).toLowerCase())
+            .join(" ");
+    }
+    static async getDefaultClearance() {
+        return await this.findOne({ where: { isDefault: true } });
+    }
+    static async findByRole(role) {
+        return await this.findOne({ where: { role } });
+    }
 }
 exports.SecurityClearance = SecurityClearance;
-const initSecurityClearanceModel = (sequelize) => {
-    SecurityClearance.init({
-        id: {
-            type: vr_migrations_1.DataTypes.UUID,
-            defaultValue: vr_migrations_1.DataTypes.UUIDV4,
-            primaryKey: true,
-        },
-        role: {
-            type: vr_migrations_1.DataTypes.ENUM(...exports.USER_ROLES),
-            allowNull: false,
-            unique: true,
-        },
-        description: {
-            type: vr_migrations_1.DataTypes.TEXT,
-            allowNull: true,
-        },
-        level: {
-            type: vr_migrations_1.DataTypes.INTEGER,
-            allowNull: false,
-        },
-        permissions: {
-            type: vr_migrations_1.DataTypes.ARRAY(vr_migrations_1.DataTypes.STRING),
-            allowNull: false,
-            defaultValue: [],
-        },
-        isDefault: {
-            type: vr_migrations_1.DataTypes.BOOLEAN,
-            defaultValue: false,
-        },
-        createdAt: {
-            type: vr_migrations_1.DataTypes.DATE,
-            defaultValue: vr_migrations_1.DataTypes.NOW,
-        },
-        updatedAt: {
-            type: vr_migrations_1.DataTypes.DATE,
-            defaultValue: vr_migrations_1.DataTypes.NOW,
-        },
-    }, {
-        sequelize,
-        modelName: "SecurityClearance",
-        tableName: "security_clearances",
-        timestamps: true,
-        freezeTableName: true,
-    });
-};
-exports.initSecurityClearanceModel = initSecurityClearanceModel;