@nutrien-br/liborgs 1.0.0

package/src/infra/models/schFinancial/__tests__/solicitation.spec.ts

@@ -0,0 +1,44 @@
+import { describe, it, afterEach, beforeEach, expect } from "vitest";
+import { initMock, closeMock } from '../../../../utils/initMock'
+import { Solicitation } from '../Solicitation'
+import { SolicitationRate } from "../SolicitationRate";
+import { CreditAnalysisResult, Person, SolicitationRevenue } from "../../initModels";
+import { SolicitationNf } from "../SolicitationNf";
+
+describe('Solicitation Model', () => {
+  beforeEach(async () => {
+    await initMock()
+  })
+
+  afterEach(async () => {
+    await closeMock()
+  })
+
+  describe('When findAll is called', () => {
+    it('should return a list of Solicitations', async () => {
+      const solicitations = await Solicitation.findAll()
+      expect(solicitations[0].soliId).toBe(1)
+    })
+  })
+
+  describe('When findOne is called', () => {
+    it('should return one with relationship', async () => {
+      const solicitation = await Solicitation.findOne({
+        where: { soliId: 1 },
+        include: [
+          { model: SolicitationRate, as: 'rates' },
+          { model: Person, as: 'person' },
+          { model: SolicitationRevenue, as: 'revenues' },
+          { model: SolicitationNf, as: 'nfs' },
+          { model: CreditAnalysisResult, as: 'analysisResults', include: ['creditSource'] }
+        ]
+      })
+      // console.log(solicitation?.toJSON())
+      expect(solicitation?.soliId).toBe(1)
+      expect(solicitation?.rates?.[0]?.soraRating).toBe('A');
+      expect(solicitation?.person?.persId).toBe(1)
+      expect(solicitation?.revenues?.[0].soreRevenue).toBe(1500.5)
+      expect(solicitation?.nfs?.[0].sonfSumNf).toBe(2500)
+    })
+  })
+})

package/src/infra/models/schOrgs/Company.ts

@@ -0,0 +1,75 @@
+import { CreationOptional, DataTypes, Model, NonAttribute, Sequelize } from "sequelize";
+import { CompanyEntity, CreateCompanyEntity } from "src/core/entity/schOrgs/CompanySchema";
+import { Solicitation, CreditSourceLimitHistory } from "../initModels";
+
+export class Company extends Model<CompanyEntity, CreateCompanyEntity> {
+  declare compId: CreationOptional<number>;
+  declare compDes: CreationOptional<string>;
+  declare compCorporateName: string;
+  declare compRegistration: CreationOptional<string>;
+  declare compUuid: CreationOptional<string>;
+  declare compObs: CreationOptional<string>;
+  declare compRegisDate: Date;
+  declare compRegisUser: string;
+  declare compErpRegisDate: CreationOptional<Date>;
+
+  declare solicitations?: NonAttribute<Solicitation[]>;
+  declare creditLimitHistories?: NonAttribute<CreditSourceLimitHistory[]>;
+
+  init(sequelize: Sequelize): void {
+    Company.init({
+      compId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+      },
+      compDes: {
+        type: DataTypes.STRING(60),
+      },
+      compCorporateName: {
+        type: DataTypes.STRING(300),
+        allowNull: false,
+      },
+      compRegistration: {
+        type: DataTypes.STRING(20),
+      },
+      compUuid: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+      },
+      compObs: {
+        type: DataTypes.STRING(4000),
+      },
+      compRegisDate: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+      compRegisUser: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      compErpRegisDate: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+      }
+    }, {
+      sequelize,
+      tableName: 'companies',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_orgs',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void {
+    Company.hasMany(Solicitation, {
+      foreignKey: 'compId',
+      as: 'solicitations'
+    });
+
+    Company.hasMany(CreditSourceLimitHistory, {
+      foreignKey: 'compId',
+      as: 'creditLimitHistories'
+    });
+  }
+}

