ojamoto_models 1.0.0

package/migrations/2026000022-create-audit-logs.js

@@ -0,0 +1,57 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("audit_logs", {
+      audit_log_id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      // One of user_id or admin_id will be populated — never both
+      user_id: {
+        type: Sequelize.INTEGER,
+        allowNull: true,
+        references: { model: "users", key: "user_id" },
+        onDelete: "SET NULL",
+        onUpdate: "CASCADE",
+        comment: "Populated when the actor is a regular user",
+      },
+      admin_id: {
+        type: Sequelize.INTEGER,
+        allowNull: true,
+        references: { model: "admin_users", key: "admin_id" },
+        onDelete: "SET NULL",
+        onUpdate: "CASCADE",
+        comment: "Populated when the actor is an admin",
+      },
+      action: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+        comment: "e.g. ESCROW_RELEASED | USER_BANNED | KYC_APPROVED",
+      },
+      metadata_json: {
+        type: Sequelize.JSON,
+        allowNull: true,
+        comment: "Contextual data — before/after values, entity IDs etc.",
+      },
+      ip_address: {
+        type: Sequelize.STRING(45),
+        allowNull: true,
+      },
+      created_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+
+    await queryInterface.addIndex("audit_logs", ["user_id"]);
+    await queryInterface.addIndex("audit_logs", ["admin_id"]);
+    await queryInterface.addIndex("audit_logs", ["action"]);
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("audit_logs");
+  },
+};

package/migrations/2026000023-create-webhook-logs.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const { WEBHOOK_STATUS } = require("../services/constants");
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("webhook_logs", {
+      webhook_log_id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      source: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+        comment: "flutterwave | twilio | onesignal",
+      },
+      event_type: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+        comment: "e.g. charge.completed | delivery.update",
+      },
+      payload_json: {
+        type: Sequelize.JSON,
+        allowNull: false,
+        comment: "Raw webhook body",
+      },
+      status: {
+        type: Sequelize.ENUM(...Object.values(WEBHOOK_STATUS)),
+        allowNull: false,
+      },
+      created_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+
+    await queryInterface.addIndex("webhook_logs", ["source"]);
+    await queryInterface.addIndex("webhook_logs", ["status"]);
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("webhook_logs");
+  },
+};

package/migrations/2026000024-create-user-otps.js

@@ -0,0 +1,75 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("user_otps", {
+      user_otp_id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      email: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      first_name: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      last_name: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      middle_name: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      phone: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      country_calling_code: {
+        type: Sequelize.STRING(3),
+        allowNull: false,
+      },
+      password_hash: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      user_type: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      otp: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      purpose: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      expires_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      created_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      updated_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+
+    await queryInterface.addIndex("user_otps", ["email", "purpose"], {
+      unique: true,
+      name: "user_otps_email_purpose_unique",
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("user_otps");
+  },
+};

package/migrations/2026000025-create-password-reset-otps.js

@@ -0,0 +1,43 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("password_reset_otps", {
+      password_reset_otp_id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      email: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      otp: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      expires_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      created_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      updated_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+
+    await queryInterface.addIndex("password_reset_otps", ["email"], {
+      unique: true,
+      name: "password_reset_otps_email_unique",
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("password_reset_otps");
+  },
+};

package/migrations/2026000026-create-seller-badges.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { SELLER_BADGE } = require("../services/constants");
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("seller_badges", {
+      seller_badge_id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      seller_profile_id: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: { model: "seller_profiles", key: "seller_profile_id" },
+        onDelete: "CASCADE",
+        onUpdate: "CASCADE",
+      },
+      badge: {
+        type: Sequelize.ENUM(...Object.values(SELLER_BADGE)),
+        allowNull: false,
+      },
+      awarded_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+
+    await queryInterface.addIndex("seller_badges", ["seller_profile_id"]);
+    // One seller can only hold each badge once
+    await queryInterface.addIndex(
+      "seller_badges",
+      ["seller_profile_id", "badge"],
+      { unique: true, name: "seller_badges_profile_badge_unique" },
+    );
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("seller_badges");
+  },
+};

package/migrations/2026000027-add-fulltext-index-for-search.js

@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface) {
+    await queryInterface.sequelize.query(
+      `ALTER TABLE products ADD FULLTEXT INDEX products_search_fulltext (name, description, brand, model, category)`,
+    );
+  },
+
+  async down(queryInterface) {
+    await queryInterface.sequelize.query(
+      `ALTER TABLE products DROP INDEX products_search_fulltext`,
+    );
+  },
+};

package/migrations/2026000028-create-admin-notifications.js

@@ -0,0 +1,53 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("admin_notifications", {
+      admin_notification_id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      admin_id: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: { model: "admin_users", key: "admin_id" },
+        onDelete: "CASCADE",
+        onUpdate: "CASCADE",
+      },
+      type: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+        comment: "DISPUTE_OPENED | KYC_SUBMITTED | WITHDRAWAL_FLAGGED etc.",
+      },
+      title: {
+        type: Sequelize.STRING(255),
+        allowNull: false,
+      },
+      message: {
+        type: Sequelize.TEXT,
+        allowNull: false,
+      },
+      read_status: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      created_at: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+
+    await queryInterface.addIndex("admin_notifications", ["admin_id"]);
+    await queryInterface.addIndex("admin_notifications", [
+      "admin_id",
+      "read_status",
+    ]);
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("admin_notifications");
+  },
+};

