@nutrien-br/liborgs 1.0.0

package/lib/index.mjs

@@ -0,0 +1,912 @@
+// src/infra/database/strategies/PostgresStrategy.ts
+import { Sequelize } from "sequelize";
+import pg from "pg";
+var PostgresStrategy = class {
+  constructor(config) {
+    this.config = config;
+  }
+  connect() {
+    return new Sequelize({
+      ...this.config,
+      dialect: "postgres",
+      dialectModule: pg,
+      logging: false,
+      pool: { max: 20, min: 5, acquire: 3e4, idle: 1e4 }
+    });
+  }
+};
+
+// src/infra/database/strategies/SqliteStrategy.ts
+import { Sequelize as Sequelize2 } from "sequelize";
+var SqliteStrategy = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  connect() {
+    return new Sequelize2({
+      dialect: "sqlite",
+      storage: this.storage || ":memory:",
+      logging: false
+    });
+  }
+};
+
+// src/infra/database/Database.ts
+var Database = class _Database {
+  static getConnection() {
+    if (!_Database.instance) {
+      const strategy = _Database.resolveStrategy();
+      _Database.instance = strategy.connect();
+    }
+    return _Database.instance;
+  }
+  static resolveStrategy() {
+    const env = process.env.NODE_ENV || "development";
+    const isProductionLike = ["dev", "sit", "pre-prod", "prod"].includes(env);
+    if (isProductionLike) {
+      return new PostgresStrategy({
+        username: process.env.DB_USER,
+        password: process.env.DB_PASSWORD,
+        database: process.env.DB_NAME,
+        host: process.env.DB_HOST,
+        port: Number(process.env.DB_PORT)
+      });
+    }
+    return new SqliteStrategy(process.env.DB_STORAGE);
+  }
+};
+
+// src/infra/models/schFinancial/CreditAnalysisResult.ts
+import {
+  DataTypes,
+  Model
+} from "sequelize";
+var CreditAnalysisResult = class _CreditAnalysisResult extends Model {
+  init(sequelize) {
+    _CreditAnalysisResult.init({
+      careId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      careExternalId: {
+        type: DataTypes.STRING(255),
+        allowNull: false
+      },
+      careRequestedLimit: {
+        type: DataTypes.DECIMAL(15, 2)
+      },
+      careApprovedLimit: {
+        type: DataTypes.DECIMAL(15, 2)
+      },
+      careDateSolicitation: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW
+      },
+      careResponseDate: {
+        type: DataTypes.DATE
+      },
+      careResponse: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false
+      },
+      careRequestId: {
+        type: DataTypes.UUID,
+        allowNull: false
+      },
+      soliId: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      },
+      csrcId: {
+        type: DataTypes.INTEGER,
+        allowNull: false
+      }
+    }, {
+      sequelize,
+      tableName: "credit_analysis_result",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _CreditAnalysisResult.belongsTo(Solicitation, { foreignKey: "soliId", as: "solicitation" });
+    _CreditAnalysisResult.belongsTo(CreditSource, { foreignKey: "csrcId", as: "creditSource" });
+  }
+};
+
+// src/infra/models/schFinancial/CreditSource.ts
+import { DataTypes as DataTypes3, Model as Model3 } from "sequelize";
+
+// src/infra/models/schFinancial/CreditSourceLimitHistory.ts
+import {
+  DataTypes as DataTypes2,
+  Model as Model2
+} from "sequelize";
+var CreditSourceLimitHistory = class _CreditSourceLimitHistory extends Model2 {
+  init(sequelize) {
+    _CreditSourceLimitHistory.init({
+      cslhId: {
+        type: DataTypes2.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      csrcId: {
+        type: DataTypes2.INTEGER,
+        allowNull: false
+      },
+      persId: {
+        type: DataTypes2.INTEGER,
+        allowNull: true,
+        references: { model: { tableName: "person", schema: "sch_orgs" }, key: "pers_id" }
+      },
+      compId: {
+        type: DataTypes2.INTEGER,
+        allowNull: true,
+        references: { model: { tableName: "company", schema: "sch_orgs" }, key: "comp_id" }
+      },
+      cslhTotalLimit: {
+        type: DataTypes2.DECIMAL(15, 2),
+        allowNull: false
+      },
+      cslhUsedLimit: {
+        type: DataTypes2.DECIMAL(15, 2),
+        allowNull: false
+      },
+      cslhAvailableLimit: {
+        type: DataTypes2.DECIMAL(15, 2),
+        allowNull: true
+        // set() { throw new Error('cslhAvailableLimit is a read-only generated column'); }
+      },
+      cslhReferenceDate: {
+        type: DataTypes2.DATEONLY,
+        allowNull: false
+      },
+      cslhCreatedAt: {
+        type: DataTypes2.DATE,
+        defaultValue: DataTypes2.NOW
+      }
+    }, {
+      sequelize,
+      tableName: "credit_source_limit_history",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _CreditSourceLimitHistory.belongsTo(Person, { foreignKey: "persId", as: "person" });
+    _CreditSourceLimitHistory.belongsTo(Company, { foreignKey: "compId", as: "company" });
+    _CreditSourceLimitHistory.belongsTo(CreditSource, {
+      foreignKey: "csrcId",
+      as: "creditSource",
+      onDelete: "CASCADE"
+    });
+  }
+};
+
+// src/infra/models/schFinancial/CreditSource.ts
+var CreditSource = class _CreditSource extends Model3 {
+  init(sequelize) {
+    _CreditSource.init({
+      csrcId: {
+        type: DataTypes3.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      csrcName: {
+        type: DataTypes3.STRING,
+        allowNull: false
+      },
+      csrcType: {
+        type: DataTypes3.ENUM("PARTNER", "IN_HOUSE"),
+        allowNull: false
+      }
+    }, {
+      sequelize,
+      tableName: "credit_start",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _CreditSource.hasMany(CreditSourceLimitHistory, {
+      foreignKey: "csrcId",
+      as: "limitHistories"
+    });
+    _CreditSource.hasMany(CreditAnalysisResult, { foreignKey: "csrcId", as: "analysisResults" });
+  }
+};
+
+// src/infra/models/schFinancial/RateRules.ts
+import { DataTypes as DataTypes4, Model as Model4 } from "sequelize";
+var RateRules = class _RateRules extends Model4 {
+  init(sequelize) {
+    _RateRules.init({
+      raruId: {
+        type: DataTypes4.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      raruVersion: {
+        type: DataTypes4.INTEGER,
+        allowNull: true
+      },
+      raruRating: {
+        type: DataTypes4.STRING(2),
+        allowNull: false
+      },
+      raruInHousePercentage: {
+        type: DataTypes4.DECIMAL(5, 2),
+        allowNull: false
+      },
+      raruPartnerPercentage: {
+        type: DataTypes4.DECIMAL(5, 2),
+        allowNull: false
+      }
+    }, {
+      sequelize,
+      tableName: "rate_rules",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+  }
+};
+
+// src/infra/models/schFinancial/Solicitation.ts
+import { DataTypes as DataTypes7, Model as Model7 } from "sequelize";
+
+// src/infra/models/schFinancial/SolicitationRate.ts
+import { DataTypes as DataTypes5, Model as Model5 } from "sequelize";
+var SolicitationRate = class _SolicitationRate extends Model5 {
+  init(sequelize) {
+    _SolicitationRate.init({
+      soraId: {
+        type: DataTypes5.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      soraRating: {
+        type: DataTypes5.STRING(2),
+        allowNull: true
+      },
+      soraInHousePercentage: {
+        type: DataTypes5.DECIMAL(5, 2),
+        allowNull: false
+      },
+      soraPartnerPercentage: {
+        type: DataTypes5.DECIMAL(5, 2),
+        allowNull: false
+      },
+      soraInHouseAllocation: {
+        type: DataTypes5.DECIMAL(15, 2),
+        allowNull: false
+      },
+      soraPartnerAllocation: {
+        type: DataTypes5.DECIMAL(15, 2),
+        allowNull: false
+      },
+      soliId: {
+        type: DataTypes5.INTEGER,
+        allowNull: false,
+        references: {
+          model: {
+            tableName: "solicitation",
+            schema: "sch_financial"
+          },
+          key: "soli_id"
+        }
+      }
+    }, {
+      sequelize,
+      tableName: "solicitation_rate",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _SolicitationRate.belongsTo(Solicitation, {
+      foreignKey: "soliId",
+      as: "solicitation",
+      onDelete: "CASCADE",
+      onUpdate: "CASCADE"
+    });
+  }
+};
+
+// src/infra/models/schFinancial/SolicitationNf.ts
+import {
+  DataTypes as DataTypes6,
+  Model as Model6
+} from "sequelize";
+var SolicitationNf = class _SolicitationNf extends Model6 {
+  init(sequelize) {
+    _SolicitationNf.init({
+      sonfId: {
+        type: DataTypes6.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      sonfSumNf: {
+        type: DataTypes6.DECIMAL(15, 2),
+        allowNull: true
+      },
+      sonfCompleted: {
+        type: DataTypes6.BOOLEAN,
+        defaultValue: false,
+        allowNull: false
+      },
+      sonfRequestId: {
+        type: DataTypes6.UUID,
+        allowNull: false
+      },
+      soliId: {
+        type: DataTypes6.INTEGER,
+        allowNull: false,
+        references: {
+          model: {
+            tableName: "solicitation",
+            schema: "sch_financial"
+          },
+          key: "soli_id"
+        }
+      }
+    }, {
+      sequelize,
+      tableName: "solicitation_nf",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _SolicitationNf.belongsTo(Solicitation, {
+      foreignKey: "soliId",
+      as: "solicitation",
+      onDelete: "CASCADE",
+      onUpdate: "CASCADE"
+    });
+  }
+};
+
+// src/infra/models/schFinancial/Solicitation.ts
+var Solicitation = class _Solicitation extends Model7 {
+  init(sequelize) {
+    _Solicitation.init({
+      soliId: {
+        type: DataTypes7.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      soliRequestedLimit: {
+        type: DataTypes7.NUMBER,
+        allowNull: false
+      },
+      soliCompleted: {
+        type: DataTypes7.BOOLEAN,
+        defaultValue: false,
+        allowNull: false
+      },
+      persId: {
+        type: DataTypes7.INTEGER,
+        allowNull: true,
+        references: {
+          model: {
+            tableName: "person",
+            schema: "sch_orgs"
+          },
+          key: "pers_id"
+        }
+      },
+      compId: {
+        type: DataTypes7.INTEGER,
+        allowNull: true,
+        references: {
+          model: {
+            tableName: "company",
+            schema: "sch_orgs"
+          },
+          key: "comp_id"
+        }
+      }
+    }, {
+      sequelize,
+      tableName: "solicitation",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _Solicitation.belongsTo(Person, {
+      foreignKey: "persId",
+      as: "person"
+    });
+    _Solicitation.belongsTo(Company, {
+      foreignKey: "compId",
+      as: "company"
+    });
+    _Solicitation.hasMany(SolicitationRate, {
+      foreignKey: "soliId",
+      as: "rates"
+    });
+    _Solicitation.hasMany(SolicitationRevenue, {
+      foreignKey: "soliId",
+      as: "revenues"
+    });
+    _Solicitation.hasMany(SolicitationNf, { foreignKey: "soliId", as: "nfs" });
+    _Solicitation.hasMany(CreditAnalysisResult, { foreignKey: "soliId", as: "analysisResults" });
+  }
+};
+
+// src/infra/models/schFinancial/SolicitationRevenue.ts
+import {
+  DataTypes as DataTypes8,
+  Model as Model8
+} from "sequelize";
+var SolicitationRevenue = class _SolicitationRevenue extends Model8 {
+  init(sequelize) {
+    _SolicitationRevenue.init({
+      soreId: {
+        type: DataTypes8.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      soreRevenue: {
+        type: DataTypes8.DECIMAL(15, 2),
+        allowNull: true
+      },
+      soreCompleted: {
+        type: DataTypes8.BOOLEAN,
+        defaultValue: false,
+        allowNull: false
+      },
+      soreRequestId: {
+        type: DataTypes8.UUID,
+        allowNull: false
+      },
+      soliId: {
+        type: DataTypes8.INTEGER,
+        allowNull: false,
+        references: {
+          model: {
+            tableName: "solicitation",
+            schema: "sch_financial"
+          },
+          key: "soli_id"
+        }
+      }
+    }, {
+      sequelize,
+      tableName: "solicitation_revenue",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_financial",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _SolicitationRevenue.belongsTo(Solicitation, {
+      foreignKey: "soliId",
+      as: "solicitation",
+      onDelete: "CASCADE",
+      onUpdate: "CASCADE"
+    });
+  }
+};
+
+// src/infra/models/schOrgs/Company.ts
+import { DataTypes as DataTypes9, Model as Model9 } from "sequelize";
+var Company = class _Company extends Model9 {
+  init(sequelize) {
+    _Company.init({
+      compId: {
+        type: DataTypes9.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      compDes: {
+        type: DataTypes9.STRING(60)
+      },
+      compCorporateName: {
+        type: DataTypes9.STRING(300),
+        allowNull: false
+      },
+      compRegistration: {
+        type: DataTypes9.STRING(20)
+      },
+      compUuid: {
+        type: DataTypes9.UUID,
+        defaultValue: DataTypes9.UUIDV4
+      },
+      compObs: {
+        type: DataTypes9.STRING(4e3)
+      },
+      compRegisDate: {
+        type: DataTypes9.DATE,
+        allowNull: false
+      },
+      compRegisUser: {
+        type: DataTypes9.STRING(100),
+        allowNull: false
+      },
+      compErpRegisDate: {
+        type: DataTypes9.DATE,
+        defaultValue: DataTypes9.NOW
+      }
+    }, {
+      sequelize,
+      tableName: "companies",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_orgs",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _Company.hasMany(Solicitation, {
+      foreignKey: "compId",
+      as: "solicitations"
+    });
+    _Company.hasMany(CreditSourceLimitHistory, {
+      foreignKey: "compId",
+      as: "creditLimitHistories"
+    });
+  }
+};
+
+// src/infra/models/schOrgs/Person.ts
+import { DataTypes as DataTypes10, Model as Model10 } from "sequelize";
+var Person = class _Person extends Model10 {
+  init(sequelize) {
+    _Person.init({
+      persId: {
+        type: DataTypes10.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      persName: {
+        type: DataTypes10.STRING(100),
+        allowNull: false
+      },
+      persSocialName: {
+        type: DataTypes10.STRING(100)
+      },
+      persFirstName: {
+        type: DataTypes10.STRING(50)
+      },
+      persLastName: {
+        type: DataTypes10.STRING(50)
+      },
+      persBirthDate: {
+        type: DataTypes10.DATE
+      },
+      persMothersName: {
+        type: DataTypes10.STRING(100)
+      },
+      persFathersName: {
+        type: DataTypes10.STRING(100)
+      },
+      persIndSex: {
+        type: DataTypes10.STRING(1)
+      },
+      persRegistration: {
+        type: DataTypes10.STRING(20)
+      },
+      persUuid: {
+        type: DataTypes10.UUID,
+        defaultValue: DataTypes10.UUIDV4
+      },
+      mastCod: {
+        type: DataTypes10.STRING(10)
+      },
+      gendCod: {
+        type: DataTypes10.STRING(10)
+      },
+      persObs: {
+        type: DataTypes10.STRING(4e3)
+      },
+      persRegisDate: {
+        type: DataTypes10.DATE,
+        allowNull: false
+      },
+      persRegisUser: {
+        type: DataTypes10.STRING(50),
+        allowNull: false
+      },
+      persErpRegisDate: {
+        type: DataTypes10.DATE,
+        defaultValue: DataTypes10.NOW
+      }
+    }, {
+      sequelize,
+      tableName: "person",
+      schema: process.env.NODE_ENV === "test" ? void 0 : "sch_orgs",
+      underscored: true,
+      timestamps: false
+    });
+  }
+  associate() {
+    _Person.hasMany(Solicitation, {
+      foreignKey: "persId",
+      as: "solicitations"
+    });
+    _Person.hasMany(CreditSourceLimitHistory, {
+      foreignKey: "persId",
+      as: "creditLimitHistories"
+    });
+  }
+};
+
+// src/infra/models/initModels.ts
+async function initModels() {
+  const sequelize = Database.getConnection();
+  const models = [
+    Person,
+    Company,
+    CreditSource,
+    Solicitation,
+    SolicitationRate,
+    RateRules,
+    SolicitationRevenue,
+    SolicitationNf,
+    CreditSourceLimitHistory,
+    CreditAnalysisResult
+  ];
+  models.forEach((model) => {
+    model.prototype.init(sequelize);
+  });
+  models.forEach((model) => {
+    if (model.prototype.associate) {
+      model.prototype.associate();
+    }
+  });
+  return sequelize;
+}
+
+// src/utils/mocks/mockCreditSources.ts
+var mockCreditSources = [
+  {
+    csrcId: 1,
+    csrcName: "FARM",
+    csrcType: "PARTNER"
+  },
+  {
+    csrcId: 2,
+    csrcName: "SUPPLIER",
+    csrcType: "PARTNER"
+  },
+  {
+    csrcId: 3,
+    csrcName: "SELLOR",
+    csrcType: "PARTNER"
+  },
+  {
+    csrcId: 4,
+    csrcName: "NUTRIEN",
+    csrcType: "IN_HOUSE"
+  }
+];
+
+// src/utils/mocks/mockPerson.ts
+import { randomUUID as uuidv4 } from "crypto";
+var mockPerson = [
+  {
+    persId: 1,
+    persName: "JOHNNY MOREIRA",
+    persSocialName: "JOHNNY",
+    persFirstName: "Johnny",
+    persLastName: "Moreira",
+    persBirthDate: /* @__PURE__ */ new Date("1991-01-18"),
+    persMothersName: "TESTE MOREIRA",
+    persFathersName: "TESTE2 MOREIRA",
+    persIndSex: "M",
+    persRegistration: "REG-001",
+    persUuid: uuidv4(),
+    mastCod: "1",
+    persObs: "Usu\xE1rio administrador",
+    persRegisDate: /* @__PURE__ */ new Date(),
+    persRegisUser: "MONEYFARM",
+    persErpRegisDate: /* @__PURE__ */ new Date()
+  }
+];
+
+// src/utils/mocks/mockCompanies.ts
+import { randomUUID as uuidv42 } from "crypto";
+var mockCompanies = [
+  {
+    compId: 1,
+    compDes: "NUTRIEN MATRIZ",
+    compCorporateName: "NUTRIEN SOLUCOES AGRICOLAS LTDA",
+    compRegistration: "12.345.678/0001-00",
+    compUuid: uuidv42(),
+    compObs: "Unidade principal de processamento.",
+    compRegisDate: /* @__PURE__ */ new Date(),
+    compRegisUser: "admin_sys",
+    compErpRegisDate: /* @__PURE__ */ new Date()
+  },
+  {
+    compId: 2,
+    compDes: "FILIAL SUL",
+    compCorporateName: "NUTRIEN AGRICULTURA DO SUL S.A.",
+    compRegistration: "98.765.432/0001-99",
+    compUuid: uuidv42(),
+    compObs: "Respons\xE1vel pela log\xEDstica regional sul.",
+    compRegisDate: /* @__PURE__ */ new Date(),
+    compRegisUser: "johnny_dev",
+    compErpRegisDate: /* @__PURE__ */ new Date()
+  }
+];
+
+// src/utils/mocks/mockSolicitation.ts
+var mockSolicitation = [{
+  soliId: 1,
+  soliRequestedLimit: 5e3,
+  soliCompleted: false,
+  persId: 1,
+  compId: null
+}];
+
+// src/utils/mocks/mockSolicitationRate.ts
+var mockSolicitationRate = [{
+  soraId: 1,
+  soraRating: "A",
+  soraInHousePercentage: 90,
+  soraPartnerPercentage: 10,
+  soraInHouseAllocation: 4500,
+  soraPartnerAllocation: 500,
+  soliId: 1
+}];
+
+// src/utils/mocks/mockRateRules.ts
+var mockRateRules = [
+  {
+    raruId: 1,
+    raruVersion: 1,
+    raruRating: "A",
+    raruInHousePercentage: 90,
+    raruPartnerPercentage: 10
+  },
+  {
+    raruId: 2,
+    raruVersion: 1,
+    raruRating: "B",
+    raruInHousePercentage: 50,
+    raruPartnerPercentage: 50
+  }
+];
+
+// src/utils/mocks/mockSolicitationRevenue.ts
+import { randomUUID as uuidv43 } from "crypto";
+var mockSolicitationRevenue = [
+  {
+    soreId: 1,
+    soreRevenue: 1500.5,
+    soreCompleted: true,
+    soreRequestId: uuidv43(),
+    soliId: 1
+  }
+];
+
+// src/utils/mocks/mockSolicitationNf.ts
+var mockSolicitationNf = [
+  {
+    sonfId: 1,
+    sonfSumNf: 2500,
+    sonfCompleted: true,
+    sonfRequestId: "550e8400-e29b-41d4-a716-446655440000",
+    soliId: 1
+  }
+];
+
+// src/utils/mocks/mockCreditSourceLimitHistory.ts
+var mockCreditSourceLimitHistory = [
+  {
+    cslhId: 1,
+    csrcId: 4,
+    persId: 1,
+    compId: null,
+    cslhTotalLimit: 4e3,
+    cslhUsedLimit: 500,
+    cslhAvailableLimit: 3500,
+    cslhReferenceDate: /* @__PURE__ */ new Date("2026-03-01"),
+    cslhCreatedAt: /* @__PURE__ */ new Date()
+  },
+  {
+    cslhId: 2,
+    csrcId: 2,
+    persId: 1,
+    compId: null,
+    cslhTotalLimit: 1e3,
+    cslhUsedLimit: 500,
+    cslhAvailableLimit: 500,
+    cslhReferenceDate: /* @__PURE__ */ new Date("2026-03-01"),
+    cslhCreatedAt: /* @__PURE__ */ new Date()
+  }
+];
+
+// src/utils/mocks/mockCreditAnalysisResult.ts
+var mockCreditAnalysisResult = [
+  {
+    careId: 1,
+    careExternalId: "FARM_001",
+    careRequestedLimit: 1e4,
+    careApprovedLimit: 5e3,
+    careDateSolicitation: /* @__PURE__ */ new Date("2026-03-01T10:00:00Z"),
+    careResponseDate: /* @__PURE__ */ new Date("2026-03-01T10:05:00Z"),
+    careResponse: true,
+    careRequestId: "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+    soliId: 1,
+    csrcId: 4
+  },
+  {
+    careId: 2,
+    careExternalId: "SUPPLIER_001",
+    careRequestedLimit: 5e3,
+    careApprovedLimit: 0,
+    careDateSolicitation: /* @__PURE__ */ new Date("2026-03-05T14:20:00Z"),
+    careResponseDate: /* @__PURE__ */ new Date("2026-03-05T14:21:00Z"),
+    careResponse: true,
+    careRequestId: "7da7b810-9dad-11d1-80b4-00c04fd430c8",
+    soliId: 1,
+    csrcId: 2
+  }
+];
+
+// src/utils/initMock.ts
+async function initMock() {
+  process.env.NODE_ENV = "test";
+  const sequelize = Database.getConnection();
+  try {
+    await initModels();
+    await sequelize.query("PRAGMA foreign_keys = OFF");
+    await sequelize.sync({ force: true });
+    await Person.bulkCreate(mockPerson);
+    await Company.bulkCreate(mockCompanies);
+    await CreditSource.bulkCreate(mockCreditSources);
+    await Solicitation.bulkCreate(mockSolicitation);
+    await SolicitationRate.bulkCreate(mockSolicitationRate);
+    await RateRules.bulkCreate(mockRateRules);
+    await SolicitationRevenue.bulkCreate(mockSolicitationRevenue);
+    await SolicitationNf.bulkCreate(mockSolicitationNf);
+    await CreditSourceLimitHistory.bulkCreate(mockCreditSourceLimitHistory);
+    await CreditAnalysisResult.bulkCreate(mockCreditAnalysisResult);
+    await sequelize.query("PRAGMA foreign_keys = ON");
+  } catch (error) {
+    console.error("Error no initMock:", error);
+  }
+}
+async function closeMock() {
+  const sequelize = Database.getConnection();
+  try {
+    console.log("Closing Mock DB...");
+    await sequelize.drop();
+  } catch (error) {
+    console.error(error);
+  }
+}
+export {
+  Company,
+  CreditAnalysisResult,
+  CreditSource,
+  CreditSourceLimitHistory,
+  Person,
+  RateRules,
+  Solicitation,
+  SolicitationNf,
+  SolicitationRate,
+  SolicitationRevenue,
+  closeMock,
+  initMock,
+  initModels
+};