package/src/infra/models/schOrgs/Person.ts

@@ -0,0 +1,107 @@
+import { CreationOptional, DataTypes, Model, NonAttribute, Sequelize } from "sequelize";
+import { CreatePersonEntity, PersonEntity } from "src/core/entity/schOrgs/PersonSchema";
+import { Solicitation, CreditSourceLimitHistory } from "../initModels";
+
+export class Person extends Model<PersonEntity, CreatePersonEntity> {
+  declare persId: CreationOptional<number>;
+  declare persName: string;
+  declare persSocialName: CreationOptional<string>;
+  declare persFirstName: CreationOptional<string>;
+  declare persLastName: CreationOptional<string>;
+  declare persBirthDate: CreationOptional<Date>;
+  declare persMothersName: CreationOptional<string>;
+  declare persFathersName: CreationOptional<string>;
+  declare persIndSex: string;
+  declare persRegistration: CreationOptional<string>;
+  declare persUuid: CreationOptional<string>;
+  declare mastCod: CreationOptional<string>;
+  declare gendCod: CreationOptional<string>;
+  declare persObs: CreationOptional<string>;
+  declare persRegisDate: Date;
+  declare persRegisUser: string;
+  declare persErpRegisDate: CreationOptional<Date>;
+
+  declare solicitations?: NonAttribute<Solicitation[]>;
+  declare creditLimitHistories?: NonAttribute<CreditSourceLimitHistory[]>;
+
+  init(sequelize: Sequelize): void {
+    Person.init({
+      persId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+      },
+      persName: {
+        type: DataTypes.STRING(100),
+        allowNull: false,
+      },
+      persSocialName: {
+        type: DataTypes.STRING(100),
+      },
+      persFirstName: {
+        type: DataTypes.STRING(50),
+      },
+      persLastName: {
+        type: DataTypes.STRING(50),
+      },
+      persBirthDate: {
+        type: DataTypes.DATE,
+      },
+      persMothersName: {
+        type: DataTypes.STRING(100),
+      },
+      persFathersName: {
+        type: DataTypes.STRING(100),
+      },
+      persIndSex: {
+        type: DataTypes.STRING(1),
+      },
+      persRegistration: {
+        type: DataTypes.STRING(20),
+      },
+      persUuid: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+      },
+      mastCod: {
+        type: DataTypes.STRING(10),
+      },
+      gendCod: {
+        type: DataTypes.STRING(10),
+      },
+      persObs: {
+        type: DataTypes.STRING(4000),
+      },
+      persRegisDate: {
+        type: DataTypes.DATE,
+        allowNull: false,
+      },
+      persRegisUser: {
+        type: DataTypes.STRING(50),
+        allowNull: false,
+      },
+      persErpRegisDate: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+      }
+    }, {
+      sequelize,
+      tableName: 'person',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_orgs',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void {
+    Person.hasMany(Solicitation, {
+      foreignKey: 'persId',
+      as: 'solicitations'
+    });
+
+    Person.hasMany(CreditSourceLimitHistory, {
+      foreignKey: 'persId',
+      as: 'creditLimitHistories'
+    });
+  }
+}

package/src/infra/models/schOrgs/__tests__/company.spec.ts

@@ -0,0 +1,20 @@
+import { describe, it, afterEach, beforeEach, expect } from "vitest";
+import { initMock, closeMock } from '../../../../utils/initMock'
+import { Company } from '../Company'
+
+describe('Company Model', () => {
+  beforeEach(async () => {
+    await initMock()
+  })
+
+  afterEach(async () => {
+    await closeMock()
+  })
+
+  describe('When findAll is called', () => {
+    it('should return a list of companies', async () => {
+      const people = await Company.findAll()
+      expect(people[0].compCorporateName).toBe('NUTRIEN SOLUCOES AGRICOLAS LTDA')
+    })
+  })
+})

