ojamoto_models 1.0.0

package/models/PasswordResetOTP.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class PasswordResetOtp extends Model {
+    static associate(models) {}
+  }
+
+  PasswordResetOtp.init(
+    {
+      password_reset_otp_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      email: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      otp: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Hashed before storage",
+      },
+      expires_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "PasswordResetOtp",
+      tableName: "password_reset_otps",
+      timestamps: true,
+      paranoid: false,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      indexes: [
+        {
+          unique: true,
+          fields: ["email"],
+          name: "password_reset_otps_email_unique",
+        },
+      ],
+    },
+  );
+
+  PasswordResetOtp.removeAttribute("id");
+  return PasswordResetOtp;
+};

package/models/PinResetOTP.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class PinResetOtp extends Model {
+    static associate(models) {
+      PinResetOtp.belongsTo(models.User, { foreignKey: "user_id", as: "user" });
+    }
+  }
+
+  PinResetOtp.init(
+    {
+      pin_reset_otp_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",
+      },
+      otp: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: "Hashed before storage",
+      },
+      expires_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "PinResetOtp",
+      tableName: "pin_reset_otps",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
+  );
+
+  PinResetOtp.removeAttribute("id");
+  return PinResetOtp;
+};

package/models/Product.js

@@ -0,0 +1,100 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { PRODUCT_CONDITION, PRODUCT_STATUS } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class Product extends Model {
+    static associate(models) {
+      Product.belongsTo(models.User, {
+        foreignKey: "seller_id",
+        as: "seller",
+      });
+
+      Product.hasMany(models.ProductImage, {
+        foreignKey: "product_id",
+        as: "images",
+      });
+
+      Product.hasMany(models.Escrow, {
+        foreignKey: "product_id",
+        as: "escrows",
+      });
+    }
+  }
+
+  Product.init(
+    {
+      product_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      seller_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+      },
+      name: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+      },
+      description: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      price: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+      },
+      currency: {
+        type: DataTypes.STRING(3),
+        allowNull: false,
+        defaultValue: "NGN",
+      },
+      category: {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+        comment: "Engine | Brake | Suspension etc.",
+      },
+      brand: {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+        comment: "Toyota, Ford, Bosch etc.",
+      },
+      model: {
+        type: DataTypes.STRING(100),
+        allowNull: true,
+        comment: "Camry, F-150 etc.",
+      },
+      condition: {
+        type: DataTypes.ENUM(...Object.values(PRODUCT_CONDITION)),
+        allowNull: false,
+      },
+      stock: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        defaultValue: 1,
+      },
+      status: {
+        type: DataTypes.ENUM(...Object.values(PRODUCT_STATUS)),
+        allowNull: false,
+        defaultValue: PRODUCT_STATUS.DRAFT,
+      },
+    },
+    {
+      sequelize,
+      modelName: "Product",
+      tableName: "products",
+      timestamps: true,
+      paranoid: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      deletedAt: "deleted_at",
+    },
+  );
+
+  Product.removeAttribute("id");
+  return Product;
+};

package/models/ProductImage.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class ProductImage extends Model {
+    static associate(models) {
+      ProductImage.belongsTo(models.Product, {
+        foreignKey: "product_id",
+        as: "product",
+      });
+    }
+  }
+
+  ProductImage.init(
+    {
+      product_image_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      product_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "products", key: "product_id" },
+        onDelete: "CASCADE",
+      },
+      image_url: {
+        type: DataTypes.STRING(500),
+        allowNull: false,
+        comment: "AWS S3 URL",
+      },
+      position: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        comment: "Display order",
+      },
+      ai_metadata: {
+        type: DataTypes.JSON,
+        allowNull: true,
+        comment: "Brand, model, condition extracted by AI analysis",
+      },
+    },
+    {
+      sequelize,
+      modelName: "ProductImage",
+      tableName: "product_images",
+      timestamps: false,
+    },
+  );
+
+  ProductImage.removeAttribute("id");
+  return ProductImage;
+};

package/models/Rating.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class Rating extends Model {
+    static associate(models) {
+      Rating.belongsTo(models.Escrow, {
+        foreignKey: "escrow_id",
+        as: "escrow",
+      });
+
+      Rating.belongsTo(models.User, {
+        foreignKey: "buyer_id",
+        as: "buyer",
+      });
+
+      Rating.belongsTo(models.User, {
+        foreignKey: "seller_id",
+        as: "seller",
+      });
+    }
+  }
+
+  Rating.init(
+    {
+      rating_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",
+        comment: "One rating per completed escrow",
+      },
+      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",
+      },
+      rating: {
+        type: DataTypes.TINYINT,
+        allowNull: false,
+        validate: { min: 1, max: 5 },
+      },
+      comment: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+    },
+    {
+      sequelize,
+      modelName: "Rating",
+      tableName: "ratings",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  Rating.removeAttribute("id");
+  return Rating;
+};

