dip-dobit-shared-model 1.0.7 → 1.0.9

package/migrations/20260507180000-add-field-to-dobituser-table.js

@@ -0,0 +1,57 @@
+"use strict";
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    const tableDescription = await queryInterface.describeTable("DobitUsers");
+
+    if (!tableDescription.appUserId) {
+      await queryInterface.addColumn("DobitUsers", "appUserId", {
+        type: Sequelize.INTEGER.UNSIGNED,
+        allowNull: true,
+        // unique: true,
+        after: "dobitUserId",
+      });
+    }
+
+    if (!tableDescription.deviceId) {
+      await queryInterface.addColumn("DobitUsers", "deviceId", {
+        type: Sequelize.STRING,
+        allowNull: true,
+        after: "statusId",
+      });
+    }
+
+    if (!tableDescription.pushNotificationId) {
+      await queryInterface.addColumn("DobitUsers", "pushNotificationId", {
+        type: Sequelize.STRING,
+        allowNull: true,
+        after: "deviceId",
+      });
+    }
+  },
+
+  down: async (queryInterface) => {
+    await queryInterface.removeColumn("DobitUsers", "appUserId");
+    await queryInterface.removeColumn("DobitUsers", "deviceId");
+    await queryInterface.removeColumn("DobitUsers", "pushNotificationId");
+  },
+};
+
+// "use strict";
+
+// module.exports = {
+//   up: async (queryInterface, Sequelize) => {
+//     await queryInterface.addColumn("DobitUsers", "appUserId", {
+//       type: Sequelize.INTEGER.UNSIGNED,
+//       allowNull: false,
+//       unique: true,
+//       after: "dobitUserId",
+//       onUpdate: "CASCADE",
+//       onDelete: "NO ACTION",
+//     });
+//   },
+
+//   down: async (queryInterface, Sequelize) => {
+//     await queryInterface.removeColumn("DobitUsers", "appUserId");
+//   },
+// };

package/migrations/20260508163000-create-table-AuthRecords.js

@@ -0,0 +1,78 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("AuthRecords", {
+      authRecordId: {
+        type: Sequelize.INTEGER.UNSIGNED,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      dobitUserId: {
+        type: Sequelize.INTEGER.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "dobitUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      },
+      loginTime: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.NOW,
+      },
+      lastLoginTime: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
+      deviceId: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      deviceName: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      deviceType: {
+        type: Sequelize.ENUM("ios", "android", "web", "other"),
+        allowNull: true,
+      },
+      ipAddress: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      location: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      pushNotificationId: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      isActive: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      deletedAt: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("AuthRecords");
+  },
+};

package/migrations/20260508225000-create-table-DobitUserOTPs.js

@@ -0,0 +1,48 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("DobitUserOTPs", {
+      otpId: {
+        type: Sequelize.INTEGER.UNSIGNED,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      dobitUserId: {
+        type: Sequelize.INTEGER.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "dobitUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      },
+      email: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      otp: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      expiresAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("DobitUserOTPs");
+  },
+};

package/migrations/20260509001000-change-data-in-DobitUser.js

@@ -0,0 +1,35 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    // Change appUserId from INTEGER to STRING
+    await queryInterface.changeColumn("DobitUsers", "appUserId", {
+      type: Sequelize.STRING,
+      allowNull: true, // temporarily allow null during conversion
+      unique: true,
+    });
+
+    // Change statusId default from ACTIVE to INACTIVE
+    await queryInterface.changeColumn("DobitUsers", "statusId", {
+      type: Sequelize.INTEGER.UNSIGNED,
+      allowNull: false,
+      defaultValue: 2, // STATUS_ID.INACTIVE
+    });
+  },
+
+  async down(queryInterface, Sequelize) {
+    // Revert appUserId back to INTEGER
+    await queryInterface.changeColumn("DobitUsers", "appUserId", {
+      type: Sequelize.INTEGER.UNSIGNED,
+      allowNull: true,
+      unique: true,
+    });
+
+    // Revert statusId default back to ACTIVE
+    await queryInterface.changeColumn("DobitUsers", "statusId", {
+      type: Sequelize.INTEGER.UNSIGNED,
+      allowNull: false,
+      defaultValue: 1, // STATUS_ID.ACTIVE
+    });
+  },
+};

package/migrations/20260512112000-add-new-fields-to-DobitUsers.js

@@ -0,0 +1,89 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    const tableDescription = await queryInterface.describeTable("DobitUsers");
+    const columnsToAdd = [];
+
+    if (!tableDescription.pin) {
+      columnsToAdd.push(
+        queryInterface.addColumn("DobitUsers", "pin", {
+          type: Sequelize.STRING,
+          allowNull: true,
+          after: "password",
+        }),
+      );
+    }
+
+    if (!tableDescription.biometrics) {
+      columnsToAdd.push(
+        queryInterface.addColumn("DobitUsers", "biometrics", {
+          type: Sequelize.BOOLEAN,
+          allowNull: false,
+          defaultValue: false,
+          after: "pushNotificationId",
+        }),
+      );
+    }
+
+    if (!tableDescription.pushNotification) {
+      columnsToAdd.push(
+        queryInterface.addColumn("DobitUsers", "pushNotification", {
+          type: Sequelize.BOOLEAN,
+          allowNull: false,
+          defaultValue: true,
+          after: "biometrics",
+        }),
+      );
+    }
+
+    if (!tableDescription.emailNotification) {
+      columnsToAdd.push(
+        queryInterface.addColumn("DobitUsers", "emailNotification", {
+          type: Sequelize.BOOLEAN,
+          allowNull: false,
+          defaultValue: true,
+          after: "pushNotification",
+        }),
+      );
+    }
+
+    if (!tableDescription.promotionalOffers) {
+      columnsToAdd.push(
+        queryInterface.addColumn("DobitUsers", "promotionalOffers", {
+          type: Sequelize.BOOLEAN,
+          allowNull: false,
+          defaultValue: true,
+          after: "emailNotification",
+        }),
+      );
+    }
+
+    if (columnsToAdd.length > 0) {
+      await Promise.all(columnsToAdd);
+    }
+
+    // Change appUserId from STRING to BIGINT
+    if (tableDescription.appUserId) {
+      await queryInterface.changeColumn("DobitUsers", "appUserId", {
+        type: Sequelize.BIGINT.UNSIGNED,
+        allowNull: true,
+        unique: true,
+      });
+    }
+  },
+
+  async down(queryInterface, Sequelize) {
+    await queryInterface.removeColumn("DobitUsers", "pin");
+    await queryInterface.removeColumn("DobitUsers", "biometrics");
+    await queryInterface.removeColumn("DobitUsers", "pushNotification");
+    await queryInterface.removeColumn("DobitUsers", "emailNotification");
+    await queryInterface.removeColumn("DobitUsers", "promotionalOffers");
+
+    await queryInterface.changeColumn("DobitUsers", "appUserId", {
+      type: Sequelize.STRING,
+      allowNull: true,
+      unique: true,
+    });
+  },
+};

