@nutrien-br/liborgs 1.0.0

package/lib/index.js

@@ -0,0 +1,949 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Company: () => Company,
+  CreditAnalysisResult: () => CreditAnalysisResult,
+  CreditSource: () => CreditSource,
+  CreditSourceLimitHistory: () => CreditSourceLimitHistory,
+  Person: () => Person,
+  RateRules: () => RateRules,
+  Solicitation: () => Solicitation,
+  SolicitationNf: () => SolicitationNf,
+  SolicitationRate: () => SolicitationRate,
+  SolicitationRevenue: () => SolicitationRevenue,
+  closeMock: () => closeMock,
+  initMock: () => initMock,
+  initModels: () => initModels
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/infra/database/strategies/PostgresStrategy.ts
+var import_sequelize = require("sequelize");
+var import_pg = __toESM(require("pg"));
+var PostgresStrategy = class {
+  constructor(config) {
+    this.config = config;
+  }
+  connect() {
+    return new import_sequelize.Sequelize({
+      ...this.config,
+      dialect: "postgres",
+      dialectModule: import_pg.default,
+      logging: false,
+      pool: { max: 20, min: 5, acquire: 3e4, idle: 1e4 }
+    });
+  }
+};
+
+// src/infra/database/strategies/SqliteStrategy.ts
+var import_sequelize2 = require("sequelize");
+var SqliteStrategy = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  connect() {
+    return new import_sequelize2.Sequelize({
+      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
+var import_sequelize3 = require("sequelize");
+var CreditAnalysisResult = class _CreditAnalysisResult extends import_sequelize3.Model {
+  init(sequelize) {
+    _CreditAnalysisResult.init({
+      careId: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      careExternalId: {
+        type: import_sequelize3.DataTypes.STRING(255),
+        allowNull: false
+      },
+      careRequestedLimit: {
+        type: import_sequelize3.DataTypes.DECIMAL(15, 2)
+      },
+      careApprovedLimit: {
+        type: import_sequelize3.DataTypes.DECIMAL(15, 2)
+      },
+      careDateSolicitation: {
+        type: import_sequelize3.DataTypes.DATE,
+        defaultValue: import_sequelize3.DataTypes.NOW
+      },
+      careResponseDate: {
+        type: import_sequelize3.DataTypes.DATE
+      },
+      careResponse: {
+        type: import_sequelize3.DataTypes.BOOLEAN,
+        defaultValue: false
+      },
+      careRequestId: {
+        type: import_sequelize3.DataTypes.UUID,
+        allowNull: false
+      },
+      soliId: {
+        type: import_sequelize3.DataTypes.INTEGER,
+        allowNull: false
+      },
+      csrcId: {
+        type: import_sequelize3.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
+var import_sequelize5 = require("sequelize");
+
+// src/infra/models/schFinancial/CreditSourceLimitHistory.ts
+var import_sequelize4 = require("sequelize");
+var CreditSourceLimitHistory = class _CreditSourceLimitHistory extends import_sequelize4.Model {
+  init(sequelize) {
+    _CreditSourceLimitHistory.init({
+      cslhId: {
+        type: import_sequelize4.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      csrcId: {
+        type: import_sequelize4.DataTypes.INTEGER,
+        allowNull: false
+      },
+      persId: {
+        type: import_sequelize4.DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: { tableName: "person", schema: "sch_orgs" }, key: "pers_id" }
+      },
+      compId: {
+        type: import_sequelize4.DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: { tableName: "company", schema: "sch_orgs" }, key: "comp_id" }
+      },
+      cslhTotalLimit: {
+        type: import_sequelize4.DataTypes.DECIMAL(15, 2),
+        allowNull: false
+      },
+      cslhUsedLimit: {
+        type: import_sequelize4.DataTypes.DECIMAL(15, 2),
+        allowNull: false
+      },
+      cslhAvailableLimit: {
+        type: import_sequelize4.DataTypes.DECIMAL(15, 2),
+        allowNull: true
+        // set() { throw new Error('cslhAvailableLimit is a read-only generated column'); }
+      },
+      cslhReferenceDate: {
+        type: import_sequelize4.DataTypes.DATEONLY,
+        allowNull: false
+      },
+      cslhCreatedAt: {
+        type: import_sequelize4.DataTypes.DATE,
+        defaultValue: import_sequelize4.DataTypes.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 import_sequelize5.Model {
+  init(sequelize) {
+    _CreditSource.init({
+      csrcId: {
+        type: import_sequelize5.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      csrcName: {
+        type: import_sequelize5.DataTypes.STRING,
+        allowNull: false
+      },
+      csrcType: {
+        type: import_sequelize5.DataTypes.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
+var import_sequelize6 = require("sequelize");
+var RateRules = class _RateRules extends import_sequelize6.Model {
+  init(sequelize) {
+    _RateRules.init({
+      raruId: {
+        type: import_sequelize6.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      raruVersion: {
+        type: import_sequelize6.DataTypes.INTEGER,
+        allowNull: true
+      },
+      raruRating: {
+        type: import_sequelize6.DataTypes.STRING(2),
+        allowNull: false
+      },
+      raruInHousePercentage: {
+        type: import_sequelize6.DataTypes.DECIMAL(5, 2),
+        allowNull: false
+      },
+      raruPartnerPercentage: {
+        type: import_sequelize6.DataTypes.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
+var import_sequelize9 = require("sequelize");
+
+// src/infra/models/schFinancial/SolicitationRate.ts
+var import_sequelize7 = require("sequelize");
+var SolicitationRate = class _SolicitationRate extends import_sequelize7.Model {
+  init(sequelize) {
+    _SolicitationRate.init({
+      soraId: {
+        type: import_sequelize7.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      soraRating: {
+        type: import_sequelize7.DataTypes.STRING(2),
+        allowNull: true
+      },
+      soraInHousePercentage: {
+        type: import_sequelize7.DataTypes.DECIMAL(5, 2),
+        allowNull: false
+      },
+      soraPartnerPercentage: {
+        type: import_sequelize7.DataTypes.DECIMAL(5, 2),
+        allowNull: false
+      },
+      soraInHouseAllocation: {
+        type: import_sequelize7.DataTypes.DECIMAL(15, 2),
+        allowNull: false
+      },
+      soraPartnerAllocation: {
+        type: import_sequelize7.DataTypes.DECIMAL(15, 2),
+        allowNull: false
+      },
+      soliId: {
+        type: import_sequelize7.DataTypes.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
+var import_sequelize8 = require("sequelize");
+var SolicitationNf = class _SolicitationNf extends import_sequelize8.Model {
+  init(sequelize) {
+    _SolicitationNf.init({
+      sonfId: {
+        type: import_sequelize8.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      sonfSumNf: {
+        type: import_sequelize8.DataTypes.DECIMAL(15, 2),
+        allowNull: true
+      },
+      sonfCompleted: {
+        type: import_sequelize8.DataTypes.BOOLEAN,
+        defaultValue: false,
+        allowNull: false
+      },
+      sonfRequestId: {
+        type: import_sequelize8.DataTypes.UUID,
+        allowNull: false
+      },
+      soliId: {
+        type: import_sequelize8.DataTypes.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 import_sequelize9.Model {
+  init(sequelize) {
+    _Solicitation.init({
+      soliId: {
+        type: import_sequelize9.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      soliRequestedLimit: {
+        type: import_sequelize9.DataTypes.NUMBER,
+        allowNull: false
+      },
+      soliCompleted: {
+        type: import_sequelize9.DataTypes.BOOLEAN,
+        defaultValue: false,
+        allowNull: false
+      },
+      persId: {
+        type: import_sequelize9.DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+          model: {
+            tableName: "person",
+            schema: "sch_orgs"
+          },
+          key: "pers_id"
+        }
+      },
+      compId: {
+        type: import_sequelize9.DataTypes.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
+var import_sequelize10 = require("sequelize");
+var SolicitationRevenue = class _SolicitationRevenue extends import_sequelize10.Model {
+  init(sequelize) {
+    _SolicitationRevenue.init({
+      soreId: {
+        type: import_sequelize10.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false
+      },
+      soreRevenue: {
+        type: import_sequelize10.DataTypes.DECIMAL(15, 2),
+        allowNull: true
+      },
+      soreCompleted: {
+        type: import_sequelize10.DataTypes.BOOLEAN,
+        defaultValue: false,
+        allowNull: false
+      },
+      soreRequestId: {
+        type: import_sequelize10.DataTypes.UUID,
+        allowNull: false
+      },
+      soliId: {
+        type: import_sequelize10.DataTypes.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
+var import_sequelize11 = require("sequelize");
+var Company = class _Company extends import_sequelize11.Model {
+  init(sequelize) {
+    _Company.init({
+      compId: {
+        type: import_sequelize11.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      compDes: {
+        type: import_sequelize11.DataTypes.STRING(60)
+      },
+      compCorporateName: {
+        type: import_sequelize11.DataTypes.STRING(300),
+        allowNull: false
+      },
+      compRegistration: {
+        type: import_sequelize11.DataTypes.STRING(20)
+      },
+      compUuid: {
+        type: import_sequelize11.DataTypes.UUID,
+        defaultValue: import_sequelize11.DataTypes.UUIDV4
+      },
+      compObs: {
+        type: import_sequelize11.DataTypes.STRING(4e3)
+      },
+      compRegisDate: {
+        type: import_sequelize11.DataTypes.DATE,
+        allowNull: false
+      },
+      compRegisUser: {
+        type: import_sequelize11.DataTypes.STRING(100),
+        allowNull: false
+      },
+      compErpRegisDate: {
+        type: import_sequelize11.DataTypes.DATE,
+        defaultValue: import_sequelize11.DataTypes.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
+var import_sequelize12 = require("sequelize");
+var Person = class _Person extends import_sequelize12.Model {
+  init(sequelize) {
+    _Person.init({
+      persId: {
+        type: import_sequelize12.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true
+      },
+      persName: {
+        type: import_sequelize12.DataTypes.STRING(100),
+        allowNull: false
+      },
+      persSocialName: {
+        type: import_sequelize12.DataTypes.STRING(100)
+      },
+      persFirstName: {
+        type: import_sequelize12.DataTypes.STRING(50)
+      },
+      persLastName: {
+        type: import_sequelize12.DataTypes.STRING(50)
+      },
+      persBirthDate: {
+        type: import_sequelize12.DataTypes.DATE
+      },
+      persMothersName: {
+        type: import_sequelize12.DataTypes.STRING(100)
+      },
+      persFathersName: {
+        type: import_sequelize12.DataTypes.STRING(100)
+      },
+      persIndSex: {
+        type: import_sequelize12.DataTypes.STRING(1)
+      },
+      persRegistration: {
+        type: import_sequelize12.DataTypes.STRING(20)
+      },
+      persUuid: {
+        type: import_sequelize12.DataTypes.UUID,
+        defaultValue: import_sequelize12.DataTypes.UUIDV4
+      },
+      mastCod: {
+        type: import_sequelize12.DataTypes.STRING(10)
+      },
+      gendCod: {
+        type: import_sequelize12.DataTypes.STRING(10)
+      },
+      persObs: {
+        type: import_sequelize12.DataTypes.STRING(4e3)
+      },
+      persRegisDate: {
+        type: import_sequelize12.DataTypes.DATE,
+        allowNull: false
+      },
+      persRegisUser: {
+        type: import_sequelize12.DataTypes.STRING(50),
+        allowNull: false
+      },
+      persErpRegisDate: {
+        type: import_sequelize12.DataTypes.DATE,
+        defaultValue: import_sequelize12.DataTypes.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
+var import_node_crypto = require("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: (0, import_node_crypto.randomUUID)(),
+    mastCod: "1",
+    persObs: "Usu\xE1rio administrador",
+    persRegisDate: /* @__PURE__ */ new Date(),
+    persRegisUser: "MONEYFARM",
+    persErpRegisDate: /* @__PURE__ */ new Date()
+  }
+];
+
+// src/utils/mocks/mockCompanies.ts
+var import_node_crypto2 = require("crypto");
+var mockCompanies = [
+  {
+    compId: 1,
+    compDes: "NUTRIEN MATRIZ",
+    compCorporateName: "NUTRIEN SOLUCOES AGRICOLAS LTDA",
+    compRegistration: "12.345.678/0001-00",
+    compUuid: (0, import_node_crypto2.randomUUID)(),
+    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: (0, import_node_crypto2.randomUUID)(),
+    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
+var import_node_crypto3 = require("crypto");
+var mockSolicitationRevenue = [
+  {
+    soreId: 1,
+    soreRevenue: 1500.5,
+    soreCompleted: true,
+    soreRequestId: (0, import_node_crypto3.randomUUID)(),
+    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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Company,
+  CreditAnalysisResult,
+  CreditSource,
+  CreditSourceLimitHistory,
+  Person,
+  RateRules,
+  Solicitation,
+  SolicitationNf,
+  SolicitationRate,
+  SolicitationRevenue,
+  closeMock,
+  initMock,
+  initModels
+});