package/models/Role.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { ROLE_NAME } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class Role extends Model {
+    static associate(models) {
+      Role.belongsToMany(models.User, {
+        through: models.UserRole,
+        foreignKey: "role_id",
+        otherKey: "user_id",
+        as: "users",
+      });
+    }
+  }
+
+  Role.init(
+    {
+      role_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      name: {
+        type: DataTypes.ENUM(...Object.values(ROLE_NAME)),
+        allowNull: false,
+        unique: true,
+      },
+    },
+    {
+      sequelize,
+      modelName: "Role",
+      tableName: "roles",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
+  );
+
+  Role.removeAttribute("id");
+  return Role;
+};

package/models/SellerBadges.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const { SELLER_BADGE } = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class SellerBadge extends Model {
+    static associate(models) {
+      SellerBadge.belongsTo(models.SellerProfile, {
+        foreignKey: "seller_profile_id",
+        as: "sellerProfile",
+      });
+    }
+  }
+
+  SellerBadge.init(
+    {
+      seller_badge_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      seller_profile_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "seller_profiles", key: "seller_profile_id" },
+        onDelete: "CASCADE",
+      },
+      badge: {
+        type: DataTypes.ENUM(...Object.values(SELLER_BADGE)),
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "SellerBadge",
+      tableName: "seller_badges",
+      timestamps: true,
+      createdAt: "awarded_at",
+      updatedAt: false,
+    },
+  );
+
+  return SellerBadge;
+};

package/models/SellerProfile.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+const {
+  SELLER_VERIFICATION_STATUS,
+  SELLER_TYPE,
+} = require("../services/constants");
+
+module.exports = (sequelize) => {
+  class SellerProfile extends Model {
+    static associate(models) {
+      SellerProfile.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+
+      SellerProfile.hasMany(models.SellerBadge, {
+        foreignKey: "seller_profile_id",
+        as: "badges",
+      });
+    }
+  }
+
+  SellerProfile.init(
+    {
+      seller_profile_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",
+      },
+      user_type: {
+        type: DataTypes.ENUM(...Object.values(SELLER_TYPE)),
+        allowNull: false,
+      },
+      store_name: {
+        type: DataTypes.STRING(150),
+        allowNull: false,
+      },
+      store_slug: {
+        type: DataTypes.STRING(150),
+        allowNull: false,
+        unique: true,
+        comment: "URL-safe identifier",
+      },
+      description: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+      },
+      logo_url: {
+        type: DataTypes.STRING(500),
+        allowNull: true,
+        comment: "AWS S3 URL",
+      },
+      avg_rating: {
+        type: DataTypes.DECIMAL(3, 2),
+        allowNull: true,
+        comment: "Computed rolling average",
+      },
+      total_sales: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+      },
+      dispute_count: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+      },
+      verification_status: {
+        type: DataTypes.ENUM(...Object.values(SELLER_VERIFICATION_STATUS)),
+        allowNull: false,
+        defaultValue: SELLER_VERIFICATION_STATUS.UNVERIFIED,
+      },
+    },
+    {
+      sequelize,
+      modelName: "SellerProfile",
+      tableName: "seller_profiles",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+    },
+  );
+
+  SellerProfile.removeAttribute("id");
+  return SellerProfile;
+};

package/models/Session.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class Session extends Model {
+    static associate(models) {
+      Session.belongsTo(models.User, {
+        foreignKey: "user_id",
+        as: "user",
+      });
+
+      Session.belongsTo(models.Device, {
+        foreignKey: "device_id",
+        as: "device",
+      });
+    }
+  }
+
+  Session.init(
+    {
+      session_id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      user_id: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: { model: "users", key: "user_id" },
+        onDelete: "CASCADE",
+      },
+      device_id: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: "devices", key: "device_id" },
+        onDelete: "SET NULL",
+      },
+      refresh_token: {
+        type: DataTypes.TEXT,
+        allowNull: false,
+        comment: "Hashed before storage",
+      },
+      expires_at: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        comment: "7 days from issuance",
+      },
+      revoked: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        comment: "Set true on logout",
+      },
+    },
+    {
+      sequelize,
+      modelName: "Session",
+      tableName: "sessions",
+      timestamps: true,
+      createdAt: "created_at",
+      updatedAt: false,
+    },
+  );
+
+  Session.removeAttribute("id");
+  return Session;
+};