package/src/infra/models/schOrgs/__tests__/person.spec.ts

@@ -0,0 +1,41 @@
+import { describe, it, afterEach, beforeEach, expect } from "vitest";
+import { initMock, closeMock } from '../../../../utils/initMock'
+import { Person } from '../Person'
+
+describe('Person Model', () => {
+  beforeEach(async () => {
+    await initMock()
+  })
+
+  afterEach(async () => {
+    await closeMock()
+  })
+
+  describe('When findAll is called', () => {
+    it('should return a list of People', async () => {
+      const people = await Person.findAll()
+      expect(people[0].persName).toBe('JOHNNY MOREIRA')
+    })
+  })
+
+  describe('When findOne is called', () => {
+    it('should get one Person', async () => {
+      const personData = await Person.findOne({
+        where: { persId: 1 },
+        include: [
+          {
+            association: 'solicitations',
+            include: ['rates', 'revenues', 'nfs']
+          },
+          {
+            association: 'creditLimitHistories',
+            limit: 10,
+            order: [['cslh_created_at', 'DESC']]
+          }
+        ]
+      });
+
+      expect(personData?.persId).toBe(1)
+    })
+  })
+})

package/src/utils/initMock.ts

@@ -0,0 +1,57 @@
+import Database from "src/infra/database/Database";
+import { Company, CreditAnalysisResult, CreditSource, CreditSourceLimitHistory, initModels, Person, RateRules, SolicitationNf, SolicitationRate, SolicitationRevenue } from "src/infra/models/initModels";
+import { mockCreditSources } from "./mocks/mockCreditSources";
+import { mockPerson } from "./mocks/mockPerson";
+import { mockCompanies } from "./mocks/mockCompanies";
+import { Solicitation } from "src/infra/models/schFinancial/Solicitation";
+import { mockSolicitation } from "./mocks/mockSolicitation";
+import { mockSolicitationRate } from "./mocks/mockSolicitationRate";
+import { mockRateRules } from "./mocks/mockRateRules";
+import { mockSolicitationRevenue } from "./mocks/mockSolicitationRevenue";
+import { mockSolicitationNf } from "./mocks/mockSolicitationNf";
+import { mockCreditSourceLimitHistory } from "./mocks/mockCreditSourceLimitHistory";
+import { mockCreditAnalysisResult } from "./mocks/mockCreditAnalysisResult";
+
+
+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 })
+
+    // orgs
+    await Person.bulkCreate(mockPerson)
+    await Company.bulkCreate(mockCompanies)
+
+    // financial
+    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 { initMock, closeMock };

package/src/utils/mocks/mockCompanies.ts

@@ -0,0 +1,27 @@
+import { randomUUID as uuidv4 } from "node:crypto";
+import { CompanyEntity } from "src/core/entity/schOrgs/CompanySchema";
+
+export const mockCompanies: CompanyEntity[] = [
+  {
+    compId: 1,
+    compDes: 'NUTRIEN MATRIZ',
+    compCorporateName: 'NUTRIEN SOLUCOES AGRICOLAS LTDA',
+    compRegistration: '12.345.678/0001-00',
+    compUuid: uuidv4(),
+    compObs: 'Unidade principal de processamento.',
+    compRegisDate: new Date(),
+    compRegisUser: 'admin_sys',
+    compErpRegisDate: new Date()
+  },
+  {
+    compId: 2,
+    compDes: 'FILIAL SUL',
+    compCorporateName: 'NUTRIEN AGRICULTURA DO SUL S.A.',
+    compRegistration: '98.765.432/0001-99',
+    compUuid: uuidv4(),
+    compObs: 'Responsável pela logística regional sul.',
+    compRegisDate: new Date(),
+    compRegisUser: 'johnny_dev',
+    compErpRegisDate: new Date()
+  }
+];

package/src/utils/mocks/mockCreditAnalysisResult.ts

