ojamoto_models 1.0.0

package/models/User.js

@@ -0,0 +1,198 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { USER_STATUS } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class User extends Model {
+    static associate(models) {
+      // Roles (many-to-many)
+      User.belongsToMany(models.Role, {
+        through: models.UserRole,
+        foreignKey: "user_id",
+        otherKey: "role_id",
+        as: "roles",
+      });
+
+      // Address
+      User.hasMany(models.Address, {
+        foreignKey: "user_id",
+        as: "addresses",
+      });
+
+      // KYC
+      User.hasOne(models.KycVerification, {
+        foreignKey: "user_id",
+        as: "kyc",
+      });
+
+      // Wallet
+      User.hasOne(models.Wallet, {
+        foreignKey: "user_id",
+        as: "wallet",
+      });
+
+      // Seller profile
+      User.hasOne(models.SellerProfile, {
+        foreignKey: "user_id",
+        as: "sellerProfile",
+      });
+
+      // Products listed by this seller
+      User.hasMany(models.Product, {
+        foreignKey: "seller_id",
+        as: "products",
+      });
+
+      // Devices
+      User.hasMany(models.Device, {
+        foreignKey: "user_id",
+        as: "devices",
+      });
+
+      // Sessions
+      User.hasMany(models.Session, {
+        foreignKey: "user_id",
+        as: "sessions",
+      });
+
+      // Escrows as buyer
+      User.hasMany(models.Escrow, {
+        foreignKey: "buyer_id",
+        as: "buyerEscrows",
+      });
+
+      // Escrows as seller
+      User.hasMany(models.Escrow, {
+        foreignKey: "seller_id",
+        as: "sellerEscrows",
+      });
+
+      // Disputes opened by this user
+      User.hasMany(models.Dispute, {
+        foreignKey: "opened_by",
+        as: "openedDisputes",
+      });
+
+      // Ratings given (as buyer)
+      User.hasMany(models.Rating, {
+        foreignKey: "buyer_id",
+        as: "givenRatings",
+      });
+
+      // Ratings received (as seller)
+      User.hasMany(models.Rating, {
+        foreignKey: "seller_id",
+        as: "receivedRatings",
+      });
+
+      // Notifications
+      User.hasMany(models.Notification, {
+        foreignKey: "user_id",
+        as: "notifications",
+      });
+
+      // Audit logs
+      User.hasMany(models.AuditLog, {
+        foreignKey: "user_id",
+        as: "auditLogs",
+      });
+
+      // Wallet transactions
+      User.hasMany(models.WalletTransaction, {
+        foreignKey: "user_id",
+        as: "walletTransactions",
+      });
+    }
+  }
+
+  User.init(
+    {
+      user_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      uuid: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        unique: true,
+      },
+      first_name: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      last_name: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      middle_name: {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+      },
+      email: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+        unique: true,
+        validate: { isEmail: true },
+      },
+      phone: {
+        type: DataTypes.STRING(10),
+        allowNull: false,
+        unique: true,
+      },
+      country_calling_code: {
+        type: DataTypes.STRING(3),
+        allowNull: false,
+      },
+      password_hash: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+      },
+      transaction_pin_hash: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(USER_STATUS)),
+        allowNull: false,
+        defaultValue: USER_STATUS.ACTIVE,
+      },
+      email_verified: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+      },
+      phone_verified: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+      },
+      nin_verified: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        comment: "Sellers only",
+      },
+      bank_verified: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+      },
+      two_factor_enabled: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "User",
+      tableName: "users",
+      timestamps: true,
+      paranoid: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      deletedAt: "deleted_at",
+    },
+  );
+
+  User.removeAttribute("id");
+  return User;
+};

package/models/UserOTP.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class UserOTP extends Model {
+    static associate(models) {}
+  }
+
+  UserOTP.init(
+    {
+      user_otp_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      email: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      first_name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      last_name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      middle_name: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      phone: {
+        type: DataTypes.STRING(10),
+        allowNull: false,
+      },
+      country_calling_code: {
+        type: DataTypes.STRING(3),
+        allowNull: false,
+      },
+      password_hash: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      user_type: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      otp: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      purpose: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      expires_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "UserOTP",
+      tableName: "user_otps",
+      timestamps: true,
+      paranoid: false,
+      expiresAt: "expires_at",
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      indexes: [
+        {
+          unique: true,
+          fields: ["email", "purpose"],
+          name: "user_otps_email_purpose_unique",
+        },
+      ],
+    },
+  );
+
+  UserOTP.removeAttribute("id");
+  return UserOTP;
+};