package/migrations/20260512112500-create-table-Transactions.js

@@ -0,0 +1,113 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("Transactions", {
+      transactionId: {
+        type: Sequelize.INTEGER.UNSIGNED,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      transactionRef: {
+        type: Sequelize.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      dobitUserId: {
+        type: Sequelize.INTEGER.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "dobitUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "RESTRICT",
+      },
+      serviceType: {
+        type: Sequelize.ENUM(
+          "airtime",
+          "data",
+          "electricity",
+          "cable_tv",
+          "internet",
+          "water",
+          "betting",
+          "education",
+          "other",
+        ),
+        allowNull: false,
+      },
+      provider: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      recipient: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      packageName: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      amount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      discount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: true,
+        defaultValue: 0.0,
+      },
+      amountCharged: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      gatewayRef: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      gatewayResponse: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      status: {
+        type: Sequelize.ENUM("pending", "successful", "failed", "reversed"),
+        allowNull: false,
+        defaultValue: "pending",
+      },
+      token: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      metadata: {
+        type: Sequelize.JSON,
+        allowNull: true,
+      },
+      deviceId: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      ipAddress: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      deletedAt: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("Transactions");
+  },
+};

package/migrations/20260512113000-add-appUserId-to-AuthRecords.js

@@ -0,0 +1,25 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    const tableDescription = await queryInterface.describeTable("AuthRecords");
+
+    if (!tableDescription.appUserId) {
+      await queryInterface.addColumn("AuthRecords", "appUserId", {
+        type: Sequelize.BIGINT.UNSIGNED,
+        allowNull: true, // temporarily allow null for existing rows
+        after: "dobitUserId",
+        references: {
+          model: "DobitUsers",
+          key: "appUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      });
+    }
+  },
+
+  async down(queryInterface) {
+    await queryInterface.removeColumn("AuthRecords", "appUserId");
+  },
+};

package/migrations/20260512113501-add-appUserId-in-DobitUserOTP.js

@@ -0,0 +1,64 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    const tableDescription =
+      await queryInterface.describeTable("DobitUserOTPs");
+
+    // Add appUserId column without inline references
+    if (!tableDescription.appUserId) {
+      await queryInterface.addColumn("DobitUserOTPs", "appUserId", {
+        type: Sequelize.BIGINT.UNSIGNED,
+        allowNull: true,
+        after: "dobitUserId",
+      });
+
+      await queryInterface.addConstraint("DobitUserOTPs", {
+        fields: ["appUserId"],
+        type: "foreign key",
+        name: "DobitUserOTPs_appUserId_fk",
+        references: {
+          table: "DobitUsers",
+          field: "appUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      });
+    }
+
+    // Add dobitUserId column without inline references
+    if (!tableDescription.dobitUserId) {
+      await queryInterface.addColumn("DobitUserOTPs", "dobitUserId", {
+        type: Sequelize.INTEGER.UNSIGNED,
+        allowNull: true,
+        after: "otpId",
+      });
+
+      await queryInterface.addConstraint("DobitUserOTPs", {
+        fields: ["dobitUserId"],
+        type: "foreign key",
+        name: "DobitUserOTPs_dobitUserId_fk",
+        references: {
+          table: "DobitUsers",
+          field: "dobitUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      });
+    }
+  },
+
+  async down(queryInterface) {
+    await queryInterface.removeConstraint(
+      "DobitUserOTPs",
+      "DobitUserOTPs_appUserId_fk",
+    );
+    await queryInterface.removeColumn("DobitUserOTPs", "appUserId");
+
+    await queryInterface.removeConstraint(
+      "DobitUserOTPs",
+      "DobitUserOTPs_dobitUserId_fk",
+    );
+    await queryInterface.removeColumn("DobitUserOTPs", "dobitUserId");
+  },
+};

package/models/authRecords.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class AuthRecords extends Model {
+    static associate(models) {
+      AuthRecords.belongsTo(models.DobitUsers, {
+        as: "user",
+        foreignKey: "dobitUserId",
+      });
+    }
+  }
+
+  AuthRecords.init(
+    {
+      authRecordId: {
+        type: DataTypes.INTEGER.UNSIGNED,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      dobitUserId: {
+        type: DataTypes.INTEGER.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "dobitUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      },
+      appUserId: {
+        type: DataTypes.BIGINT.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "appUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      },
+      loginTime: {
+        type: DataTypes.DATE,
+        allowNull: false,
+        defaultValue: DataTypes.NOW,
+      },
+      lastLoginTime: {
+        type: DataTypes.DATE,
+        allowNull: true,
+      },
+      deviceId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      deviceName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      deviceType: {
+        type: DataTypes.ENUM("ios", "android", "web", "other"),
+        allowNull: true,
+      },
+      ipAddress: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      location: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      pushNotificationId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      isActive: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+      },
+    },
+    {
+      sequelize,
+      modelName: "AuthRecords",
+      tableName: "AuthRecords",
+      timestamps: true,
+      paranoid: true,
+    },
+  );
+
+  AuthRecords.removeAttribute("id");
+  return AuthRecords;
+};

package/models/dobitUser.js

@@ -6,7 +6,6 @@ const { STATUS_ID } = require("../service/constants");
 module.exports = (sequelize) => {
   class DobitUsers extends Model {
     static associate(models) {
-      // define association here
       DobitUsers.belongsTo(models.PortalUsers, {
         as: "createdBy",
         foreignKey: "userCreatedby",
@@ -15,6 +14,14 @@ module.exports = (sequelize) => {
         as: "updatedBy",
         foreignKey: "userUpdatedby",
       });
+      DobitUsers.hasMany(models.AuthRecords, {
+        as: "authRecords",
+        foreignKey: "dobitUserId",
+      });
+      DobitUsers.hasMany(models.Transactions, {
+        as: "transactions",
+        foreignKey: "dobitUserId",
+      });
     }
   }
 
@@ -26,6 +33,11 @@ module.exports = (sequelize) => {
         autoIncrement: true,
         allowNull: false,
       },
+      appUserId: {
+        type: DataTypes.BIGINT.UNSIGNED,
+        allowNull: false,
+        unique: true,
+      },
       firstName: {
         type: DataTypes.STRING,
         allowNull: false,
@@ -38,9 +50,7 @@ module.exports = (sequelize) => {
         type: DataTypes.STRING,
         allowNull: false,
         unique: true,
-        validate: {
-          isEmail: true,
-        },
+        validate: { isEmail: true },
       },
       username: {
         type: DataTypes.STRING,
@@ -56,6 +66,10 @@ module.exports = (sequelize) => {
         type: DataTypes.STRING,
         allowNull: false,
       },
+      pin: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
       nin: {
         type: DataTypes.STRING,
         allowNull: true,
@@ -64,13 +78,41 @@ module.exports = (sequelize) => {
       statusId: {
         type: DataTypes.INTEGER.UNSIGNED,
         allowNull: false,
-        defaultValue: STATUS_ID.ACTIVE,
+        defaultValue: STATUS_ID.INACTIVE,
+      },
+      deviceId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      pushNotificationId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      biometrics: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      pushNotification: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+      },
+      emailNotification: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
+      },
+      promotionalOffers: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: true,
       },
       userCreatedby: {
         type: DataTypes.INTEGER.UNSIGNED,
         allowNull: true,
         references: {
-          model: "PortalUser",
+          model: "PortalUsers",
           key: "portalUserId",
         },
       },
@@ -78,7 +120,7 @@ module.exports = (sequelize) => {
         type: DataTypes.INTEGER.UNSIGNED,
         allowNull: true,
         references: {
-          model: "PortalUser",
+          model: "PortalUsers",
           key: "portalUserId",
         },
       },
@@ -95,5 +137,3 @@ module.exports = (sequelize) => {
   DobitUsers.removeAttribute("id");
   return DobitUsers;
 };
-
-// firstName, lastName, email, username, phoneNumber, password, nin

package/models/dobitUserOTP.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class DobitUserOTP extends Model {
+    static associate(models) {
+      DobitUserOTP.belongsTo(models.DobitUsers, {
+        as: "user",
+        foreignKey: "dobitUserId",
+      });
+    }
+  }
+
+  DobitUserOTP.init(
+    {
+      otpId: {
+        type: DataTypes.INTEGER.UNSIGNED,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      dobitUserId: {
+        type: DataTypes.INTEGER.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "dobitUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      },
+      appUserId: {
+        type: DataTypes.BIGINT.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "appUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE",
+      },
+      email: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      otp: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      expiresAt: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: "DobitUserOTP",
+      tableName: "DobitUserOTPs",
+      timestamps: true,
+      paranoid: false,
+    },
+  );
+
+  DobitUserOTP.removeAttribute("id");
+  return DobitUserOTP;
+};

package/models/transactions.js

@@ -0,0 +1,135 @@
+"use strict";
+
+const { Model, DataTypes } = require("sequelize");
+
+module.exports = (sequelize) => {
+  class Transactions extends Model {
+    static associate(models) {
+      Transactions.belongsTo(models.DobitUsers, {
+        as: "user",
+        foreignKey: "dobitUserId",
+      });
+    }
+  }
+
+  Transactions.init(
+    {
+      transactionId: {
+        type: DataTypes.INTEGER.UNSIGNED,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      transactionRef: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      dobitUserId: {
+        type: DataTypes.INTEGER.UNSIGNED,
+        allowNull: false,
+        references: {
+          model: "DobitUsers",
+          key: "dobitUserId",
+        },
+        onUpdate: "CASCADE",
+        onDelete: "RESTRICT",
+      },
+      appUserId: {
+        type: DataTypes.BIGINT.UNSIGNED,
+        allowNull: false,
+        references: { model: "DobitUsers", key: "appUserId" },
+        onUpdate: "CASCADE",
+        onDelete: "RESTRICT",
+      },
+      // Bills payment type: airtime, data, electricity, cable, etc.
+      serviceType: {
+        type: DataTypes.ENUM(
+          "airtime",
+          "data",
+          "electricity",
+          "cable_tv",
+          "internet",
+          "water",
+          "betting",
+          "education",
+          "other",
+        ),
+        allowNull: false,
+      },
+      // Network or provider: MTN, Airtel, DSTV, EKEDC, etc.
+      provider: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      // Phone number, meter number, smartcard number, etc.
+      recipient: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      // Data bundle, TV package, electricity token, etc.
+      packageName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      amount: {
+        type: DataTypes.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      // Cashback or discount applied
+      discount: {
+        type: DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        defaultValue: 0.0,
+      },
+      // Final amount charged after discount
+      amountCharged: {
+        type: DataTypes.DECIMAL(10, 2),
+        allowNull: false,
+      },
+      // Response from payment gateway
+      gatewayRef: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      gatewayResponse: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      status: {
+        type: DataTypes.ENUM("pending", "successful", "failed", "reversed"),
+        allowNull: false,
+        defaultValue: "pending",
+      },
+      // Token or PIN returned for electricity payments
+      token: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      // Extra metadata from provider response (units, bonus, etc.)
+      metadata: {
+        type: DataTypes.JSON,
+        allowNull: true,
+      },
+      // Device used to make the transaction
+      deviceId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+      ipAddress: {
+        type: DataTypes.STRING,
+        allowNull: true,
+      },
+    },
+    {
+      sequelize,
+      modelName: "Transactions",
+      tableName: "Transactions",
+      timestamps: true,
+      paranoid: true,
+    },
+  );
+
+  Transactions.removeAttribute("id");
+  return Transactions;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dip-dobit-shared-model",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "main": "models/index.js",
   "scripts": {
     "migrate:up": "npx sequelize-cli db:migrate",