@@ -0,0 +1,28 @@
+import { CreditAnalysisResultEntity } from "src/core/entity/schFinancial/CreditAnalysisResultSchema";
+
+export const mockCreditAnalysisResult: CreditAnalysisResultEntity[] = [
+  {
+    careId: 1,
+    careExternalId: 'FARM_001',
+    careRequestedLimit: 10000.00,
+    careApprovedLimit: 5000.00,
+    careDateSolicitation: new Date('2026-03-01T10:00:00Z'),
+    careResponseDate: 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: 5000.00,
+    careApprovedLimit: 0,
+    careDateSolicitation: new Date('2026-03-05T14:20:00Z'),
+    careResponseDate: new Date('2026-03-05T14:21:00Z'),
+    careResponse: true,
+    careRequestId: '7da7b810-9dad-11d1-80b4-00c04fd430c8',
+    soliId: 1,
+    csrcId: 2
+  }
+];

package/src/utils/mocks/mockCreditSourceLimitHistory.ts

@@ -0,0 +1,26 @@
+import { CreditSourceLimitHistoryEntity } from "src/core/entity/schFinancial/CreditSourceLimitHistorySchema";
+
+export const mockCreditSourceLimitHistory: CreditSourceLimitHistoryEntity[] = [
+  {
+    cslhId: 1,
+    csrcId: 4,
+    persId: 1,
+    compId: null,
+    cslhTotalLimit: 4000.00,
+    cslhUsedLimit: 500.00,
+    cslhAvailableLimit: 3500.00,
+    cslhReferenceDate: new Date('2026-03-01'),
+    cslhCreatedAt: new Date()
+  },
+  {
+    cslhId: 2,
+    csrcId: 2,
+    persId: 1,
+    compId: null,
+    cslhTotalLimit: 1000.00,
+    cslhUsedLimit: 500.00,
+    cslhAvailableLimit: 500.00,
+    cslhReferenceDate: new Date('2026-03-01'),
+    cslhCreatedAt: new Date()
+  }
+];

package/src/utils/mocks/mockCreditSources.ts

@@ -0,0 +1,24 @@
+import { CreditSourceEntity } from "src/core/entity/CreditSourceSchema";
+
+export const mockCreditSources: CreditSourceEntity[] = [
+  {
+    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'
+  },
+]

package/src/utils/mocks/mockPerson.ts

@@ -0,0 +1,23 @@
+import { PersonEntity } from "src/core/entity/schOrgs/PersonSchema";
+import { randomUUID as uuidv4 } from "node:crypto";
+
+export const mockPerson: PersonEntity[] = [
+  {
+    persId: 1,
+    persName: 'JOHNNY MOREIRA',
+    persSocialName: 'JOHNNY',
+    persFirstName: 'Johnny',
+    persLastName: 'Moreira',
+    persBirthDate: new Date('1991-01-18'),
+    persMothersName: 'TESTE MOREIRA',
+    persFathersName: 'TESTE2 MOREIRA',
+    persIndSex: 'M',
+    persRegistration: 'REG-001',
+    persUuid: uuidv4(),
+    mastCod: '1',
+    persObs: 'Usuário administrador',
+    persRegisDate: new Date(),
+    persRegisUser: 'MONEYFARM',
+    persErpRegisDate: new Date()
+  },
+];

package/src/utils/mocks/mockRateRules.ts

@@ -0,0 +1,18 @@
+import { RateRulesEntity } from "src/core/entity/schFinancial/RateRulesSchema";
+
+export const mockRateRules: RateRulesEntity[] = [
+  {
+    raruId: 1,
+    raruVersion: 1,
+    raruRating: 'A',
+    raruInHousePercentage: 90.00,
+    raruPartnerPercentage: 10.00,
+  },
+  {
+    raruId: 2,
+    raruVersion: 1,
+    raruRating: 'B',
+    raruInHousePercentage: 50.00,
+    raruPartnerPercentage: 50.00,
+  }
+];