package/models/UserRole.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class UserRole extends Model {
+    static associate(models) {}
+  }
+
+  UserRole.init(
+    {
+      user_role_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+      },
+      role_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "roles", key: "role_id" },
+        onDelete: "CASCADE",
+      },
+    },
+    {
+      sequelize,
+      modelName: "UserRole",
+      tableName: "user_roles",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
+  );
+
+  UserRole.removeAttribute("id");
+  return UserRole;
+};

package/models/Wallet.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class Wallet extends Model {
+    static associate(models) {
+      Wallet.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+
+      Wallet.hasMany(models.WalletTransaction, {
+        foreignKey: "wallet_id",
+        as: "transactions",
+      });
+    }
+  }
+
+  Wallet.init(
+    {
+      wallet_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        unique: true,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+        comment: "One wallet per user",
+      },
+      available_balance: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+        defaultValue: 0.0,
+        comment: "Spendable funds",
+      },
+      locked_balance: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+        defaultValue: 0.0,
+        comment: "Funds currently held in active escrows",
+      },
+      currency: {
+        type: DataTypes.STRING(3),
+        allowNull: false,
+        defaultValue: "NGN",
+      },
+    },
+    {
+      sequelize,
+      modelName: "Wallet",
+      tableName: "wallets",
+      timestamps: false,
+    },
+  );
+
+  Wallet.removeAttribute("id");
+  return Wallet;
+};

package/models/WalletTransaction.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const {
+  WALLET_TRANSACTION_TYPE,
+  WALLET_TRANSACTION_STATUS,
+} = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class WalletTransaction extends Model {
+    static associate(models) {
+      WalletTransaction.belongsTo(models.Wallet, {
+        foreignKey: "wallet_id",
+        as: "wallet",
+      });
+
+      WalletTransaction.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+    }
+  }
+
+  WalletTransaction.init(
+    {
+      wallet_transaction_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      wallet_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "wallets", key: "wallet_id" },
+        onDelete: "CASCADE",
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+        comment: "Denormalized for quick queries",
+      },
+      type: {
+        type: DataTypes.ENUM(...Object.values(WALLET_TRANSACTION_TYPE)),
+        allowNull: false,
+      },
+      amount: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+      },
+      currency: {
+        type: DataTypes.STRING(3),
+        allowNull: false,
+        defaultValue: "NGN",
+      },
+      reference: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+        unique: true,
+        comment: "Flutterwave ref or internal reference",
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(WALLET_TRANSACTION_STATUS)),
+        allowNull: false,
+        defaultValue: WALLET_TRANSACTION_STATUS.PENDING,
+      },
+    },
+    {
+      sequelize,
+      modelName: "WalletTransaction",
+      tableName: "wallet_transactions",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  WalletTransaction.removeAttribute("id");
+  return WalletTransaction;
+};

package/models/WebhookLog.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { WEBHOOK_STATUS } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class WebhookLog extends Model {
+    static associate(models) {
+      // No associations — standalone security log
+    }
+  }
+
+  WebhookLog.init(
+    {
+      webhook_log_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      source: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+        comment: "flutterwave | twilio | onesignal",
+      },
+      event_type: {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+        comment: "e.g. charge.completed | delivery.update",
+      },
+      payload_json: {
+        type: DataTypes.JSON,
+        allowNull: false,
+        comment: "Raw webhook body",
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(WEBHOOK_STATUS)),
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "WebhookLog",
+      tableName: "webhook_logs",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  WebhookLog.removeAttribute("id");
+  return WebhookLog;
+};

package/models/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const basename = path.basename(__filename);
+
+module.exports = (sequelize) => {
+  const db = {};
+
+  fs.readdirSync(__dirname)
+    .filter((file) => file !== basename && file.endsWith(".js"))
+    .forEach((file) => {
+      const model = require(path.join(__dirname, file))(sequelize);
+      db[model.name] = model;
+    });
+
+  // Setup associations
+  Object.keys(db).forEach((name) => {
+    if (db[name].associate) db[name].associate(db);
+  });
+
+  return db;
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "ojamoto_models",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "migrate:up": "npx sequelize-cli db:migrate",
+    "migrate:undo": "npx sequelize-cli db:migrate:undo",
+    "migrate:undo:all": "npx sequelize-cli db:migrate:undo:all",
+    "seed:all": "npx sequelize-cli db:seed:all",
+    "seed:undo": "npx sequelize-cli db:seed:undo"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ojamoto/ojamoto_models.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/ojamoto/ojamoto_models/issues"
+  },
+  "homepage": "https://github.com/ojamoto/ojamoto_models#readme",
+  "description": "",
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "mysql2": "^3.23.2",
+    "sequelize": "^6.37.8",
+    "sequelize-cli": "^6.6.5"
+  }
+}