package/migrations/2026000029-create-pin-reset-otp.js

@@ -0,0 +1,30 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("pin_reset_otps", {
+      pin_reset_otp_id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      user_id: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        unique: true,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+        onUpdate: "CASCADE",
+      },
+      otp: { type: Sequelize.STRING, allowNull: false },
+      expires_at: { type: Sequelize.DATE, allowNull: false },
+      created_at: { type: Sequelize.DATE, allowNull: false },
+      updated_at: { type: Sequelize.DATE, allowNull: false },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("pin_reset_otps");
+  },
+};

package/models/Address.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { ADDRESS_LABEL } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class Address extends Model {
+    static associate(models) {
+      Address.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+    }
+  }
+
+  Address.init(
+    {
+      address_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+      },
+      label: {
+        type: DataTypes.ENUM(...Object.values(ADDRESS_LABEL)),
+        allowNull: false,
+      },
+      address_line1: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+      },
+      address_line2: {
+        type: DataTypes.STRING(255),
+        allowNull: true,
+      },
+      city: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      state: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      country: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      postal_code: {
+        type: DataTypes.STRING(20),
+        allowNull: true,
+      },
+      is_default: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "Address",
+      tableName: "addresses",
+      timestamps: true,
+      paranoid: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      deletedAt: "deleted_at",
+    },
+  );
+
+  Address.removeAttribute("id");
+  return Address;
+};

package/models/AdminNotification.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class AdminNotification extends Model {
+    static associate(models) {
+      AdminNotification.belongsTo(models.AdminUser, {
+        foreignKey: "admin_id",
+        as: "admin",
+      });
+    }
+  }
+
+  AdminNotification.init(
+    {
+      admin_notification_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      admin_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "admin_users", key: "admin_id" },
+        onDelete: "CASCADE",
+      },
+      type: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+        comment: "DISPUTE_OPENED | KYC_SUBMITTED | WITHDRAWAL_FLAGGED etc.",
+      },
+      title: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+      },
+      message: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+      },
+      read_status: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "AdminNotification",
+      tableName: "admin_notifications",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  AdminNotification.removeAttribute("id");
+  return AdminNotification;
+};

package/models/AdminUser.js

@@ -0,0 +1,115 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { ADMIN_ROLE, ADMIN_STATUS } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class AdminUser extends Model {
+    static associate(models) {
+      // Self-referential: who created this admin account
+      AdminUser.belongsTo(models.AdminUser, {
+        foreignKey: "created_by",
+        as: "createdByAdmin",
+      });
+
+      AdminUser.hasMany(models.AdminUser, {
+        foreignKey: "created_by",
+        as: "createdAdmins",
+      });
+
+      // Disputes assigned to this admin
+      AdminUser.hasMany(models.Dispute, {
+        foreignKey: "assigned_admin",
+        as: "assignedDisputes",
+      });
+
+      // Audit logs performed by this admin
+      AdminUser.hasMany(models.AuditLog, {
+        foreignKey: "admin_id",
+        as: "auditLogs",
+      });
+
+      // Notifications
+      AdminUser.hasMany(models.AdminNotification, {
+        foreignKey: "admin_id",
+        as: "notifications",
+      });
+    }
+  }
+
+  AdminUser.init(
+    {
+      admin_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,
+      },
+      email: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+        unique: true,
+        validate: { isEmail: true },
+      },
+      phone: {
+        type: DataTypes.STRING(20),
+        allowNull: false,
+        unique: true,
+      },
+      password_hash: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+      },
+      role: {
+        type: DataTypes.ENUM(...Object.values(ADMIN_ROLE)),
+        allowNull: false,
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(ADMIN_STATUS)),
+        allowNull: false,
+        defaultValue: ADMIN_STATUS.ACTIVE,
+      },
+      two_factor_enabled: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+        comment: "Mandatory for all admin accounts",
+      },
+      last_login_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+      },
+      created_by: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: "admin_users", key: "admin_id" },
+        onDelete: "SET NULL",
+        comment: "Which super admin created this account",
+      },
+    },
+    {
+      sequelize,
+      modelName: "AdminUser",
+      tableName: "admin_users",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
+  );
+
+  AdminUser.removeAttribute("id");
+  return AdminUser;
+};

package/models/AuditLog.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class AuditLog extends Model {
+    static associate(models) {
+      // Actor can be a regular user
+      AuditLog.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+
+      // Or an admin user — use admin_id to distinguish
+      AuditLog.belongsTo(models.AdminUser, {
+        foreignKey: "admin_id",
+        as: "admin",
+      });
+    }
+  }
+
+  AuditLog.init(
+    {
+      audit_log_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: "users", key: "user_id" },
+        onDelete: "SET NULL",
+        comment: "Populated when the actor is a regular user",
+      },
+      admin_id: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: "admin_users", key: "admin_id" },
+        onDelete: "SET NULL",
+        comment: "Populated when the actor is an admin",
+      },
+      action: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+        comment: "e.g. ESCROW_RELEASED | USER_BANNED | KYC_APPROVED",
+      },
+      metadata_json: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        comment: "Contextual data — before/after values, entity IDs etc.",
+      },
+      ip_address: {
+        type: DataTypes.STRING(45),
+        allowNull: true,
+      },
+    },
+    {
+      sequelize,
+      modelName: "AuditLog",
+      tableName: "audit_logs",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  AuditLog.removeAttribute("id");
+  return AuditLog;
+};