ojamoto_models 1.0.0

package/models/Device.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class Device extends Model {
+    static associate(models) {
+      Device.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+
+      Device.hasMany(models.Session, {
+        foreignKey: "device_id",
+        as: "sessions",
+      });
+    }
+  }
+
+  Device.init(
+    {
+      device_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+      },
+      device_name: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      device_type: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+        comment: "mobile | desktop | tablet",
+      },
+      user_device_id: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      push_notification_id: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      browser: {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+      },
+      ip_address: {
+        type: DataTypes.STRING(45),
+        allowNull: false,
+        comment: "IPv4 or IPv6",
+      },
+      location: {
+        type: DataTypes.STRING(500),
+        allowNull: false,
+        comment: "City, Country",
+      },
+      trusted: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        comment: "User-approved device",
+      },
+    },
+    {
+      sequelize,
+      modelName: "Device",
+      tableName: "devices",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  Device.removeAttribute("id");
+  return Device;
+};

package/models/Dispute.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const {
+  DISPUTE_REASON,
+  DISPUTE_STATUS,
+  DISPUTE_RESOLUTION,
+} = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class Dispute extends Model {
+    static associate(models) {
+      Dispute.belongsTo(models.Escrow, {
+        foreignKey: "escrow_id",
+        as: "escrow",
+      });
+
+      Dispute.belongsTo(models.User, {
+        foreignKey: "opened_by",
+        as: "opener",
+      });
+
+      // assigned_admin references admin_users, not users
+      Dispute.belongsTo(models.AdminUser, {
+        foreignKey: "assigned_admin",
+        as: "assignedAdmin",
+      });
+
+      Dispute.hasMany(models.DisputeEvidence, {
+        foreignKey: "dispute_id",
+        as: "evidence",
+      });
+
+      Dispute.hasMany(models.DisputeMessage, {
+        foreignKey: "dispute_id",
+        as: "messages",
+      });
+    }
+  }
+
+  Dispute.init(
+    {
+      dispute_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      escrow_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "escrows", key: "escrow_id" },
+        onDelete: "RESTRICT",
+      },
+      opened_by: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "RESTRICT",
+        comment: "Buyer or seller who opened the dispute",
+      },
+      reason: {
+        type: DataTypes.ENUM(...Object.values(DISPUTE_REASON)),
+        allowNull: false,
+      },
+      description: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+        comment: "Buyer/seller's initial explanation when opening the dispute",
+      },
+      assigned_admin: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: "admin_users", key: "admin_id" },
+        onDelete: "SET NULL",
+        comment: "NULL until assigned by super admin",
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(DISPUTE_STATUS)),
+        allowNull: false,
+        defaultValue: DISPUTE_STATUS.OPEN,
+      },
+      resolution: {
+        type: DataTypes.ENUM(...Object.values(DISPUTE_RESOLUTION)),
+        allowNull: true,
+        defaultValue: null,
+      },
+      resolution_note: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Admin explanation of decision",
+      },
+      resolved_at: {
+        type: DataTypes.DATE,
+        allowNull: true,
+      },
+    },
+    {
+      sequelize,
+      modelName: "Dispute",
+      tableName: "disputes",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  Dispute.removeAttribute("id");
+  return Dispute;
+};

package/models/DisputeEvidence.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { EVIDENCE_FILE_TYPE } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class DisputeEvidence extends Model {
+    static associate(models) {
+      DisputeEvidence.belongsTo(models.Dispute, {
+        foreignKey: "dispute_id",
+        as: "dispute",
+      });
+
+      DisputeEvidence.belongsTo(models.User, {
+        foreignKey: "uploaded_by",
+        as: "uploader",
+      });
+    }
+  }
+
+  DisputeEvidence.init(
+    {
+      dispute_evidence_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      dispute_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "disputes", key: "dispute_id" },
+        onDelete: "CASCADE",
+      },
+      uploaded_by: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "RESTRICT",
+      },
+      file_url: {
+        type: DataTypes.STRING(500),
+        allowNull: false,
+        comment: "AWS S3 URL",
+      },
+      file_type: {
+        type: DataTypes.ENUM(...Object.values(EVIDENCE_FILE_TYPE)),
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "DisputeEvidence",
+      tableName: "dispute_evidence",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  DisputeEvidence.removeAttribute("id");
+  return DisputeEvidence;
+};

package/models/DisputeMessage.js

@@ -0,0 +1,57 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class DisputeMessage extends Model {
+    static associate(models) {
+      DisputeMessage.belongsTo(models.Dispute, {
+        foreignKey: "dispute_id",
+        as: "dispute",
+      });
+
+      DisputeMessage.belongsTo(models.User, {
+        foreignKey: "sender_id",
+        as: "sender",
+      });
+    }
+  }
+
+  DisputeMessage.init(
+    {
+      dispute_message_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      dispute_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "disputes", key: "dispute_id" },
+        onDelete: "CASCADE",
+      },
+      sender_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "RESTRICT",
+        comment: "Buyer or seller user id",
+      },
+      message: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "DisputeMessage",
+      tableName: "dispute_messages",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  DisputeMessage.removeAttribute("id");
+  return DisputeMessage;
+};

package/models/Escrow.js