package/src/utils/mocks/mockSolicitation.ts

@@ -0,0 +1,9 @@
+import { SolicitationEntity } from "src/core/entity/schFinancial/SolicitationSchema";
+
+export const mockSolicitation: SolicitationEntity[] = [{
+  soliId: 1,
+  soliRequestedLimit: 5000.00,
+  soliCompleted: false,
+  persId: 1,
+  compId: null,
+}]

package/src/utils/mocks/mockSolicitationNf.ts

@@ -0,0 +1,11 @@
+import { SolicitationNfEntity } from "src/core/entity/schFinancial/SolicitationNfSchema";
+
+export const mockSolicitationNf: SolicitationNfEntity[] = [
+  {
+    sonfId: 1,
+    sonfSumNf: 2500.00,
+    sonfCompleted: true,
+    sonfRequestId: '550e8400-e29b-41d4-a716-446655440000',
+    soliId: 1
+  }
+];

package/src/utils/mocks/mockSolicitationRate.ts

@@ -0,0 +1,11 @@
+import { SolicitationRateEntity } from "src/core/entity/schFinancial/SolicitationRateSchema";
+
+export const mockSolicitationRate: SolicitationRateEntity[] = [{
+  soraId: 1,
+  soraRating: "A",
+  soraInHousePercentage: 90.00,
+  soraPartnerPercentage: 10.00,
+  soraInHouseAllocation: 4500.00,
+  soraPartnerAllocation: 500.00,
+  soliId: 1,
+}];

package/src/utils/mocks/mockSolicitationRevenue.ts

@@ -0,0 +1,12 @@
+import { SolicitationRevenueEntity } from "src/core/entity/schFinancial/SolicitationRevenueSchema";
+import { randomUUID as uuidv4 } from 'node:crypto';
+
+export const mockSolicitationRevenue: SolicitationRevenueEntity[] = [
+  {
+    soreId: 1,
+    soreRevenue: 1500.50,
+    soreCompleted: true,
+    soreRequestId: uuidv4(),
+    soliId: 1
+  }
+];

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": [
+      "ES2020"
+    ],
+    "allowJs": true,
+    "outDir": "./lib",
+    "rootDir": "./src",
+    "removeComments": true,
+    "typeRoots": [
+      "./node_modules/@types",
+      "./src/@types"
+    ],
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "strict": true,
+    "sourceMap": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "baseUrl": ".",
+  },
+  "include": [
+    "src/**/*"
+  ],
+}

package/tsup.config.js

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  splitting: false,
+  format: ['cjs', 'esm'],
+  sourcemap: false,
+  target: 'ES2020',
+  clean: true,
+  dts: true,
+  outDir: 'lib',
+  minify: false,
+  shims: true,
+})

package/vitest.config.ts

@@ -0,0 +1,43 @@
+import { defineConfig, configDefaults } from "vitest/config";
+import tsconfigPaths from "vite-tsconfig-paths";
+import path from "path";
+
+console.log(">>>> CARREGANDO CONFIG DO VITEST <<<<");
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  test: {
+    ...configDefaults,
+    globals: true,
+    environment: 'node',
+    exclude: [
+      ...configDefaults.exclude,
+      'coverage/**',
+      'lib/**',
+    ],
+    include: ['src/**/*.spec.ts'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: [
+        'lib',
+        'src/infra/database/seeds/**',
+        'src/infra/database/migrations /**',
+        'src/infra/database/**',
+        'src/core/entity/**',
+        'tsup.config.js',
+        'vitest.config.mjs',
+        'src/index.ts'
+      ],
+      enabled: true,
+      thresholds: {
+        functions: 90
+      },
+    },
+  },
+  resolve: {
+    alias: {
+      "src": path.resolve(__dirname, "./src")
+    }
+  }
+});