@@ -0,0 +1,110 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { ESCROW_STATUS } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class Escrow extends Model {
+    static associate(models) {
+      Escrow.belongsTo(models.User, {
+        foreignKey: "buyer_id",
+        as: "buyer",
+      });
+
+      Escrow.belongsTo(models.User, {
+        foreignKey: "seller_id",
+        as: "seller",
+      });
+
+      Escrow.belongsTo(models.Product, {
+        foreignKey: "product_id",
+        as: "product",
+      });
+
+      Escrow.hasMany(models.EscrowEvent, {
+        foreignKey: "escrow_id",
+        as: "events",
+      });
+
+      Escrow.hasOne(models.Dispute, {
+        foreignKey: "escrow_id",
+        as: "dispute",
+      });
+
+      Escrow.hasOne(models.Logistics, {
+        foreignKey: "escrow_id",
+        as: "logistics",
+      });
+
+      Escrow.hasOne(models.Rating, {
+        foreignKey: "escrow_id",
+        as: "rating",
+      });
+    }
+  }
+
+  Escrow.init(
+    {
+      escrow_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      buyer_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "RESTRICT",
+      },
+      seller_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "RESTRICT",
+      },
+      product_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "products", key: "product_id" },
+        onDelete: "RESTRICT",
+      },
+      amount: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+        comment: "Agreed transaction value",
+      },
+      platform_fee: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+        defaultValue: 0.0,
+        comment: "AutoParts NG escrow fee",
+      },
+      currency: {
+        type: DataTypes.STRING(3),
+        allowNull: false,
+        defaultValue: "NGN",
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(ESCROW_STATUS)),
+        allowNull: false,
+        defaultValue: ESCROW_STATUS.PENDING,
+      },
+      delivery_deadline: {
+        type: DataTypes.DATEONLY,
+        allowNull: true,
+        comment: "Auto-release trigger date if buyer does not confirm",
+      },
+    },
+    {
+      sequelize,
+      modelName: "Escrow",
+      tableName: "escrows",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
+  );
+
+  Escrow.removeAttribute("id");
+  return Escrow;
+};

package/models/EscrowEvent.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class EscrowEvent extends Model {
+    static associate(models) {
+      EscrowEvent.belongsTo(models.Escrow, {
+        foreignKey: "escrow_id",
+        as: "escrow",
+      });
+
+      EscrowEvent.belongsTo(models.User, {
+        foreignKey: "created_by",
+        as: "actor",
+      });
+    }
+  }
+
+  EscrowEvent.init(
+    {
+      escrow_event_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      escrow_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "escrows", key: "escrow_id" },
+        onDelete: "CASCADE",
+      },
+      event_type: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+        comment: "FUNDED | ACCEPTED | DELIVERED | RELEASED etc.",
+      },
+      description: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: "Human-readable event detail",
+      },
+      created_by: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: "users", key: "user_id" },
+        onDelete: "SET NULL",
+        comment: "User or system actor (null = system)",
+      },
+    },
+    {
+      sequelize,
+      modelName: "EscrowEvent",
+      tableName: "escrow_events",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  EscrowEvent.removeAttribute("id");
+  return EscrowEvent;
+};

package/models/KycVerification.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { KYC_STATUS, KYC_PROVIDER } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class KycVerification extends Model {
+    static associate(models) {
+      KycVerification.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+    }
+  }
+
+  KycVerification.init(
+    {
+      kyc_verification_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",
+      },
+      nin_data_json: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        comment: "Raw NIN API response from provider",
+      },
+      bank_data_json: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        comment: "Resolved account name and bank details",
+      },
+      verification_status: {
+        type: DataTypes.ENUM(...Object.values(KYC_STATUS)),
+        allowNull: false,
+        defaultValue: KYC_STATUS.PENDING,
+      },
+      provider: {
+        type: DataTypes.ENUM(...Object.values(KYC_PROVIDER)),
+        allowNull: true,
+      },
+    },
+    {
+      sequelize,
+      modelName: "KycVerification",
+      tableName: "kyc_verifications",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  KycVerification.removeAttribute("id");
+  return KycVerification;
+};

package/models/Logistics.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { LOGISTICS_STATUS } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class Logistics extends Model {
+    static associate(models) {
+      Logistics.belongsTo(models.Escrow, {
+        foreignKey: "escrow_id",
+        as: "escrow",
+      });
+    }
+  }
+
+  Logistics.init(
+    {
+      logistics_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      escrow_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        unique: true,
+        references: { model: "escrows", key: "escrow_id" },
+        onDelete: "RESTRICT",
+      },
+      provider: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+        comment: "GIG | DHL | FedEx",
+      },
+      tracking_number: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(LOGISTICS_STATUS)),
+        allowNull: false,
+        defaultValue: LOGISTICS_STATUS.SHIPPED,
+      },
+      delivery_proof_url: {
+        type: DataTypes.STRING(500),
+        allowNull: true,
+        comment: "AWS S3 URL — photo or waybill",
+      },
+    },
+    {
+      sequelize,
+      modelName: "Logistics",
+      tableName: "logistics",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
+  );
+
+  Logistics.removeAttribute("id");
+  return Logistics;
+};

package/models/Notification.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class Notification extends Model {
+    static associate(models) {
+      Notification.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+    }
+  }
+
+  Notification.init(
+    {
+      notification_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+      },
+      type: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+        comment: "ESCROW_FUNDED | PAYMENT_RELEASED | DISPUTE_OPENED etc.",
+      },
+      title: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+      },
+      message: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+      },
+      read_status: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "Notification",
+      tableName: "notifications",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  Notification.removeAttribute("id");
+  return Notification;
+};